"""

def __init__(self, axes, loc, label,

size=None, # points

width=None,

color=None,

tickdir=None,

pad=None,

labelsize=None,

labelcolor=None,

zorder=None,

gridOn=None, # defaults to axes.grid depending on

# axes.grid.which

tick1On=True,

tick2On=True,

label1On=True,

label2On=False,

major=True,

labelrotation=0,

):

"""

artist.Artist.__init__(self)

if gridOn is None:

if major and (rcParams['axes.grid.which'] in ('both', 'major')):

gridOn = rcParams['axes.grid']

elif (not major) and (rcParams['axes.grid.which']

in ('both', 'minor')):

gridOn = rcParams['axes.grid']

else:

gridOn = False

self.set_figure(axes.figure)

self.axes = axes

name = self.__name__.lower()

self._name = name

self._loc = loc

if size is None:

if major:

size = rcParams['%s.major.size' % name]

else:

size = rcParams['%s.minor.size' % name]

self._size = size

if width is None:

if major:

width = rcParams['%s.major.width' % name]

else:

width = rcParams['%s.minor.width' % name]

self._width = width

if color is None:

color = rcParams['%s.color' % name]

self._color = color

if pad is None:

if major:

pad = rcParams['%s.major.pad' % name]

else:

pad = rcParams['%s.minor.pad' % name]

self._base_pad = pad

if labelcolor is None:

labelcolor = rcParams['%s.color' % name]

self._labelcolor = labelcolor

if labelsize is None:

labelsize = rcParams['%s.labelsize' % name]

self._labelsize = labelsize

self._labelrotation = labelrotation

if zorder is None:

if major:

zorder = mlines.Line2D.zorder + 0.01

else:

zorder = mlines.Line2D.zorder

self._zorder = zorder

self.apply_tickdir(tickdir)

self.tick1line = self._get_tick1line()

self.tick2line = self._get_tick2line()

self.gridline = self._get_gridline()

self.label1 = self._get_text1()

self.label = self.label1 # legacy name

self.label2 = self._get_text2()

self.gridOn = gridOn

self.tick1On = tick1On

self.tick2On = tick2On

self.label1On = label1On

self.label2On = label2On

self.update_position(loc)

def apply_tickdir(self, tickdir):

"""

pass

def get_tickdir(self):

return self._tickdir

def get_tick_padding(self):

"""

padding = {

'in': 0.0,

'inout': 0.5,

'out': 1.0

}

return self._size * padding[self._tickdir]

def get_children(self):

children = [self.tick1line, self.tick2line,

self.gridline, self.label1, self.label2]

return children

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

artist.Artist.set_clip_path(self, clippath, transform)

self.gridline.set_clip_path(clippath, transform)

self.stale = True

set_clip_path.__doc__ = artist.Artist.set_clip_path.__doc__

def get_pad_pixels(self):

return self.figure.dpi * self._base_pad / 72.0

def contains(self, mouseevent):

"""

if callable(self._contains):

return self._contains(self, mouseevent)

return False, {}

def set_pad(self, val):

"""

self._apply_params(pad=val)

self.stale = True

def get_pad(self):

'Get the value of the tick label pad in points'

return self._base_pad

def _get_text1(self):

'Get the default Text 1 instance'

pass

def _get_text2(self):

'Get the default Text 2 instance'

pass

def _get_tick1line(self):

'Get the default line2D instance for tick1'

pass

def _get_tick2line(self):

'Get the default line2D instance for tick2'

pass

def _get_gridline(self):

'Get the default grid Line2d instance for this tick'

pass

def get_loc(self):

'Return the tick location (data coords) as a scalar'

return self._loc

@allow_rasterization

def draw(self, renderer):

if not self.get_visible():

self.stale = False

return

renderer.open_group(self.__name__)

if self.gridOn:

self.gridline.draw(renderer)

if self.tick1On:

self.tick1line.draw(renderer)

if self.tick2On:

self.tick2line.draw(renderer)

if self.label1On:

self.label1.draw(renderer)

if self.label2On:

self.label2.draw(renderer)

renderer.close_group(self.__name__)

self.stale = False

def set_label1(self, s):

"""

self.label1.set_text(s)

self.stale = True

set_label = set_label1

def set_label2(self, s):

"""

self.label2.set_text(s)

self.stale = True

def _set_artist_props(self, a):

a.set_figure(self.figure)

def get_view_interval(self):

'return the view Interval instance for the axis this tick is ticking'

raise NotImplementedError('Derived must override')

def _apply_params(self, **kw):

switchkw = ['gridOn', 'tick1On', 'tick2On', 'label1On', 'label2On']

switches = [k for k in kw if k in switchkw]

for k in switches:

setattr(self, k, kw.pop(k))

newmarker = [k for k in kw if k in ['size', 'width', 'pad', 'tickdir']]

if newmarker:

self._size = kw.pop('size', self._size)

# Width could be handled outside this block, but it is

# convenient to leave it here.

self._width = kw.pop('width', self._width)

self._base_pad = kw.pop('pad', self._base_pad)

# apply_tickdir uses _size and _base_pad to make _pad,

# and also makes _tickmarkers.

self.apply_tickdir(kw.pop('tickdir', self._tickdir))

self.tick1line.set_marker(self._tickmarkers[0])

self.tick2line.set_marker(self._tickmarkers[1])

for line in (self.tick1line, self.tick2line):

line.set_markersize(self._size)

line.set_markeredgewidth(self._width)

# _get_text1_transform uses _pad from apply_tickdir.

trans = self._get_text1_transform()[0]

self.label1.set_transform(trans)

trans = self._get_text2_transform()[0]

self.label2.set_transform(trans)

tick_kw = {k: v for k, v in six.iteritems(kw)

if k in ['color', 'zorder']}

if tick_kw:

self.tick1line.set(**tick_kw)

self.tick2line.set(**tick_kw)

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

setattr(self, '_' + k, v)

label_list = [k for k in six.iteritems(kw)

if k[0] in ['labelsize', 'labelcolor', 'labelrotation']]

if label_list:

label_kw = {k[5:]: v for k, v in label_list}

self.label1.set(**label_kw)

self.label2.set(**label_kw)

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

# for labelsize the text objects covert str ('small')

# -> points. grab the integer from the `Text` object

# instead of saving the string representation

v = getattr(self.label1, 'get_' + k)()

setattr(self, '_label' + k, v)

def update_position(self, loc):

'Set the location of tick in data coords with scalar *loc*'

raise NotImplementedError('Derived must override')

def _get_text1_transform(self):

raise NotImplementedError('Derived must override')

def _get_text2_transform(self):

"""

__name__ = 'xtick'

def _get_text1_transform(self):

return self.axes.get_xaxis_text1_transform(self._pad)

def _get_text2_transform(self):

return self.axes.get_xaxis_text2_transform(self._pad)

def apply_tickdir(self, tickdir):

if tickdir is None:

tickdir = rcParams['%s.direction' % self._name]

self._tickdir = tickdir

if self._tickdir == 'in':

self._tickmarkers = (mlines.TICKUP, mlines.TICKDOWN)

elif self._tickdir == 'inout':

self._tickmarkers = ('|', '|')

else:

self._tickmarkers = (mlines.TICKDOWN, mlines.TICKUP)

self._pad = self._base_pad + self.get_tick_padding()

self.stale = True

def _get_text1(self):

'Get the default Text instance'

# the y loc is 3 points below the min of y axis

# get the affine as an a,b,c,d,tx,ty list

# x in data coords, y in axes coords

trans, vert, horiz = self._get_text1_transform()

t = mtext.Text(

x=0, y=0,

fontproperties=font_manager.FontProperties(size=self._labelsize),

color=self._labelcolor,

verticalalignment=vert,

horizontalalignment=horiz,

)

t.set_transform(trans)

self._set_artist_props(t)

return t

def _get_text2(self):

'Get the default Text 2 instance'

# x in data coords, y in axes coords

trans, vert, horiz = self._get_text2_transform()

t = mtext.Text(

x=0, y=1,

fontproperties=font_manager.FontProperties(size=self._labelsize),

color=self._labelcolor,

verticalalignment=vert,

horizontalalignment=horiz,

)

t.set_transform(trans)

self._set_artist_props(t)

return t

def _get_tick1line(self):

'Get the default line2D instance'

# x in data coords, y in axes coords

l = mlines.Line2D(xdata=(0,), ydata=(0,), color=self._color,

linestyle='None', marker=self._tickmarkers[0],

markersize=self._size,

markeredgewidth=self._width, zorder=self._zorder)

l.set_transform(self.axes.get_xaxis_transform(which='tick1'))

self._set_artist_props(l)

return l

def _get_tick2line(self):

'Get the default line2D instance'

# x in data coords, y in axes coords

l = mlines.Line2D(xdata=(0,), ydata=(1,),

color=self._color,

linestyle='None',

marker=self._tickmarkers[1],

markersize=self._size,

markeredgewidth=self._width,

zorder=self._zorder)

l.set_transform(self.axes.get_xaxis_transform(which='tick2'))

self._set_artist_props(l)

return l

def _get_gridline(self):

'Get the default line2D instance'

# x in data coords, y in axes coords

l = mlines.Line2D(xdata=(0.0, 0.0), ydata=(0, 1.0),

color=rcParams['grid.color'],

linestyle=rcParams['grid.linestyle'],

linewidth=rcParams['grid.linewidth'],

alpha=rcParams['grid.alpha'],

markersize=0)

l.set_transform(self.axes.get_xaxis_transform(which='grid'))

l.get_path()._interpolation_steps = GRIDLINE_INTERPOLATION_STEPS

self._set_artist_props(l)

return l

def update_position(self, loc):

'Set the location of tick in data coords with scalar *loc*'

if self.tick1On:

self.tick1line.set_xdata((loc,))

if self.tick2On:

self.tick2line.set_xdata((loc,))

if self.gridOn:

self.gridline.set_xdata((loc,))

if self.label1On:

self.label1.set_x(loc)

if self.label2On:

self.label2.set_x(loc)

self._loc = loc

self.stale = True

def get_view_interval(self):

'return the Interval instance for this axis view limits'

"""

__name__ = 'ytick'

def _get_text1_transform(self):

return self.axes.get_yaxis_text1_transform(self._pad)

def _get_text2_transform(self):

return self.axes.get_yaxis_text2_transform(self._pad)

def apply_tickdir(self, tickdir):

if tickdir is None:

tickdir = rcParams['%s.direction' % self._name]

self._tickdir = tickdir

if self._tickdir == 'in':

self._tickmarkers = (mlines.TICKRIGHT, mlines.TICKLEFT)

elif self._tickdir == 'inout':

self._tickmarkers = ('_', '_')

else:

self._tickmarkers = (mlines.TICKLEFT, mlines.TICKRIGHT)

self._pad = self._base_pad + self.get_tick_padding()

self.stale = True

# how far from the y axis line the right of the ticklabel are

def _get_text1(self):

'Get the default Text instance'

# x in axes coords, y in data coords

trans, vert, horiz = self._get_text1_transform()

t = mtext.Text(

x=0, y=0,

fontproperties=font_manager.FontProperties(size=self._labelsize),

color=self._labelcolor,

verticalalignment=vert,

horizontalalignment=horiz,

)

t.set_transform(trans)

self._set_artist_props(t)

return t

def _get_text2(self):

'Get the default Text instance'

# x in axes coords, y in data coords

trans, vert, horiz = self._get_text2_transform()

t = mtext.Text(

x=1, y=0,

fontproperties=font_manager.FontProperties(size=self._labelsize),

color=self._labelcolor,

verticalalignment=vert,

horizontalalignment=horiz,

)

t.set_transform(trans)

self._set_artist_props(t)

return t

def _get_tick1line(self):

'Get the default line2D instance'

# x in axes coords, y in data coords

l = mlines.Line2D((0,), (0,),

color=self._color,

marker=self._tickmarkers[0],

linestyle='None',

markersize=self._size,

markeredgewidth=self._width,

zorder=self._zorder)

l.set_transform(self.axes.get_yaxis_transform(which='tick1'))

self._set_artist_props(l)

return l

def _get_tick2line(self):

'Get the default line2D instance'

# x in axes coords, y in data coords

l = mlines.Line2D((1,), (0,),

color=self._color,

marker=self._tickmarkers[1],

linestyle='None',

markersize=self._size,

markeredgewidth=self._width,

zorder=self._zorder)

l.set_transform(self.axes.get_yaxis_transform(which='tick2'))

self._set_artist_props(l)

return l

def _get_gridline(self):

'Get the default line2D instance'

# x in axes coords, y in data coords

l = mlines.Line2D(xdata=(0, 1), ydata=(0, 0),

color=rcParams['grid.color'],

linestyle=rcParams['grid.linestyle'],

linewidth=rcParams['grid.linewidth'],

alpha=rcParams['grid.alpha'],

markersize=0)

l.set_transform(self.axes.get_yaxis_transform(which='grid'))

l.get_path()._interpolation_steps = GRIDLINE_INTERPOLATION_STEPS

self._set_artist_props(l)

return l

def update_position(self, loc):

'Set the location of tick in data coords with scalar *loc*'

if self.tick1On:

self.tick1line.set_ydata((loc,))

if self.tick2On:

self.tick2line.set_ydata((loc,))

if self.gridOn:

self.gridline.set_ydata((loc,))

if self.label1On:

self.label1.set_y(loc)

if self.label2On:

self.label2.set_y(loc)

self._loc = loc

self.stale = True

def get_view_interval(self):

'return the Interval instance for this axis view limits'

"""

OFFSETTEXTPAD = 3

def __str__(self):

return self.__class__.__name__ \

+ "(%f,%f)" % tuple(self.axes.transAxes.transform_point((0, 0)))

def __init__(self, axes, pickradius=15):

"""

artist.Artist.__init__(self)

self.set_figure(axes.figure)

# Keep track of setting to the default value, this allows use to know

# if any of the following values is explicitly set by the user, so as

# to not overwrite their settings with any of our 'auto' settings.

self.isDefault_majloc = True

self.isDefault_minloc = True

self.isDefault_majfmt = True

self.isDefault_minfmt = True

self.isDefault_label = True

self.axes = axes

self.major = Ticker()

self.minor = Ticker()

self.callbacks = cbook.CallbackRegistry()

self._autolabelpos = True

self._smart_bounds = False

self.label = self._get_label()

self.labelpad = rcParams['axes.labelpad']

self.offsetText = self._get_offset_text()

self.majorTicks = []

self.minorTicks = []

self.unit_data = None

self.pickradius = pickradius

# Initialize here for testing; later add API

self._major_tick_kw = dict()

self._minor_tick_kw = dict()

self.cla()

self._set_scale('linear')

def set_label_coords(self, x, y, transform=None):

"""

self._autolabelpos = False

if transform is None:

transform = self.axes.transAxes

self.label.set_transform(transform)

self.label.set_position((x, y))

self.stale = True

def get_transform(self):

return self._scale.get_transform()

def get_scale(self):

return self._scale.name

def _set_scale(self, value, **kwargs):

self._scale = mscale.scale_factory(value, self, **kwargs)

self._scale.set_default_locators_and_formatters(self)

self.isDefault_majloc = True

self.isDefault_minloc = True

self.isDefault_majfmt = True

self.isDefault_minfmt = True

def limit_range_for_scale(self, vmin, vmax):

return self._scale.limit_range_for_scale(vmin, vmax, self.get_minpos())

@property

def unit_data(self):

"""Holds data that a ConversionInterface subclass uses

return self._unit_data

@unit_data.setter

def unit_data(self, unit_data):

self._unit_data = unit_data

def get_children(self):

children = [self.label, self.offsetText]

majorticks = self.get_major_ticks()

minorticks = self.get_minor_ticks()

children.extend(majorticks)

children.extend(minorticks)

return children

def cla(self):

'clear the current axis'

self.set_major_locator(mticker.AutoLocator())

self.set_major_formatter(mticker.ScalarFormatter())

self.set_minor_locator(mticker.NullLocator())

self.set_minor_formatter(mticker.NullFormatter())

self.set_label_text('')

self._set_artist_props(self.label)

# Keep track of setting to the default value, this allows use to know

# if any of the following values is explicitly set by the user, so as

# to not overwrite their settings with any of our 'auto' settings.

self.isDefault_majloc = True

self.isDefault_minloc = True

self.isDefault_majfmt = True

self.isDefault_minfmt = True

self.isDefault_label = True

# Clear the callback registry for this axis, or it may "leak"

self.callbacks = cbook.CallbackRegistry()

# whether the grids are on

self._gridOnMajor = (rcParams['axes.grid'] and

rcParams['axes.grid.which'] in ('both', 'major'))

self._gridOnMinor = (rcParams['axes.grid'] and

rcParams['axes.grid.which'] in ('both', 'minor'))

self.label.set_text('')

self._set_artist_props(self.label)

self.reset_ticks()

self.converter = None

self.units = None

self.set_units(None)

self.stale = True

def reset_ticks(self):

# build a few default ticks; grow as necessary later; only

# define 1 so properties set on ticks will be copied as they

# grow

del self.majorTicks[:]

del self.minorTicks[:]

self.majorTicks.extend([self._get_tick(major=True)])

self.minorTicks.extend([self._get_tick(major=False)])

self._lastNumMajorTicks = 1

self._lastNumMinorTicks = 1

def set_tick_params(self, which='major', reset=False, **kw):

"""

dicts = []

if which == 'major' or which == 'both':

dicts.append(self._major_tick_kw)

if which == 'minor' or which == 'both':

dicts.append(self._minor_tick_kw)

kwtrans = self._translate_tick_kw(kw, to_init_kw=True)

for d in dicts:

if reset:

d.clear()

d.update(kwtrans)

if reset:

self.reset_ticks()

else:

if which == 'major' or which == 'both':

for tick in self.majorTicks:

tick._apply_params(**self._major_tick_kw)

if which == 'minor' or which == 'both':

for tick in self.minorTicks:

tick._apply_params(**self._minor_tick_kw)

if 'labelcolor' in kwtrans:

self.offsetText.set_color(kwtrans['labelcolor'])

self.stale = True

@staticmethod

def _translate_tick_kw(kw, to_init_kw=True):

# The following lists may be moved to a more

# accessible location.

kwkeys0 = ['size', 'width', 'color', 'tickdir', 'pad',

'labelsize', 'labelcolor', 'zorder', 'gridOn',

'tick1On', 'tick2On', 'label1On', 'label2On']

kwkeys1 = ['length', 'direction', 'left', 'bottom', 'right', 'top',

'labelleft', 'labelbottom', 'labelright', 'labeltop',

'rotation']

kwkeys = kwkeys0 + kwkeys1

kwtrans = dict()

if to_init_kw:

if 'length' in kw:

kwtrans['size'] = kw.pop('length')

if 'direction' in kw:

kwtrans['tickdir'] = kw.pop('direction')

if 'rotation' in kw:

kwtrans['labelrotation'] = kw.pop('rotation')

if 'left' in kw:

kwtrans['tick1On'] = _string_to_bool(kw.pop('left'))

if 'bottom' in kw:

kwtrans['tick1On'] = _string_to_bool(kw.pop('bottom'))

if 'right' in kw:

kwtrans['tick2On'] = _string_to_bool(kw.pop('right'))

if 'top' in kw:

kwtrans['tick2On'] = _string_to_bool(kw.pop('top'))

if 'labelleft' in kw:

kwtrans['label1On'] = _string_to_bool(kw.pop('labelleft'))

if 'labelbottom' in kw:

kwtrans['label1On'] = _string_to_bool(kw.pop('labelbottom'))

if 'labelright' in kw:

kwtrans['label2On'] = _string_to_bool(kw.pop('labelright'))

if 'labeltop' in kw:

kwtrans['label2On'] = _string_to_bool(kw.pop('labeltop'))

if 'colors' in kw:

c = kw.pop('colors')

kwtrans['color'] = c

kwtrans['labelcolor'] = c

# Maybe move the checking up to the caller of this method.

for key in kw:

if key not in kwkeys:

raise ValueError(

"keyword %s is not recognized; valid keywords are %s"

% (key, kwkeys))

kwtrans.update(kw)

else:

raise NotImplementedError("Inverse translation is deferred")

return kwtrans

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

artist.Artist.set_clip_path(self, clippath, transform)

for child in self.majorTicks + self.minorTicks:

child.set_clip_path(clippath, transform)

self.stale = True

def get_view_interval(self):

'return the Interval instance for this axis view limits'

raise NotImplementedError('Derived must override')

def set_view_interval(self, vmin, vmax, ignore=False):

raise NotImplementedError('Derived must override')

def get_data_interval(self):

'return the Interval instance for this axis data limits'

raise NotImplementedError('Derived must override')

def set_data_interval(self):

'''set the axis data limits'''

raise NotImplementedError('Derived must override')

def set_default_intervals(self):

'''set the default limits for the axis data and view interval if they

# this is mainly in support of custom object plotting. For

# example, if someone passes in a datetime object, we do not

# know automagically how to set the default min/max of the

# data and view limits. The unit conversion AxisInfo

# interface provides a hook for custom types to register

# default limits through the AxisInfo.default_limits

# attribute, and the derived code below will check for that

# and use it if is available (else just use 0..1)

pass

def _set_artist_props(self, a):

if a is None:

return

a.set_figure(self.figure)

def iter_ticks(self):

"""

majorLocs = self.major.locator()

majorTicks = self.get_major_ticks(len(majorLocs))

self.major.formatter.set_locs(majorLocs)

majorLabels = [self.major.formatter(val, i)

for i, val in enumerate(majorLocs)]

minorLocs = self.minor.locator()

minorTicks = self.get_minor_ticks(len(minorLocs))

self.minor.formatter.set_locs(minorLocs)

minorLabels = [self.minor.formatter(val, i)

for i, val in enumerate(minorLocs)]

major_minor = [

(majorTicks, majorLocs, majorLabels),

(minorTicks, minorLocs, minorLabels)]

for group in major_minor:

for tick in zip(*group):

yield tick

def get_ticklabel_extents(self, renderer):

"""

ticks_to_draw = self._update_ticks(renderer)

ticklabelBoxes, ticklabelBoxes2 = self._get_tick_bboxes(ticks_to_draw,

renderer)

if len(ticklabelBoxes):

bbox = mtransforms.Bbox.union(ticklabelBoxes)

else:

bbox = mtransforms.Bbox.from_extents(0, 0, 0, 0)

if len(ticklabelBoxes2):

bbox2 = mtransforms.Bbox.union(ticklabelBoxes2)

else:

bbox2 = mtransforms.Bbox.from_extents(0, 0, 0, 0)

return bbox, bbox2

def set_smart_bounds(self, value):

"""set the axis to have smart bounds"""

self._smart_bounds = value

self.stale = True

def get_smart_bounds(self):

"""get whether the axis has smart bounds"""

return self._smart_bounds

def _update_ticks(self, renderer):

"""

interval = self.get_view_interval()

tick_tups = list(self.iter_ticks())

if self._smart_bounds and tick_tups:

# handle inverted limits

view_low, view_high = sorted(interval)

data_low, data_high = sorted(self.get_data_interval())

locs = np.sort([ti[1] for ti in tick_tups])

if data_low <= view_low:

# data extends beyond view, take view as limit

ilow = view_low

else:

# data stops within view, take best tick

good_locs = locs[locs <= data_low]

if len(good_locs):

# last tick prior or equal to first data point

ilow = good_locs[-1]

else:

# No ticks (why not?), take first tick

ilow = locs[0]

if data_high >= view_high:

# data extends beyond view, take view as limit

ihigh = view_high

else:

# data stops within view, take best tick

good_locs = locs[locs >= data_high]

if len(good_locs):

# first tick after or equal to last data point

ihigh = good_locs[0]

else:

# No ticks (why not?), take last tick

ihigh = locs[-1]

tick_tups = [ti for ti in tick_tups if ilow <= ti[1] <= ihigh]

# so that we don't lose ticks on the end, expand out the interval ever

# so slightly. The "ever so slightly" is defined to be the width of a

# half of a pixel. We don't want to draw a tick that even one pixel

# outside of the defined axis interval.

if interval[0] <= interval[1]:

interval_expanded = interval

else:

interval_expanded = interval[1], interval[0]

if hasattr(self, '_get_pixel_distance_along_axis'):

# normally, one does not want to catch all exceptions that

# could possibly happen, but it is not clear exactly what

# exceptions might arise from a user's projection (their

# rendition of the Axis object). So, we catch all, with

# the idea that one would rather potentially lose a tick