def __init__(self, r, g=None, b=None, a=None):

""" Stores channel values for a color.

try:

is_nodebox_color = isinstance(r, PDColor)

except:

is_nodebox_color = False

# One parameter, a Color object.

if isinstance(r, Color) or is_nodebox_color:

r, g, b, a = r.r, r.g, r.b, r.a

if isinstance(r, (list, tuple)):

if len(r) == 2: r, g = r

elif len(r) == 3: r, g, b = r

elif len(r) == 4: r, g, b, a = r

# No alpha means an opaque color.

if a == None:

a = 1.0

# One parameter, a grayscale value.

if g == None and b == None:

g, b = r, r

# Two parameters, gray value and alpha.

if b == None:

a, g, b = g, r, r

if isinstance(r, int): r = float(r) / 255

if isinstance(g, int): g = float(g) / 255

if isinstance(b, int): b = float(b) / 255

if isinstance(a, int): a = float(a) / 255

self.r = max(0.0, min(r, 1.0))

self.g = max(0.0, min(g, 1.0))

self.b = max(0.0, min(b, 1.0))

self.a = max(0.0, min(a, 1.0))

def __repr__(self):

return "%s(%s, %s, %s, %s)" % (self.__class__.__name__,

def __init__(self, path):

""" A wrapper for acceptable bezier paths.

self.path = None

# Path from BezierPath.

try:

b = isinstance(path, Bezier)

if b: self.path = path._nsBezierPath

except:

pass

# Path from list of points.

if isinstance(path, list):

p = NSBezierPath.bezierPath()

first = True

for i in range(len(path)/2):

x = path[i*2]

y = path[i*2+1]

if first == True:

p.moveToPoint_((x, y))

first = False

else:

p.lineToPoint_((x, y))

self.path = p

# Path from NSBezierPath.

if isinstance(path, NSBezierPath):

self.path = path

def is_path(self):

def __init__(self, w, h, renderer):

self.renderer = renderer

self.layers = Layers()

self._parent = None

self.w = w

self.h = h

def copy(self):

canvas = Canvas(self.w, self.h, self.renderer)

canvas._parent = self._parent

for layer in self.layers:

canvas.layers.append(layer.copy())

return canvas

def layer(self, *args, **kwargs):

""" Adds a new layer to the canvas.

x = y = w = h = None

if "x" in kwargs: x = kwargs["x"]

if "y" in kwargs: y = kwargs["y"]

if "w" in kwargs: w = kwargs["w"]

if "h" in kwargs: h = kwargs["h"]

name = ""

type = ""

if "name" in kwargs: name = kwargs["name"]

if "type" in kwargs: type = kwargs["type"]

# Creates a new Layer object in the Canvas.

def _add_layer(data, type, x=None, y=None, w=None, h=None, s=Point(1.0,1.0)):

if x == None: x = self.w/2

if y == None: y = self.h/2

if w == None: w = self.w

if h == None: h = self.h

layer = Layer(self, type, data, x, y, w, h, name)

layer._scale = s

self.layers.append(layer)

return layer

# File: layer(str)

# An image file is a pathname for which the renderer can calculate a size.

# ------------------------------------------------------------------------

try:

w0, h0 = self.renderer.imagesize(args[0])

type = LAYER_FILE

s = Point(1.0, 1.0)

if w != None: s.x = float(w) / w0

if h != None: s.y = float(h) / h0

w, h = w0, h0

return _add_layer(args[0], type, x, y, w, h, s)

except:

pass

# Gradient: layer(clr1, clr2, type="linear", spread=0.0)

# A gradient are two color objects and an optional spread parameter.

# ------------------------------------------------------------------------

try:

r, g, b, a = args[0].r, args[0].g, args[0].b, args[0].a

r, g, b, a = args[1].r, args[1].g, args[1].b, args[1].a

if type == "radial":

type = LAYER_RADIAL_GRADIENT

if "spread" not in kwargs \

or kwargs["spread"] == None:

kwargs["spread"] = 0.0

return _add_layer((args[0], args[1], float(kwargs["spread"])), type, x, y, w, h)

else:

type = LAYER_LINEAR_GRADIENT

return _add_layer((args[0], args[1]), type, x, y, w, h)

except:

pass

# Fill color: layer(clr)

# A fill is a single color object with r, g, b and a properties.

# ------------------------------------------------------------------------

try:

r, g, b, a = args[0].r, args[0].g, args[0].b, args[0].a

type = LAYER_FILL

return _add_layer(args[0], type, x, y, w, h)

except:

pass

# Layer: layer(layer)

# A Layer copied from another canvas.

# ------------------------------------------------------------------------

try:

c, b, f = args[0].canvas, args[0].blendmode, args[0].filters

layer = args[0].copy()

layer.canvas = self

self.layers.append(layer)

return layer

except:

pass

# Canvas: layer(canvas)

# A Canvas is identified by w, h and layers properties.

# ------------------------------------------------------------------------

try:

w0, h0, n = args[0].w, args[0].h, len(args[0].layers)

if args[0] == self: raise CanvasInCanvasRecursionError

type = LAYER_LAYERS

if w == None: w = args[0].w

if h == None: h = args[0].h

return _add_layer(args[0], type, x, y, w, h)

except:

pass

# Path:

# layer(path, background=None, fill=None, stroke=None, strokewidth=None)

# path can be: BezierPath, NSBezierPath, [x1, y1, x2, y2, ...]

# A valid path can be used to initialize a coreimage.Path object.

# ------------------------------------------------------------------------

try:

path = Path(args[0]).path

(dx,dy), (w0,h0) = path.bounds()

type = LAYER_PATH

if x == None: x = self.w/2

if y == None: y = self.h/2

#x += dx

#y += dy

default_fill = Color(0.0)

if self._parent != None and self._parent.mask == self:

default_fill = Color(1.0)

colors = [

kwargs.get("background", Transparent()),

kwargs.get("fill", default_fill),

kwargs.get("stroke", Transparent())

]

for i in range(len(colors)):

clr = colors[i]

if isinstance(clr, int): clr = float(clr)

if isinstance(clr, (list, tuple)):

clr = [float(v) for v in clr]

colors[i] = Color(clr)

background, fill, stroke = colors

strokewidth = kwargs.get("strokewidth", 1.0)

if stroke.a == 0:

strokewidth = 0.0

strokewidth = max(0, strokewidth)

if w == None: w = w0 + strokewidth + PATH_PADDING*2

if h == None: h = h0 + strokewidth + PATH_PADDING*2

return _add_layer((path, background, fill, stroke, strokewidth), type, x, y, w, h)

except:

pass

# Pixels:

# layer([clr1, clr2, clr3, ...], w, h)

# Pixels are passed as a list of color objects and w and h parameters.

# ------------------------------------------------------------------------

try:

r, g, b, a = args[0][0].r, args[0][0].g, args[0][0].b, args[0][0].a

if len(args) >= 2: w = args[1]

if len(args) == 3: h = args[2]

w *= 1

h *= 1

type = LAYER_PIXELS

return _add_layer((args[0], w, h), type, x, y, w, h)

except:

pass

# Core Image CIImage object:

# layer(layer.render())

# layer(canvas.render())

# A CIImage object has an extent() method.

# ----------------------------------------------------------------------

try:

(x0, y0), (w0, h0) = args[0].extent()

type = LAYER_CIIMAGEOBJECT

return _add_layer(args[0], type, x, y, w0, h0)

except:

pass

# TIFF data extracted from Cocoa NSImage object, or byte data:

# layer(NSImage)

# layer(open(img).read())

# layer(movieframe)

# An image byte string can be passed to _ctx.Image() to create an NSImage.

# An NSImage or a movieframe has size() and TIFFRepresentation methods.

# ------------------------------------------------------------------------

try:

try:

img = PDImage(None, data=args[0])

img = img._nsImage

except:

img = args[0]

w0, h0 = img.size()

img = img.TIFFRepresentation()

type = LAYER_NSIMAGEDATA

s = Point(1.0,1.0)

if w != None: s.x = float(w) / w0

if h != None: s.y = float(h) / h0

w, h = w0, h0

return _add_layer(img, type, x, y, w, h, s)

except:

pass

append = layer

def layer_fill(self, clr=None, x=None, y=None, w=None, h=None, name=""):

if clr == None:

clr = Color(0.0)

if self._parent != None and self._parent.mask == self:

clr = Color(1.0)

return self.layer(clr, x=x, y=y, w=w, h=h, name=name)

def layer_gradient(self, clr1=None, clr2=None, type="linear", spread=None, x=None, y=None, w=None, h=None, name=""):

if clr1 == None: clr1 = Color(1.0)

if clr2 == None: clr2 = Color(0.0)

return self.layer(clr1, clr2, type=type, spread=spread, x=x, y=y, w=w, h=h, name=name)

def layer_linear_gradient(self, clr1=None, clr2=None, x=None, y=None, w=None, h=None, name=""):

return self.layer_gradient(clr1, clr2, x=x, y=y, w=w, h=h, name=name)

def layer_radial_gradient(self, clr1=None, clr2=None, spread=0.0, x=None, y=None, w=None, h=None, name=""):

return self.layer_gradient(clr1, clr2, type="radial", spread=spread, x=x, y=y, w=w, h=h, name=name)

def layer_group(self, canvas, x=None, y=None, w=None, h=None, name=""):

return self.layer(canvas, x=x, y=y, w=w, h=h)

def layer_path(self, path, fill=None, background=None, stroke=None, strokewidth=None, x=None, y=None, w=None, h=None, name=""):

return self.layer(path, fill=fill, background=background, stroke=stroke, strokewidth=strokewidth, x=x, y=y, w=w, h=h, name=name)

def layer_pixels(self, colors, w, h, x=None, y=None, name=""):

return self.layer(colors, w, h, x=x, y=y, name=name)

def layer_bytes(self, data, x=None, y=None, w=None, h=None, name=""):

return self.layer(data, x=x, y=y, w=w, h=h, name=name)

fill = add_fill = layer_fill

gradient = add_gradient = layer_gradient

linear = add_linear = layer_linear_gradient

radial = add_radial = layer_radial_gradient

group = add_group = layer_group

path = add_path = layer_path

bytes = add_bytes = layer_bytes

pixels = add_pixels = layer_pixels

def find(self, index):

""" Returns the layer with the given name or index.

return self.layers[index]

def __getitem__(self, index): return self.find(index)

def __getslice__(self, i, j): return self.layers.__getslice__(i, j)

def __getattr__(self, index): return self.layers.__getattr__(index, cls="Canvas")

def __iter__(self): return self.layers.__iter__()

def __len__(self): return len(self.layers)

def _render_shadows(self, layers=[]):

""" A software layer dropshadow renderer.

l = Layers()

if len(layers) == 0:

layers = self.layers

for layer in layers:

if layer.has_shadow:

dx, dy, alpha, blur = layer._shadow

shadow = layer.copy()

shadow.adjust(-1, 0, 0)

shadow.x += dx

shadow.y += dy

shadow.opacity *= alpha

shadow.blur += blur

shadow.blendmode = "multiply"

shadow._shadow = None

l.append(shadow)

l.append(layer)

return l

def render(self, layers=[], fast=True):

""" Returned a rendered version of the canvas.

if not self.renderer.can_render_shadows:

layers = self._render_shadows(layers)

return self.renderer.merge(self, layers, fast)

flatten = render

def draw(self, x=0, y=0, layers=[], fast=False, helper=False):

""" Draws the flattened canvas to NodeBox.

if not self.renderer.can_render_shadows:

layers = self._render_shadows(layers)

self.renderer.draw(self, x, y, layers, fast, helper)

def export(self, name, type=FILE_PNG, compression=None, cmyk=False, layers=[]):

""" Exports the flattened canvas to .jpg, .gif, .png or .tif.

if name.endswith(".jpg"): name = name[:-4]; type = FILE_JPEG

if name.endswith(".gif"): name = name[:-4]; type = FILE_GIF

if name.endswith(".png"): name = name[:-4]; type = FILE_PNG

if name.endswith(".tif"): name = name[:-4]; type = FILE_TIFF

if not self.renderer.can_render_shadows:

layers = self._render_shadows(self.layers)

self.renderer.export(self, name+type, type, compression, cmyk, layers)

def export_gif(self, name):

self.renderer.export(self, splitext(name)[0]+".gif", FILE_GIF)

def export_png(self, name):

self.renderer.export(self, splitext(name)[0]+".png", FILE_PNG)

def export_jpg(self, name, quality=1.0):

self.renderer.export(self, splitext(name)[0]+".jpg", FILE_JPEG, quality)

def export_tif(self, name, lzw=False, cmyk=False):

from plotdevice.gfx.geometry import Dimension

if not w: w = _ctx.WIDTH

if not h: h = _ctx.HEIGHT

if not renderer: renderer = CoreImageRenderer(quality)

if not isinstance(w, (int, float, Dimension)):

try:

w0, h0 = renderer.imagesize(w)

canvas = Canvas(w0, h0, renderer)

layer = canvas.layer(w)

return canvas

except:

pass

else:

def __getitem__(self, index):

""" Extends the canvas.layers[] list so it indexes layers names.

# Layer by name, recursive.

if isinstance(index, str):

for layer in self:

if layer.name == index:

return layer

if isinstance(layer.data, Canvas):

try: return layer.data.layers[index]

except:

pass

if isinstance(layer.mask, Canvas):

try: return layer.data.layers[index]

except:

pass

raise KeyError(index)

# Layer by index number.

if isinstance(index, int):

return list.__getitem__(self, index)

raise IndexError("list index out of range")

def __getattr__(self, name, cls="Layers"):

""" You can also do: canvas.layers.layer_name (without recursion).

for layer in self:

if layer.name == name:

return layer

# This method is also called from the Canvas object,

# In that case, the cls parameter will be "Canvas".

def __init__(self, canvas, type, data, x, y, w, h, name=""):

self.canvas = canvas

self.type = type

self.data = data

self.name = name

self.hidden = False

# A layer can be a Canvas.

self.layers = None

if self.type == LAYER_LAYERS:

self.layers = self.data.layers

# Transformations.

self.x = x

self.y = y

self._w = w

self._h = h

self._crop = None

self._origin = Point(0.5, 0.5)

self._flip = (False, False)

self._distort = [Point(0.0, 0.0) for i in range(4)]

self._scale = Point(1.0, 1.0)

self.rotation = 0

# Compositing.

self._opacity = 1.0

self.blendmode = BLEND_NORMAL

# A mask is a grayscale canvas of layers owned by this layer,

# and of the same width and height.

# An alpha mask hides parts of the masked layer

# where the mask is darker.

self.mask = Canvas(self._w, self._h, self.canvas.renderer)

self.mask._parent = self

# Adjustments.

self._brightness = 0.0

self._contrast = 1.0

self._saturation = 1.0

self.inverted = False

# Shadow.

self._shadow = None

# Filters.

self.blur = 0.0

self.sharpness = 0.0

self.filters = []

self._filters_first = True

def _is_file(self) : return (self.type == LAYER_FILE)

def _is_fill(self) : return (self.type == LAYER_FILL)

def _is_gradient(self) : return (self.type == LAYER_LINEAR_GRADIENT or

self.type == LAYER_RADIAL_GRADIENT)

def _is_linear_gradient(self) : return (self.type == LAYER_RADIAL_GRADIENT)

def _is_radial_gradient(self) : return (self.type == LAYER_LINEAR_GRADIENT)

def _is_path(self) : return (self.type == LAYER_PATH)

def _is_pixels(self) : return (self.type == LAYER_PIXELS)

def _has_layers(self) : return (self.type == LAYER_LAYERS)

def _has_shadow(self) : return (self._shadow != None)

def _is_mask(self) : return (self.canvas._parent != None and

self.canvas._parent.mask == self.canvas)

is_file = property(_is_file)

is_fill = property(_is_fill)

is_gradient = property(_is_gradient)

is_linear_gradient = property(_is_linear_gradient)

is_radial_gradient = property(_is_radial_gradient)

is_linear = property(_is_linear_gradient)

is_radial = property(_is_radial_gradient)

is_path = property(_is_path)

is_pixels = property(_is_pixels)

is_group = property(_has_layers)

is_canvas = property(_has_layers)

has_layers = property(_has_layers)

has_shadow = property(_has_shadow)

is_mask = property(_is_mask)

def _index(self):

""" Returns this layer's index in the canvas.layers[].

if self.canvas == None:

return None

return self.canvas.layers.index(self)

index = property(_index)

def arrange(self, where):

""" Moves the layer either forwards or backwards.

i = self._index()

j = None

if where == ARRANGE_UP : j = i+1

if where == ARRANGE_DOWN : j = i-1

if where == ARRANGE_FRONT : j = len(self.canvas.layers)

if where == ARRANGE_BACK : j = 0

if j != None:

del self.canvas.layers[i]

j = max(0, min(j, len(self.canvas.layers)))

self.canvas.layers.insert(j, self)

return j

def arrange_up(self) : return self.arrange(ARRANGE_UP)

def arrange_down(self) : return self.arrange(ARRANGE_DOWN)

def arrange_front(self) : return self.arrange(ARRANGE_FRONT)

def arrange_back(self) : return self.arrange(ARRANGE_BACK)

up, down = arrange_up, arrange_down

to_front, to_back = arrange_front, arrange_back

def hide(self):

""" Hides the layer from the output.

self.hidden = True

def copy(self):

""" Creates a copy of the layer.

# Determine the type of layer and copy image data.

if self.type == LAYER_FILE:

data = self.data

if self.type == LAYER_FILL:

data = Color(self.data)

if self.type == LAYER_LINEAR_GRADIENT:

data = (Color(self.data[0]), Color(self.data[1]))

if self.type == LAYER_RADIAL_GRADIENT:

data = (Color(self.data[0]), Color(self.data[1]), self.data[2])

if self.type == LAYER_LAYERS:

data = self.data.copy()

if self.type == LAYER_PATH:

data = (self.data[0].copy(), Color(self.data[1]), Color(self.data[2]), Color(self.data[3]), self.data[4])

if self.type == LAYER_PIXELS:

data = self.data

if self.type == LAYER_CIIMAGEOBJECT:

data = self.data

if self.type == LAYER_NSIMAGEDATA:

data = self.data

layer = Layer(self.canvas, self.type, data, self.x, self.y, self._w, self._h)

# Transformations.

layer._origin = Point(self._origin.x, self._origin.y)

layer._flip = self._flip

layer._distort = [Point(self._distort[i].x, self._distort[i].y) for i in range(4)]

layer._scale = Point(self._scale.x, self._scale.y)

layer.rotation = self.rotation

# Compositing.

layer._opacity = self._opacity

layer.blendmode = self.blendmode

# Alpha mask.

layer.mask = self.mask.copy()

layer.mask._parent = layer

# Adjustments.

layer._brightness = self._brightness

layer._contrast = self._contrast

layer._saturation = self._saturation

layer.inverted = self.inverted

# Shadow.

layer._shadow = self._shadow

# Filters.

layer.blur = self.blur

layer.sharpness = self.sharpness

layer.filters = [(filter, params) for filter, params in self.filters]

return layer

def duplicate(self):

""" Adds a copy of the layer on top of this one.

i = self._index()

layer = self.copy()

self.canvas.layers.insert(i+1, layer)

return layer

def origin(self, x=None, y=None):

""" Sets the transformation origin point.

def f(s):

if s == ORIGIN_LEFT : return 0.0

if s == ORIGIN_TOP : return 0.0

if s == ORIGIN_RIGHT : return 1.0

if s == ORIGIN_BOTTOM : return 1.0

if s == ORIGIN_CENTER : return 0.5

return s

x = f(x)

y = f(y)

if y == None: y = x

if isinstance(x, int): x = float(x) / self._w

if isinstance(y, int): y = float(y) / self._h

if isinstance(x, float): self._origin.x = x

if isinstance(y, float): self._origin.y = y

return (self._origin.x, self._origin.y)

def origin_top_left(self) : return self.origin(ORIGIN_LEFT , ORIGIN_TOP)

def origin_top_right(self) : return self.origin(ORIGIN_RIGHT , ORIGIN_TOP)

def origin_top_center(self) : return self.origin(ORIGIN_CENTER , ORIGIN_TOP)

def origin_bottom_left(self) : return self.origin(ORIGIN_LEFT , ORIGIN_BOTTOM)

def origin_bottom_right(self) : return self.origin(ORIGIN_RIGHT , ORIGIN_BOTTOM)

def origin_bottom_center(self) : return self.origin(ORIGIN_CENTER , ORIGIN_BOTTOM)

def origin_left_center(self) : return self.origin(ORIGIN_LEFT , ORIGIN_CENTER)

def origin_right_center(self) : return self.origin(ORIGIN_RIGHT , ORIGIN_CENTER)

def origin_center(self) : return self.origin(ORIGIN_CENTER , ORIGIN_CENTER)

def bounds(self):

""" Returns the left, top, right, bottom in pixels.

if isinstance(self.canvas._parent, Layer):

return self.canvas._parent.bounds()

x, y, w, h = self.x, self.y, self._w, self._h

# Crop.

if self._crop != None:

w = min(w, self._crop[2])

h = min(h, self._crop[3])

# Scale.

w = w * self._scale.x

h = h * self._scale.y

# Origin.

ox = x + self._origin.x * w

oy = y + self._origin.y * h

# Rotate and distort.

l = t = float( INFINITY)

r = b = float(-INFINITY)

corners = [(x, y), (x+w, y), (x+w, y+h), (x, y+h)]

for i in range(len(corners)):

dx, dy = corners[i]

dx += self._distort[i].x * w

dy += self._distort[i].y * h

a = self.rotation - angle(ox, oy, dx, dy)

d = distance(ox, oy, dx, dy)

dx = x + d * cos(radians(a))

dy = y + d * sin(radians(a))

l = min(l, dx)

r = max(r, dx)

t = min(t, dy)

b = max(b, dy)

return (l, t, r, b)

def size(self):

""" Returns the layer's size.

l, t, r, b = self.bounds()

return (r-l, b-t)

def _get_w(self): return self.size()[0]

def _get_h(self): return self.size()[1]

w = width = property(_get_w)

h = height = property(_get_h)

def center(self):

""" Puts the origin point of the layer at the center of the canvas.

self.x = self.canvas.w/2

self.y = self.canvas.h/2

def translate(self, x, y):

""" Places the layer at the given position.

if isinstance(x, float): x = x * self.canvas.w

if isinstance(y, float): y = y * self.canvas.h

self.x = x

self.y = y

def scale(self, w=None, h=None):

""" Scales the layer horizontally and vertically.