ENH: Add TransformedPatchPath for clipping.

By linking to the Patch instead of its Path, the clip path can
automatically update whenever the underlying Patch changes.

Author: QuLogic

lib/matplotlib/artist.py

@@ -12,7 +12,7 @@
 from matplotlib.cbook import mplDeprecation
 from matplotlib import docstring, rcParams
 from .transforms import (Bbox, IdentityTransform, TransformedBbox,
-                         TransformedPath, Transform)
+                         TransformedPatchPath, TransformedPath, Transform)
 from .path import Path
 
 # Note, matplotlib artists use the doc strings for set and get
@@ -685,9 +685,7 @@ def set_clip_path(self, path, transform=None):
                 self._clippath = None
                 success = True
             elif isinstance(path, Patch):
-                self._clippath = TransformedPath(
-                    path.get_path(),
-                    path.get_transform())
+                self._clippath = TransformedPatchPath(path)
                 success = True
             elif isinstance(path, tuple):
                 path, transform = path
@@ -698,6 +696,9 @@ def set_clip_path(self, path, transform=None):
         elif isinstance(path, Path):
             self._clippath = TransformedPath(path, transform)
             success = True
+        elif isinstance(path, TransformedPatchPath):
+            self._clippath = path
+            success = True
         elif isinstance(path, TransformedPath):
             self._clippath = path
             success = True

lib/matplotlib/transforms.py

@@ -2715,6 +2715,46 @@ def get_affine(self):
         return self._transform.get_affine()
 
 
+class TransformedPatchPath(TransformedPath):
+    """
+    A :class:`TransformedPatchPath` caches a non-affine transformed copy of
+    the :class:`~matplotlib.path.Patch`. This cached copy is automatically
+    updated when the non-affine part of the transform or the patch changes.
+    """
+    def __init__(self, patch):
+        """
+        Create a new :class:`TransformedPatchPath` from the given
+        :class:`~matplotlib.path.Patch`.
+        """
+        TransformNode.__init__(self)
+
+        transform = patch.get_transform()
+        self._patch = patch
+        self._transform = transform
+        self.set_children(transform)
+        self._path = patch.get_path()
+        self._transformed_path = None
+        self._transformed_points = None
+
+    def _revalidate(self):
+        patch_path = self._patch.get_path()
+        # Only recompute if the invalidation includes the non_affine part of
+        # the transform, or the Patch's Path has changed.
+        if (self._transformed_path is None or self._path != patch_path or
+                (self._invalid & self.INVALID_NON_AFFINE ==
+                    self.INVALID_NON_AFFINE)):
+            self._path = patch_path
+            self._transformed_path = \
+                self._transform.transform_path_non_affine(patch_path)
+            self._transformed_points = \
+                Path._fast_from_codes_and_verts(
+                    self._transform.transform_non_affine(patch_path.vertices),
+                    None,
+                    {'interpolation_steps': patch_path._interpolation_steps,
+                     'should_simplify': patch_path.should_simplify})
+        self._invalid = 0
+
+
 def nonsingular(vmin, vmax, expander=0.001, tiny=1e-15, increasing=True):
     '''
     Modify the endpoints of a range as needed to avoid singularities.