add function to compute (signed) area of path

brunobeltran · brunobeltran · commit a56841301cd8 · 2020-04-08T21:52:31.000-07:00
diff --git a/doc/users/next_whats_new/2020-03-31-path-size-methods.rst b/doc/users/next_whats_new/2020-03-31-path-size-methods.rst
@@ -1,12 +1,36 @@
 
-Path extents now computed correctly
------------------------------------
+Functions to compute a Path's size
+----------------------------------
+
+Various functions were added to `~.bezier.BezierSegment` and `~.path.Path` to
+allow computation of the shape, size and area of a `~.path.Path` and its
+composite Bezier curves.
+
+In addition, to the fixes below, `~.bezier.BezierSegment` has gained more
+documentation and usability improvements, including properties that contain its
+dimension, degree, control_points, and more.
+
+Better interface for Path segment iteration
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+`~.path.Path.iter_bezier` iterates through the `~.bezier.BezierSegment`'s that
+make up the Path. This is much more useful typically than the existing
+`~.path.Path.iter_segments` function, which returns the absolute minimum amount
+of information possible to reconstruct the Path.
+
+Fixed bug that computed a Path's Bbox incorrectly
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 Historically, `~.path.Path.get_extents` has always simply returned the Bbox of
-its control points. While this is a correct upper bound for the path's extents,
-it can differ dramatically from the Path's actual extents for non-linear Bezier
-curves.
+a curve's control points, instead of the Bbox of the curve itself. While this is
+a correct upper bound for the path's extents, it can differ dramatically from
+the Path's actual extents for non-linear Bezier curves.
+
+Path area
+~~~~~~~~~
+
+A `~.path.Path.signed_area` method was added to compute the (signed) filled area
+of a Path object efficiently (i.e. without integration). This should be useful
+for constructing Path's of a desired area.
+
 
-In addition, `~.bezier.BezierSegment` has gained more documentation and
-usability improvements, including properties that contain its dimension, degree,
-control_points, and more.
diff --git a/lib/matplotlib/bezier.py b/lib/matplotlib/bezier.py
@@ -191,12 +191,135 @@ def __init__(self, control_points):
         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
+        self._px = (self._cpoints.T * coeff).T
+
+    def __call__(self, t):
+        """
+        Evaluate the Bezier curve at point(s) t in [0, 1].
+
+        Parameters
+        ----------
+        t : float (k,), array_like
+            Points at which to evaluate the curve.
+
+        Returns
+        -------
+        float (k, d), array_like
+            Value of the curve for each point in *t*.
+        """
+        t = np.array(t)
+        orders_shape = (1,)*t.ndim + self._orders.shape
+        t_shape = t.shape + (1,)  # self._orders.ndim == 1
+        orders = np.reshape(self._orders, orders_shape)
+        rev_orders = np.reshape(self._orders[::-1], orders_shape)
+        t = np.reshape(t, t_shape)
+        return ((1 - t)**rev_orders * t**orders) @ self._px
 
     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))
+        """Evaluate curve at a single point *t*. Returns a Tuple[float*d]."""
+        return tuple(self(t))
+
+    def arc_area(self):
+        r"""
+        (Signed) area swept out by ray from origin to curve.
+
+        The sum of this function for each Bezier curve in a Path will give the
+        area enclosed by the Path.
+
+        Returns
+        -------
+        float
+            The signed area of the arc swept out by the curve.
+
+        Notes
+        -----
+        A simple, analytical formula is possible for arbitrary bezier curves.
+
+        Given a bezier curve B(t), in order to calculate the area of the arc
+        swept out by the ray from the origin to the curve, we simply need to
+        compute :math:`\frac{1}{2}\int_0^1 B(t) \cdot n(t) dt`, where
+        :math:`n(t) = u^{(1)}(t) \hat{x}_0 - u{(0)}(t) \hat{x}_1` is the normal
+        vector oriented away from the origin and :math:`u^{(i)}(t) =
+        \frac{d}{dt} B^{(i)}(t)` is the :math:`i`th component of the curve's
+        tangent vector.  (This formula can be found by applying the divergence
+        theorem to :math:`F(x,y) = [x, y]/2`, and calculates the *signed* area
+        for a counter-clockwise curve, by the right hand rule).
+
+        The control points of the curve are just its coefficients in a
+        Bernstein expansion, so if we let :math:`P_i = [P^{(0)}_i, P^{(1)}_i]`
+        be the :math:`i`'th control point, then
+
+        .. math::
+
+            \frac{1}{2}\int_0^1 B(t) \cdot n(t) dt
+                   &= \frac{1}{2}\int_0^1 B^{(0)}(t) \frac{d}{dt} B^{(1)}(t)
+                                        - B^{(1)}(t) \frac{d}{dt} B^{(0)}(t)
+                                        dt \\
+                   &= \frac{1}{2}\int_0^1
+                        \left( \sum_{j=0}^n P_j^{(0)} b_{j,n} \right)
+                        \left( n \sum_{k=0}^{n-1} (P_{k+1}^{(1)} -
+                               P_{k}^{(1)}) b_{j,n} \right)
+                      \\
+                      &\hspace{1em} - \left( \sum_{j=0}^n P_j^{(1)} b_{j,n}
+                        \right) \left( n \sum_{k=0}^{n-1} (P_{k+1}^{(0)}
+                                     - P_{k}^{(0)}) b_{j,n} \right)
+                      dt,
+
+        where :math:`b_{\nu, n}(t) = {n \choose \nu} t^\nu {(1 - t)}^{n-\nu}`
+        is the :math:`\nu`'th Bernstein polynomial of degree :math:`n`.
+
+        Grouping :math:`t^l(1-t)^m` terms together for each :math:`l`,
+        :math:`m`, we get that the integrand becomes
+
+        .. math::
+
+            \sum_{j=0}^n \sum_{k=0}^{n-1}
+                {n \choose j} {{n - 1} \choose k}
+                &\left[P_j^{(0)} (P_{k+1}^{(1)} - P_{k}^{(1)})
+                    - P_j^{(1)} (P_{k+1}^{(0)} - P_{k}^{(0)})\right] \\
+                &\hspace{1em}\times{}t^{j + k} {(1 - t)}^{2n - 1 - j - k}
+
+        or just
+
+        .. math::
+
+            \sum_{j=0}^n \sum_{k=0}^{n-1}
+                \frac{{n \choose j} {{n - 1} \choose k}}
+                        {{{2n - 1} \choose {j+k}}}
+                [P_j^{(0)} (P_{k+1}^{(1)} - P_{k}^{(1)})
+                    - P_j^{(1)} (P_{k+1}^{(0)} - P_{k}^{(0)})]
+                b_{j+k,2n-1}(t).
+
+        Interchanging sum and integral, and using the fact that :math:`\int_0^1
+        b_{\nu, n}(t) dt = \frac{1}{n + 1}`, we conclude that the
+        original integral  can
+        simply be written as
+
+        .. math::
+
+            \frac{1}{2}&\int_0^1 B(t) \cdot n(t) dt
+            \\
+            &= \frac{1}{4}\sum_{j=0}^n \sum_{k=0}^{n-1}
+              \frac{{n \choose j} {{n - 1} \choose k}}
+                    {{{2n - 1} \choose {j+k}}}
+              [P_j^{(0)} (P_{k+1}^{(1)} - P_{k}^{(1)})
+             - P_j^{(1)} (P_{k+1}^{(0)} - P_{k}^{(0)})]
+        """
+        n = self.degree
+        area = 0
+        P = self.control_points
+        dP = np.diff(P, axis=0)
+        for j in range(n + 1):
+            for k in range(n):
+                area += _comb(n, j)*_comb(n-1, k)/_comb(2*n - 1, j + k) \
+                        * (P[j, 0]*dP[k, 1] - P[j, 1]*dP[k, 0])
+        return (1/4)*area
+
+    @classmethod
+    def differentiate(cls, B):
+        """Return the derivative of a BezierSegment, itself a BezierSegment"""
+        dcontrol_points = B.degree*np.diff(B.control_points, axis=0)
+        return cls(dcontrol_points)
 
     @property
     def control_points(self):
diff --git a/lib/matplotlib/path.py b/lib/matplotlib/path.py
@@ -610,14 +610,14 @@ def get_extents(self, transform=None, **kwargs):
         extents = np.array([np.inf, np.inf, -np.inf, -np.inf])
         for curve, code in self.iter_bezier(**kwargs):
             # start and endpoints can be extrema of the curve
-            _update_extents(extents, curve.point_at_t(0))  # start point
-            _update_extents(extents, curve.point_at_t(1))  # end point
+            _update_extents(extents, curve(0))  # start point
+            _update_extents(extents, curve(1))  # end point
             # interior extrema where d/ds B(s) == 0
             _, dzeros = curve.axis_aligned_extrema
             if len(dzeros) == 0:
                 continue
             for ti in dzeros:
-                potential_extrema = curve.point_at_t(ti)
+                potential_extrema = curve(ti)
                 _update_extents(extents, potential_extrema)
         return Bbox.from_extents(extents)
 
@@ -642,6 +642,47 @@ def intersects_bbox(self, bbox, filled=True):
         return _path.path_intersects_rectangle(
             self, bbox.x0, bbox.y0, bbox.x1, bbox.y1, filled)
 
+    def signed_area(self, **kwargs):
+        """
+        Get signed area of the filled path.
+
+        All sub paths are treated as if they had been closed. That is, if there
+        is a MOVETO without a preceding CLOSEPOLY, one is added.
+
+        If the path is made up of multiple components that overlap, the
+        overlapping area is multiply counted.
+
+        Returns
+        -------
+        float
+            The (signed) enclosed area of the path.
+
+        Notes
+        -----
+        If the Path is not self-intersecting and has no overlapping components,
+        then the absolute value of the signed area is equal to the actual
+        filled area when the Path is drawn (e.g. as a PathPatch).
+        """
+        area = 0
+        prev_point = None
+        prev_code = None
+        start_point = None
+        for B, code in self.iter_bezier(**kwargs):
+            if code == Path.MOVETO:
+                if prev_code is not None and prev_code is not Path.CLOSEPOLY:
+                    Bclose = BezierSegment(np.array([prev_point, start_point]))
+                    area += Bclose.arc_area()
+                start_point = B.control_points[0]
+            area += B.arc_area()
+            prev_point = B.control_points[-1]
+            prev_code = code
+        # add final implied CLOSEPOLY, if necessary
+        if start_point is not None \
+                and not np.all(np.isclose(start_point, prev_point)):
+            B = BezierSegment(np.array([prev_point, start_point]))
+            area += B.arc_area()
+        return area
+
     def interpolated(self, steps):
         """
         Return a new path resampled to length N x steps.
diff --git a/lib/matplotlib/tests/test_bezier.py b/lib/matplotlib/tests/test_bezier.py
@@ -0,0 +1,25 @@
+from matplotlib.tests.test_path import _test_curves
+
+import numpy as np
+import pytest
+import scipy.integrate
+
+
+# get several curves to test our code on by borrowing the tests cases used in
+# `~.tests.test_path`. get last path element ([-1]) and curve, not code ([0])
+_test_curves = [list(tc.path.iter_bezier())[-1][0] for tc in _test_curves]
+
+
+def _integral_arc_area(B):
+    """(Signed) area swept out by ray from origin to curve."""
+    dB = B.differentiate(B)
+    def integrand(t):
+        dr = dB(t).T
+        n = np.array([dr[1], -dr[0]])
+        return (B(t).T @ n) / 2
+    return scipy.integrate.quad(integrand, 0, 1)[0]
+
+
+@pytest.mark.parametrize("B", _test_curves)
+def test_area_formula(B):
+    assert np.isclose(_integral_arc_area(B), B.arc_area())
diff --git a/lib/matplotlib/tests/test_path.py b/lib/matplotlib/tests/test_path.py
@@ -1,7 +1,7 @@
 import copy
+from collections import namedtuple
 
 import numpy as np
-
 from numpy.testing import assert_array_equal
 import pytest
 
@@ -49,25 +49,26 @@ def test_contains_points_negative_radius():
     np.testing.assert_equal(result, [True, False, False])
 
 
-_test_paths = [
+_ExampleCurve = namedtuple('ExampleCurve', ['path', 'extents', 'area'])
+_test_curves = [
     # interior extrema determine extents and degenerate derivative
-    Path([[0, 0], [1, 0], [1, 1], [0, 1]],
-           [Path.MOVETO, Path.CURVE4, Path.CURVE4, Path.CURVE4]),
-    # a quadratic curve
-    Path([[0, 0], [0, 1], [1, 0]], [Path.MOVETO, Path.CURVE3, Path.CURVE3]),
+    _ExampleCurve(Path([[0, 0], [1, 0], [1, 1], [0, 1]],
+                       [Path.MOVETO, Path.CURVE4, Path.CURVE4, Path.CURVE4]),
+                  extents=(0., 0., 0.75, 1.), area=0.6),
+    # a quadratic curve, clockwise
+    _ExampleCurve(Path([[0, 0], [0, 1], [1, 0]], [Path.MOVETO, Path.CURVE3,
+                  Path.CURVE3]), extents=(0., 0., 1., 0.5), area=-1/3),
     # a linear curve, degenerate vertically
-    Path([[0, 1], [1, 1]], [Path.MOVETO, Path.LINETO]),
+    _ExampleCurve(Path([[0, 1], [1, 1]], [Path.MOVETO, Path.LINETO]),
+                  extents=(0., 1., 1., 1.), area=0.),
     # a point
-    Path([[1, 2]], [Path.MOVETO]),
+    _ExampleCurve(Path([[1, 2]], [Path.MOVETO]), extents=(1., 2., 1., 2.),
+                  area=0.),
 ]
 
 
-_test_path_extents = [(0., 0., 0.75, 1.), (0., 0., 1., 0.5), (0., 1., 1., 1.),
-                      (1., 2., 1., 2.)]
-
-
-@pytest.mark.parametrize('path, extents', zip(_test_paths, _test_path_extents))
-def test_exact_extents(path, extents):
+@pytest.mark.parametrize('precomputed_curve', _test_curves)
+def test_exact_extents(precomputed_curve):
     # notice that if we just looked at the control points to get the bounding
     # box of each curve, we would get the wrong answers. For example, for
     # hard_curve = Path([[0, 0], [1, 0], [1, 1], [0, 1]],
@@ -77,9 +78,33 @@ def test_exact_extents(path, extents):
     # the way out to the control points.
     # Note that counterintuitively, path.get_extents() returns a Bbox, so we
     # have to get that Bbox's `.extents`.
+    path, extents = precomputed_curve.path, precomputed_curve.extents
     assert np.all(path.get_extents().extents == extents)
 
 
+@pytest.mark.parametrize('precomputed_curve', _test_curves)
+def test_signed_area(precomputed_curve):
+    path, area = precomputed_curve.path, precomputed_curve.area
+    assert np.isclose(path.signed_area(), area)
+    # now flip direction, sign of *signed_area* should flip
+    rverts = path.vertices[:0:-1]
+    rverts = np.append(rverts, np.atleast_2d(path.vertices[0]), axis=0)
+    rcurve = Path(rverts, path.codes)
+    assert np.isclose(rcurve.signed_area(), -area)
+
+
+def test_signed_area_unit_rectangle():
+    rect = Path.unit_rectangle()
+    assert np.isclose(rect.signed_area(), 1)
+
+
+def test_signed_area_unit_circle():
+    circ = Path.unit_circle()
+    # not quite pi, since it's not a "real" circle, just an approximation of a
+    # circle made out of bezier curves
+    assert np.isclose(circ.signed_area(), 3.1415935732517166)
+
+
 def test_point_in_path_nan():
     box = np.array([[0, 0], [1, 0], [1, 1], [0, 1], [0, 0]])
     p = Path(box)
diff --git a/requirements/testing/travis_all.txt b/requirements/testing/travis_all.txt
@@ -8,3 +8,4 @@ pytest-timeout
 pytest-xdist
 python-dateutil
 tornado
+scipy
