"""

_offsets = np.zeros((0, 2))

_transOffset = transforms.IdentityTransform()

#: Either a list of 3x3 arrays or an Nx3x3 array of transforms, suitable

#: for the `all_transforms` argument to

#: `~matplotlib.backend_bases.RendererBase.draw_path_collection`;

#: each 3x3 array is used to initialize an

#: `~matplotlib.transforms.Affine2D` object.

#: Each kind of collection defines this based on its arguments.

_transforms = np.empty((0, 3, 3))

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

# subclass-by-subclass basis.

_edge_default = False

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

def __init__(self,

edgecolors=None,

facecolors=None,

linewidths=None,

linestyles='solid',

capstyle=None,

joinstyle=None,

antialiaseds=None,

offsets=None,

transOffset=None,

norm=None, # optional for ScalarMappable

cmap=None, # ditto

pickradius=5.0,

hatch=None,

urls=None,

offset_position='screen',

zorder=1,

**kwargs

):

"""

artist.Artist.__init__(self)

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

# list of un-scaled dash patterns

# this is needed scaling the dash pattern by linewidth

self._us_linestyles = [(0, None)]

# list of dash patterns

self._linestyles = [(0, None)]

# list of unbroadcast/scaled linewidths

self._us_lw = [0]

self._linewidths = [0]

self._is_filled = True # May be modified by set_facecolor().

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

self.set_facecolor(facecolors)

self.set_edgecolor(edgecolors)

self.set_linewidth(linewidths)

self.set_linestyle(linestyles)

self.set_antialiased(antialiaseds)

self.set_pickradius(pickradius)

self.set_urls(urls)

self.set_hatch(hatch)

self._offset_position = "screen"

if offset_position != "screen":

self.set_offset_position(offset_position) # emit deprecation.

self.set_zorder(zorder)

if capstyle:

self.set_capstyle(capstyle)

else:

self._capstyle = None

if joinstyle:

self.set_joinstyle(joinstyle)

else:

self._joinstyle = None

self._offsets = np.zeros((1, 2))

# save if offsets passed in were none...

self._offsetsNone = offsets is None

self._uniform_offsets = None

if offsets is not None:

offsets = np.asanyarray(offsets, float)

# Broadcast (2,) -> (1, 2) but nothing else.

if offsets.shape == (2,):

offsets = offsets[None, :]

if transOffset is not None:

self._offsets = offsets

self._transOffset = transOffset

else:

self._uniform_offsets = offsets

self._path_effects = None

self.update(kwargs)

self._paths = None

def get_paths(self):

return self._paths

def set_paths(self):

raise NotImplementedError

def get_transforms(self):

return self._transforms

def get_offset_transform(self):

t = self._transOffset

if (not isinstance(t, transforms.Transform)

and hasattr(t, '_as_mpl_transform')):

t = t._as_mpl_transform(self.axes)

return t

def get_datalim(self, transData):

# Get the automatic datalim of the collection.

#

# This operation depends on the transforms for the data in the

# collection and whether the collection has offsets.

#

# 1) offsets = None, transform child of transData: use the paths for

# the automatic limits (i.e. for LineCollection in streamline).

# 2) offsets != None: offset_transform is child of transData:

# a) transform is child of transData: use the path + offset for

# limits (i.e for bar).

# b) transform is not a child of transData: just use the offsets

# for the limits (i.e. for scatter)

# 3) otherwise return a null Bbox.

transform = self.get_transform()

transOffset = self.get_offset_transform()

if (not self._offsetsNone and

not transOffset.contains_branch(transData)):

# if there are offsets but in some coords other than data,

# then don't use them for autoscaling.

return transforms.Bbox.null()

offsets = self._offsets

paths = self.get_paths()

if not transform.is_affine:

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

# Don't convert transform to transform.get_affine() here because

# we may have transform.contains_branch(transData) but not

# transforms.get_affine().contains_branch(transData). But later,

# be careful to only apply the affine part that remains.

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

offsets = offsets.filled(np.nan)

# get_path_collection_extents handles nan but not masked arrays

if len(paths) and len(offsets):

if any(transform.contains_branch_seperately(transData)):

# collections that are just in data units (like quiver)

# can properly have the axes limits set by their shape +

# offset. LineCollections that have no offsets can

# also use this algorithm (like streamplot).

result = mpath.get_path_collection_extents(

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

transOffset.transform_non_affine(offsets),

transOffset.get_affine().frozen())

return result.transformed(transData.inverted())

if not self._offsetsNone:

# this is for collections that have their paths (shapes)

# in physical, axes-relative, or figure-relative units

# (i.e. like scatter). We can't uniquely set limits based on

# those shapes, so we just set the limits based on their

# location.

offsets = (transOffset - transData).transform(offsets)

# note A-B means A B^{-1}

offsets = np.ma.masked_invalid(offsets)

if not offsets.mask.all():

points = np.row_stack((offsets.min(axis=0),

offsets.max(axis=0)))

return transforms.Bbox(points)

return transforms.Bbox.null()

def get_window_extent(self, renderer):

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

# cases other than scatter plot legend

return self.get_datalim(transforms.IdentityTransform())

def _prepare_points(self):

# Helper for drawing and hit testing.

transform = self.get_transform()

transOffset = self.get_offset_transform()

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(np.column_stack([xs, ys]), path.codes))

if offsets.size:

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

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

offsets = np.column_stack([xs, ys])

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 isinstance(offsets, np.ma.MaskedArray):

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

@artist.allow_rasterization

def draw(self, renderer):

if not self.get_visible():

return

renderer.open_group(self.__class__.__name__, self.get_gid())

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

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)

# If the collection is made up of a single shape/color/stroke,

# it can be rendered once and blitted multiple times, using

# `draw_markers` rather than `draw_path_collection`. This is

# *much* faster for Agg, and results in smaller file sizes in

# PDF/SVG/PS.

trans = self.get_transforms()

facecolors = self.get_facecolor()

edgecolors = self.get_edgecolor()

do_single_path_optimization = False

if (len(paths) == 1 and len(trans) <= 1 and

len(facecolors) == 1 and len(edgecolors) == 1 and

len(self._linewidths) == 1 and

all(ls[1] is None for ls in self._linestyles) and

len(self._antialiaseds) == 1 and len(self._urls) == 1 and

self.get_hatch() is None):

if len(trans):

combined_transform = transforms.Affine2D(trans[0]) + transform

else:

combined_transform = transform

extents = paths[0].get_extents(combined_transform)

if (extents.width < self.figure.bbox.width

and extents.height < self.figure.bbox.height):

do_single_path_optimization = True

if self._joinstyle:

gc.set_joinstyle(self._joinstyle)

if self._capstyle:

gc.set_capstyle(self._capstyle)

if do_single_path_optimization:

gc.set_foreground(tuple(edgecolors[0]))

gc.set_linewidth(self._linewidths[0])

gc.set_dashes(*self._linestyles[0])

gc.set_antialiased(self._antialiaseds[0])

gc.set_url(self._urls[0])

renderer.draw_markers(

gc, paths[0], combined_transform.frozen(),

mpath.Path(offsets), transOffset, tuple(facecolors[0]))

else:

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,

self._offset_position)

gc.restore()

renderer.close_group(self.__class__.__name__)

self.stale = False

def set_pickradius(self, pr):

"""

self._pickradius = pr

def get_pickradius(self):

return self._pickradius

def contains(self, mouseevent):

"""

inside, info = self._default_contains(mouseevent)

if inside is not None:

return inside, info

if not self.get_visible():

return False, {}

pickradius = (

float(self._picker)

if isinstance(self._picker, Number) and

self._picker is not True # the bool, not just nonzero or 1

else self._pickradius)

if self.axes:

self.axes._unstale_viewLim()

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

ind = _path.point_in_path_collection(

mouseevent.x, mouseevent.y, pickradius,

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

offsets, transOffset, pickradius <= 0,

self._offset_position)

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

def set_urls(self, urls):

"""

self._urls = urls if urls is not None else [None]

self.stale = True

def get_urls(self):

return self._urls

def set_hatch(self, hatch):

r"""

self._hatch = hatch

self.stale = True

def get_hatch(self):

"""Return the current hatching pattern."""

return self._hatch

def set_offsets(self, offsets):

"""

offsets = np.asanyarray(offsets, float)

if offsets.shape == (2,): # Broadcast (2,) -> (1, 2) but nothing else.

offsets = offsets[None, :]

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

if self._uniform_offsets is None:

self._offsets = offsets

else:

self._uniform_offsets = offsets

self.stale = True

def get_offsets(self):

"""Return the offsets for the collection."""

# 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

@cbook.deprecated("3.3")

def set_offset_position(self, offset_position):

"""

cbook._check_in_list(['screen', 'data'],

offset_position=offset_position)

self._offset_position = offset_position

self.stale = True

@cbook.deprecated("3.3")

def get_offset_position(self):

"""

return self._offset_position

def set_linewidth(self, lw):

"""

if lw is None:

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

if lw is None:

lw = mpl.rcParams['lines.linewidth']

# get the un-scaled/broadcast lw

self._us_lw = np.atleast_1d(np.asarray(lw))

# scale all of the dash patterns.

self._linewidths, self._linestyles = self._bcast_lwls(

self._us_lw, self._us_linestyles)

self.stale = True

def set_linestyle(self, ls):

"""

try:

if isinstance(ls, str):

ls = cbook.ls_mapper.get(ls, ls)

dashes = [mlines._get_dash_pattern(ls)]

else:

try:

dashes = [mlines._get_dash_pattern(ls)]

except ValueError:

dashes = [mlines._get_dash_pattern(x) for x in ls]

except ValueError as err:

raise ValueError('Do not know how to convert {!r} to '

'dashes'.format(ls)) from err

# get the list of raw 'unscaled' dash patterns

self._us_linestyles = dashes

# broadcast and scale the lw and dash patterns

self._linewidths, self._linestyles = self._bcast_lwls(

self._us_lw, self._us_linestyles)

def set_capstyle(self, cs):

"""

mpl.rcsetup.validate_capstyle(cs)

self._capstyle = cs

def get_capstyle(self):

return self._capstyle

def set_joinstyle(self, js):

"""

mpl.rcsetup.validate_joinstyle(js)

self._joinstyle = js

def get_joinstyle(self):

return self._joinstyle

@staticmethod

def _bcast_lwls(linewidths, dashes):

"""

if mpl.rcParams['_internal.classic_mode']:

return linewidths, dashes

# make sure they are the same length so we can zip them

if len(dashes) != len(linewidths):

l_dashes = len(dashes)

l_lw = len(linewidths)

gcd = math.gcd(l_dashes, l_lw)

dashes = list(dashes) * (l_lw // gcd)

linewidths = list(linewidths) * (l_dashes // gcd)

# scale the dash patters

dashes = [mlines._scale_dashes(o, d, lw)

for (o, d), lw in zip(dashes, linewidths)]

return linewidths, dashes

def set_antialiased(self, aa):

"""

if aa is None:

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

self._antialiaseds = np.atleast_1d(np.asarray(aa, bool))

self.stale = True

def set_color(self, c):

"""

self.set_facecolor(c)

self.set_edgecolor(c)

def _set_facecolor(self, c):

if c is None:

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

self._is_filled = True

try:

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

self._is_filled = False

except AttributeError:

pass

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

self.stale = True

def set_facecolor(self, c):

"""

self._original_facecolor = c

self._set_facecolor(c)

def get_facecolor(self):

return self._facecolors

def get_edgecolor(self):

if cbook._str_equal(self._edgecolors, 'face'):

return self.get_facecolor()

else:

return self._edgecolors

def _set_edgecolor(self, c):

set_hatch_color = True

if c is None:

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

not self._is_filled or self._edge_default):

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

else:

c = 'none'

set_hatch_color = False

self._is_stroked = True

try:

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

self._is_stroked = False

except AttributeError:

pass

try:

if c.lower() == 'face': # Special case: lookup in "get" method.

self._edgecolors = 'face'

return

except AttributeError:

pass

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

if set_hatch_color and len(self._edgecolors):

self._hatch_color = tuple(self._edgecolors[0])

self.stale = True

def set_edgecolor(self, c):

"""

self._original_edgecolor = c

self._set_edgecolor(c)

def set_alpha(self, alpha):

# docstring inherited

super().set_alpha(alpha)

self._update_dict['array'] = True

self._set_facecolor(self._original_facecolor)

self._set_edgecolor(self._original_edgecolor)

def get_linewidth(self):

return self._linewidths

def get_linestyle(self):

return self._linestyles

def update_scalarmappable(self):

"""Update colors from the scalar mappable array, if it is not None."""

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)

self.stale = True

def get_fill(self):

"""Return whether fill is set."""

return self._is_filled

def update_from(self, other):

"""Copy properties from other to self."""

artist.Artist.update_from(self, other)

self._antialiaseds = other._antialiaseds

self._original_edgecolor = other._original_edgecolor

self._edgecolors = other._edgecolors

self._original_facecolor = other._original_facecolor

self._facecolors = other._facecolors

self._linewidths = other._linewidths

self._linestyles = other._linestyles

self._us_linestyles = other._us_linestyles

self._pickradius = other._pickradius

self._hatch = other._hatch

# update_from for scalarmappable

self._A = other._A

self.norm = other.norm

self.cmap = other.cmap

# do we need to copy self._update_dict? -JJL

"""

_factor = 1.0

def get_sizes(self):

"""

return self._sizes

def set_sizes(self, sizes, dpi=72.0):

"""

if sizes is None:

self._sizes = np.array([])

self._transforms = np.empty((0, 3, 3))

else:

self._sizes = np.asarray(sizes)

self._transforms = np.zeros((len(self._sizes), 3, 3))

scale = np.sqrt(self._sizes) * dpi / 72.0 * self._factor

self._transforms[:, 0, 0] = scale

self._transforms[:, 1, 1] = scale

self._transforms[:, 2, 2] = 1.0

self.stale = True

@artist.allow_rasterization

def draw(self, renderer):

self.set_sizes(self._sizes, self.figure.dpi)

"""

@docstring.dedent_interpd

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

"""

Collection.__init__(self, **kwargs)

self.set_paths(paths)

self.set_sizes(sizes)

self.stale = True

def set_paths(self, paths):

self._paths = paths

self.stale = True

def get_paths(self):

return self._paths

def legend_elements(self, prop="colors", num="auto",

fmt=None, func=lambda x: x, **kwargs):

"""

handles = []

labels = []

hasarray = self.get_array() is not None

if fmt is None:

fmt = mpl.ticker.ScalarFormatter(useOffset=False, useMathText=True)

elif isinstance(fmt, str):

fmt = mpl.ticker.StrMethodFormatter(fmt)

fmt.create_dummy_axis()

if prop == "colors":

if not hasarray:

warnings.warn("Collection without array used. Make sure to "

"specify the values to be colormapped via the "

"`c` argument.")

return handles, labels

u = np.unique(self.get_array())

size = kwargs.pop("size", mpl.rcParams["lines.markersize"])

elif prop == "sizes":

u = np.unique(self.get_sizes())

color = kwargs.pop("color", "k")

else:

raise ValueError("Valid values for `prop` are 'colors' or "

f"'sizes'. You supplied '{prop}' instead.")

fmt.set_bounds(func(u).min(), func(u).max())

if num == "auto":

num = 9

if len(u) <= num:

num = None

if num is None:

values = u

label_values = func(values)