'antialiased': ['aa'],

'edgecolor': ['ec'],

'facecolor': ['fc'],

'linewidth': ['lw'],

'linestyle': ['ls']

"""

zorder = 1

validCap = ('butt', 'round', 'projecting')

validJoin = ('miter', 'round', 'bevel')

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

# subclass-by-subclass basis.

_edge_default = False

def __str__(self):

return str(self.__class__).split('.')[-1]

def __init__(self,

edgecolor=None,

facecolor=None,

color=None,

linewidth=None,

linestyle=None,

antialiased=None,

hatch=None,

fill=True,

capstyle=None,

joinstyle=None,

**kwargs):

"""

artist.Artist.__init__(self)

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

warnings.warn("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)

self._combined_transform = transforms.IdentityTransform()

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 cbook.is_numlike(self._picker):

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

"""Test whether the mouse event occurred in the patch.

if callable(self._contains):

return self._contains(self, mouseevent)

radius = self._process_radius(radius)

inside = self.get_path().contains_point(

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

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 update_from(self, other):

"""

artist.Artist.update_from(self, 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._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())

def get_extents(self):

"""

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

def get_transform(self):

"""

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 self._antialiased

get_aa = get_antialiased

def get_edgecolor(self):

"""

return self._edgecolor

get_ec = get_edgecolor

def get_facecolor(self):

"""

return self._facecolor

get_fc = get_facecolor

def get_linewidth(self):

"""

return self._linewidth

get_lw = get_linewidth

def get_linestyle(self):

"""

return self._linestyle

get_ls = get_linestyle

def set_antialiased(self, aa):

"""

if aa is None:

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

self._antialiased = aa

self.stale = True

def set_aa(self, aa):

"""alias for set_antialiased"""

return self.set_antialiased(aa)

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_ec(self, color):

"""alias for set_edgecolor"""

return 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_fc(self, color):

"""alias for set_facecolor"""

return self.set_facecolor(color)

def set_color(self, c):

"""

self.set_facecolor(c)

self.set_edgecolor(c)

def set_alpha(self, alpha):

"""

if alpha is not None:

try:

float(alpha)

except TypeError:

raise TypeError('alpha must be a float or None')

artist.Artist.set_alpha(self, 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_lw(self, lw):

"""alias for set_linewidth"""

return self.set_linewidth(lw)

def set_linestyle(self, ls):

"""

if ls is None:

ls = "solid"

self._linestyle = ls

# get the unscalled 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_ls(self, ls):

"""alias for set_linestyle"""

return self.set_linestyle(ls)

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 fill is set'

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

"""

s = s.lower()

if s not in self.validCap:

raise ValueError('set_capstyle passed "%s";\n' % (s,) +

'valid capstyles are %s' % (self.validCap,))

self._capstyle = s

self.stale = True

def get_capstyle(self):

"Return the current capstyle"

return self._capstyle

def set_joinstyle(self, s):

"""

s = s.lower()

if s not in self.validJoin:

raise ValueError('set_joinstyle passed "%s";\n' % (s,) +

'valid joinstyles are %s' % (self.validJoin,))

self._joinstyle = s

self.stale = True

def get_joinstyle(self):

"Return the current joinstyle"

return self._joinstyle

def set_hatch(self, hatch):

"""

self._hatch = hatch

self.stale = True

def get_hatch(self):

'Return the current hatching pattern'

return self._hatch

@allow_rasterization

def draw(self, renderer):

'Draw the :class:`Patch` to the given *renderer*.'

if not self.get_visible():

return

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:

lw = 0

gc.set_linewidth(lw)

gc.set_dashes(0, 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())

rgbFace = self._facecolor

if rgbFace[3] == 0:

rgbFace = None # (some?) renderers expect this as no-fill signal

gc.set_alpha(self._alpha)

if self._hatch:

gc.set_hatch(self._hatch)

try:

gc.set_hatch_color(self._hatch_color)

except AttributeError:

# if we end up with a GC that does not have this method

warnings.warn("Your backend does not have support for "

"setting the hatch color.")

if self.get_sketch_params() is not None:

gc.set_sketch_params(*self.get_sketch_params())

path = self.get_path()

transform = self.get_transform()

tpath = transform.transform_path_non_affine(path)

affine = transform.get_affine()

if self.get_path_effects():

from matplotlib.patheffects import PathEffectRenderer

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

renderer.draw_path(gc, tpath, affine, rgbFace)

gc.restore()

renderer.close_group('patch')

self.stale = False

def get_path(self):

"""

raise NotImplementedError('Derived must override')

def get_window_extent(self, renderer=None):

def __str__(self):

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

@docstring.dedent_interpd

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

"""

Patch.__init__(self)

self.patch = patch

self.props = props

self._ox, self._oy = ox, oy

self._shadow_transform = transforms.Affine2D()

self._update()

def _update(self):

self.update_from(self.patch)

if self.props is not None:

self.update(self.props)

else:

r, g, b, a = colors.to_rgba(self.patch.get_facecolor())

rho = 0.3

r = rho * r

g = rho * g

b = rho * b

self.set_facecolor((r, g, b, 0.5))

self.set_edgecolor((r, g, b, 0.5))

self.set_alpha(0.5)

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

return self._ox

def _set_ox(self, ox):

self._ox = ox

def _get_oy(self):

return self._oy

def _set_oy(self, oy):

self._oy = 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._x, self._y, 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):

"""

Patch.__init__(self, **kwargs)

self._x = float(xy[0])

self._y = float(xy[1])

self._width = float(width)

self._height = float(height)

self.angle = float(angle)

# Note: This cannot be calculated until this is added to an Axes

self._rect_transform = transforms.IdentityTransform()

def get_path(self):

"""

return Path.unit_rectangle()

def _update_patch_transform(self):

"""NOTE: This cannot be called until after this has been added

x = self.convert_xunits(self._x)

y = self.convert_yunits(self._y)

width = self.convert_xunits(self._width)

height = self.convert_yunits(self._height)

bbox = transforms.Bbox.from_bounds(x, y, width, height)

rot_trans = transforms.Affine2D()

rot_trans.rotate_deg_around(x, y, self.angle)

self._rect_transform = transforms.BboxTransformTo(bbox)

self._rect_transform += rot_trans

def get_patch_transform(self):

self._update_patch_transform()

return self._rect_transform

def get_x(self):

"Return the left coord of the rectangle"

return self._x

def get_y(self):

"Return the bottom coord of the rectangle"

return self._y

def get_xy(self):

"Return the left and bottom coords of the rectangle"

return self._x, self._y

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

"""

self._x = x

self.stale = True

def set_y(self, y):

"""

self._y = y

self.stale = True

def set_xy(self, xy):

"""

self._x, self._y = xy

self.stale = True

def set_width(self, w):

"""

self._width = w

self.stale = True

def set_height(self, h):

"""

self._height = h

self.stale = True

def set_bounds(self, *args):

"""

if len(args) == 0:

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

else:

l, b, w, h = args

self._x = l

self._y = b

self._width = w

self._height = h

self.stale = True

def get_bbox(self):

return transforms.Bbox.from_bounds(self._x, self._y,

self._width, self._height)

"""

def __str__(self):

return "Poly%d(%g,%g)" % (self._numVertices, self._xy[0], self._xy[1])

@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._poly_transform = transforms.Affine2D()

self._update_transform()

Patch.__init__(self, **kwargs)

def _update_transform(self):

self._poly_transform.clear() \

.scale(self.radius) \

.rotate(self.orientation) \

.translate(*self.xy)

def _get_xy(self):

return self._xy

def _set_xy(self, xy):

self._xy = xy

self._update_transform()

xy = property(_get_xy, _set_xy)

def _get_orientation(self):

return self._orientation

def _set_orientation(self, orientation):

self._orientation = orientation

self._update_transform()

orientation = property(_get_orientation, _set_orientation)

def _get_radius(self):

return self._radius

def _set_radius(self, radius):

self._radius = radius

self._update_transform()

radius = property(_get_radius, _set_radius)

def _get_numvertices(self):

return self._numVertices

def _set_numvertices(self, numVertices):

self._numVertices = numVertices

numvertices = property(_get_numvertices, _set_numvertices)

def get_path(self):

return self._path

def get_patch_transform(self):

self._update_transform()

"""

_edge_default = True

def __str__(self):

return "Poly((%g, %g) ...)" % tuple(self._path.vertices[0])

@docstring.dedent_interpd

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

"""

Patch.__init__(self, **kwargs)

self._path = path

def get_path(self):

"""

def __str__(self):

return "Poly((%g, %g) ...)" % tuple(self._path.vertices[0])

@docstring.dedent_interpd

def __init__(self, xy, closed=True, **kwargs):

"""

Patch.__init__(self, **kwargs)

self._closed = closed

self.set_xy(xy)

def get_path(self):

"""

return self._path

def get_closed(self):

"""

return self._closed

def set_closed(self, closed):

"""

if self._closed == bool(closed):

return

self._closed = bool(closed)

self.set_xy(self.get_xy())

self.stale = True

def get_xy(self):

"""