Patched tick-generation on pan/zoom & misc. tidying

Author: rwpenney

doc/users/next_whats_new/asinh_scale.rst

@@ -5,8 +5,7 @@ The new ``asinh`` axis scale offers an alternative to ``symlog`` that
 smoothly transitions between the quasi-linear and asymptotically logarithmic
 regions of the scale. This is based on an arcsinh transformation that
 allows plotting both positive and negative values that span many orders
-of magnitude. A scale parameter is provided to allow the user
-to tune the width of the linear region of the scale.
+of magnitude.
 
 .. plot::
 

examples/images_contours_and_fields/colormap_normalizations_symlognorm.py

@@ -35,7 +35,7 @@ def rbf(x, y):
 
 shadeopts = {'cmap': 'PRGn', 'shading': 'gouraud'}
 colormap = 'PRGn'
-lnrwidth = 0.2
+lnrwidth = 0.5
 
 fig, ax = plt.subplots(2, 1, sharex=True, sharey=True)
 
@@ -60,23 +60,23 @@ def rbf(x, y):
 # the option of using the `~.colors.AsinhNorm`, which has a smoother
 # transition between the linear and logarithmic regions of the transformation
 # applied to the "z" axis.
-# In the plots below, it may be possible to see ring-like artifacts
-# in the lower-amplitude, negative, hump shown in purple despite
-# there being no sharp features in the dataset itself.
-# The ``asinh`` scaling shows a smoother shading of each hump.
+# In the plots below, it may be possible to see contour-like artifacts
+# around each hump despite there being no sharp features
+# in the dataset itself. The ``asinh`` scaling shows a smoother shading
+# of each hump.
 
 fig, ax = plt.subplots(2, 1, sharex=True, sharey=True)
 
 pcm = ax[0].pcolormesh(X, Y, Z,
                        norm=colors.SymLogNorm(linthresh=lnrwidth, linscale=1,
-                                              vmin=-2, vmax=gain, base=10),
+                                              vmin=-gain, vmax=gain, base=10),
                        **shadeopts)
 fig.colorbar(pcm, ax=ax[0], extend='both')
 ax[0].text(-2.5, 1.5, 'symlog')
 
 pcm = ax[1].pcolormesh(X, Y, Z,
                        norm=colors.AsinhNorm(linear_width=lnrwidth,
-                                             vmin=-2, vmax=gain),
+                                             vmin=-gain, vmax=gain),
                        **shadeopts)
 fig.colorbar(pcm, ax=ax[1], extend='both')
 ax[1].text(-2.5, 1.5, 'asinh')

examples/scales/asinh_demo.py

@@ -64,7 +64,7 @@
 # Compare "asinh" graphs with different scale parameter "linear_width":
 fig2 = plt.figure(constrained_layout=True)
 axs = fig2.subplots(1, 3, sharex=True)
-for ax, (a0, base) in zip(axs, ((0.2, 2), (1.0, 0), (5.0, 3))):
+for ax, (a0, base) in zip(axs, ((0.2, 2), (1.0, 0), (5.0, 10))):
     ax.set_title('linear_width={:.3g}'.format(a0))
     ax.plot(x, x, label='y=x')
     ax.plot(x, 10*x, label='y=10x')

lib/matplotlib/scale.py

@@ -465,7 +465,8 @@ class AsinhTransform(Transform):
     def __init__(self, linear_width):
         super().__init__()
         if linear_width <= 0.0:
-            raise ValueError("Scale parameter 'linear_width' must be strictly positive")
+            raise ValueError("Scale parameter 'linear_width' " +
+                             "must be strictly positive")
         self.linear_width = linear_width
 
     def transform_non_affine(self, a):

lib/matplotlib/tests/test_ticker.py

@@ -517,7 +517,7 @@ def test_symmetrizing(self):
         class DummyAxis:
             bounds = (-1, 1)
             @classmethod
-            def get_data_interval(cls): return cls.bounds
+            def get_view_interval(cls): return cls.bounds
 
         lctr = mticker.AsinhLocator(linear_width=1, numticks=3,
                                     symthresh=0.25, base=0)

lib/matplotlib/ticker.py

@@ -2636,13 +2636,13 @@ def set_params(self, numticks=None, symthresh=None,
             self.subs = subs if len(subs) > 0 else None
 
     def __call__(self):
-        dmin, dmax = self.axis.get_data_interval()
-        if (dmin * dmax) < 0 and abs(1 + dmax / dmin) < self.symthresh:
+        vmin, vmax = self.axis.get_view_interval()
+        if (vmin * vmax) < 0 and abs(1 + vmax / vmin) < self.symthresh:
             # Data-range appears to be almost symmetric, so round up:
-            bound = max(abs(dmin), abs(dmax))
+            bound = max(abs(vmin), abs(vmax))
             return self.tick_values(-bound, bound)
         else:
-            return self.tick_values(dmin, dmax)
+            return self.tick_values(vmin, vmax)
 
     def tick_values(self, vmin, vmax):
         # Construct a set of "on-screen" locations
@@ -2660,7 +2660,9 @@ def tick_values(self, vmin, vmax):
         xs = self.linear_width * np.sinh(ys / self.linear_width)
         zero_xs = (ys == 0)
 
-        # Round the data-space values to be intuitive base-n numbers:
+        # Round the data-space values to be intuitive base-n numbers,
+        # keeping track of positive and negative values separately,
+        # but giving careful treatment to the zero value:
         if self.base > 1:
             log_base = math.log(self.base)
             powers = (