Speedup ax.get_tightbbox() for nonrectilinear axes

lukelbd · lukelbd · commit a5a704eb2b34 · 2021-12-15T22:44:21.000-07:00
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. positive to negative infinity)
+        # before the associated artist is drawn, and this method is meant
+        # to determine whether ``axes.get_tightbbox()`` 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
diff --git a/lib/matplotlib/tests/test_tightlayout.py b/lib/matplotlib/tests/test_tightlayout.py
@@ -342,3 +342,18 @@ def test_manual_colorbar():
     fig.colorbar(pts, cax=cax)
     with pytest.warns(UserWarning, match="This figure includes Axes"):
         fig.tight_layout()
+
+
+def test_axes_clipped():
+    # Test that artists with default axes clipping are
+    # detected and skipped by the tight layout algorithm.
+    arr = np.arange(100).reshape((10, 10))
+    fig = plt.figure(figsize=(6, 2))
+    ax1 = fig.add_subplot(projection='rectilinear')
+    ax2 = fig.add_subplot(projection='mollweide')
+    ax3 = fig.add_subplot(projection='polar')
+    for ax in (ax1, ax2, ax3):
+        h, = ax.plot(arr[:, 0])
+        m = ax.pcolor(arr)
+        assert h._is_axes_clipped()
+        assert m._is_axes_clipped()
