The PillowWriter class from matplotlib.animation is a writer that allows us to save animations we create in matplotlib. Pillow is a fork of the Python Image Library (PIL). Both PIL and Pillow come with matplotlib. The matplotlib.animation.PillowWriter class is the image writer class for the matplotlib.animation module.

In this post, we’re going to cover the class signature of matplotlib.animation.PillowWriter, including its parameters, methods, and attributes. Then we’ll go over an example of how to use PillowWriter to save an animation via the animation of a sine wave. It’ll be an extension of the animation example we covered for the post on animation.FuncAnimation.

PillowWriter Class Signature

class matplotlib.animation.PillowWriter(fps=5, metadata=None, codec=None, bitrate=None)

The PillowWriter class has four parameters. None of these parameters are required. The four parameters are fps, metadata, codec, and bitrate. PillowWriter also has five methods (other than __init__), and one attribute. The methods are finish, grab_frame, isAvailable, saving, and setup. PillowWriter’s one attribute is frame_size.

Python PillowWriter Parameters

Let’s take a look at the four PillowWriter parameters. Only fps has a default, the other three default to None.

Parameter	Type	Description
`fps`	`int`	Defaults to 5, represents frames per second that the animation will be saved at
`metadata`	`dict`, None	Defaults to an empty `dict`. Represents the metadata of the animation.
`codec`	`string`, None	Defaults to the `animation.codec` default from `matplotlib`. Represents the video codec to use.
`bitrate`	`int`, None	Defaults to the `animation.bitrate` default from `matplotlib`. Represents the bitrate to save the animation at.

PillowWriter Parameters

Python PillowWriter Methods

There are five methods in `matplotlib.animation.PillowWriter`. Three of these methods are instance methods, one is a class method, and one is an inherited method.

Instance Method	Parameters	Description
`setup`	`fig`, `outfile`, `dpi`	Set up saving the animation. `fig` is the `matplotlib.figure.Figure` containing the animation, `outfile` is the name of the file we’re saving to, and `dpi` is a `float` representing the resolution of the file and defaults to 100.
`grab_frame`	`savefig_kwargs`	Grab the current image in the `Figure` and save it. Passes `savefig_kwargs` the the `savefig` function of `matplotlib.figure.Figure`.
`finish`		Finish processes for writing the movie

PillowWriter Methods and Functions

The one class method in `PillowWriter` is `isAvailable`. It represents whether the writer is available, and defaults to returning `True`. The one inherited method for `PillowWriter` is `saving`. `saving` takes up to five arguments, `fig`, `outfile`, dpi`, `args`, and `kwargs`. It’s a context manager that calls the `setup` method of the superclass. It basically does the same thing that the `matplotlib.animation.PillowWriter` `setup` method does.

Python PillowWriter Attributes

The `PillowWriter` class only has one attribute, `frame_size`. This attribute is a `(width, height)` tuple that represents the number of pixels in the width and height of each frame.

Save Animations with PillowWriter

Example Sine Function Animated and Saved with PillowWriter

All we have to do to save an animation with `PillowWriter` is have an animation to save. In this example, we’re going to do the exact same thing we did in the `FuncAnimation` tutorial except we’re going to show how to save the animation. We’ll build a simple example of an animation of a Sine function, the same function we used for our Recurrent Neural Network example. To follow this example you’ll need to install two libraries, `numpy` for the numerical data to plot and `matplotlib` (obviously) to use `FuncAnimation`, `PillowWriter`, and plot a figure. We can do this with the line below in the terminal.

pip install numpy matplotlib

Python Code for Creating the Animation with FuncAnimation

For a more detailed description of the code for creating this animation, read How to Make Animations with FuncAnimation. Basically what we’re going to do is create the animation that you see at the beginning of this section. We plot a sine wave and then plot multiple points along the wave as a red dot.

import numpy as np
import matplotlib.pyplot as plt
from matplotlib.animation import FuncAnimation
 
fig, ax = plt.subplots()
 
#plot sine function
_range = np.arange(0, 2*np.pi, 0.001)
sine = np.sin(_range)
line = plt.plot(_range, sine)
 
ax = plt.axis([0, 2*np.pi, -1, 1])
dot, = plt.plot([0], [np.sin(0)], 'ro') #plt.plot returns a tuple
 
def func(i):
    dot.set_data(i, np.sin(i))
    return dot, #return the unpacked tuple
   
_animation = FuncAnimation(fig, func, frames=np.arange(0, 2*np.pi, 0.1), interval=10, repeat=True)
plt.show()

Python Code for Saving the Animation with PillowWriter

We only need three lines of code to save an animation. First, we’ll import the `PillowWriter` class from `matplotlib.animation`. Then we’ll create a writer using the `PillowWriter` class, in this example, we’ll give it an fps of 30 instead of 5. Finally, we call the `save` method from the animation and pass in a filename and the writer.

from matplotlib.animation import PillowWriter
writer = PillowWriter(fps=30)
_animation.save("sine_example.gif", writer=writer)