python - font - ¿Cómo actualizar una parcela en matplotlib?

matplotlib title position

Question

Tengo problemas para volver a dibujar la figura aquí. Permito al usuario especificar las unidades en la escala de tiempo (eje x) y luego recalculo y llamo a esta función plots() . Quiero que el argumento simplemente actualice, no agregue otro diagrama a la figura.

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)

Answer 1

En caso de que alguien se encuentre con este artículo buscando lo que estaba buscando, encontré ejemplos en

¿Cómo visualizar datos 2D escalares con Matplotlib?

y

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

luego los modificó para usar imshow con una pila de marcos de entrada, en lugar de generar y usar contornos sobre la marcha.

Comenzando con una matriz tridimensional de imágenes de forma (nBins, nBins, nBins), llamadas 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)

También encontré una manera mucho más simple de llevar a cabo todo este proceso, aunque menos robusto:

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

Tenga en cuenta que ambos parecen funcionar solo con ipython --pylab=tk , aka backend = TkAgg

Gracias por la ayuda con todo.

Answer 2

Esto funcionó para mí. Repetidamente llama a una función actualizando el gráfico cada vez.

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

"diversión" es una función que devuelve un número entero. FuncAnimation repetidamente llamará "actualización", hará ese "xmax" veces.

Answer 3

He lanzado un paquete llamado python-drawnow que proporciona funcionalidad para permitir actualizar una figura, normalmente llamada dentro de un bucle for, similar al drawnow de Matlab.

Un ejemplo de uso:

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)

Este paquete funciona con cualquier figura de matplotlib y proporciona opciones para esperar después de cada actualización de figura o caer en el depurador.

Answer 4

También puede hacer lo siguiente: Esto dibujará datos de matriz aleatoria de 10x1 en la gráfica para 50 ciclos del bucle for.

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

Answer 5

Todo lo anterior puede ser cierto, sin embargo, para mí la "actualización en línea" de las cifras solo funciona con algunos backends, específicamente wx . Puede tratar de cambiar a esto, por ejemplo, al iniciar ipython / pylab por ipython --pylab=wx ! ¡Buena suerte!

Answer 6

Usted esencialmente tiene dos opciones:

1. Haga exactamente lo que está haciendo actualmente, pero llame a graph1.clear() y graph2.clear() antes de volver a copiar los datos. Esta es la opción más lenta, pero más simple y más robusta.

2. En lugar de redirigir, puede actualizar los datos de los objetos de la trama. Tendrá que hacer algunos cambios en su código, pero esto debería ser mucho, mucho más rápido que repetir las cosas todo el tiempo. Sin embargo, la forma de los datos que está trazando no puede cambiar, y si el rango de sus datos está cambiando, tendrá que restablecer manualmente los límites del eje xey.

Para dar un ejemplo de la segunda opción:

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

Answer 7

import csv
import sys
import getopt
import socket
import time
import numpy as np
import matplotlib
from scipy.misc import imread
from matplotlib import pyplot as plt
import warnings
fig, ax = plt.subplots()
ax.set_xlim(-158, 553)
ax.set_ylim(-290, 733)
im = plt.imread("")
plt.imshow(img, zorder=0, extent=[0.5, 8.0, 1.0, 7.0])

fig.show()
l_global=[]
points=[]
master_tag_csvlink=''c:/logfolde.log.csv''
csvfile=open(master_tag_csvlink, ''r'')
for ainfo in csvfile:
        line= ainfo
        l_list= list(line.split(''_''))
        l_local=[]
        for i in range(int(l_list[0])):
            l_local.append(list(l_list[i+1].split('','')))
        function1= lambda x,i: x[i] # return list[n,X] of elements at x
        c= lambda x,l: [x for i in range(l) if True]
        for i in range(len(l_local)):
            l_local[i][1],l_local[i][2]=int(l_local[i][1]),int(l_local[i][2])

        if l_global: #In begining l_glocal is empty, so just copy the data in to l_global
            l_global=l_local[:]
            for i in range(len(l_global)):
                points.append(plt.plot(function1(l_global[i],1),function1(l_global[i],2),''g'',label="Tag:%s, X:%f, y: %f"%(function1(l_global[i],0),function1(l_global[i],1),function1(l_global[i],2))))



        else: # compare the l_local & l_global for any updates 
            tag_Id=map(function1,l_local,c(0,len(l_local))) #list of list of tagId,x,y TagId is filtered - local
            mTag_Id=map(fuction1,l_global,c(0,len(l_global))) #list of list of tagId,x,y TagId is filtered - master

            for i in mTag_Id: 
                if i not in tag_Id: #comparing master tags and tag_Id''s
                    index=mTag_Id.index(i) ###############  Tags in master list but not in Tag_id
                    copy_point=l_global[index]
                    [removing_point]=points[index]########  means tag is in-active ,turn tag color into red
                    removing_point.remove()
                    del points[index]

                    points.insert(index,plt.plot(function1(l_global[index],1),function1(l_global[index],2),''r'',label="Tag:%s, X:%f, y: %f"%(function1(l_global[i],0),function1(l_global[i],1),function1(l_global[i],2))))

                elif i in tag_Id: # append the tag into l_global
                    index=mTag_Id.index(i) ###############  Tags in master list but not in Tag_id
                    l_global[index]=l_local[index][:]
                    [removing_point]=points[index]########  means tag is active update coordinates
                    removing_point.remove()
                    del points[index]
                    points.insert(index,plt.plot(function1(l_global[index],1),function1(l_global[index],2),''g'',label="Tag:%s, X:%f, y: %f"%(function1(l_global[i],0),function1(l_global[i],1),function1(l_global[i],2))))
            for i in Tag_Id:
                if i not in mTag_Id:
                    index=Tag_Id(i)
                    l_global.append(l_local[index]]
                    points.append(plt.plot(function1(l_global[-1],1),function1(l_global[-1],2),''g'',label="Tag:%s, X:%f, y: %f"%(function1(l_global[i],0),function1(l_global[i],1),function1(l_global[i],2))))

# 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(11)1
# 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()