Improved LogNorm ticks and tick labels on colorbar

efiring · NelleV · commit 1fe5820b960b · 2016-11-24T10:24:21.000-08:00
diff --git a/lib/matplotlib/colorbar.py b/lib/matplotlib/colorbar.py
@@ -310,8 +310,8 @@ def __init__(self, ax, cmap=None,
         else:
             self.locator = ticks    # Handle default in _ticker()
         if format is None:
-            if isinstance(self.norm, colors.LogNorm):
-                self.formatter = ticker.LogFormatterMathtext()
+            if isinstance(self.norm, (colors.LogNorm, colors.SymLogNorm)):
+                self.formatter = ticker.LogFormatterSciNotation()
             else:
                 self.formatter = ticker.ScalarFormatter()
         elif cbook.is_string_like(format):
@@ -574,7 +574,12 @@ def _ticker(self):
                     b = self.norm.boundaries
                     locator = ticker.FixedLocator(b, nbins=10)
                 elif isinstance(self.norm, colors.LogNorm):
-                    locator = ticker.LogLocator()
+                    locator = ticker.LogLocator(subs='all')
+                # FIXME: we should be able to use the SymmetricalLogLocator
+                # but we need to give it a transform, or modify the
+                # locator to get what it needs from the Norm.
+                # elif isinstance(self.norm, colors.SymLogNorm):
+                #     locator = ticker.SymmetricalLogLocator(...)
                 else:
                     if mpl.rcParams['_internal.classic_mode']:
                         locator = ticker.MaxNLocator()
diff --git a/lib/matplotlib/ticker.py b/lib/matplotlib/ticker.py
@@ -798,32 +798,58 @@ def _formatSciNotation(self, s):
 
 class LogFormatter(Formatter):
     """
-    Format values for log axis.
+    Base class for formatting ticks on a log or symlog scale.
+
+    It may be instantiated directly, or subclassed.
+
+    Parameters
+    ----------
+    base : float, optional, default: 10.
+        Base of the logarithm used in all calculations.
+
+    labelOnlyBase : bool, optional, default: False
+        If True, label ticks only at integer powers of base.
+        This is normally True for major ticks and False for
+        minor ticks.
+
+    minor_thresholds : (subset, all), optional, default: (1, 0.4)
+        If labelOnlyBase is False, these two numbers control
+        the labeling of ticks that are not at integer powers of
+        base; normally these are the minor ticks. The controlling
+        parameter is the log of the axis data range.  In the typical
+        case where base is 10 it is the number of decades spanned
+        by the axis, so we can call it 'numdec'. If ``numdec <= all``,
+        all minor ticks will be labeled.  If ``all < numdec <= subset``,
+        then only a subset of minor ticks will be labeled, so as to
+        avoid crowding. If ``numdec > subset`` then no minor ticks will
+        be labeled.
+
+    Notes
+    -----
+    The `set_locs` method must be called to enable the subsetting
+    logic controlled by the ``minor_thresholds`` parameter.
+
+    In some cases such as the colorbar, there is no distinction between
+    major and minor ticks; the tick locations might be set manually,
+    or by a locator that puts ticks at integer powers of base and
+    at intermediate locations.  For this situation, disable the
+    minor_thresholds logic by using ``minor_thresholds=(np.inf, np.inf)``.
+
+    Examples
+    --------
+    To label a subset of minor ticks when the view limits span up
+    to 2 decades, and all of the ticks when zoomed in to 0.5 decades
+    or less, use ``minor_thresholds=(2, 0.5)``.
+
+    To label all minor ticks when the view limits span up to 1.5
+    decades, use ``minor_thresholds=(1.5, 1.5)``.
+
+
     """
     def __init__(self, base=10.0, labelOnlyBase=False,
                  minor_thresholds=(1, 0.4)):
-        """
-        `base` is used to locate the decade tick, which will be the only
-        one to be labeled if `labelOnlyBase` is ``True``.
 
-        Parameters
-        ----------
-        base : float, optional, default: 10.
-            base of the logarithm.
-
-        labelOnlyBase : bool, optional, default: False
-            whether label ticks only at integer multiples of base.
-            This is normally True for major ticks and False for
-            minor ticks.
-
-        minor_thresholds : (subset, all), optional, default: (1, 0.4)
-            Thresholds applied to the data range measured in powers
-            of the base (numbers of "decades", or 'numdec'), and
-            effective only when labelOnlyBase is False.  Then a
-            subset of minor ticks will be labeled if `numdec <= subset`,
-            and all will be labeled if `numdec <= all`.
-        """
-        self._base = base + 0.0
+        self._base = float(base)
         self.labelOnlyBase = labelOnlyBase
         self.minor_thresholds = minor_thresholds
         self._sublabels = None
@@ -850,17 +876,24 @@ def label_minor(self, labelOnlyBase):
         """
         self.labelOnlyBase = labelOnlyBase
 
-    def set_locs(self, locs):
+    def set_locs(self, locs=None):
+        """
+        Use axis view limits to control which ticks are labeled.
+
+        The ``locs`` parameter is ignored in the present algorithm.
+
+        """
+        if np.isinf(self.minor_thresholds[0]):
+            self._sublabels = None
+            return
+
         b = self._base
 
         vmin, vmax = self.axis.get_view_interval()
         self.d = abs(vmax - vmin)
 
-        if not hasattr(self.axis, 'get_transform'):
-            # This might be a colorbar dummy axis, do not attempt to get
-            # transform
-            numdec = 10
-        elif hasattr(self.axis.get_transform(), 'linthresh'):
+        if (hasattr(self.axis, 'get_transform') and
+                hasattr(self.axis.get_transform(), 'linthresh')):
             t = self.axis.get_transform()
             linthresh = t.linthresh
             # Only compute the number of decades in the logarithmic part of the
@@ -882,11 +915,13 @@ def set_locs(self, locs):
             # Label only bases
             self._sublabels = set((1,))
         elif numdec > self.minor_thresholds[1]:
-            # Add labels between bases at log-spaced coefficients
-            c = np.logspace(0, 1, b//2 + 1, base=b)[1:-1]
+            # Add labels between bases at log-spaced coefficients;
+            # include base powers in case the locations include
+            # "major" and "minor" points, as in colorbar.
+            c = np.logspace(0, 1, b//2 + 1, base=b)
             self._sublabels = set(np.round(c))
         else:
-            self._sublabels = set(np.linspace(2, b-1, b-2))
+            self._sublabels = set(np.linspace(1, b, b-2))
 
     def __call__(self, x, pos=None):
         """
@@ -1809,7 +1844,22 @@ class LogLocator(Locator):
 
     def __init__(self, base=10.0, subs=(1.0,), numdecs=4, numticks=None):
         """
-        place ticks on the location= base**i*subs[j]
+        Place ticks on the locations : subs[j] * base**i
+
+        Parameters
+        ----------
+        subs : None, string, or sequence of float, optional, default (1.0,)
+            Gives the multiples of integer powers of the base at which
+            to place ticks.  The default places ticks only at
+            integer powers of the base.
+            The permitted string values are ``'auto'`` and ``'all'``,
+            both of which use an algorithm based on the axis view
+            limits to determine whether and how to put ticks between
+            integer powers of the base.  With ``'auto'``, ticks are
+            placed only between integer powers; with ``'all'``, the
+            integer powers are included.  A value of None is
+            equivalent to ``'auto'``.
+
         """
         if numticks is None:
             if rcParams['_internal.classic_mode']:
@@ -1832,6 +1882,9 @@ def set_params(self, base=None, subs=None, numdecs=None, numticks=None):
         if numticks is not None:
             self.numticks = numticks
 
+    # FIXME: these base and subs functions are contrary to our
+    # usual and desired API.
+
     def base(self, base):
         """
         set the base of the log scaling (major tick every base**i, i integer)
@@ -1842,8 +1895,11 @@ def subs(self, subs):
         """
         set the minor ticks for the log scaling every base**i*subs[j]
         """
-        if subs is None:
-            self._subs = None  # autosub
+        if subs is None:  # consistency with previous bad API
+            self._subs = 'auto'
+        elif cbook.is_string_like(subs):
+            # TODO: validation ('all', 'auto')
+            self._subs = subs
         else:
             self._subs = np.asarray(subs, dtype=float)
 
@@ -1887,13 +1943,17 @@ def tick_values(self, vmin, vmax):
 
         numdec = math.floor(vmax) - math.ceil(vmin)
 
-        if self._subs is None:  # autosub for minor ticks
+        if cbook.is_string_like(self._subs):
+            _first = 2.0 if self._subs == 'auto' else 1.0
             if numdec > 10 or b < 3:
-                return np.array([])  # no minor ticks
+                if self._subs == 'auto':
+                    return np.array([])  # no minor or major ticks
+                else:
+                    subs = np.array([1.0])  # major ticks
             elif numdec > 5 and b >= 6:
-                subs = np.arange(2.0, b, 2.0)
+                subs = np.arange(_first, b, 2.0)
             else:
-                subs = np.arange(2.0, b)
+                subs = np.arange(_first, b)
         else:
             subs = self._subs
 
