ticker: overhaul AutoMinorLocator, add optional argument

efiring · efiring · commit 06206a00721f · 2011-07-02T15:33:31.000-10:00
The optional argument allows one to specify the number of
minor intervals per major interval.

If that number is not specified, the overhaul improves the
automated choice of 4 or 5 intervals.  For example, a major
interval of 10 now yields 5 intervals instead of 4.

major_minor_demo2.py was also changed to illustrate the
AutoMinorLocator.
diff --git a/examples/pylab_examples/major_minor_demo2.py b/examples/pylab_examples/major_minor_demo2.py
@@ -1,26 +1,34 @@
 #!/usr/bin/env python
 """
-Set the major ticks on the ints and minor ticks on multiples of 0.2
+Automatic tick selection for major and minor ticks.
+
+Use interactive pan and zoom to see how the tick intervals
+change. There will be either 4 or 5 minor tick intervals
+per major interval, depending on the major interval.
 """
 
-from pylab import *
-from matplotlib.ticker import MultipleLocator, FormatStrFormatter
+import numpy as np
+import matplotlib.pyplot as plt
+from matplotlib.ticker import AutoMinorLocator
 
-majorLocator   = MultipleLocator(1)
-majorFormatter = FormatStrFormatter('%d')
-minorLocator   = MultipleLocator(.2)
+# One can supply an argument to AutoMinorLocator to
+# specify a fixed number of minor intervals per major interval, e.g.:
+# minorLocator = AutoMinorLocator(2)
+# would lead to a single minor tick between major ticks.
 
+minorLocator   = AutoMinorLocator()
 
-t = arange(0.0, 10.0, 0.01)
-s = sin(2*pi*t)*exp(-t*0.01)
 
-ax = subplot(111)
-plot(t,s)
+t = np.arange(0.0, 100.0, 0.01)
+s = np.sin(2*np.pi*t)*np.exp(-t*0.01)
 
-ax.xaxis.set_major_locator(majorLocator)
-ax.xaxis.set_major_formatter(majorFormatter)
+ax = plt.subplot(111)
+plt.plot(t,s)
 
-#for the minor ticks, use no labels; default NullFormatter
 ax.xaxis.set_minor_locator(minorLocator)
 
-show()
+plt.tick_params(which='both', width=2)
+plt.tick_params(which='major', length=7)
+plt.tick_params(which='minor', length=4, color='r')
+
+plt.show()
diff --git a/lib/matplotlib/ticker.py b/lib/matplotlib/ticker.py
@@ -50,6 +50,13 @@
     :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
 
@@ -1402,6 +1409,16 @@ class AutoMinorLocator(Locator):
     major ticks. Assumes the scale is linear and major ticks are
     evenly spaced.
     """
+    def __init__(self, n=None):
+        """
+        *n* is the number of subdivisions of the interval between
+        major ticks; e.g., n=2 will place a single minor tick midway
+        between major ticks.
+
+        If *n* is omitted or None, it will be set to 5 or 4.
+        """
+        self.ndivs = n
+
     def __call__(self):
         'Return the locations of the ticks'
         majorlocs = self.axis.get_majorticklocs()
@@ -1410,25 +1427,28 @@ def __call__(self):
         except IndexError:
             raise ValueError('Need at least two major ticks to find minor '
                              'tick locations')
-        # see whether major step should be divided by 5, 4. This
-        # should cover most cases.
-        temp = float(('%e' % majorstep).split('e')[0])
-        if temp % 5 < 1e-10:
-            minorstep = majorstep / 5.
+
+        if self.ndivs is None:
+            x = int(round(10 ** (np.log10(majorstep) % 1)))
+            if x in [1, 5, 10]:
+                ndivs = 5
+            else:
+                ndivs = 4
         else:
-            minorstep = majorstep / 4.
+            ndivs = self.ndivs
+
+        minorstep = majorstep / ndivs
 
-        tmin = majorlocs[0] - majorstep
-        tmax = majorlocs[-1] + majorstep
-        locs = np.arange(tmin, tmax, minorstep)
         vmin, vmax = self.axis.get_view_interval()
         if vmin > vmax:
             vmin,vmax = vmax,vmin
-        locs = locs[(vmin < locs) & (locs < vmax)]
 
-        # don't create minor ticks on top of existing major ticks
-        diff = 0.5 * abs(locs[1] - locs[0])
-        locs = [l for l in locs if (np.abs(l - majorlocs) > diff).all()]
+        t0 = majorlocs[0]
+        tmin = np.ceil((vmin - t0) / minorstep) * minorstep
+        tmax = np.floor((vmax - t0) / minorstep) * minorstep
+        locs = np.arange(tmin, tmax, minorstep) + t0
+        cond = np.abs((locs - t0) % majorstep) > minorstep/10.0
+        locs = locs.compress(cond)
 
         return self.raise_if_exceeds(np.array(locs))
 
@@ -1495,4 +1515,4 @@ def get_locator(self, d):
            'LogFormatterMathtext', 'Locator', 'IndexLocator',
            'FixedLocator', 'NullLocator', 'LinearLocator',
            'LogLocator', 'AutoLocator', 'MultipleLocator',
-           'MaxNLocator', )
+           'MaxNLocator', 'AutoMinorLocator',)
