"""

zorder = 1

validCap = mlines.Line2D.validCap

validJoin = mlines.Line2D.validJoin

# Whether to draw an edge by default. Set on a

# subclass-by-subclass basis.

_edge_default = False

def __init__(self,

edgecolor=None,

facecolor=None,

color=None,

linewidth=None,

linestyle=None,

antialiased=None,

hatch=None,

fill=True,

capstyle=None,

joinstyle=None,

**kwargs):

"""

super().__init__()

if linewidth is None:

linewidth = mpl.rcParams['patch.linewidth']

if linestyle is None:

linestyle = "solid"

if capstyle is None:

capstyle = 'butt'

if joinstyle is None:

joinstyle = 'miter'

if antialiased is None:

antialiased = mpl.rcParams['patch.antialiased']

self._hatch_color = colors.to_rgba(mpl.rcParams['hatch.color'])

self._fill = True # needed for set_facecolor call

if color is not None:

if edgecolor is not None or facecolor is not None:

cbook._warn_external(

"Setting the 'color' property will override "

"the edgecolor or facecolor properties.")

self.set_color(color)

else:

self.set_edgecolor(edgecolor)

self.set_facecolor(facecolor)

# unscaled dashes. Needed to scale dash patterns by lw

self._us_dashes = None

self._linewidth = 0

self.set_fill(fill)

self.set_linestyle(linestyle)

self.set_linewidth(linewidth)

self.set_antialiased(antialiased)

self.set_hatch(hatch)

self.set_capstyle(capstyle)

self.set_joinstyle(joinstyle)

if len(kwargs):

self.update(kwargs)

def get_verts(self):

"""

trans = self.get_transform()

path = self.get_path()

polygons = path.to_polygons(trans)

if len(polygons):

return polygons[0]

return []

def _process_radius(self, radius):

if radius is not None:

return radius

if isinstance(self._picker, Number):

_radius = self._picker

else:

if self.get_edgecolor()[3] == 0:

_radius = 0

else:

_radius = self.get_linewidth()

return _radius

def contains(self, mouseevent, radius=None):

"""

inside, info = self._default_contains(mouseevent)

if inside is not None:

return inside, info

radius = self._process_radius(radius)

codes = self.get_path().codes

if codes is not None:

vertices = self.get_path().vertices

# if the current path is concatenated by multiple sub paths.

# get the indexes of the starting code(MOVETO) of all sub paths

idxs, = np.where(codes == Path.MOVETO)

# Don't split before the first MOVETO.

idxs = idxs[1:]

subpaths = map(

Path, np.split(vertices, idxs), np.split(codes, idxs))

else:

subpaths = [self.get_path()]

inside = any(

subpath.contains_point(

(mouseevent.x, mouseevent.y), self.get_transform(), radius)

for subpath in subpaths)

return inside, {}

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

"""

radius = self._process_radius(radius)

return self.get_path().contains_point(point,

self.get_transform(),

radius)

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

"""

radius = self._process_radius(radius)

return self.get_path().contains_points(points,

self.get_transform(),

radius)

def update_from(self, other):

# docstring inherited.

super().update_from(other)

# For some properties we don't need or don't want to go through the

# getters/setters, so we just copy them directly.

self._edgecolor = other._edgecolor

self._facecolor = other._facecolor

self._original_edgecolor = other._original_edgecolor

self._original_facecolor = other._original_facecolor

self._fill = other._fill

self._hatch = other._hatch

self._hatch_color = other._hatch_color

# copy the unscaled dash pattern

self._us_dashes = other._us_dashes

self.set_linewidth(other._linewidth) # also sets dash properties

self.set_transform(other.get_data_transform())

# If the transform of other needs further initialization, then it will

# be the case for this artist too.

self._transformSet = other.is_transform_set()

def get_extents(self):

"""

return self.get_path().get_extents(self.get_transform())

def get_transform(self):

"""Return the `~.transforms.Transform` applied to the `Patch`."""

return self.get_patch_transform() + artist.Artist.get_transform(self)

def get_data_transform(self):

"""

return artist.Artist.get_transform(self)

def get_patch_transform(self):

"""

return transforms.IdentityTransform()

def get_antialiased(self):

"""Return whether antialiasing is used for drawing."""

return self._antialiased

def get_edgecolor(self):

"""Return the edge color."""

return self._edgecolor

def get_facecolor(self):

"""Return the face color."""

return self._facecolor

def get_linewidth(self):

"""Return the line width in points."""

return self._linewidth

def get_linestyle(self):

"""Return the linestyle."""

return self._linestyle

def set_antialiased(self, aa):

"""

if aa is None:

aa = mpl.rcParams['patch.antialiased']

self._antialiased = aa

self.stale = True

def _set_edgecolor(self, color):

set_hatch_color = True

if color is None:

if (mpl.rcParams['patch.force_edgecolor'] or

not self._fill or self._edge_default):

color = mpl.rcParams['patch.edgecolor']

else:

color = 'none'

set_hatch_color = False

self._edgecolor = colors.to_rgba(color, self._alpha)

if set_hatch_color:

self._hatch_color = self._edgecolor

self.stale = True

def set_edgecolor(self, color):

"""

self._original_edgecolor = color

self._set_edgecolor(color)

def _set_facecolor(self, color):

if color is None:

color = mpl.rcParams['patch.facecolor']

alpha = self._alpha if self._fill else 0

self._facecolor = colors.to_rgba(color, alpha)

self.stale = True

def set_facecolor(self, color):

"""

self._original_facecolor = color

self._set_facecolor(color)

def set_color(self, c):

"""

self.set_facecolor(c)

self.set_edgecolor(c)

def set_alpha(self, alpha):

# docstring inherited

super().set_alpha(alpha)

self._set_facecolor(self._original_facecolor)

self._set_edgecolor(self._original_edgecolor)

# stale is already True

def set_linewidth(self, w):

"""

if w is None:

w = mpl.rcParams['patch.linewidth']

if w is None:

w = mpl.rcParams['axes.linewidth']

self._linewidth = float(w)

# scale the dash pattern by the linewidth

offset, ls = self._us_dashes

self._dashoffset, self._dashes = mlines._scale_dashes(

offset, ls, self._linewidth)

self.stale = True

def set_linestyle(self, ls):

"""

if ls is None:

ls = "solid"

if ls in [' ', '', 'none']:

ls = 'None'

self._linestyle = ls

# get the unscaled dash pattern

offset, ls = self._us_dashes = mlines._get_dash_pattern(ls)

# scale the dash pattern by the linewidth

self._dashoffset, self._dashes = mlines._scale_dashes(

offset, ls, self._linewidth)

self.stale = True

def set_fill(self, b):

"""

self._fill = bool(b)

self._set_facecolor(self._original_facecolor)

self._set_edgecolor(self._original_edgecolor)

self.stale = True

def get_fill(self):

"""Return whether the patch is filled."""

return self._fill

# Make fill a property so as to preserve the long-standing

# but somewhat inconsistent behavior in which fill was an

# attribute.

fill = property(get_fill, set_fill)

def set_capstyle(self, s):

"""

mpl.rcsetup.validate_capstyle(s)

self._capstyle = s

self.stale = True

def get_capstyle(self):

"""Return the capstyle."""

return self._capstyle

def set_joinstyle(self, s):

"""

mpl.rcsetup.validate_joinstyle(s)

self._joinstyle = s

self.stale = True

def get_joinstyle(self):

"""Return the joinstyle."""

return self._joinstyle

def set_hatch(self, hatch):

r"""

# Use validate_hatch(list) after deprecation.

mhatch._validate_hatch_pattern(hatch)

self._hatch = hatch

self.stale = True

def get_hatch(self):

"""Return the hatching pattern."""

return self._hatch

@contextlib.contextmanager

def _bind_draw_path_function(self, renderer):

"""

renderer.open_group('patch', self.get_gid())

gc = renderer.new_gc()

gc.set_foreground(self._edgecolor, isRGBA=True)

lw = self._linewidth

if self._edgecolor[3] == 0 or self._linestyle == 'None':

lw = 0

gc.set_linewidth(lw)

gc.set_dashes(self._dashoffset, self._dashes)

gc.set_capstyle(self._capstyle)

gc.set_joinstyle(self._joinstyle)

gc.set_antialiased(self._antialiased)

self._set_gc_clip(gc)

gc.set_url(self._url)

gc.set_snap(self.get_snap())

gc.set_alpha(self._alpha)

if self._hatch:

gc.set_hatch(self._hatch)

gc.set_hatch_color(self._hatch_color)

if self.get_sketch_params() is not None:

gc.set_sketch_params(*self.get_sketch_params())

if self.get_path_effects():

from matplotlib.patheffects import PathEffectRenderer

renderer = PathEffectRenderer(self.get_path_effects(), renderer)

# In `with _bind_draw_path_function(renderer) as draw_path: ...`

# (in the implementations of `draw()` below), calls to `draw_path(...)`

# will occur as if they took place here with `gc` inserted as

# additional first argument.

yield functools.partial(renderer.draw_path, gc)

gc.restore()

renderer.close_group('patch')

self.stale = False

@artist.allow_rasterization

def draw(self, renderer):

# docstring inherited

if not self.get_visible():

return

# Patch has traditionally ignored the dashoffset.

with cbook._setattr_cm(self, _dashoffset=0), \

self._bind_draw_path_function(renderer) as draw_path:

path = self.get_path()

transform = self.get_transform()

tpath = transform.transform_path_non_affine(path)

affine = transform.get_affine()

draw_path(tpath, affine,

# Work around a bug in the PDF and SVG renderers, which

# do not draw the hatches if the facecolor is fully

# transparent, but do if it is None.

self._facecolor if self._facecolor[3] else None)

def get_path(self):

"""Return the path of this patch."""

raise NotImplementedError('Derived must override')

def get_window_extent(self, renderer=None):

return self.get_path().get_extents(self.get_transform())

def _convert_xy_units(self, xy):

"""Convert x and y units for a tuple (x, y)."""

x = self.convert_xunits(xy[0])

y = self.convert_yunits(xy[1])

def __str__(self):

return "Shadow(%s)" % (str(self.patch))

@cbook._delete_parameter("3.3", "props")

@docstring.dedent_interpd

def __init__(self, patch, ox, oy, props=None, **kwargs):

"""

super().__init__()

self.patch = patch

# Note: when removing props, we can directly pass kwargs to _update()

# and remove self._props

if props is None:

color = .3 * np.asarray(colors.to_rgb(self.patch.get_facecolor()))

props = {

'facecolor': color,

'edgecolor': color,

'alpha': 0.5,

}

self._props = {**props, **kwargs}

self._ox, self._oy = ox, oy

self._shadow_transform = transforms.Affine2D()

self._update()

props = cbook._deprecate_privatize_attribute("3.3")

def _update(self):

self.update_from(self.patch)

# Place the shadow patch directly behind the inherited patch.

self.set_zorder(np.nextafter(self.patch.zorder, -np.inf))

self.update(self._props)

def _update_transform(self, renderer):

ox = renderer.points_to_pixels(self._ox)

oy = renderer.points_to_pixels(self._oy)

self._shadow_transform.clear().translate(ox, oy)

def get_path(self):

return self.patch.get_path()

def get_patch_transform(self):

return self.patch.get_patch_transform() + self._shadow_transform

def draw(self, renderer):

self._update_transform(renderer)

"""

def __str__(self):

pars = self._x0, self._y0, self._width, self._height, self.angle

fmt = "Rectangle(xy=(%g, %g), width=%g, height=%g, angle=%g)"

return fmt % pars

@docstring.dedent_interpd

def __init__(self, xy, width, height, angle=0.0, **kwargs):

"""

super().__init__(**kwargs)

self._x0 = xy[0]

self._y0 = xy[1]

self._width = width

self._height = height

self.angle = float(angle)

self._convert_units() # Validate the inputs.

def get_path(self):

"""Return the vertices of the rectangle."""

return Path.unit_rectangle()

def _convert_units(self):

"""Convert bounds of the rectangle."""

x0 = self.convert_xunits(self._x0)

y0 = self.convert_yunits(self._y0)

x1 = self.convert_xunits(self._x0 + self._width)

y1 = self.convert_yunits(self._y0 + self._height)

return x0, y0, x1, y1

def get_patch_transform(self):

# Note: This cannot be called until after this has been added to

# an Axes, otherwise unit conversion will fail. This makes it very

# important to call the accessor method and not directly access the

# transformation member variable.

bbox = self.get_bbox()

return (transforms.BboxTransformTo(bbox)

+ transforms.Affine2D().rotate_deg_around(

bbox.x0, bbox.y0, self.angle))

def get_x(self):

"""Return the left coordinate of the rectangle."""

return self._x0

def get_y(self):

"""Return the bottom coordinate of the rectangle."""

return self._y0

def get_xy(self):

"""Return the left and bottom coords of the rectangle as a tuple."""

return self._x0, self._y0

def get_width(self):

"""Return the width of the rectangle."""

return self._width

def get_height(self):

"""Return the height of the rectangle."""

return self._height

def set_x(self, x):

"""Set the left coordinate of the rectangle."""

self._x0 = x

self.stale = True

def set_y(self, y):

"""Set the bottom coordinate of the rectangle."""

self._y0 = y

self.stale = True

def set_xy(self, xy):

"""

self._x0, self._y0 = xy

self.stale = True

def set_width(self, w):

"""Set the width of the rectangle."""

self._width = w

self.stale = True

def set_height(self, h):

"""Set the height of the rectangle."""

self._height = h

self.stale = True

def set_bounds(self, *args):

"""

if len(args) == 1:

l, b, w, h = args[0]

else:

l, b, w, h = args

self._x0 = l

self._y0 = b

self._width = w

self._height = h

self.stale = True

def get_bbox(self):

"""Return the `.Bbox`."""

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

return transforms.Bbox.from_extents(x0, y0, x1, y1)

"""A regular polygon patch."""

def __str__(self):

s = "RegularPolygon((%g, %g), %d, radius=%g, orientation=%g)"

return s % (self.xy[0], self.xy[1], self.numvertices, self.radius,

self.orientation)

@docstring.dedent_interpd

def __init__(self, xy, numVertices, radius=5, orientation=0,

**kwargs):

"""

self.xy = xy

self.numvertices = numVertices

self.orientation = orientation

self.radius = radius

self._path = Path.unit_regular_polygon(numVertices)

self._patch_transform = transforms.Affine2D()

super().__init__(**kwargs)

def get_path(self):

return self._path

def get_patch_transform(self):

return self._patch_transform.clear() \

.scale(self.radius) \

.rotate(self.orientation) \

"""A general polycurve path patch."""

_edge_default = True

def __str__(self):

s = "PathPatch%d((%g, %g) ...)"

return s % (len(self._path.vertices), *tuple(self._path.vertices[0]))

@docstring.dedent_interpd

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

"""

super().__init__(**kwargs)

self._path = path

def get_path(self):

return self._path

def set_path(self, path):

"""

_edge_default = False

@docstring.dedent_interpd

def __init__(self, values, edges, *,

orientation='vertical', baseline=0, **kwargs):

"""

self.orientation = orientation

self._edges = np.asarray(edges)

self._values = np.asarray(values)

self._baseline = np.asarray(baseline) if baseline is not None else None

self._update_path()

super().__init__(self._path, **kwargs)

def _update_path(self):

if np.isnan(np.sum(self._edges)):

raise ValueError('Nan values in "edges" are disallowed')

if self._edges.size - 1 != self._values.size:

raise ValueError('Size mismatch between "values" and "edges". '

"Expected `len(values) + 1 == len(edges)`, but "

f"`len(values) = {self._values.size}` and "

f"`len(edges) = {self._edges.size}`.")

verts, codes = [], []

_nan_mask = np.isnan(self._values)

if self._baseline is not None:

_nan_mask |= np.isnan(self._baseline)

for idx0, idx1 in cbook.contiguous_regions(~_nan_mask):

x = np.repeat(self._edges[idx0:idx1+1], 2)

y = np.repeat(self._values[idx0:idx1], 2)

if self._baseline is None:

y = np.hstack((y[0], y, y[-1]))

elif self._baseline.ndim == 0: # single baseline value

y = np.hstack((self._baseline, y, self._baseline))

elif self._baseline.ndim == 1: # baseline array

base = np.repeat(self._baseline[idx0:idx1], 2)[::-1]

x = np.concatenate([x, x[::-1]])

y = np.concatenate([np.hstack((base[-1], y, base[0],

base[0], base, base[-1]))])

else: # no baseline

raise ValueError('Invalid `baseline` specified')

if self.orientation == 'vertical':

xy = np.column_stack([x, y])

else:

xy = np.column_stack([y, x])