Wyświetl tablicę NumPy jako stale aktualizującą obraz z Glumpy

Question

Mam model symulacyjny uruchomiony w Pythonie za pomocą NumPy i SciPy i generuje on tablicę 2D NumPy jako wynik każdej iteracji. Wyświetlałem to wyjście jako obraz przy użyciu matplotlib i funkcji imshow. Jednak dowiedziałem się o Glumpy i na jego stronie dokumentacji jest napisane:

Dzięki powłoce IPython, glumpy może być uruchomiony w trybie interaktywnym, w którym można zobaczyć aktualizację na żywo w wyświetlanych tablicach, gdy ich zawartość zostanie zmieniona .

Jednak nie mogę wydawać się, jak to zrobić z przykładami, które podali. Zasadniczo mój model działa jako jedna funkcja, która ma dużą pętlę for w pętli dla liczby uruchomionych iteracji. Na końcu każdej iteracji pętli for chcę wyświetlić tablicę. W tej chwili używam matplotlib, aby zapisać obraz do pliku PNG, ponieważ wyświetlanie go na ekranie przez Matplotlib wydaje się blokować proces Pythona.

Jestem pewien, że jest sposób na zrobienie tego z Glumpy, po prostu nie jestem pewien jak i nie mogę znaleźć żadnych przydatnych samouczków.

Answer 1

Dokumentacja Glumpy jest dość nieistniejąca! Oto przykład prostego symulacji, porównując wizualizację tablicy z glumpy przeciwko 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() 

Korzystanie matplotlib z GTKAgg jako mojego backend i korzystania blit uniknąć za każdym razem, rysunek tło, mogę trafić około 95 FPS. Dzięki Glumpy uzyskuję około 250-300 klatek na sekundę, mimo że obecnie mam dość kiepską konfigurację graficzną na moim laptopie. Mimo to, Glumpy jest nieco bardziej skrzypiący, aby uzyskać pracę, i jeśli nie masz do czynienia z ogromnymi matrycami lub potrzebujesz bardzo dużego framerate z jakiegokolwiek powodu, będę trzymać się przy użyciu matplotlib z blit.