Wie man mit Matplotlib Daten in Echtzeit plotten kann

  1. Funktion FuncAnimation()
  2. canvas.draw() Zusammen mit Canvas_flush_events()
  3. Echtzeit-Streudiagramm

Um Daten in Echtzeit mit Matplotlib zu plotten oder eine Animation in Matplotlib zu erstellen, aktualisieren wir ständig die zu plottenden Variablen, indem wir in einer Schleife iterieren und dann die aktualisierten Werte plotten. Um den aktualisierten Plot in Echtzeit durch eine Animation zu betrachten, verwenden wir verschiedene Methoden wie die Funktion FuncAnimation(), canvas.draw() zusammen mit canvas_flush_events().

Funktion FuncAnimation()

Wir können den Plot in Echtzeit aktualisieren, indem wir die Variablen x und y aktualisieren und dann Aktualisierungen durch Animation mit matplotlib.animation.FuncAnimation anzeigen.

Syntax:

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

Plotten in Echtzeit unter Verwendung von FuncAnimation function.png

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

figure ist das Figur-Objekt, dessen Plot aktualisiert wird.

func_animate ist die Funktion, die bei jedem Frame aufgerufen wird. Ihr erstes Argument kommt von dem nächsten Wert frames.

frames=10 ist gleich range(10). Werte von 0 bis 9 werden bei jedem Frame an die Funktion func_animate übergeben. Wir könnten den Frames auch ein Interalbe zuweisen, wie eine Liste [0, 1, 3, 7, 12].

Intervall ist die Verzögerung zwischen Frames in der Einheit ms.

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

Wir könnten die Animation in einem gif oder mp4 mit den Parametern wie fps und dpi speichern.

canvas.draw() Zusammen mit Canvas_flush_events()

Wir können die Plot in Echtzeit aktualisieren, indem wir die Variablen x und y mit set_xdata() und set_ydata() aktualisieren und dann Aktualisierungen durch Animation mit canvas.draw() anzeigen, einer auf Javascript basierenden Methode.

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)

Echtzeit-Plot in Matplotlib unter Verwendung von canvas_draw

Hier werden die Werte von x und y wiederholt aktualisiert, und auch die Handlung wird in Echtzeit aktualisiert.

plt.ion() schaltet den interaktiven Modus ein. Der Plot wird nicht aktualisiert, wenn er nicht aufgerufen wird.

canvas.flush_events() ist eine auf Javascript basierende Methode zum Löschen von Figuren in jeder Iteration, so dass aufeinanderfolgende Figuren sich nicht überlappen können.

Echtzeit-Streudiagramm

Um jedoch eine Echtzeit-Streuung vorzunehmen, können wir einfach die Werte von x und y aktualisieren und Streupunkte in jeder Iteration hinzufügen. In diesem Fall müssen wir nicht jede Figur klären, da ein Streudiagramm im Allgemeinen einen bestimmten Punkt in der Ebene darstellt und die Punkte nur eine sehr geringe Chance haben, sich zu überlappen.

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

Streudiagramme in Echtzeit