Quel est le meilleur tracé en temps réel widget pour wxPython?

Je voudrais afficher un graphique en temps réel avec une ou deux courbes de un jusqu'à 50 échantillons par seconde à l'aide de Python et wxPython.
Le widget devrait soutenir Win32 et Linux.

Tous les conseils sont les bienvenus.

Modifiées afin d'ajouter:

Je n'ai pas besoin de mettre à jour l'affichage à 50 fps, mais besoin de montrer jusqu'à 50 échantillons de données sur les deux courbes, avec une fréquence de mise à jour pour l'écran (5..10 fps devrait être correct).

Modifiées afin d'ajouter:

J'ai utilisé mathplotlib dans un projet avec succès.
J'ai ensuite opté pour wx.lib.parcelle de terrain pour d'autres projets, que j'ai trouvé pour être plus simple, mais un peu plus facile à utiliser et consommer moins de cycles de PROCESSEUR. Comme wx.lib vient dans le cadre de la norme wxPython distribution est particulièrement facile à utiliser.

OriginalL'auteur Ber | 2009-01-19

  1. 15

    Si vous voulez de haute performance avec un minimum d'empreinte de code, ne cherchez pas plus loin que Python intégré au tracé de la bibliothèque tkinter. Pas besoin d'écrire spécial de code C /C++ ou de l'utilisation d'un grand complot paquet pour obtenir des performances bien meilleures que 50 fps.

    Quel est le meilleur tracé en temps réel widget pour wxPython?

    Le code suivant fait défiler un 1000x200 diagramme à bande à 400 fps sur un 2.2 GHz Core 2 duo, 1000 fps sur un 3.4 GHz Core i3. La centrale de routine "scrollstrip" parcelles d'un ensemble de points de données et les couleurs correspondantes sur le bord droit le long avec une option de grille verticale de la barre, puis fait défiler le stripchart à gauche en 1. Pour tracer les horizontales de la grille des bars les inclure dans les données et la couleur des tableaux en tant que constantes le long de avec votre variable de points de données.

    from tkinter import *
import math, random, threading, time
class StripChart:
def __init__(self, root):
self.gf = self.makeGraph(root)
self.cf = self.makeControls(root)
self.gf.pack()
self.cf.pack()
self.Reset()
def makeGraph(self, frame):
self.sw = 1000
self.h = 200
self.top = 2
gf = Canvas(frame, width=self.sw, height=self.h+10,
bg="#002", bd=0, highlightthickness=0)
gf.p = PhotoImage(width=2*self.sw, height=self.h)
self.item = gf.create_image(0, self.top, image=gf.p, anchor=NW)
return(gf)
def makeControls(self, frame):
cf = Frame(frame, borderwidth=1, relief="raised")
Button(cf, text="Run", command=self.Run).grid(column=2, row=2)
Button(cf, text="Stop", command=self.Stop).grid(column=4, row=2)
Button(cf, text="Reset", command=self.Reset).grid(column=6, row=2)
self.fps = Label(cf, text="0 fps")
self.fps.grid(column=2, row=4, columnspan=5)
return(cf)
def Run(self):
self.go = 1
for t in threading.enumerate():
if t.name == "_gen_":
print("already running")
return
threading.Thread(target=self.do_start, name="_gen_").start()
def Stop(self):
self.go = 0
for t in threading.enumerate():
if t.name == "_gen_":
t.join()
def Reset(self):
self.Stop()
self.clearstrip(self.gf.p, '#345')
def do_start(self):
t = 0
y2 = 0
tx = time.time()
while self.go:
y1 = 0.2*math.sin(0.02*math.pi*t)
y2 = 0.9*y2 + 0.1*(random.random()-0.5)
self.scrollstrip(self.gf.p,
(0.25+y1,   0.25, 0.7+y2,   0.6,     0.7,   0.8),
( '#ff4', '#f40', '#4af', '#080', '#0f0', '#080'),
"" if t % 65 else "#088")
t += 1
if not t % 100:
tx2 = time.time()
self.fps.config(text='%d fps' % int(100/(tx2 - tx)))
tx = tx2
#            time.sleep(0.001)
def clearstrip(self, p, color):  # Fill strip with background color
self.bg = color              # save background color for scroll
self.data = None             # clear previous data
self.x = 0
p.tk.call(p, 'put', color, '-to', 0, 0, p['width'], p['height'])
def scrollstrip(self, p, data, colors, bar=""):   # Scroll the strip, add new data
self.x = (self.x + 1) % self.sw               # x = double buffer position
bg = bar if bar else self.bg
p.tk.call(p, 'put', bg, '-to', self.x, 0,
self.x+1, self.h)
p.tk.call(p, 'put', bg, '-to', self.x+self.sw, 0,
self.x+self.sw+1, self.h)
self.gf.coords(self.item, -1-self.x, self.top)  # scroll to just-written column
if not self.data:
self.data = data
for d in range(len(data)):
y0 = int((self.h-1) * (1.0-self.data[d]))   # plot all the data points
y1 = int((self.h-1) * (1.0-data[d]))
ya, yb = sorted((y0, y1))
for y in range(ya, yb+1):                   # connect the dots
p.put(colors[d], (self.x,y))
p.put(colors[d], (self.x+self.sw,y))
self.data = data            # save for next call
def main():
root = Tk()
root.title("StripChart")
app = StripChart(root)
root.mainloop()
main()
    C'est méchant intelligent. 🙂 Merci à vous.

    OriginalL'auteur Dave

  2. 6

    Il n'est pas difficile de créer un C++ widget qui permettrait de lire à partir de votre source de données, et de mettre à jour à 50 FPS. La belle chose à propos de cette approche est que très peu (le cas échéant) code Python serait en cours d'exécution à 50 im /s, il en aurait dans le C++, selon la façon dont vous placez vos mises à jour de données pour le widget.

    Vous pouvez même pousser un gestionnaire d'événement dans la coutume de données en temps réel de la visionneuse de l'Python côté, pour gérer tous les événements de la souris et l'interaction de l'utilisateur, et de laisser uniquement le rendu en C++.

    Ce serait un petit C++ classe qui étend la classe wxWidget de wxWindow classe

    classe RealtimeDataViewer: public wxWindow {
    ...

    et remplacer OnPaint

    void OnPaint(wxPaintEvent &WXUNUSED(event)) {
    ....

    Alors il faudrait obtenir un périphérique de contexte, et de commencer à dessiner des lignes et des formes...

    Il vous faudra alors prendre le .h fichier et le copier .j', et le modifier un peu pour en faire une définition qui RASADE pourraient utiliser pour prolonger wxPython.

    Le processus de construction pourraient être pris en charge par Python propre distutils utiliser le paramètre suivant pour l'installation:

      ext_modules=[Extension('myextension', sources, 
include_dirs=includeDirs
library_dirs=usual_libs,
)],

    Il aurait quelques jours de travail pour obtenir la recherche de grande et de travail bien... Mais c'est probablement la seule option serait vraiment accélérer votre projet dans le futur.

    Et tout cela fonctionne bien sur Mac, Windows et Linux.

    wxPython est vraiment un Joyau caché qui serait vraiment prendre sur le monde avec les plus professionnels des prises en charge IDE /outils du concepteur.

    Cela dit, essayez de matplotlib tout d'abord, il y a beaucoup de belles optimisé le rendu, et peut faire des mises à jour en temps réel aussi.

    Merci. Je suis en train d'essayer d'éviter d'aller "vers le bas" en C++ pour cela. Je n'ai pas besoin de 50 FPS taux de mise à jour, mais je veux afficher des 50 échantillons/s, à un taux de mise à jour (par exemple, 10 im / s ou de l'événement 5fps).
    Comme vous le savez, l'option existe... je pense que matplotlib va faire un travail fantastique avec vos besoins actuels.

    OriginalL'auteur Jim Carroll

  3. 2

    Si vous voulez vraiment quelque chose de rapide avec 50 images par seconde, je pense que vous avez besoin de quelque chose comme PyGame et le type de parler directement à l'affichage, pas un complot module.

    Vérifier que le fils:

    OriginalL'auteur Mapad

  4. 2

    - Je utiliser PyQtGraph pour ce genre de chose. Il est beaucoup plus rapide que Matplotlib en temps réel de traçage et a beaucoup de caractéristiques de commodité comme un menu contextuel dans le tracé de la toile avec de l'auto-scaling et le défilement sans travail supplémentaire.

    OriginalL'auteur Mike

  5. 1

    Peut-être Chaco? Je ne sais pas si il peut faire 50 images par seconde, mais j'ai vu dans une démonstration de la façon dont il l'a fait très lisse de traçage en temps réel. Il devrait certainement être plus rapide que matplotlib.

    chaco est un puissant tracé de l'api, avec beaucoup de fonctionnalités. (flèches dans des graphiques, des marqueurs,etc..). il peut être utilisé à l'intérieur de wxpython trop

    OriginalL'auteur nikow