"""

_offsets = np.array([], np.float_)

# _offsets must be a Nx2 array!

_offsets.shape = (0, 2)

_transOffset = transforms.IdentityTransform()

_transforms = []

zorder = 1

def __init__(self,

edgecolors=None,

facecolors=None,

linewidths=None,

linestyles='solid',

antialiaseds = None,

offsets = None,

transOffset = None,

norm = None, # optional for ScalarMappable

cmap = None, # ditto

pickradius = 5.0,

urls = None,

**kwargs

):

"""

artist.Artist.__init__(self)

cm.ScalarMappable.__init__(self, norm, cmap)

self.set_edgecolor(edgecolors)

self.set_facecolor(facecolors)

self.set_linewidth(linewidths)

self.set_linestyle(linestyles)

self.set_antialiased(antialiaseds)

self.set_pickradius(pickradius)

self.set_urls(urls)

self._uniform_offsets = None

self._offsets = np.array([], np.float_)

# Force _offsets to be Nx2

self._offsets.shape = (0, 2)

if offsets is not None:

offsets = np.asanyarray(offsets)

offsets.shape = (-1, 2) # Make it Nx2

if transOffset is not None:

self._offsets = offsets

self._transOffset = transOffset

else:

self._uniform_offsets = offsets

self.update(kwargs)

self._paths = None

@staticmethod

def _get_value(val):

try:

return (float(val), )

except TypeError:

if cbook.iterable(val) and len(val):

try:

float(val[0])

except (TypeError, ValueError):

pass # raise below

else:

return val

raise TypeError('val must be a float or nonzero sequence of floats')

@staticmethod

def _get_bool(val):

if not cbook.iterable(val):

val = (val,)

try:

bool(val[0])

except (TypeError, IndexError):

raise TypeError('val must be a bool or nonzero sequence of them')

return val

def get_paths(self):

return self._paths

def set_paths(self):

raise NotImplementedError

def get_transforms(self):

return self._transforms

def get_datalim(self, transData):

transform = self.get_transform()

transOffset = self._transOffset

offsets = self._offsets

paths = self.get_paths()

if not transform.is_affine:

paths = [transform.transform_path_non_affine(p) for p in paths]

transform = transform.get_affine()

if not transOffset.is_affine:

offsets = transOffset.transform_non_affine(offsets)

transOffset = transOffset.get_affine()

offsets = np.asanyarray(offsets, np.float_)

if np.ma.isMaskedArray(offsets):

offsets = offsets.filled(np.nan)

# get_path_collection_extents handles nan but not masked arrays

offsets.shape = (-1, 2) # Make it Nx2

result = mpath.get_path_collection_extents(

transform.frozen(), paths, self.get_transforms(),

offsets, transOffset.frozen())

result = result.inverse_transformed(transData)

return result

def get_window_extent(self, renderer):

bbox = self.get_datalim(transforms.IdentityTransform())

#TODO:check to ensure that this does not fail for

#cases other than scatter plot legend

return bbox

def _prepare_points(self):

"""Point prep for drawing and hit testing"""

transform = self.get_transform()

transOffset = self._transOffset

offsets = self._offsets

paths = self.get_paths()

if self.have_units():

paths = []

for path in self.get_paths():

vertices = path.vertices

xs, ys = vertices[:, 0], vertices[:, 1]

xs = self.convert_xunits(xs)

ys = self.convert_yunits(ys)

paths.append(mpath.Path(zip(xs, ys), path.codes))

if offsets.size > 0:

xs = self.convert_xunits(offsets[:,0])

ys = self.convert_yunits(offsets[:,1])

offsets = zip(xs, ys)

offsets = np.asanyarray(offsets, np.float_)

offsets.shape = (-1, 2) # Make it Nx2

if not transform.is_affine:

paths = [transform.transform_path_non_affine(path) for path in paths]

transform = transform.get_affine()

if not transOffset.is_affine :

offsets = transOffset.transform_non_affine(offsets)

# This might have changed an ndarray into a masked array.

transOffset = transOffset.get_affine()

if np.ma.isMaskedArray(offsets):

offsets = offsets.filled(np.nan)

# Changing from a masked array to nan-filled ndarray

# is probably most efficient at this point.

return transform, transOffset, offsets, paths

@allow_rasterization

def draw(self, renderer):

if not self.get_visible(): return

renderer.open_group(self.__class__.__name__)

self.update_scalarmappable()

transform, transOffset, offsets, paths = self._prepare_points()

gc = renderer.new_gc()

self._set_gc_clip(gc)

gc.set_snap(self.get_snap())

renderer.draw_path_collection(

gc, transform.frozen(), paths, self.get_transforms(),

offsets, transOffset, self.get_facecolor(), self.get_edgecolor(),

self._linewidths, self._linestyles, self._antialiaseds, self._urls)

gc.restore()

renderer.close_group(self.__class__.__name__)

def set_pickradius(self, pr):

self._pickradius = pr

def get_pickradius(self):

return self._pickradius

def contains(self, mouseevent):

"""

if callable(self._contains):

return self._contains(self,mouseevent)

if not self.get_visible():

return False, {}

if self._picker is True: # the Boolean constant, not just nonzero or 1

pickradius = self._pickradius

else:

try:

pickradius = float(self._picker)

except TypeError:

# This should not happen if "contains" is called via

# pick, the normal route; the check is here in case

# it is called through some unanticipated route.

warnings.warn(

"Collection picker %s could not be converted to float"

% self._picker)

pickradius = self._pickradius

transform, transOffset, offsets, paths = self._prepare_points()

ind = mpath.point_in_path_collection(

mouseevent.x, mouseevent.y, pickradius,

transform.frozen(), paths, self.get_transforms(),

offsets, transOffset, pickradius <= 0)

return len(ind)>0, dict(ind=ind)

def set_urls(self, urls):

if urls is None:

self._urls = [None,]

else:

self._urls = urls

def get_urls(self): return self._urls

def set_offsets(self, offsets):

"""

offsets = np.asanyarray(offsets, np.float_)

offsets.shape = (-1, 2) # Make it Nx2

#This decision is based on how they are initialized above

if self._uniform_offsets is None:

self._offsets = offsets

else:

self._uniform_offsets = offsets

def get_offsets(self):

"""

#This decision is based on how they are initialized above in __init__()

if self._uniform_offsets is None:

return self._offsets

else:

return self._uniform_offsets

def set_linewidth(self, lw):

"""

if lw is None: lw = mpl.rcParams['patch.linewidth']

self._linewidths = self._get_value(lw)

def set_linewidths(self, lw):

"""alias for set_linewidth"""

return self.set_linewidth(lw)

def set_lw(self, lw):

"""alias for set_linewidth"""

return self.set_linewidth(lw)

def set_linestyle(self, ls):

"""

try:

dashd = backend_bases.GraphicsContextBase.dashd

if cbook.is_string_like(ls):

if ls in dashd:

dashes = [dashd[ls]]

elif ls in cbook.ls_mapper:

dashes = [dashd[cbook.ls_mapper[ls]]]

else:

raise ValueError()

elif cbook.iterable(ls):

try:

dashes = []

for x in ls:

if cbook.is_string_like(x):

if x in dashd:

dashes.append(dashd[x])

elif x in cbook.ls_mapper:

dashes.append(dashd[cbook.ls_mapper[x]])

else:

raise ValueError()

elif cbook.iterable(x) and len(x) == 2:

dashes.append(x)

else:

raise ValueError()

except ValueError:

if len(ls)==2:

dashes = ls

else:

raise ValueError()

else:

raise ValueError()

except ValueError:

raise ValueError('Do not know how to convert %s to dashes'%ls)

self._linestyles = dashes

def set_linestyles(self, ls):

"""alias for set_linestyle"""

return self.set_linestyle(ls)

def set_dashes(self, ls):

"""alias for set_linestyle"""

return self.set_linestyle(ls)

def set_antialiased(self, aa):

"""

if aa is None:

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

self._antialiaseds = self._get_bool(aa)

def set_antialiaseds(self, aa):

"""alias for set_antialiased"""

return self.set_antialiased(aa)

def set_color(self, c):

"""

self.set_facecolor(c)

self.set_edgecolor(c)

def set_facecolor(self, c):

"""

self._is_filled = True

try:

if c.lower() == 'none':

self._is_filled = False

except AttributeError:

pass

if c is None: c = mpl.rcParams['patch.facecolor']

self._facecolors_original = c

self._facecolors = mcolors.colorConverter.to_rgba_array(c, self._alpha)

def set_facecolors(self, c):

"""alias for set_facecolor"""

return self.set_facecolor(c)

def get_facecolor(self):

return self._facecolors

get_facecolors = get_facecolor

def get_edgecolor(self):

if self._edgecolors == 'face':

return self.get_facecolors()

else:

return self._edgecolors

get_edgecolors = get_edgecolor

def set_edgecolor(self, c):

"""

self._is_stroked = True

try:

if c.lower() == 'none':

self._is_stroked = False

except AttributeError:

pass

try:

if c.lower() == 'face':

self._edgecolors = 'face'

self._edgecolors_original = 'face'

return

except AttributeError:

pass

if c is None:

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

self._edgecolors_original = c

self._edgecolors = mcolors.colorConverter.to_rgba_array(c, self._alpha)

def set_edgecolors(self, c):

"""alias for set_edgecolor"""

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

try:

self._facecolors = mcolors.colorConverter.to_rgba_array(

self._facecolors_original, self._alpha)

except (AttributeError, TypeError, IndexError):

pass

try:

if self._edgecolors_original != 'face':

self._edgecolors = mcolors.colorConverter.to_rgba_array(

self._edgecolors_original, self._alpha)

except (AttributeError, TypeError, IndexError):

pass

def get_linewidths(self):

return self._linewidths

get_linewidth = get_linewidths

def get_linestyles(self):

return self._linestyles

get_dashes = get_linestyle = get_linestyles

def update_scalarmappable(self):

"""

if self._A is None:

return

if self._A.ndim > 1:

raise ValueError('Collections can only map rank 1 arrays')

if not self.check_update("array"):

return

if self._is_filled:

self._facecolors = self.to_rgba(self._A, self._alpha)

elif self._is_stroked:

self._edgecolors = self.to_rgba(self._A, self._alpha)

def update_from(self, other):

'copy properties from other to self'

artist.Artist.update_from(self, other)

self._antialiaseds = other._antialiaseds

self._edgecolors_original = other._edgecolors_original

self._edgecolors = other._edgecolors

self._facecolors_original = other._facecolors_original

self._facecolors = other._facecolors

self._linewidths = other._linewidths

self._linestyles = other._linestyles

self._pickradius = other._pickradius

# update_from for scalarmappable

self._A = other._A

self.norm = other.norm

self.cmap = other.cmap

"""

@docstring.dedent_interpd

def __init__(self, paths, sizes=None, **kwargs):

"""

Collection.__init__(self, **kwargs)

self.set_paths(paths)

self._sizes = sizes

def set_paths(self, paths):

self._paths = paths

def get_paths(self):

return self._paths

def get_sizes(self):

return self._sizes

@allow_rasterization

def draw(self, renderer):

if self._sizes is not None:

self._transforms = [

transforms.Affine2D().scale(

(np.sqrt(x) * self.figure.dpi / 72.0))

for x in self._sizes]

@docstring.dedent_interpd

def __init__(self, verts, sizes = None, closed = True, **kwargs):

"""

Collection.__init__(self,**kwargs)

self._sizes = sizes

self.set_verts(verts, closed)

def set_verts(self, verts, closed=True):

'''This allows one to delay initialization of the vertices.'''

if np.ma.isMaskedArray(verts):

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

# This is much faster than having Path do it one at a time.

if closed:

self._paths = []

for xy in verts:

if len(xy):

if np.ma.isMaskedArray(xy):

xy = np.ma.concatenate([xy, np.zeros((1,2))])

else:

xy = np.asarray(xy)

xy = np.concatenate([xy, np.zeros((1,2))])

codes = np.empty(xy.shape[0], dtype=mpath.Path.code_type)

codes[:] = mpath.Path.LINETO

codes[0] = mpath.Path.MOVETO

codes[-1] = mpath.Path.CLOSEPOLY

self._paths.append(mpath.Path(xy, codes))

else:

self._paths.append(mpath.Path(xy))

else:

self._paths = [mpath.Path(xy) for xy in verts]

set_paths = set_verts

@allow_rasterization

def draw(self, renderer):

if self._sizes is not None:

self._transforms = [

transforms.Affine2D().scale(

(np.sqrt(x) * self.figure.dpi / 72.0))

for x in self._sizes]

"""

@docstring.dedent_interpd

def __init__(self, xranges, yrange, **kwargs):

"""

ymin, ywidth = yrange

ymax = ymin + ywidth

verts = [ [(xmin, ymin), (xmin, ymax), (xmin+xwidth, ymax), (xmin+xwidth, ymin), (xmin, ymin)] for xmin, xwidth in xranges]

PolyCollection.__init__(self, verts, **kwargs)

@staticmethod

def span_where(x, ymin, ymax, where, **kwargs):

"""

xranges = []

for ind0, ind1 in mlab.contiguous_regions(where):

xslice = x[ind0:ind1]

if not len(xslice):

continue

xranges.append((xslice[0], xslice[-1]-xslice[0]))

collection = BrokenBarHCollection(xranges, [ymin, ymax-ymin], **kwargs)

"""Draw a collection of regular polygons with *numsides*."""

_path_generator = mpath.Path.unit_regular_polygon

@docstring.dedent_interpd

def __init__(self,

numsides,

rotation = 0 ,

sizes = (1,),

**kwargs):

"""

Collection.__init__(self,**kwargs)

self._sizes = sizes

self._numsides = numsides

self._paths = [self._path_generator(numsides)]

self._rotation = rotation

self.set_transform(transforms.IdentityTransform())

@allow_rasterization

def draw(self, renderer):

self._transforms = [

transforms.Affine2D().rotate(-self._rotation).scale(

(np.sqrt(x) * self.figure.dpi / 72.0) / np.sqrt(np.pi))

for x in self._sizes]

return Collection.draw(self, renderer)

def get_numsides(self):

return self._numsides

def get_rotation(self):

return self._rotation

def get_sizes(self):

"""

"""

"""

zorder = 2

def __init__(self, segments, # Can be None.

linewidths = None,

colors = None,

antialiaseds = None,

linestyles = 'solid',

offsets = None,

transOffset = None,

norm = None,

cmap = None,

pickradius = 5,

**kwargs

):

"""

if colors is None: colors = mpl.rcParams['lines.color']

if linewidths is None: linewidths = (mpl.rcParams['lines.linewidth'],)

if antialiaseds is None: antialiaseds = (mpl.rcParams['lines.antialiased'],)

self.set_linestyles(linestyles)

colors = mcolors.colorConverter.to_rgba_array(colors)

Collection.__init__(

self,

edgecolors=colors,

facecolors='none',

linewidths=linewidths,

linestyles=linestyles,

antialiaseds=antialiaseds,

offsets=offsets,

transOffset=transOffset,

norm=norm,

cmap=cmap,

pickradius=pickradius,

**kwargs)

self.set_segments(segments)

def set_segments(self, segments):

if segments is None: return

_segments = []

for seg in segments:

if not np.ma.isMaskedArray(seg):

seg = np.asarray(seg, np.float_)

_segments.append(seg)

if self._uniform_offsets is not None:

_segments = self._add_offsets(_segments)

self._paths = [mpath.Path(seg) for seg in _segments]

set_verts = set_segments # for compatibility with PolyCollection

set_paths = set_segments

def _add_offsets(self, segs):

offsets = self._uniform_offsets

Nsegs = len(segs)

Noffs = offsets.shape[0]

if Noffs == 1:

for i in range(Nsegs):

segs[i] = segs[i] + i * offsets

else:

for i in range(Nsegs):

io = i%Noffs

segs[i] = segs[i] + offsets[io:io+1]

return segs

def set_color(self, c):

"""

self.set_edgecolor(c)

def color(self, c):

"""

warnings.warn('LineCollection.color deprecated; use set_color instead')

return self.set_color(c)

def get_color(self):

return self._edgecolors

"""

@docstring.dedent_interpd

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

"""

Collection.__init__(self,**kwargs)

self._sizes = sizes

self.set_transform(transforms.IdentityTransform())

self._paths = [mpath.Path.unit_circle()]

def get_sizes(self):

"return sizes of circles"

return self._sizes

@allow_rasterization

def draw(self, renderer):

# sizes is the area of the circle circumscribing the polygon

# in points^2

self._transforms = [

transforms.Affine2D().scale(

(np.sqrt(x) * self.figure.dpi / 72.0) / np.sqrt(np.pi))

for x in self._sizes]

"""

@docstring.dedent_interpd

def __init__(self, widths, heights, angles, units='points', **kwargs):

"""