[Tut] Matplotlib Animation – A Helpful Illustrated Guide

[Tut] Matplotlib Animation – A Helpful Illustrated Guide - Printable Version

+- Sick Gaming (https://sickgaming.net)
+-- Forum: Programming (https://sickgaming.net/forum-76.html)
+--- Forum: Python (https://sickgaming.net/forum-83.html)
+--- Thread: [Tut] Matplotlib Animation – A Helpful Illustrated Guide (/thread-95038.html)

[Tut] Matplotlib Animation – A Helpful Illustrated Guide - xSicKxBot - 05-13-2020

Matplotlib Animation – A Helpful Illustrated Guide

Creating animations in matplotlib is reasonably straightforward. However, it can be tricky when starting, and there is no consensus for the best way to create them. In this article, I show you a few methods you can use to make amazing animations in matplotlib.

Matplotlib Animation Example

The hardest thing about creating animations in matplotlib is coming up with the idea for them. This article covers the basic ideas for line plots, and I may cover other plots such as scatter and 3D plots in the future. Once you understand these overarching principles, you can animate other plots effortlessly.

There are two classes you can use to create animations:

Code:
FuncAnimation

and

Code:
ArtistAnimation.

I focus on

Code:
FuncAnimation

as this is the more intuitive and more widely used one of the two.

To use

Code:
FuncAnimation,

define a function (often called

Code:
animate

), which matplotlib repeatedly calls to create the next frame/image for your animation.

To create an animation with

Code:
FuncAnimation

in matplotlib, follow these seven steps:

Have a clear picture in your mind of what you want the animation to do
Import standard modules and
Code:
FuncAnimation
Set up
Code:
Figure
,
Code:
Axes
, and
Code:
Line
objects
Initialize data
Define your animation function –
Code:
animate(i)
Pass everything to
Code:
FuncAnimation
Display or save your animation

Let’s create a sin wave that matplotlib ‘draws’ for us. Note that this code may look strange to you when you first read it. Creating animations with matplotlib is different from creating static plots.

Code:
# Standard imports
import numpy as np
import matplotlib.pyplot as plt
from matplotlib.animation import FuncAnimation

Import NumPyand matplotlib using their standard aliases and

Code:
FuncAnimation

from

Code:
matplotlib.animation

Code:
# Set up empty Figure, Axes and Line objects
fig, ax = plt.subplots()
# Set axes limits so that the whole image is included
ax.set(xlim=(-0.1, 2*np.pi+0.1), ylim=(-1.1, 1.1))
# Draw a blank line
line, = ax.plot([], [])

Set up the

Code:
Figure

and

Code:
Axes

objects using

Code:
plt.subplots()

and – using

Code:
ax.set()

– set the x- and y-axis limits to the same size as a normal sine curve – from 0 to 2π on the x-axis and from -1 to 1 on the y-axis. Note that I included padding of 0.1 on each axis limit so that you can see the whole line matplotlib draws.

Then, I did something you have probably never done before: I drew a blank line. You need to do this because

Code:
animate

modifies this line, and it can only modify something that already exists. You can also think of it as initializing an empty line object that you will soon fill with data.

Note that you must include a comma after

Code:
line,

! The plot method returns a tuple, and you need to unpack it to create the variable

Code:
line

Code:
# Define data - one sine wave
x = np.linspace(0, 2*np.pi, num=50)
y = np.sin(x)

Next, define the data you want to plot. Here, I am plotting one sine wave, so I used

Code:
np.linspace()

to create the x-axis data and created

Code:
y

by calling

Code:
np.sin()

Code:
x

. Thanks to numpy broadcasting, it is easy to apply functions to NumPy arrays!

Code:
# Define animate function
def animate(i): line.set_data(x[:i], y[:i]) return line,

Define the

Code:
animate(i)

function. Its argument

Code:
i

is an integer starting from 0 and up to the total number of frames you want in your animation. I used the

Code:
line.set_data()

method to draw the first

Code:
i

elements of the sine curve for both

Code:
x

and

Code:
y

. Note that you return

Code:
line,

with a comma again because you need to return an iterable and adding a comma makes it a tuple.

Code:
# Pass to FuncAnimation
anim = FuncAnimation(fig, animate, frames=len(x)+1, interval=30, blit=True)

Create a

Code:
FuncAnimation

object. First, pass the

Code:
Figure

and

Code:
animate

function as positional arguments.

Next, set the number of

Code:
frames

Code:
len(x)+1

so that it includes all the values in

Code:
x

. It works like the

Code:
range()

function, and so even though

Code:
x

has length 50, python only draws frames 0 to 49 and not the 50th member. So, add on one more to draw the entire plot.

The

Code:
interval

is how long in milliseconds matplotlib waits between drawing the next part of the animation. I’ve found that 30 works well as a general go-to. A larger number means matplotlib waits longer between drawing and so the animation is slower.

Finally, set

Code:
blit=True

so that it only redraws parts that have not been drawn before. It doesn’t make much difference for this example, but once you create more complex plots, you should use this; it can take quite a while for matplotlib to create animations (waiting several minutes is common for large ones).

Code:
# Save in the current working directory
anim.save('sin.mp4')

I saved the animation as a video called ‘sin.mp4’ to the current working directory.

https://blog.finxter.com/wp-content/uploads/2020/05/sin-2.mp4

Open your current working directory, find the saved video, and play it. Congratulations! You’ve just made your first animation in matplotlib!

Some of the steps you take to create animations are unique and may feel unusual the first time you try them. I know I felt strange the first time I used them. Don’t worry, the more you practice and experiment, the easier it becomes.

Here’s the full code:

Code:
# Standard imports
import numpy as np
import matplotlib.pyplot as plt
from matplotlib.animation import FuncAnimation # Set up empty Figure, Axes and Line objects
fig, ax = plt.subplots()
# Set axes limits so that the whole image is included
ax.set(xlim=(-0.1, 2*np.pi+0.1), ylim=(-1.1, 1.1))
# Draw a blank line
line, = ax.plot([], []) # Define data - one sine wave
x = np.linspace(0, 2*np.pi, num=50)
y = np.sin(x) # Define animate function
def animate(i): line.set_data(x[:i], y[:i]) return line, # Pass to FuncAnimation
anim = FuncAnimation(fig, animate, frames=len(x)+1, interval=30, blit=True) # Save in the current working directory
anim.save('sin.mp4')

Note that if this final step did not work for you, it’s probably because you don’t have the right libraries installed – I’ll show you what to install right now.

Related:

Matplotlib Animation Save

To save your animation in matplotlib, use the

Code:
.save()

method on your

Code:
FuncAnimation

object. You can either save them as mp4 videos or gifs.

Matplotlib Animation Save Mp4

To save animations as mp4 videos, first, install the FFmpeg library. It’s an incredibly powerful command-line tool, and you can download it from their official site, Github, or, if you use anaconda, by running

Code:
conda install ffmpeg

.

Once you have created your animation, run

Code:
anim.save('name.mp4', writer='ffmpeg')

, and python saves your animation as the video ‘name.mp4’ in your current working directory.

Note that the default writer is FFmpeg, and so you don’t have to explicitly state it if you don’t want to.

Matplotlib Animation Save Gif

To save animations as gifs, first, install the ImageMagick library. It is a command-line tool, and you can download it from their official site, GitHub, or if you use anaconda, by running

Code:
conda install -c conda-forge imagemagick

.

Once you have created your animation, run

Code:
anim.save('name.gif', writer='imagemagick')

, and python saves your animation as the gif ‘name.gif’ in your current working directory.

Code:
anim.save('sin.gif', writer='imagemagick')

Note that both ImageMagick and FFmpeg are command-line tools and not python libraries. As such, you cannot install them using

Code:
pip

. There are some python wrappers for those tools online, but they are not what you need to install.

Matplotlib Animation Jupyter

If you write your code in Jupyter notebooks (something I highly recommend), and don’t want to save your animations to disk every time, you may be disappointed to hear that your animations do not work out of the box. By default, Jupyter renders plots as static png images that cannot be animated.

To fix this, you have a couple of options to choose from:

The
Code:
%matplotlib notebook
magic command, or
Changing the
Code:
plt.rcParams
dictionary

If you run

Code:
%matplotlib notebook

in a code cell at the top of your notebook, then all your plots render in interactive windows.

Code:
# Run at the top of your notebook
%matplotlib notebook

https://blog.finxter.com/wp-content/uploads/2020/05/notebook_option.mov

As I cannot show you interactive Jupyter windows in a blog post, the above video shows you the result of running the sin drawing curve above.

This method is by far the simplest but gives you the least control. For one thing, the buttons at the bottom do nothing. Plus, it keeps running until you click the off button at the top… but when you do, you have no way to turn it on again!

I much prefer using the default

Code:
%matplotlin inline

style for all my plots, but you are free to choose whichever you want.

The other option is to change the

Code:
plt.rcParams

dictionary. This dictionary controls the default behavior for all your matplotlib plots such as figure size, font size, and how your animations should display when you call them.

If you print it to the screen, you can see all the parameters it controls.

The one you are interested in is

Code:
animation.html

, which is

Code:
none

by default. The other options are:

Code:
'html5'

and

Code:
'jshtml'

.

Let’s see what happens when you set

Code:
plt.rcParams

to those options. First, let’s look at

Code:
'html5'

Code:
plt.rcParams['animation.html'] = 'html5'
anim

Now the animation is rendered as an HTML5 video that plays as a loop. You can start/stop it using the play/pause buttons, but that’s about it. In my experience, this video plays much smoother than the interactive windows produced by

Code:
%matplotlib notebook

.

Now let’s look at the much more powerful option:

Code:
'jshtml'

which stands for Javascript HTML.

Code:
plt.rcParams['animation.html'] = 'jshtml'
anim

Now your animations are displayed in interactive javascript windows! This option is by far the most powerful one available to you.

Here are what each of the keys do (starting from the far left):

speed up/slow down: + / –
jump to end/start: |<< / >>|
move one frame backwards/forwards: |< / >|
play it backwards/forwards: < / >
pause with the pause key

Moreover, you can choose to play it ‘Once’, ‘Loop’ infinitely or play forwards and backward indefinitely using ‘Reflect’.

To have all your animations render as either HTML5 video or in interactive javascript widgets, set

Code:
plt.rcParams

at the top of your code.

Conclusion

Excellent! You now know how to create basic animations in matplotlib. You know how to use

Code:
FuncAnimaton

, how to save them as videos or gifs, and plot animations in Jupyter notebooks.

You’ve seen how to create ‘drawing’ plots, but there are many other things you can do, such as creating moving plots, animating 3D plots, and even scatter graphs. But we’ll leave them for another article.

Where To Go From Here?

Do you wish you could be a programmer full-time but don’t know how to start?

Check out the pure value-packed webinar where Chris – creator of Finxter.com – teaches you to become a Python freelancer in 60 days or your money back!

https://tinyurl.com/become-a-python-freelancer

It doesn’t matter if you’re a Python novice or Python pro. If you are not making six figures/year with Python right now, you will learn something from this webinar.

These are proven, no-BS methods that get you results fast.

This webinar won’t be online forever. Click the link below before the seats fill up and learn how to become a Python freelancer, guaranteed.

https://tinyurl.com/become-a-python-freelancer