Reference the axis domain for axes-fraction sides of spans

Author: robertoffmoura

plotly/matplotlylib/renderer.py

@@ -56,19 +56,26 @@ def _convert_collection_dash(linestyle):
     return ",".join("{0:g}px".format(d) for d in dashes)
 
 
-def _has_blended_transform(transform):
-    """Check whether a matplotlib transform contains a blended transform."""
+def _find_blended_transform(transform):
+    """Return the first blended transform within a matplotlib transform, or
+    None when it contains no blended transform."""
     if isinstance(
         transform, (transforms.BlendedGenericTransform, transforms.BlendedAffine2D)
     ):
-        return True
+        return transform
     if hasattr(transform, "_a") and hasattr(transform, "_b"):
-        return _has_blended_transform(transform._a) or _has_blended_transform(
-            transform._b
-        )
+        blended = _find_blended_transform(transform._a)
+        if blended is None:
+            blended = _find_blended_transform(transform._b)
+        return blended
     if hasattr(transform, "_transform"):
-        return _has_blended_transform(transform._transform)
-    return False
+        return _find_blended_transform(transform._transform)
+    return None
+
+
+def _has_blended_transform(transform):
+    """Check whether a matplotlib transform contains a blended transform."""
+    return _find_blended_transform(transform) is not None
 
 
 class PlotlyRenderer(Renderer):
@@ -699,15 +706,29 @@ def _draw_axes_line(self, props):
         return True
 
     def _draw_axes_span(self, props):
-        """Draw a reference span (axhspan/axvspan) as a layout shape spanning
-        the region in data coordinates."""
+        """Draw a reference span (axhspan/axvspan) as a layout shape.
+
+        Sides given in axes fractions (e.g. axhspan xmin/xmax) map onto the
+        axis domain, so they stay fixed to the axes on pan/zoom; sides given
+        in data coordinates map onto the data axis."""
         ax = self.current_mpl_ax
         px_points = props["data"]
-        data_points = [ax.transData.inverted().transform(pt) for pt in px_points]
-        xs = [pt[0] for pt in data_points]
-        ys = [pt[1] for pt in data_points]
+        blended = _find_blended_transform(props["mplobj"].get_transform())
+        x_in_axes = blended._x == ax.transAxes
+        y_in_axes = blended._y == ax.transAxes
+        axes_points = ax.transAxes.inverted().transform(px_points)
+        data_points = ax.transData.inverted().transform(px_points)
+        xs = (axes_points if x_in_axes else data_points)[:, 0]
+        ys = (axes_points if y_in_axes else data_points)[:, 1]
         x0, x1 = float(min(xs)), float(max(xs))
         y0, y1 = float(min(ys)), float(max(ys))
+        axis_suffix = str(self.axis_ct) if self.axis_ct > 1 else ""
+        xref = "x{0}".format(axis_suffix)
+        yref = "y{0}".format(axis_suffix)
+        if x_in_axes:
+            xref += " domain"
+        if y_in_axes:
+            yref += " domain"
         style = props["style"]
         fillcolor = _export_color(style["facecolor"])
         edgecolor = _export_color(style["edgecolor"])
@@ -718,8 +739,8 @@ def _draw_axes_span(self, props):
             y0=y0,
             x1=x1,
             y1=y1,
-            xref="x{0}".format(self.axis_ct),
-            yref="y{0}".format(self.axis_ct),
+            xref=xref,
+            yref=yref,
             fillcolor=fillcolor,
             line=go.layout.shape.Line(
                 color=edgecolor,

plotly/matplotlylib/tests/test_renderer.py

@@ -1395,7 +1395,7 @@ def test_mixed_style_lines_group_consecutive_matches():
 
 
 def test_axhspan_converts():
-    """axhspan converts to a layout shape spanning the axes width."""
+    """axhspan converts to a layout shape spanning the x axis domain."""
     fig, ax = plt.subplots()
     ax.axhspan(0.25, 0.75)
 
@@ -1405,19 +1405,18 @@ def test_axhspan_converts():
     assert len(plotly_fig.layout.shapes) == 1
     shape = plotly_fig.layout.shapes[0]
     assert shape.type == "rect"
-    x0, x1 = ax.get_xlim()
-    assert abs(shape.x0 - x0) < 1e-9
-    assert abs(shape.x1 - x1) < 1e-9
+    assert abs(shape.x0 - 0) < 1e-9
+    assert abs(shape.x1 - 1) < 1e-9
     assert abs(shape.y0 - 0.25) < 1e-9
     assert abs(shape.y1 - 0.75) < 1e-9
-    assert shape.xref == "x"
+    assert shape.xref == "x domain"
     assert shape.yref == "y"
     assert shape.fillcolor == "#1F77B4"
     assert shape.layer == "below"
 
 
 def test_axvspan_converts():
-    """axvspan converts to a layout shape spanning the axes height."""
+    """axvspan converts to a layout shape spanning the y axis domain."""
     fig, ax = plt.subplots()
     ax.axvspan(0.25, 0.75)
 
@@ -1427,17 +1426,47 @@ def test_axvspan_converts():
     assert len(plotly_fig.layout.shapes) == 1
     shape = plotly_fig.layout.shapes[0]
     assert shape.type == "rect"
-    y0, y1 = ax.get_ylim()
     assert abs(shape.x0 - 0.25) < 1e-9
     assert abs(shape.x1 - 0.75) < 1e-9
-    assert abs(shape.y0 - y0) < 1e-9
-    assert abs(shape.y1 - y1) < 1e-9
+    assert abs(shape.y0 - 0) < 1e-9
+    assert abs(shape.y1 - 1) < 1e-9
     assert shape.xref == "x"
-    assert shape.yref == "y"
+    assert shape.yref == "y domain"
     assert shape.fillcolor == "#1F77B4"
     assert shape.layer == "below"
 
 
+def test_axhspan_axes_fractions_convert():
+    """axhspan xmin/xmax convert to x axis domain fractions and axvspan
+    ymin/ymax convert to y axis domain fractions."""
+    fig, ax = plt.subplots()
+    ax.plot([0, 10], [0, 10])
+    ax.axhspan(2, 4, xmin=0.2, xmax=0.6)
+    ax.axvspan(6, 8, ymin=0.1, ymax=0.5)
+
+    plotly_fig = tls.mpl_to_plotly(fig)
+
+    hspan, vspan = plotly_fig.layout.shapes
+    assert hspan.xref == "x domain"
+    assert hspan.yref == "y"
+    assert np.allclose([hspan.x0, hspan.x1, hspan.y0, hspan.y1], [0.2, 0.6, 2, 4])
+    assert vspan.xref == "x"
+    assert vspan.yref == "y domain"
+    assert np.allclose([vspan.x0, vspan.x1, vspan.y0, vspan.y1], [6, 8, 0.1, 0.5])
+
+
+def test_axhspan_on_second_subplot_references_its_domain():
+    """Spans on a second subplot reference that subplot's axis domain."""
+    fig, (ax1, ax2) = plt.subplots(1, 2)
+    ax2.axhspan(2, 4)
+
+    plotly_fig = tls.mpl_to_plotly(fig)
+
+    (shape,) = plotly_fig.layout.shapes
+    assert shape.xref == "x2 domain"
+    assert shape.yref == "y2"
+
+
 def test_axhspan_with_custom_style_converts():
     """axhspan with custom colors and alpha converts to a styled layout shape."""
     fig, ax = plt.subplots()