Improve(?) implementation of secondary_axis.

anntzer · anntzer · commit 3504a7f75f8e · 2019-06-06T16:39:39.000+02:00
Currently, secondary_xaxis is implemented by adding a child axes with a physical height set to zero and y position set accordingly relative to its parent axes (using the axes_locator mechanism). This patch changes it so that the child axes' extents actually *matches* the parent axes, and instead positioning the spines using Spine.set_position. It also makes sure that the secondary axes patch is invisible and that the bounds of the "orthogonal" axis (the one that is not shown) matches the parent bounds. By doing so, it becomes possible to plot data directly on the secondary axis as well; e.g. the following now works: ``` from matplotlib import pyplot as plt from matplotlib.axes import Axes fig, ax0 = plt.subplots() ax1 = ax0.secondary_xaxis( "top", functions=(lambda x: x**3, lambda x: x**(1/3))) Axes.plot(ax1, [.25, .5, .75], [.25, .5, .75], ".-") plt.show() ``` (We have to use Axes.plot here instead of ax1.plot just because SecondaryAxes inherits from _AxesBase, not from Axes, but that doesn't really matter.) Another advantage is that one can now use secondary_axis as a replacement for SubplotZero, a relatively obscure feature of mpl_toolkits that is only showcased in 3 examples: https://matplotlib.org/gallery/axisartist/simple_axisline.html https://matplotlib.org/gallery/axisartist/simple_axisline2.html https://matplotlib.org/gallery/axisartist/demo_axisline_style.html whose goal is just to draw a spine at x=0 or y=0. simple_axisline2 just moves its main spine to y=0, so we can implement that directly with Spine.set_position (see also simple_axisartist1). simple_axisline adds additional spines, and I added an equivalent implementation using secondary_axis, which is fairly transparent. (This example, as well as test_secondary_xy, show why the axes patch must be made invisible: otherwise, the patch of later secondary axes would be drawn over other secondary axes.) demo_axisline_style doesn't showcase anything that's specifically related to SubplotZero so I just rewrote it without SubplotZero. If we agree that secondary_axis is a suitable replacement, SubplotZero could ultimately be deprecated (in a later PR). Minor points: Also delete `SecondaryAxis._loc`, which is set in a single place and never used.
diff --git a/examples/axisartist/demo_axisline_style.py b/examples/axisartist/demo_axisline_style.py
@@ -6,24 +6,19 @@
 This example shows some configurations for axis style.
 """
 
-from mpl_toolkits.axisartist.axislines import SubplotZero
+from mpl_toolkits.axisartist.axislines import Subplot
 import matplotlib.pyplot as plt
 import numpy as np
 
 
 fig = plt.figure()
-ax = SubplotZero(fig, 111)
+ax = Subplot(fig, 111)
 fig.add_subplot(ax)
 
-for direction in ["xzero", "yzero"]:
-    # adds arrows at the ends of each axis
+for direction in ["bottom", "left"]:  # Add arrows for bottom and left axes.
     ax.axis[direction].set_axisline_style("-|>")
 
-    # adds X and Y-axis from the origin
-    ax.axis[direction].set_visible(True)
-
-for direction in ["left", "right", "bottom", "top"]:
-    # hides borders
+for direction in ["top", "right"]:  # Hide top and right axes.
     ax.axis[direction].set_visible(False)
 
 x = np.linspace(-0.5, 1., 100)
diff --git a/examples/axisartist/simple_axisartist1.py b/examples/axisartist/simple_axisartist1.py
@@ -24,4 +24,16 @@
 
 ax.set_ylim(-2, 4)
 
+###############################################################################
+# This can also be achieved without axisartist as follows:
+
+fig, ax = plt.subplots()
+
+ax.spines["bottom"].set_position(("data", 0))
+ax.set(xlabel="y = 0")
+for side in ["top", "right"]:
+    ax.spines[side].set_visible(False)
+
+ax.set_ylim(-2, 4)
+
 plt.show()
diff --git a/examples/axisartist/simple_axisline.py b/examples/axisartist/simple_axisline.py
@@ -37,4 +37,25 @@
 ax.axis["right2"].label.set_text("Label Y2")
 
 ax.plot([-2, 3, 2])
+
+###############################################################################
+# Or, without axisartist, one can use secondary axes to add the additional
+# axes:
+
+fig, ax = plt.subplots()
+fig.subplots_adjust(right=0.85)
+
+ax.spines["top"].set_visible(False)
+ax.spines["right"].set_visible(False)
+
+ax1 = ax.secondary_xaxis(0)
+ax1.spines["bottom"].set_position(("data", 0))
+ax1.set_xlabel("Axis Zero")
+
+ax2 = ax.secondary_yaxis(1)
+ax2.spines["right"].set_position(("outward", 20))
+ax2.set_ylabel("Label Y2")
+
+ax.plot([-2, 3, 2])
+
 plt.show()
diff --git a/examples/axisartist/simple_axisline2.py b/examples/axisartist/simple_axisline2.py
@@ -8,7 +8,7 @@
 from mpl_toolkits.axisartist.axislines import SubplotZero
 import numpy as np
 
-fig = plt.figure(figsize=(4, 3))
+fig = plt.figure()
 
 # a subplot with two additional axis, "xzero" and "yzero". "xzero" is
 # y=0 line, and "yzero" is x=0 line.
@@ -26,4 +26,17 @@
 xx = np.arange(0, 2*np.pi, 0.01)
 ax.plot(xx, np.sin(xx))
 
+###############################################################################
+# This can also be achieved without axisartist as follows:
+
+fig, ax = plt.subplots()
+ax.spines["bottom"].set_position(("data", 0))
+ax.set(xlabel="Axis Zero")
+for side in ["top", "right"]:
+    ax.spines[side].set_visible(False)
+
+xx = np.arange(0, 2*np.pi, 0.01)
+ax.plot(xx, np.sin(xx))
+ax.plot()
+
 plt.show()
diff --git a/lib/matplotlib/axes/_secondary_axes.py b/lib/matplotlib/axes/_secondary_axes.py
@@ -27,33 +27,6 @@
 from matplotlib.scale import Log10Transform
 
 
-def _make_secondary_locator(rect, parent):
-    """
-    Helper function to locate the secondary axes.
-
-    A locator gets used in `Axes.set_aspect` to override the default
-    locations...  It is a function that takes an axes object and
-    a renderer and tells `set_aspect` where it is to be placed.
-
-    This locator make the transform be in axes-relative co-coordinates
-    because that is how we specify the "location" of the secondary axes.
-
-    Here *rect* is a rectangle [l, b, w, h] that specifies the
-    location for the axes in the transform given by *trans* on the
-    *parent*.
-    """
-    _rect = mtransforms.Bbox.from_bounds(*rect)
-    def secondary_locator(ax, renderer):
-        # delay evaluating transform until draw time because the
-        # parent transform may have changed (i.e. if window reesized)
-        bb = mtransforms.TransformedBbox(_rect, parent.transAxes)
-        tr = parent.figure.transFigure.inverted()
-        bb = mtransforms.TransformedBbox(bb, tr)
-        return bb
-
-    return secondary_locator
-
-
 class SecondaryAxis(_AxesBase):
     """
     General class to hold a Secondary_X/Yaxis.
@@ -86,6 +59,12 @@ def __init__(self, parent, orientation,
         self._layoutbox = None
         self._poslayoutbox = None
 
+        # Make this axes always follow the parent axes' position.
+        self.set_axes_locator(
+            lambda ax, renderer:
+            self.figure.transFigure.inverted()
+            .transform_bbox(self._parent.bbox))
+
         self.set_location(location)
         self.set_functions(functions)
 
@@ -98,6 +77,7 @@ def __init__(self, parent, orientation,
         otheraxis.set_major_locator(mticker.NullLocator())
         otheraxis.set_ticks_position('none')
 
+        self.patch.set_visible(False)
         for st in self._otherstrings:
             self.spines[st].set_visible(False)
         for st in self._locstrings:
@@ -161,20 +141,8 @@ def set_location(self, location):
                                  self._locstrings[0], self._locstrings[1]))
         else:
             self._pos = location
-        self._loc = location
-
-        if self._orientation == 'x':
-            bounds = [0, self._pos, 1., 1e-10]
-        else:
-            bounds = [self._pos, 0, 1e-10, 1]
-
-        secondary_locator = _make_secondary_locator(bounds, self._parent)
-
-        # this locator lets the axes move in the parent axes coordinates.
-        # so it never needs to know where the parent is explicitly in
-        # figure co-ordinates.
-        # it gets called in `ax.apply_aspect() (of all places)
-        self.set_axes_locator(secondary_locator)
+        for loc in self._locstrings:
+            self.spines[loc].set_position(('axes', self._pos))
 
     def apply_aspect(self, position=None):
         self._set_lims()
@@ -290,14 +258,16 @@ def _set_scale(self):
     def _set_lims(self):
         """
         Set the limits based on parent limits and the convert method
-        between the parent and this secondary axes
+        between the parent and this secondary axes.
         """
         if self._orientation == 'x':
             lims = self._parent.get_xlim()
             set_lim = self.set_xlim
+            self.set_ylim(self._parent.get_ylim())
         if self._orientation == 'y':
             lims = self._parent.get_ylim()
             set_lim = self.set_ylim
+            self.set_xlim(self._parent.get_xlim())
         order = lims[0] < lims[1]
         lims = self._functions[0](np.array(lims))
         neworder = lims[0] < lims[1]
