"""

_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):

"""

self._parents = {}

# 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 its repr

return self._shorthand_name or repr(self)

def __getstate__(self):

# turn the dictionary with weak values into a normal dictionary

return {**self.__dict__,

'_parents': {k: v() for k, v in self._parents.items()}}

def __setstate__(self, data_dict):

self.__dict__ = data_dict

# turn the normal dictionary back into a dictionary with weak values

self._parents = {k: weakref.ref(v)

for k, v in self._parents.items() if v is not None}

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 list(self._parents.values()):

# Dereference the weak reference

parent = parent()

if parent is not None:

parent._invalidate_internal(

value=value, invalidating_node=self)

def set_children(self, *children):

"""

# Parents are stored as weak references, so that if the

# parents are destroyed, references from the children won't

# keep them alive.

for child in children:

child._parents[id(self)] = weakref.ref(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(map('{0[0]}={0[1]}'.format, props.items()))

fobj.write('%s [%s];\n' % (hash(root), props))

if hasattr(root, '_children'):

for child in root._children:

name = next((key for key, val in root.__dict__.items()

if val is child), '?')

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

if DEBUG:

def _check(points):

if isinstance(points, np.ma.MaskedArray):

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.]

@property

def x0(self):

"""

return self.get_points()[0, 0]

@property

def y0(self):

"""

return self.get_points()[0, 1]

@property

def x1(self):

"""

return self.get_points()[1, 0]

@property

def y1(self):

"""

return self.get_points()[1, 1]

@property

def p0(self):

"""

return self.get_points()[0]

@property

def p1(self):

"""

return self.get_points()[1]

@property

def xmin(self):

"""

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

@property

def ymin(self):

"""

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

@property

def xmax(self):

"""

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

@property

def ymax(self):

"""

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

@property

def min(self):

"""

return np.min(self.get_points(), axis=0)

@property

def max(self):

"""

return np.max(self.get_points(), axis=0)

@property

def intervalx(self):

"""

return self.get_points()[:, 0]

@property

def intervaly(self):

"""

return self.get_points()[:, 1]

@property

def width(self):

"""

points = self.get_points()

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

@property

def height(self):

"""

points = self.get_points()

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

@property

def size(self):

"""

points = self.get_points()

return points[1] - points[0]

@property

def bounds(self):

"""

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

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

@property

def extents(self):

"""

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

def get_points(self):

raise NotImplementedError

def containsx(self, x):

"""

x0, x1 = self.intervalx

return x0 <= x <= x1 or x0 >= x >= x1

def containsy(self, y):

"""

y0, y1 = self.intervaly

return y0 <= y <= y1 or y0 >= y >= y1

def contains(self, x, y):

"""

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

def overlaps(self, other):

"""

ax1, ay1, ax2, ay2 = self.extents

bx1, by1, bx2, by2 = other.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 ax1 <= bx2 and bx1 <= ax2 and ay1 <= by2 and by1 <= ay2

def fully_containsx(self, x):

"""

x0, x1 = self.intervalx

return x0 < x < x1 or x0 > x > x1

def fully_containsy(self, y):

"""

y0, y1 = self.intervaly

return y0 < y < y1 or y0 > y > y1

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.extents

bx1, by1, bx2, by2 = other.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 ax1 < bx2 and bx1 < ax2 and ay1 < by2 and by1 < ay2

def transformed(self, transform):

"""

pts = self.get_points()

ll, ul, lr = transform.transform(np.array([pts[0],

[pts[0, 0], pts[1, 1]], [pts[1, 0], pts[0, 1]]]))

return Bbox([ll, [lr[0], ul[1]]])

def inverse_transformed(self, transform):

"""

return self.transformed(transform.inverted())

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, str):

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):

"""

if box_aspect <= 0 or fig_aspect <= 0:

raise ValueError("'box_aspect' and 'fig_aspect' must be positive")

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):

"""

xf = [0, *args, 1]

x0, y0, x1, y1 = self.extents

w = x1 - x0

return [Bbox([[x0 + xf0 * w, y0], [x0 + xf1 * w, y1]])

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

def splity(self, *args):

"""

yf = [0, *args, 1]

x0, y0, x1, y1 = self.extents

h = y1 - y0

return [Bbox([[x0, y0 + yf0 * h], [x1, y0 + yf1 * h]])

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

def count_contains(self, vertices):

"""

if len(vertices) == 0:

return 0

vertices = np.asarray(vertices)

with np.errstate(invalid='ignore'):

return (((self.min < vertices) &

(vertices < self.max)).all(axis=1).sum())

def count_overlaps(self, bboxes):

"""

return count_bboxes_overlapping_bbox(

self, np.atleast_3d([np.array(x) for x in 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):

"""

if not len(bboxes):

raise ValueError("'bboxes' cannot be empty")

x0 = np.min([bbox.xmin for bbox in bboxes])

x1 = np.max([bbox.xmax for bbox in bboxes])

y0 = np.min([bbox.ymin for bbox in bboxes])

y1 = np.max([bbox.ymax for bbox in bboxes])

return Bbox([[x0, y0], [x1, y1]])

@staticmethod

def intersection(bbox1, bbox2):

"""

x0 = np.maximum(bbox1.xmin, bbox2.xmin)

x1 = np.minimum(bbox1.xmax, bbox2.xmax)

y0 = np.maximum(bbox1.ymin, bbox2.ymin)

y1 = np.minimum(bbox1.ymax, bbox2.ymax)

"""

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

"""

BboxBase.__init__(self, **kwargs)

points = np.asarray(points, float)

if points.shape != (2, 2):

raise ValueError('Bbox points must be of the form '

'"[[x0, y0], [x1, y1]]".')

self._points = points

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

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)

@staticmethod

def unit():

"""

return Bbox(np.array([[0.0, 0.0], [1.0, 1.0]], float))

@staticmethod

def null():

"""

return Bbox(np.array([[np.inf, np.inf], [-np.inf, -np.inf]], float))

@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=float).reshape(2, 2)

return Bbox(points)

def __format__(self, fmt):

return (

'Bbox(x0={0.x0:{1}}, y0={0.y0:{1}}, x1={0.x1:{1}}, y1={0.y1:{1}})'.

format(self, fmt))

def __str__(self):

return format(self, '')

def __repr__(self):

return 'Bbox([[{0.x0}, {0.y0}], [{0.x1}, {0.y1}]])'.format(self)

def ignore(self, value):

"""

self._ignore = value

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)

@BboxBase.x0.setter

def x0(self, val):

self._points[0, 0] = val

self.invalidate()

@BboxBase.y0.setter

def y0(self, val):

self._points[0, 1] = val

self.invalidate()

@BboxBase.x1.setter

def x1(self, val):

self._points[1, 0] = val

self.invalidate()

@BboxBase.y1.setter

def y1(self, val):

self._points[1, 1] = val

self.invalidate()

@BboxBase.p0.setter

def p0(self, val):

self._points[0] = val

self.invalidate()

@BboxBase.p1.setter

def p1(self, val):

self._points[1] = val

self.invalidate()

@BboxBase.intervalx.setter

def intervalx(self, interval):

self._points[:, 0] = interval

self.invalidate()

@BboxBase.intervaly.setter

def intervaly(self, interval):

self._points[:, 1] = interval

self.invalidate()

@BboxBase.bounds.setter

def bounds(self, bounds):

l, b, w, h = bounds

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

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

self._points = points

self.invalidate()

@property

def minpos(self):

return self._minpos

@property

def minposx(self):

return self._minpos[0]

@property

def minposy(self):

return self._minpos[1]

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