Pillow/PIL/ImageDraw.py

383 lines
13 KiB
Python
Raw Normal View History

2010-07-31 06:52:47 +04:00
#
# The Python Imaging Library
# $Id$
#
# drawing interface operations
#
# History:
# 1996-04-13 fl Created (experimental)
# 1996-08-07 fl Filled polygons, ellipses.
# 1996-08-13 fl Added text support
# 1998-06-28 fl Handle I and F images
# 1998-12-29 fl Added arc; use arc primitive to draw ellipses
# 1999-01-10 fl Added shape stuff (experimental)
# 1999-02-06 fl Added bitmap support
# 1999-02-11 fl Changed all primitives to take options
# 1999-02-20 fl Fixed backwards compatibility
# 2000-10-12 fl Copy on write, when necessary
# 2001-02-18 fl Use default ink for bitmap/text also in fill mode
# 2002-10-24 fl Added support for CSS-style color strings
# 2002-12-10 fl Added experimental support for RGBA-on-RGB drawing
# 2002-12-11 fl Refactored low-level drawing API (work in progress)
# 2004-08-26 fl Made Draw() a factory function, added getdraw() support
# 2004-09-04 fl Added width support to line primitive
# 2004-09-10 fl Added font mode handling
# 2006-06-19 fl Added font bearing support (getmask2)
#
# Copyright (c) 1997-2006 by Secret Labs AB
# Copyright (c) 1996-2006 by Fredrik Lundh
#
# See the README file for information on usage and redistribution.
#
import numbers
2015-12-09 08:55:33 +03:00
import warnings
2013-03-07 20:20:28 +04:00
from PIL import Image, ImageColor
2013-06-30 15:04:42 +04:00
from PIL._util import isStringType
2010-07-31 06:52:47 +04:00
2016-05-24 10:36:14 +03:00
"""
A simple 2D drawing interface for PIL images.
<p>
Application code should use the <b>Draw</b> factory, instead of
directly.
"""
2010-07-31 06:52:47 +04:00
2015-12-10 01:35:35 +03:00
2015-05-26 17:07:21 +03:00
class ImageDraw(object):
2010-07-31 06:52:47 +04:00
def __init__(self, im, mode=None):
2016-05-24 10:36:14 +03:00
"""
Create a drawing instance.
:param im: The image to draw in.
:param mode: Optional mode to use for color values. For RGB
2016-05-24 10:36:14 +03:00
images, this argument can be RGB or RGBA (to blend the
drawing into the image). For all other modes, this argument
must be the same as the image mode. If omitted, the mode
defaults to the mode of the image.
"""
2010-07-31 06:52:47 +04:00
im.load()
if im.readonly:
2014-08-26 17:47:10 +04:00
im._copy() # make it writeable
2010-07-31 06:52:47 +04:00
blend = 0
if mode is None:
mode = im.mode
if mode != im.mode:
if mode == "RGBA" and im.mode == "RGB":
blend = 1
else:
raise ValueError("mode mismatch")
if mode == "P":
self.palette = im.palette
else:
self.palette = None
self.im = im.im
self.draw = Image.core.draw(self.im, blend)
self.mode = mode
if mode in ("I", "F"):
self.ink = self.draw.draw_ink(1, mode)
else:
self.ink = self.draw.draw_ink(-1, mode)
if mode in ("1", "P", "I", "F"):
# FIXME: fix Fill2 to properly support matte for I+F images
self.fontmode = "1"
else:
2014-08-26 17:47:10 +04:00
self.fontmode = "L" # aliasing is okay for other modes
2010-07-31 06:52:47 +04:00
self.fill = 0
self.font = None
def setink(self, ink):
raise NotImplementedError("setink() has been removed. " +
"Please use keyword arguments instead.")
def setfill(self, onoff):
raise NotImplementedError("setfill() has been removed. " +
"Please use keyword arguments instead.")
2010-07-31 06:52:47 +04:00
def setfont(self, font):
2015-12-09 08:55:33 +03:00
warnings.warn("setfont() is deprecated. " +
"Please set the attribute directly instead.")
2010-07-31 06:52:47 +04:00
# compatibility
self.font = font
def getfont(self):
2016-05-24 10:36:14 +03:00
"""Get the current default font."""
2010-07-31 06:52:47 +04:00
if not self.font:
# FIXME: should add a font repository
2013-03-07 20:20:28 +04:00
from PIL import ImageFont
2010-07-31 06:52:47 +04:00
self.font = ImageFont.load_default()
return self.font
def _getink(self, ink, fill=None):
if ink is None and fill is None:
if self.fill:
fill = self.ink
else:
ink = self.ink
else:
if ink is not None:
2013-06-30 15:04:42 +04:00
if isStringType(ink):
2010-07-31 06:52:47 +04:00
ink = ImageColor.getcolor(ink, self.mode)
if self.palette and not isinstance(ink, numbers.Number):
2010-07-31 06:52:47 +04:00
ink = self.palette.getcolor(ink)
ink = self.draw.draw_ink(ink, self.mode)
if fill is not None:
2013-06-30 15:04:42 +04:00
if isStringType(fill):
2010-07-31 06:52:47 +04:00
fill = ImageColor.getcolor(fill, self.mode)
if self.palette and not isinstance(fill, numbers.Number):
2010-07-31 06:52:47 +04:00
fill = self.palette.getcolor(fill)
fill = self.draw.draw_ink(fill, self.mode)
return ink, fill
def arc(self, xy, start, end, fill=None):
2016-05-24 10:36:14 +03:00
"""Draw an arc."""
2010-07-31 06:52:47 +04:00
ink, fill = self._getink(fill)
if ink is not None:
self.draw.draw_arc(xy, start, end, ink)
def bitmap(self, xy, bitmap, fill=None):
2016-05-24 10:36:14 +03:00
"""Draw a bitmap."""
2010-07-31 06:52:47 +04:00
bitmap.load()
ink, fill = self._getink(fill)
if ink is None:
ink = fill
if ink is not None:
self.draw.draw_bitmap(xy, bitmap.im, ink)
def chord(self, xy, start, end, fill=None, outline=None):
2016-05-24 10:36:14 +03:00
"""Draw a chord."""
2010-07-31 06:52:47 +04:00
ink, fill = self._getink(outline, fill)
if fill is not None:
self.draw.draw_chord(xy, start, end, fill, 1)
if ink is not None:
self.draw.draw_chord(xy, start, end, ink, 0)
def ellipse(self, xy, fill=None, outline=None):
2016-05-24 10:36:14 +03:00
"""Draw an ellipse."""
2010-07-31 06:52:47 +04:00
ink, fill = self._getink(outline, fill)
if fill is not None:
self.draw.draw_ellipse(xy, fill, 1)
if ink is not None:
self.draw.draw_ellipse(xy, ink, 0)
def line(self, xy, fill=None, width=0):
2016-05-24 10:36:14 +03:00
"""Draw a line, or a connected sequence of line segments."""
2010-07-31 06:52:47 +04:00
ink, fill = self._getink(fill)
if ink is not None:
self.draw.draw_lines(xy, ink, width)
def shape(self, shape, fill=None, outline=None):
2016-05-24 10:36:14 +03:00
"""(Experimental) Draw a shape."""
2010-07-31 06:52:47 +04:00
shape.close()
ink, fill = self._getink(outline, fill)
if fill is not None:
self.draw.draw_outline(shape, fill, 1)
if ink is not None:
self.draw.draw_outline(shape, ink, 0)
def pieslice(self, xy, start, end, fill=None, outline=None):
2016-05-24 10:36:14 +03:00
"""Draw a pieslice."""
2010-07-31 06:52:47 +04:00
ink, fill = self._getink(outline, fill)
if fill is not None:
self.draw.draw_pieslice(xy, start, end, fill, 1)
if ink is not None:
self.draw.draw_pieslice(xy, start, end, ink, 0)
def point(self, xy, fill=None):
2016-05-24 10:36:14 +03:00
"""Draw one or more individual pixels."""
2010-07-31 06:52:47 +04:00
ink, fill = self._getink(fill)
if ink is not None:
self.draw.draw_points(xy, ink)
def polygon(self, xy, fill=None, outline=None):
2016-05-24 10:36:14 +03:00
"""Draw a polygon."""
2010-07-31 06:52:47 +04:00
ink, fill = self._getink(outline, fill)
if fill is not None:
self.draw.draw_polygon(xy, fill, 1)
if ink is not None:
self.draw.draw_polygon(xy, ink, 0)
def rectangle(self, xy, fill=None, outline=None):
2016-05-24 10:36:14 +03:00
"""Draw a rectangle."""
2010-07-31 06:52:47 +04:00
ink, fill = self._getink(outline, fill)
if fill is not None:
self.draw.draw_rectangle(xy, fill, 1)
if ink is not None:
self.draw.draw_rectangle(xy, ink, 0)
def _multiline_check(self, text):
2016-05-24 10:36:14 +03:00
"""Draw text."""
split_character = "\n" if isinstance(text, str) else b"\n"
return split_character in text
def _multiline_split(self, text):
split_character = "\n" if isinstance(text, str) else b"\n"
return text.split(split_character)
2016-05-24 10:36:14 +03:00
def text(self, xy, text, fill=None, font=None, anchor=None,
*args, **kwargs):
if self._multiline_check(text):
2016-05-24 10:36:14 +03:00
return self.multiline_text(xy, text, fill, font, anchor,
*args, **kwargs)
2010-07-31 06:52:47 +04:00
ink, fill = self._getink(fill)
if font is None:
font = self.getfont()
if ink is None:
ink = fill
if ink is not None:
try:
mask, offset = font.getmask2(text, self.fontmode)
xy = xy[0] + offset[0], xy[1] + offset[1]
except AttributeError:
try:
mask = font.getmask(text, self.fontmode)
except TypeError:
mask = font.getmask(text)
self.draw.draw_bitmap(xy, mask, ink)
def multiline_text(self, xy, text, fill=None, font=None, anchor=None,
2015-12-06 19:31:33 +03:00
spacing=4, align="left"):
2015-11-18 18:02:16 +03:00
widths = []
max_width = 0
lines = self._multiline_split(text)
2015-11-18 18:02:16 +03:00
line_spacing = self.textsize('A', font=font)[1] + spacing
for line in lines:
line_width, line_height = self.textsize(line, font)
widths.append(line_width)
max_width = max(max_width, line_width)
left, top = xy
for idx, line in enumerate(lines):
if align == "left":
pass # left = x
elif align == "center":
left += (max_width - widths[idx]) / 2.0
elif align == "right":
left += (max_width - widths[idx])
else:
assert False, 'align must be "left", "center" or "right"'
self.text((left, top), line, fill, font, anchor)
2015-11-18 18:02:16 +03:00
top += line_spacing
left = xy[0]
def textsize(self, text, font=None, *args, **kwargs):
2016-05-24 10:36:14 +03:00
"""Get the size of a given string, in pixels."""
if self._multiline_check(text):
return self.multiline_textsize(text, font, *args, **kwargs)
2010-07-31 06:52:47 +04:00
if font is None:
font = self.getfont()
return font.getsize(text)
def multiline_textsize(self, text, font=None, spacing=4):
max_width = 0
lines = self._multiline_split(text)
2015-11-18 18:02:16 +03:00
line_spacing = self.textsize('A', font=font)[1] + spacing
for line in lines:
line_width, line_height = self.textsize(line, font)
max_width = max(max_width, line_width)
2015-11-18 18:02:16 +03:00
return max_width, len(lines)*line_spacing
2014-08-26 17:47:10 +04:00
2010-07-31 06:52:47 +04:00
def Draw(im, mode=None):
2016-05-24 10:36:14 +03:00
"""
A simple 2D drawing interface for PIL images.
:param im: The image to draw in.
:param mode: Optional mode to use for color values. For RGB
2016-05-24 10:36:14 +03:00
images, this argument can be RGB or RGBA (to blend the
drawing into the image). For all other modes, this argument
must be the same as the image mode. If omitted, the mode
defaults to the mode of the image.
"""
2010-07-31 06:52:47 +04:00
try:
return im.getdraw(mode)
except AttributeError:
return ImageDraw(im, mode)
# experimental access to the outline API
try:
Outline = Image.core.outline
2015-05-27 02:15:45 +03:00
except AttributeError:
2010-07-31 06:52:47 +04:00
Outline = None
2014-08-26 17:47:10 +04:00
2010-07-31 06:52:47 +04:00
def getdraw(im=None, hints=None):
2016-05-24 10:36:14 +03:00
"""
(Experimental) A more advanced 2D drawing interface for PIL images,
based on the WCK interface.
:param im: The image to draw in.
:param hints: An optional list of hints.
:returns: A (drawing context, drawing resource factory) tuple.
2016-05-24 10:36:14 +03:00
"""
2010-07-31 06:52:47 +04:00
# FIXME: this needs more work!
# FIXME: come up with a better 'hints' scheme.
handler = None
if not hints or "nicest" in hints:
try:
from PIL import _imagingagg as handler
2010-07-31 06:52:47 +04:00
except ImportError:
pass
if handler is None:
from PIL import ImageDraw2 as handler
2010-07-31 06:52:47 +04:00
if im:
im = handler.Draw(im)
return im, handler
2014-08-26 17:47:10 +04:00
2010-07-31 06:52:47 +04:00
def floodfill(image, xy, value, border=None):
2016-05-24 10:36:14 +03:00
"""
(experimental) Fills a bounded region with a given color.
:param image: Target image.
:param xy: Seed position (a 2-item coordinate tuple).
:param value: Fill color.
:param border: Optional border value. If given, the region consists of
2016-05-24 10:36:14 +03:00
pixels with a color different from the border color. If not given,
the region consists of pixels having the same color as the seed
pixel.
"""
2010-07-31 06:52:47 +04:00
# based on an implementation by Eric S. Raymond
pixel = image.load()
x, y = xy
try:
background = pixel[x, y]
if background == value:
2014-08-26 17:47:10 +04:00
return # seed point already has fill color
2010-07-31 06:52:47 +04:00
pixel[x, y] = value
except IndexError:
2014-08-26 17:47:10 +04:00
return # seed point outside image
2010-07-31 06:52:47 +04:00
edge = [(x, y)]
if border is None:
while edge:
newedge = []
for (x, y) in edge:
for (s, t) in ((x+1, y), (x-1, y), (x, y+1), (x, y-1)):
try:
p = pixel[s, t]
except IndexError:
pass
else:
if p == background:
pixel[s, t] = value
newedge.append((s, t))
edge = newedge
else:
while edge:
newedge = []
for (x, y) in edge:
for (s, t) in ((x+1, y), (x-1, y), (x, y+1), (x, y-1)):
try:
p = pixel[s, t]
except IndexError:
pass
else:
if p != value and p != border:
pixel[s, t] = value
newedge.append((s, t))
edge = newedge