Dynamisches Aktualisieren von Plot in Matplotlib

Ich mache eine Anwendung in Python, die Daten von einem seriellen Port sammelt und zeichnet ein Diagramm der gesammelten Daten gegen Ankunftszeit. Die Ankunftszeit für die Daten ist unsicher. Ich möchte, dass die Handlung aktualisiert wird, wenn Daten empfangen werden. Ich suchte, wie dies zu tun und fand zwei Methoden:

  1. Löschen Sie die Handlung und ziehen Sie die Handlung wieder mit allen Punkten wieder auf.
  2. Animieren Sie die Handlung, indem Sie sie nach einem bestimmten Intervall ändern.

Ich bevorzuge nicht die erste, wie das Programm läuft und sammelt Daten für eine lange Zeit (ein Tag zum Beispiel), und die Neuzeichnung der Handlung wird ziemlich langsam sein. Die zweite ist auch nicht vorzuziehen, wie die Zeit der Ankunft der Daten ist unsicher und ich möchte die Handlung nur aktualisieren, wenn die Daten empfangen werden.

Gibt es eine Möglichkeit, in der ich das Plot nur aktualisieren kann, indem ich nur noch Punkte hinzufüge, wenn die Daten empfangen werden?

  • Zeigen Sie mehrere Plots in einem scrollbaren Widget mit PyQt und matplotlib
  • Overlay gedreht Bilder auf Handlung mit Matplotlib
  • Nicht in der Lage zu importieren Matplotlib python 2.7 windows 7
  • Mehrere Zeiträume von Pandas Dataframe
  • Dynamische Hinzufügen von Subplots in Matplotlib mit mehr als einer Spalte
  • Wie gebe ich eine Schrittfunktion mit Matplotlib in Python?
  • 3 Solutions collect form web for “Dynamisches Aktualisieren von Plot in Matplotlib”

    Gibt es einen Weg, in dem ich die Handlung nur durch Hinzufügen von mehr Punkt [s] zu aktualisieren kann …

    Es gibt eine Reihe von Möglichkeiten zur Animation von Daten in Matplotlib, je nach der Version, die Sie haben. Haben Sie die matplotlib Kochbuch Beispiele gesehen? Sehen Sie sich auch die modernen Animationsbeispiele in der Matplotlib-Dokumentation an. Schließlich definiert die Animations-API eine Funktion FuncAnimation , die eine Funktion in der Zeit animiert. Diese Funktion könnte nur die Funktion sein, mit der Sie Ihre Daten erwerben können.

    Jede Methode legt grundsätzlich die data des zu zeichnenden Objekts fest, so dass kein Bild oder Bild gelöscht werden muss. Die data kann einfach verlängert werden, also kannst du die vorherigen Punkte behalten und einfach weiter zu deiner Linie hinzufügen (oder Bild oder was auch immer du zeichnet).

    Angesichts der Tatsache, dass Sie sagen, dass Ihre Daten Ankunftszeit ist unsicher Ihre beste Wette ist wahrscheinlich nur so etwas wie zu tun:

     import matplotlib.pyplot as plt import numpy hl, = plt.plot([], []) def update_line(hl, new_data): hl.set_xdata(numpy.append(hl.get_xdata(), new_data)) hl.set_ydata(numpy.append(hl.get_ydata(), new_data)) plt.draw() 

    Dann, wenn Sie Daten von der seriellen Schnittstelle erhalten, rufen update_line einfach update_line .

    Um dies ohne FuncAnimation zu machen (zB möchten Sie andere Teile des Codes ausführen, während das Plot produziert wird oder Sie gleichzeitig mehrere Plots aktualisieren möchten), ruft das draw allein nicht die Handlung (zumindest mit Das qt backend).

    Die folgenden Arbeiten für mich:

     import matplotlib.pyplot as plt plt.ion() class DynamicUpdate(): #Suppose we know the x range min_x = 0 max_x = 10 def on_launch(self): #Set up plot self.figure, self.ax = plt.subplots() self.lines, = self.ax.plot([],[], 'o') #Autoscale on unknown axis and known lims on the other self.ax.set_autoscaley_on(True) self.ax.set_xlim(self.min_x, self.max_x) #Other stuff self.ax.grid() ... def on_running(self, xdata, ydata): #Update data (with the new _and_ the old points) self.lines.set_xdata(xdata) self.lines.set_ydata(ydata) #Need both of these in order to rescale self.ax.relim() self.ax.autoscale_view() #We need to draw *and* flush self.figure.canvas.draw() self.figure.canvas.flush_events() #Example def __call__(self): import numpy as np import time self.on_launch() xdata = [] ydata = [] for x in np.arange(0,10,0.5): xdata.append(x) ydata.append(np.exp(-x**2)+10*np.exp(-(x-7)**2)) self.on_running(xdata, ydata) time.sleep(1) return xdata, ydata d = DynamicUpdate() d() 

    Ich weiß, ich bin spät, um diese Frage zu beantworten, aber für Ihr Problem könntest du in das "Joystick" -Paket schauen. Ich habe es entworfen, um einen Datenstrom aus dem seriellen Port zu plotten, aber es funktioniert für jeden Stream. Es ermöglicht auch interaktive Textprotokollierung oder Bildplotten (zusätzlich zur graphischen Darstellung). Keine Notwendigkeit, Ihre eigenen Loops in einem separaten Thread zu machen, das Paket kümmert sich darum, geben Sie einfach die Update-Frequenz, die Sie wünschen. Plus bleibt das Terminal für die Überwachung von Befehlen beim Plotten verfügbar. Siehe http://www.github.com/ceyzeriat/joystick/ oder https://pypi.python.org/pypi/joystick (mit Pip installieren Joystick installieren)

    Ersetzen Sie einfach np.random.random () durch Ihren realen Datenpunkt, der von der seriellen Schnittstelle im folgenden Code gelesen wird:

     import joystick as jk import numpy as np import time class test(jk.Joystick): # initialize the infinite loop decorator _infinite_loop = jk.deco_infinite_loop() def _init(self, *args, **kwargs): """ Function called at initialization, see the doc """ self._t0 = time.time() # initialize time self.xdata = np.array([self._t0]) # time x-axis self.ydata = np.array([0.0]) # fake data y-axis # create a graph frame self.mygraph = self.add_frame(jk.Graph(name="test", size=(500, 500), pos=(50, 50), fmt="go-", xnpts=10000, xnptsmax=10000, xylim=(None, None, 0, 1))) @_infinite_loop(wait_time=0.2) def _generate_data(self): # function looped every 0.2 second to read or produce data """ Loop starting with the simulation start, getting data and pushing it to the graph every 0.2 seconds """ # concatenate data on the time x-axis self.xdata = jk.core.add_datapoint(self.xdata, time.time(), xnptsmax=self.mygraph.xnptsmax) # concatenate data on the fake data y-axis self.ydata = jk.core.add_datapoint(self.ydata, np.random.random(), xnptsmax=self.mygraph.xnptsmax) self.mygraph.set_xydata(t, self.ydata) t = test() t.start() t.stop() 
    Python ist die beste Programmiersprache der Welt.