Comment puis-je tracer en temps réel dans une boucle while l'aide de matplotlib?

Je suis en train de tracer certaines données provenant d'une caméra en temps réel à l'aide d'OpenCV. Cependant, le tracé en temps réel (à l'aide de matplotlib) ne semble pas fonctionner.

J'ai isolé le problème dans cet exemple simple:

fig = plt.figure()
plt.axis([0, 1000, 0, 1])

i = 0
x = list()
y = list()

while i < 1000:
    temp_y = np.random.random()
    x.append(i)
    y.append(temp_y)
    plt.scatter(i, temp_y)
    i += 1
    plt.show()

Je m'attends à ce que cet exemple parcelle de 1000 points individuellement. Ce qui se passe réellement est que la fenêtre pop-up s'ouvre avec le premier point marquant (ok avec ça), puis attend la boucle se termine avant qu'il remplit le reste du graphe.

Pensées, pourquoi je ne suis pas le voir points peuplée à la fois?

InformationsquelleAutor Chris | 2012-08-08

268

Voici la version de travail du code en question (nécessite au moins la version Matplotlib 1.1.0 de 2011-11-14):
```
import numpy as np
import matplotlib.pyplot as plt

plt.axis([0, 10, 0, 1])

for i in range(10):
    y = np.random.random()
    plt.scatter(i, y)
    plt.pause(0.05)

plt.show()
```
Noter certains changements:
1. Appel plt.pause(0.05) pour dessiner les nouvelles données et qu'il exécute la GUI boucle d'évènements (permettant l'interaction de la souris).
- Cela a fonctionné pour moi en Python2. En Python3, il n'a pas. Il met en pause la boucle après le rendu de la fenêtre du tracé. Mais après le déplacement de la plt.méthode show() d'après la boucle... il résolu pour Python3, pour moi.
- Bizarre, a travaillé très bien pour moi en Python 3 (version 3.4.0) Matplotlib (version 1.3.1) Numpy (version 1.8.1) Ubuntu Linux 3.13.0 64-bit
- cela ne fonctionne pas avec ipython='2.1.0', matplotlib='1.3.1'. l'intrigue se coince
- au lieu de plt.show() et plt.draw() il suffit de remplacer plt.draw() avec le plt.pause(0.1)
- Ne fonctionne pas sur Win64/Anaconda matplotlib.__version__ 1.5.0. Une première figure de la fenêtre ouverte, mais ne pas afficher quoi que ce soit, il est resté dans un état bloqué jusqu'à ce que je l'ai fermé
- concernant plt.pause() vs plt.draw() et time.sleep(0.05): dessiner/sommeil attire toujours de la parcelle, mais à l'aide de tirage/le sommeil empêche choses comme la souris redimensionner la fenêtre, de la souris zoom, bouton d'événements, toute l'interaction de la souris, etc.
- Cette réponse nécessite une connaissance a priori des données x/y... qui n'est pas nécessaire: je préfère le 1. ne l'appelez pas plt.axis() mais au lieu de créer deux listes x et y et appelez plt.plot(x,y) 2. dans votre boucle, ajouter les nouvelles valeurs des données pour les deux listes 3. appel plt.gca().lines[0].set_xdata(x); plt.gca().lines[0].set_ydata(y); plt.gca().relim(); plt.gca().autoscale_view(); plt.pause(0.05);
- avec ipython 4.0.0 et matplotlib 1.5.1 de copier et de coller ce code ne fonctionne pas pour moi.
- plt.pause() n'est pas un choix judicieux, car il déclenche une pleine draw(). Utilisation time.sleep() avec canvas.flush_events() est beaucoup mieux.
- Je voudrais remplacer la dernière boucle while, c'est à dire while True: plt.pause(0.5), avec plt.ioff(); plt.show().
InformationsquelleAutor Velimir M.
67

Si vous êtes intéressé en temps réel complot, je vous recommande de regarder dans matplotlib d'animation de l'API. En particulier, en utilisant blit pour éviter de redessiner l'arrière-plan sur chaque image peut vous donner de substantiels gains de vitesse (~10x):
```
#!/usr/bin/env python
import numpy as np
import time
import matplotlib
matplotlib.use('GTKAgg')
from matplotlib import pyplot as plt
def randomwalk(dims=(256, 256), n=20, sigma=5, alpha=0.95, seed=1):
""" A simple random walk with memory """
r, c = dims
gen = np.random.RandomState(seed)
pos = gen.rand(2, n) * ((r,), (c,))
old_delta = gen.randn(2, n) * sigma
while True:
delta = (1. - alpha) * gen.randn(2, n) * sigma + alpha * old_delta
pos += delta
for ii in xrange(n):
if not (0. <= pos[0, ii] < r):
pos[0, ii] = abs(pos[0, ii] % r)
if not (0. <= pos[1, ii] < c):
pos[1, ii] = abs(pos[1, ii] % c)
old_delta = delta
yield pos
def run(niter=1000, doblit=True):
"""
Display the simulation using matplotlib, optionally using blit for speed
"""
fig, ax = plt.subplots(1, 1)
ax.set_aspect('equal')
ax.set_xlim(0, 255)
ax.set_ylim(0, 255)
ax.hold(True)
rw = randomwalk()
x, y = rw.next()
plt.show(False)
plt.draw()
if doblit:
# cache the background
background = fig.canvas.copy_from_bbox(ax.bbox)
points = ax.plot(x, y, 'o')[0]
tic = time.time()
for ii in xrange(niter):
# update the xy data
x, y = rw.next()
points.set_data(x, y)
if doblit:
# restore background
fig.canvas.restore_region(background)
# redraw just the points
ax.draw_artist(points)
# fill in the axes rectangle
fig.canvas.blit(ax.bbox)
else:
# redraw everything
fig.canvas.draw()
plt.close(fig)
print "Blit = %s, average FPS: %.2f" % (
str(doblit), niter / (time.time() - tic))
if __name__ == '__main__':
run(doblit=False)
run(doblit=True)
```
De sortie:
```
Blit = False, average FPS: 54.37
Blit = True, average FPS: 438.27
```
- C'est joli, mais où avez-vous fait appel à "montrer" ou l'affichage du graphique?
- La version originale a été conçu pour fonctionner à l'intérieur d'un interactive matplotlib session. Pour le faire fonctionner comme un script autonome, il est nécessaire d'1) sélectionner explicitement un backend pour matplotlib, et 2) à la force de la figure pour être affiché et dessiné avant d'entrer dans la boucle d'animation à l'aide de plt.show() et plt.draw(). J'ai ajouté ces modifications dans le code ci-dessus.
- Génial, merci! Je vais à mâcher sur ce temps. J'ai plusieurs axes et les plages axe sont également en train de changer.
- Est l'intention et la motivation de l' blit() semble très bien être "améliorer le tracé en temps réel"? Si vous avez un matplotlib développeur/blog discuter le pourquoi/but/intention/la motivation, ce qui serait formidable. (on dirait que cette nouvelle blit opération serait de convertir Matplotlib à partir de seulement utiliser en mode hors connexion ou très lentement de la modification des données à maintenant, vous pouvez utiliser Matplotlib avec une très rapide mise à jour des données... presque comme un oscilloscope).
- J'ai trouvé que cette approche rend l'intrigue de la fenêtre ne répond pas: je ne peux pas interagir avec elle, et vous risqueriez de crash.
- 'FigureCanvasMac' objet n'a pas d'attribut "copy_from_bbox'
- Pour ceux qui se "gtk n'est pas trouvé" problème, il fonctionne très bien avec un autre back-end (j'ai utilisé "TKAgg'). Trouver un appui soutenu, j'ai utilisé cette solution: stackoverflow.com/questions/3285193/...
- Le lien dans cette réponse ne semble pas fonctionner. Cela peut être une mise à jour lien: scipy-livre de recettes.readthedocs.io/articles/...
InformationsquelleAutor ali_m
33

show est probablement pas le meilleur choix pour ce. Ce que je voudrais faire est d'utiliser pyplot.draw() à la place. Vous pouvez également inclure un petit temps de retard (par exemple, time.sleep(0.05)) dans la boucle de sorte que vous pouvez voir les parcelles qui se passe. Si je fais ces changements à votre exemple, il fonctionne pour moi et je vois chaque point figurant à la fois.
- J'ai très similaire à la partie de code, et quand j'ai essayer votre solution (tirage au sort au lieu de spectacle et de temps de retard) python n'a pas ouvert une figure de la fenêtre, tout va de travers la boucle...
InformationsquelleAutor BrenBarn
29

Aucune des méthodes qui ont fonctionné pour moi.
Mais j'ai trouvé que c'
Temps réel matplotlib intrigue n'est pas de travail tout en restant dans une boucle

Tous vous avez besoin est d'ajouter
```
plt.pause(0.0001)
```
et que vous avez pu voir de la nouvelle parcelle.

De sorte que votre code devrait ressembler à ceci, et il va travailler
```
import matplotlib.pyplot as plt
import numpy as np
plt.ion() ## Note this correction
fig=plt.figure()
plt.axis([0,1000,0,1])
i=0
x=list()
y=list()
while i <1000:
temp_y=np.random.random();
x.append(i);
y.append(temp_y);
plt.scatter(i,temp_y);
i+=1;
plt.show()
plt.pause(0.0001) #Note this correction
```
- Cela ouvre une nouvelle figure / la fenêtre du tracé à chaque fois pour moi est-il un moyen pour mettre à jour l'existant figure ? c'est peut-être parce que je suis avec imshow ?
- si vous utilisez imshow, vous devez utiliser set_data, regarde ici: stackoverflow.com/questions/17835302/...
InformationsquelleAutor Oren

Je sais que je suis un peu en retard pour répondre à cette question. Néanmoins, j'ai fait un peu de code il y a un moment pour tracer des graphiques en direct, que j'aimerais partager:

###################################################################
#                                                                 #
#                     PLOTTING A LIVE GRAPH                       #
#                  ----------------------------                   #
#            EMBED A MATPLOTLIB ANIMATION INSIDE YOUR             #
#            OWN GUI!                                             #
#                                                                 #
###################################################################
import sys
import os
from PyQt4 import QtGui
from PyQt4 import QtCore
import functools
import numpy as np
import random as rd
import matplotlib
matplotlib.use("Qt4Agg")
from matplotlib.figure import Figure
from matplotlib.animation import TimedAnimation
from matplotlib.lines import Line2D
from matplotlib.backends.backend_qt4agg import FigureCanvasQTAgg as FigureCanvas
import time
import threading
def setCustomSize(x, width, height):
sizePolicy = QtGui.QSizePolicy(QtGui.QSizePolicy.Fixed, QtGui.QSizePolicy.Fixed)
sizePolicy.setHorizontalStretch(0)
sizePolicy.setVerticalStretch(0)
sizePolicy.setHeightForWidth(x.sizePolicy().hasHeightForWidth())
x.setSizePolicy(sizePolicy)
x.setMinimumSize(QtCore.QSize(width, height))
x.setMaximumSize(QtCore.QSize(width, height))
''''''
class CustomMainWindow(QtGui.QMainWindow):
def __init__(self):
super(CustomMainWindow, self).__init__()
# Define the geometry of the main window
self.setGeometry(300, 300, 800, 400)
self.setWindowTitle("my first window")
# Create FRAME_A
self.FRAME_A = QtGui.QFrame(self)
self.FRAME_A.setStyleSheet("QWidget { background-color: %s }" % QtGui.QColor(210,210,235,255).name())
self.LAYOUT_A = QtGui.QGridLayout()
self.FRAME_A.setLayout(self.LAYOUT_A)
self.setCentralWidget(self.FRAME_A)
# Place the zoom button
self.zoomBtn = QtGui.QPushButton(text = 'zoom')
setCustomSize(self.zoomBtn, 100, 50)
self.zoomBtn.clicked.connect(self.zoomBtnAction)
self.LAYOUT_A.addWidget(self.zoomBtn, *(0,0))
# Place the matplotlib figure
self.myFig = CustomFigCanvas()
self.LAYOUT_A.addWidget(self.myFig, *(0,1))
# Add the callbackfunc to ..
myDataLoop = threading.Thread(name = 'myDataLoop', target = dataSendLoop, daemon = True, args = (self.addData_callbackFunc,))
myDataLoop.start()
self.show()
''''''
def zoomBtnAction(self):
print("zoom in")
self.myFig.zoomIn(5)
''''''
def addData_callbackFunc(self, value):
# print("Add data: " + str(value))
self.myFig.addData(value)
''' End Class '''
class CustomFigCanvas(FigureCanvas, TimedAnimation):
def __init__(self):
self.addedData = []
print(matplotlib.__version__)
# The data
self.xlim = 200
self.n = np.linspace(0, self.xlim - 1, self.xlim)
a = []
b = []
a.append(2.0)
a.append(4.0)
a.append(2.0)
b.append(4.0)
b.append(3.0)
b.append(4.0)
self.y = (self.n * 0.0) + 50
# The window
self.fig = Figure(figsize=(5,5), dpi=100)
self.ax1 = self.fig.add_subplot(111)
# self.ax1 settings
self.ax1.set_xlabel('time')
self.ax1.set_ylabel('raw data')
self.line1 = Line2D([], [], color='blue')
self.line1_tail = Line2D([], [], color='red', linewidth=2)
self.line1_head = Line2D([], [], color='red', marker='o', markeredgecolor='r')
self.ax1.add_line(self.line1)
self.ax1.add_line(self.line1_tail)
self.ax1.add_line(self.line1_head)
self.ax1.set_xlim(0, self.xlim - 1)
self.ax1.set_ylim(0, 100)
FigureCanvas.__init__(self, self.fig)
TimedAnimation.__init__(self, self.fig, interval = 50, blit = True)
def new_frame_seq(self):
return iter(range(self.n.size))
def _init_draw(self):
lines = [self.line1, self.line1_tail, self.line1_head]
for l in lines:
l.set_data([], [])
def addData(self, value):
self.addedData.append(value)
def zoomIn(self, value):
bottom = self.ax1.get_ylim()[0]
top = self.ax1.get_ylim()[1]
bottom += value
top -= value
self.ax1.set_ylim(bottom,top)
self.draw()
def _step(self, *args):
# Extends the _step() method for the TimedAnimation class.
try:
TimedAnimation._step(self, *args)
except Exception as e:
self.abc += 1
print(str(self.abc))
TimedAnimation._stop(self)
pass
def _draw_frame(self, framedata):
margin = 2
while(len(self.addedData) > 0):
self.y = np.roll(self.y, -1)
self.y[-1] = self.addedData[0]
del(self.addedData[0])
self.line1.set_data(self.n[ 0 : self.n.size - margin ], self.y[ 0 : self.n.size - margin ])
self.line1_tail.set_data(np.append(self.n[-10:-1 - margin], self.n[-1 - margin]), np.append(self.y[-10:-1 - margin], self.y[-1 - margin]))
self.line1_head.set_data(self.n[-1 - margin], self.y[-1 - margin])
self._drawn_artists = [self.line1, self.line1_tail, self.line1_head]
''' End Class '''
# You need to setup a signal slot mechanism, to 
# send data to your GUI in a thread-safe way.
# Believe me, if you don't do this right, things
# go very very wrong..
class Communicate(QtCore.QObject):
data_signal = QtCore.pyqtSignal(float)
''' End Class '''
def dataSendLoop(addData_callbackFunc):
# Setup the signal-slot mechanism.
mySrc = Communicate()
mySrc.data_signal.connect(addData_callbackFunc)
# Simulate some data
n = np.linspace(0, 499, 500)
y = 50 + 25*(np.sin(n / 8.3)) + 10*(np.sin(n / 7.5)) - 5*(np.sin(n / 1.5))
i = 0
while(True):
if(i > 499):
i = 0
time.sleep(0.1)
mySrc.data_signal.emit(y[i]) # <- Here you emit a signal!
i += 1
###
###
if __name__== '__main__':
app = QtGui.QApplication(sys.argv)
QtGui.QApplication.setStyle(QtGui.QStyleFactory.create('Plastique'))
myGUI = CustomMainWindow()
sys.exit(app.exec_())
''''''

Il suffit de l'essayer. Copiez-collez ce code dans un nouveau python-fichier et exécutez-le. Vous devriez obtenir un beau, fluide en mouvement graphique:

Comment puis-je tracer en temps réel dans une boucle while l'aide de matplotlib?

J'ai remarqué que le dataSendLoop fil restent en cours d'exécution en arrière-plan lorsque vous fermez la fenêtre. J'ai donc ajouté le daemon = True mot-clé pour résoudre ce problème.
L'environnement virtuel pour cela a pris un peu de travail. Enfin, conda install pyqt=4 a fait le tour.
Merci beaucoup pour le code de base. Il m'a aidé à constituer une INTERFACE utilisateur simple par la modification et l'ajout de fonctionnalités autour de la base de votre code. Il a sauvé mon temps = ]
Salut @IsaacSim, je vous remercie beaucoup pour votre gentil message. Je suis heureux que ce code a été très utile 🙂
Il semble que PyQt4 ne fonctionne que sur Windows.

InformationsquelleAutor K.Mulier

16

Le haut (et beaucoup d'autres) les réponses ont été construits sur plt.pause(), mais c'était une vieille façon de l'animation de l'intrigue dans matplotlib. Il est non seulement lente, mais aussi les causes de se concentrer à être saisi à chaque mise à jour (j'ai eu un temps d'arrêt dur le tracé python processus).

TL;DR: vous souhaiterez peut-être utiliser matplotlib.animation (comme mentionné dans la documentation).

Après avoir creusé autour de diverses réponses et des morceaux de code, c'est en fait avéré être un bon moyen d'attirer les données entrantes à l'infini pour moi.

Voici mon code pour un démarrage rapide. Il marque heure actuelle avec un nombre au hasard dans [0, 100) toutes les 200ms à l'infini, tout en également la manipulation automatique de mise à l'échelle de la vue:
```
from datetime import datetime
from matplotlib import pyplot
from matplotlib.animation import FuncAnimation
from random import randrange
x_data, y_data = [], []
figure = pyplot.figure()
line, = pyplot.plot_date(x_data, y_data, '-')
def update(frame):
x_data.append(datetime.now())
y_data.append(randrange(0, 100))
line.set_data(x_data, y_data)
figure.gca().relim()
figure.gca().autoscale_view()
return line,
animation = FuncAnimation(figure, update, interval=200)
pyplot.show()
```
Vous pouvez aussi explorer blit pour de meilleures performances, même comme dans FuncAnimation documentation.

Un exemple de la blit documentation:
```
import numpy as np
import matplotlib.pyplot as plt
from matplotlib.animation import FuncAnimation
fig, ax = plt.subplots()
xdata, ydata = [], []
ln, = plt.plot([], [], 'ro')
def init():
ax.set_xlim(0, 2*np.pi)
ax.set_ylim(-1, 1)
return ln,
def update(frame):
xdata.append(frame)
ydata.append(np.sin(frame))
ln.set_data(xdata, ydata)
return ln,
ani = FuncAnimation(fig, update, frames=np.linspace(0, 2*np.pi, 128),
init_func=init, blit=True)
plt.show()
```
- Salut, ce qui va se passer si c'était tout dans une boucle. dire for i in range(1000): x,y = some func_func(). Ici some_func() génère en ligne x,y les paires de données, dont je voudrais parcelle une fois qu'ils sont disponibles. Est-il possible de faire cela avec FuncAnimation. Mon objectif est de construire la courbe définie par les données, étape par étape, à chaque itération.
- Le Cska pyploy.show() devrait bloquer. Si vous souhaitez ajouter des données, de les récupérer et de mettre à jour le update fonction.
- Je crains que je ne comprends pas vraiment votre réponse. Souhaitez-vous renforcer votre suggestion s'il vous plaît.
- Je veux dire, si vous appelez pyplot.show dans une boucle, la boucle sera bloqué par le présent appel et ne va pas continuer. Si vous souhaitez ajouter des données à la courbe, étape par étape, mettez votre logique à update, qui sera appelée à chaque interval donc c'est aussi une étape-par-étape.
InformationsquelleAutor Dreaming in Code
12

Je sais que cette question est ancienne, mais maintenant il y en a un paquet appelé drawnow sur GitHub comme "python-drawnow". Cela fournit une interface similaire à MATLAB drawnow -- vous pouvez facilement mise à jour d'une figure.

Un exemple pour votre cas d'utilisation:
```
import matplotlib.pyplot as plt
from drawnow import drawnow
def make_fig():
plt.scatter(x, y)  # I think you meant this
plt.ion()  # enable interactivity
fig = plt.figure()  # make a figure
x = list()
y = list()
for i in range(1000):
temp_y = np.random.random()
x.append(i)
y.append(temp_y)  # or any arbitrary update to your figure's data
i += 1
drawnow(make_fig)
```
python-drawnow est une fine enveloppe plt.draw mais offre la possibilité de confirmer (ou debug) après la figure d'affichage.
- Cela rend les savoirs traditionnels accrocher quelque part
- Si oui, fichier un problème avec le contexte plus github.com/scottsievert/python-drawnow/issues
- +1 Cela a fonctionné pour moi pour le traçage des données en direct par image de capture vidéo à partir d'opencv, tandis que matplotlib gelé.
- Je l'ai essayé et il semblait plus lent que les autres méthodes.
InformationsquelleAutor Scott
5

Le problème semble être que vous attendez plt.show() pour afficher la fenêtre, puis de revenir. Il ne le fait pas. Le programme s'arrête à ce point et ne reprendra qu'une fois que vous fermez la fenêtre. Vous devriez être capable de test: Si vous fermez la fenêtre, puis une autre fenêtre devrait apparaître.

Pour résoudre le problème viens de l'appeler plt.show() une fois après votre boucle. Alors vous procurer l'intégralité de la parcelle. (Mais pas un "tracé en temps réel')

Vous pouvez essayer le réglage de la clé argument block comme ceci: plt.show(block=False) une fois au début et ensuite utiliser .draw() de mise à jour.
- tracé en temps réel est vraiment ce que je vais faire. Je vais être en cours d'exécution à 5 heures de test sur quelque chose et vous voulez voir comment les choses avancent.
- avez-vous été en mesure de mener les 5 heures de test? Je suis également à la recherche de quelque chose de similaire. Je suis à l'aide de plyplot.pause(time_duration) pour mettre à jour le complot. Est-il un autre moyen pour le faire?
InformationsquelleAutor Michael Mauderer

Voici une version que j'ai eu à travailler sur mon système.

import matplotlib.pyplot as plt
from drawnow import drawnow
import numpy as np
def makeFig():
plt.scatter(xList,yList) # I think you meant this
plt.ion() # enable interactivity
fig=plt.figure() # make a figure
xList=list()
yList=list()
for i in np.arange(50):
y=np.random.random()
xList.append(i)
yList.append(y)
drawnow(makeFig)
#makeFig()      The drawnow(makeFig) command can be replaced
#plt.draw()     with makeFig(); plt.draw()
plt.pause(0.001)

La drawnow(makeFig) ligne peut être remplacé par un makeFig(); plt.draw() de la séquence et il fonctionne toujours OK.

Comment savez-vous combien de temps de pause? Il semble dépendre de l'intrigue elle-même.

InformationsquelleAutor slehar

Si vous voulez tirer et de ne pas geler votre fil que d'autres point sont établis, vous devez utiliser plt.pause() pas de temps.sleep()

im en utilisant le code suivant à l'intrigue d'une série de coordonnées xy.

import matplotlib.pyplot as plt 
import math
pi = 3.14159
fig, ax = plt.subplots()
x = []
y = []
def PointsInCircum(r,n=20):
circle = [(math.cos(2*pi/n*x)*r,math.sin(2*pi/n*x)*r) for x in xrange(0,n+1)]
return circle
circle_list = PointsInCircum(3, 50)
for t in range(len(circle_list)):
if t == 0:
points, = ax.plot(x, y, marker='o', linestyle='--')
ax.set_xlim(-4, 4) 
ax.set_ylim(-4, 4) 
else:
x_coord, y_coord = circle_list.pop()
x.append(x_coord)
y.append(y_coord)
points.set_data(x, y)
plt.pause(0.01)

InformationsquelleAutor user2672474

Vous devez vous connecter pour publier un commentaire.