def tight_layout(self, renderer=None, pad=1.08, h_pad=None, w_pad=None, rect=None): """ Adjust subplot parameters to give specified padding. Parameters: *pad* : float padding between the figure edge and the edges of subplots, as a fraction of the font-size. *h_pad*, *w_pad* : float padding (height/width) between edges of adjacent subplots. Defaults to `pad_inches`. *rect* : if rect is given, it is interpreted as a rectangle (left, bottom, right, top) in the normalized figure coordinate that the whole subplots area (including labels) will fit into. Default is (0, 0, 1, 1). """ from tight_layout import get_renderer, get_tight_layout_figure if renderer is None: renderer = get_renderer(self) kwargs = get_tight_layout_figure(self, self.axes, renderer, pad=pad, h_pad=h_pad, w_pad=w_pad, rect=rect) self.subplots_adjust(**kwargs)
def tight_layout(self, renderer=None, pad=1.08, h_pad=None, w_pad=None, rect=None): """ Adjust subplot parameters to give specified padding. Parameters: *pad* : float padding between the figure edge and the edges of subplots, as a fraction of the font-size. *h_pad*, *w_pad* : float padding (height/width) between edges of adjacent subplots. Defaults to `pad_inches`. *rect* : if rect is given, it is interpreted as a rectangle (left, bottom, right, top) in the normalized figure coordinate that the whole subplots area (including labels) will fit into. Default is (0, 0, 1, 1). """ from tight_layout import get_renderer, get_tight_layout_figure subplot_axes = [ax for ax in self.axes if isinstance(ax, SubplotBase)] if len(subplot_axes) < len(self.axes): warnings.warn("tight_layout can only process Axes that descend " "from SubplotBase; results might be incorrect.") if renderer is None: renderer = get_renderer(self) kwargs = get_tight_layout_figure(self, subplot_axes, renderer, pad=pad, h_pad=h_pad, w_pad=w_pad, rect=rect) self.subplots_adjust(**kwargs)
def tight_layout(self, fig, renderer=None, pad=1.08, h_pad=None, w_pad=None, rect=None): """ Adjust subplot parameters to give specified padding. Parameters: pad : float padding between the figure edge and the edges of subplots, as a fraction of the font-size. h_pad, w_pad : float padding (height/width) between edges of adjacent subplots. Defaults to `pad_inches`. rect : if rect is given, it is interpreted as a rectangle (left, bottom, right, top) in the normalized figure coordinate that the whole subplots area (including labels) will fit into. Default is (0, 0, 1, 1). """ from tight_layout import (get_subplotspec_list, get_tight_layout_figure, get_renderer) subplotspec_list = get_subplotspec_list(fig.axes, grid_spec=self) if None in subplotspec_list: warnings.warn("This figure includes Axes that are not " "compatible with tight_layout, so its " "results might be incorrect.") if renderer is None: renderer = get_renderer(fig) kwargs = get_tight_layout_figure( fig, fig.axes, subplotspec_list, renderer, pad=pad, h_pad=h_pad, w_pad=w_pad, rect=rect, ) self.update(**kwargs)
def tight_layout(self, fig, renderer=None, pad=1.08, h_pad=None, w_pad=None, rect=None): """ Adjust subplot parameters to give specified padding. Parameters: pad : float padding between the figure edge and the edges of subplots, as a fraction of the font-size. h_pad, w_pad : float padding (height/width) between edges of adjacent subplots. Defaults to `pad_inches`. rect : if rect is given, it is interpreted as a rectangle (left, bottom, right, top) in the normalized figure coordinate that the whole subplots area (including labels) will fit into. Default is (0, 0, 1, 1). """ from tight_layout import (get_subplotspec_list, get_tight_layout_figure, get_renderer) subplotspec_list = get_subplotspec_list(fig.axes, grid_spec=self) if None in subplotspec_list: warnings.warn("This figure includes Axes that are not " "compatible with tight_layout, so its " "results might be incorrect.") if renderer is None: renderer = get_renderer(fig) kwargs = get_tight_layout_figure(fig, fig.axes, subplotspec_list, renderer, pad=pad, h_pad=h_pad, w_pad=w_pad, rect=rect, ) self.update(**kwargs)
def tight_layout(self, renderer=None, pad=1.2, h_pad=None, w_pad=None): """Adjust subplot parameters to give specified padding. Parameters ---------- pad : float padding between the figure edge and the edges of subplots, as a fraction of the font-size. h_pad, w_pad : float padding (height/width) between edges of adjacent subplots. Defaults to `pad_inches`. """ from tight_layout import auto_adjust_subplotpars, get_renderer if renderer is None: renderer = get_renderer(self) subplotspec_list = [] subplot_list = [] nrows_list = [] ncols_list = [] ax_bbox_list = [] subplot_dict = {} # for axes_grid1, multiple axes can share # same subplot_interface. Thus we need to # join them together. for ax in self.axes: locator = ax.get_axes_locator() if hasattr(locator, "get_subplotspec"): subplotspec = locator.get_subplotspec( ).get_topmost_subplotspec() elif hasattr(ax, "get_subplotspec"): subplotspec = ax.get_subplotspec().get_topmost_subplotspec() else: continue if (subplotspec is None) or \ subplotspec.get_gridspec().locally_modified_subplot_params(): continue subplots = subplot_dict.setdefault(subplotspec, []) if not subplots: myrows, mycols, _, _ = subplotspec.get_geometry() nrows_list.append(myrows) ncols_list.append(mycols) subplotspec_list.append(subplotspec) subplot_list.append(subplots) ax_bbox_list.append(subplotspec.get_position(self)) subplots.append(ax) max_nrows = max(nrows_list) max_ncols = max(ncols_list) num1num2_list = [] for subplotspec in subplotspec_list: rows, cols, num1, num2 = subplotspec.get_geometry() div_row, mod_row = divmod(max_nrows, rows) div_col, mod_col = divmod(max_ncols, cols) if (mod_row != 0) or (mod_col != 0): raise RuntimeError("") rowNum1, colNum1 = divmod(num1, cols) if num2 is None: rowNum2, colNum2 = rowNum1, colNum1 else: rowNum2, colNum2 = divmod(num2, cols) num1num2_list.append( (rowNum1 * div_row * max_ncols + colNum1 * div_col, ((rowNum2 + 1) * div_row - 1) * max_ncols + (colNum2 + 1) * div_col - 1)) kwargs = auto_adjust_subplotpars(self, renderer, nrows_ncols=(max_nrows, max_ncols), num1num2_list=num1num2_list, subplot_list=subplot_list, ax_bbox_list=ax_bbox_list, pad=pad, h_pad=h_pad, w_pad=w_pad) self.subplots_adjust(**kwargs)
def tight_layout(self, renderer=None, pad=1.2, h_pad=None, w_pad=None): """ Adjust subplot parameters to give specified padding. Parameters: pad : float padding between the figure edge and the edges of subplots, as a fraction of the font-size. h_pad, w_pad : float padding (height/width) between edges of adjacent subplots. Defaults to `pad_inches`. """ from tight_layout import auto_adjust_subplotpars, get_renderer if renderer is None: renderer = get_renderer(self) subplotspec_list = [] subplot_list = [] nrows_list = [] ncols_list = [] ax_bbox_list = [] subplot_dict = {} # for axes_grid1, multiple axes can share # same subplot_interface. Thus we need to # join them together. for ax in self.axes: locator = ax.get_axes_locator() if hasattr(locator, "get_subplotspec"): subplotspec = locator.get_subplotspec().get_topmost_subplotspec() elif hasattr(ax, "get_subplotspec"): subplotspec = ax.get_subplotspec().get_topmost_subplotspec() else: continue if (subplotspec is None) or \ subplotspec.get_gridspec().locally_modified_subplot_params(): continue subplots = subplot_dict.setdefault(subplotspec, []) if not subplots: myrows, mycols, _, _ = subplotspec.get_geometry() nrows_list.append(myrows) ncols_list.append(mycols) subplotspec_list.append(subplotspec) subplot_list.append(subplots) ax_bbox_list.append(subplotspec.get_position(self)) subplots.append(ax) max_nrows = max(nrows_list) max_ncols = max(ncols_list) num1num2_list = [] for subplotspec in subplotspec_list: rows, cols, num1, num2 = subplotspec.get_geometry() div_row, mod_row = divmod(max_nrows, rows) div_col, mod_col = divmod(max_ncols, cols) if (mod_row != 0) or (mod_col != 0): raise RuntimeError("") rowNum1, colNum1 = divmod(num1, cols) if num2 is None: rowNum2, colNum2 = rowNum1, colNum1 else: rowNum2, colNum2 = divmod(num2, cols) num1num2_list.append((rowNum1*div_row*max_ncols + colNum1*div_col, ((rowNum2+1)*div_row-1)*max_ncols + (colNum2+1)*div_col-1)) kwargs = auto_adjust_subplotpars(self, renderer, nrows_ncols=(max_nrows, max_ncols), num1num2_list=num1num2_list, subplot_list=subplot_list, ax_bbox_list=ax_bbox_list, pad=pad, h_pad=h_pad, w_pad=w_pad) self.subplots_adjust(**kwargs)
def tight_layout(self, fig, renderer=None, pad=1.2, h_pad=None, w_pad=None, rect=None): """ Adjust subplot parameters to give specified padding. Parameters: pad : float padding between the figure edge and the edges of subplots, as a fraction of the font-size. h_pad, w_pad : float padding (height/width) between edges of adjacent subplots. Defaults to `pad_inches`. """ from tight_layout import auto_adjust_subplotpars, get_renderer if renderer is None: renderer = get_renderer(fig) subplot_list = [] num1num2_list = [] subplot_dict = {} for ax in fig.axes: locator = ax.get_axes_locator() if hasattr(locator, "get_subplotspec"): subplotspec = locator.get_subplotspec() elif hasattr(ax, "get_subplotspec"): subplotspec = ax.get_subplotspec() else: continue if subplotspec.get_gridspec() != self: continue subplots = subplot_dict.get(subplotspec, []) if not subplots: _, _, num1, num2 = subplotspec.get_geometry() num1num2_list.append((num1, num2)) subplot_list.append(subplots) subplots.append(ax) kwargs = auto_adjust_subplotpars(fig, renderer, nrows_ncols=self.get_geometry(), num1num2_list=num1num2_list, subplot_list=subplot_list, pad=pad, h_pad=h_pad, w_pad=w_pad) if rect is not None: # if rect is given, the whole subplots area (including # labels) will fit into the rect instead of the # figure. Note that the rect argument of # *auto_adjust_subplotpars* specify the area that will be # covered by the total area of axes.bbox. Thus we call # auto_adjust_subplotpars twice, where the second run # with adjusted rect parameters. left, bottom, right, top = rect if left is not None: left += kwargs["left"] if bottom is not None: bottom += kwargs["bottom"] if right is not None: right -= (1 - kwargs["right"]) if top is not None: top -= (1 - kwargs["top"]) #if h_pad is None: h_pad = pad #if w_pad is None: w_pad = pad kwargs = auto_adjust_subplotpars(fig, renderer, nrows_ncols=self.get_geometry(), num1num2_list=num1num2_list, subplot_list=subplot_list, pad=pad, h_pad=h_pad, w_pad=w_pad, rect=(left, bottom, right, top)) self.update(**kwargs)
def tight_layout(self, fig, renderer=None, pad=1.2, h_pad=None, w_pad=None, rect=None): """Adjust subplot parameters to give specified padding. Parameters ---------- pad : float padding between the figure edge and the edges of subplots, as a fraction of the font-size. h_pad, w_pad : float padding (height/width) between edges of adjacent subplots. Defaults to `pad_inches`. """ from tight_layout import auto_adjust_subplotpars, get_renderer if renderer is None: renderer = get_renderer(fig) subplot_list = [] num1num2_list = [] subplot_dict = {} for ax in fig.axes: locator = ax.get_axes_locator() if hasattr(locator, "get_subplotspec"): subplotspec = locator.get_subplotspec() elif hasattr(ax, "get_subplotspec"): subplotspec = ax.get_subplotspec() else: continue if subplotspec.get_gridspec() != self: continue subplots = subplot_dict.get(subplotspec, []) if not subplots: _, _, num1, num2 = subplotspec.get_geometry() num1num2_list.append((num1, num2)) subplot_list.append(subplots) subplots.append(ax) kwargs = auto_adjust_subplotpars(fig, renderer, nrows_ncols=self.get_geometry(), num1num2_list=num1num2_list, subplot_list=subplot_list, pad=pad, h_pad=h_pad, w_pad=w_pad) if rect is not None: # if rect is given, the whole subplots area (including # labels) will fit into the rect instead of the # figure. Note that the rect argument of # *auto_adjust_subplotpars* specify the area that will be # covered by the total area of axes.bbox. Thus we call # auto_adjust_subplotpars twice, where the second run # with adjusted rect parameters. left, bottom, right, top = rect if left is not None: left += kwargs["left"] if bottom is not None: bottom += kwargs["bottom"] if right is not None: right -= (1 - kwargs["right"]) if top is not None: top -= (1 - kwargs["top"]) #if h_pad is None: h_pad = pad #if w_pad is None: w_pad = pad kwargs = auto_adjust_subplotpars(fig, renderer, nrows_ncols=self.get_geometry(), num1num2_list=num1num2_list, subplot_list=subplot_list, pad=pad, h_pad=h_pad, w_pad=w_pad, rect=(left, bottom, right, top)) self.update(**kwargs)