NORMAL = auto()

MULTIPLY = auto()

SCREEN = auto()

OVERLAY = auto()

DARKEN = auto()

LIGHTEN = auto()

COLOR_DODGE = "color dodge"

COLOR_BURN = "color burn"

HARD_LIGHT = "hard light"

SOFT_LIGHT = "soft light"

DIFFERENCE = auto()

EXCLUSION = auto()

HUE = auto()

SATURATION = auto()

COLOR = auto()

KNOCKOUT = auto()

ERASE = auto()

CLEAR = auto()

ATOP = auto()

XOR = auto()

# We assume that by default artists are not allowed to rasterize (unless

# its draw method is explicitly decorated). If it is being drawn after a

# rasterized artist and it has reached a raster_depth of 0, we stop

# rasterization so that it does not affect the behavior of normal artist

# (e.g., change in dpi).

@wraps(draw)

def draw_wrapper(artist, renderer, *args, **kwargs):

if renderer._raster_depth == 0 and renderer._rasterizing:

# Only stop when we are not in a rasterized parent

# and something has been rasterized since last stop.

renderer.stop_rasterizing()

renderer._rasterizing = False

return draw(artist, renderer, *args, **kwargs)

draw_wrapper._supports_rasterization = False

"""

@wraps(draw)

def draw_wrapper(artist, renderer):

try:

if artist.get_rasterized():

if renderer._raster_depth == 0 and not renderer._rasterizing:

renderer.start_rasterizing()

renderer._rasterizing = True

renderer._raster_depth += 1

else:

if renderer._raster_depth == 0 and renderer._rasterizing:

# Only stop when we are not in a rasterized parent

# and something has be rasterized since last stop

renderer.stop_rasterizing()

renderer._rasterizing = False

if artist.get_agg_filter() is not None:

renderer.start_filter()

return draw(artist, renderer)

finally:

if artist.get_agg_filter() is not None:

renderer.stop_filter(artist.get_agg_filter())

if artist.get_rasterized():

renderer._raster_depth -= 1

if (renderer._rasterizing and (fig := artist.get_figure(root=True)) and

fig.suppressComposite):

# restart rasterizing to prevent merging

renderer.stop_rasterizing()

renderer.start_rasterizing()

draw_wrapper._supports_rasterization = True

"""

@wraps(draw)

def draw_wrapper(artist, renderer, *args, **kwargs):

result = draw(artist, renderer, *args, **kwargs)

if renderer._rasterizing:

renderer.stop_rasterizing()

renderer._rasterizing = False

return result

"""

zorder = 0

def __init_subclass__(cls):

# Decorate draw() method so that all artists are able to stop

# rastrization when necessary. If the artist's draw method is already

# decorated (has a `_supports_rasterization` attribute), it won't be

# decorated.

if not hasattr(cls.draw, "_supports_rasterization"):

cls.draw = _prevent_rasterization(cls.draw)

# Inject custom set() methods into the subclass with signature and

# docstring based on the subclasses' properties.

if not hasattr(cls.set, '_autogenerated_signature'):

# Don't overwrite cls.set if the subclass or one of its parents

# has defined a set method set itself.

# If there was no explicit definition, cls.set is inherited from

# the hierarchy of auto-generated set methods, which hold the

# flag _autogenerated_signature.

return

cls.set = lambda self, **kwargs: Artist.set(self, **kwargs)

cls.set.__name__ = "set"

cls.set.__qualname__ = f"{cls.__qualname__}.set"

cls._update_set_signature_and_docstring()

_PROPERTIES_EXCLUDED_FROM_SET = [

'navigate_mode', # not a user-facing function

'figure', # changing the figure is such a profound operation

# that we don't want this in set()

'3d_properties', # cannot be used as a keyword due to leading digit

]

@classmethod

def _update_set_signature_and_docstring(cls):

"""

cls.set.__signature__ = Signature(

[Parameter("self", Parameter.POSITIONAL_OR_KEYWORD),

*[Parameter(prop, Parameter.KEYWORD_ONLY, default=_api.UNSET)

for prop in ArtistInspector(cls).get_setters()

if prop not in Artist._PROPERTIES_EXCLUDED_FROM_SET]])

cls.set._autogenerated_signature = True

cls.set.__doc__ = ("""\

""" + kwdoc(cls))

def __init__(self):

self._stale = True

self.stale_callback = None

self._axes = None

self._parent_figure = None

self._transform = None

self._transformSet = False

self._visible = True

self._animated = False

self._alpha = None

self._blend_mode = "normal"

self._fill_rule = "nonzero"

self.clipbox = None

self._clippath = None

self._clipon = True

self._label = ''

self._picker = None

self._rasterized = False

self._agg_filter = None

# Normally, artist classes need to be queried for mouseover info if and

# only if they override get_cursor_data.

self._mouseover = type(self).get_cursor_data != Artist.get_cursor_data

self._callbacks = cbook.CallbackRegistry(signals=["pchanged"])

try:

self.axes = None

except AttributeError:

# Handle self.axes as a read-only property, as in Figure.

pass

self._remove_method = None

self._url = None

self._gid = None

self._snap = None

self._sketch = mpl.rcParams['path.sketch']

self._path_effects = mpl.rcParams['path.effects']

self._sticky_edges = None

self._in_layout = True

self._in_autoscale = False

def __getstate__(self):

d = self.__dict__.copy()

d['stale_callback'] = None

return d

def remove(self):

"""

# There is no method to set the callback. Instead, the parent should

# set the _remove_method attribute directly. This would be a

# protected attribute if Python supported that sort of thing. The

# callback has one parameter, which is the child to be removed.

if self._remove_method is not None:

self._remove_method(self)

# clear stale callback

self.stale_callback = None

_ax_flag = False

ax = getattr(self, 'axes', None)

mouseover_set = getattr(ax, '_mouseover_set', None)

if mouseover_set is not None:

# remove from the mouse hit list

mouseover_set.discard(self)

ax.stale = True

self.axes = None # decouple the artist from the Axes

_ax_flag = True

if (fig := self.get_figure(root=False)) is not None:

if not _ax_flag:

fig.stale = True

self._parent_figure = None

else:

raise NotImplementedError('cannot remove artist')

def have_units(self):

"""Return whether units are set on any axis."""

ax = self.axes

return ax and any(axis.have_units() for axis in ax._axis_map.values())

def convert_xunits(self, x):

"""

ax = getattr(self, 'axes', None)

if ax is None or ax.xaxis is None:

return x

return ax.xaxis.convert_units(x)

def convert_yunits(self, y):

"""

ax = getattr(self, 'axes', None)

if ax is None or ax.yaxis is None:

return y

return ax.yaxis.convert_units(y)

@property

def axes(self):

"""The `~.axes.Axes` instance the artist resides in, or *None*."""

return self._axes

@axes.setter

def axes(self, new_axes):

if (new_axes is not None and self._axes is not None

and new_axes != self._axes):

raise ValueError("Can not reset the Axes. You are probably trying to reuse "

"an artist in more than one Axes which is not supported")

self._axes = new_axes

if new_axes is not None and new_axes is not self:

self.stale_callback = _stale_axes_callback

@property

def stale(self):

"""

return self._stale

@stale.setter

def stale(self, val):

self._stale = val

# if the artist is animated it does not take normal part in the

# draw stack and is not expected to be drawn as part of the normal

# draw loop (when not saving) so do not propagate this change

if self._animated:

return

if val and self.stale_callback is not None:

self.stale_callback(self, val)

def get_window_extent(self, renderer=None):

"""

return Bbox([[0, 0], [0, 0]])

def get_tightbbox(self, renderer=None):

"""

bbox = self.get_window_extent(renderer)

if self.get_clip_on():

clip_box = self.get_clip_box()

if clip_box is not None:

bbox = Bbox.intersection(bbox, clip_box)

clip_path = self.get_clip_path()

if clip_path is not None and bbox is not None:

clip_path = clip_path.get_fully_transformed_path()

bbox = Bbox.intersection(bbox, clip_path.get_extents())

return bbox

def add_callback(self, func):

"""

# Wrapping func in a lambda ensures it can be connected multiple times

# and never gets weakref-gc'ed.

return self._callbacks.connect("pchanged", lambda: func(self))

def remove_callback(self, oid):

"""

self._callbacks.disconnect(oid)

def pchanged(self):

"""

self._callbacks.process("pchanged")

def is_transform_set(self):

"""

return self._transformSet

def set_transform(self, t):

"""

self._transform = t

self._transformSet = True

self.pchanged()

self.stale = True

def get_transform(self):

"""Return the `.Transform` instance used by this artist."""

if self._transform is None:

self._transform = IdentityTransform()

elif (not isinstance(self._transform, Transform)

and hasattr(self._transform, '_as_mpl_transform')):

self._transform = self._transform._as_mpl_transform(self.axes)

return self._transform

def get_children(self):

r"""Return a list of the child `.Artist`\s of this `.Artist`."""

return []

def _different_canvas(self, event):

"""

return (getattr(event, "canvas", None) is not None

and (fig := self.get_figure(root=True)) is not None

and event.canvas is not fig.canvas)

def contains(self, mouseevent):

"""

_log.warning("%r needs 'contains' method", self.__class__.__name__)

return False, {}

def pickable(self):

"""

return self.get_figure(root=False) is not None and self._picker is not None

def pick(self, mouseevent):

"""

from .backend_bases import PickEvent # Circular import.

# Pick self

if self.pickable():

picker = self.get_picker()

if callable(picker):

inside, prop = picker(self, mouseevent)

else:

inside, prop = self.contains(mouseevent)

if inside:

PickEvent("pick_event", self.get_figure(root=True).canvas,

mouseevent, self, **prop)._process()

# Pick children

for a in self.get_children():

# make sure the event happened in the same Axes

ax = getattr(a, 'axes', None)

if (isinstance(a, mpl.figure.SubFigure)

or mouseevent.inaxes is None or ax is None

or mouseevent.inaxes == ax):

# we need to check if mouseevent.inaxes is None

# because some objects associated with an Axes (e.g., a

# tick label) can be outside the bounding box of the

# Axes and inaxes will be None

# also check that ax is None so that it traverse objects

# which do not have an axes property but children might

a.pick(mouseevent)

def set_picker(self, picker):

"""

self._picker = picker

def get_picker(self):

"""

return self._picker

def get_url(self):

"""Return the url."""

return self._url

def set_url(self, url):

"""

self._url = url

def get_gid(self):

"""Return the group id."""

return self._gid

def set_gid(self, gid):

"""

self._gid = gid

def get_snap(self):

"""

if mpl.rcParams['path.snap']:

return self._snap

else:

return False

def set_snap(self, snap):

"""

self._snap = snap

self.stale = True

def get_sketch_params(self):

"""

return self._sketch

def set_sketch_params(self, scale=None, length=None, randomness=None):

"""

if scale is None:

self._sketch = None

else:

self._sketch = (scale, length or 128.0, randomness or 16.0)

self.stale = True

def set_path_effects(self, path_effects):

"""

self._path_effects = path_effects

self.stale = True

def get_path_effects(self):

return self._path_effects

def get_figure(self, root=False):

"""

if root and self._parent_figure is not None:

return self._parent_figure.get_figure(root=True)

return self._parent_figure

def set_figure(self, fig):

"""

# if this is a no-op just return

if self._parent_figure is fig:

return

# if we currently have a figure (the case of both `self.figure`

# and *fig* being none is taken care of above) we then user is

# trying to change the figure an artist is associated with which

# is not allowed for the same reason as adding the same instance

# to more than one Axes

if self._parent_figure is not None:

raise RuntimeError("Can not put single artist in "

"more than one figure")

self._parent_figure = fig

if self._parent_figure and self._parent_figure is not self:

self.pchanged()

self.stale = True

figure = property(get_figure, set_figure,

doc=("The (Sub)Figure that the artist is on. For more "

"control, use the `get_figure` method."))

def set_clip_box(self, clipbox):

"""

_api.check_isinstance((BboxBase, None), clipbox=clipbox)

if clipbox != self.clipbox:

self.clipbox = clipbox

self.pchanged()

self.stale = True

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

"""

from matplotlib.patches import Patch, Rectangle

success = False

if transform is None:

if isinstance(path, Rectangle):

self.clipbox = TransformedBbox(Bbox.unit(),

path.get_transform())

self._clippath = None

success = True

elif isinstance(path, Patch):

self._clippath = TransformedPatchPath(path)

success = True

elif isinstance(path, tuple):

path, transform = path

if path is None:

self._clippath = None

success = True

elif isinstance(path, Path):

self._clippath = TransformedPath(path, transform)

success = True

elif isinstance(path, TransformedPatchPath):

self._clippath = path

success = True

elif isinstance(path, TransformedPath):

self._clippath = path

success = True

if not success:

raise TypeError(

"Invalid arguments to set_clip_path, of type "

f"{type(path).__name__} and {type(transform).__name__}")

# This may result in the callbacks being hit twice, but guarantees they

# will be hit at least once.

self.pchanged()

self.stale = True

def get_alpha(self):

"""

return self._alpha

def get_visible(self):

"""Return the visibility."""

return self._visible

def get_animated(self):

"""Return whether the artist is animated."""

return self._animated

def get_in_layout(self):

"""

return self._in_layout

def _get_in_autoscale(self):

"""

return self._in_autoscale

def _fully_clipped_to_axes(self):

"""

# Note that ``clip_path.get_fully_transformed_path().get_extents()``

# cannot be directly compared to ``axes.bbox.extents`` because the

# extents may be undefined (i.e. equivalent to ``Bbox.null()``)

# before the associated artist is drawn, and this method is meant

# to determine whether ``axes.get_tightbbox()`` may bypass drawing

clip_box = self.get_clip_box()

clip_path = self.get_clip_path()

return (self.axes is not None

and self.get_clip_on()

and (clip_box is not None or clip_path is not None)

and (clip_box is None

or np.all(clip_box.extents == self.axes.bbox.extents))

and (clip_path is None

or isinstance(clip_path, TransformedPatchPath)

and clip_path._patch is self.axes.patch))

def get_clip_on(self):

"""Return whether the artist uses clipping."""

return self._clipon

def get_clip_box(self):

"""Return the clipbox."""

return self.clipbox

def get_clip_path(self):

"""Return the clip path."""