Traccia i dati in tempo reale utilizzando Matplotlib

  1. Funzione FuncAnimation()
  2. canvas.draw() Insieme a canvas_flush_events()
  3. Grafico a dispersione in tempo reale

Per tracciare i dati in tempo reale utilizzando Matplotlib o creare un’animazione in Matplotlib, aggiorniamo costantemente le variabili da tracciare iterando in un ciclo e quindi tracciando i valori aggiornati. Per visualizzare la trama aggiornata in tempo reale attraverso l’animazione, usiamo vari metodi come la funzione FuncAnimation(), canvas.draw() insieme a canvas_flush_events().

Funzione FuncAnimation()

Possiamo aggiornare il grafico in tempo reale aggiornando le variabili x e y e quindi visualizzare gli aggiornamenti tramite l’animazione usando matplotlib.animation.FuncAnimation.

Sintassi:

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

Codice:

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()

tracciare in tempo reale utilizzando FuncAnimation function.png

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

figure è l’oggetto figura la cui trama verrà aggiornata.

func_animate è la funzione da chiamare in ogni frame. Il suo primo argomento proviene dal valore successivo frames.

frames=10 è uguale a range(10). I valori da 0 a 9 vengono passati a func_animate ad ogni frame. Potremmo anche assegnare un interalbe a frames, come una lista [0, 1, 3, 7, 12].

interval è il ritardo tra i frame nell’unità di ms.

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

Potremmo salvare l’animazione in un gif o mp4 con parametri come fps e dpi.

canvas.draw() Insieme a canvas_flush_events()

Possiamo aggiornare la trama in tempo reale aggiornando le variabili x e y con set_xdata() e set_ydata() e quindi visualizzare gli aggiornamenti tramite l’animazione usando canvas.draw(), che è un metodo basato su 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)

Grafico in tempo reale in Matplotlib utilizzando canvas_draw

Qui i valori di x e y vengono aggiornati ripetutamente e anche il grafico viene aggiornato in tempo reale.

plt.ion() attiva la modalità interattiva. La trama non verrà aggiornata se non viene richiamata.

canvas.flush_events() è un metodo basato su Javascript per cancellare le cifre in ogni iterazione in modo che le cifre successive non si sovrappongano.

Grafico a dispersione in tempo reale

Tuttavia, per creare una dispersione in tempo reale, possiamo semplicemente aggiornare i valori di x e y e aggiungere punti di dispersione in ogni iterazione. In questo caso, non è necessario cancellare tutte le figure poiché un grafico a dispersione generalmente rappresenta un punto distinto nel piano ei punti hanno pochissime possibilità di sovrapporsi.

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()

trama dispersione in tempo reale