Plotting Live Data with Python using Matplotlib

Python Installation

Python can be downloaded from python.org. A detailed tutorial on how to install Python on Windows, Mac, or Linux can be found at realpython.com.

Matplotlib Installation

Instructions for installing the Matplotlib package can be found on their home page (matplotlib.org) and installation guide page (matplotlib.org). You can install Matplotlib with either pip or conda. The pip command is given below.

Imported Libraries

The Python code starts by importing the following libraries.

import os:

For obtaining the current filename of the script being ran using os.path.basename (docs.python.org).

import matplotlib.pyplot as plt:

A state-based interface to matplotlib that provides an implicit, MATLAB-like, way of plotting. It acts as the figure GUIGraphical User Interface manager used to open figures on your screen and make changes to the figure axes. More details about the functionality of matplotlib.pyplot can be found at matplotlib.org.

import matplotlib.animation as animation:

A class to make a live animation in Matplotlib. The animation is advanced by a timer (typically from the host GUI framework) which the Animation object holds the only reference to. The animation object has a method FuncAnimation() that handles '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. More details on Matplotlib's animation can be found at matplotlib.org.

from matplotlib import style:

Different styles can be set in Matplotlib that define the visual appearance of the plot. Documentation on Matplotlib's style APIApplication Programming Interface can be found at matplotlib.org.. The "fivethirtyeight" styling (matplotlib.org) is a popular choice for styling plots, which tries to replicate the styles from the website FiveThirtyEight.com that focuses on opinion poll analysis, politics, economics, and sports blogging in the United States. The 'dark_background' style (matplotlib.org) was chosen to be consistent with the dark theme of this website.

import datetime as datetime:

The datetime module is needed for the x-tick label time stamps of the data in the plot.

import random:

Python's random library (docs.python.org) is imported to create random numbers to represent data from external devices. By default, the random numbers are generated from the current system time, which will give different results each time the script is ran. Reproducability of the results is preferred for development, testing, and debugging, which can be accomplished by initializing the random number generator with a seed: random.seed(a=10) documented at docs.python.org.

Read Data Function: read_data()

The read_data() function simulates data from an external device by generating random numbers in the range -0.5 to +0.5 along with a timestamp. The code in this function can be replaced, for example, by PySerial read calls to the serial port to collect data from external hardware such as a microcontroller.

Animation Function: FuncAnimation()

The animation function call FuncAnimation() repeatedly calls a function you define for the plot animation.

    ani = animation.FuncAnimation(
                                  fig=fig,
                                  func=animate,
                                  fargs=(xs, ys),
                                  interval=1000,
                                  )
          

fig:

This is the figure object obtained when creating the figure.

func:

The function to call each frame. This is assigned to the function animate(i, xs, ys), where i is the frame iterator.

fargs:

The input arguments to the function assigned to func. These are additional arguments passed to each call to func. This is set to the x samples and y samples (xs, ys).

interval:

The time interval in milliseconds between frames. This is set to 1000 milliseconds (1 second). If this is not set, the default value of 200 milliseconds is used.

ani:

The output of the animation function. The animation function needs to persist, so it must be assigned to a variable. Otherwise, the Animation object will be garbage-collected and the animation stops.

More arguments can be used with the FuncAnimation function, which is documented at matplotlib.org.

To avoid cluttering the plot, the number of samples plotted in a frame is limited to only 10 samples at a time with x_len = 10, where the plot only shows the last 10 samples. The lists that hold the samples are truncated to hold the last 10 samples with xs = xs[-xlen:] and ys = ys[-xlen:].

The x tick labels have a time format of Hour:Minute:Seconds. Since these tick labels are unique for each data point, they must be updated (redrawn) on the plot for every frame. They are also rotated 45 degrees to avoid overlap on the x-axis. Recreating the x-tick labels and rotating them on the plot for every frame is extra overhead that slows down the plot drawing, limiting how quickly the animate function can be called. If these labels are not needed, higher performance can be gained by using blitting where only the plot line is updated every frame.

Output

The first 15 seconds (15 frames) of the live plotting output is shown in the figure below. The first 10 frames build up on samples to fill out the plot, then the plot only displays the latest 10 samples for every frame.

Timing and Performance

In this section the timing performance of the animation will be measured. The runtime of the plotting routine will vary depending on the computer used, but as will be shown later the speed results of this code can be compared to an example using blitting ran on the same machine. The timing performance code is given below along with the plot results showing the time between frames.

The time interval between animation calls has be set to zero (interval=0) in order to measure only the plotting time rather than the frame delay. Since the animation is now running at such a high speed (less than a second), the data timestamps has been extended out to milliseconds to produce unique labels for each point. The time library has been imported to use time.perf_counter() to capture the time the animation frames occur in the time_array. The number of frames is set to nframes = 1000. After the frame times are recorded, the timing_plot(time_array) is called to produce the timing plot, which shows 40.3ms per frame (24.8fpsFrames Per Second) on average.

Output

The first 6 seconds (150 frames) of the live plotting output is shown in the figure below. The first 10 frames build up on samples to fill out the plot, then the plot only displays the latest 10 samples for every frame.

Timing and Performance

In this section the timing performance benefits of blitting will be measured. The runtime of the plotting routine will vary depending on the computer used, but this will show the speed improvements compared to the example given by redrawing timestamps. The timing performance code is given below along with the plot results showing the time between frames.

The time interval between animation calls has be set to zero (interval=0) in order to measure only the plotting time rather than the frame delay. The time library has been imported to use time.perf_counter() to capture the time the animation frames occur in the time_array. The number of frames is set to nframes = 1000. After the frame times are recorded, the timing_plot(time_array) is called to produce the timing plot, which shows an average speedup from 40.3ms per frame (24.8fpsFrames Per Second) to 8.8ms per frame (113.6fpsFrames Per Second) with blitting.