| | .. redirect-from:: /tutorials/toolkits/axes_grid |
| |
|
| | .. _axes_grid1_users-guide-index: |
| | .. _axes_grid: |
| |
|
| | ====================== |
| | The axes_grid1 toolkit |
| | ====================== |
| |
|
| | :mod:`.axes_grid1` provides the following features: |
| |
|
| | - Helper classes (ImageGrid_, RGBAxes_, AxesDivider_) to ease the layout of |
| | axes displaying images with a fixed aspect ratio while satisfying additional |
| | constraints (matching the heights of a colorbar and an image, or fixing the |
| | padding between images); |
| | - ParasiteAxes_ (twinx/twiny-like features so that you can plot different data |
| | (e.g., different y-scale) in a same Axes); |
| | - AnchoredArtists_ (custom artists which are placed at an anchored position, |
| | similarly to legends). |
| |
|
| | .. figure:: /gallery/axes_grid1/images/sphx_glr_demo_axes_grid_001.png |
| | :target: /gallery/axes_grid1/demo_axes_grid.html |
| | :align: center |
| |
|
| | axes_grid1 |
| | ========== |
| |
|
| | ImageGrid |
| | --------- |
| |
|
| | In Matplotlib, axes location and size are usually specified in normalized |
| | figure coordinates (0 = bottom left, 1 = top right), which makes |
| | it difficult to achieve a fixed (absolute) padding between images. |
| | `~.axes_grid1.axes_grid.ImageGrid` can be used to achieve such a padding; see |
| | its docs for detailed API information. |
| |
|
| | .. figure:: /gallery/axes_grid1/images/sphx_glr_simple_axesgrid_001.png |
| | :target: /gallery/axes_grid1/simple_axesgrid.html |
| | :align: center |
| |
|
| | * The position of each axes is determined at the drawing time (see |
| | AxesDivider_), so that the size of the entire grid fits in the |
| | given rectangle (like the aspect of axes). Note that in this example, |
| | the paddings between axes are fixed even if you change the figure |
| | size. |
| |
|
| | * Axes in the same column share their x-axis, and axes in the same row share |
| | their y-axis (in the sense of `~.Axes.sharex`, `~.Axes.sharey`). |
| | Additionally, Axes in the same column all have the same width, and axes in |
| | the same row all have the same height. These widths and heights are scaled |
| | in proportion to the axes' view limits (xlim or ylim). |
| |
|
| | .. figure:: /gallery/axes_grid1/images/sphx_glr_simple_axesgrid2_001.png |
| | :target: /gallery/axes_grid1/simple_axesgrid2.html |
| | :align: center |
| |
|
| | The examples below show what you can do with ImageGrid. |
| |
|
| | .. figure:: /gallery/axes_grid1/images/sphx_glr_demo_axes_grid_001.png |
| | :target: /gallery/axes_grid1/demo_axes_grid.html |
| | :align: center |
| |
|
| | AxesDivider Class |
| | ----------------- |
| |
|
| | Behind the scenes, ImageGrid (and RGBAxes, described below) rely on |
| | `~.axes_grid1.axes_divider.AxesDivider`, whose role is to calculate the |
| | location of the axes at drawing time. |
| |
|
| | Users typically do not need to directly instantiate dividers |
| | by calling `~.axes_grid1.axes_divider.AxesDivider`; instead, |
| | `~.axes_grid1.axes_divider.make_axes_locatable` can be used to create a divider |
| | for an Axes:: |
| | |
| | ax = subplot(1, 1, 1) |
| | divider = make_axes_locatable(ax) |
| |
|
| | `.AxesDivider.append_axes` can then be used to create a new axes on a given |
| | side ("left", "right", "top", "bottom") of the original axes. |
| |
|
| | colorbar whose height (or width) is in sync with the main axes |
| | -------------------------------------------------------------- |
| |
|
| | .. figure:: /gallery/axes_grid1/images/sphx_glr_simple_colorbar_001.png |
| | :target: /gallery/axes_grid1/simple_colorbar.html |
| | :align: center |
| |
|
| | scatter_hist.py with AxesDivider |
| | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ |
| |
|
| | The :doc:`/gallery/lines_bars_and_markers/scatter_hist` example can be |
| | rewritten using `~.axes_grid1.axes_divider.make_axes_locatable`:: |
| |
|
| | axScatter = plt.subplot() |
| | axScatter.scatter(x, y) |
| | axScatter.set_aspect(1.) |
| |
|
| | # create new axes on the right and on the top of the current axes. |
| | divider = make_axes_locatable(axScatter) |
| | axHistx = divider.append_axes("top", size=1.2, pad=0.1, sharex=axScatter) |
| | axHisty = divider.append_axes("right", size=1.2, pad=0.1, sharey=axScatter) |
| |
|
| | # the scatter plot: |
| | # histograms |
| | bins = np.arange(-lim, lim + binwidth, binwidth) |
| | axHistx.hist(x, bins=bins) |
| | axHisty.hist(y, bins=bins, orientation='horizontal') |
| |
|
| | See the full source code below. |
| |
|
| | .. figure:: /gallery/axes_grid1/images/sphx_glr_scatter_hist_locatable_axes_001.png |
| | :target: /gallery/axes_grid1/scatter_hist_locatable_axes.html |
| | :align: center |
| |
|
| | The :doc:`/gallery/axes_grid1/scatter_hist_locatable_axes` using the |
| | AxesDivider has some advantages over the |
| | original :doc:`/gallery/lines_bars_and_markers/scatter_hist` in Matplotlib. |
| | For example, you can set the aspect ratio of the scatter plot, even with the |
| | x-axis or y-axis is shared accordingly. |
| |
|
| | ParasiteAxes |
| | ------------ |
| |
|
| | The ParasiteAxes is an Axes whose location is identical to its host |
| | axes. The location is adjusted in the drawing time, thus it works even |
| | if the host change its location (e.g., images). |
| |
|
| | In most cases, you first create a host axes, which provides a few |
| | methods that can be used to create parasite axes. They are ``twinx``, |
| | ``twiny`` (which are similar to ``twinx`` and ``twiny`` in the matplotlib) and |
| | ``twin``. ``twin`` takes an arbitrary transformation that maps between the |
| | data coordinates of the host axes and the parasite axes. The ``draw`` |
| | method of the parasite axes are never called. Instead, host axes |
| | collects artists in parasite axes and draws them as if they belong to |
| | the host axes, i.e., artists in parasite axes are merged to those of |
| | the host axes and then drawn according to their zorder. The host and |
| | parasite axes modifies some of the axes behavior. For example, color |
| | cycle for plot lines are shared between host and parasites. Also, the |
| | legend command in host, creates a legend that includes lines in the |
| | parasite axes. To create a host axes, you may use ``host_subplot`` or |
| | ``host_axes`` command. |
| |
|
| | Example 1: twinx |
| | ~~~~~~~~~~~~~~~~ |
| |
|
| | .. figure:: /gallery/axes_grid1/images/sphx_glr_parasite_simple_001.png |
| | :target: /gallery/axes_grid1/parasite_simple.html |
| | :align: center |
| |
|
| | Example 2: twin |
| | ~~~~~~~~~~~~~~~ |
| |
|
| | ``twin`` without a transform argument assumes that the parasite axes has the |
| | same data transform as the host. This can be useful when you want the |
| | top(or right)-axis to have different tick-locations, tick-labels, or |
| | tick-formatter for bottom(or left)-axis. :: |
| | |
| | ax2 = ax.twin() # now, ax2 is responsible for "top" axis and "right" axis |
| | ax2.set_xticks([0., .5*np.pi, np.pi, 1.5*np.pi, 2*np.pi], |
| | labels=["0", r"$\frac{1}{2}\pi$", |
| | r"$\pi$", r"$\frac{3}{2}\pi$", r"$2\pi$"]) |
| |
|
| | .. figure:: /gallery/axes_grid1/images/sphx_glr_simple_axisline4_001.png |
| | :target: /gallery/axes_grid1/simple_axisline4.html |
| | :align: center |
| |
|
| | A more sophisticated example using twin. Note that if you change the |
| | x-limit in the host axes, the x-limit of the parasite axes will change |
| | accordingly. |
| |
|
| | .. figure:: /gallery/axes_grid1/images/sphx_glr_parasite_simple2_001.png |
| | :target: /gallery/axes_grid1/parasite_simple2.html |
| | :align: center |
| |
|
| | AnchoredArtists |
| | --------------- |
| |
|
| | :mod:`.axes_grid1.anchored_artists` is a collection of artists whose location |
| | is anchored to the (axes) bbox, similarly to legends. These artists derive |
| | from `.offsetbox.OffsetBox`, and the artist need to be drawn in canvas |
| | coordinates. There is limited support for arbitrary transforms. For example, |
| | the ellipse in the example below will have width and height in data coordinates. |
| |
|
| | .. figure:: /gallery/axes_grid1/images/sphx_glr_simple_anchored_artists_001.png |
| | :target: /gallery/axes_grid1/simple_anchored_artists.html |
| | :align: center |
| |
|
| | InsetLocator |
| | ------------ |
| |
|
| | .. seealso:: |
| | `.Axes.inset_axes` and `.Axes.indicate_inset_zoom` in the main library. |
| |
|
| | :mod:`.axes_grid1.inset_locator` provides helper classes and functions to |
| | place inset axes at an anchored position of the parent axes, similarly to |
| | AnchoredArtist. |
| |
|
| | `.inset_locator.inset_axes` creates an inset axes whose size is either fixed, |
| | or a fixed proportion of the parent axes:: |
| | |
| | inset_axes = inset_axes(parent_axes, |
| | width="30%", # width = 30% of parent_bbox |
| | height=1., # height = 1 inch |
| | loc='lower left') |
| |
|
| | creates an inset axes whose width is 30% of the parent axes and whose |
| | height is fixed at 1 inch. |
| |
|
| | `.inset_locator.zoomed_inset_axes` creates an inset axes whose data scale is |
| | that of the parent axes multiplied by some factor, e.g. :: |
| | |
| | inset_axes = zoomed_inset_axes(ax, |
| | 0.5, # zoom = 0.5 |
| | loc='upper right') |
| |
|
| | creates an inset axes whose data scale is half of the parent axes. This can be |
| | useful to mark the zoomed area on the parent axes: |
| |
|
| | .. figure:: /gallery/axes_grid1/images/sphx_glr_inset_locator_demo_001.png |
| | :target: /gallery/axes_grid1/inset_locator_demo.html |
| | :align: center |
| |
|
| | `.inset_locator.mark_inset` allows marking the location of the area represented |
| | by the inset axes: |
| |
|
| | .. figure:: /gallery/axes_grid1/images/sphx_glr_inset_locator_demo2_001.png |
| | :target: /gallery/axes_grid1/inset_locator_demo2.html |
| | :align: center |
| |
|
| | RGBAxes |
| | ------- |
| |
|
| | RGBAxes is a helper class to conveniently show RGB composite |
| | images. Like ImageGrid, the location of axes are adjusted so that the |
| | area occupied by them fits in a given rectangle. Also, the xaxis and |
| | yaxis of each axes are shared. :: |
| | |
| | from mpl_toolkits.axes_grid1.axes_rgb import RGBAxes |
| |
|
| | fig = plt.figure() |
| | ax = RGBAxes(fig, [0.1, 0.1, 0.8, 0.8], pad=0.0) |
| | r, g, b = get_rgb() # r, g, b are 2D images. |
| | ax.imshow_rgb(r, g, b) |
| |
|
| | .. figure:: /gallery/axes_grid1/images/sphx_glr_demo_axes_rgb_001.png |
| | :target: /gallery/axes_grid1/demo_axes_rgb.html |
| | :align: center |
| |
|
| | AxesDivider |
| | =========== |
| |
|
| | The :mod:`mpl_toolkits.axes_grid1.axes_divider` module provides helper classes |
| | to adjust the axes positions of a set of images at drawing time. |
| |
|
| | * :mod:`~mpl_toolkits.axes_grid1.axes_size` provides a class of |
| | units that are used to determine the size of each axes. For example, |
| | you can specify a fixed size. |
| |
|
| | * `~mpl_toolkits.axes_grid1.axes_divider.Divider` is the class that |
| | calculates the axes position. It divides the given rectangular area into |
| | several areas. The divider is initialized by setting the lists of horizontal |
| | and vertical sizes on which the division will be based. Then use |
| | :meth:`~mpl_toolkits.axes_grid1.axes_divider.Divider.new_locator`, which |
| | returns a callable object that can be used to set the axes_locator of the |
| | axes. |
| |
|
| | Here, we demonstrate how to achieve the following layout: we want to position |
| | axes in a 3x4 grid (note that `.Divider` makes row indices start from the |
| | *bottom*\(!) of the grid): |
| |
|
| | .. code-block:: none |
| |
|
| | ┌────────┬────────┬────────┬────────┐ |
| | │ (2, 0) │ (2, 1) │ (2, 2) │ (2, 3) │ |
| | ├────────┼────────┼────────┼────────┤ |
| | │ (1, 0) │ (1, 1) │ (1, 2) │ (1, 3) │ |
| | ├────────┼────────┼────────┼────────┤ |
| | │ (0, 0) │ (0, 1) │ (0, 2) │ (0, 3) │ |
| | └────────┴────────┴────────┴────────┘ |
| |
|
| | such that the bottom row has a fixed height of 2 (inches) and the top two rows |
| | have a height ratio of 2 (middle) to 3 (top). (For example, if the grid has |
| | a size of 7 inches, the bottom row will be 2 inches, the middle row also 2 |
| | inches, and the top row 3 inches.) |
| |
|
| | These constraints are specified using classes from the |
| | :mod:`~mpl_toolkits.axes_grid1.axes_size` module, namely:: |
| |
|
| | from mpl_toolkits.axes_grid1.axes_size import Fixed, Scaled |
| | vert = [Fixed(2), Scaled(2), Scaled(3)] |
| |
|
| | (More generally, :mod:`~mpl_toolkits.axes_grid1.axes_size` classes define a |
| | ``get_size(renderer)`` method that returns a pair of floats -- a relative size, |
| | and an absolute size. ``Fixed(2).get_size(renderer)`` returns ``(0, 2)``; |
| | ``Scaled(2).get_size(renderer)`` returns ``(2, 0)``.) |
| | |
| | We use these constraints to initialize a `.Divider` object:: |
| | |
| | rect = [0.2, 0.2, 0.6, 0.6] # Position of the grid in the figure. |
| | vert = [Fixed(2), Scaled(2), Scaled(3)] # As above. |
| | horiz = [...] # Some other horizontal constraints. |
| | divider = Divider(fig, rect, horiz, vert) |
| |
|
| | then use `.Divider.new_locator` to create an axes locator callable for a |
| | given grid entry:: |
| | |
| | locator = divider.new_locator(nx=0, ny=1) # Grid entry (1, 0). |
| |
|
| | and make it responsible for locating the axes:: |
| | |
| | ax.set_axes_locator(locator) |
| |
|
| | The axes locator callable returns the location and size of |
| | the cell at the first column and the second row. |
| |
|
| | Locators that spans over multiple cells can be created with, e.g.:: |
| | |
| | # Columns #0 and #1 ("0-2 range"), row #1. |
| | locator = divider.new_locator(nx=0, nx1=2, ny=1) |
| |
|
| | See the example, |
| |
|
| | .. figure:: /gallery/axes_grid1/images/sphx_glr_simple_axes_divider1_001.png |
| | :target: /gallery/axes_grid1/simple_axes_divider1.html |
| | :align: center |
| |
|
| | You can also adjust the size of each axes according to its x or y |
| | data limits (AxesX and AxesY). |
| |
|
| | .. figure:: /gallery/axes_grid1/images/sphx_glr_simple_axes_divider3_001.png |
| | :target: /gallery/axes_grid1/simple_axes_divider3.html |
| | :align: center |
| |
|
