duración de la animación matplotlib

El siguiente código muestra y guarda una animación de matrices aleatorias en sucesión. Mi pregunta es cómo puedo ajustar la duración de la animación que guardo. Los únicos parámetros que tengo aquí fps y ppp controlan primero cuántos segundos queda un cuadro y el segundo controla la calidad de la imagen. Lo que quiero es controlar realmente el número de cuadros que se van a guardar en términos de las matrices, el número de ellos que realmente se almacenan.

import numpy as np import matplotlib.pyplot as plt import matplotlib.animation as animation fig = plt.figure() N = 5 A = np.random.rand(N,N) im = plt.imshow(A) def updatefig(*args): im.set_array(np.random.rand(N,N)) return im, ani = animation.FuncAnimation(fig, updatefig, interval=200, blit=True) ani.save('try_animation.mp4', fps=10, dpi=80) #Frame per second controls speed, dpi controls the quality plt.show() 

Me pregunto si debería agregar más parámetros. Intenté buscar el apropiado en la documentación de la clase en matplotlib pero no tuve éxito:

http://matplotlib.org/api/animation_api.html#module-matplotlib.animation

La documentación revela que FuncAnimation acepta frames argumentos, que controlan el número total de cuadros jugados. Tu código podría así leer

 import numpy as np import matplotlib.pyplot as plt import matplotlib.animation as animation fig = plt.figure() N = 5 A = np.random.rand(N,N) im = plt.imshow(A) def updatefig(*args): im.set_array(np.random.rand(N,N)) return im, ani = animation.FuncAnimation(fig, updatefig, frames=10, interval=200, blit=True) ani.save('try_animation.mp4', fps=10, dpi=80) #Frame per second controls speed, dpi controls the quality plt.show() 

para jugar 10 cuadros.

Años después, he construido este es un ejemplo al que vuelvo cada vez que necesito ver cómo se relacionan entre sí los parámetros de la animación. Decidí compartirlo aquí para quien lo encuentre útil.

tl / dr:

  • Para la animación guardada, la duración será de frames * (1 / fps) (en segundos)
  • Para la animación visualizada, la duración será de frames * interval / 1000 (en segundos)

El código que figura a continuación le permite jugar con esta configuración en un entorno que ofrece una respuesta visual inmediata.

Este código crea un reloj que funciona según los parámetros:

 import numpy as np import matplotlib.pyplot as plt import matplotlib.animation as animation fig = plt.figure(figsize=(16, 12)) ax = fig.add_subplot(111) # You can initialize this with whatever im = ax.imshow(np.random.rand(6, 10), cmap='bone_r', interpolation='nearest') def animate(i): aux = np.zeros(60) aux[i] = 1 image_clock = np.reshape(aux, (6, 10)) im.set_array(image_clock) ani = animation.FuncAnimation(fig, animate, frames=60, interval=1000) ani.save('clock.mp4', fps=1.0, dpi=200) plt.show() 

Esto generará y guardará una animación que se verá así:

introduzca la descripción de la imagen aquí

Entonces, el punto es que el cuadrado negro se moverá a lo largo del gran cuadrado blanco a medida que pasa el tiempo. Hay 60 cajas blancas para que pueda construir un reloj que lo repase en un minuto.

Ahora, lo importante a tener en cuenta es que hay dos parámetros que determinan qué tan rápido se movería la caja negra: el interval en la función de animation.FuncAnimation y ‘fps’ en la función ani.save . El primero controla la velocidad en la animación que se mostrará y el segundo en la animación que guardará.

Como el código anterior se mantiene, generará 60 cuadros y se mostrarán a 1 cuadro por segundo. Eso significa que el reloj hace tic cada segundo. Si desea que el reloj de animación guardado marque cada dos segundos, debe configurar fps=0.5 . Si desea que el reloj de animación que se muestra haga clic cada dos segundos, debe establecer el interval=2000 .

[Editaré la explicación más larga tan pronto como tenga tiempo]