.. _figure_explanation:

Creating, viewing, and saving Matplotlib Figures

..plot::

fig = plt.figure(figsize=(2, 2), facecolor='0.8', layout='constrained')

ax = fig.add_subplot()

When looking at Matplotlib visualization, you are almost always looking at

Artists placed on a `~.Figure`. In the example above, the figure is the

gray region and `~.Figure.add_subplot` has added an `~.axes.Axes` artist to the

`~.Figure` (see:ref:`figure_parts`). A more complicated visualization can add multiple Axes to

the Figure, colorbars, legends, annotations, and the Axes theselves can have

multiple Artists added to them (e.g. ``ax.plot`` or ``ax.imshow``).

.. _viewing_figures:

Viewing Figures

We will discuss how to create Figures in more detail below, but first it is

helpful to understand how to view a Figure. This varies based on how you are

using Matplotlib, and what:ref:`Backend<what-is-a-backend>` you are using.

Notebooks and IDEs

If you are using a Notebook (e.g. `Jupyter<https://jupyter.org>`_) or an IDE

that renders Notebooks (PyCharm, VSCode, etc), then they have a backend that

will render the Matplotlib Figure when a code cell is executed. One thing to

be aware of is that the default Jupyter backend (``%matplotlib inline``) will

by default trim or expand the figure size to have a tight box around Artists

added to the Figure (see:ref:`saving_figures`, below).

Standalone scripts and interctive use

If the user is on a client with a windowing system, there are a number of

:ref:`Backends<what-is-a-backend>` that can be used to render the Figure to

the screen, usually using a Python Qt, Tk, or Wx toolkit, though there is a native

MacOS backend as well. These are typically chosen either in the user's

:ref:`matplotlibrc<customizing-with-matplotlibrc-files>`, or by calling

``matplotlib.use('QtAgg')`` at the beginning of a session or script.

When run from a script, or interactively (e.g. from an

`iPython shell<https://https://ipython.readthedocs.io/en/stable/>`_) the Figure

will not be shown until we call ``plt.show()``. The Figure will appear in

a new GUI window, and usually will have a toolbar with Zoom, Pan, and other tools

for interacting with the Figure. By default, ``plt.show()`` blocks

further interaction from the script or shell until the Figure window is closed,

though that can be toggled off for some pusposes. For more details, please see

:ref:`controlling-interactive`.

Note that if you are on a client that does not have access to a windowing

system, the Figure will fallback to being drawn using the "Agg" backend, and

cannot be viewed, though it can be:ref:`saved<saving_figures>`.

.. _creating_figures:

Creating Figures

By far the most common way to create a figure is using the

:doc:`pyplot</tutorials/introductory/pyplot>` interface. As noted in

:ref:`api_interfaces`, the pyplot interface serves two purposes. One is to spin

up the Backend and keep track of GUI windows. The other is a global state for

Axes and Artists that allow a short-form API to plotting methods. In the

example above, we only use pyplot for the first purpose, to create the Figure

object, ``fig``.

In addition to `~.pyplot.figure`, there are convenience methods to create Axes

at the same time that the figure is created since these two actions are so commonly

done at the same time. A simple grid can be achieved with `~.pyplot.subplots` (which

simply wraps `~.Figure.subplots`):

..plot::

fig, axs = plt.subplots(2, 2, figsize=(4, 3), layout='constrained')

More complex grids can be achieved with `~.pyplot.subplot_mosaic` (which wraps

`~.Figure.subplot_mosaic`):

..plot::

fig, axs = plt.subplot_mosaic([['A', 'right'], ['B', 'right']],

figsize=(4, 3), layout='constrained')

for ax_name in axs:

axs[ax_name].text(0.5, 0.5, ax_name, ha='center', va='center')

Sometimes we want to have a nested layout in a Figure, with two or more sets of

Axes that do not necessarily share the same subplot grid.

We can use `~.Figure.add_subfigure` or `~.Figure.subfigures` to create virtual

figures inside a parent Figure; see

:doc:`/gallery/subplots_axes_and_figures/subfigures` for more details.

..plot::

fig = plt.figure(layout='constrained', facecolor='beige')

fig.suptitle('Figure')

figL, figR = fig.subfigures(1, 2)

figL.set_facecolor('0.9')

axL = figL.subplots(2, 1, sharex=True)

figL.suptitle('Left subfigure')

figR.set_facecolor('0.7')

axR = figR.subplots(1, 2, sharey=True)

figR.suptitle('Right subfigure')

It is possible to directly instantiate a `.Figure` instance without using the

pyplot interface. This is usually only necessary if you want to create your

own GUI application or service that you do not want carrying the pyplot global

state. See the embedding examples in:doc:`/gallery/user_interfaces/index` for

examples of how to do this.

Figure options

There are a few options available when creating figures. The Figure size on

the screen is set by *figsize* and *dpi*. *figsize* is the ``(width, height)``

of the Figure in inches (or, if preferred, units of 72 typographic points). *dpi*

are how many pixels per inch the figure will be rendered at. To make your Figures

appear on the screen at the physical size you requested, you should set *dpi*

to the same *dpi* as your graphics system. Note that many graphics systems now use

a "dpi ratio" to specify how many screen pixels are used to represent a graphics

pixel. Matplotlib applies the dpi ratio to the *dpi* passed to the figure to make

it have higher resolution, so you should pass the lower number to the figure.

The *facecolor*, *edgecolor*, *linewidth*, and *frameon* options all change the appearance of the

figure in expected ways, with *frameon* making the figure transparent if set to *False*.

Finally, the user can specify a layout engine for the figure with the *layout*

parameter. Currently Matplotlib supplies

:doc:`"constrained"</tutorials/intermediate/constrainedlayout_guide>`,

:ref:`"compressed"<compressed_layout>` and

:doc:`"tight"</tutorials/intermediate/tight_layout_guide>` layout engines. These

rescale axes inside the Figure to prevent overlap of ticklabels, and try and align

axes, and can save significant manual adjustment of artists on a Figure for many

common cases.

.. _saving_figures:

Saving Figures

Finally, Figures can be saved to disk using the `~.Figure.savefig` method.

``fig.savefig('MyFigure.png', dpi=200)`` will save a PNG formatted figure to

the file ``MyFigure.png`` in the current directory on disk with 200 dots-per-inch

resolution. Note that the filename can include a relative or absolute path to

any place on the file system.

Many types of output are supported, including raster formats like PNG, GIF, JPEG,

TIFF and vector formats like PDF, EPS, and SVG.

By default, the size of the saved Figure is set by the Figure size (in inches) and, for the raster

formats, the *dpi*. If *dpi* is not set, then the *dpi* of the Figure is used.

Note that *dpi* still has meaning for vector formats like PDF if the Figure includes

Artists that have been:doc:`rasterized</gallery/misc/rasterization_demo>`; the

*dpi* specified will be the resolution of the rasterized objects.

It is possible to change the size of the Figure using the *bbox_inches* argument

to savefig. This can be specified manually, again in inches. However, by far

the most common use is ``bbox_inches='tight'``. This option trims, or expands, the

size of the figure so that it is tight around all the artists in a figure, with a

small pad that can be specified by *pad_inches*, which defaults to 0.1 inches.

The dashed box in the plot below shows the portion of the figure that would be

saved if ``bbox_inches='tight'`` were used in savefig.

..plot::

import matplotlib.pyplot as plt

from matplotlib.patches import FancyBboxPatch

fig, ax = plt.subplots(figsize=(4, 2), facecolor='0.8')

ax.set_position([0.1, 0.2, 0.8, 0.7])

ax.set_aspect(1)

bb = ax.get_tightbbox()

bb = bb.padded(10)

fancy = FancyBboxPatch(bb.p0, bb.width, bb.height, fc='none',

ec=(0, 0.0, 0, 0.5), lw=2, linestyle='--',

transform=None, clip_on=False)

ax.add_patch(fancy)