Deprecate Path helpers in bezier.py

anntzer · anntzer · commit 6fc5d566f9b9 · 2019-05-18T18:26:43.000+02:00
... in favor of the corresponding ones in path.py.
(Strictly speaking, `make_path_regular` is closed to
`cleaned(remove_nans=False)` but in practice `cleaned()` works equally
well.)
diff --git a/doc/api/next_api_changes/2019-05-11-AL.rst b/doc/api/next_api_changes/2019-05-11-AL.rst
@@ -0,0 +1,9 @@
+Deprecations
+````````````
+
+``bezier.make_path_regular`` is deprecated.  Use ``Path.cleaned()`` (or
+``Path.cleaned(curves=True)``, etc.) instead (but note that these methods add a
+``STOP`` code at the end of the path).
+
+``bezier.concatenate_paths`` is deprecated.  Use ``Path.make_compound_path()``
+instead.
diff --git a/lib/matplotlib/bezier.py b/lib/matplotlib/bezier.py
@@ -457,6 +457,7 @@ def make_wedged_bezier2(bezier2, width, w1=1., wm=0.5, w2=0.):
     return path_left, path_right
 
 
+@cbook.deprecated("3.2", alternative="Path.cleaned()")
 def make_path_regular(p):
     """
     If the :attr:`codes` attribute of `Path` *p* is None, return a copy of *p*
@@ -472,6 +473,7 @@ def make_path_regular(p):
         return p
 
 
+@cbook.deprecated("3.2", alternative="Path.make_compound_path()")
 def concatenate_paths(paths):
     """Concatenate a list of paths into a single path."""
     vertices = np.concatenate([p.vertices for p in paths])
diff --git a/lib/matplotlib/patches.py b/lib/matplotlib/patches.py
@@ -3223,26 +3223,20 @@ def __call__(self, path, mutation_size, linewidth,
             and takes care of the aspect ratio.
             """
 
-            path = make_path_regular(path)
-
             if aspect_ratio is not None:
                 # Squeeze the given height by the aspect_ratio
-
-                vertices, codes = path.vertices[:], path.codes[:]
-                # Squeeze the height
-                vertices[:, 1] = vertices[:, 1] / aspect_ratio
-                path_shrunk = Path(vertices, codes)
+                path_shrunk = Path(path.vertices / [1, aspect_ratio],
+                                   path.codes)
                 # call transmute method with squeezed height.
                 path_mutated, fillable = self.transmute(path_shrunk,
                                                         linewidth,
                                                         mutation_size)
                 if np.iterable(fillable):
                     path_list = []
                     for p in zip(path_mutated):
-                        v, c = p.vertices, p.codes
                         # Restore the height
-                        v[:, 1] = v[:, 1] * aspect_ratio
-                        path_list.append(Path(v, c))
+                        path_list.append(
+                            Path(p.vertices * [1, aspect_ratio], p.codes))
                     return path_list, fillable
                 else:
                     return path_mutated, fillable
@@ -4253,10 +4247,8 @@ def get_path(self):
         in display coordinates.
         """
         _path, fillable = self.get_path_in_displaycoord()
-
         if np.iterable(fillable):
-            _path = concatenate_paths(_path)
-
+            _path = Path.make_compound_path(*_path)
         return self.get_transform().inverted().transform_path(_path)
 
     def get_path_in_displaycoord(self):
diff --git a/lib/matplotlib/tests/test_artist.py b/lib/matplotlib/tests/test_artist.py
@@ -101,10 +101,7 @@ def test_clipping():
     exterior.vertices -= 2
     interior = mpath.Path.unit_circle().deepcopy()
     interior.vertices = interior.vertices[::-1]
-    clip_path = mpath.Path(vertices=np.concatenate([exterior.vertices,
-                                                    interior.vertices]),
-                           codes=np.concatenate([exterior.codes,
-                                                 interior.codes]))
+    clip_path = mpath.Path.make_compound_path(exterior, interior)
 
     star = mpath.Path.unit_regular_star(6).deepcopy()
     star.vertices *= 2.6
