compute area enclosed by path

brunobeltran · brunobeltran · commit 7615112d49ee · 2020-03-20T16:53:48.000-07:00
diff --git a/lib/matplotlib/bezier.py b/lib/matplotlib/bezier.py
@@ -6,6 +6,7 @@
 import warnings
 
 import numpy as np
+import scipy.integrate
 
 import matplotlib.cbook as cbook
 
@@ -254,6 +255,20 @@ def point_at_t(self, t):
         """Return the point on the Bezier curve for parameter *t*."""
         return tuple(self(t))
 
+    def arc_area(self):
+        """(Signed) area between curve an origin."""
+        dB = self.differentiate(self)
+        def integrand(t):
+            dr = dB(t).T
+            n = np.array([dr[1], -dr[0]])
+            return (self(t).T @ n) / 2
+        return scipy.integrate.quad(integrand, 0, 1)[0]
+
+    @classmethod
+    def differentiate(cls, B):
+        dcontrol_points = B.degree*np.diff(B.control_points, axis=0)
+        return cls(dcontrol_points)
+
     @property
     def control_points(self):
         """The control points of the curve."""
diff --git a/lib/matplotlib/path.py b/lib/matplotlib/path.py
@@ -658,6 +658,41 @@ 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 filled by 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.
+
+        Signed area means that if a path is self-intersecting, the drawing rule
+        "even-odd" is used and only the filled area is counted.
+
+        Returns
+        -------
+        area : float
+            The (signed) enclosed area of the path.
+        """
+        area = 0
+        prev_point = None
+        prev_code = None
+        start_point = None
+        for cpoints, code in self.iter_curves(**kwargs):
+            if code == Path.MOVETO:
+                if prev_code is not None and prev_code is not Path.CLOSEPOLY:
+                    B = BezierSegment(np.array([prev_point, start_point]))
+                    area += B.arc_area()
+                start_point = cpoints[0]
+            B = BezierSegment(cpoints)
+            area += B.arc_area()
+            prev_point = cpoints[-1]
+            prev_code = code
+        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):
         """
         Returns a new path resampled to length N x steps.  Does not
