matplotlib · brunobeltran · Feb 29, 2020 · Mar 1, 2020 · Mar 1, 2020 · Mar 3, 2020
diff --git a/lib/matplotlib/bezier.py b/lib/matplotlib/bezier.py
@@ -7,7 +7,6 @@
 import numpy as np
 
 import matplotlib.cbook as cbook
-from matplotlib.path import Path
 
 
 class NonIntersectingPathException(ValueError):
@@ -177,18 +176,74 @@ 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*."""
         return tuple(
             self._px @ (((1 - t) ** self._orders)[::-1] * t ** self._orders))
 
+    @property
+    def tan_in(self):
+        if self.n < 2:
+            raise ValueError("Need at least two control points to get tangent "
+                             "vector!")
+        return self.cpoints[1] - self.cpoints[0]
+
+    @property
+    def tan_out(self):
+        if self.n < 2:
+            raise ValueError("Need at least two control points to get tangent "
+                             "vector!")
+        return self.cpoints[-1] - self.cpoints[-2]
+
+    @property
+    def interior_extrema(self):
+        if self.n <= 2:  # a line's extrema are always its tips
+            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])
+            num = 2*(self.cpoints[2] - 2*self.cpoints[1] + self.cpoints[0])
+            denom = self.cpoints[1] - self.cpoints[0]
+            mask = ~np.isclose(denom, 0)
+            zeros = num[mask]/denom[mask]
+            dims = np.arange(self.d)[mask]
+            in_range = (0 <= zeros) & (zeros <= 1)
+            return dims[in_range], zeros[in_range]
+        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])
+            discriminant = b**2 - 4*a*c
+            dims = []
+            zeros = []
+            for i in range(self.d):
+                if discriminant[i] < 0:
+                    continue
+                roots = [(-b[i] + np.sqrt(discriminant[i]))/2/a[i],
+                         (-b[i] - np.sqrt(discriminant[i]))/2/a[i]]
+                for root in roots:
+                    if 0 <= root <= 1:
+                        dims.append(i)
+                        zeros.append(root)
+            return np.asarray(dims), np.asarray(zeros)
+        else:  # self.n > 4:
+            raise NotImplementedError("Zero finding only implemented up to "
+                                      "cubic curves.")
+
 
 def split_bezier_intersecting_with_closedpath(
         bezier, inside_closedpath, tolerance=0.01):
@@ -225,68 +280,6 @@ def split_bezier_intersecting_with_closedpath(
 # 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
@@ -306,6 +299,7 @@ def _f(xy):
 
 # 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 +472,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/lines.py b/lib/matplotlib/lines.py
@@ -617,8 +617,13 @@ def get_window_extent(self, renderer):
                                  ignore=True)
         # correct for marker size, if any
         if self._marker:
-            ms = (self._markersize / 72.0 * self.figure.dpi) * 0.5
-            bbox = bbox.padded(ms)
+            m_bbox = self._marker.get_bbox(
+                    self._markersize, self._markeredgewidth)
+            # markers use units of pts, not pixels
+            box_points_px = renderer.points_to_pixels(m_bbox.get_points())
+            # add correct padding to each side of bbox (note: get_points means
+            # the four points of the bbox, not units of "pt".
+            bbox = Bbox(bbox.get_points() + box_points_px)
         return bbox
 
     @Artist.axes.setter

diff --git a/lib/matplotlib/markers.py b/lib/matplotlib/markers.py
@@ -133,7 +133,7 @@
 
 from . import cbook, rcParams
 from .path import Path
-from .transforms import IdentityTransform, Affine2D
+from .transforms import IdentityTransform, Affine2D, Bbox
 
 # special-purpose marker identifiers:
 (TICKLEFT, TICKRIGHT, TICKUP, TICKDOWN,
@@ -198,9 +198,6 @@ class MarkerStyle:
     fillstyles = ('full', 'left', 'right', 'bottom', 'top', 'none')
     _half_fillstyles = ('left', 'right', 'bottom', 'top')
 
-    # TODO: Is this ever used as a non-constant?
-    _point_size_reduction = 0.5
-
     def __init__(self, marker=None, fillstyle=None):
         """
         Attributes
@@ -408,7 +405,8 @@ def _set_pixel(self):
         self._snap_threshold = None
 
     def _set_point(self):
-        self._set_circle(reduction=self._point_size_reduction)
+        # a "point" is defined to a circle with half the requested markersize
+        self._set_circle(reduction=0.5)
 
     _triangle_path = Path(
         [[0.0, 1.0], [-1.0, -1.0], [1.0, -1.0], [0.0, 1.0]],
@@ -898,3 +896,43 @@ def _set_x_filled(self):
             self._alt_transform = Affine2D().translate(-0.5, -0.5)
             self._transform.rotate_deg(rotate)
             self._alt_transform.rotate_deg(rotate_alt)
+
+    def get_bbox(self, markersize, markeredgewidth=0, **kwargs):
+        """Get size of bbox of marker directly from its path.
+
+        Parameters
+        ----------
+        markersize : float
+            "Size" of the marker, in points.
+
+        markeredgewidth : float, optional, default: 0
+            Width, in points, of the stroke used to create the marker's edge.
+
+        kwargs : Dict[str, object]
+            forwarded to path's iter_curves and iter_corners
+
+        Returns
+        -------
+        bbox : matplotlib.transforms.Bbox
+            The extents of the marker including its edge (in points) if it were
+            centered at (0,0).
+
+        Note
+        ----
+        The approach used is simply to notice that the bbox with no marker edge
+        must be defined by a corner (control point of the linear parts of path)
+        or a an extremal point on one of the curved parts of the path.
+
+        For a nonzero marker edge width, because the interior extrema will by
+        definition be parallel to the bounding box, we need only check if the
+        path location + width/2 extends the bbox at each interior extrema.
+        Then, for each join and cap, we check if that join extends the bbox.
+        """
+        if np.isclose(markersize, 0):
+            return Bbox([[0, 0], [0, 0]])
+        unit_path = self._transform.transform_path(self._path)
+        scale = Affine2D().scale(markersize)
+        path = scale.transform_path(unit_path)
+        return Bbox.from_extents(path.get_stroked_extents(markeredgewidth,
+                                                          self._joinstyle,
+                                                          self._capstyle))
diff --git a/lib/matplotlib/patches.py b/lib/matplotlib/patches.py
@@ -10,10 +10,9 @@
 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,
+    inside_circle, make_wedged_bezier2,
+    split_bezier_intersecting_with_closedpath)
 from .path import Path
 
 
@@ -2724,7 +2723,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
 
@@ -2736,7 +2735,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
 
@@ -2751,13 +2750,13 @@ def _shrink(self, path, shrinkA, shrinkB):
             if 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)
                 try:
-                    path, right = split_path_inout(path, insideB)
+                    path, right = path.split_path_inout(insideB)
                 except ValueError:
                     pass
             return path
@@ -3187,7 +3186,7 @@ def __call__(self, path, mutation_size, linewidth,
             and takes care of the aspect ratio.
             """
 
-            path = make_path_regular(path)
+            path = path.make_path_regular()
 
             if aspect_ratio is not None:
                 # Squeeze the given height by the aspect_ratio
@@ -4174,7 +4173,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):