examples - wxpython python 3

¿Cuál es el mejor widget de trazado en tiempo real para wxPython?

Question

Me gustaría mostrar un gráfico en tiempo real con una o dos curvas de hasta 50 muestras por segundo usando Python y wxPython. El widget debería ser compatible con plataformas Win32 y Linux.

Cualquier sugerencia es bienvenida.

Editado para agregar:

No necesito actualizar la pantalla a 50 fps, pero necesito mostrar hasta 50 muestras de datos en ambas curvas, con una tasa de actualización razonable para la pantalla (5.10 fps deberían estar bien).

Editado para agregar:

He usado mathplotlib en un proyecto con buen éxito. Luego me conformé con wx.lib.plot para otros proyectos, que encontré más simple, pero algo más fácil de usar y consumiendo menos ciclos de CPU. Como wx.lib viene como parte del estándar, la distribución de wxPython es particularmente fácil de usar.

Answer 1

No es difícil crear un widget C ++ que lea de su fuente de datos y realmente actualice a 50 FPS. Lo bueno de este enfoque es que muy poco (si es que hay alguno) código de Python se ejecutaría a 50FPS, todo estaría en C ++, dependiendo de cómo le entregue sus datos actualizados al widget.

Incluso podría insertar un controlador de eventos en el visor de datos personalizado en tiempo real desde el lado de Python, para manejar todos los eventos del mouse y la interacción del usuario, y dejar solo el renderizado en C ++.

Sería una pequeña clase de C ++ que amplía la clase wxWindow de wxWidget

clase RealtimeDataViewer: public wxWindow {...

y anula OnPaint

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

Luego obtendría un contexto de dispositivo, y comenzaría a dibujar líneas y formas ...

Tendría que tomar el archivo .h, copiarlo en .i y modificarlo un poco para que sea una definición que SWIG pueda usar para extender wxPython.

El proceso de compilación podría ser manejado por los propios distutils de Python usando el siguiente parámetro para configurar:

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

Sería de unos días de trabajo para que se vea bien y funcione bien ... Pero es probable que sea la única opción que realmente acelere su proyecto en el futuro.

Y todo esto funciona bien en Mac, Windows y Linux.

wxPython es realmente una Gema oculta que realmente tomaría el control del mundo con herramientas IDE / diseñador más compatibles.

Dicho esto, pruebe matplotlib primero, tiene muchas representaciones optimizadas y hermosas, y también puede hacer actualizaciones en tiempo real.

Answer 2

¿Quizás Chaco ? No sé si puede hacer 50 fotogramas por segundo, pero vi en una demostración cómo hizo un trazado en tiempo real muy suave. Definitivamente debería ser más rápido que matplotlib.

Answer 3

Si desea un alto rendimiento con una huella de código mínima, no busque más allá de la biblioteca de trazados incorporada de Python. No es necesario escribir un código especial C / C ++ o utilizar un paquete de trazado grande para obtener un rendimiento mucho mejor que 50 fps.

El siguiente código desplaza un gráfico de tira de 1000x200 a 400 fps en un dúo Core 2 de 2.2 GHz, 1000 fps en un Core i3 de 3.4 GHz. La "rueda de desplazamiento" de rutina central traza un conjunto de puntos de datos y colores correspondientes en el borde derecho junto con una barra de cuadrícula vertical opcional, luego desplaza el diagrama hacia la izquierda por 1. Para trazar barras de cuadrícula horizontales solo incluirlas en los datos y colores arrays como constantes junto con sus puntos de datos variables.

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

Answer 4

Yo uso PyQtGraph para este tipo de cosas. Es mucho más rápido que Matplotlib para el trazado en tiempo real y tiene muchas características agradables como un menú contextual en el lienzo de trazado con escalado automático y desplazamiento sin ningún trabajo adicional.

Answer 5

Si realmente quieres algo rápido con 50 fotogramas por segundo, creo que necesitas algo como PyGame y tipo de conversación directamente a la pantalla, no un módulo de trazado.

Verifique los hilos relacionados:

• ¿Cuál es la forma más rápida de dibujar una imagen a partir de valores de píxeles discretos en Python?
• https://.com/search?q=python+pygame