"""

indent = functools.partial(textwrap.indent, prefix=" " * 4)

def strrepr(x): return repr(x) if isinstance(x, str) else str(x)

return lambda self: (

type(self).__name__ + "("

+ ",".join([*(indent("\n" + strrepr(getattr(self, arg)))

for arg in args),

*(indent("\n" + k + "=" + strrepr(getattr(self, arg)))

for k, arg in kwargs.items())])

"""

# 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

# The extra lambda is to provide a callback to remove dead

# weakrefs from the dictionary when garbage collection is done.

self._parents = {

k: weakref.ref(v, lambda _, pop=self._parents.pop, k=k: pop(k))

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

def __copy__(self):

other = copy.copy(super())

# If `c = a + b; a1 = copy(a)`, then modifications to `a1` do not

# propagate back to `c`, i.e. we need to clear the parents of `a1`.

other._parents = {}

# If `c = a + b; c1 = copy(c)`, then modifications to `a` also need to

# be propagated to `c1`.

for key, val in vars(self).items():

if isinstance(val, TransformNode) and id(self) in val._parents:

other.set_children(val) # val == getattr(other, key)

return other

def __deepcopy__(self, memo):

# We could deepcopy the entire transform tree, but nothing except

# `self` is accessible publicly, so we may as well just freeze `self`.

other = self.frozen()

if other is not self:

return other

# Some classes implement frozen() as returning self, which is not

# acceptable for deepcopying, so we need to handle them separately.

other = copy.deepcopy(super(), memo)

# If `c = a + b; a1 = copy(a)`, then modifications to `a1` do not

# propagate back to `c`, i.e. we need to clear the parents of `a1`.

other._parents = {}

# If `c = a + b; c1 = copy(c)`, this creates a separate tree

# (`c1 = a1 + b1`) so nothing needs to be done.

return other

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:

# Use weak references so this dictionary won't keep obsolete nodes

# alive; the callback deletes the dictionary entry. This is a

# performance improvement over using WeakValueDictionary.

ref = weakref.ref(

self, lambda _, pop=child._parents.pop, k=id(self): pop(k))

child._parents[id(self)] = ref

def frozen(self):

"""

"""

is_bbox = True

is_affine = True

if DEBUG:

@staticmethod

def _check(points):

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

_api.warn_external("Bbox bounds are a masked array.")

points = np.asarray(points)

if any((points[1, :] - points[0, :]) == 0):

_api.warn_external("Singular Bbox.")

def frozen(self):

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

frozen.__doc__ = TransformNode.__doc__

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

return self.get_points()

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

"""The left edge of the bounding box."""

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

@property

def ymin(self):

"""The bottom edge of the bounding box."""

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

@property

def xmax(self):

"""The right edge of the bounding box."""

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

@property

def ymax(self):

"""The top edge of the bounding box."""

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

@property

def min(self):

"""The bottom-left corner of the bounding box."""

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

@property

def max(self):

"""The top-right corner of the bounding box."""

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

"""The (signed) width of the bounding box."""

points = self.get_points()

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

@property

def height(self):

"""The (signed) height of the bounding box."""

points = self.get_points()

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

@property

def size(self):

"""The (signed) width and height of the bounding box."""

points = self.get_points()

return points[1] - points[0]

@property

def bounds(self):

"""Return (:attr:`x0`, :attr:`y0`, :attr:`width`, :attr:`height`)."""

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

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

@property

def extents(self):

"""Return (:attr:`x0`, :attr:`y0`, :attr:`x1`, :attr:`y1`)."""

return self.get_points().flatten() # flatten returns a 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]]])

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

"""Construct a `Bbox` by padding this one on all four sides by *p*."""

points = self.get_points()

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

def translated(self, tx, ty):

"""Construct a `Bbox` by translating this one by *tx* and *ty*."""

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

def corners(self):

"""

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

return np.array([[x0, y0], [x0, y1], [x1, y0], [x1, y1]])

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

"""Return a `Bbox` that contains all of the given *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):

"""

super().__init__(**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)

super().invalidate()

def frozen(self):

# docstring inherited

frozen_bbox = super().frozen()

frozen_bbox._minpos = self.minpos.copy()

return frozen_bbox

@staticmethod

def unit():

"""Create a new unit `Bbox` from (0, 0) to (1, 1)."""

return Bbox([[0, 0], [1, 1]])

@staticmethod

def null():

"""Create a new null `Bbox` from (inf, inf) to (-inf, -inf)."""

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

@staticmethod

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

"""

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

@staticmethod

def from_extents(*args, minpos=None):

"""

bbox = Bbox(np.reshape(args, (2, 2)))

if minpos is not None:

bbox._minpos[:] = minpos

return bbox

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]