"""

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,

):

"""

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

"""

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

"""

if callable(self._contains): return self._contains(self,mouseevent)

return False,{}

def set_pad(self, val):

"""

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

"""

self.label1.set_text(s)

set_label = set_label1

def set_label2(self, s):

"""

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

"""

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

)

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'

"""

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

)

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'

"""

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

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

"""

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

"""

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)

majorticks = self.get_major_ticks()

minorticks = self.get_minor_ticks()

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

"""

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

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 = [ 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)]

ticks_to_draw = []

for tick, loc, label in tick_tups:

if tick is None: continue

if not mtransforms.interval_contains(interval, loc): continue

tick.update_position(loc)

tick.set_label1(label)

tick.set_label2(label)

ticks_to_draw.append(tick)

return ticks_to_draw

def _get_tick_bboxes(self, ticks, renderer):

"""

ticklabelBoxes = []

ticklabelBoxes2 = []

for tick in ticks:

if tick.label1On and tick.label1.get_visible():

extent = tick.label1.get_window_extent(renderer)

ticklabelBoxes.append(extent)