"""

Tick locating and formatting

============================

This module contains classes to support completely configurable tick locating

and formatting. Although the locators know nothing about major or minor

ticks, they are used by the Axis class to support major and minor tick

locating and formatting. Generic tick locators and formatters are provided,

as well as domain specific custom ones..

Default Formatter

-----------------

The default formatter identifies when the x-data being

plotted is a small range on top of a large off set. To

reduce the chances that the ticklabels overlap the ticks

are labeled as deltas from a fixed offset. For example::

ax.plot(np.arange(2000, 2010), range(10))

will have tick of 0-9 with an offset of +2e3. If this

is not desired turn off the use of the offset on the default

formatter::

ax.get_xaxis().get_major_formatter().set_useOffset(False)

set the rcParam ``axes.formatter.useoffset=False`` to turn it off

globally, or set a different formatter.

Tick locating

-------------

The Locator class is the base class for all tick locators. The locators

handle autoscaling of the view limits based on the data limits, and the

choosing of tick locations. A useful semi-automatic tick locator is

MultipleLocator. You initialize this with a base, eg 10, and it picks axis

limits and ticks that are multiples of your base.

The Locator subclasses defined here are

:class:`NullLocator`

No ticks

:class:`FixedLocator`

Tick locations are fixed

:class:`IndexLocator`

locator for index plots (e.g., where x = range(len(y)))

:class:`LinearLocator`

evenly spaced ticks from min to max

:class:`LogLocator`

logarithmically ticks from min to max

:class:`MultipleLocator`

ticks and range are a multiple of base;

either integer or float

:class:`OldAutoLocator`

choose a MultipleLocator and dyamically reassign it for

intelligent ticking during navigation

:class:`MaxNLocator`

finds up to a max number of ticks at nice locations

:class:`AutoLocator`

:class:`MaxNLocator` with simple defaults. This is the default

tick locator for most plotting.

:class:`AutoMinorLocator`

locator for minor ticks when the axis is linear and the

major ticks are uniformly spaced. It subdivides the major

tick interval into a specified number of minor intervals,

defaulting to 4 or 5 depending on the major interval.

There are a number of locators specialized for date locations - see

the dates module

You can define your own locator by deriving from Locator. You must

override the __call__ method, which returns a sequence of locations,

and you will probably want to override the autoscale method to set the

view limits from the data limits.

If you want to override the default locator, use one of the above or a

custom locator and pass it to the x or y axis instance. The relevant

methods are::

ax.xaxis.set_major_locator( xmajorLocator )

ax.xaxis.set_minor_locator( xminorLocator )

ax.yaxis.set_major_locator( ymajorLocator )

ax.yaxis.set_minor_locator( yminorLocator )

The default minor locator is the NullLocator, eg no minor ticks on by

default.

Tick formatting

---------------

Tick formatting is controlled by classes derived from Formatter. The

formatter operates on a single tick value and returns a string to the

axis.

:class:`NullFormatter`

no labels on the ticks

:class:`IndexFormatter`

set the strings from a list of labels

:class:`FixedFormatter`

set the strings manually for the labels

:class:`FuncFormatter`

user defined function sets the labels

:class:`FormatStrFormatter`

use a sprintf format string

:class:`ScalarFormatter`

default formatter for scalars; autopick the fmt string

:class:`LogFormatter`

formatter for log axes

You can derive your own formatter from the Formatter base class by

simply overriding the ``__call__`` method. The formatter class has access

to the axis view and data limits.

To control the major and minor tick label formats, use one of the

following methods::

ax.xaxis.set_major_formatter( xmajorFormatter )

ax.xaxis.set_minor_formatter( xminorFormatter )

ax.yaxis.set_major_formatter( ymajorFormatter )

ax.yaxis.set_minor_formatter( yminorFormatter )

See :ref:`pylab_examples-major_minor_demo1` for an example of setting

major and minor ticks. See the :mod:`matplotlib.dates` module for

more information and examples of using date locators and formatters.

"""

from __future__ import (absolute_import, division, print_function,

unicode_literals)

import six

if six.PY3:

long = int

import decimal

import locale

import math

import numpy as np

from matplotlib import rcParams

from matplotlib import cbook

from matplotlib import transforms as mtransforms

class _DummyAxis(object):

def __init__(self, minpos=0):

self.dataLim = mtransforms.Bbox.unit()

self.viewLim = mtransforms.Bbox.unit()

self._minpos = minpos

def get_view_interval(self):

return self.viewLim.intervalx

def set_view_interval(self, vmin, vmax):

self.viewLim.intervalx = vmin, vmax

def get_minpos(self):

return self._minpos

def get_data_interval(self):

return self.dataLim.intervalx

def set_data_interval(self, vmin, vmax):

self.dataLim.intervalx = vmin, vmax

class TickHelper(object):

axis = None

def set_axis(self, axis):

self.axis = axis

def create_dummy_axis(self, **kwargs):

if self.axis is None:

self.axis = _DummyAxis(**kwargs)

def set_view_interval(self, vmin, vmax):

self.axis.set_view_interval(vmin, vmax)

def set_data_interval(self, vmin, vmax):

self.axis.set_data_interval(vmin, vmax)

def set_bounds(self, vmin, vmax):

self.set_view_interval(vmin, vmax)

self.set_data_interval(vmin, vmax)

class Formatter(TickHelper):

"""

Convert the tick location to a string

"""

# some classes want to see all the locs to help format

# individual ones

locs = []

def __call__(self, x, pos=None):

"""Return the format for tick val x at position pos; pos=None

indicated unspecified"""

raise NotImplementedError('Derived must override')

def format_data(self, value):

return self.__call__(value)

def format_data_short(self, value):

"""return a short string version"""

return self.format_data(value)

def get_offset(self):

return ''

def set_locs(self, locs):

self.locs = locs

def fix_minus(self, s):

"""

Some classes may want to replace a hyphen for minus with the

proper unicode symbol (U+2212) for typographical correctness.

The default is to not replace it.

Note, if you use this method, e.g., in :meth:`format_data` or

call, you probably don't want to use it for

:meth:`format_data_short` since the toolbar uses this for

interactive coord reporting and I doubt we can expect GUIs

across platforms will handle the unicode correctly. So for

now the classes that override :meth:`fix_minus` should have an

explicit :meth:`format_data_short` method

"""

return s

class IndexFormatter(Formatter):

"""

format the position x to the nearest i-th label where i=int(x+0.5)

"""

def __init__(self, labels):

self.labels = labels

self.n = len(labels)

def __call__(self, x, pos=None):

"""Return the format for tick val x at position pos; pos=None

indicated unspecified"""

i = int(x + 0.5)

if i < 0:

return ''

elif i >= self.n:

return ''

else:

return self.labels[i]

class NullFormatter(Formatter):

'Always return the empty string'

def __call__(self, x, pos=None):

'Return the format for tick val *x* at position *pos*'

return ''

class FixedFormatter(Formatter):

'Return fixed strings for tick labels'

def __init__(self, seq):

"""

*seq* is a sequence of strings. For positions ``i < len(seq)`` return

*seq[i]* regardless of *x*. Otherwise return ''

"""

self.seq = seq

self.offset_string = ''

def __call__(self, x, pos=None):

'Return the format for tick val *x* at position *pos*'

if pos is None or pos >= len(self.seq):

return ''

else:

return self.seq[pos]

def get_offset(self):

return self.offset_string

def set_offset_string(self, ofs):

self.offset_string = ofs

class FuncFormatter(Formatter):

"""

User defined function for formatting

"""

def __init__(self, func):

self.func = func

def __call__(self, x, pos=None):

'Return the format for tick val *x* at position *pos*'

return self.func(x, pos)

class FormatStrFormatter(Formatter):

"""

Use an old-style ('%' operator) format string to format the tick

"""

def __init__(self, fmt):

self.fmt = fmt

def __call__(self, x, pos=None):

'Return the format for tick val *x* at position *pos*'

return self.fmt % x

class StrMethodFormatter(Formatter):

"""

Use a new-style format string (as used by `str.format()`)

to format the tick. The field formatting must be labeled `x`.

"""

def __init__(self, fmt):

self.fmt = fmt

def __call__(self, x, pos=None):

'Return the format for tick val *x* at position *pos*'

return self.fmt.format(x=x)

class OldScalarFormatter(Formatter):

"""

Tick location is a plain old number.

"""

def __call__(self, x, pos=None):

'Return the format for tick val *x* at position *pos*'

xmin, xmax = self.axis.get_view_interval()

d = abs(xmax - xmin)

return self.pprint_val(x, d)

def pprint_val(self, x, d):

#if the number is not too big and it's an int, format it as an

#int

if abs(x) < 1e4 and x == int(x):

return '%d' % x

if d < 1e-2:

fmt = '%1.3e'

elif d < 1e-1:

fmt = '%1.3f'

elif d > 1e5:

fmt = '%1.1e'

elif d > 10:

fmt = '%1.1f'

elif d > 1:

fmt = '%1.2f'

else:

fmt = '%1.3f'

s = fmt % x

#print d, x, fmt, s

tup = s.split('e')

if len(tup) == 2:

mantissa = tup[0].rstrip('0').rstrip('.')

sign = tup[1][0].replace('+', '')

exponent = tup[1][1:].lstrip('0')

s = '%se%s%s' % (mantissa, sign, exponent)

else:

s = s.rstrip('0').rstrip('.')

return s

class ScalarFormatter(Formatter):

"""

Tick location is a plain old number. If useOffset==True and the data range

is much smaller than the data average, then an offset will be determined

such that the tick labels are meaningful. Scientific notation is used for

data < 10^-n or data >= 10^m, where n and m are the power limits set using

set_powerlimits((n,m)). The defaults for these are controlled by the

axes.formatter.limits rc parameter.

"""

def __init__(self, useOffset=None, useMathText=None, useLocale=None):

# useOffset allows plotting small data ranges with large offsets: for

# example: [1+1e-9,1+2e-9,1+3e-9] useMathText will render the offset

# and scientific notation in mathtext

if useOffset is None:

useOffset = rcParams['axes.formatter.useoffset']

self.set_useOffset(useOffset)

self._usetex = rcParams['text.usetex']

if useMathText is None:

useMathText = rcParams['axes.formatter.use_mathtext']

self._useMathText = useMathText

self.orderOfMagnitude = 0

self.format = ''

self._scientific = True

self._powerlimits = rcParams['axes.formatter.limits']

if useLocale is None:

useLocale = rcParams['axes.formatter.use_locale']

self._useLocale = useLocale

def get_useOffset(self):

return self._useOffset

def set_useOffset(self, val):

if val in [True, False]:

self.offset = 0

self._useOffset = val

else:

self._useOffset = False

self.offset = val

useOffset = property(fget=get_useOffset, fset=set_useOffset)

def get_useLocale(self):

return self._useLocale

def set_useLocale(self, val):

if val is None:

self._useLocale = rcParams['axes.formatter.use_locale']

else:

self._useLocale = val

useLocale = property(fget=get_useLocale, fset=set_useLocale)

def fix_minus(self, s):

"""use a unicode minus rather than hyphen"""

if rcParams['text.usetex'] or not rcParams['axes.unicode_minus']:

return s

else:

return s.replace('-', '\u2212')

def __call__(self, x, pos=None):

'Return the format for tick val *x* at position *pos*'

if len(self.locs) == 0:

return ''

else:

s = self.pprint_val(x)

return self.fix_minus(s)

def set_scientific(self, b):

'''True or False to turn scientific notation on or off

see also :meth:`set_powerlimits`

'''

self._scientific = bool(b)

def set_powerlimits(self, lims):

'''

Sets size thresholds for scientific notation.

e.g., ``formatter.set_powerlimits((-3, 4))`` sets the pre-2007 default

in which scientific notation is used for numbers less than 1e-3 or

greater than 1e4.

See also :meth:`set_scientific`.

'''

assert len(lims) == 2, "argument must be a sequence of length 2"

self._powerlimits = lims

def format_data_short(self, value):

"""return a short formatted string representation of a number"""

if self._useLocale:

return locale.format_string('%-12g', (value,))

else:

return '%-12g' % value

def format_data(self, value):

'return a formatted string representation of a number'

if self._useLocale:

s = locale.format_string('%1.10e', (value,))

else:

s = '%1.10e' % value

s = self._formatSciNotation(s)

return self.fix_minus(s)

def get_offset(self):

"""Return scientific notation, plus offset"""

if len(self.locs) == 0:

return ''

s = ''

if self.orderOfMagnitude or self.offset:

offsetStr = ''

sciNotStr = ''

if self.offset:

offsetStr = self.format_data(self.offset)

if self.offset > 0:

offsetStr = '+' + offsetStr

if self.orderOfMagnitude:

if self._usetex or self._useMathText:

sciNotStr = self.format_data(10 ** self.orderOfMagnitude)

else:

sciNotStr = '1e%d' % self.orderOfMagnitude

if self._useMathText:

if sciNotStr != '':

sciNotStr = r'\times\mathdefault{%s}' % sciNotStr

s = ''.join(('$', sciNotStr,

r'\mathdefault{', offsetStr, '}$'))

elif self._usetex:

if sciNotStr != '':

sciNotStr = r'\times%s' % sciNotStr

s = ''.join(('$', sciNotStr, offsetStr, '$'))

else:

s = ''.join((sciNotStr, offsetStr))

return self.fix_minus(s)

def set_locs(self, locs):

'set the locations of the ticks'

self.locs = locs

if len(self.locs) > 0:

vmin, vmax = self.axis.get_view_interval()

d = abs(vmax - vmin)

if self._useOffset:

self._set_offset(d)

self._set_orderOfMagnitude(d)

self._set_format(vmin, vmax)

def _set_offset(self, range):

# offset of 20,001 is 20,000, for example

locs = self.locs

if locs is None or not len(locs) or range == 0:

self.offset = 0

return

ave_loc = np.mean(locs)

if ave_loc: # dont want to take log10(0)

ave_oom = math.floor(math.log10(np.mean(np.absolute(locs))))

range_oom = math.floor(math.log10(range))

if np.absolute(ave_oom - range_oom) >= 3: # four sig-figs

p10 = 10 ** range_oom

if ave_loc < 0:

self.offset = (math.ceil(np.max(locs) / p10) * p10)

else:

self.offset = (math.floor(np.min(locs) / p10) * p10)

else:

self.offset = 0

def _set_orderOfMagnitude(self, range):

# if scientific notation is to be used, find the appropriate exponent

# if using an numerical offset, find the exponent after applying the

# offset

if not self._scientific:

self.orderOfMagnitude = 0

return

locs = np.absolute(self.locs)

if self.offset:

oom = math.floor(math.log10(range))

else:

if locs[0] > locs[-1]:

val = locs[0]

else:

val = locs[-1]

if val == 0:

oom = 0

else:

oom = math.floor(math.log10(val))

if oom <= self._powerlimits[0]:

self.orderOfMagnitude = oom

elif oom >= self._powerlimits[1]:

self.orderOfMagnitude = oom

else:

self.orderOfMagnitude = 0

def _set_format(self, vmin, vmax):

# set the format string to format all the ticklabels

if len(self.locs) < 2:

# Temporarily augment the locations with the axis end points.

_locs = list(self.locs) + [vmin, vmax]

else:

_locs = self.locs

locs = (np.asarray(_locs) - self.offset) / 10. ** self.orderOfMagnitude

loc_range = np.ptp(locs)

if len(self.locs) < 2:

# We needed the end points only for the loc_range calculation.

locs = locs[:-2]

loc_range_oom = int(math.floor(math.log10(loc_range)))

# first estimate:

sigfigs = max(0, 3 - loc_range_oom)

# refined estimate:

thresh = 1e-3 * 10 ** loc_range_oom

while sigfigs >= 0:

if np.abs(locs - np.round(locs, decimals=sigfigs)).max() < thresh:

sigfigs -= 1

else:

break

sigfigs += 1

self.format = '%1.' + str(sigfigs) + 'f'

if self._usetex:

self.format = '$%s$' % self.format

elif self._useMathText:

self.format = '$\mathdefault{%s}$' % self.format

def pprint_val(self, x):

xp = (x - self.offset) / (10. ** self.orderOfMagnitude)

if np.absolute(xp) < 1e-8:

xp = 0

if self._useLocale:

return locale.format_string(self.format, (xp,))

else:

return self.format % xp

def _formatSciNotation(self, s):

# transform 1e+004 into 1e4, for example

if self._useLocale:

decimal_point = locale.localeconv()['decimal_point']

positive_sign = locale.localeconv()['positive_sign']

else:

decimal_point = '.'

positive_sign = '+'

tup = s.split('e')

try:

significand = tup[0].rstrip('0').rstrip(decimal_point)

sign = tup[1][0].replace(positive_sign, '')

exponent = tup[1][1:].lstrip('0')

if self._useMathText or self._usetex:

if significand == '1' and exponent != '':

# reformat 1x10^y as 10^y

significand = ''

if exponent:

exponent = '10^{%s%s}' % (sign, exponent)

if significand and exponent:

return r'%s{\times}%s' % (significand, exponent)

else:

return r'%s%s' % (significand, exponent)

else:

s = ('%se%s%s' % (significand, sign, exponent)).rstrip('e')

return s

except IndexError:

return s

class LogFormatter(Formatter):

"""

Format values for log axis;

"""

def __init__(self, base=10.0, labelOnlyBase=True):

"""

*base* is used to locate the decade tick,

which will be the only one to be labeled if *labelOnlyBase*

is ``False``

"""

self._base = base + 0.0

self.labelOnlyBase = labelOnlyBase

def base(self, base):

"""change the *base* for labeling - warning: should always match the

base used for :class:`LogLocator`"""

self._base = base

def label_minor(self, labelOnlyBase):

'switch on/off minor ticks labeling'

self.labelOnlyBase = labelOnlyBase

def __call__(self, x, pos=None):

"""Return the format for tick val *x* at position *pos*"""

vmin, vmax = self.axis.get_view_interval()

d = abs(vmax - vmin)

b = self._base

if x == 0.0:

return '0'

sign = np.sign(x)

# only label the decades

fx = math.log(abs(x)) / math.log(b)

isDecade = is_close_to_int(fx)

if not isDecade and self.labelOnlyBase:

s = ''

elif x > 10000:

s = '%1.0e' % x

elif x < 1:

s = '%1.0e' % x

else:

s = self.pprint_val(x, d)

if sign == -1:

s = '-%s' % s

return self.fix_minus(s)

def format_data(self, value):

b = self.labelOnlyBase

self.labelOnlyBase = False

value = cbook.strip_math(self.__call__(value))

self.labelOnlyBase = b

return value

def format_data_short(self, value):

'return a short formatted string representation of a number'

return '%-12g' % value

def pprint_val(self, x, d):

#if the number is not too big and it's an int, format it as an

#int

if abs(x) < 1e4 and x == int(x):

return '%d' % x

if d < 1e-2:

fmt = '%1.3e'

elif d < 1e-1:

fmt = '%1.3f'

elif d > 1e5:

fmt = '%1.1e'

elif d > 10:

fmt = '%1.1f'

elif d > 1:

fmt = '%1.2f'

else:

fmt = '%1.3f'

s = fmt % x

#print d, x, fmt, s

tup = s.split('e')

if len(tup) == 2:

mantissa = tup[0].rstrip('0').rstrip('.')

sign = tup[1][0].replace('+', '')

exponent = tup[1][1:].lstrip('0')

s = '%se%s%s' % (mantissa, sign, exponent)

else:

s = s.rstrip('0').rstrip('.')

return s

class LogFormatterExponent(LogFormatter):

"""

Format values for log axis; using ``exponent = log_base(value)``

"""

def __call__(self, x, pos=None):

"""Return the format for tick val *x* at position *pos*"""

vmin, vmax = self.axis.get_view_interval()

vmin, vmax = mtransforms.nonsingular(vmin, vmax, expander=0.05)

d = abs(vmax - vmin)

b = self._base

if x == 0:

return '0'

sign = np.sign(x)

# only label the decades

fx = math.log(abs(x)) / math.log(b)

isDecade = is_close_to_int(fx)

if not isDecade and self.labelOnlyBase:

s = ''

elif abs(fx) > 10000:

s = '%1.0g' % fx

elif abs(fx) < 1:

s = '%1.0g' % fx

else:

s = self.pprint_val(fx, d)

if sign == -1:

s = '-%s' % s

return self.fix_minus(s)

class LogFormatterMathtext(LogFormatter):

"""

Format values for log axis; using ``exponent = log_base(value)``

"""

def __call__(self, x, pos=None):

'Return the format for tick val *x* at position *pos*'

b = self._base

usetex = rcParams['text.usetex']

# only label the decades

if x == 0:

if usetex:

return '$0$'

else:

return '$\mathdefault{0}$'

fx = math.log(abs(x)) / math.log(b)

is_decade = is_close_to_int(fx)

sign_string = '-' if x < 0 else ''

# use string formatting of the base if it is not an integer

if b % 1 == 0.0:

base = '%d' % b

else:

base = '%s' % b

if not is_decade and self.labelOnlyBase:

return ''

elif not is_decade:

if usetex:

return (r'$%s%s^{%.2f}$') % \

(sign_string, base, fx)

else:

return ('$\mathdefault{%s%s^{%.2f}}$') % \

(sign_string, base, fx)

else:

if usetex:

return (r'$%s%s^{%d}$') % (sign_string,

base,

nearest_long(fx))

else:

return (r'$\mathdefault{%s%s^{%d}}$') % (sign_string,

base,

nearest_long(fx))

class EngFormatter(Formatter):

"""

Formats axis values using engineering prefixes to represent powers of 1000,

plus a specified unit, e.g., 10 MHz instead of 1e7.

"""

# the unicode for -6 is the greek letter mu

# commeted here due to bug in pep8

# (https://github.com/jcrocholl/pep8/issues/271)

# The SI engineering prefixes

ENG_PREFIXES = {

-24: "y",

-21: "z",

-18: "a",

-15: "f",

-12: "p",

-9: "n",

-6: "\u03bc",

-3: "m",

0: "",

3: "k",

6: "M",

9: "G",

12: "T",

15: "P",

18: "E",

21: "Z",

24: "Y"

}

def __init__(self, unit="", places=None):

self.unit = unit

self.places = places

def __call__(self, x, pos=None):

s = "%s%s" % (self.format_eng(x), self.unit)

return self.fix_minus(s)

def format_eng(self, num):

""" Formats a number in engineering notation, appending a letter

representing the power of 1000 of the original number. Some examples:

>>> format_eng(0) # for self.places = 0

'0'

>>> format_eng(1000000) # for self.places = 1

'1.0 M'

>>> format_eng("-1e-6") # for self.places = 2

u'-1.00 \u03bc'

@param num: the value to represent

@type num: either a numeric value or a string that can be converted to

a numeric value (as per decimal.Decimal constructor)

@return: engineering formatted string

"""

dnum = decimal.Decimal(str(num))

sign = 1

if dnum < 0:

sign = -1

dnum = -dnum

if dnum != 0:

pow10 = decimal.Decimal(int(math.floor(dnum.log10() / 3) * 3))

else:

pow10 = decimal.Decimal(0)

pow10 = pow10.min(max(self.ENG_PREFIXES.keys()))

pow10 = pow10.max(min(self.ENG_PREFIXES.keys()))

prefix = self.ENG_PREFIXES[int(pow10)]

mant = sign * dnum / (10 ** pow10)

if self.places is None:

format_str = "%g %s"

elif self.places == 0:

format_str = "%i %s"

elif self.places > 0:

format_str = ("%%.%if %%s" % self.places)

formatted = format_str % (mant, prefix)

return formatted.strip()

class Locator(TickHelper):

"""

Determine the tick locations;

Note, you should not use the same locator between different

:class:`~matplotlib.axis.Axis` because the locator stores references to

the Axis data and view limits

"""

# Some automatic tick locators can generate so many ticks they

# kill the machine when you try and render them.

# This parameter is set to cause locators to raise an error if too

# many ticks are generated.

MAXTICKS = 1000

def tick_values(self, vmin, vmax):

"""

Return the values of the located ticks given **vmin** and **vmax**.

.. note::

To get tick locations with the vmin and vmax values defined

automatically for the associated :attr:`axis` simply call

the Locator instance::

>>> print((type(loc)))

<type 'Locator'>

>>> print((loc()))

[1, 2, 3, 4]

"""

raise NotImplementedError('Derived must override')

def __call__(self):

"""Return the locations of the ticks"""

# note: some locators return data limits, other return view limits,

# hence there is no *one* interface to call self.tick_values.

raise NotImplementedError('Derived must override')

def raise_if_exceeds(self, locs):

"""raise a RuntimeError if Locator attempts to create more than

MAXTICKS locs"""

if len(locs) >= self.MAXTICKS:

msg = ('Locator attempting to generate %d ticks from %s to %s: ' +

'exceeds Locator.MAXTICKS') % (len(locs), locs[0], locs[-1])

raise RuntimeError(msg)

return locs

def view_limits(self, vmin, vmax):

"""

select a scale for the range from vmin to vmax

Normally this method is overridden by subclasses to

change locator behaviour.

"""

return mtransforms.nonsingular(vmin, vmax)

def autoscale(self):

"""autoscale the view limits"""

return self.view_limits(*self.axis.get_view_interval())

def pan(self, numsteps):

"""Pan numticks (can be positive or negative)"""

ticks = self()

numticks = len(ticks)

vmin, vmax = self.axis.get_view_interval()

vmin, vmax = mtransforms.nonsingular(vmin, vmax, expander=0.05)

if numticks > 2:

step = numsteps * abs(ticks[0] - ticks[1])

else:

d = abs(vmax - vmin)

step = numsteps * d / 6.

vmin += step

vmax += step

self.axis.set_view_interval(vmin, vmax, ignore=True)

def zoom(self, direction):

"Zoom in/out on axis; if direction is >0 zoom in, else zoom out"

vmin, vmax = self.axis.get_view_interval()

vmin, vmax = mtransforms.nonsingular(vmin, vmax, expander=0.05)

interval = abs(vmax - vmin)

step = 0.1 * interval * direction

self.axis.set_view_interval(vmin + step, vmax - step, ignore=True)

def refresh(self):

"""refresh internal information based on current lim"""

pass

class IndexLocator(Locator):

"""

Place a tick on every multiple of some base number of points

plotted, eg on every 5th point. It is assumed that you are doing

index plotting; ie the axis is 0, len(data). This is mainly

useful for x ticks.

"""

def __init__(self, base, offset):

'place ticks on the i-th data points where (i-offset)%base==0'