incorporate @anntzer's BezierSegment feedback

brunobeltran · brunobeltran · commit dfc5ea040412 · 2020-03-19T10:38:51.000-07:00
diff --git a/lib/matplotlib/bezier.py b/lib/matplotlib/bezier.py
@@ -3,11 +3,13 @@
 """
 
 import math
+import warnings
 
 import numpy as np
 
 import matplotlib.cbook as cbook
 
+_comb = np.vectorize(math.comb)
 
 class NonIntersectingPathException(ValueError):
     pass
@@ -213,32 +215,80 @@ def find_bezier_t_intersecting_with_closedpath(
             start = middle
             start_inside = middle_inside
 
-
 class BezierSegment:
     """
-    A D-dimensional Bezier segment.
+    A d-dimensional Bezier segment.
 
     Parameters
     ----------
-    control_points : (N, D) array
+    control_points : (N, d) array
         Location of the *N* control points.
     """
 
     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 __call__(self, t):
+        return self.point_at_t(t)
 
     def point_at_t(self, t):
         """Return the point on the Bezier curve for parameter *t*."""
         return tuple(
             self._px @ (((1 - t) ** self._orders)[::-1] * t ** self._orders))
 
-    def __call__(self, t):
-        return self.point_at_t(t)
+    @property
+    def control_points(self):
+        """The control points of the curve."""
+        return self._cpoints
+
+    @property
+    def dimension(self):
+        """The dimension of the curve."""
+        return self._d
+
+    @property
+    def degree(self):
+        """The number of control points in the curve."""
+        return self._N - 1
+
+    @property
+    def polynomial_coefficients(self):
+        r"""The polynomial coefficients of the Bezier curve.
+
+        Returns
+        -------
+        coefs : float, (n+1, d) array_like
+            coefficients after expanding in polynomial basis, where n is the
+            degree of the bezier curve
+
+        Notes
+        -----
+        The coefficients are calculated as
+
+        .. math::
+
+            {n \choose j} \sum_{i=0}^j (-1)^{i+j} {j \choose i} P_i
+
+        """
+        n = self.degree
+        if n > 10:
+            warnings.warn("Polynomial coefficients formula unstable for high "
+                          "order Bezier curves!", RuntimeWarning)
+        d = self.dimension
+        P = self.control_points
+        coefs = np.zeros((n+1, d))
+        for j in range(n+1):
+            i = np.arange(j+1)
+            prefactor = np.power(-1, i + j) * _comb(j, i)
+            prefactor = np.tile(prefactor, (d, 1)).T
+            coefs[j] = _comb(n, j) * np.sum(prefactor*P[i], axis=0)
+        return coefs
 
     @property
     def interior_extrema(self):
@@ -254,33 +304,15 @@ def interior_extrema(self):
         dzeros : float, array_like
             of same size as dims. the $t$ such that $d/dx_i B(t) = 0$
         """
-        if self.n <= 2:  # a line's extrema are always its tips
-            p = [0]  # roots returns empty array for zero polynomial
+        n = self.degree
+        Cj = self.polynomial_coefficients
+        dCj = np.atleast_2d(np.arange(1, n+1)).T * Cj[1:]
+        if len(dCj) == 0:
             return np.array([]), np.array([])
-        elif self.n == 3:  # quadratic curve
-            # the bezier curve in standard form is
-            # cp[0] * (1 - t)^2 + cp[1] * 2t(1-t) + cp[2] * t^2
-            # can be re-written as
-            # cp[0] + 2 (cp[1] - cp[0]) t + (cp[2] - 2 cp[1] + cp[0]) t^2
-            # which has simple derivative
-            # 2*(cp[2] - 2*cp[1] + cp[0]) t + 2*(cp[1] - cp[0])
-            p = [2*(self.cpoints[2] - 2*self.cpoints[1] + self.cpoints[0]),
-                 2*(self.cpoints[1] - self.cpoints[0])]
-        elif self.n == 4:  # cubic curve
-            P = self.cpoints
-            # derivative of cubic bezier curve has coefficients
-            a = 3*(P[3] - 3*P[2] + 3*P[1] - P[0])
-            b = 6*(P[2] - 2*P[1] + P[0])
-            c = 3*(P[1] - P[0])
-            p = [a, b, c]
-        else:  # self.n > 4:
-            # a general formula exists, but is not useful for matplotlib
-            raise NotImplementedError("Zero finding only implemented up to "
-                                      "cubic curves.")
         dims = []
         roots = []
-        for i, pi in enumerate(np.array(p).T):
-            r = np.roots(pi)
+        for i, pi in enumerate(dCj.T):
+            r = np.roots(pi[::-1])
             roots.append(r)
             dims.append(i*np.ones_like(r))
         roots = np.concatenate(roots)
