Merge pull request #20144 from anntzer/tl

jklymak · web-flow · commit b33711b76e8c · 2021-05-10T14:56:47.000-07:00
More tight_layout cleanups
diff --git a/lib/matplotlib/tight_layout.py b/lib/matplotlib/tight_layout.py
@@ -23,10 +23,9 @@ def _auto_adjust_subplotpars(
     Return a dict of subplot parameters to adjust spacing between subplots
     or ``None`` if resulting axes would have zero height or width.
 
-    Note that this function ignores geometry information of subplot
-    itself, but uses what is given by the *nrows_ncols* and *num1num2_list*
-    parameters.  Also, the results could be incorrect if some subplots have
-    ``adjustable=datalim``.
+    Note that this function ignores geometry information of subplot itself, but
+    uses what is given by the *shape* and *subplot_list* parameters.  Also, the
+    results could be incorrect if some subplots have ``adjustable=datalim``.
 
     Parameters
     ----------
@@ -47,11 +46,11 @@ def _auto_adjust_subplotpars(
     """
     rows, cols = shape
 
-    font_size_inches = (
+    font_size_inch = (
         FontProperties(size=rcParams["font.size"]).get_size_in_points() / 72)
-    pad_inches = pad * font_size_inches
-    vpad_inches = h_pad * font_size_inches if h_pad is not None else pad_inches
-    hpad_inches = w_pad * font_size_inches if w_pad is not None else pad_inches
+    pad_inch = pad * font_size_inch
+    vpad_inch = h_pad * font_size_inch if h_pad is not None else pad_inch
+    hpad_inch = w_pad * font_size_inch if w_pad is not None else pad_inch
 
     if len(span_pairs) != len(subplot_list) or len(subplot_list) == 0:
         raise ValueError
@@ -98,42 +97,37 @@ def _auto_adjust_subplotpars(
     # margins can be negative for axes with aspect applied, so use max(, 0) to
     # make them nonnegative.
     if not margin_left:
-        margin_left = (max(hspaces[:, 0].max(), 0)
-                       + pad_inches / fig_width_inch)
+        margin_left = max(hspaces[:, 0].max(), 0) + pad_inch/fig_width_inch
         suplabel = fig._supylabel
         if suplabel and suplabel.get_in_layout():
             rel_width = fig.transFigure.inverted().transform_bbox(
                 suplabel.get_window_extent(renderer)).width
-            margin_left += rel_width + pad_inches / fig_width_inch
-
+            margin_left += rel_width + pad_inch/fig_width_inch
     if not margin_right:
-        margin_right = (max(hspaces[:, -1].max(), 0)
-                        + pad_inches / fig_width_inch)
+        margin_right = max(hspaces[:, -1].max(), 0) + pad_inch/fig_width_inch
     if not margin_top:
-        margin_top = (max(vspaces[0, :].max(), 0)
-                      + pad_inches / fig_height_inch)
+        margin_top = max(vspaces[0, :].max(), 0) + pad_inch/fig_height_inch
         if fig._suptitle and fig._suptitle.get_in_layout():
             rel_height = fig.transFigure.inverted().transform_bbox(
                 fig._suptitle.get_window_extent(renderer)).height
-            margin_top += rel_height + pad_inches / fig_height_inch
+            margin_top += rel_height + pad_inch/fig_height_inch
     if not margin_bottom:
-        margin_bottom = (max(vspaces[-1, :].max(), 0)
-                         + pad_inches / fig_height_inch)
+        margin_bottom = max(vspaces[-1, :].max(), 0) + pad_inch/fig_height_inch
         suplabel = fig._supxlabel
         if suplabel and suplabel.get_in_layout():
             rel_height = fig.transFigure.inverted().transform_bbox(
                 suplabel.get_window_extent(renderer)).height
-            margin_bottom += rel_height + pad_inches / fig_height_inch
+            margin_bottom += rel_height + pad_inch/fig_height_inch
 
     if margin_left + margin_right >= 1:
         _api.warn_external('Tight layout not applied. The left and right '
                            'margins cannot be made large enough to '
-                           'accommodate all axes decorations. ')
+                           'accommodate all axes decorations.')
         return None
     if margin_bottom + margin_top >= 1:
         _api.warn_external('Tight layout not applied. The bottom and top '
                            'margins cannot be made large enough to '
-                           'accommodate all axes decorations. ')
+                           'accommodate all axes decorations.')
         return None
 
     kwargs = dict(left=margin_left,
@@ -142,7 +136,7 @@ def _auto_adjust_subplotpars(
                   top=1 - margin_top)
 
     if cols > 1:
-        hspace = hspaces[:, 1:-1].max() + hpad_inches / fig_width_inch
+        hspace = hspaces[:, 1:-1].max() + hpad_inch / fig_width_inch
         # axes widths:
         h_axes = (1 - margin_right - margin_left - hspace * (cols - 1)) / cols
         if h_axes < 0:
@@ -153,12 +147,12 @@ def _auto_adjust_subplotpars(
         else:
             kwargs["wspace"] = hspace / h_axes
     if rows > 1:
-        vspace = vspaces[1:-1, :].max() + vpad_inches / fig_height_inch
+        vspace = vspaces[1:-1, :].max() + vpad_inch / fig_height_inch
         v_axes = (1 - margin_top - margin_bottom - vspace * (rows - 1)) / rows
         if v_axes < 0:
             _api.warn_external('Tight layout not applied. tight_layout '
                                'cannot make axes height small enough to '
-                               'accommodate all axes decorations')
+                               'accommodate all axes decorations.')
             return None
         else:
             kwargs["hspace"] = vspace / v_axes
@@ -283,41 +277,28 @@ def get_tight_layout_figure(fig, axes_list, subplotspec_list, renderer,
         None if tight_layout could not be accomplished.
     """
 
-    subplot_list = []
-    nrows_list = []
-    ncols_list = []
-    ax_bbox_list = []
-
-    # Multiple axes can share same subplot_interface (e.g., axes_grid1); thus
-    # we need to join them together.
-    subplot_dict = {}
-
-    subplotspec_list2 = []
-
-    for ax, subplotspec in zip(axes_list, subplotspec_list):
-        if subplotspec is None:
-            continue
-
-        subplots = subplot_dict.setdefault(subplotspec, [])
-
-        if not subplots:
-            myrows, mycols, _, _ = subplotspec.get_geometry()
-            nrows_list.append(myrows)
-            ncols_list.append(mycols)
-            subplotspec_list2.append(subplotspec)
-            subplot_list.append(subplots)
-            ax_bbox_list.append(subplotspec.get_position(fig))
-
-        subplots.append(ax)
-
-    if len(nrows_list) == 0 or len(ncols_list) == 0:
+    # Multiple axes can share same subplotspec (e.g., if using axes_grid1);
+    # we need to group them together.
+    ss_to_subplots = {ss: [] for ss in subplotspec_list}
+    for ax, ss in zip(axes_list, subplotspec_list):
+        ss_to_subplots[ss].append(ax)
+    ss_to_subplots.pop(None, None)  # Skip subplotspec == None.
+    if not ss_to_subplots:
         return {}
+    subplot_list = list(ss_to_subplots.values())
+    ax_bbox_list = [ss.get_position(fig) for ss in ss_to_subplots]
 
-    max_nrows = max(nrows_list)
-    max_ncols = max(ncols_list)
+    max_nrows = max(ss.get_gridspec().nrows for ss in ss_to_subplots)
+    max_ncols = max(ss.get_gridspec().ncols for ss in ss_to_subplots)
 
     span_pairs = []
-    for ss in subplotspec_list2:
+    for ss in ss_to_subplots:
+        # The intent here is to support axes from different gridspecs where
+        # one's nrows (or ncols) is a multiple of the other (e.g. 2 and 4),
+        # but this doesn't actually work because the computed wspace, in
+        # relative-axes-height, corresponds to different physical spacings for
+        # the 2-row grid and the 4-row grid.  Still, this code is left, mostly
+        # for backcompat.
         rows, cols = ss.get_gridspec().get_geometry()
         div_row, mod_row = divmod(max_nrows, rows)
         div_col, mod_col = divmod(max_ncols, cols)
@@ -331,7 +312,6 @@ def get_tight_layout_figure(fig, axes_list, subplotspec_list, renderer,
                                'columns in subplot specifications must be '
                                'multiples of one another.')
             return {}
-
         span_pairs.append((
             slice(ss.rowspan.start * div_row, ss.rowspan.stop * div_row),
             slice(ss.colspan.start * div_col, ss.colspan.stop * div_col)))
