Wie aktualisiere ich ein Diagramm in matplotlib?

Ich habe Probleme beim Neuzeichnen der Figur hier. Ich erlaube dem Benutzer, die Einheiten in der Zeitskala (x-Achse) anzugeben, und dann berechne ich diese Funktion neu und rufe sie auf plots(). Ich möchte, dass der Plot einfach aktualisiert wird und kein weiterer Plot an die Figur angehängt wird.

def plots():
    global vlgaBuffSorted
    cntr()

    result = collections.defaultdict(list)
    for d in vlgaBuffSorted:
        result[d['event']].append(d)

    result_list = result.values()

    f = Figure()
    graph1 = f.add_subplot(211)
    graph2 = f.add_subplot(212,sharex=graph1)

    for item in result_list:
        tL = []
        vgsL = []
        vdsL = []
        isubL = []
        for dict in item:
            tL.append(dict['time'])
            vgsL.append(dict['vgs'])
            vdsL.append(dict['vds'])
            isubL.append(dict['isub'])
        graph1.plot(tL,vdsL,'bo',label='a')
        graph1.plot(tL,vgsL,'rp',label='b')
        graph2.plot(tL,isubL,'b-',label='c')

    plotCanvas = FigureCanvasTkAgg(f, pltFrame)
    toolbar = NavigationToolbar2TkAgg(plotCanvas, pltFrame)
    toolbar.pack(side=BOTTOM)
    plotCanvas.get_tk_widget().pack(side=TOP)

Sie haben im Wesentlichen zwei Möglichkeiten:

1. Machen Sie genau das, was Sie gerade tun, aber rufen Sie an graph1.clear()und graph2.clear()bevor Sie die Daten neu plotten. Dies ist die langsamste, aber einfachste und robusteste Option.

2. Anstatt neu zu zeichnen, können Sie einfach die Daten der Plotobjekte aktualisieren. Sie müssen einige Änderungen an Ihrem Code vornehmen, aber dies sollte viel, viel schneller sein, als jedes Mal Dinge neu zu zeichnen. Die Form der Daten, die Sie zeichnen, kann sich jedoch nicht ändern. Wenn sich der Bereich Ihrer Daten ändert, müssen Sie die Grenzwerte für die x- und y-Achse manuell zurücksetzen.

Um ein Beispiel für die zweite Option zu geben:

import matplotlib.pyplot as plt
import numpy as np

x = np.linspace(0, 6*np.pi, 100)
y = np.sin(x)

# You probably won't need this if you're embedding things in a tkinter plot...
plt.ion()

fig = plt.figure()
ax = fig.add_subplot(111)
line1, = ax.plot(x, y, 'r-') # Returns a tuple of line objects, thus the comma

for phase in np.linspace(0, 10*np.pi, 500):
    line1.set_ydata(np.sin(x + phase))
    fig.canvas.draw()
    fig.canvas.flush_events()

Sie können auch Folgendes tun: Dadurch werden 10x1-Zufallsmatrixdaten für 50 Zyklen der for-Schleife auf dem Plot gezeichnet.

import matplotlib.pyplot as plt
import numpy as np

plt.ion()
for i in range(50):
    y = np.random.random([10,1])
    plt.plot(y)
    plt.draw()
    plt.pause(0.0001)
    plt.clf()

Das hat bei mir funktioniert. Ruft wiederholt eine Funktion auf, die das Diagramm jedes Mal aktualisiert.

import matplotlib.pyplot as plt
import matplotlib.animation as anim

def plot_cont(fun, xmax):
    y = []
    fig = plt.figure()
    ax = fig.add_subplot(1,1,1)

    def update(i):
        yi = fun()
        y.append(yi)
        x = range(len(y))
        ax.clear()
        ax.plot(x, y)
        print i, ': ', yi

    a = anim.FuncAnimation(fig, update, frames=xmax, repeat=False)
    plt.show()

"fun" ist eine Funktion, die eine Ganzzahl zurückgibt. FuncAnimation ruft wiederholt "update" auf, dies geschieht "xmax" mal.

Für den Fall, dass jemand auf diesen Artikel stößt und nach dem sucht, wonach ich gesucht habe, habe ich Beispiele unter gefunden

Wie visualisiere ich skalare 2D-Daten mit Matplotlib?

und

http://mri.brechmos.org/2009/07/automatically-update-a-figure-in-a-loop (auf web.archive.org)

Ändern Sie sie dann so, dass sie imshow mit einem Eingabestapel von Frames verwenden, anstatt Konturen im laufenden Betrieb zu generieren und zu verwenden.

Beginnend mit einem 3D-Array von Formbildern (nBins, nBins, nBins), genannt frames.

def animate_frames(frames):
    nBins   = frames.shape[0]
    frame   = frames[0]
    tempCS1 = plt.imshow(frame, cmap=plt.cm.gray)
    for k in range(nBins):
        frame   = frames[k]
        tempCS1 = plt.imshow(frame, cmap=plt.cm.gray)
        del tempCS1
        fig.canvas.draw()
        #time.sleep(1e-2) #unnecessary, but useful
        fig.clf()

fig = plt.figure()
ax  = fig.add_subplot(111)

win = fig.canvas.manager.window
fig.canvas.manager.window.after(100, animate_frames, frames)

Ich habe auch einen viel einfacheren Weg gefunden, um diesen ganzen Prozess durchzuführen, wenn auch weniger robust:

fig = plt.figure()

for k in range(nBins):
    plt.clf()
    plt.imshow(frames[k],cmap=plt.cm.gray)
    fig.canvas.draw()
    time.sleep(1e-6) #unnecessary, but useful

Beachten Sie, dass beide nur funktionieren ipython --pylab=tk, auch bekannt alsbackend = TkAgg

Vielen Dank für die Hilfe bei allem.

Ich habe ein Paket namens python-drawow veröffentlicht , das Funktionen zum Aktualisieren einer Figur bietet, die normalerweise in einer for-Schleife aufgerufen werden, ähnlich wie bei Matlabdrawnow .

Ein Anwendungsbeispiel:

from pylab import figure, plot, ion, linspace, arange, sin, pi
def draw_fig():
    # can be arbitrarily complex; just to draw a figure
    #figure() # don't call!
    plot(t, x)
    #show() # don't call!

N = 1e3
figure() # call here instead!
ion()    # enable interactivity
t = linspace(0, 2*pi, num=N)
for i in arange(100):
    x = sin(2 * pi * i**2 * t / 100.0)
    drawnow(draw_fig)

Dieses Paket funktioniert mit jeder matplotlib-Figur und bietet Optionen zum Warten nach jeder Figurenaktualisierung oder zum Ablegen im Debugger.

All dies mag zutreffen, aber für mich funktioniert die "Online-Aktualisierung" von Zahlen nur mit einigen Backends, insbesondere wx. Sie könnten versuchen, dies zu ändern, z. B. indem Sie ipython / pylab mit starten ipython --pylab=wx! Viel Glück!

Das hat bei mir funktioniert:

from matplotlib import pyplot as plt
from IPython.display import clear_output
import numpy as np
for i in range(50):
    clear_output(wait=True)
    y = np.random.random([10,1])
    plt.plot(y)
    plt.show()