Added a simple test that artist._is_axes_clipped() returns True under default conditions / various projections. Note all non-rectilinear axes (e.g. PolarAxes, MollweideAxes, cartopy GeoAxes) have artist.get_clip_box() set to None.

I can also see the origin of this bug: The Artist._get_clipping_extent_bbox() lines that I removed (previously used inside Axes.get_tightbbox() to skip artists) mirror the below lines in Artist.get_tightbbox().

While Artist.get_tightbbox() starts the if block with a valid bbox, Artist._get_clipping_extent_bbox() starts with bbox = None... so when it gets to Line 361, the clip_path is ignored, because there is no bbox to intersect with.

I've improved this PR in a force push:

• Renamed _is_axes_clipped() to _fully_clipped_to_axes (thanks @tacaswell).
• Added test lines that assert _fully_clipped_to_axes() is False for non-default clipping situations (re: @jklymak).
• Removed the redundant addition of ax.patch to the bboxes (it's included in get_default_bbox_extra_artists()).
• Condensed multiple return statements into a single boolean return statement (possibly cleaner?)
• Moved the line that skips artists from Axes.get_tightbbox() to Axes.get_default_bbox_extra_artists(). Note this means the public get_default_bbox_extra_artists() will return different values compared to previous versions.

I also made the following additional changes:

• Removed an unnecessary bbox is not None check in Artist.get_tightbbox() (this is always True).
• Removed axis instances from get_default_bbox_extra_artists() (was redundant -- see Axes.get_tightbbox()).
• Replaced Axes.get_tightbbox() reference to [xy]axis with ax._get_axis_list() (consistent with removed lines).
• Always include artists that don't internally implement clipping (should fix obscure tight layout "bugs").

The latter points also resolve a second inefficiency: Currently, Axes.get_tightbbox() both 1) computes the xaxis and yaxis tight bbox using for_layout_only=True on these lines:

and 2) includes xaxis and yaxis as "extra artists" in get_default_bbox_extra_artists(). This meant that their bounding boxes would be effectively calculated twice if they were not "skipped" by the _get_clipping_extent_bbox check. For some reason, this check was successfully skipping xaxis and yaxis in rectilinear axes, because they have a clip_on set to True and clip_box set to ax.bbox (despite the fact that they are not clipped when drawn..... weird). However, this failed to skip non-rectilinear axis instances, because they only have a clip_path set to ax.patch. After this PR, axis instances are excluded from Axes.get_default_bbox_extra_artists(), and their extents are always calculated once.

I've also verified that, as before, ax.patch and ax.spines are still included as default "extra artists". Here's a test I used to determine the default clipping settings for various axes components:

import matplotlib.pyplot as plt
import cartopy.crs as ccrs
fig = plt.figure(figsize=(4, 2))
ax1 = fig.add_subplot(131)
ax2 = fig.add_subplot(132, projection='polar')
ax3 = fig.add_subplot(133, projection='hammer')
for ax in (ax1, ax2, ax3):
    print(ax)
    for a in (ax.patch, tuple(ax.spines.values())[0]):
        clip_box = a.get_clip_box()
        b1 = clip_box is not None and np.all(clip_box.extents == ax.bbox.extents)
        clip_path = a.get_clip_path()
        b2 = clip_path is not None and clip_path._patch is ax.patch
        print(a, '\nclip on?', a.get_clip_on(), '\naxes clip box?', b1, '\naxes clip path?', b2, '\nFULLY CLIPPED?', a._fully_clipped_to_axes())
    print()

Results:

AxesSubplot(0.125,0.11;0.227941x0.77)
Rectangle(xy=(0, 0), width=1, height=1, angle=0)
clip on? True
axes clip box? False
axes clip path? False
FULLY CLIPPED? False
Spine
clip on? True
axes clip box? False
axes clip path? False
FULLY CLIPPED? False

PolarAxesSubplot(0.398529,0.11;0.227941x0.77)
Wedge(center=(0.5, 0.5), r=0.5, theta1=0, theta2=360, width=None)
clip on? True
axes clip box? False
axes clip path? False
FULLY CLIPPED? False
Spine
clip on? True
axes clip box? False
axes clip path? False
FULLY CLIPPED? False

HammerAxesSubplot(0.672059,0.11;0.227941x0.77)
Circle(xy=(0.5, 0.5), radius=0.5)
clip on? True
axes clip box? False
axes clip path? False
FULLY CLIPPED? False
Spine
clip on? True
axes clip box? False
axes clip path? False
FULLY CLIPPED? False

This all looks good, but are we sure it has similar performance to before? https://github.com/matplotlib/mpl-bench has benchmarking mechanisms, in particular you could use the constrained_layout and tight_layout tests?

Here are some very quick benchmarks with 2-column figures of map projections (thanks for pointing me to mpl-benchmark -- don't have time to look into that now, but will later). Repeating the tests several times gives qualitatively similar results. If I have time later I can post more rigorous benchmarks.

In principle this fits as a matplotlib PR, but the speedup does seem to be cartopy-specific. I get essentially zero speedup for 1) non-rectilinear matplotlib axes and 2) by omitting the transform=ccrs.PlateCarree() line in the cartopy example. It seems that for high-res datasets, the limitation in cartopy is translating coordinates (triggered in both get_window_extent and draw). In those cases, this PR can deliver a roughly 2x speedup.

Cartopy JPG test

Test code:

import time
import numpy as np
import matplotlib.pyplot as plt
import cartopy.crs as ccrs
import proplot as pplt
fig, axs = plt.subplots(ncols=2, figsize=(8, 4), subplot_kw={'projection': ccrs.Stereographic()})
t1 = time.time()
lon = np.linspace(0, 360, 3000)
lat = np.linspace(-60, 60, 500)
state = np.random.RandomState(51423)
data = state.rand(len(lat) - 1, len(lon) - 1)
for ax in axs:
    ax.coastlines()
    ax.pcolormesh(lon, lat, data, transform=ccrs.PlateCarree())
t2 = time.time()
print('Plot time:', t2 - t1)
fig.savefig('test.jpg', dpi=300, bbox_inches=None)
# fig.savefig('test.jpg', dpi=300, bbox_inches='tight')
t3 = time.time()
print('Save time:', t3 - t2)

Results with bbox_inches=None:

Plot time: 5.106376886367798
Save time: 4.24917197227478

Results with bbox_inches='tight', after this PR (save time ~20% slower):

Plot time: 5.4417970180511475
Save time: 5.905539035797119

Results with bbox_inches='tight', before this PR (save time ~120% slower):

Plot time: 5.133382081985474
Save time: 10.721824884414673

Cartopy PDF test

Test code:

import time
import numpy as np
import matplotlib.pyplot as plt
import cartopy.crs as ccrs
import proplot as pplt
fig, axs = plt.subplots(ncols=2, figsize=(8, 4), subplot_kw={'projection': ccrs.Stereographic()})
t1 = time.time()
lon = np.linspace(0, 360, 100)
lat = np.linspace(-60, 60, 100)
state = np.random.RandomState(51423)
data = state.rand(len(lat) - 1, len(lon) - 1)
for ax in axs:
    ax.coastlines()
    ax.pcolormesh(lon, lat, data, transform=ccrs.PlateCarree())
t2 = time.time()
print('Plot time:', t2 - t1)
fig.savefig('test.pdf')
t3 = time.time()
print('Save time:', t3 - t2)

Results with bbox_inches=None:

Plot time: 0.28498291969299316
Save time: 2.3959097862243652

Results with bbox_inches='tight', after this PR (save time ~10% slower):

Plot time: 0.24462389945983887
Save time: 2.699641227722168

Results with bbox_inches='tight', before this PR (save time ~60% slower):

Plot time: 0.2555239200592041
Save time: 3.705993890762329

Matplotlib JPG test

Test code:

import time
import numpy as np
import matplotlib.pyplot as plt
import cartopy.crs as ccrs
import proplot as pplt
fig, axs = plt.subplots(ncols=2, figsize=(8, 4), subplot_kw={'projection': 'hammer'})
t1 = time.time()
lon = np.linspace(0, 360, 500)
lat = np.linspace(-60, 60, 500)
state = np.random.RandomState(51423)
data = state.rand(len(lat) - 1, len(lon) - 1)
for ax in axs:
    ax.pcolormesh(lon, lat, data)
t2 = time.time()
print('Plot time:', t2 - t1)
fig.savefig('test.jpg', dpi=300, bbox_inches='tight')
t3 = time.time()
print('Save time:', t3 - t2)

Results with bbox_inches=None:

0.04705810546875
Save time: 12.776510953903198

Results with bbox_inches='tight', after this PR (save time about the same):

Plot time: 0.05183219909667969
Save time: 11.54852819442749

Results with bbox_inches='tight', before this PR (save time about the same):

Plot time: 0.053359031677246094
Save time: 11.422415018081665