"""

@contextmanager

def with_rasterized(artist, renderer):

if artist.get_rasterized():

renderer.start_rasterizing()

if artist.get_agg_filter() is not None:

renderer.start_filter()

try:

yield

finally:

if artist.get_agg_filter() is not None:

renderer.stop_filter(artist.get_agg_filter())

if artist.get_rasterized():

renderer.stop_rasterizing()

# the axes class has a second argument inframe for its draw method.

@wraps(draw)

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

with with_rasterized(artist, renderer):

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

draw_wrapper._supports_rasterization = True

"""

aname = 'Artist'

zorder = 0

# order of precedence when bulk setting/updating properties

# via update. The keys should be property names and the values

# integers

_prop_order = dict(color=-1)

def __init__(self):

self._stale = True

self.stale_callback = None

self._axes = None

self.figure = None

self._transform = None

self._transformSet = False

self._visible = True

self._animated = False

self._alpha = None

self.clipbox = None

self._clippath = None

self._clipon = True

self._label = ''

self._picker = None

self._contains = None

self._rasterized = None

self._agg_filter = None

self._mouseover = False

self.eventson = False # fire events only if eventson

self._oid = 0 # an observer id

self._propobservers = {} # a dict from oids to funcs

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 = rcParams['path.sketch']

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

self._margins = {}

def __getstate__(self):

d = self.__dict__.copy()

# remove the unpicklable remove method, this will get re-added on load

# (by the axes) if the artist lives on an axes.

d['_remove_method'] = None

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

if hasattr(self, 'axes') and self.axes:

# remove from the mouse hit list

self.axes.mouseover_set.discard(self)

# mark the axes as stale

self.axes.stale = True

# decouple the artist from the axes

self.axes = None

_ax_flag = True

if self.figure:

self.figure = None

if not _ax_flag:

self.figure = True

else:

raise NotImplementedError('cannot remove artist')

# TODO: the fix for the collections relim problem is to move the

# limits calculation into the artist itself, including the property of

# whether or not the artist should affect the limits. Then there will

# be no distinction between axes.add_line, axes.add_patch, etc.

# TODO: add legend support

def have_units(self):

'Return *True* if units are set on the *x* or *y* axes'

ax = self.axes

if ax is None or ax.xaxis is None:

return False

return ax.xaxis.have_units() or ax.yaxis.have_units()

def convert_xunits(self, x):

"""For artists in an axes, if the xaxis has units support,

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

"""For artists in an axes, if the yaxis has units support,

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

if ax is None or ax.yaxis is None:

return y

return ax.yaxis.convert_units(y)

def set_axes(self, axes):

"""

warnings.warn(_get_axes_msg.format('set_axes'), mplDeprecation,

stacklevel=1)

self.axes = axes

def get_axes(self):

"""

warnings.warn(_get_axes_msg.format('get_axes'), mplDeprecation,

stacklevel=1)

return self.axes

@property

def axes(self):

"""

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 re-use 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

return new_axes

@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.get_animated():

return

if val and self.stale_callback is not None:

self.stale_callback(self, val)

def get_window_extent(self, renderer):

"""

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

def add_callback(self, func):

"""

oid = self._oid

self._propobservers[oid] = func

self._oid += 1

return oid

def remove_callback(self, oid):

"""

try:

del self._propobservers[oid]

except KeyError:

pass

def pchanged(self):

"""

for oid, func in six.iteritems(self._propobservers):

func(self)

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

"""

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 hitlist(self, event):

"""

L = []

try:

hascursor, info = self.contains(event)

if hascursor:

L.append(self)

except:

import traceback

traceback.print_exc()

print("while checking", self.__class__)

for a in self.get_children():

L.extend(a.hitlist(event))

return L

def get_children(self):

"""

return []

def contains(self, mouseevent):

"""Test whether the artist contains the mouse event.

if six.callable(self._contains):

return self._contains(self, mouseevent)

warnings.warn("'%s' needs 'contains' method" % self.__class__.__name__)

return False, {}

def set_contains(self, picker):

"""

self._contains = picker

def get_contains(self):

"""

return self._contains

def pickable(self):

'Return *True* if :class:`Artist` is pickable.'

return (self.figure is not None and

self.figure.canvas is not None and

self._picker is not None)

def pick(self, mouseevent):

"""

# Pick self

if self.pickable():

picker = self.get_picker()

if six.callable(picker):

inside, prop = picker(self, mouseevent)

else:

inside, prop = self.contains(mouseevent)

if inside:

self.figure.canvas.pick_event(mouseevent, self, **prop)

# Pick children

for a in self.get_children():

# make sure the event happened in the same axes

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

if 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 no have an axes property but children might

a.pick(mouseevent)

def set_picker(self, picker):

"""

self._picker = picker

def get_picker(self):

'Return the picker object used by this artist'

return self._picker

def is_figure_set(self):

"""

return self.figure is not None

def get_url(self):

"""

return self._url

def set_url(self, url):

"""

self._url = url

def get_gid(self):

"""

return self._gid

def set_gid(self, gid):

"""

self._gid = gid

def get_snap(self):

"""

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

"""

return self.figure

def set_figure(self, fig):

"""

# if this is a no-op just return

if self.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.figure is not None:

raise RuntimeError("Can not put single artist in "

"more than one figure")

self.figure = fig

if self.figure and self.figure is not self:

self.pchanged()

self.stale = True

def set_clip_box(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:

print(type(path), type(transform))

raise TypeError("Invalid arguments to set_clip_path")

# this may result in the callbacks being hit twice, but grantees 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 artist's visiblity"

return self._visible

def get_animated(self):

"Return the artist's animated state"

return self._animated

def get_clip_on(self):

'Return whether artist uses clipping'

return self._clipon

def get_clip_box(self):

'Return artist clipbox'

return self.clipbox

def get_clip_path(self):

'Return artist clip path'

return self._clippath

def get_transformed_clip_path_and_affine(self):

'''

if self._clippath is not None:

return self._clippath.get_transformed_path_and_affine()

return None, None

def set_clip_on(self, b):

"""

self._clipon = b

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

# are hit at least once

self.pchanged()

self.stale = True

def _set_gc_clip(self, gc):

'Set the clip properly for the gc'

if self._clipon:

if self.clipbox is not None:

gc.set_clip_rectangle(self.clipbox)

gc.set_clip_path(self._clippath)

else:

gc.set_clip_rectangle(None)

gc.set_clip_path(None)

def get_rasterized(self):

"return True if the artist is to be rasterized"

return self._rasterized

def set_rasterized(self, rasterized):

"""

if rasterized and not hasattr(self.draw, "_supports_rasterization"):

warnings.warn("Rasterization of '%s' will be ignored" % self)

self._rasterized = rasterized

def get_agg_filter(self):

"return filter function to be used for agg filter"

return self._agg_filter

def set_agg_filter(self, filter_func):

"""

self._agg_filter = filter_func

self.stale = True

def draw(self, renderer, *args, **kwargs):

'Derived classes drawing method'

if not self.get_visible():

return

self.stale = False

def set_alpha(self, alpha):

"""

self._alpha = alpha

self.pchanged()

self.stale = True

def set_visible(self, b):

"""

self._visible = b

self.pchanged()

self.stale = True

def set_animated(self, b):

"""

if self._animated != b:

self._animated = b

self.pchanged()

def update(self, props):

"""

def _update_property(self, k, v):

"""sorting out how to update property (setter or setattr)

k = k.lower()

# white list attributes we want to be able to update through

# art.update, art.set, setp

if k in {'axes'}:

return setattr(self, k, v)

else:

func = getattr(self, 'set_' + k, None)

if func is None or not six.callable(func):

raise AttributeError('Unknown property %s' % k)

return func(v)

store = self.eventson

self.eventson = False

try:

ret = [_update_property(self, k, v)

for k, v in props.items()]

finally:

self.eventson = store

if len(ret):

self.pchanged()

self.stale = True

return ret

def get_label(self):

"""

return self._label

def set_label(self, s):

"""

if s is not None:

self._label = '%s' % (s, )

else:

self._label = None

self.pchanged()

self.stale = True

def get_zorder(self):

"""

return self.zorder

def set_zorder(self, level):

"""

self.zorder = level

self.pchanged()

self.stale = True

def get_top_margin(self):

"""

return self._margins.get('top', True)

def set_top_margin(self, margin):

"""

if margin != self._margins.get('top', True):

self.stale = True

self._margins['top'] = margin

top_margin = property(get_top_margin, set_top_margin)

def get_bottom_margin(self):

"""

return self._margins.get('bottom', True)

def set_bottom_margin(self, margin):

"""

if margin != self._margins.get('bottom', True):

self.stale = True

self._margins['bottom'] = margin

bottom_margin = property(get_bottom_margin, set_bottom_margin)

def get_left_margin(self):

"""

return self._margins.get('left', True)

def set_left_margin(self, margin):

"""

if margin != self._margins.get('left', True):

self.stale = True

self._margins['left'] = margin

left_margin = property(get_left_margin, set_left_margin)

def get_right_margin(self):

"""

return self._margins.get('right', True)

def set_right_margin(self, margin):

"""

if margin != self._margins.get('right', True):

self.stale = True

self._margins['right'] = margin

right_margin = property(get_right_margin, set_right_margin)

def get_margins(self):

"""

return self._margins