Comment tracer des données en temps réel à l'aide de Matplotlib

  1. Fonction FuncAnimation()
  2. canvas.draw() avec canvas_flush_events()
  3. Diagramme de dispersion en temps réel

Pour tracer des données en temps réel à l’aide de Matplotlib, ou faire une animation dans Matplotlib, nous mettons constamment à jour les variables à tracer en itérant dans une boucle puis en traçant les valeurs mises à jour. Pour visualiser l’intrigue mise à jour en temps réel via une animation, nous utilisons différentes méthodes telles que la fonction FuncAnimation(), canvas.draw() avec canvas_flush_events().

Fonction FuncAnimation()

Nous pouvons mettre à jour le tracé en temps réel en mettant à jour les variables x et y, puis en affichant les mises à jour via une animation en utilisant matplotlib.animation.FuncAnimation.

Syntaxe:

matplotlib.animation.FuncAnimation(fig, 
                                   func, 
                                   frames=None,
                                   init_func=None, 
                                   fargs=None,
                                   save_count=None, 
                                   *, 
                                   cache_frame_data=True,
                                   **kwargs)

Code:

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

x = []
y = []

figure, ax = plt.subplots(figsize=(4,3))
line, = ax.plot(x, y)
plt.axis([0, 4*np.pi, -1, 1])

def func_animate(i):
    x = np.linspace(0, 4*np.pi, 1000)
    y = np.sin(2 * (x - 0.1 * i))
    
    line.set_data(x, y)
    
    return line,

ani = FuncAnimation(figure,
                    func_animate,
                    frames=10,
                    interval=50)

ani.save(r'animation.gif', fps=10)

plt.show()

tracer en temps réel à l'aide de la fonction FuncAnimation.png

ani = FuncAnimation(figure,
                    func_animate,
                    frames=10,
                    interval=50)

figure est l’objet figure dont le tracé sera mis à jour.

func_animate est la fonction à appeler à chaque trame. Son premier argument provient de la valeur suivante frames.

frames = 10 est égal à range(10). Les valeurs de 0 à 9 sont passées à func_animate à chaque trame. Nous pourrions également assigner un interalbe aux frames, comme une liste [0, 1, 3, 7, 12].

interval est le délai entre les trames dans l’unité de ms.

ani.save('animation.gif', fps=10)

Nous pourrions enregistrer l’animation dans un gif oump4 avec les paramètres comme fps et dpi.

canvas.draw() avec canvas_flush_events()

Nous pouvons mettre à jour le tracé en temps réel en mettant à jour les variables x ety avec set_xdata() et set_ydata() puis en affichant les mises à jour via une animation en utilisant canvas.draw(), qui est un méthode basée sur Javascript.

import numpy as np
import time
import matplotlib.pyplot as plt

x = np.linspace(0, 10, 100)
y = np.cos(x)

plt.ion()

figure, ax = plt.subplots(figsize=(8,6))
line1, = ax.plot(x, y)

plt.title("Dynamic Plot of sinx",fontsize=25)

plt.xlabel("X",fontsize=18)
plt.ylabel("sinX",fontsize=18)

for p in range(100):
    updated_y = np.cos(x-0.05*p)
    
    line1.set_xdata(x)
    line1.set_ydata(updated_y)
    
    figure.canvas.draw()
    
    figure.canvas.flush_events()
    time.sleep(0.1)

Tracé en temps réel dans Matplotlib à l'aide de canvas_draw

Ici, les valeurs de x et y sont mises à jour à plusieurs reprises et le tracé est également mis à jour en temps réel.

plt.ion() active le mode interactif. Le tracé ne sera pas mis à jour s’il n’est pas appelé.

canvas.flush_events() est une méthode basée sur Javascript pour effacer les chiffres à chaque itération afin que les chiffres successifs ne se chevauchent pas.

Diagramme de dispersion en temps réel

Cependant, pour faire un scatter en temps réel, nous pouvons simplement mettre à jour les valeurs de x et y et ajouter des points de dispersion à chaque itération. Dans ce cas, nous n’avons pas besoin d’effacer chaque figure car un nuage de points représente généralement un point distinct dans le plan et les points ont très peu de chances de se chevaucher.

import numpy as np
import matplotlib.pyplot as plt
x=0
for i in range(100):
    x=x+0.04
    y = np.sin(x)
    plt.scatter(x, y)
    plt.title("Real Time plot")
    plt.xlabel("x")
    plt.ylabel("sinx")
    plt.pause(0.05)

plt.show()

tracer la dispersion en temps réel

comments powered by Disqus