Group consecutive same-style line collection paths into single traces

Author: robertoffmoura

plotly/matplotlylib/renderer.py

@@ -632,15 +632,35 @@ def draw_path_collection(self, **props):
 
     def _draw_line_collection(self, props):
         """Draw a path collection without face colors (e.g. contour lines)
-        as plain lines."""
+        as plain lines, grouping consecutive same-style paths into single traces."""
         edgecolors = mpltools.convert_rgba_array(props["styles"]["edgecolor"])
         linewidths = mpltools.convert_linewidth_array(props["styles"]["linewidth"])
         linestyles = props["styles"].get("linestyle")
 
+        current_style = None
+        grouped_x = []
+        grouped_y = []
+
+        def flush():
+            if current_style is not None and grouped_x:
+                ec, lw, d = current_style
+                self.plotly_fig.add_trace(
+                    go.Scatter(
+                        x=grouped_x,
+                        y=grouped_y,
+                        mode="lines",
+                        showlegend=False,
+                        line=go.scatter.Line(
+                            color=_export_color(ec),
+                            width=lw,
+                            dash=d,
+                        ),
+                        xaxis="x{0}".format(self.axis_ct),
+                        yaxis="y{0}".format(self.axis_ct),
+                    )
+                )
+
         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.
@@ -666,8 +686,8 @@ def _draw_line_collection(self, props):
                     vi += step
             if current:
                 subpaths.append((current, closed))
-            x_combined = []
-            y_combined = []
+            path_x = []
+            path_y = []
             for sub, closed in subpaths:
                 if len(sub) < 2:
                     continue
@@ -677,27 +697,31 @@ def _draw_line_collection(self, props):
                     sub = sub + [sub[0]]
                 sub_x = self._convert_x_dates([v[0] for v in sub])
                 sub_y = [v[1] for v in sub]
-                if x_combined:
-                    x_combined.append(None)
-                    y_combined.append(None)
-                x_combined.extend(sub_x)
-                y_combined.extend(sub_y)
-            if x_combined:
-                self.plotly_fig.add_trace(
-                    go.Scatter(
-                        x=x_combined,
-                        y=y_combined,
-                        mode="lines",
-                        showlegend=False,
-                        line=go.scatter.Line(
-                            color=_export_color(edgecolor),
-                            width=linewidth,
-                            dash=dash,
-                        ),
-                        xaxis="x{0}".format(self.axis_ct),
-                        yaxis="y{0}".format(self.axis_ct),
-                    )
-                )
+                if path_x:
+                    path_x.append(None)
+                    path_y.append(None)
+                path_x.extend(sub_x)
+                path_y.extend(sub_y)
+            if not path_x:
+                continue
+
+            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))
+            style = (edgecolor, linewidth, dash)
+
+            if style != current_style:
+                flush()
+                current_style = style
+                grouped_x = list(path_x)
+                grouped_y = list(path_y)
+            else:
+                grouped_x.append(None)
+                grouped_y.append(None)
+                grouped_x.extend(path_x)
+                grouped_y.extend(path_y)
+
+        flush()
 
     def _draw_filled_path_collection(self, props):
         """Draw a path collection (e.g. violin plot bodies) as filled polygons."""

plotly/matplotlylib/tests/test_renderer.py

@@ -434,7 +434,9 @@ def test_eventplot_segments_render():
     fig, ax = plt.subplots()
     ax.eventplot([np.random.randn(20) for _ in range(5)])
     plotly_fig = tls.mpl_to_plotly(fig)
-    assert len(plotly_fig.data) == 100
+    # Each of the 5 event rows is a line collection whose 20 segments are grouped
+    assert len(plotly_fig.data) == 5
+    assert all(t.x.count(None) == 19 for t in plotly_fig.data)
 
 
 def test_stackplot_areas_render():
@@ -486,7 +488,11 @@ def test_stem_plot_renders():
     fig, ax = plt.subplots()
     ax.stem(x, np.sin(x))
     plotly_fig = tls.mpl_to_plotly(fig)
-    assert len(plotly_fig.data) >= 20
+    # The 20 vertical stem lines are grouped into a single line trace with 19 None separators
+    stem_lines = [
+        t for t in plotly_fig.data if t.mode == "lines" and t.x.count(None) == 19
+    ]
+    assert len(stem_lines) == 1
 
 
 def test_contour_lines_convert():
@@ -885,3 +891,49 @@ def test_contour_lines_not_in_legend():
     contour_traces = [t for t in plotly_fig.data if t.name != "Line"]
     assert len(contour_traces) >= 1
     assert all(t.showlegend is False for t in contour_traces)
+
+
+def test_consecutive_same_style_lines_grouped_into_one_trace():
+    """Consecutive paths with identical styles are grouped into a single trace."""
+    x = np.linspace(-3, 3, 30)
+    X, Y = np.meshgrid(x, x)
+    fig, ax = plt.subplots()
+    # 4 contour levels, all black, solid, width 1.5
+    ax.contour(
+        X,
+        Y,
+        X**2 + Y**2,
+        levels=[1, 2, 3, 4],
+        colors="k",
+        linestyles="solid",
+        linewidths=1.5,
+    )
+    plotly_fig = tls.mpl_to_plotly(fig)
+
+    # All 4 levels share the same style, so they should be grouped into 1 trace
+    assert len(plotly_fig.data) == 1
+    trace = plotly_fig.data[0]
+    # The trace combines the distinct levels separated by None
+    assert trace.x.count(None) >= 3
+
+
+def test_mixed_style_lines_group_consecutive_matches():
+    """Paths are grouped by consecutive matching style (color, width, dash)."""
+    x = np.linspace(-3, 3, 30)
+    X, Y = np.meshgrid(x, x)
+    fig, ax = plt.subplots()
+    # 4 levels: 2 negative (dashed by default in mpl), 2 positive (solid by default)
+    ax.contour(
+        X,
+        Y,
+        np.sin(X) * np.cos(Y),
+        levels=[-0.5, -0.25, 0.25, 0.5],
+        colors="k",
+        linewidths=1.5,
+    )
+    plotly_fig = tls.mpl_to_plotly(fig)
+
+    # 2 dashed levels grouped into 1 trace, 2 solid levels grouped into 1 trace -> 2 traces total
+    assert len(plotly_fig.data) == 2
+    assert plotly_fig.data[0].line.dash != "solid"
+    assert plotly_fig.data[1].line.dash == "solid"