replace separate function axline_transaxes with new functionality for axline

johan12345 · johan12345 · commit c91537bd0f4b · 2020-10-20T19:33:48.000+02:00
diff --git a/lib/matplotlib/axes/_axes.py b/lib/matplotlib/axes/_axes.py
@@ -808,6 +808,12 @@ def axline(self, xy1, xy2=None, *, slope=None, **kwargs):
         all other scales, and thus the behavior is undefined. Please specify
         the line using the points *xy1*, *xy2* for non-linear scales.
 
+        As part of the ``kwargs``, a 'transform' can be passed. In the case
+        that a point and a slope are given, the transformation will only be
+        used for the point and not for the slope, i.e. the slope stays in data
+        coordinates. This can be used e.g. with ``ax.transAxes`` for drawing grid
+        lines with a fixed slope.
+
         Parameters
         ----------
         xy1, xy2 : (float, float)
@@ -823,8 +829,7 @@ def axline(self, xy1, xy2=None, *, slope=None, **kwargs):
         Other Parameters
         ----------------
         **kwargs
-            Valid kwargs are `.Line2D` properties, with the exception of
-            'transform':
+            Valid kwargs are `.Line2D` properties
 
             %(_Line2D_docstr)s
 
@@ -839,30 +844,21 @@ def axline(self, xy1, xy2=None, *, slope=None, **kwargs):
 
             >>> axline((0, 0), (1, 1), linewidth=4, color='r')
         """
-        def _to_points(xy1, xy2, slope):
-            """
-            Check for a valid combination of input parameters and convert
-            to two points, if necessary.
-            """
-            if (xy2 is None and slope is None or
-                    xy2 is not None and slope is not None):
-                raise TypeError(
-                    "Exactly one of 'xy2' and 'slope' must be given")
-            if xy2 is None:
-                x1, y1 = xy1
-                xy2 = (x1, y1 + 1) if np.isinf(slope) else (x1 + 1, y1 + slope)
-            return xy1, xy2
+        if (xy2 is None and slope is None or
+                xy2 is not None and slope is not None):
+            raise TypeError(
+                "Exactly one of 'xy2' and 'slope' must be given")
 
-        if "transform" in kwargs:
-            raise TypeError("'transform' is not allowed as a kwarg; "
-                            "axline generates its own transform")
         if slope is not None and (self.get_xscale() != 'linear' or
                                   self.get_yscale() != 'linear'):
             raise TypeError("'slope' cannot be used with non-linear scales")
 
         datalim = [xy1] if xy2 is None else [xy1, xy2]
-        (x1, y1), (x2, y2) = _to_points(xy1, xy2, slope)
-        line = mlines._AxLine([x1, x2], [y1, y2], **kwargs)
+        if "transform" in kwargs:
+            #TODO: datalim = (kwargs["transform"] + self.transData.inverted()).transform(datalim)?
+            datalim = []
+
+        line = mlines._AxLine(xy1, xy2, slope, **kwargs)
         # Like add_line, but correctly handling data limits.
         self._set_artist_props(line)
         if line.get_clip_path() is None:
@@ -876,59 +872,6 @@ def _to_points(xy1, xy2, slope):
         self._request_autoscale_view()
         return line
 
-    def axline_transaxes(self, xy1, slope, **kwargs):
-        """
-        Add an infinitely long straight line.
-
-        The line is defined by a *slope* in data coordinates, set by the
-        current x and y limits of the axes, and a point in axes-relative
-        coordinates, which is in the same place on the axes regardless of x
-        and y limits.
-
-        This should only be used with linear scales; the *slope* has no clear
-        meaning for all other scales, and thus the behavior is undefined.
-
-        Parameters
-        ----------
-        xy1 : (float, float)
-            Point for the line to pass through, in axes coordinates.
-            ``(0, 0)`` is the bottom left corner of the axes, ``(1, 1)`` is
-            the upper right.
-        slope : float
-            The slope of the line, in data coordinates.
-
-        Returns
-        -------
-        `.Line2D`
-
-        Other Parameters
-        ----------------
-        **kwargs
-            Valid kwargs are `.Line2D` properties, with the exception of
-            'transform':
-
-            %(_Line2D_docstr)s
-
-        See Also
-        --------
-        axhline : for horizontal lines
-        axvline : for vertical lines
-
-        Examples
-        --------
-        Draw a thick red line passing through (0, 0)
-        (the lower left corner of the viewport) with slope 1::
-
-            >>> axline_transaxes((0, 0), 1, linewidth=4, color='r')
-        """
-        if "transform" in kwargs:
-            raise TypeError("'transform' is not allowed as a kwarg; "
-                            "axline_transaxes generates its own transform")
-
-        line = mlines._AxLineTransAxes(xy1, slope, **kwargs)
-        self.add_line(line)
-        return line
-
     @docstring.dedent_interpd
     def axhspan(self, ymin, ymax, xmin=0, xmax=1, **kwargs):
         """
diff --git a/lib/matplotlib/lines.py b/lib/matplotlib/lines.py
@@ -1406,66 +1406,59 @@ class _AxLine(Line2D):
     transform at draw time.
     """
 
+    def __init__(self, xy1, xy2, slope, **kwargs):
+        super().__init__([0, 1], [0, 1], **kwargs)
+        self._slope = slope
+        self._xy1 = xy1
+        self._xy2 = xy2
+        self._transform = kwargs.get("transform")
+
     def get_transform(self):
         ax = self.axes
-        (x1, y1), (x2, y2) = ax.transScale.transform([*zip(*self.get_data())])
-        dx = x2 - x1
-        dy = y2 - y1
-        if np.allclose(x1, x2):
-            if np.allclose(y1, y2):
-                raise ValueError(
-                    f"Cannot draw a line through two identical points "
-                    f"(x={self.get_xdata()}, y={self.get_ydata()})")
-            # First send y1 to 0 and y2 to 1.
-            return (Affine2D.from_values(1, 0, 0, 1 / dy, 0, -y1 / dy)
-                    + ax.get_xaxis_transform(which="grid"))
-        if np.allclose(y1, y2):
-            # First send x1 to 0 and x2 to 1.
-            return (Affine2D.from_values(1 / dx, 0, 0, 1, -x1 / dx, 0)
-                    + ax.get_yaxis_transform(which="grid"))
+        if self._transform is not None:
+            points_transform = self._transform + ax.transData.inverted()
+        else:
+            points_transform = ax.transScale
+
+        if self._xy2 is not None:
+            # two points were given
+            (x1, y1), (x2, y2) = points_transform.transform([self._xy1, self._xy2])
+            dx = x2 - x1
+            dy = y2 - y1
+            if np.allclose(x1, x2):
+                if np.allclose(y1, y2):
+                    raise ValueError(
+                        f"Cannot draw a line through two identical points "
+                        f"(x={self.get_xdata()}, y={self.get_ydata()})")
+                # First send y1 to 0 and y2 to 1.
+                return (Affine2D.from_values(1, 0, 0, 1 / dy, 0, -y1 / dy)
+                        + ax.get_xaxis_transform(which="grid"))
+            slope = dy / dx
+        else:
+            # one point and a slope were given
+            x1, y1 = points_transform.transform(self._xy1)
+            slope = self._slope
         (vxlo, vylo), (vxhi, vyhi) = ax.transScale.transform(ax.viewLim)
         # General case: find intersections with view limits in either
         # direction, and draw between the middle two points.
-        _, start, stop, _ = sorted([
-            (vxlo, y1 + (vxlo - x1) * dy / dx),
-            (vxhi, y1 + (vxhi - x1) * dy / dx),
-            (x1 + (vylo - y1) * dx / dy, vylo),
-            (x1 + (vyhi - y1) * dx / dy, vyhi),
-        ])
-        return (BboxTransformFrom(Bbox([*zip(*self.get_data())]))
-                + BboxTransformTo(Bbox([start, stop]))
+        if np.isclose(slope, 0):
+            start = vxlo, y1
+            stop = vxhi, y1
+        else:
+            _, start, stop, _ = sorted([
+                (vxlo, y1 + (vxlo - x1) * slope),
+                (vxhi, y1 + (vxhi - x1) * slope),
+                (x1 + (vylo - y1) / slope, vylo),
+                (x1 + (vyhi - y1) / slope, vyhi),
+            ])
+        return (BboxTransformTo(Bbox([start, stop]))
                 + ax.transLimits + ax.transAxes)
 
     def draw(self, renderer):
         self._transformed_path = None  # Force regen.
         super().draw(renderer)
 
 
-class _AxLineTransAxes(_AxLine):
-    """
-    A helper class that implements `~.Axes.axline_transaxes`, by recomputing
-    the artist transform at draw time.
-    """
-
-    def __init__(self, xy1, slope, **kwargs):
-        super().__init__([0, 1], [0, 1], **kwargs)
-        self._slope = slope
-        self._xy1 = xy1
-
-    def get_transform(self):
-        ax = self.axes
-        x, y = self._xy1
-
-        dx, dy = AffineDeltaTransform(ax.transData + ax.transAxes.inverted())\
-            .transform([1, self._slope])
-        slope_axes = dy / dx
-
-        start = 0, slope_axes * (0 - x) + y
-        stop = 1, slope_axes * (1 - x) + y
-
-        return BboxTransformTo(Bbox([start, stop])) + ax.transAxes
-
-
 class VertexSelector:
     """
     Manage the callbacks to maintain a list of selected vertices for
diff --git a/lib/matplotlib/tests/test_axes.py b/lib/matplotlib/tests/test_axes.py
@@ -4076,9 +4076,9 @@ def test_axline(fig_test, fig_ref):
 def test_axline_transaxes(fig_test, fig_ref):
     ax = fig_test.subplots()
     ax.set(xlim=(-1, 1), ylim=(-1, 1))
-    ax.axline_transaxes((0, 0), slope=1)
-    ax.axline_transaxes((1, 0.5), slope=1, color='C1')
-    ax.axline_transaxes((0.5, 0.5), slope=0, color='C2')
+    ax.axline((0, 0), slope=1, transform=ax.transAxes)
+    ax.axline((1, 0.5), slope=1, color='C1', transform=ax.transAxes)
+    ax.axline((0.5, 0.5), slope=0, color='C2', transform=ax.transAxes)
 
     ax = fig_ref.subplots()
     ax.set(xlim=(-1, 1), ylim=(-1, 1))
@@ -4093,9 +4093,9 @@ def test_axline_transaxes_panzoom(fig_test, fig_ref):
     # figure resize after plotting
     ax = fig_test.subplots()
     ax.set(xlim=(-1, 1), ylim=(-1, 1))
-    ax.axline_transaxes((0, 0), slope=1)
-    ax.axline_transaxes((0.5, 0.5), slope=2, color='C1')
-    ax.axline_transaxes((0.5, 0.5), slope=0, color='C2')
+    ax.axline((0, 0), slope=1, transform=ax.transAxes)
+    ax.axline((0.5, 0.5), slope=2, color='C1', transform=ax.transAxes)
+    ax.axline((0.5, 0.5), slope=0, color='C2', transform=ax.transAxes)
     ax.set(xlim=(0, 5), ylim=(0, 10))
     fig_test.set_size_inches(3, 3)
 
