"""

_gid = 0

# Invalidation may affect only the affine part. If the

# invalidation was "affine-only", the _invalid member is set to

# INVALID_AFFINE_ONLY

INVALID_NON_AFFINE = 1

INVALID_AFFINE = 2

INVALID = INVALID_NON_AFFINE | INVALID_AFFINE

# Some metadata about the transform, used to determine whether an

# invalidation is affine-only

is_affine = False

is_bbox = False

pass_through = False

"""

def __init__(self, shorthand_name=None):

"""

# Parents are stored in a WeakValueDictionary, so that if the

# parents are deleted, references from the children won't keep

# them alive.

self._parents = WeakValueDictionary()

# TransformNodes start out as invalid until their values are

# computed for the first time.

self._invalid = 1

self._shorthand_name = shorthand_name or ''

if DEBUG:

def __str__(self):

# either just return the name of this TransformNode, or it's repr

return self._shorthand_name or repr(self)

def __getstate__(self):

d = self.__dict__.copy()

# turn the weakkey dictionary into a normal dictionary

d['_parents'] = dict(self._parents.iteritems())

return d

def __setstate__(self, data_dict):

self.__dict__ = data_dict

# turn the normal dictionary back into a WeakValueDictionary

self._parents = WeakValueDictionary(self._parents)

def __copy__(self, *args):

raise NotImplementedError(

"TransformNode instances can not be copied. " +

"Consider using frozen() instead.")

__deepcopy__ = __copy__

def invalidate(self):

"""

value = self.INVALID

if self.is_affine:

value = self.INVALID_AFFINE

return self._invalidate_internal(value, invalidating_node=self)

def _invalidate_internal(self, value, invalidating_node):

"""

# determine if this call will be an extension to the invalidation

# status. If not, then a shortcut means that we needn't invoke an

# invalidation up the transform stack as it will already have been

# invalidated.

# N.B This makes the invalidation sticky, once a transform has been

# invalidated as NON_AFFINE, then it will always be invalidated as

# NON_AFFINE even when triggered with a AFFINE_ONLY invalidation.

# In most cases this is not a problem (i.e. for interactive panning and

# zooming) and the only side effect will be on performance.

status_changed = self._invalid < value

if self.pass_through or status_changed:

self._invalid = value

for parent in self._parents.itervalues():

parent._invalidate_internal(value=value,

invalidating_node=self)

def set_children(self, *children):

"""

for child in children:

child._parents[id(self)] = self

if DEBUG:

_set_children = set_children

def set_children(self, *children):

self._set_children(*children)

self._children = children

set_children.__doc__ = _set_children.__doc__

def frozen(self):

"""

return self

if DEBUG:

def write_graphviz(self, fobj, highlight=[]):

"""

seen = set()

def recurse(root):

if root in seen:

return

seen.add(root)

props = {}

label = root.__class__.__name__

if root._invalid:

label = '[%s]' % label

if root in highlight:

props['style'] = 'bold'

props['shape'] = 'box'

props['label'] = '"%s"' % label

props = ' '.join(['%s=%s' % (key, val)

for key, val

in props.iteritems()])

fobj.write('%s [%s];\n' %

(hash(root), props))

if hasattr(root, '_children'):

for child in root._children:

name = '?'

for key, val in root.__dict__.iteritems():

if val is child:

name = key

break

fobj.write('"%s" -> "%s" [label="%s", fontsize=10];\n'

% (hash(root),

hash(child),

name))

recurse(child)

fobj.write("digraph G {\n")

recurse(self)

"""

is_bbox = True

is_affine = True

#* Redundant: Removed for performance

#

# def __init__(self):

# TransformNode.__init__(self)

if DEBUG:

def _check(points):

if ma.isMaskedArray(points):

warnings.warn("Bbox bounds are a masked array.")

points = np.asarray(points)

if (points[1, 0] - points[0, 0] == 0 or

points[1, 1] - points[0, 1] == 0):

warnings.warn("Singular Bbox.")

_check = staticmethod(_check)

def frozen(self):

return Bbox(self.get_points().copy())

frozen.__doc__ = TransformNode.__doc__

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

return self.get_points()

def is_unit(self):

"""

return list(self.get_points().flatten()) == [0., 0., 1., 1.]

def _get_x0(self):

return self.get_points()[0, 0]

x0 = property(_get_x0, None, None, """

less than :attr:`x1`. If you require that, use :attr:`xmin`.""")

def _get_y0(self):

return self.get_points()[0, 1]

y0 = property(_get_y0, None, None, """

less than :attr:`y1`. If you require that, use :attr:`ymin`.""")

def _get_x1(self):

return self.get_points()[1, 0]

x1 = property(_get_x1, None, None, """

greater than :attr:`x0`. If you require that, use :attr:`xmax`.""")

def _get_y1(self):

return self.get_points()[1, 1]

y1 = property(_get_y1, None, None, """

greater than :attr:`y0`. If you require that, use :attr:`ymax`.""")

def _get_p0(self):

return self.get_points()[0]

p0 = property(_get_p0, None, None, """

bottom-left corner. For that, use :attr:`min`.""")

def _get_p1(self):

return self.get_points()[1]

p1 = property(_get_p1, None, None, """

top-right corner. For that, use :attr:`max`.""")

def _get_xmin(self):

return min(self.get_points()[:, 0])

xmin = property(_get_xmin, None, None, """

(property) :attr:`xmin` is the left edge of the bounding box.""")

def _get_ymin(self):

return min(self.get_points()[:, 1])

ymin = property(_get_ymin, None, None, """

(property) :attr:`ymin` is the bottom edge of the bounding box.""")

def _get_xmax(self):

return max(self.get_points()[:, 0])

xmax = property(_get_xmax, None, None, """

(property) :attr:`xmax` is the right edge of the bounding box.""")

def _get_ymax(self):

return max(self.get_points()[:, 1])

ymax = property(_get_ymax, None, None, """

(property) :attr:`ymax` is the top edge of the bounding box.""")

def _get_min(self):

return [min(self.get_points()[:, 0]),

min(self.get_points()[:, 1])]

min = property(_get_min, None, None, """

box.""")

def _get_max(self):

return [max(self.get_points()[:, 0]),

max(self.get_points()[:, 1])]

max = property(_get_max, None, None, """

(property) :attr:`max` is the top-right corner of the bounding box.""")

def _get_intervalx(self):

return self.get_points()[:, 0]

intervalx = property(_get_intervalx, None, None, """

right.""")

def _get_intervaly(self):

return self.get_points()[:, 1]

intervaly = property(_get_intervaly, None, None, """

top.""")

def _get_width(self):

points = self.get_points()

return points[1, 0] - points[0, 0]

width = property(_get_width, None, None, """

:attr:`x1` < :attr:`x0`.""")

def _get_height(self):

points = self.get_points()

return points[1, 1] - points[0, 1]

height = property(_get_height, None, None, """

:attr:`y1` < :attr:`y0`.""")

def _get_size(self):

points = self.get_points()

return points[1] - points[0]

size = property(_get_size, None, None, """

in the same way as :attr:`width` and :attr:`height`.""")

def _get_bounds(self):

x0, y0, x1, y1 = self.get_points().flatten()

return (x0, y0, x1 - x0, y1 - y0)

bounds = property(_get_bounds, None, None, """

:attr:`height`).""")

def _get_extents(self):

return self.get_points().flatten().copy()

extents = property(_get_extents, None, None, """

:attr:`y1`).""")

def get_points(self):

return NotImplementedError()

def containsx(self, x):

"""

x0, x1 = self.intervalx

return ((x0 < x1

and (x >= x0 and x <= x1))

or (x >= x1 and x <= x0))

def containsy(self, y):

"""

y0, y1 = self.intervaly

return ((y0 < y1

and (y >= y0 and y <= y1))

or (y >= y1 and y <= y0))

def contains(self, x, y):

"""

return self.containsx(x) and self.containsy(y)

def overlaps(self, other):

"""

ax1, ay1, ax2, ay2 = self._get_extents()

bx1, by1, bx2, by2 = other._get_extents()

if ax2 < ax1:

ax2, ax1 = ax1, ax2

if ay2 < ay1:

ay2, ay1 = ay1, ay2

if bx2 < bx1:

bx2, bx1 = bx1, bx2

if by2 < by1:

by2, by1 = by1, by2

return not ((bx2 < ax1) or

(by2 < ay1) or

(bx1 > ax2) or

(by1 > ay2))

def fully_containsx(self, x):

"""

x0, x1 = self.intervalx

return ((x0 < x1

and (x > x0 and x < x1))

or (x > x1 and x < x0))

def fully_containsy(self, y):

"""

y0, y1 = self.intervaly

return ((y0 < y1

and (y > y0 and y < y1))

or (y > y1 and y < y0))

def fully_contains(self, x, y):

"""

return self.fully_containsx(x) \

and self.fully_containsy(y)

def fully_overlaps(self, other):

"""

ax1, ay1, ax2, ay2 = self._get_extents()

bx1, by1, bx2, by2 = other._get_extents()

if ax2 < ax1:

ax2, ax1 = ax1, ax2

if ay2 < ay1:

ay2, ay1 = ay1, ay2

if bx2 < bx1:

bx2, bx1 = bx1, bx2

if by2 < by1:

by2, by1 = by1, by2

return not ((bx2 <= ax1) or

(by2 <= ay1) or

(bx1 >= ax2) or

(by1 >= ay2))

def transformed(self, transform):

"""

return Bbox(transform.transform(self.get_points()))

def inverse_transformed(self, transform):

"""

return Bbox(transform.inverted().transform(self.get_points()))

coefs = {'C': (0.5, 0.5),

'SW': (0, 0),

'S': (0.5, 0),

'SE': (1.0, 0),

'E': (1.0, 0.5),

'NE': (1.0, 1.0),

'N': (0.5, 1.0),

'NW': (0, 1.0),

'W': (0, 0.5)}

def anchored(self, c, container=None):

"""

if container is None:

container = self

l, b, w, h = container.bounds

if isinstance(c, basestring):

cx, cy = self.coefs[c]

else:

cx, cy = c

L, B, W, H = self.bounds

return Bbox(self._points +

[(l + cx * (w - W)) - L,

(b + cy * (h - H)) - B])

def shrunk(self, mx, my):

"""

w, h = self.size

return Bbox([self._points[0],

self._points[0] + [mx * w, my * h]])

def shrunk_to_aspect(self, box_aspect, container=None, fig_aspect=1.0):

"""

assert box_aspect > 0 and fig_aspect > 0

if container is None:

container = self

w, h = container.size

H = w * box_aspect / fig_aspect

if H <= h:

W = w

else:

W = h * fig_aspect / box_aspect

H = h

return Bbox([self._points[0],

self._points[0] + (W, H)])

def splitx(self, *args):

"""

boxes = []

xf = [0] + list(args) + [1]

x0, y0, x1, y1 = self._get_extents()

w = x1 - x0

for xf0, xf1 in zip(xf[:-1], xf[1:]):

boxes.append(Bbox([[x0 + xf0 * w, y0], [x0 + xf1 * w, y1]]))

return boxes

def splity(self, *args):

"""

boxes = []

yf = [0] + list(args) + [1]

x0, y0, x1, y1 = self._get_extents()

h = y1 - y0

for yf0, yf1 in zip(yf[:-1], yf[1:]):

boxes.append(Bbox([[x0, y0 + yf0 * h], [x1, y0 + yf1 * h]]))

return boxes

def count_contains(self, vertices):

"""

if len(vertices) == 0:

return 0

vertices = np.asarray(vertices)

x0, y0, x1, y1 = self._get_extents()

dx0 = np.sign(vertices[:, 0] - x0)

dy0 = np.sign(vertices[:, 1] - y0)

dx1 = np.sign(vertices[:, 0] - x1)

dy1 = np.sign(vertices[:, 1] - y1)

inside = (abs(dx0 + dx1) + abs(dy0 + dy1)) <= 2

return np.sum(inside)

def count_overlaps(self, bboxes):

"""

return count_bboxes_overlapping_bbox(self, bboxes)

def expanded(self, sw, sh):

"""

width = self.width

height = self.height

deltaw = (sw * width - width) / 2.0

deltah = (sh * height - height) / 2.0

a = np.array([[-deltaw, -deltah], [deltaw, deltah]])

return Bbox(self._points + a)

def padded(self, p):

"""

points = self.get_points()

return Bbox(points + [[-p, -p], [p, p]])

def translated(self, tx, ty):

"""

return Bbox(self._points + (tx, ty))

def corners(self):

"""

l, b, r, t = self.get_points().flatten()

return np.array([[l, b], [l, t], [r, b], [r, t]])

def rotated(self, radians):

"""

corners = self.corners()

corners_rotated = Affine2D().rotate(radians).transform(corners)

bbox = Bbox.unit()

bbox.update_from_data_xy(corners_rotated, ignore=True)

return bbox

@staticmethod

def union(bboxes):

"""

assert(len(bboxes))

if len(bboxes) == 1:

return bboxes[0]

x0 = np.inf

y0 = np.inf

x1 = -np.inf

y1 = -np.inf

for bbox in bboxes:

points = bbox.get_points()

xs = points[:, 0]

ys = points[:, 1]

x0 = min(x0, np.min(xs))

y0 = min(y0, np.min(ys))

x1 = max(x1, np.max(xs))

y1 = max(y1, np.max(ys))

"""

def __init__(self, points, **kwargs):

"""

BboxBase.__init__(self, **kwargs)

self._points = np.asarray(points, np.float_)

self._minpos = np.array([0.0000001, 0.0000001])

self._ignore = True

# it is helpful in some contexts to know if the bbox is a

# default or has been mutated; we store the orig points to

# support the mutated methods

self._points_orig = self._points.copy()

if DEBUG:

___init__ = __init__

def __init__(self, points, **kwargs):

self._check(points)

self.___init__(points, **kwargs)

def invalidate(self):

self._check(self._points)

TransformNode.invalidate(self)

_unit_values = np.array([[0.0, 0.0], [1.0, 1.0]], np.float_)

@staticmethod

def unit():

"""

return Bbox(Bbox._unit_values.copy())

@staticmethod

def from_bounds(x0, y0, width, height):

"""

return Bbox.from_extents(x0, y0, x0 + width, y0 + height)

@staticmethod

def from_extents(*args):

"""

points = np.array(args, dtype=np.float_).reshape(2, 2)

return Bbox(points)

def __repr__(self):

return 'Bbox(%r)' % repr(self._points)

def ignore(self, value):

"""

self._ignore = value

def update_from_data(self, x, y, ignore=None):

"""

warnings.warn(

"update_from_data requires a memory copy -- please replace with "

"update_from_data_xy")

xy = np.hstack((x.reshape((len(x), 1)), y.reshape((len(y), 1))))

return self.update_from_data_xy(xy, ignore)

def update_from_path(self, path, ignore=None, updatex=True, updatey=True):

"""

if ignore is None:

ignore = self._ignore

if path.vertices.size == 0:

return

points, minpos, changed = update_path_extents(

path, None, self._points, self._minpos, ignore)

if changed:

self.invalidate()

if updatex:

self._points[:, 0] = points[:, 0]

self._minpos[0] = minpos[0]

if updatey:

self._points[:, 1] = points[:, 1]

self._minpos[1] = minpos[1]

def update_from_data_xy(self, xy, ignore=None, updatex=True, updatey=True):

"""

if len(xy) == 0:

return

path = Path(xy)

self.update_from_path(path, ignore=ignore,

updatex=updatex, updatey=updatey)

def _set_x0(self, val):

self._points[0, 0] = val

self.invalidate()

x0 = property(BboxBase._get_x0, _set_x0)

def _set_y0(self, val):

self._points[0, 1] = val

self.invalidate()

y0 = property(BboxBase._get_y0, _set_y0)

def _set_x1(self, val):

self._points[1, 0] = val

self.invalidate()

x1 = property(BboxBase._get_x1, _set_x1)

def _set_y1(self, val):

self._points[1, 1] = val

self.invalidate()

y1 = property(BboxBase._get_y1, _set_y1)

def _set_p0(self, val):

self._points[0] = val

self.invalidate()

p0 = property(BboxBase._get_p0, _set_p0)

def _set_p1(self, val):

self._points[1] = val

self.invalidate()

p1 = property(BboxBase._get_p1, _set_p1)

def _set_intervalx(self, interval):

self._points[:, 0] = interval

self.invalidate()

intervalx = property(BboxBase._get_intervalx, _set_intervalx)

def _set_intervaly(self, interval):

self._points[:, 1] = interval

self.invalidate()

intervaly = property(BboxBase._get_intervaly, _set_intervaly)

def _set_bounds(self, bounds):

l, b, w, h = bounds

points = np.array([[l, b], [l + w, b + h]], np.float_)

if np.any(self._points != points):

self._points = points

self.invalidate()

bounds = property(BboxBase._get_bounds, _set_bounds)

def _get_minpos(self):

return self._minpos

minpos = property(_get_minpos)

def _get_minposx(self):

return self._minpos[0]

minposx = property(_get_minposx)

def _get_minposy(self):

return self._minpos[1]

minposy = property(_get_minposy)

def get_points(self):

"""

self._invalid = 0

return self._points

def set_points(self, points):

"""

if np.any(self._points != points):

self._points = points

self.invalidate()

def set(self, other):

"""

if np.any(self._points != other.get_points()):

self._points = other.get_points()

self.invalidate()

def mutated(self):

'return whether the bbox has changed since init'

return self.mutatedx() or self.mutatedy()

def mutatedx(self):

'return whether the x-limits have changed since init'

return (self._points[0, 0] != self._points_orig[0, 0] or

self._points[1, 0] != self._points_orig[1, 0])

def mutatedy(self):

'return whether the y-limits have changed since init'

return (self._points[0, 1] != self._points_orig[0, 1] or