Improve multi-axes layout options

[mwaskom]

Here are some notes on a plan for improving the layout options in the classes defined in seaborn.axisgrid. These objects try to produce plots with "nice layouts" by default, including by placing a joint legend "outside" and then resizing the figure to include it. They also use a different approach to specifying figure size such that the user gives the height and aspect ratio of each facet rather than the total figure size.

Some issues are that

• The height/aspect parameters are only approximate: the figure size is (n_col * height * aspect, n_row * height) which doesn't account for the axes/tick labels. Things can really get distorted with long y axes labels, i.e. with horiztonally oriented categorical plots. (I feel like I've seen particularly pathological cases where long y axes labels stole space only from the first axes, but am having trouble reproducing, so perhaps matplotlib improved the tight_layout algorithm to handle this better.
• It's not possible to specify the legend position.
• ~Once the legend exist, calling tight_layout again ignores it and stretches the subplots out to overlap with it. This is because in general matplotlib layout algorithms ignore figure-level legends.~ Fixed (in seaborn) by https://github.com/mwaskom/seaborn/pull/2073.
• ~There are some bad interactions with the macOS backend (#1527)~ (Fixed by https://github.com/matplotlib/matplotlib/issues/15131)

Matplotlib has a new constrained layout manager which could give better performance than the current approach of periodically calling tight_layout. It is currently described as "experimental" so it can't be the default but it could be made an option.

I'd also like to replace the bespoke approach to modifying the figure size to account for the legend by using the existing bbox_inches="tight" machinery, and also extend it to expand the figure to include the axis ticks and labels in a way that doesn't distort the requested size and aspect ratio.

I've figured out some of this. Here's a relevant example:

f, ax = plt.subplots(figsize=(4, 4))

f.subplots_adjust(0, 0, 1, 1)
ax.plot([0, 1], [0, 1], label="the plot")
ax.legend(loc="center left", bbox_to_anchor=(1, .5))

renderer = f.canvas.get_renderer()
f.draw(renderer)
bbox = f.get_tightbbox(renderer)
tight_bbox.adjust_bbox(f, bbox.padded(.05))

The basic approach then is going to be to set up the subplot array, set the subplot params to minimize exterior padding, delegate arrangement of the interior of the plot to tight_layout or constrained_layout, and then use an "expand figure" operation with the above logic when the legend/labels change.

Other related ideas:

• Adding single labels for x and y variables. This is actually a little tricky to do in a way that will get updated properly by {tight,constrained}_layout. Maybe worth pitching "subplot labels" to matplotlib, although we couldn't use them yet.
• Set the default size by some kind of scaling factor from the rcParams default figure size? This is a point of confusion for people but there's not an obvious way to do it.
• Using relplot, catplot, and lmplot without specifying col or row returns a FacetGrid which is maybe confusing? Perhaps this could be slightly different class that shares relevant methods.
• No way to add a shared continuous colorbar, which has been requested a bunch.
• Maybe add a parameter like adjust_strategy which can be "expand" or "contract", where "expand" uses the approach described above and "contract" keeps the plot at the original size.
• Add a FacetGrid.set_prop (or similiar — matplotlib uses setp which is not very discoverable) with the api set_prop(artists, **kwargs) which iterates through the axes, gets the relevant artist, and sets properties on them.
• Need better documentation for how figure size is determined and what to do if you really want an exact total figure size.

[MaozGelbart]

These objects try to produce plots with "nice layouts" by default, including by placing a joint legend "outside" and then resizing the figure to include it.

I think https://github.com/matplotlib/matplotlib/pull/13072 may be useful to overcome some of the described difficulties with the current legend placement of FacetGrid (in fact seaborn facet plots are mentioned as a use case in the linked issue).

[mwaskom]

Thanks for the pointer. Unfortunately I don't think matplotlib has any machinery to place the legend outside the subplot grid and expand the figure to fully match what seaborn wants to do. This is because I want to preserve the height/aspect parameterization of facetgrid figure sizes.

It's possible that it would give seaborn a different route: put the legend outside, let constrained layout shrink the subplot grid, then calculate how much it shrank by and resize the whole figure (similar to the current approach, maybe more robust).

[jklymak]

Right now CL doesn't shrink the axes yet if the axes have a fixed aspect. https://github.com/matplotlib/matplotlib/pull/17246 does this with a new kwarg, because its not super flexible.

[mwaskom]

@jklymak aspect in seaborn (in this context) means something a little bit different than in matplotlib. I want to fix the aspect ratio of the subplot in figure coordinates, not in data coordinates.

[jklymak]

Fair enough, but the same problem applies. The space between the subplots is, by default, spread out. I still think matplotlib/matplotlib#17246 could apply to your case - it just cares about the difference between the axes "original" position and the actual position.

[mwaskom]

It might apply in some cases, but what I'm trying to deal with is situations where the subplots get squashed inwards. e.g.:

f, axs = plt.subplots(1, 2, figsize=(6, 3), constrained_layout=True, sharey=True)
axs[0].set(yticks=[0, 1], yticklabels=["This is a really long tick label", "This one is too"])

[jklymak]

I see, so you want the equivalent of bbox_inches='tight' but at draw time instead of save time? i.e. 6, 3 is the "natural" size, but it will expand if that is too small?

[mwaskom]

Yep, that's the basic idea. The tricky part is going to be combining that with either constrained_layout or tight_layout to get nice automatic spacing on the interior of a subplot grid without changing the aspect ratio.

I guess, formally, I want the automatic transformations to translate the axes but not scale them.