"""

linestyle = None

marker = None

color = None

# Is fmt just a colorspec?

try:

color = mcolors.to_rgba(fmt)

# We need to differentiate grayscale '1.0' from tri_down marker '1'

try:

fmtint = str(int(fmt))

except ValueError:

return linestyle, marker, color # Yes

else:

if fmt != fmtint:

# user definitely doesn't want tri_down marker

return linestyle, marker, color # Yes

else:

# ignore converted color

color = None

except ValueError:

pass # No, not just a color.

# handle the multi char special cases and strip them from the

# string

if fmt.find('--') >= 0:

linestyle = '--'

fmt = fmt.replace('--', '')

if fmt.find('-.') >= 0:

linestyle = '-.'

fmt = fmt.replace('-.', '')

if fmt.find(' ') >= 0:

linestyle = 'None'

fmt = fmt.replace(' ', '')

chars = [c for c in fmt]

i = 0

while i < len(chars):

c = chars[i]

if c in mlines.lineStyles:

if linestyle is not None:

raise ValueError(

'Illegal format string "%s"; two linestyle symbols' % fmt)

linestyle = c

elif c in mlines.lineMarkers:

if marker is not None:

raise ValueError(

'Illegal format string "%s"; two marker symbols' % fmt)

marker = c

elif c in mcolors.get_named_colors_mapping():

if color is not None:

raise ValueError(

'Illegal format string "%s"; two color symbols' % fmt)

color = c

elif c == 'C' and i < len(chars) - 1:

color_cycle_number = int(chars[i + 1])

color = mcolors.to_rgba("C{}".format(color_cycle_number))

i += 1

else:

raise ValueError(

'Unrecognized character %c in format string' % c)

i += 1

if linestyle is None and marker is None:

linestyle = rcParams['lines.linestyle']

if linestyle is None:

linestyle = 'None'

if marker is None:

marker = 'None'

"""

def __init__(self, axes, command='plot'):

self.axes = axes

self.command = command

self.set_prop_cycle()

def __getstate__(self):

# note: it is not possible to pickle a itertools.cycle instance

return {'axes': self.axes, 'command': self.command}

def __setstate__(self, state):

self.__dict__ = state.copy()

self.set_prop_cycle()

def set_prop_cycle(self, *args, **kwargs):

if not (args or kwargs) or (len(args) == 1 and args[0] is None):

prop_cycler = rcParams['axes.prop_cycle']

if prop_cycler is None and 'axes.color_cycle' in rcParams:

clist = rcParams['axes.color_cycle']

prop_cycler = cycler('color', clist)

else:

prop_cycler = cycler(*args, **kwargs)

# Make sure the cycler always has at least one color

if 'color' not in prop_cycler.keys:

prop_cycler = prop_cycler * cycler('color', ['k'])

self.prop_cycler = itertools.cycle(prop_cycler)

# This should make a copy

self._prop_keys = prop_cycler.keys

def __call__(self, *args, **kwargs):

if self.axes.xaxis is not None and self.axes.yaxis is not None:

xunits = kwargs.pop('xunits', self.axes.xaxis.units)

if self.axes.name == 'polar':

xunits = kwargs.pop('thetaunits', xunits)

yunits = kwargs.pop('yunits', self.axes.yaxis.units)

if self.axes.name == 'polar':

yunits = kwargs.pop('runits', yunits)

if xunits != self.axes.xaxis.units:

self.axes.xaxis.set_units(xunits)

if yunits != self.axes.yaxis.units:

self.axes.yaxis.set_units(yunits)

ret = self._grab_next_args(*args, **kwargs)

return ret

def get_next_color(self):

"""

return six.next(self.prop_cycler)['color']

def set_lineprops(self, line, **kwargs):

assert self.command == 'plot', 'set_lineprops only works with "plot"'

line.set(**kwargs)

def set_patchprops(self, fill_poly, **kwargs):

assert self.command == 'fill', 'set_patchprops only works with "fill"'

fill_poly.set(**kwargs)

def _xy_from_xy(self, x, y):

if self.axes.xaxis is not None and self.axes.yaxis is not None:

bx = self.axes.xaxis.update_units(x)

by = self.axes.yaxis.update_units(y)

if self.command != 'plot':

# the Line2D class can handle unitized data, with

# support for post hoc unit changes etc. Other mpl

# artists, e.g., Polygon which _process_plot_var_args

# also serves on calls to fill, cannot. So this is a

# hack to say: if you are not "plot", which is

# creating Line2D, then convert the data now to

# floats. If you are plot, pass the raw data through

# to Line2D which will handle the conversion. So

# polygons will not support post hoc conversions of

# the unit type since they are not storing the orig

# data. Hopefully we can rationalize this at a later

# date - JDH

if bx:

x = self.axes.convert_xunits(x)

if by:

y = self.axes.convert_yunits(y)

# like asanyarray, but converts scalar to array, and doesn't change

# existing compatible sequences

x = _check_1d(x)

y = _check_1d(y)

if x.shape[0] != y.shape[0]:

raise ValueError("x and y must have same first dimension, but "

"have shapes {} and {}".format(x.shape, y.shape))

if x.ndim > 2 or y.ndim > 2:

raise ValueError("x and y can be no greater than 2-D, but have "

"shapes {} and {}".format(x.shape, y.shape))

if x.ndim == 1:

x = x[:, np.newaxis]

if y.ndim == 1:

y = y[:, np.newaxis]

return x, y

def _getdefaults(self, ignore, *kwargs):

"""

prop_keys = self._prop_keys

if ignore is None:

ignore = set([])

prop_keys = prop_keys - ignore

if any(all(kw.get(k, None) is None for kw in kwargs)

for k in prop_keys):

# Need to copy this dictionary or else the next time around

# in the cycle, the dictionary could be missing entries.

default_dict = six.next(self.prop_cycler).copy()

for p in ignore:

default_dict.pop(p, None)

else:

default_dict = {}

return default_dict

def _setdefaults(self, defaults, *kwargs):

"""

for k in defaults:

if all(kw.get(k, None) is None for kw in kwargs):

for kw in kwargs:

kw[k] = defaults[k]

def _makeline(self, x, y, kw, kwargs):

kw = kw.copy() # Don't modify the original kw.

kwargs = kwargs.copy()

default_dict = self._getdefaults(None, kw, kwargs)

self._setdefaults(default_dict, kw, kwargs)

seg = mlines.Line2D(x, y, **kw)

self.set_lineprops(seg, **kwargs)

return seg

def _makefill(self, x, y, kw, kwargs):

kw = kw.copy() # Don't modify the original kw.

kwargs = kwargs.copy()

# Ignore 'marker'-related properties as they aren't Polygon

# properties, but they are Line2D properties, and so they are

# likely to appear in the default cycler construction.

# This is done here to the defaults dictionary as opposed to the

# other two dictionaries because we do want to capture when a

# *user* explicitly specifies a marker which should be an error.

# We also want to prevent advancing the cycler if there are no

# defaults needed after ignoring the given properties.

ignores = set(['marker', 'markersize', 'markeredgecolor',

'markerfacecolor', 'markeredgewidth'])

# Also ignore anything provided by *kwargs*.

for k, v in six.iteritems(kwargs):

if v is not None:

ignores.add(k)

# Only using the first dictionary to use as basis

# for getting defaults for back-compat reasons.

# Doing it with both seems to mess things up in

# various places (probably due to logic bugs elsewhere).

default_dict = self._getdefaults(ignores, kw)

self._setdefaults(default_dict, kw)

# Looks like we don't want "color" to be interpreted to

# mean both facecolor and edgecolor for some reason.

# So the "kw" dictionary is thrown out, and only its

# 'color' value is kept and translated as a 'facecolor'.

# This design should probably be revisited as it increases

# complexity.

facecolor = kw.get('color', None)

# Throw out 'color' as it is now handled as a facecolor

default_dict.pop('color', None)

# To get other properties set from the cycler

# modify the kwargs dictionary.

self._setdefaults(default_dict, kwargs)

seg = mpatches.Polygon(np.hstack((x[:, np.newaxis],

y[:, np.newaxis])),

facecolor=facecolor,

fill=kwargs.get('fill', True),

closed=kw['closed'])

self.set_patchprops(seg, **kwargs)

return seg

def _plot_args(self, tup, kwargs):

ret = []

if len(tup) > 1 and is_string_like(tup[-1]):

linestyle, marker, color = _process_plot_format(tup[-1])

tup = tup[:-1]

elif len(tup) == 3:

raise ValueError('third arg must be a format string')

else:

linestyle, marker, color = None, None, None

# Don't allow any None value; These will be up-converted

# to one element array of None which causes problems

# downstream.

if any(v is None for v in tup):

raise ValueError("x and y must not be None")

kw = {}

for k, v in zip(('linestyle', 'marker', 'color'),

(linestyle, marker, color)):

if v is not None:

kw[k] = v

if 'label' not in kwargs or kwargs['label'] is None:

kwargs['label'] = get_label(tup[-1], None)

if len(tup) == 2:

x = _check_1d(tup[0])

y = _check_1d(tup[-1])

else:

x, y = index_of(tup[-1])

x, y = self._xy_from_xy(x, y)

if self.command == 'plot':

func = self._makeline

else:

kw['closed'] = kwargs.get('closed', True)

func = self._makefill

ncx, ncy = x.shape[1], y.shape[1]

for j in xrange(max(ncx, ncy)):

seg = func(x[:, j % ncx], y[:, j % ncy], kw, kwargs)

ret.append(seg)

return ret

def _grab_next_args(self, *args, **kwargs):

remaining = args

while 1:

if len(remaining) == 0:

return

if len(remaining) <= 3:

for seg in self._plot_args(remaining, kwargs):

yield seg

return

if is_string_like(remaining[2]):

isplit = 3

else:

isplit = 2

for seg in self._plot_args(remaining[:isplit], kwargs):

yield seg

"""

name = "rectilinear"

_shared_x_axes = cbook.Grouper()

_shared_y_axes = cbook.Grouper()

def __str__(self):

return "Axes(%g,%g;%gx%g)" % tuple(self._position.bounds)

def __init__(self, fig, rect,

facecolor=None, # defaults to rc axes.facecolor

frameon=True,

sharex=None, # use Axes instance's xaxis info

sharey=None, # use Axes instance's yaxis info

label='',

xscale=None,

yscale=None,

axisbg=None, # This will be removed eventually

**kwargs

):

"""

""" % {'scale': ' | '.join(

[repr(x) for x in mscale.get_scale_names()])}

martist.Artist.__init__(self)

if isinstance(rect, mtransforms.Bbox):

self._position = rect

else:

self._position = mtransforms.Bbox.from_bounds(*rect)

self._originalPosition = self._position.frozen()

# self.set_axes(self)

self.axes = self

self.set_aspect('auto')

self._adjustable = 'box'

self.set_anchor('C')

self._sharex = sharex

self._sharey = sharey

if sharex is not None:

self._shared_x_axes.join(self, sharex)

if sharex._adjustable == 'box':

sharex._adjustable = 'datalim'

# warnings.warn(

# 'shared axes: "adjustable" is being changed to "datalim"')

self._adjustable = 'datalim'

if sharey is not None:

self._shared_y_axes.join(self, sharey)

if sharey._adjustable == 'box':

sharey._adjustable = 'datalim'

# warnings.warn(

# 'shared axes: "adjustable" is being changed to "datalim"')

self._adjustable = 'datalim'

self.set_label(label)

self.set_figure(fig)

self.set_axes_locator(kwargs.get("axes_locator", None))

self.spines = self._gen_axes_spines()

# this call may differ for non-sep axes, e.g., polar

self._init_axis()

if axisbg is not None and facecolor is not None:

raise TypeError('Both axisbg and facecolor are not None. '

'These keywords are aliases, only one may be '

'provided.')

if axisbg is not None:

cbook.warn_deprecated(

'2.0', name='axisbg', alternative='facecolor')

facecolor = axisbg

if facecolor is None:

facecolor = rcParams['axes.facecolor']

self._facecolor = facecolor

self._frameon = frameon

self._axisbelow = rcParams['axes.axisbelow']

self._rasterization_zorder = None

self._hold = rcParams['axes.hold']

self._connected = {} # a dict from events to (id, func)

self.cla()

# funcs used to format x and y - fall back on major formatters

self.fmt_xdata = None

self.fmt_ydata = None

self.set_cursor_props((1, 'k')) # set the cursor properties for axes

self._cachedRenderer = None

self.set_navigate(True)

self.set_navigate_mode(None)

if xscale:

self.set_xscale(xscale)

if yscale:

self.set_yscale(yscale)

if len(kwargs):

self.update(kwargs)

if self.xaxis is not None:

self._xcid = self.xaxis.callbacks.connect('units finalize',

self.relim)

if self.yaxis is not None:

self._ycid = self.yaxis.callbacks.connect('units finalize',

self.relim)

self.tick_params(top=rcParams['xtick.top'],

bottom=rcParams['xtick.bottom'],

left=rcParams['ytick.left'],

right=rcParams['ytick.right'])

def __setstate__(self, state):

self.__dict__ = state

# put the _remove_method back on all artists contained within the axes

for container_name in ['lines', 'collections', 'tables', 'patches',

'texts', 'images']:

container = getattr(self, container_name)

for artist in container:

artist._remove_method = container.remove

self._stale = True

def get_window_extent(self, *args, **kwargs):

"""

bbox = self.bbox

x_pad = self.xaxis.get_tick_padding()

y_pad = self.yaxis.get_tick_padding()

return mtransforms.Bbox([[bbox.x0 - x_pad, bbox.y0 - y_pad],

[bbox.x1 + x_pad, bbox.y1 + y_pad]])

def _init_axis(self):

"move this out of __init__ because non-separable axes don't use it"

self.xaxis = maxis.XAxis(self)

self.spines['bottom'].register_axis(self.xaxis)

self.spines['top'].register_axis(self.xaxis)

self.yaxis = maxis.YAxis(self)

self.spines['left'].register_axis(self.yaxis)

self.spines['right'].register_axis(self.yaxis)

self._update_transScale()

def set_figure(self, fig):

"""

martist.Artist.set_figure(self, fig)

self.bbox = mtransforms.TransformedBbox(self._position,

fig.transFigure)

# these will be updated later as data is added

self.dataLim = mtransforms.Bbox.null()

self.viewLim = mtransforms.Bbox.unit()

self.transScale = mtransforms.TransformWrapper(

mtransforms.IdentityTransform())

self._set_lim_and_transforms()

def _set_lim_and_transforms(self):

"""

self.transAxes = mtransforms.BboxTransformTo(self.bbox)

# Transforms the x and y axis separately by a scale factor.

# It is assumed that this part will have non-linear components

# (e.g., for a log scale).

self.transScale = mtransforms.TransformWrapper(

mtransforms.IdentityTransform())

# An affine transformation on the data, generally to limit the

# range of the axes

self.transLimits = mtransforms.BboxTransformFrom(

mtransforms.TransformedBbox(self.viewLim, self.transScale))

# The parentheses are important for efficiency here -- they

# group the last two (which are usually affines) separately

# from the first (which, with log-scaling can be non-affine).

self.transData = self.transScale + (self.transLimits + self.transAxes)

self._xaxis_transform = mtransforms.blended_transform_factory(

self.transData, self.transAxes)

self._yaxis_transform = mtransforms.blended_transform_factory(

self.transAxes, self.transData)

def get_xaxis_transform(self, which='grid'):

"""

if which == 'grid':

return self._xaxis_transform

elif which == 'tick1':

# for cartesian projection, this is bottom spine

return self.spines['bottom'].get_spine_transform()

elif which == 'tick2':

# for cartesian projection, this is top spine

return self.spines['top'].get_spine_transform()

else:

raise ValueError('unknown value for which')

def get_xaxis_text1_transform(self, pad_points):

"""

return (self.get_xaxis_transform(which='tick1') +

mtransforms.ScaledTranslation(0, -1 * pad_points / 72.0,

self.figure.dpi_scale_trans),

"top", "center")

def get_xaxis_text2_transform(self, pad_points):

"""

return (self.get_xaxis_transform(which='tick2') +

mtransforms.ScaledTranslation(0, pad_points / 72.0,

self.figure.dpi_scale_trans),

"bottom", "center")

def get_yaxis_transform(self, which='grid'):

"""

if which == 'grid':

return self._yaxis_transform

elif which == 'tick1':

# for cartesian projection, this is bottom spine

return self.spines['left'].get_spine_transform()

elif which == 'tick2':

# for cartesian projection, this is top spine

return self.spines['right'].get_spine_transform()

else:

raise ValueError('unknown value for which')

def get_yaxis_text1_transform(self, pad_points):

"""

return (self.get_yaxis_transform(which='tick1') +

mtransforms.ScaledTranslation(-1 * pad_points / 72.0, 0,

self.figure.dpi_scale_trans),

"center_baseline", "right")

def get_yaxis_text2_transform(self, pad_points):

"""

return (self.get_yaxis_transform(which='tick2') +

mtransforms.ScaledTranslation(pad_points / 72.0, 0,

self.figure.dpi_scale_trans),

"center_baseline", "left")

def _update_transScale(self):

self.transScale.set(

mtransforms.blended_transform_factory(

self.xaxis.get_transform(), self.yaxis.get_transform()))

if hasattr(self, "lines"):

for line in self.lines:

try:

line._transformed_path.invalidate()

except AttributeError:

pass

def get_position(self, original=False):

'Return the a copy of the axes rectangle as a Bbox'

if original:

return self._originalPosition.frozen()

else:

return self._position.frozen()

def set_position(self, pos, which='both'):

"""

if not isinstance(pos, mtransforms.BboxBase):

pos = mtransforms.Bbox.from_bounds(*pos)

if which in ('both', 'active'):

self._position.set(pos)

if which in ('both', 'original'):

self._originalPosition.set(pos)

self.stale = True

def reset_position(self):

"""Make the original position the active position"""

pos = self.get_position(original=True)

self.set_position(pos, which='active')

def set_axes_locator(self, locator):

"""

self._axes_locator = locator

self.stale = True

def get_axes_locator(self):

"""

return self._axes_locator

def _set_artist_props(self, a):

"""set the boilerplate props for artists added to axes"""

a.set_figure(self.figure)

if not a.is_transform_set():

a.set_transform(self.transData)

a.axes = self

if a.mouseover:

self.mouseover_set.add(a)

def _gen_axes_patch(self):

"""

return mpatches.Rectangle((0.0, 0.0), 1.0, 1.0)

def _gen_axes_spines(self, locations=None, offset=0.0, units='inches'):

"""

return OrderedDict([

('left', mspines.Spine.linear_spine(self, 'left')),

('right', mspines.Spine.linear_spine(self, 'right')),

('bottom', mspines.Spine.linear_spine(self, 'bottom')),

('top', mspines.Spine.linear_spine(self, 'top'))])

def cla(self):

"""Clear the current axes."""

# Note: this is called by Axes.__init__()

# stash the current visibility state

if hasattr(self, 'patch'):

patch_visible = self.patch.get_visible()

else:

patch_visible = True

xaxis_visible = self.xaxis.get_visible()

yaxis_visible = self.yaxis.get_visible()

self.xaxis.cla()

self.yaxis.cla()

for name, spine in six.iteritems(self.spines):

spine.cla()

self.ignore_existing_data_limits = True

self.callbacks = cbook.CallbackRegistry()

if self._sharex is not None:

# major and minor are class instances with

# locator and formatter attributes

self.xaxis.major = self._sharex.xaxis.major

self.xaxis.minor = self._sharex.xaxis.minor

x0, x1 = self._sharex.get_xlim()

self.set_xlim(x0, x1, emit=False, auto=None)

# Save the current formatter/locator so we don't lose it

majf = self._sharex.xaxis.get_major_formatter()

minf = self._sharex.xaxis.get_minor_formatter()

majl = self._sharex.xaxis.get_major_locator()

minl = self._sharex.xaxis.get_minor_locator()

# This overwrites the current formatter/locator

self.xaxis._set_scale(self._sharex.xaxis.get_scale())

# Reset the formatter/locator

self.xaxis.set_major_formatter(majf)

self.xaxis.set_minor_formatter(minf)

self.xaxis.set_major_locator(majl)

self.xaxis.set_minor_locator(minl)

else:

self.xaxis._set_scale('linear')

if self._sharey is not None:

self.yaxis.major = self._sharey.yaxis.major

self.yaxis.minor = self._sharey.yaxis.minor

y0, y1 = self._sharey.get_ylim()

self.set_ylim(y0, y1, emit=False, auto=None)

# Save the current formatter/locator so we don't lose it

majf = self._sharey.yaxis.get_major_formatter()

minf = self._sharey.yaxis.get_minor_formatter()

majl = self._sharey.yaxis.get_major_locator()

minl = self._sharey.yaxis.get_minor_locator()