Improve tightbbox speed for non-rectilinear axes

lukelbd · lukelbd · commit 136de270f893 · 2021-12-12T15:57:48.000-07:00
This significantly improves the speed of `Axes.get_tightbbox()` for
non-rectilinear axes (in particular, PolarAxes and cartopy GeoAxes). By
default, artists added to these axes have an undefined `clip_box` and have
a `clip_path` equivalent to `TransformedPatchPath(ax.patch)` but whose extent
is undefined until the aritst is drawn. Matplotlib currently skips artists
in the `Axes.get_tightbbox()` computation only if their `clip_box` is
defined and its extents are equivalent to `ax.bbox.extents`, but this fails
to skip artists clipped by `TransformedPatchPath(ax.patch)`. This PR adds
`ax.patch.get_window_extent()` to the list of bounding boxes used by
`Axes.get_tightbbox()`, removes `Artist._get_clipping_extent_bbox()`,
adds `Artist._is_axes_clipped()`, and prevents `Axes.get_tightbbox()` from
drawing artists clipped by either `ax.bbox` or `ax.patch` (i.e. artists
for which `Artist._is_axes_clipped()` returns True).
diff --git a/lib/matplotlib/artist.py b/lib/matplotlib/artist.py
@@ -320,22 +320,34 @@ def get_window_extent(self, renderer):
         """
         return Bbox([[0, 0], [0, 0]])
 
-    def _get_clipping_extent_bbox(self):
-        """
-        Return a bbox with the extents of the intersection of the clip_path
-        and clip_box for this artist, or None if both of these are
-        None, or ``get_clip_on`` is False.
-        """
-        bbox = None
-        if self.get_clip_on():
-            clip_box = self.get_clip_box()
-            if clip_box is not None:
-                bbox = clip_box
-            clip_path = self.get_clip_path()
-            if clip_path is not None and bbox is not None:
-                clip_path = clip_path.get_fully_transformed_path()
-                bbox = Bbox.intersection(bbox, clip_path.get_extents())
-        return bbox
+    def _is_axes_clipped(self):
+        """
+        Return a boolean indicating whether the artist is clipped by the
+        axes bounding box or patch. True if ``get_clip_on`` is True, one of
+        `clip_box` or `clip_path` is set, ``clip_box.extents`` is equivalent
+        to ``axes.bbox.extents`` (if set), and ``clip_path._patch`` is
+        equivalent to ``axes.patch`` (if set).
+        """
+        # Note that ``clip_path.get_fully_transformed_path().get_extents()``
+        # cannot be directly compared to ``axes.bbox.extents`` because the
+        # extents may be undefined (i.e. negative to positive infinity)
+        # before the associated artist is drawn, and this method is meant
+        # to determine whether ``axes.get_tightbboe()`` may bypass drawing
+        ax = self.axes
+        clip_on = self.get_clip_on()
+        clip_box = self.get_clip_box()
+        clip_path = self.get_clip_path()
+        if ax is None or not clip_on or clip_box is None and clip_path is None:
+            return False
+        if clip_box is not None:
+            if not np.all(clip_box.extents == ax.bbox.extents):
+                return False
+        if clip_path is not None:
+            if not isinstance(clip_path, TransformedPatchPath):
+                return False
+            if clip_path._patch is not ax.patch:
+                return False
+        return True
 
     def get_tightbbox(self, renderer):
         """
diff --git a/lib/matplotlib/axes/_base.py b/lib/matplotlib/axes/_base.py
@@ -4626,6 +4626,8 @@ def get_tightbbox(self, renderer, call_axes_locator=True,
         self._update_title_position(renderer)
         axbbox = self.get_window_extent(renderer)
         bb.append(axbbox)
+        patchbbox = self.patch.get_window_extent(renderer)
+        bb.append(patchbbox)
 
         for title in [self.title, self._left_title, self._right_title]:
             if title.get_visible():
@@ -4642,18 +4644,11 @@ def get_tightbbox(self, renderer, call_axes_locator=True,
         if bbox_artists is None:
             bbox_artists = self.get_default_bbox_extra_artists()
 
+        include_types = (_AxesBase, maxis.Axis, mspines.Spine)
         for a in bbox_artists:
-            # Extra check here to quickly see if clipping is on and
-            # contained in the Axes.  If it is, don't get the tightbbox for
-            # this artist because this can be expensive:
-            clip_extent = a._get_clipping_extent_bbox()
-            if clip_extent is not None:
-                clip_extent = mtransforms.Bbox.intersection(
-                    clip_extent, axbbox)
-                if np.all(clip_extent.extents == axbbox.extents):
-                    # clip extent is inside the Axes bbox so don't check
-                    # this artist
-                    continue
+            # skip artists clipped by ax.bbox or ax.patch
+            if a._is_axes_clipped() and not isinstance(a, include_types):
+                continue
             bbox = a.get_tightbbox(renderer)
             if (bbox is not None
                     and 0 < bbox.width < np.inf
