02_Figure.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Figure and Subplots"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%matplotlib inline\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We usually need a `Figure` with one or multiple `Axes` (subplots).\n",
    "\n",
    "There are convenience functions to create both with one call."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## One plot - ``plt.subplots()``"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.subplots();"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Returns a figure and an axes:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fig, ax = plt.subplots()\n",
    "fig.set_facecolor('blue')\n",
    "ax.set_facecolor('seagreen')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(type(fig))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(type(ax))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## A regular grid of plots - `plt.subplots(rows, columns)`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.subplots(1, 2);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Returns a `Figure` and a numpy array of `Axes`.\n",
    "\n",
    "By default, this is squeezed, i.e. if *rows* or *columns* is 1, you get a 1D array."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fig, axs = plt.subplots(1, 2)\n",
    "print(type(axs), axs.shape)\n",
    "axs[0].set_facecolor('lime')\n",
    "axs[1].set_facecolor('fuchsia')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The return value of `plt.subplots` is a (squeezed) numpy array."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fig, axs = plt.subplots(2, 2)\n",
    "print(type(axs), axs.shape)\n",
    "axs[0, 0].set_facecolor('0.2')\n",
    "axs[0, 1].set_facecolor('0.4')\n",
    "axs[1, 0].set_facecolor('0.6')\n",
    "axs[1, 1].set_facecolor('0.8')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "By default, size-1 dimensions of the axes array are squeezed out."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-info\">\n",
    "    <b>Tip:</b> Tuple unpacking\n",
    "</div>\n",
    "\n",
    "Tuple unpacking can be used to assign the returned axes to single variables. Common patterns:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fig, ax = plt.subplots()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fig, (ax1, ax2) = plt.subplots(1, 2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fig, ((ax11, ax12), (ax21, ax22)) = plt.subplots(2, 2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-info\">\n",
    "    <b>Tip:</b> Use axs.flat to iterate over all Axes.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fig, axs = plt.subplots(3, 3)\n",
    "for ax in axs.flat:\n",
    "    ax.set_facecolor('lightsalmon')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`plt.subplots(N, M)` suits your needs when all created axes are on a regular grid and should have the same size."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## An irregular grid of plots - `plt.subplot_mosaic(...)`\n",
    "\n",
    "Inspired by the [patchwork](https://patchwork.data-imaginist.com/) library in R:\n",
    "\n",
    "- Provide a regular grid of names\n",
    "- Cells with the same name are merged into one plot\n",
    "- Use  `None` for empty cells\n",
    "- Returns a dict, in which the individual `Axes` can be selected by name\n",
    "\n",
    "See the [subplot_mosaic() tutorial](https://matplotlib.org/stable/tutorials/provisional/mosaic.html) for more information."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.subplot_mosaic([\n",
    "    ['left', 'right-top'],\n",
    "    ['left', 'right-bottom'],\n",
    "]);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fig, axd = plt.subplot_mosaic([\n",
    "    ['left', 'right-top'],\n",
    "    ['left', 'right-bottom'],\n",
    "])\n",
    "axd['left'].plot([1, 3, 2])\n",
    "axd['right-top'].hist(np.random.normal(size=500))\n",
    "axd['right-bottom'].hist(np.random.poisson(3, size=500))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Tip: As a shortcut you can use a simple string\n",
    "\n",
    "- Lines -> rows\n",
    "- Letters -> subplot labels"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fig, axd = plt.subplot_mosaic(\"\"\"\n",
    "    AAABB\n",
    "    AAACC\n",
    "    DD.CC\n",
    "    \"\"\");"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "axd"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## More complex layouts\n",
    "\n",
    "The above are the most important methods, but there is more:\n",
    "\n",
    "![](images/figure_creation_methods.png)\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Figure size\n",
    "\n",
    "`figsize = (width, height)` determines the dimensions of the figure in inches."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fig, ax = plt.subplots()\n",
    "print('Default size:', fig.get_size_inches())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fig, ax = plt.subplots(figsize=(12, 4))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": []
   },
   "source": [
    "### Excusion: Exact figure size\n",
    "\n",
    "For pixel-based backends `figsize * dpi` is the actual size in pixels.\n",
    "\n",
    "Let's make the figure the pysically correct size on the screen."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "resolution = 1920, 1080  # pixels\n",
    "diagonal = 13.3  # inches\n",
    "\n",
    "import numpy as np\n",
    "rx, ry = resolution\n",
    "dpi = np.sqrt(rx**2 + ry**2) / diagonal\n",
    "print(dpi)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fig, ax = plt.subplots(dpi=dpi, facecolor='royalblue')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Still does not match for the inline backend. :(\n",
    "\n",
    "The inline backend is trying to be smart and cuts of unused space around the axes ('tight' layout). Let's deactivate that:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%config InlineBackend.print_figure_kwargs = {'bbox_inches': None}\n",
    "\n",
    "fig, ax = plt.subplots(dpi=dpi, facecolor='royalblue')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# reactivate the tight layouting\n",
    "%config InlineBackend.print_figure_kwargs = {'bbox_inches': 'tight'}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### General recommendation on figure size:\n",
    "\n",
    "<div class=\"alert alert-info\">\n",
    "    <b>Tip:</b> Use dpi=100, do not bother with actual figure size.\n",
    "</div>\n",
    "\n",
    "Usually it's not worth adjusting the `dpi` to get a physically correct size on the screen, because different screens have different `dpi` and you don't want your plot to be screen depended.\n",
    "\n",
    "When working with pixel based output (i.e. not svg or pdf), use a fixed `dpi=100` and scale `figsize` as needed. Rule:\n",
    "\n",
    "   `figsize * dpi = pixels` i.e. `figsize = (6, 4) --> 600x400 pixels`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*Note*: The default is `dpi=100` in matplotlib (since version 2.0). The inline backend still overrides this default with `dpi=72` so that figures in the notebook are smaller by default."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### `figsize` and fonts\n",
    "\n",
    "Font sizes are in points. They are not affected by `figsize`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fig, ax = plt.subplots(figsize=(8, 4))\n",
    "fig.text(0.2, 0.5, 'figsize=(8, 4)', fontsize=20)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fig, ax = plt.subplots(figsize=(4, 2))\n",
    "fig.text(0.2, 0.5, 'figsize=(8, 4)', fontsize=20)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Layouting: Constrained Layout\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = np.linspace(0, 2, 201)\n",
    "fig, (ax1, ax2) = plt.subplots(1, 2)\n",
    "ax1.plot(x, x)\n",
    "ax2.plot(x, 1000*x**2)\n",
    "ax1.set_title('Function: x')\n",
    "ax2.set_title('Function: $x^2$')\n",
    "ax1.set_ylabel('The y label')\n",
    "ax2.set_ylabel('The y label')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Layouting a figure is hard: Need to size and position elements such that they don't overlap.\n",
    "\n",
    "Matplotlib used to have a simple layouter (`plt.tight_layout()` or `fig.tight_layout()`).\n",
    "\n",
    "### New since Matplotlib 3.0: Constrained Layout"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fig, (ax1, ax2) = plt.subplots(1, 2, layout='constrained')\n",
    "ax1.plot(x, x)\n",
    "ax2.plot(x, 1000*x**2)\n",
    "ax1.set_title('Function: x')\n",
    "ax2.set_title('Function: $x^2$')\n",
    "ax1.set_ylabel('The y label')\n",
    "ax2.set_ylabel('The y label')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.11.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}