refactor Bezier so it doesn't depend on Path

brunobeltran · brunobeltran · commit 696b64cce0b9 · 2020-03-21T20:17:14.000-07:00
diff --git a/doc/api/next_api_changes/deprecations.rst b/doc/api/next_api_changes/deprecations.rst
@@ -369,10 +369,10 @@ also be accessible as ``toolbar.parent()``.
 
 Path helpers in :mod:`.bezier`
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-``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.
+- ``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.
+- ``bezier.split_path_inout`` (use ``Path.split_path_inout`` instead)
+- ``bezier.inside_circle()`` (no replacement)
diff --git a/doc/api/next_api_changes/removals.rst b/doc/api/next_api_changes/removals.rst
@@ -92,7 +92,7 @@ Classes and methods
 
 - ``image.BboxImage.interp_at_native`` property (no replacement)
 - ``lines.Line2D.verticalOffset`` property (no replacement)
-- ``bezier.find_r_to_boundary_of_closedpath()`` (no relacement)
+- ``bezier.find_r_to_boundary_of_closedpath()`` (no replacement)
 
 - ``quiver.Quiver.color()`` (use ``Quiver.get_facecolor()`` instead)
 - ``quiver.Quiver.keyvec`` property (no replacement)
diff --git a/lib/matplotlib/bezier.py b/lib/matplotlib/bezier.py
@@ -7,12 +7,12 @@
 import numpy as np
 
 import matplotlib.cbook as cbook
-from matplotlib.path import Path
 
 
 class NonIntersectingPathException(ValueError):
     pass
 
+
 # some functions
 
 
@@ -68,6 +68,15 @@ def get_normal_points(cx, cy, cos_t, sin_t, length):
     return x1, y1, x2, y2
 
 
+@cbook.deprecated("3.3", alternative="Path.split_path_inout()")
+def split_path_inout(path, inside, tolerance=0.01, reorder_inout=False):
+    """
+    Divide a path into two segments at the point where ``inside(x, y)``
+    becomes False.
+    """
+    return path.split_path_inout(inside, tolerance, reorder_inout)
+
+
 # BEZIER routines
 
 # subdividing bezier curve
@@ -222,71 +231,7 @@ def split_bezier_intersecting_with_closedpath(
     return _left, _right
 
 
-# matplotlib specific
-
-
-def split_path_inout(path, inside, tolerance=0.01, reorder_inout=False):
-    """
-    Divide a path into two segments at the point where ``inside(x, y)`` becomes
-    False.
-    """
-    path_iter = path.iter_segments()
-
-    ctl_points, command = next(path_iter)
-    begin_inside = inside(ctl_points[-2:])  # true if begin point is inside
-
-    ctl_points_old = ctl_points
-
-    concat = np.concatenate
-
-    iold = 0
-    i = 1
-
-    for ctl_points, command in path_iter:
-        iold = i
-        i += len(ctl_points) // 2
-        if inside(ctl_points[-2:]) != begin_inside:
-            bezier_path = concat([ctl_points_old[-2:], ctl_points])
-            break
-        ctl_points_old = ctl_points
-    else:
-        raise ValueError("The path does not intersect with the patch")
-
-    bp = bezier_path.reshape((-1, 2))
-    left, right = split_bezier_intersecting_with_closedpath(
-        bp, inside, tolerance)
-    if len(left) == 2:
-        codes_left = [Path.LINETO]
-        codes_right = [Path.MOVETO, Path.LINETO]
-    elif len(left) == 3:
-        codes_left = [Path.CURVE3, Path.CURVE3]
-        codes_right = [Path.MOVETO, Path.CURVE3, Path.CURVE3]
-    elif len(left) == 4:
-        codes_left = [Path.CURVE4, Path.CURVE4, Path.CURVE4]
-        codes_right = [Path.MOVETO, Path.CURVE4, Path.CURVE4, Path.CURVE4]
-    else:
-        raise AssertionError("This should never be reached")
-
-    verts_left = left[1:]
-    verts_right = right[:]
-
-    if path.codes is None:
-        path_in = Path(concat([path.vertices[:i], verts_left]))
-        path_out = Path(concat([verts_right, path.vertices[i:]]))
-
-    else:
-        path_in = Path(concat([path.vertices[:iold], verts_left]),
-                       concat([path.codes[:iold], codes_left]))
-
-        path_out = Path(concat([verts_right, path.vertices[i:]]),
-                        concat([codes_right, path.codes[i:]]))
-
-    if reorder_inout and not begin_inside:
-        path_in, path_out = path_out, path_in
-
-    return path_in, path_out
-
-
+@cbook.deprecated("3.3")
 def inside_circle(cx, cy, r):
     """
     Return a function that checks whether a point is in a circle with center
@@ -296,16 +241,13 @@ def inside_circle(cx, cy, r):
 
         f(xy: Tuple[float, float]) -> bool
     """
-    r2 = r ** 2
-
-    def _f(xy):
-        x, y = xy
-        return (x - cx) ** 2 + (y - cy) ** 2 < r2
-    return _f
+    from .patches import _inside_circle
+    return _inside_circle(cx, cy, r)
 
 
 # quadratic Bezier lines
 
+
 def get_cos_sin(x0, y0, x1, y1):
     dx, dy = x1 - x0, y1 - y0
     d = (dx * dx + dy * dy) ** .5
@@ -488,6 +430,7 @@ def make_path_regular(p):
     with ``codes`` set to (MOVETO, LINETO, LINETO, ..., LINETO); otherwise
     return *p* itself.
     """
+    from .path import Path
     c = p.codes
     if c is None:
         c = np.full(len(p.vertices), Path.LINETO, dtype=Path.code_type)
@@ -500,6 +443,5 @@ def make_path_regular(p):
 @cbook.deprecated("3.3", 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])
-    codes = np.concatenate([make_path_regular(p).codes for p in paths])
-    return Path(vertices, codes)
+    from .path import Path
+    return Path.make_compound_path(*paths)
diff --git a/lib/matplotlib/patches.py b/lib/matplotlib/patches.py
@@ -10,12 +10,28 @@
 import matplotlib as mpl
 from . import artist, cbook, colors, docstring, lines as mlines, transforms
 from .bezier import (
-    NonIntersectingPathException, get_cos_sin, get_intersection,
-    get_parallels, inside_circle, make_wedged_bezier2,
-    split_bezier_intersecting_with_closedpath, split_path_inout)
+    NonIntersectingPathException, get_cos_sin, get_intersection, get_parallels,
+    make_wedged_bezier2, split_bezier_intersecting_with_closedpath)
 from .path import Path
 
 
+def _inside_circle(cx, cy, r):
+    """
+    Return a function that checks whether a point is in a circle with center
+    (*cx*, *cy*) and radius *r*.
+
+    The returned function has the signature::
+
+        f(xy: Tuple[float, float]) -> bool
+    """
+    r2 = r ** 2
+
+    def _f(xy):
+        x, y = xy
+        return (x - cx) ** 2 + (y - cy) ** 2 < r2
+    return _f
+
+
 @cbook._define_aliases({
     "antialiased": ["aa"],
     "edgecolor": ["ec"],
@@ -2411,7 +2427,7 @@ def insideA(xy_display):
                     return patchA.contains(xy_event)[0]
 
                 try:
-                    left, right = split_path_inout(path, insideA)
+                    left, right = path.split_path_inout(insideA)
                 except ValueError:
                     right = path
 
@@ -2423,7 +2439,7 @@ def insideB(xy_display):
                     return patchB.contains(xy_event)[0]
 
                 try:
-                    left, right = split_path_inout(path, insideB)
+                    left, right = path.split_path_inout(insideB)
                 except ValueError:
                     left = path
 
@@ -2436,15 +2452,15 @@ def _shrink(self, path, shrinkA, shrinkB):
             Shrink the path by fixed size (in points) with shrinkA and shrinkB.
             """
             if shrinkA:
-                insideA = inside_circle(*path.vertices[0], shrinkA)
+                insideA = _inside_circle(*path.vertices[0], shrinkA)
                 try:
-                    left, path = split_path_inout(path, insideA)
+                    left, path = path.split_path_inout(insideA)
                 except ValueError:
                     pass
             if shrinkB:
-                insideB = inside_circle(*path.vertices[-1], shrinkB)
+                insideB = _inside_circle(*path.vertices[-1], shrinkB)
                 try:
-                    path, right = split_path_inout(path, insideB)
+                    path, right = path.split_path_inout(insideB)
                 except ValueError:
                     pass
             return path
@@ -2869,7 +2885,6 @@ def __call__(self, path, mutation_size, linewidth,
             The __call__ method is a thin wrapper around the transmute method
             and takes care of the aspect ratio.
             """
-
             if aspect_ratio is not None:
                 # Squeeze the given height by the aspect_ratio
                 vertices = path.vertices / [1, aspect_ratio]
@@ -3334,7 +3349,7 @@ def transmute(self, path, mutation_size, linewidth):
 
             # divide the path into a head and a tail
             head_length = self.head_length * mutation_size
-            in_f = inside_circle(x2, y2, head_length)
+            in_f = _inside_circle(x2, y2, head_length)
             arrow_path = [(x0, y0), (x1, y1), (x2, y2)]
 
             try:
@@ -3417,7 +3432,7 @@ def transmute(self, path, mutation_size, linewidth):
             arrow_path = [(x0, y0), (x1, y1), (x2, y2)]
 
             # path for head
-            in_f = inside_circle(x2, y2, head_length)
+            in_f = _inside_circle(x2, y2, head_length)
             try:
                 path_out, path_in = split_bezier_intersecting_with_closedpath(
                     arrow_path, in_f, tolerance=0.01)
@@ -3432,7 +3447,7 @@ def transmute(self, path, mutation_size, linewidth):
                 path_head = path_in
 
             # path for head
-            in_f = inside_circle(x2, y2, head_length * .8)
+            in_f = _inside_circle(x2, y2, head_length * .8)
             path_out, path_in = split_bezier_intersecting_with_closedpath(
                 arrow_path, in_f, tolerance=0.01)
             path_tail = path_out
@@ -3450,7 +3465,7 @@ def transmute(self, path, mutation_size, linewidth):
                                                         w1=1., wm=0.6, w2=0.3)
 
             # path for head
-            in_f = inside_circle(x0, y0, tail_width * .3)
+            in_f = _inside_circle(x0, y0, tail_width * .3)
             path_in, path_out = split_bezier_intersecting_with_closedpath(
                 arrow_path, in_f, tolerance=0.01)
             tail_start = path_in[-1]
diff --git a/lib/matplotlib/path.py b/lib/matplotlib/path.py
@@ -17,6 +17,7 @@
 import matplotlib as mpl
 from . import _path, cbook
 from .cbook import _to_unmasked_float_array, simple_linear_interpolation
+from .bezier import split_bezier_intersecting_with_closedpath
 
 
 class Path:
@@ -586,6 +587,67 @@ def interpolated(self, steps):
             new_codes = None
         return Path(vertices, new_codes)
 
+    def split_path_inout(self, inside, tolerance=0.01, reorder_inout=False):
+        """
+        Divide a path into two segments at the point where ``inside(x, y)``
+        becomes False.
+        """
+        path_iter = self.iter_segments()
+
+        ctl_points, command = next(path_iter)
+        begin_inside = inside(ctl_points[-2:])  # true if begin point is inside
+
+        ctl_points_old = ctl_points
+
+        concat = np.concatenate
+
+        iold = 0
+        i = 1
+
+        for ctl_points, command in path_iter:
+            iold = i
+            i += len(ctl_points) // 2
+            if inside(ctl_points[-2:]) != begin_inside:
+                bezier_path = concat([ctl_points_old[-2:], ctl_points])
+                break
+            ctl_points_old = ctl_points
+        else:
+            raise ValueError("The path does not intersect with the patch")
+
+        bp = bezier_path.reshape((-1, 2))
+        left, right = split_bezier_intersecting_with_closedpath(
+            bp, inside, tolerance)
+        if len(left) == 2:
+            codes_left = [Path.LINETO]
+            codes_right = [Path.MOVETO, Path.LINETO]
+        elif len(left) == 3:
+            codes_left = [Path.CURVE3, Path.CURVE3]
+            codes_right = [Path.MOVETO, Path.CURVE3, Path.CURVE3]
+        elif len(left) == 4:
+            codes_left = [Path.CURVE4, Path.CURVE4, Path.CURVE4]
+            codes_right = [Path.MOVETO, Path.CURVE4, Path.CURVE4, Path.CURVE4]
+        else:
+            raise AssertionError("This should never be reached")
+
+        verts_left = left[1:]
+        verts_right = right[:]
+
+        if self.codes is None:
+            path_in = Path(concat([self.vertices[:i], verts_left]))
+            path_out = Path(concat([verts_right, self.vertices[i:]]))
+
+        else:
+            path_in = Path(concat([self.vertices[:iold], verts_left]),
+                           concat([self.codes[:iold], codes_left]))
+
+            path_out = Path(concat([verts_right, self.vertices[i:]]),
+                            concat([codes_right, self.codes[i:]]))
+
+        if reorder_inout and not begin_inside:
+            path_in, path_out = path_out, path_in
+
+        return path_in, path_out
+
     def to_polygons(self, transform=None, width=0, height=0, closed_only=True):
         """
         Convert this path to a list of polygons or polylines.  Each
@@ -648,7 +710,8 @@ def unit_rectangle(cls):
     def unit_regular_polygon(cls, numVertices):
         """
         Return a :class:`Path` instance for a unit regular polygon with the
-        given *numVertices* and radius of 1.0, centered at (0, 0).
+        given *numVertices* such that the circumscribing circle has radius 1.0,
+        centered at (0, 0).
         """
         if numVertices <= 16:
             path = cls._unit_regular_polygons.get(numVertices)
