Merge pull request matplotlib#29919 from rcomer/geo-contour

Author: timhoffm

lib/matplotlib/path.py

@@ -667,14 +667,35 @@ def intersects_bbox(self, bbox, filled=True):
 
     def interpolated(self, steps):
         """
-        Return a new path resampled to length N x *steps*.
+        Return a new path with each segment divided into *steps* parts.
 
-        Codes other than `LINETO` are not handled correctly.
+        Codes other than `LINETO`, `MOVETO`, and `CLOSEPOLY` are not handled correctly.
+
+        Parameters
+        ----------
+        steps : int
+            The number of segments in the new path for each in the original.
+
+        Returns
+        -------
+        Path
+            The interpolated path.
         """
-        if steps == 1:
+        if steps == 1 or len(self) == 0:
             return self
 
-        vertices = simple_linear_interpolation(self.vertices, steps)
+        if self.codes is not None and self.MOVETO in self.codes[1:]:
+            return self.make_compound_path(
+                *(p.interpolated(steps) for p in self._iter_connected_components()))
+
+        if self.codes is not None and self.CLOSEPOLY in self.codes and not np.all(
+                self.vertices[self.codes == self.CLOSEPOLY] == self.vertices[0]):
+            vertices = self.vertices.copy()
+            vertices[self.codes == self.CLOSEPOLY] = vertices[0]
+        else:
+            vertices = self.vertices
+
+        vertices = simple_linear_interpolation(vertices, steps)
         codes = self.codes
         if codes is not None:
             new_codes = np.full((len(codes) - 1) * steps + 1, Path.LINETO,

lib/matplotlib/tests/test_path.py

@@ -541,3 +541,84 @@ def test_cleanup_closepoly():
         cleaned = p.cleaned(remove_nans=True)
         assert len(cleaned) == 1
         assert cleaned.codes[0] == Path.STOP
+
+
+def test_interpolated_moveto():
+    # Initial path has two subpaths with two LINETOs each
+    vertices = np.array([[0, 0],
+                         [0, 1],
+                         [1, 2],
+                         [4, 4],
+                         [4, 5],
+                         [5, 5]])
+    codes = [Path.MOVETO, Path.LINETO, Path.LINETO] * 2
+
+    path = Path(vertices, codes)
+    result = path.interpolated(3)
+
+    # Result should have two subpaths with six LINETOs each
+    expected_subpath_codes = [Path.MOVETO] + [Path.LINETO] * 6
+    np.testing.assert_array_equal(result.codes, expected_subpath_codes * 2)
+
+
+def test_interpolated_closepoly():
+    codes = [Path.MOVETO] + [Path.LINETO]*2 + [Path.CLOSEPOLY]
+    vertices = [(4, 3), (5, 4), (5, 3), (0, 0)]
+
+    path = Path(vertices, codes)
+    result = path.interpolated(2)
+
+    expected_vertices = np.array([[4, 3],
+                                  [4.5, 3.5],
+                                  [5, 4],
+                                  [5, 3.5],
+                                  [5, 3],
+                                  [4.5, 3],
+                                  [4, 3]])
+    expected_codes = [Path.MOVETO] + [Path.LINETO]*5 + [Path.CLOSEPOLY]
+
+    np.testing.assert_allclose(result.vertices, expected_vertices)
+    np.testing.assert_array_equal(result.codes, expected_codes)
+
+    # Usually closepoly is the last vertex but does not have to be.
+    codes += [Path.LINETO]
+    vertices += [(2, 1)]
+
+    path = Path(vertices, codes)
+    result = path.interpolated(2)
+
+    extra_expected_vertices = np.array([[3, 2],
+                                        [2, 1]])
+    expected_vertices = np.concatenate([expected_vertices, extra_expected_vertices])
+
+    expected_codes += [Path.LINETO] * 2
+
+    np.testing.assert_allclose(result.vertices, expected_vertices)
+    np.testing.assert_array_equal(result.codes, expected_codes)
+
+
+def test_interpolated_moveto_closepoly():
+    # Initial path has two closed subpaths
+    codes = ([Path.MOVETO] + [Path.LINETO]*2 + [Path.CLOSEPOLY]) * 2
+    vertices = [(4, 3), (5, 4), (5, 3), (0, 0), (8, 6), (10, 8), (10, 6), (0, 0)]
+
+    path = Path(vertices, codes)
+    result = path.interpolated(2)
+
+    expected_vertices1 = np.array([[4, 3],
+                                   [4.5, 3.5],
+                                   [5, 4],
+                                   [5, 3.5],
+                                   [5, 3],
+                                   [4.5, 3],
+                                   [4, 3]])
+    expected_vertices = np.concatenate([expected_vertices1, expected_vertices1 * 2])
+    expected_codes = ([Path.MOVETO] + [Path.LINETO]*5 + [Path.CLOSEPOLY]) * 2
+
+    np.testing.assert_allclose(result.vertices, expected_vertices)
+    np.testing.assert_array_equal(result.codes, expected_codes)
+
+
+def test_interpolated_empty_path():
+    path = Path(np.zeros((0, 2)))
+    assert path.interpolated(42) is path