Mostra l'array NumPy come immagine di aggiornamento continuo con Glumpy

Question

Ho un modello di simulazione in esecuzione in Python utilizzando NumPy e SciPy e produce un array NumPy 2D come output ogni iterazione. Ho visualizzato questo output come immagine usando matplotlib e la funzione imshow. Tuttavia, ho scoperto Glumpy e nella sua pagina di documentazione dice:

Grazie alla shell IPython, glumpy può essere eseguito in modalità interattiva in cui è possibile visualizzare l'aggiornamento in tempo reale negli array visualizzati quando il loro contenuto viene modificato .

Tuttavia, non riesco a capire come farlo con gli esempi che hanno fornito. Fondamentalmente il mio modello funziona come una singola funzione che ha un grande ciclo in loop per il numero di iterazioni che sto eseguendo. Alla fine di ogni iterazione del ciclo for voglio visualizzare l'array. Al momento sto usando matplotlib per salvare l'immagine in un file png, poiché la visualizzazione sullo schermo tramite matplotlib sembra bloccare il processo python.

Sono sicuro che c'è un modo per farlo con Glumpy, non sono sicuro di come, e non riesco a trovare alcun tutorial utile.

Answer 1

La documentazione di Glumpy è abbastanza inesistente! Ecco un esempio di una semplice simulazione, confrontando la visualizzazione array con glumpy contro matplotlib:

import numpy as np 
import glumpy 
from OpenGL import GLUT as glut 
from time import time 
from matplotlib.pyplot import subplots,close 
from matplotlib import cm 

def randomwalk(dims=(256,256),n=3,sigma=10,alpha=0.95,seed=1): 
    """ A simple random walk with memory """ 
    M = np.zeros(dims,dtype=np.float32) 
    r,c = dims 
    gen = np.random.RandomState(seed) 
    pos = gen.rand(2,n)*((r,),(c,)) 
    old_delta = gen.randn(2,n)*sigma 
    while 1: 
     delta = (1.-alpha)*gen.randn(2,n)*sigma + alpha*old_delta 
     pos += delta 
     for ri,ci in pos.T: 
      if not (0. <= ri < r) : ri = abs(ri % r) 
      if not (0. <= ci < c) : ci = abs(ci % c) 
      M[ri,ci] += 1 
     old_delta = delta 
     yield M 

def mplrun(niter=1000): 
    """ Visualise the simulation using matplotlib, using blit for 
    improved speed""" 
    fig,ax = subplots(1,1) 
    rw = randomwalk() 
    im = ax.imshow(rw.next(),interpolation='nearest',cmap=cm.hot,animated=True) 
    fig.canvas.draw() 
    background = fig.canvas.copy_from_bbox(ax.bbox) # cache the background 

    tic = time() 
    for ii in xrange(niter): 
     im.set_data(rw.next())   # update the image data 
     fig.canvas.restore_region(background) # restore background 
     ax.draw_artist(im)   # redraw the image 
     fig.canvas.blit(ax.bbox)  # redraw the axes rectangle 

    close(fig) 
    print "Matplotlib average FPS: %.2f" %(niter/(time()-tic)) 

def gprun(niter=1000): 
    """ Visualise the same simulation using Glumpy """ 
    rw = randomwalk() 
    M = rw.next() 

    # create a glumpy figure 
    fig = glumpy.figure((512,512)) 

    # the Image.data attribute is a referenced copy of M - when M 
    # changes, the image data also gets updated 
    im = glumpy.image.Image(M,colormap=glumpy.colormap.Hot) 

    @fig.event 
    def on_draw(): 
     """ called in the simulation loop, and also when the 
     figure is resized """ 
     fig.clear() 
     im.update() 
     im.draw(x=0, y=0, z=0, width=fig.width, height=fig.height) 

    tic = time() 
    for ii in xrange(niter): 
     M = rw.next()   # update the array   
     glut.glutMainLoopEvent() # dispatch queued window events 
     on_draw()   # update the image in the back buffer 
     glut.glutSwapBuffers()  # swap the buffers so image is displayed 

    fig.window.hide() 
    print "Glumpy average FPS: %.2f" %(niter/(time()-tic)) 

if __name__ == "__main__": 
    mplrun() 
    gprun() 

Utilizzando matplotlib con GTKAgg come il mio back-end e l'utilizzo di blit per evitare di attirare lo sfondo ogni volta, posso colpire circa 95 FPS. Con Glumpy ottengo circa 250-300 FPS, anche se attualmente ho una configurazione grafica piuttosto scadente sul mio portatile. Detto questo, Glumpy è un po 'più complicato per funzionare, ea meno che non si abbia a che fare con enormi matrici, o se si ha bisogno di un framerate molto alto per qualsiasi ragione, rimango con matplotlib con blit.