How to create high-res animations with Matplotlib without memory problems?

Question

I'd like to create a Matplotlib heatmap animation with at least 200*300 resolution, and 500 frames. The problem is the standard approach for the animation I took has a huge memory leak (as discussed in this question*). When the animation starts to draw, or to write out, the RAM begins to be filled up, to the point the system freezes until the script is killed. It's so bad that even my 4gb RAM and 4gb swap together is not enough. Is there any way to make that animation, besides creating smaller chunks and editing there together?

This is my code, with a bit of simplification. (Note: it'd take minutes to run and probably will fill up your memory completely, causing freezes.)

import numpy as np
from matplotlib import pyplot as plt
import matplotlib.animation as animation

def waveanim(frames, trange, xbounds, ybounds, xnum, ynum, fps):

    xpoints = np.linspace(*xbounds, xnum)
    ypoints = np.linspace(*ybounds, ynum)
    tmin, tmax = trange

    # this part is a complicated calculation in my actual code; point is I have all the 
    # values for all the time points in an array that I calculate like this ready before 
    # I even start animating. (Since the calculation involves an inverse FFT, I can't just use NumPy's cool array managing abilities as ImportanceOfBeingErnest's answer suggests.)
    result = np.empty((xnum, ynum, frames), dtype="float64")
    for i, x in enumerate(xpoints):
        print("calculating: {} out of {}".format(i, len(xpoints)), end='\r')
        for j, y in enumerate(ypoints):
            arr = np.array([np.sin(x+t) + np.cos(x-y-2*t) for t in np.linspace(tmin, tmax, frames)])
            result[i,j] = arr
    print('\n')
    def animate(i):
        print("animating: {} out of {}".format(i, frames), end='\r')
        val = result[:,:,i].transpose()
        pc = plt.pcolor(xpoints, ypoints, val, cmap='jet')
        return pc,

    fig, ax = plt.subplots()
    im_ani = animation.FuncAnimation(fig, animate, frames=frames, interval=1000/fps, repeat_delay=0, blit=True)
    plt.show()


def main():

    trange = (-10.0, 10.0)
    xbounds = (-20.0, 20.0)
    ybounds = (-20.0, 20.0)
    frames = 100
    xnum = 300
    ynum = 300
    fps = 25
    waveanim(frames, trange, xbounds, ybounds, xnum, ynum, fps)

if __name__ == '__main__':
     main()

I also tried generating the plots individually, putting them in an array and that array to ArtistAnimation, like in this example, but the result is the same.

*Mine is not a dupe since a) I work on Kubuntu, not on iOS, and the fix was OS-specific, and b) because I don't limit the solutions to solve the leak bug.

ImportanceOfBeingErnest · Accepted Answer · 2018-08-09 00:11:37Z

You're creating 100 plt.pcolor plots in the same figure. That is for sure a lot. For an efficient memory usage you would only use a single plt.pcolor plot. You may then update this plot in each animation step. (This concepts is actually also used in the linked question, just for a different plot type.)

To save computation time, you may also get rid of the nested python loop to fill the array, but instead evaluate the function on a grid with numpy. That will decrease the time up to the point where the animation starts from ~1 minute to some seconds.

import numpy as np
from matplotlib import pyplot as plt
import matplotlib.animation as animation

def waveanim(frames, trange, xbounds, ybounds, xnum, ynum, fps):

    xpoints = np.linspace(*xbounds, xnum)
    ypoints = np.linspace(*ybounds, ynum)
    tmin, tmax = trange

    # Evaluating a function on a grid is more efficient than using a python loop
    X, Y, T = np.meshgrid(xpoints, ypoints, np.linspace(tmin, tmax, frames))
    # Because pcolor(mesh) defines the values at the edges of the pixels,
    # we need one less row and column in the result
    result = (np.sin(X+T) + np.cos(X-Y-2*T))[:-1,:-1,:]


    def animate(i):
        print("animating: {} out of {}".format(i, frames), end='\r')
        val = result[:,:,i]
        # update the values of the pcolormesh plot
        pc.set_array(val.flatten())
        return pc,

    fig, ax = plt.subplots()
    norm = plt.Normalize(result.min(), result.max())
    pc = plt.pcolormesh(xpoints, ypoints, result[:,:,0], cmap='jet', norm=norm)
    im_ani = animation.FuncAnimation(fig, animate, frames=frames, interval=1000/fps, 
                                     repeat_delay=0, blit=True)
    plt.show()


def main():

    trange = (-10.0, 10.0)
    xbounds = (-20.0, 20.0)
    ybounds = (-20.0, 20.0)
    frames = 100
    xnum = 300
    ynum = 300
    fps = 25
    waveanim(frames, trange, xbounds, ybounds, xnum, ynum, fps)

if __name__ == '__main__':
     main()

Collectives™ on Stack Overflow

How to create high-res animations with Matplotlib without memory problems?

1 Answer 1

Comments

Your Answer

Linked

Hot Network Questions

Collectives™ on Stack Overflow

1 Answer 1

Comments

Your Answer

Sign up or log in

Post as a guest

Linked

Related