Extend axline shapes in data coordinates to span across zoom levels

Author: robertoffmoura

plotly/matplotlylib/renderer.py

@@ -7,6 +7,7 @@
 
 """
 
+import math
 import warnings
 
 from matplotlib import transforms
@@ -528,15 +529,56 @@ def _draw_axes_line(self, props):
             # general reference line (e.g. axline)
             if props["coordinates"] == "display":
                 px_points = props["data"]
+            elif props["coordinates"] == "axes":
+                px_points = [ax.transAxes.transform(pt) for pt in props["data"]]
             else:
                 px_points = [trans.transform(pt) for pt in props["data"]]
             (x0, y0), (x1, y1) = [
                 ax.transData.inverted().transform(pt) for pt in px_points
             ]
-            if self.x_is_mpl_date:
-                x0, x1 = self._convert_x_dates([x0, x1])
-            xref = x_axis
-            yref = y_axis
+
+            dx = x1 - x0
+            dy = y1 - y0
+            if math.isclose(dy, 0.0, abs_tol=1e-12):
+                # Horizontal line: use x domain so it spans the chart, y in data coordinates
+                x0, x1 = 0.0, 1.0
+                y0, y1 = float(y0), float(y1)
+                xref = x_domain
+                yref = y_axis
+            elif math.isclose(dx, 0.0, abs_tol=1e-12):
+                # Vertical line: use y domain so it spans the chart, x in data coordinates
+                y0, y1 = 0.0, 1.0
+                if self.x_is_mpl_date:
+                    x0, x1 = self._convert_x_dates([x0, x1])
+                else:
+                    x0, x1 = float(x0), float(x1)
+                xref = x_axis
+                yref = y_domain
+            else:
+                # Diagonal line: extend endpoints in data coordinates so it spans
+                # across zoom levels while staying locked to data coordinates on pan/zoom
+                extension_factor = 100.0
+                x0_ext = x0 - extension_factor * dx
+                y0_ext = y0 - extension_factor * dy
+                x1_ext = x1 + extension_factor * dx
+                y1_ext = y1 + extension_factor * dy
+
+                if self.x_is_mpl_date:
+                    min_date_num = 1.0
+                    max_date_num = 3652000.0
+                    slope = dy / dx
+                    if x0_ext < min_date_num:
+                        y0_ext = y0 + slope * (min_date_num - x0)
+                        x0_ext = min_date_num
+                    if x1_ext > max_date_num:
+                        y1_ext = y1 + slope * (max_date_num - x1)
+                        x1_ext = max_date_num
+                    x0, x1 = self._convert_x_dates([x0_ext, x1_ext])
+                else:
+                    x0, x1 = float(x0_ext), float(x1_ext)
+                y0, y1 = float(y0_ext), float(y1_ext)
+                xref = x_axis
+                yref = y_axis
 
         color = mpltools.merge_color_and_opacity(
             props["linestyle"]["color"], props["linestyle"]["alpha"]

plotly/matplotlylib/tests/test_renderer.py

@@ -358,7 +358,7 @@ def test_axvline_converts():
 
 
 def test_axline_converts():
-    """axline converts to a layout shape spanning the whole axes box."""
+    """axline converts to a layout shape extended in data coordinates."""
     fig, ax = plt.subplots()
     ax.axline((0.5, 0.5), slope=1)
 
@@ -368,12 +368,77 @@ def test_axline_converts():
     assert len(plotly_fig.layout.shapes) == 1
     shape = plotly_fig.layout.shapes[0]
     assert shape.type == "line"
-    x0, x1 = ax.get_xlim()
-    y0, y1 = ax.get_ylim()
-    assert abs(shape.x0 - x0) < 1e-9
-    assert abs(shape.x1 - x1) < 1e-9
-    assert abs(shape.y0 - y0) < 1e-9
-    assert abs(shape.y1 - y1) < 1e-9
+    assert shape.xref == "x"
+    assert shape.yref == "y"
+    x_min, x_max = ax.get_xlim()
+    assert shape.x0 < x_min
+    assert shape.x1 > x_max
+    slope = (shape.y1 - shape.y0) / (shape.x1 - shape.x0)
+    assert abs(slope - 1.0) < 1e-9
+    # Passes through (0.5, 0.5)
+    y_at_05 = shape.y0 + slope * (0.5 - shape.x0)
+    assert abs(y_at_05 - 0.5) < 1e-9
+
+
+def test_axline_arbitrary_slope_and_limits():
+    """axline with non-trivial slopes and limits extends in data coordinates."""
+    fig, ax = plt.subplots()
+    ax.scatter([1, 2, 4, 7, 9], [2, 5, 4, 8, 10])
+    ax.axline((0, 1), slope=1.0)
+    ax.axline((1, 8), (8, 2))
+    ax.set_xlim(0, 10)
+    ax.set_ylim(0, 12)
+
+    plotly_fig = tls.mpl_to_plotly(fig)
+    shapes = plotly_fig.layout.shapes
+    assert len(shapes) == 2
+
+    # Line 1: (0, 1), slope 1, xlim [0, 10], ylim [0, 12]
+    assert shapes[0].xref == "x"
+    assert shapes[0].yref == "y"
+    assert shapes[0].x0 < -500
+    assert shapes[0].x1 > 500
+    slope1 = (shapes[0].y1 - shapes[0].y0) / (shapes[0].x1 - shapes[0].x0)
+    assert abs(slope1 - 1.0) < 1e-9
+    y_at_0 = shapes[0].y0 + slope1 * (0.0 - shapes[0].x0)
+    assert abs(y_at_0 - 1.0) < 1e-9
+
+    # Line 2: (1, 8) to (8, 2) with slope -6/7
+    assert shapes[1].xref == "x"
+    assert shapes[1].yref == "y"
+    assert shapes[1].x0 < -500
+    assert shapes[1].x1 > 500
+    slope2 = (shapes[1].y1 - shapes[1].y0) / (shapes[1].x1 - shapes[1].x0)
+    assert abs(slope2 - (-6.0 / 7.0)) < 1e-9
+    y_at_1 = shapes[1].y0 + slope2 * (1.0 - shapes[1].x0)
+    assert abs(y_at_1 - 8.0) < 1e-9
+
+
+def test_axline_horizontal_and_vertical():
+    """Horizontal and vertical axline use domain coordinates appropriately."""
+    fig, ax = plt.subplots()
+    ax.axline((0, 5), slope=0)
+    ax.axline((3, 0), (3, 10))
+
+    plotly_fig = tls.mpl_to_plotly(fig)
+    shapes = plotly_fig.layout.shapes
+    assert len(shapes) == 2
+
+    # Horizontal axline: xref is domain, y is data
+    assert shapes[0].xref == "x domain"
+    assert shapes[0].yref == "y"
+    assert abs(shapes[0].x0 - 0.0) < 1e-9
+    assert abs(shapes[0].x1 - 1.0) < 1e-9
+    assert abs(shapes[0].y0 - 5.0) < 1e-9
+    assert abs(shapes[0].y1 - 5.0) < 1e-9
+
+    # Vertical axline: xref is data, yref is domain
+    assert shapes[1].xref == "x"
+    assert shapes[1].yref == "y domain"
+    assert abs(shapes[1].x0 - 3.0) < 1e-9
+    assert abs(shapes[1].x1 - 3.0) < 1e-9
+    assert abs(shapes[1].y0 - 0.0) < 1e-9
+    assert abs(shapes[1].y1 - 1.0) < 1e-9
 
 
 def test_axvline_and_axhline_on_date_xaxis():