"""

# Path codes

STOP = 0 # 1 vertex

MOVETO = 1 # 1 vertex

LINETO = 2 # 1 vertex

CURVE3 = 3 # 2 vertices

CURVE4 = 4 # 3 vertices

CLOSEPOLY = 79 # 1 vertex

#: A dictionary mapping Path codes to the number of vertices that the

#: code expects.

NUM_VERTICES_FOR_CODE = {STOP: 1,

MOVETO: 1,

LINETO: 1,

CURVE3: 2,

CURVE4: 3,

CLOSEPOLY: 1}

code_type = np.uint8

def __init__(self, vertices, codes=None, _interpolation_steps=1,

closed=False, readonly=False):

"""

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

vertices = vertices.astype(float).filled(np.nan)

else:

vertices = np.asarray(vertices, float)

if (vertices.ndim != 2) or (vertices.shape[1] != 2):

msg = "'vertices' must be a 2D list or array with shape Nx2"

raise ValueError(msg)

if codes is not None:

codes = np.asarray(codes, self.code_type)

if (codes.ndim != 1) or len(codes) != len(vertices):

msg = ("'codes' must be a 1D list or array with the same"

" length of 'vertices'")

raise ValueError(msg)

if len(codes) and codes[0] != self.MOVETO:

msg = ("The first element of 'code' must be equal to 'MOVETO':"

" {0}")

raise ValueError(msg.format(self.MOVETO))

elif closed:

codes = np.empty(len(vertices), dtype=self.code_type)

codes[0] = self.MOVETO

codes[1:-1] = self.LINETO

codes[-1] = self.CLOSEPOLY

self._vertices = vertices

self._codes = codes

self._interpolation_steps = _interpolation_steps

self._update_values()

if readonly:

self._vertices.flags.writeable = False

if self._codes is not None:

self._codes.flags.writeable = False

self._readonly = True

else:

self._readonly = False

@classmethod

def _fast_from_codes_and_verts(cls, verts, codes, internals=None):

"""

internals = internals or {}

pth = cls.__new__(cls)

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

verts = verts.astype(float).filled(np.nan)

else:

verts = np.asarray(verts, float)

pth._vertices = verts

pth._codes = codes

pth._readonly = internals.pop('readonly', False)

pth.should_simplify = internals.pop('should_simplify', True)

pth.simplify_threshold = (

internals.pop('simplify_threshold',

rcParams['path.simplify_threshold'])

)

pth._has_nonfinite = internals.pop('has_nonfinite', False)

pth._interpolation_steps = internals.pop('interpolation_steps', 1)

if internals:

raise ValueError('Unexpected internals provided to '

'_fast_from_codes_and_verts: '

'{0}'.format('\n *'.join(internals)))

return pth

def _update_values(self):

self._should_simplify = (

rcParams['path.simplify'] and

(len(self._vertices) >= 128 and

(self._codes is None or np.all(self._codes <= Path.LINETO)))

)

self._simplify_threshold = rcParams['path.simplify_threshold']

self._has_nonfinite = not np.isfinite(self._vertices).all()

@property

def vertices(self):

"""

return self._vertices

@vertices.setter

def vertices(self, vertices):

if self._readonly:

raise AttributeError("Can't set vertices on a readonly Path")

self._vertices = vertices

self._update_values()

@property

def codes(self):

"""

return self._codes

@codes.setter

def codes(self, codes):

if self._readonly:

raise AttributeError("Can't set codes on a readonly Path")

self._codes = codes

self._update_values()

@property

def simplify_threshold(self):

"""

return self._simplify_threshold

@simplify_threshold.setter

def simplify_threshold(self, threshold):

self._simplify_threshold = threshold

@property

def has_nonfinite(self):

"""

return self._has_nonfinite

@property

def should_simplify(self):

"""

return self._should_simplify

@should_simplify.setter

def should_simplify(self, should_simplify):

self._should_simplify = should_simplify

@property

def readonly(self):

"""

return self._readonly

def __copy__(self):

"""

import copy

return copy.copy(self)

copy = __copy__

def __deepcopy__(self, memo=None):

"""

try:

codes = self.codes.copy()

except AttributeError:

codes = None

return self.__class__(

self.vertices.copy(), codes,

_interpolation_steps=self._interpolation_steps)

deepcopy = __deepcopy__

@classmethod

def make_compound_path_from_polys(cls, XY):

"""

# for each poly: 1 for the MOVETO, (numsides-1) for the LINETO, 1 for

# the CLOSEPOLY; the vert for the closepoly is ignored but we still

# need it to keep the codes aligned with the vertices

numpolys, numsides, two = XY.shape

if two != 2:

raise ValueError("The third dimension of 'XY' must be 2")

stride = numsides + 1

nverts = numpolys * stride

verts = np.zeros((nverts, 2))

codes = np.ones(nverts, int) * cls.LINETO

codes[0::stride] = cls.MOVETO

codes[numsides::stride] = cls.CLOSEPOLY

for i in range(numsides):

verts[i::stride] = XY[:, i]

return cls(verts, codes)

@classmethod

def make_compound_path(cls, *args):

"""Make a compound path from a list of Path objects."""

# Handle an empty list in args (i.e. no args).

if not args:

return Path(np.empty([0, 2], dtype=np.float32))

lengths = [len(x) for x in args]

total_length = sum(lengths)

vertices = np.vstack([x.vertices for x in args])

vertices.reshape((total_length, 2))

codes = np.empty(total_length, dtype=cls.code_type)

i = 0

for path in args:

if path.codes is None:

codes[i] = cls.MOVETO

codes[i + 1:i + len(path.vertices)] = cls.LINETO

else:

codes[i:i + len(path.codes)] = path.codes

i += len(path.vertices)

return cls(vertices, codes)

def __repr__(self):

return "Path(%r, %r)" % (self.vertices, self.codes)

def __len__(self):

return len(self.vertices)

def iter_segments(self, transform=None, remove_nans=True, clip=None,

snap=False, stroke_width=1.0, simplify=None,

curves=True, sketch=None):

"""

if not len(self):

return

cleaned = self.cleaned(transform=transform,

remove_nans=remove_nans, clip=clip,

snap=snap, stroke_width=stroke_width,

simplify=simplify, curves=curves,

sketch=sketch)

vertices = cleaned.vertices

codes = cleaned.codes

len_vertices = vertices.shape[0]

# Cache these object lookups for performance in the loop.

NUM_VERTICES_FOR_CODE = self.NUM_VERTICES_FOR_CODE

STOP = self.STOP

i = 0

while i < len_vertices:

code = codes[i]

if code == STOP:

return

else:

num_vertices = NUM_VERTICES_FOR_CODE[code]

curr_vertices = vertices[i:i+num_vertices].flatten()

yield curr_vertices, code

i += num_vertices

def cleaned(self, transform=None, remove_nans=False, clip=None,

quantize=False, simplify=False, curves=False,

stroke_width=1.0, snap=False, sketch=None):

"""

vertices, codes = _path.cleanup_path(self, transform,

remove_nans, clip,

snap, stroke_width,

simplify, curves, sketch)

internals = {'should_simplify': self.should_simplify and not simplify,

'has_nonfinite': self.has_nonfinite and not remove_nans,

'simplify_threshold': self.simplify_threshold,

'interpolation_steps': self._interpolation_steps}

return Path._fast_from_codes_and_verts(vertices, codes, internals)

def transformed(self, transform):

"""

return Path(transform.transform(self.vertices), self.codes,

self._interpolation_steps)

def contains_point(self, point, transform=None, radius=0.0):

"""

if transform is not None:

transform = transform.frozen()

# `point_in_path` does not handle nonlinear transforms, so we

# transform the path ourselves. If `transform` is affine, letting

# `point_in_path` handle the transform avoids allocating an extra

# buffer.

if transform and not transform.is_affine:

self = transform.transform_path(self)

transform = None

return _path.point_in_path(point[0], point[1], radius, self, transform)

def contains_points(self, points, transform=None, radius=0.0):

"""

if transform is not None:

transform = transform.frozen()

result = _path.points_in_path(points, radius, self, transform)

return result.astype('bool')

def contains_path(self, path, transform=None):

"""

if transform is not None:

transform = transform.frozen()

return _path.path_in_path(self, None, path, transform)

def get_extents(self, transform=None):

"""

from .transforms import Bbox

path = self

if transform is not None:

transform = transform.frozen()

if not transform.is_affine:

path = self.transformed(transform)

transform = None

return Bbox(_path.get_path_extents(path, transform))

def intersects_path(self, other, filled=True):

"""

return _path.path_intersects_path(self, other, filled)

def intersects_bbox(self, bbox, filled=True):

"""

return _path.path_intersects_rectangle(self,

bbox.x0, bbox.y0, bbox.x1, bbox.y1, filled)

def interpolated(self, steps):

"""

if steps == 1:

return self

vertices = simple_linear_interpolation(self.vertices, steps)

codes = self.codes

if codes is not None:

new_codes = Path.LINETO * np.ones(((len(codes) - 1) * steps + 1, ))

new_codes[0::steps] = codes

else:

new_codes = None

return Path(vertices, new_codes)

def to_polygons(self, transform=None, width=0, height=0, closed_only=True):

"""

if len(self.vertices) == 0:

return []

if transform is not None:

transform = transform.frozen()

if self.codes is None and (width == 0 or height == 0):

vertices = self.vertices

if closed_only:

if len(vertices) < 3:

return []

elif np.any(vertices[0] != vertices[-1]):

vertices = list(vertices) + [vertices[0]]

if transform is None:

return [vertices]

else:

return [transform.transform(vertices)]

# Deal with the case where there are curves and/or multiple

# subpaths (using extension code)

return _path.convert_path_to_polygons(

self, transform, width, height, closed_only)

_unit_rectangle = None

@classmethod

def unit_rectangle(cls):

"""

if cls._unit_rectangle is None:

cls._unit_rectangle = \

cls([[0.0, 0.0], [1.0, 0.0], [1.0, 1.0], [0.0, 1.0],

[0.0, 0.0]],

[cls.MOVETO, cls.LINETO, cls.LINETO, cls.LINETO,

cls.CLOSEPOLY],

readonly=True)

return cls._unit_rectangle

_unit_regular_polygons = WeakValueDictionary()

@classmethod

def unit_regular_polygon(cls, numVertices):

"""

if numVertices <= 16:

path = cls._unit_regular_polygons.get(numVertices)

else:

path = None

if path is None:

theta = (2*np.pi/numVertices *

np.arange(numVertices + 1).reshape((numVertices + 1, 1)))

# This initial rotation is to make sure the polygon always

# "points-up"

theta += np.pi / 2.0

verts = np.concatenate((np.cos(theta), np.sin(theta)), 1)

codes = np.empty((numVertices + 1,))

codes[0] = cls.MOVETO

codes[1:-1] = cls.LINETO

codes[-1] = cls.CLOSEPOLY

path = cls(verts, codes, readonly=True)

if numVertices <= 16:

cls._unit_regular_polygons[numVertices] = path

return path

_unit_regular_stars = WeakValueDictionary()

@classmethod

def unit_regular_star(cls, numVertices, innerCircle=0.5):

"""

if numVertices <= 16:

path = cls._unit_regular_stars.get((numVertices, innerCircle))

else:

path = None

if path is None:

ns2 = numVertices * 2

theta = (2*np.pi/ns2 * np.arange(ns2 + 1))

# This initial rotation is to make sure the polygon always

# "points-up"

theta += np.pi / 2.0

r = np.ones(ns2 + 1)

r[1::2] = innerCircle

verts = np.vstack((r*np.cos(theta), r*np.sin(theta))).transpose()

codes = np.empty((ns2 + 1,))

codes[0] = cls.MOVETO

codes[1:-1] = cls.LINETO

codes[-1] = cls.CLOSEPOLY

path = cls(verts, codes, readonly=True)

if numVertices <= 16:

cls._unit_regular_stars[(numVertices, innerCircle)] = path

return path

@classmethod

def unit_regular_asterisk(cls, numVertices):

"""

return cls.unit_regular_star(numVertices, 0.0)

_unit_circle = None

@classmethod

def unit_circle(cls):

"""

if cls._unit_circle is None:

cls._unit_circle = cls.circle(center=(0, 0), radius=1,

readonly=True)

return cls._unit_circle

@classmethod

def circle(cls, center=(0., 0.), radius=1., readonly=False):

"""

MAGIC = 0.2652031

SQRTHALF = np.sqrt(0.5)

MAGIC45 = np.sqrt((MAGIC*MAGIC) / 2.0)

vertices = np.array([[0.0, -1.0],

[MAGIC, -1.0],

[SQRTHALF-MAGIC45, -SQRTHALF-MAGIC45],

[SQRTHALF, -SQRTHALF],

[SQRTHALF+MAGIC45, -SQRTHALF+MAGIC45],

[1.0, -MAGIC],

[1.0, 0.0],

[1.0, MAGIC],

[SQRTHALF+MAGIC45, SQRTHALF-MAGIC45],

[SQRTHALF, SQRTHALF],

[SQRTHALF-MAGIC45, SQRTHALF+MAGIC45],

[MAGIC, 1.0],

[0.0, 1.0],

[-MAGIC, 1.0],

[-SQRTHALF+MAGIC45, SQRTHALF+MAGIC45],

[-SQRTHALF, SQRTHALF],

[-SQRTHALF-MAGIC45, SQRTHALF-MAGIC45],

[-1.0, MAGIC],

[-1.0, 0.0],

[-1.0, -MAGIC],

[-SQRTHALF-MAGIC45, -SQRTHALF+MAGIC45],

[-SQRTHALF, -SQRTHALF],

[-SQRTHALF+MAGIC45, -SQRTHALF-MAGIC45],

[-MAGIC, -1.0],

[0.0, -1.0],

[0.0, -1.0]],

dtype=float)

codes = [cls.CURVE4] * 26

codes[0] = cls.MOVETO

codes[-1] = cls.CLOSEPOLY

return Path(vertices * radius + center, codes, readonly=readonly)

_unit_circle_righthalf = None

@classmethod

def unit_circle_righthalf(cls):

"""

if cls._unit_circle_righthalf is None:

MAGIC = 0.2652031

SQRTHALF = np.sqrt(0.5)

MAGIC45 = np.sqrt((MAGIC*MAGIC) / 2.0)

vertices = np.array(

[[0.0, -1.0],

[MAGIC, -1.0],

[SQRTHALF-MAGIC45, -SQRTHALF-MAGIC45],

[SQRTHALF, -SQRTHALF],

[SQRTHALF+MAGIC45, -SQRTHALF+MAGIC45],

[1.0, -MAGIC],

[1.0, 0.0],

[1.0, MAGIC],

[SQRTHALF+MAGIC45, SQRTHALF-MAGIC45],

[SQRTHALF, SQRTHALF],

[SQRTHALF-MAGIC45, SQRTHALF+MAGIC45],

[MAGIC, 1.0],

[0.0, 1.0],

[0.0, -1.0]],

float)

codes = cls.CURVE4 * np.ones(14)

codes[0] = cls.MOVETO

codes[-1] = cls.CLOSEPOLY

cls._unit_circle_righthalf = cls(vertices, codes, readonly=True)

return cls._unit_circle_righthalf

@classmethod

def arc(cls, theta1, theta2, n=None, is_wedge=False):

"""

theta1, theta2 = np.deg2rad([theta1, theta2])

twopi = np.pi * 2.0

halfpi = np.pi * 0.5

eta1 = np.arctan2(np.sin(theta1), np.cos(theta1))

eta2 = np.arctan2(np.sin(theta2), np.cos(theta2))

eta2 -= twopi * np.floor((eta2 - eta1) / twopi)

# number of curve segments to make

if n is None:

n = int(2 ** np.ceil((eta2 - eta1) / halfpi))

if n < 1:

raise ValueError("n must be >= 1 or None")

deta = (eta2 - eta1) / n

t = np.tan(0.5 * deta)

alpha = np.sin(deta) * (np.sqrt(4.0 + 3.0 * t * t) - 1) / 3.0

steps = np.linspace(eta1, eta2, n + 1, True)

cos_eta = np.cos(steps)

sin_eta = np.sin(steps)

xA = cos_eta[:-1]

yA = sin_eta[:-1]

xA_dot = -yA

yA_dot = xA

xB = cos_eta[1:]

yB = sin_eta[1:]

xB_dot = -yB

yB_dot = xB

if is_wedge:

length = n * 3 + 4

vertices = np.zeros((length, 2), float)

codes = cls.CURVE4 * np.ones((length, ), cls.code_type)

vertices[1] = [xA[0], yA[0]]

codes[0:2] = [cls.MOVETO, cls.LINETO]

codes[-2:] = [cls.LINETO, cls.CLOSEPOLY]

vertex_offset = 2

end = length - 2

else:

length = n * 3 + 1

vertices = np.empty((length, 2), float)

codes = cls.CURVE4 * np.ones((length, ), cls.code_type)

vertices[0] = [xA[0], yA[0]]

codes[0] = cls.MOVETO

vertex_offset = 1

end = length

vertices[vertex_offset:end:3, 0] = xA + alpha * xA_dot

vertices[vertex_offset:end:3, 1] = yA + alpha * yA_dot

vertices[vertex_offset+1:end:3, 0] = xB - alpha * xB_dot

vertices[vertex_offset+1:end:3, 1] = yB - alpha * yB_dot

vertices[vertex_offset+2:end:3, 0] = xB

vertices[vertex_offset+2:end:3, 1] = yB

return cls(vertices, codes, readonly=True)

@classmethod

def wedge(cls, theta1, theta2, n=None):

"""

return cls.arc(theta1, theta2, n, True)

_hatch_dict = maxdict(8)

@classmethod

def hatch(cls, hatchpattern, density=6):

"""

from matplotlib.hatch import get_path

if hatchpattern is None:

return None

hatch_path = cls._hatch_dict.get((hatchpattern, density))

if hatch_path is not None:

return hatch_path

hatch_path = get_path(hatchpattern, density)

cls._hatch_dict[(hatchpattern, density)] = hatch_path

return hatch_path

def clip_to_bbox(self, bbox, inside=True):

"""

# Use make_compound_path_from_polys

verts = _path.clip_path_to_rect(self, bbox, inside)

paths = [Path(poly) for poly in verts]

master_transform, paths, transforms, offsets, offset_transform):

"""