Convert line collection dash styles for contour plots

Author: robertoffmoura

plotly/matplotlylib/mplexporter/exporter.py

@@ -282,6 +282,7 @@ def draw_collection(
             "linewidth": collection.get_linewidths(),
             "facecolor": collection.get_facecolors(),
             "edgecolor": collection.get_edgecolors(),
+            "linestyle": collection.get_linestyle(),
             "alpha": collection._alpha,
             "zorder": collection.get_zorder(),
         }

plotly/matplotlylib/renderer.py

@@ -45,6 +45,21 @@ def _per_path(values, i, default):
     return values[i % n] if n else default
 
 
+def _convert_collection_dash(linestyle):
+    """Convert a matplotlib collection line style to a plotly dash string.
+
+    Collections report line styles as (offset, dashes) tuples, with dashes
+    in points and already scaled by line width (None for solid lines). Line
+    widths are exported with their point values used as px, so the dashes
+    are exported the same way, which keeps matplotlib's dash-to-width ratio.
+    plotly has no dash offset, so the offset is dropped.
+    """
+    dashes = linestyle[1] if linestyle is not None else None
+    if not dashes:
+        return "solid"
+    return ",".join("{0:g}px".format(d) for d in dashes)
+
+
 class PlotlyRenderer(Renderer):
     """A renderer class inheriting from base for rendering mpl plots in plotly.
 
@@ -526,6 +541,7 @@ def draw_path_collection(self, **props):
         'linewidth',            (one or more linewidths)
         'facecolor',            (one or more facecolors for path)
         'edgecolor',            (one or more edgecolors for path)
+        'linestyle',            (one or more (offset, dashes) line styles)
         'alpha',                (one or more opacites for path)
         'zorder',               (precedence when stacked)
         ]
@@ -565,10 +581,12 @@ def _draw_line_collection(self, props):
         as plain lines."""
         edgecolors = mpltools.convert_rgba_array(props["styles"]["edgecolor"])
         linewidths = mpltools.convert_linewidth_array(props["styles"]["linewidth"])
+        linestyles = props["styles"].get("linestyle")
 
         for i, (verts, codes) in enumerate(props["paths"]):
             edgecolor = _per_path(edgecolors, i, "rgba(0,0,0,0)")
             linewidth = _per_path(linewidths, i, 0)
+            dash = _convert_collection_dash(_per_path(linestyles, i, None))
             # a path may contain several disjoint lines (e.g. contour lines
             # of the same level); separate disjoint subpaths with None so
             # plotly does not connect them.
@@ -617,7 +635,9 @@ def _draw_line_collection(self, props):
                         y=y_combined,
                         mode="lines",
                         line=go.scatter.Line(
-                            color=_export_color(edgecolor), width=linewidth
+                            color=_export_color(edgecolor),
+                            width=linewidth,
+                            dash=dash,
                         ),
                         xaxis="x{0}".format(self.axis_ct),
                         yaxis="y{0}".format(self.axis_ct),

plotly/matplotlylib/tests/test_renderer.py

@@ -419,3 +419,43 @@ def test_line_collection_date_xaxis():
     assert len(lines) >= 1
     assert any(isinstance(x, str) for t in lines for x in t.x)
     assert all(x is None or isinstance(x, str) for t in lines for x in t.x)
+
+
+def test_contour_line_dash_styles():
+    """Each contour level keeps its matplotlib dash pattern, exported as a
+    px dash list (matplotlib's pattern is already scaled by line width)."""
+    x = np.linspace(-3, 3, 30)
+    X, Y = np.meshgrid(x, x)
+    fig, ax = plt.subplots()
+    ax.contour(
+        X,
+        Y,
+        np.sin(X) * np.cos(Y),
+        levels=[-0.5, -0.25, 0.25, 0.5],
+        colors="k",
+        linewidths=1.5,
+        linestyles=["dashed", "solid", "dotted", (0, (5, 2, 1, 2))],
+    )
+    plotly_fig = tls.mpl_to_plotly(fig)
+
+    assert [t.line.dash for t in plotly_fig.data] == [
+        "5.55px,2.4px",
+        "solid",
+        "1.5px,2.475px",
+        "7.5px,3px,1.5px,3px",
+    ]
+
+
+def test_contour_line_dash_scales_with_linewidth():
+    """matplotlib scales dash patterns by line width; the export follows."""
+    x = np.linspace(-3, 3, 30)
+    X, Y = np.meshgrid(x, x)
+    fig, ax = plt.subplots()
+    ax.contour(
+        X, Y, np.sin(X) * np.cos(Y), levels=[0.5], linewidths=3, linestyles="dashed"
+    )
+    plotly_fig = tls.mpl_to_plotly(fig)
+
+    assert len(plotly_fig.data) == 1
+    assert plotly_fig.data[0].line.width == 3
+    assert plotly_fig.data[0].line.dash == "11.1px,4.8px"