पाइथन के साथ पारदर्शी बहुभुज कैसे आकर्षित करते हैं?

Question

मैं पीआईएल (पायथन इमेजिंग लाइब्रेरी) का उपयोग कर रहा हूं। मैं पारदर्शी बहुभुज आकर्षित करना चाहता हूं। ऐसा लगता है कि एक भरने वाले रंग को निर्दिष्ट करना जिसमें अल्फा स्तर शामिल नहीं है। क्या उनके कामकाज हैं?

यदि यह पीआईएल का उपयोग करके नहीं किया जा सकता है तो मैं कुछ और उपयोग करने के लिए तैयार हूं।

यदि एक से अधिक समाधान हैं, तो प्रदर्शन में फ़ैक्टर किया जाना चाहिए। ड्राइंग जितनी जल्दी संभव हो सके।

Answer 1

मैं इसके लिए cairo + pycairo का उपयोग कर रहा हूं, और यह अच्छी तरह से काम करता है। और पाइथन बफर इंटरफ़ेस का उपयोग करके आप पीआईएल और कैरो के बीच छवि डेटा साझा कर सकते हैं, यदि पायल में ऑपरेशन हो तो कैरो में नहीं किया जा सकता है।

Answer 2

पीआईएल का छवि मॉड्यूल एक मिश्रण विधि प्रदान करता है।

एक काला छवि के साथ, अपनी पहली छवि के समान आकार को दूसरी छवि बनाएं। अपने बहुभुज को (पूर्ण रंग के साथ) बनाएं। फिर Image.blend को दो छवियों और अल्फा स्तर को पारित करें। यह एक तीसरी छवि देता है, जिसमें उस पर अर्ध-पारदर्शी बहुभुज होना चाहिए।

मैंने प्रदर्शन को माप नहीं लिया है (हे, मैंने कोशिश भी नहीं की है!) इसलिए मैं इसकी उपयुक्तता पर टिप्पणी नहीं कर सकता। मेरा सुझाव है कि आप अपना प्रदर्शन बजट तैयार करें, और उसके बाद यह मापें कि यह आपके उद्देश्यों के लिए पर्याप्त तेज़ है या नहीं।

Answer 3

क्या मैं जब जनहित याचिका का उपयोग कर पारदर्शी छवियों आकर्षित करने के लिए ऐसा करने के लिए मिला है एक रंग परत, बहुभुज उस पर तैयार के साथ एक अस्पष्टता परत बनाने, और उन्हें आधार परत के रूप में इतनी के साथ सम्मिश्रित:

color_layer = Image.new('RGBA', base_layer.size, fill_rgb) 
alpha_mask = Image.new('L', base_layer.size, 0) 
alpha_mask_draw = ImageDraw.Draw(alpha_mask) 
alpha_mask_draw.polygon(self.outline, fill=fill_alpha) 
base_layer = Image.composite(color_layer, base_layer, alpha_mask) 

Image.Blend का उपयोग करते समय मुझे खींचे गए बहुभुजों पर अजीब रूपरेखा व्यवहार के साथ समस्याएं थीं।

इस दृष्टिकोण के साथ एकमात्र मुद्दा यह है कि बड़ी संख्या में उचित आकार वाले बहुभुजों को चित्रित करते समय प्रदर्शन अबाध होता है। एक बहुत तेज समाधान छवि के एक numpy सरणी प्रतिनिधित्व पर बहुभुज चित्रण "मैन्युअल" की तरह कुछ होगा।

Answer 4

मुझे एक रूपरेखा के साथ बाहरी बहुभुज खींचना था, और आंतरिक बहुभुज (जीआईएस में एक आम ऑपरेशन) घटा देना था। रंग (255,255,255,0) का उपयोग कर एक आकर्षण की तरह काम करता है।

image = Image.new("RGBA", (100,100)) 
drawing = ImageDraw.Draw(i) 
for index, p in enumerate(polygons): 
    if index == 0: 
     options = { 'fill': "#AA5544", 
        'outline': "#993300"} 
    else: 
     options = {'fill': (255,255,255,0)} 
    drawing.polygon(p, **options) 

buf= StringIO.StringIO() 
i.save(buf, format= 'PNG') 
# do something with buf 

Answer 5

जो मैंने पाया है उसे सीधे पीआईएल के साथ नहीं किया जा सकता है। PyCairo के साथ एक समाधान यहाँ है। काहिरा का उपयोग मोज़िला, जीटीएक्स +, मोनो, इंकस्केप और वेबकिट द्वारा भी किया जाता है, इसलिए मुझे लगता है कि भविष्य के समर्थन के संदर्भ में इसका उपयोग सुरक्षित है। यह पीजीआई के लिए वैकल्पिक ऐड-ऑन, एग्ग्राव के साथ भी किया जा सकता है। अधिक जानकारी के लिए मेरे सूचीबद्ध स्रोत देखें। पायथन संस्करण 2.7.3 का उपयोग किया जाता है।

स्रोत: http://livingcode.org/2008/12/14/drawing-with-opacity.1.html

हेल्पर फ़ाइल: random_polys_util.py

MIN_ALPHA = 50 
    MAX_ALPHA = 100 

    WIDTH = 500 
    HEIGHT = 250 

    # 
    # Utilities 
    # 
    def hex2tuple(hex_color): 
     return tuple([int(hex_color[i:i+2], 16) for i in range(1,9,2)]) 

    def tuple2hex(tuple_color): 
     return "#%0.2X%0.2X%0.2X%0.2X" % tuple_color 

    def ints2floats(tuple_color): 
     return tuple([c/255.0 for c in tuple_color]) 

    def inc_point(p, dp): 
     return (p[0] + dp[0]) % WIDTH, (p[1] + dp[1]) % HEIGHT 

    def inc_triangle(t, dt): 
     return tuple([inc_point(t[i], dt[i]) for i in range(3)]) 

    def inc_color(c, dc): 
     new_c = [(c[i] + dc[i]) % 256 for i in range(3)] 
     new_a = (c[3] + dc[3]) % MAX_ALPHA 
     if new_a < MIN_ALPHA: new_a += MIN_ALPHA 
     new_c.append(new_a) 
     return tuple(new_c) 

    def draw_all(draw_fn): 
     triangle = start_t 
     color = start_c 
     for i in range(50): 
      triangle = inc_triangle(triangle, dt) 
      color = inc_color(color, dc) 
      draw_fn(triangle, color) 

    # 
    # Starting and incrementing values 
    # 
    start_c = hex2tuple('E6A20644') 
    start_t = (127, 132), (341, 171), (434, 125) 
    dt = (107, 23), (47, 73), (13, 97) 
    dc = 61, 113, 109, 41 

मुख्य फ़ाइल: random_polys.py

from random_polys_util import * 

def cairo_poly(pts, clr): 
    ctx.set_source_rgba(*ints2floats(clr)) 
    ctx.move_to(*pts[-1]) 
    for pt in pts: 
     ctx.line_to(*pt) 
    ctx.close_path() 
    ctx.fill() 

def cairo_main(): 
    # Setup Cairo 
    import cairo 
    global ctx 
    surface = cairo.ImageSurface(cairo.FORMAT_ARGB32, WIDTH, HEIGHT) 
    ctx = cairo.Context(surface) 
    # fill background white 
    cairo_poly(((0,0),(WIDTH,0),(WIDTH,HEIGHT),(0,HEIGHT)),(255,255,255,255)) 
    draw_all(cairo_poly) 
    surface.write_to_png('cairo_example.png') 

def main(): 
    cairo_main() 

if __name__ == "__main__": 
    main() 

Answer 6

यह तकिया, जनहित याचिका की एक और अधिक बनाए रखा कांटा के लिए है। http://pillow.readthedocs.org/

यदि आप पारदर्शी वाले बहुभुज को आकर्षित करना चाहते हैं, तो एक दूसरे के सापेक्ष, मूल छवि को आरजीबी नहीं, आरजीबीए नहीं, और ImageDraw प्रकार आरजीबीए होना चाहिए।उदाहरण:

from PIL import Image, ImageDraw 

img = Image.new('RGB', (100, 100)) 
drw = ImageDraw.Draw(img, 'RGBA') 
drw.polygon([(50, 0), (100, 100), (0, 100)], (255, 0, 0, 125)) 
drw.polygon([(50,100), (100, 0), (0, 0)], (0, 255, 0, 125)) 
del drw 

img.save('out.png', 'PNG') 

इससे दो त्रिकोणों को उनके दो रंगों के मिश्रण के साथ ओवरलैपिंग मिल जाएगी। प्रत्येक बहुभुज के लिए कई 'परतों' को मिश्रित करने से यह बहुत तेज़ है।