"""

Classes for the ticks and x and y axis

"""

from __future__ import division, print_function

from matplotlib import rcParams

import matplotlib.artist as artist

from matplotlib.artist import allow_rasterization

import matplotlib.cbook as cbook

import matplotlib.font_manager as font_manager

import matplotlib.lines as mlines

import matplotlib.patches as mpatches

import matplotlib.scale as mscale

import matplotlib.text as mtext

import matplotlib.ticker as mticker

import matplotlib.transforms as mtransforms

import matplotlib.units as munits

import numpy as np

import warnings

GRIDLINE_INTERPOLATION_STEPS = 180

class Tick(artist.Artist):

"""

Abstract base class for the axis ticks, grid lines and labels

1 refers to the bottom of the plot for xticks and the left for yticks

2 refers to the top of the plot for xticks and the right for yticks

Publicly accessible attributes:

:attr:`tick1line`

a Line2D instance

:attr:`tick2line`

a Line2D instance

:attr:`gridline`

a Line2D instance

:attr:`label1`

a Text instance

:attr:`label2`

a Text instance

:attr:`gridOn`

a boolean which determines whether to draw the tickline

:attr:`tick1On`

a boolean which determines whether to draw the 1st tickline

:attr:`tick2On`

a boolean which determines whether to draw the 2nd tickline

:attr:`label1On`

a boolean which determines whether to draw tick label

:attr:`label2On`

a boolean which determines whether to draw tick label

"""

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

tick1On=True,

tick2On=True,

label1On=True,

label2On=False,

major=True,

):

"""

bbox is the Bound2D bounding box in display coords of the Axes

loc is the tick location in data coords

size is the tick size in points

"""

artist.Artist.__init__(self)

if gridOn is None:

gridOn = rcParams['axes.grid']

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

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

"""

Calculate self._pad and self._tickmarkers

"""

pass

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.tick1line.set_clip_path(clippath, transform)

#self.tick2line.set_clip_path(clippath, transform)

self.gridline.set_clip_path(clippath, transform)

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

"""

Test whether the mouse event occurred in the Tick marks.

This function always returns false. It is more useful to test if the

axis as a whole contains the mouse rather than the set of tick marks.

"""

if callable(self._contains):

return self._contains(self, mouseevent)

return False, {}

def set_pad(self, val):

"""

Set the tick label pad in points

ACCEPTS: float

"""

self._apply_params(pad=val)

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

return

renderer.open_group(self.__name__)

midPoint = mtransforms.interval_contains(self.get_view_interval(),

self.get_loc())

if midPoint:

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

def set_label1(self, s):

"""

Set the text of ticklabel

ACCEPTS: str

"""

self.label1.set_text(s)

set_label = set_label1

def set_label2(self, s):

"""

Set the text of ticklabel2

ACCEPTS: str

"""

self.label2.set_text(s)

def _set_artist_props(self, a):

a.set_figure(self.figure)

#if isinstance(a, mlines.Line2D): a.set_clip_box(self.axes.bbox)

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

dirpad = [k for k in kw if k in ['pad', 'tickdir']]

if dirpad:

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

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

trans = self._get_text1_transform()[0]

self.label1.set_transform(trans)

trans = self._get_text2_transform()[0]

self.label2.set_transform(trans)

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

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

tick_kw = dict([kv for kv in kw.iteritems()

if kv[0] in ['color', 'zorder']])

if tick_kw:

self.tick1line.set(**tick_kw)

self.tick2line.set(**tick_kw)

for k, v in tick_kw.iteritems():

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

tick_list = [kv for kv

in kw.iteritems() if kv[0] in ['size', 'width']]

for k, v in tick_list:

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

if k == 'size':

self.tick1line.set_markersize(v)

self.tick2line.set_markersize(v)

else:

self.tick1line.set_markeredgewidth(v)

self.tick2line.set_markeredgewidth(v)

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

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

if label_list:

label_kw = dict([(k[5:], v) for (k, v) in label_list])

self.label1.set(**label_kw)

self.label2.set(**label_kw)

for k, v in label_kw.iteritems():

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

class XTick(Tick):

"""

Contains all the Artists needed to make an x tick - the tick line,

the label text and the grid line

"""

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

self._pad = self._base_pad

elif self._tickdir == 'inout':

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

self._pad = self._base_pad + self._size / 2.

else:

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

self._pad = self._base_pad + self._size

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

#t = mtext.Text(

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

#t = mtext.Text(

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*'

x = loc

nonlinear = (hasattr(self.axes, 'yaxis') and

self.axes.yaxis.get_scale() != 'linear' or

hasattr(self.axes, 'xaxis') and

self.axes.xaxis.get_scale() != 'linear')

if self.tick1On:

self.tick1line.set_xdata((x,))

if self.tick2On:

self.tick2line.set_xdata((x,))

if self.gridOn:

self.gridline.set_xdata((x,))

if self.label1On:

self.label1.set_x(x)

if self.label2On:

self.label2.set_x(x)

if nonlinear:

self.tick1line._invalid = True

self.tick2line._invalid = True

self.gridline._invalid = True

self._loc = loc

def get_view_interval(self):

'return the Interval instance for this axis view limits'

return self.axes.viewLim.intervalx

class YTick(Tick):

"""

Contains all the Artists needed to make a Y tick - the tick line,

the label text and the grid line

"""

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

self._pad = self._base_pad

elif self._tickdir == 'inout':

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

self._pad = self._base_pad + self._size / 2.

else:

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

self._pad = self._base_pad + self._size

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

#t.set_transform( self.axes.transData )

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'

y = loc

nonlinear = (hasattr(self.axes, 'yaxis') and

self.axes.yaxis.get_scale() != 'linear' or

hasattr(self.axes, 'xaxis') and

self.axes.xaxis.get_scale() != 'linear')

if self.tick1On:

self.tick1line.set_ydata((y,))

if self.tick2On:

self.tick2line.set_ydata((y,))

if self.gridOn:

self.gridline.set_ydata((y, ))

if self.label1On:

self.label1.set_y(y)

if self.label2On:

self.label2.set_y(y)

if nonlinear:

self.tick1line._invalid = True

self.tick2line._invalid = True

self.gridline._invalid = True

self._loc = loc

def get_view_interval(self):

'return the Interval instance for this axis view limits'

return self.axes.viewLim.intervaly

class Ticker:

locator = None

formatter = None

class Axis(artist.Artist):

"""

Public attributes

* :attr:`axes.transData` - transform data coords to display coords

* :attr:`axes.transAxes` - transform axis coords to display coords

* :attr:`labelpad` - number of points between the axis and its label

"""

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

"""

Init the axis with the parent Axes instance

"""

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

#class dummy:

# locator = None

# formatter = None

#self.major = dummy()

#self.minor = dummy()

self._autolabelpos = True

self._smart_bounds = False

self.label = self._get_label()

self.labelpad = 5

self.offsetText = self._get_offset_text()

self.majorTicks = []

self.minorTicks = []

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

"""

Set the coordinates of the label. By default, the x

coordinate of the y label is determined by the tick label

bounding boxes, but this can lead to poor alignment of

multiple ylabels if there are multiple axes. Ditto for the y

coodinate of the x label.

You can also specify the coordinate system of the label with

the transform. If None, the default coordinate system will be

the axes coordinate system (0,0) is (left,bottom), (0.5, 0.5)

is middle, etc

"""

self._autolabelpos = False

if transform is None:

transform = self.axes.transAxes

self.label.set_transform(transform)

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

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

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']

self._gridOnMinor = False

self.label.set_text('')

self._set_artist_props(self.label)

self.reset_ticks()

self.converter = None

self.units = None

self.set_units(None)

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

cbook.popall(self.majorTicks)

cbook.popall(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):

"""

Set appearance parameters for ticks and ticklabels.

For documentation of keyword arguments, see

:meth:`matplotlib.axes.Axes.tick_params`.

"""

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)

@staticmethod

def _translate_tick_kw(kw, to_init_kw=True):

# We may want to move the following function to

# a more visible location; or maybe there already

# is something like this.

def _bool(arg):

if cbook.is_string_like(arg):

if arg.lower() == 'on':

return True

if arg.lower() == 'off':

return False

raise ValueError('String "%s" should be "on" or "off"' % arg)

return bool(arg)

# 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']

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 'left' in kw:

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

if 'bottom' in kw:

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

if 'right' in kw:

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

if 'top' in kw:

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

if 'labelleft' in kw:

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

if 'labelbottom' in kw:

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

if 'labelright' in kw:

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

if 'labeltop' in kw:

kwtrans['label2On'] = _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)

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

are not mutated'''

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

"""

Iterate through all of the major and minor ticks.

"""

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

"""

Get the extents of the tick labels on either side

of the axes.

"""

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

def get_smart_bounds(self):

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

return self._smart_bounds

def _update_ticks(self, renderer):

"""

Update ticks (position and labels) using the current data

interval of the axes. Returns a list of ticks that will be

drawn.

"""

interval = self.get_view_interval()

tick_tups = [t for t in self.iter_ticks()]

if self._smart_bounds:

# handle inverted limits

view_low, view_high = min(*interval), max(*interval)

data_low, data_high = self.get_data_interval()

if data_low > data_high:

data_low, data_high = data_high, data_low

locs = [ti[1] for ti in tick_tups]

locs.sort()

locs = np.array(locs)

if len(locs):

if data_low <= view_low:

# data extends beyond view, take view as limit

ilow = view_low

else:

# data stops within view, take best tick

cond = locs <= data_low

good_locs = locs[cond]

if len(good_locs) > 0:

# 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

cond = locs >= data_high

good_locs = locs[cond]

if len(good_locs) > 0:

# 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 (ti[1] >= ilow) and (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 from one side of the axis or another, rather than see a stack trace.

try:

ds1 = self._get_pixel_distance_along_axis(interval_expanded[0], -0.5)

except:

warnings.warn("Unable to find pixel distance along axis for interval padding; assuming no interval padding needed.")

ds1 = 0.0

try:

ds2 = self._get_pixel_distance_along_axis(interval_expanded[1], +0.5)

except:

warnings.warn("Unable to find pixel distance along axis for interval padding; assuming no interval padding needed.")

ds2 = 0.0