refactor Bezier so it doesn't depend on Path

brunobeltran · brunobeltran · commit 1a7b35ba9aca · 2020-03-18T12:41:22.000-07:00
diff --git a/doc/api/next_api_changes/deprecations.rst b/doc/api/next_api_changes/deprecations.rst
@@ -227,19 +227,9 @@ The following validators, defined in `.rcsetup`, are deprecated:
 ``validate_axes_titlelocation``, ``validate_toolbar``,
 ``validate_ps_papersize``, ``validate_legend_loc``,
 ``validate_bool_maybe_none``, ``validate_hinting``,
-``validate_movie_writers``.
+``validate_movie_writers``, ``validate_webagg_address``.
 To test whether an rcParam value would be acceptable, one can test e.g. ``rc =
 RcParams(); rc[k] = v`` raises an exception.
-||||||| constructed merge base
-``validate_ps_papersize``, ``validate_legend_log``.  To test whether an rcParam
-value would be acceptable, one can test e.g. ``rc = RcParams(); rc[k] = v``
-raises an exception.
-=======
-``validate_ps_papersize``, ``validate_legend_loc``,
-``validate_webagg_address``.
-To test whether an rcParam value would be acceptable, one can test e.g. ``rc =
-RcParams(); rc[k] = v`` raises an exception.
->>>>>>> Deprecate validate_webagg_address.
 
 Stricter rcParam validation
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~
@@ -370,3 +360,13 @@ mathtext ``Glue`` helper classes
 The ``Fil``, ``Fill``, ``Filll``, ``NegFil``, ``NegFill``, ``NegFilll``, and
 ``SsGlue`` classes in the :mod:`matplotlib.mathtext` module are deprecated.
 As an alternative, directly construct glue instances with ``Glue("fil")``, etc.
+
+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.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
@@ -84,7 +84,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,54 @@ def get_normal_points(cx, cy, cos_t, sin_t, length):
     return x1, y1, x2, y2
 
 
+# deprecated routines (moved to `.Path`)
+
+
+@cbook.deprecated("3.3")
+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.deprecated("3.3", alternative="Path.make_compound_path()")
+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)
+
+
+@cbook.deprecated(
+    "3.3", alternative="Path.cleaned() and remove the final STOP if needed")
+def make_path_regular(path):
+    """
+    If the ``codes`` attribute of `.Path` *p* is None, return a copy of *p*
+    with ``codes`` set to (MOVETO, LINETO, LINETO, ..., LINETO); otherwise
+    return *p* itself.
+    """
+    return path.make_path_regular()
+
+
+@cbook.deprecated("3.3", alternative="Path.make_compound_path()")
+def concatenate_paths(paths):
+    """Concatenate a list of paths into a single path."""
+    from .path import Path
+    return Path.make_compound_path(*paths)
+
+
 # BEZIER routines
 
 # subdividing bezier curve
@@ -177,12 +225,13 @@ class BezierSegment:
     """
 
     def __init__(self, control_points):
-        n = len(control_points)
-        self._orders = np.arange(n)
-        coeff = [math.factorial(n - 1)
-                 // (math.factorial(i) * math.factorial(n - 1 - i))
-                 for i in range(n)]
-        self._px = np.asarray(control_points).T * coeff
+        self.cpoints = np.asarray(control_points)
+        self.n, self.d = self.cpoints.shape
+        self._orders = np.arange(self.n)
+        coeff = [math.factorial(self.n - 1)
+                 // (math.factorial(i) * math.factorial(self.n - 1 - i))
+                 for i in range(self.n)]
+        self._px = self.cpoints.T * coeff
 
     def point_at_t(self, t):
         """Return the point on the Bezier curve for parameter *t*."""
@@ -222,90 +271,9 @@ 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
-
-
-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
-
-
 # quadratic Bezier lines
 
+
 def get_cos_sin(x0, y0, x1, y1):
     dx, dy = x1 - x0, y1 - y0
     d = (dx * dx + dy * dy) ** .5
@@ -478,25 +446,3 @@ def make_wedged_bezier2(bezier2, width, w1=1., wm=0.5, w2=0.):
                                      c3x_right, c3y_right)
 
     return path_left, path_right
-
-
-def make_path_regular(p):
-    """
-    If the ``codes`` attribute of `.Path` *p* is None, return a copy of *p*
-    with ``codes`` set to (MOVETO, LINETO, LINETO, ..., LINETO); otherwise
-    return *p* itself.
-    """
-    c = p.codes
-    if c is None:
-        c = np.full(len(p.vertices), Path.LINETO, dtype=Path.code_type)
-        c[0] = Path.MOVETO
-        return Path(p.vertices, c)
-    else:
-        return p
-
-
-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)
diff --git a/lib/matplotlib/patches.py b/lib/matplotlib/patches.py
@@ -10,13 +10,28 @@
 import matplotlib as mpl
 from . import artist, cbook, colors, docstring, lines as mlines, transforms
 from .bezier import (
-    NonIntersectingPathException, concatenate_paths, get_cos_sin,
-    get_intersection, get_parallels, inside_circle, make_path_regular,
-    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"],
@@ -2414,7 +2429,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
 
@@ -2426,7 +2441,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
 
@@ -2439,15 +2454,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
@@ -2872,9 +2887,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.
             """
-
-            path = make_path_regular(path)
-
             if aspect_ratio is not None:
                 # Squeeze the given height by the aspect_ratio
                 vertices = path.vertices / [1, aspect_ratio]
@@ -2886,10 +2898,9 @@ def __call__(self, path, mutation_size, linewidth,
                 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
@@ -3340,7 +3351,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:
@@ -3423,7 +3434,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)
@@ -3438,7 +3449,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
@@ -3456,7 +3467,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]
@@ -4125,7 +4136,7 @@ def get_path(self):
         """
         _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/path.py b/lib/matplotlib/path.py
diff --git a/lib/matplotlib/tests/test_artist.py b/lib/matplotlib/tests/test_artist.py
