""" .. redirect-from:: /tutorials/introductory/animation_tutorial .. _animations: =========================== Animations using Matplotlib =========================== Based on its plotting functionality, Matplotlib also provides an interface to generate animations using the `~matplotlib.animation` module. An animation is a sequence of frames where each frame corresponds to a plot on a `~matplotlib.figure.Figure`. This tutorial covers a general guideline on how to create such animations and the different options available. """ import matplotlib.pyplot as plt import numpy as np import matplotlib.animation as animation # %% # Animation Classes # ================= # # The animation process in Matplotlib can be thought of in 2 different ways: # # - `~matplotlib.animation.FuncAnimation`: Generate data for first # frame and then modify this data for each frame to create an animated plot. # # - `~matplotlib.animation.ArtistAnimation`: Generate a list (iterable) # of artists that will draw in each frame in the animation. # # `~matplotlib.animation.FuncAnimation` is more efficient in terms of # speed and memory as it draws an artist once and then modifies it. On the # other hand `~matplotlib.animation.ArtistAnimation` is flexible as it # allows any iterable of artists to be animated in a sequence. # # ``FuncAnimation`` # ----------------- # # The `~matplotlib.animation.FuncAnimation` class allows us to create an # animation by passing a function that iteratively modifies the data of a plot. # This is achieved by using the *setter* methods on various # `~matplotlib.artist.Artist` (examples: `~matplotlib.lines.Line2D`, # `~matplotlib.collections.PathCollection`, etc.). A usual # `~matplotlib.animation.FuncAnimation` object takes a # `~matplotlib.figure.Figure` that we want to animate and a function # *func* that modifies the data plotted on the figure. It uses the *frames* # parameter to determine the length of the animation. The *interval* parameter # is used to determine time in milliseconds between drawing of two frames. # Animating using `.FuncAnimation` would usually follow the following # structure: # # - Plot the initial figure, including all the required artists. Save all the # artists in variables so that they can be updated later on during the # animation. # - Create an animation function that updates the data in each artist to # generate the new frame at each function call. # - Create a `.FuncAnimation` object with the `.Figure` and the animation # function, along with the keyword arguments that determine the animation # properties. # - Use `.animation.Animation.save` or `.pyplot.show` to save or show the # animation. # # The update function uses the ``set_*`` function for different artists to # modify the data. The following table shows a few plotting methods, the artist # types they return and some methods that can be used to update them. # # ======================================== ============================= =========================== # Plotting method Artist Set method # ======================================== ============================= =========================== # `.Axes.plot` `.lines.Line2D` `~.lines.Line2D.set_data` # `.Axes.scatter` `.collections.PathCollection` `~.collections.\ # PathCollection.set_offsets` # `.Axes.imshow` `.image.AxesImage` ``AxesImage.set_data`` # `.Axes.annotate` `.text.Annotation` `~.text.Annotation.\ # update_positions` # `.Axes.barh` `.patches.Rectangle` `~.Rectangle.set_angle`, # `~.Rectangle.set_bounds`, # `~.Rectangle.set_height`, # `~.Rectangle.set_width`, # `~.Rectangle.set_x`, # `~.Rectangle.set_y`, # `~.Rectangle.set_xy` # `.Axes.fill` `.patches.Polygon` `~.Polygon.set_xy` # `.Axes.add_patch`\(`.patches.Ellipse`\) `.patches.Ellipse` `~.Ellipse.set_angle`, # `~.Ellipse.set_center`, # `~.Ellipse.set_height`, # `~.Ellipse.set_width` # ======================================== ============================= =========================== # # Covering the set methods for all types of artists is beyond the scope of this # tutorial but can be found in their respective documentations. An example of # such update methods in use for `.Axes.scatter` and `.Axes.plot` is as follows. fig, ax = plt.subplots() t = np.linspace(0, 3, 40) g = -9.81 v0 = 12 z = g * t**2 / 2 + v0 * t v02 = 5 z2 = g * t**2 / 2 + v02 * t scat = ax.scatter(t[0], z[0], c="b", s=5, label=f'v0 = {v0} m/s') line2 = ax.plot(t[0], z2[0], label=f'v0 = {v02} m/s')[0] ax.set(xlim=[0, 3], ylim=[-4, 10], xlabel='Time [s]', ylabel='Z [m]') ax.legend() def update(frame): # for each frame, update the data stored on each artist. x = t[:frame] y = z[:frame] # update the scatter plot: data = np.stack([x, y]).T scat.set_offsets(data) # update the line plot: line2.set_xdata(t[:frame]) line2.set_ydata(z2[:frame]) return (scat, line2) ani = animation.FuncAnimation(fig=fig, func=update, frames=40, interval=30) plt.show() # %% # ``ArtistAnimation`` # ------------------- # # `~matplotlib.animation.ArtistAnimation` can be used # to generate animations if there is data stored on various different artists. # This list of artists is then converted frame by frame into an animation. For # example, when we use `.Axes.barh` to plot a bar-chart, it creates a number of # artists for each of the bar and error bars. To update the plot, one would # need to update each of the bars from the container individually and redraw # them. Instead, `.animation.ArtistAnimation` can be used to plot each frame # individually and then stitched together to form an animation. A barchart race # is a simple example for this. fig, ax = plt.subplots() rng = np.random.default_rng(19680801) data = np.array([20, 20, 20, 20]) x = np.array([1, 2, 3, 4]) artists = [] colors = ['tab:blue', 'tab:red', 'tab:green', 'tab:purple'] for i in range(20): data += rng.integers(low=0, high=10, size=data.shape) container = ax.barh(x, data, color=colors) artists.append(container) ani = animation.ArtistAnimation(fig=fig, artists=artists, interval=400) plt.show() # %% # Animation Writers # ================= # # Animation objects can be saved to disk using various multimedia writers # (ex: Pillow, *ffpmeg*, *imagemagick*). Not all video formats are supported # by all writers. There are 4 major types of writers: # # - `~matplotlib.animation.PillowWriter` - Uses the Pillow library to # create the animation. # # - `~matplotlib.animation.HTMLWriter` - Used to create JavaScript-based # animations. # # - Pipe-based writers - `~matplotlib.animation.FFMpegWriter` and # `~matplotlib.animation.ImageMagickWriter` are pipe based writers. # These writers pipe each frame to the utility (*ffmpeg* / *imagemagick*) # which then stitches all of them together to create the animation. # # - File-based writers - `~matplotlib.animation.FFMpegFileWriter` and # `~matplotlib.animation.ImageMagickFileWriter` are examples of # file-based writers. These writers are slower than their pipe-based # alternatives but are more useful for debugging as they save each frame in # a file before stitching them together into an animation. # # Saving Animations # ----------------- # # .. list-table:: # :header-rows: 1 # # * - Writer # - Supported Formats # * - `~matplotlib.animation.PillowWriter` # - .gif, .apng, .webp # * - `~matplotlib.animation.HTMLWriter` # - .htm, .html, .png # * - | `~matplotlib.animation.FFMpegWriter` # | `~matplotlib.animation.FFMpegFileWriter` # - All formats supported by |ffmpeg|_: ``ffmpeg -formats`` # * - | `~matplotlib.animation.ImageMagickWriter` # | `~matplotlib.animation.ImageMagickFileWriter` # - All formats supported by |imagemagick|_: ``magick -list format`` # # .. _ffmpeg: https://www.ffmpeg.org/general.html#Supported-File-Formats_002c-Codecs-or-Features # .. |ffmpeg| replace:: *ffmpeg* # # .. _imagemagick: https://imagemagick.org/script/formats.php#supported # .. |imagemagick| replace:: *imagemagick* # # To save animations using any of the writers, we can use the # `.animation.Animation.save` method. It takes the *filename* that we want to # save the animation as and the *writer*, which is either a string or a writer # object. It also takes an *fps* argument. This argument is different than the # *interval* argument that `~.animation.FuncAnimation` or # `~.animation.ArtistAnimation` uses. *fps* determines the frame rate that the # **saved** animation uses, whereas *interval* determines the frame rate that # the **displayed** animation uses. # # Below are a few examples that show how to save an animation with different # writers. # # # Pillow writers:: # # ani.save(filename="/tmp/pillow_example.gif", writer="pillow") # ani.save(filename="/tmp/pillow_example.apng", writer="pillow") # # HTML writers:: # # ani.save(filename="/tmp/html_example.html", writer="html") # ani.save(filename="/tmp/html_example.htm", writer="html") # ani.save(filename="/tmp/html_example.png", writer="html") # # FFMpegWriter:: # # ani.save(filename="/tmp/ffmpeg_example.mkv", writer="ffmpeg") # ani.save(filename="/tmp/ffmpeg_example.mp4", writer="ffmpeg") # ani.save(filename="/tmp/ffmpeg_example.mjpeg", writer="ffmpeg") # # Imagemagick writers:: # # ani.save(filename="/tmp/imagemagick_example.gif", writer="imagemagick") # ani.save(filename="/tmp/imagemagick_example.webp", writer="imagemagick") # ani.save(filename="apng:/tmp/imagemagick_example.apng", # writer="imagemagick", extra_args=["-quality", "100"]) # # (the ``extra_args`` for *apng* are needed to reduce filesize by ~10x)