Comment dessinez-vous des polygones transparents avec Python?

Je suis à l'aide de PIL (Python Imaging Library). Je voudrais attirer l'transparent polygones. Il semble que le fait de spécifier une couleur de fond qui comprend alpha niveau ne fonctionne pas. Leurs solutions de contournement?

Si elle ne peut pas être fait à l'aide de PIL, je suis prêt à utiliser quelque chose d'autre.

Si il n'y a plus qu'une solution, alors que les performances devraient être pris en compte. Le dessin doit être aussi rapide que possible.

source d'informationauteur carrier

34

C'est pour Oreiller, une plus maintenu fourche de PIL. http://pillow.readthedocs.org/

Si vous voulez dessiner des polygones qui sont transparentes, les uns par rapport aux autres, l'Image de base doit être de type RVB, pas RGBA, et la ImageDraw doit être de type LED. Exemple:
```
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')
```
Cela attirera deux triangles qui se chevauchent avec leurs deux couleurs de mélange. Beaucoup plus rapide que d'avoir à en composite de plusieurs "couches" pour chaque polygone.
6

Ce que j'ai eu à le faire lors de l'utilisation de la LIP à dessiner des images transparentes est de créer un calque de couleur, l'opacité de la couche avec le polygone dessiné sur elle, et du compositing avec la couche de base de la manière suivante:
```
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)
```
Lors de l'utilisation de l'Image.Mélange j'ai eu des problèmes avec d'étranges décrivant des comportements sur la polygones.

Le seul problème avec cette approche est que le rendement est catastrophique lors de l'élaboration d'un grand nombre de taille raisonnable, des polygones. Beaucoup plus rapide solution serait quelque chose comme "manuellement" le polygone sur un tableau numpy représentation de l'image.
2

Je suis en utilisant le caire + pycairo pour cela, et il fonctionne bien.
Et vous pouvez partager des données d'image entre le DIP et le caire, à l'aide de python tampon d'interface, si il y a opération de paiement tenant lieu d'indemnité qui ne peut être fait au caire.
2

PIL de l'Image module fournit un mélange de méthode.

Créer une seconde image de la même taille que votre première, avec un arrière-plan noir. Dessinez votre polygone (avec couleur). Puis l'appel de l'Image.mélange de passage les deux images et un alpha. Elle retourne une troisième image, qui devrait avoir un effet semi-transparent polygone.

Je n'ai pas mesuré les performances (hey, je n'ai même pas essayé!) donc, je ne peux me prononcer sur sa pertinence. Je vous suggère de travailler sur votre budget de performances, puis à mesurer pour voir si elle est assez rapide à vos fins.

De ce que j'ai trouvé, il ne peut pas être fait directement avec PIL. Voici une solution avec PyCairo. Le caire est également utilisé par Mozilla, GTX+, Mono, Inkscape, et WebKit, donc je pense qu'il est sûr à utiliser dans les conditions de l'avenir. Il peut également être fait avec aggdraw, une option à ajouter pour PIL. Voir mon énumérés à la source pour plus de détails. Une version de Python 2.7.3 est utilisé.

Source: http://livingcode.org/2008/12/14/drawing-with-opacity.1.html

Helper fichier: 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

Fichier principal: 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()

-1

J'ai eu à dessiner un à l'extérieur du polygone avec un contour, et soustraire intérieur des polygones (une opération courante dans le SIG). Fonctionne comme un charme utilisation de la couleur (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

Vous devez vous connecter pour publier un commentaire.