| ************************ | |
| ``matplotlib.animation`` | |
| ************************ | |
| .. automodule:: matplotlib.animation | |
| :no-members: | |
| :no-undoc-members: | |
| .. contents:: Table of Contents | |
| :depth: 1 | |
| :local: | |
| :backlinks: entry | |
| Animation | |
| ========= | |
| The easiest way to make a live animation in Matplotlib is to use one of the | |
| `Animation` classes. | |
| .. inheritance-diagram:: matplotlib.animation.FuncAnimation matplotlib.animation.ArtistAnimation | |
| :parts: 1 | |
| .. autosummary:: | |
| :toctree: _as_gen | |
| :nosignatures: | |
| Animation | |
| FuncAnimation | |
| ArtistAnimation | |
| In both cases it is critical to keep a reference to the instance | |
| object. The animation is advanced by a timer (typically from the host | |
| GUI framework) which the `Animation` object holds the only reference | |
| to. If you do not hold a reference to the `Animation` object, it (and | |
| hence the timers) will be garbage collected which will stop the | |
| animation. | |
| To save an animation use `Animation.save`, `Animation.to_html5_video`, | |
| or `Animation.to_jshtml`. | |
| See :ref:`ani_writer_classes` below for details about what movie formats are | |
| supported. | |
| .. _func-animation: | |
| ``FuncAnimation`` | |
| ----------------- | |
| The inner workings of `FuncAnimation` is more-or-less:: | |
| for d in frames: | |
| artists = func(d, *fargs) | |
| fig.canvas.draw_idle() | |
| fig.canvas.start_event_loop(interval) | |
| with details to handle 'blitting' (to dramatically improve the live | |
| performance), to be non-blocking, not repeatedly start/stop the GUI | |
| event loop, handle repeats, multiple animated axes, and easily save | |
| the animation to a movie file. | |
| 'Blitting' is a `standard technique | |
| <https://en.wikipedia.org/wiki/Bit_blit>`__ in computer graphics. The | |
| general gist is to take an existing bit map (in our case a mostly | |
| rasterized figure) and then 'blit' one more artist on top. Thus, by | |
| managing a saved 'clean' bitmap, we can only re-draw the few artists | |
| that are changing at each frame and possibly save significant amounts of | |
| time. When we use blitting (by passing ``blit=True``), the core loop of | |
| `FuncAnimation` gets a bit more complicated:: | |
| ax = fig.gca() | |
| def update_blit(artists): | |
| fig.canvas.restore_region(bg_cache) | |
| for a in artists: | |
| a.axes.draw_artist(a) | |
| ax.figure.canvas.blit(ax.bbox) | |
| artists = init_func() | |
| for a in artists: | |
| a.set_animated(True) | |
| fig.canvas.draw() | |
| bg_cache = fig.canvas.copy_from_bbox(ax.bbox) | |
| for f in frames: | |
| artists = func(f, *fargs) | |
| update_blit(artists) | |
| fig.canvas.start_event_loop(interval) | |
| This is of course leaving out many details (such as updating the | |
| background when the figure is resized or fully re-drawn). However, | |
| this hopefully minimalist example gives a sense of how ``init_func`` | |
| and ``func`` are used inside of `FuncAnimation` and the theory of how | |
| 'blitting' works. | |
| .. note:: | |
| The zorder of artists is not taken into account when 'blitting' | |
| because the 'blitted' artists are always drawn on top. | |
| The expected signature on ``func`` and ``init_func`` is very simple to | |
| keep `FuncAnimation` out of your book keeping and plotting logic, but | |
| this means that the callable objects you pass in must know what | |
| artists they should be working on. There are several approaches to | |
| handling this, of varying complexity and encapsulation. The simplest | |
| approach, which works quite well in the case of a script, is to define the | |
| artist at a global scope and let Python sort things out. For example:: | |
| import numpy as np | |
| import matplotlib.pyplot as plt | |
| from matplotlib.animation import FuncAnimation | |
| fig, ax = plt.subplots() | |
| xdata, ydata = [], [] | |
| ln, = ax.plot([], [], 'ro') | |
| def init(): | |
| ax.set_xlim(0, 2*np.pi) | |
| ax.set_ylim(-1, 1) | |
| return ln, | |
| def update(frame): | |
| xdata.append(frame) | |
| ydata.append(np.sin(frame)) | |
| ln.set_data(xdata, ydata) | |
| return ln, | |
| ani = FuncAnimation(fig, update, frames=np.linspace(0, 2*np.pi, 128), | |
| init_func=init, blit=True) | |
| plt.show() | |
| The second method is to use `functools.partial` to pass arguments to the | |
| function:: | |
| import numpy as np | |
| import matplotlib.pyplot as plt | |
| from matplotlib.animation import FuncAnimation | |
| from functools import partial | |
| fig, ax = plt.subplots() | |
| line1, = ax.plot([], [], 'ro') | |
| def init(): | |
| ax.set_xlim(0, 2*np.pi) | |
| ax.set_ylim(-1, 1) | |
| return line1, | |
| def update(frame, ln, x, y): | |
| x.append(frame) | |
| y.append(np.sin(frame)) | |
| ln.set_data(x, y) | |
| return ln, | |
| ani = FuncAnimation( | |
| fig, partial(update, ln=line1, x=[], y=[]), | |
| frames=np.linspace(0, 2*np.pi, 128), | |
| init_func=init, blit=True) | |
| plt.show() | |
| A third method is to use closures to build up the required | |
| artists and functions. A fourth method is to create a class. | |
| Examples | |
| ~~~~~~~~ | |
| * :doc:`../gallery/animation/animate_decay` | |
| * :doc:`../gallery/animation/bayes_update` | |
| * :doc:`../gallery/animation/double_pendulum` | |
| * :doc:`../gallery/animation/animated_histogram` | |
| * :doc:`../gallery/animation/rain` | |
| * :doc:`../gallery/animation/random_walk` | |
| * :doc:`../gallery/animation/simple_anim` | |
| * :doc:`../gallery/animation/strip_chart` | |
| * :doc:`../gallery/animation/unchained` | |
| ``ArtistAnimation`` | |
| ------------------- | |
| Examples | |
| ~~~~~~~~ | |
| * :doc:`../gallery/animation/dynamic_image` | |
| Writer Classes | |
| ============== | |
| .. inheritance-diagram:: matplotlib.animation.FFMpegFileWriter matplotlib.animation.FFMpegWriter matplotlib.animation.ImageMagickFileWriter matplotlib.animation.ImageMagickWriter matplotlib.animation.PillowWriter matplotlib.animation.HTMLWriter | |
| :top-classes: matplotlib.animation.AbstractMovieWriter | |
| :parts: 1 | |
| The provided writers fall into a few broad categories. | |
| The Pillow writer relies on the Pillow library to write the animation, keeping | |
| all data in memory. | |
| .. autosummary:: | |
| :toctree: _as_gen | |
| :nosignatures: | |
| PillowWriter | |
| The HTML writer generates JavaScript-based animations. | |
| .. autosummary:: | |
| :toctree: _as_gen | |
| :nosignatures: | |
| HTMLWriter | |
| The pipe-based writers stream the captured frames over a pipe to an external | |
| process. The pipe-based variants tend to be more performant, but may not work | |
| on all systems. | |
| .. autosummary:: | |
| :toctree: _as_gen | |
| :nosignatures: | |
| FFMpegWriter | |
| ImageMagickWriter | |
| The file-based writers save temporary files for each frame which are stitched | |
| into a single file at the end. Although slower, these writers can be easier to | |
| debug. | |
| .. autosummary:: | |
| :toctree: _as_gen | |
| :nosignatures: | |
| FFMpegFileWriter | |
| ImageMagickFileWriter | |
| The writer classes provide a way to grab sequential frames from the same | |
| underlying `~matplotlib.figure.Figure`. They all provide three methods that | |
| must be called in sequence: | |
| - `~.AbstractMovieWriter.setup` prepares the writer (e.g. opening a pipe). | |
| Pipe-based and file-based writers take different arguments to ``setup()``. | |
| - `~.AbstractMovieWriter.grab_frame` can then be called as often as | |
| needed to capture a single frame at a time | |
| - `~.AbstractMovieWriter.finish` finalizes the movie and writes the output | |
| file to disk. | |
| Example:: | |
| moviewriter = MovieWriter(...) | |
| moviewriter.setup(fig, 'my_movie.ext', dpi=100) | |
| for j in range(n): | |
| update_figure(j) | |
| moviewriter.grab_frame() | |
| moviewriter.finish() | |
| If using the writer classes directly (not through `Animation.save`), it is | |
| strongly encouraged to use the `~.AbstractMovieWriter.saving` context manager:: | |
| with moviewriter.saving(fig, 'myfile.mp4', dpi=100): | |
| for j in range(n): | |
| update_figure(j) | |
| moviewriter.grab_frame() | |
| to ensure that setup and cleanup are performed as necessary. | |
| Examples | |
| -------- | |
| * :doc:`../gallery/animation/frame_grabbing_sgskip` | |
| .. _ani_writer_classes: | |
| Helper Classes | |
| ============== | |
| Animation Base Classes | |
| ---------------------- | |
| .. autosummary:: | |
| :toctree: _as_gen | |
| :nosignatures: | |
| Animation | |
| TimedAnimation | |
| Writer Registry | |
| --------------- | |
| A module-level registry is provided to map between the name of the | |
| writer and the class to allow a string to be passed to | |
| `Animation.save` instead of a writer instance. | |
| .. autosummary:: | |
| :toctree: _as_gen | |
| :nosignatures: | |
| MovieWriterRegistry | |
| Writer Base Classes | |
| ------------------- | |
| To reduce code duplication base classes | |
| .. autosummary:: | |
| :toctree: _as_gen | |
| :nosignatures: | |
| AbstractMovieWriter | |
| MovieWriter | |
| FileMovieWriter | |
| and mixins | |
| .. autosummary:: | |
| :toctree: _as_gen | |
| :nosignatures: | |
| FFMpegBase | |
| ImageMagickBase | |
| are provided. | |
| See the source code for how to easily implement new `MovieWriter` classes. | |