Python - rappresentazione efficiente di pixel e valori associati

Question

Sto usando python per lavorare con matrici di grandi dimensioni (circa 2000 x 2000), dove ogni punto I, J nella matrice rappresenta un singolo pixel.

Le matrici stesse sono sparse (ovvero una parte sostanziale di esse avrà valori zero), ma quando vengono aggiornate tendono ad essere operazioni di incremento, a un numero elevato di pixel adiacenti in un "blocco" rettangolare, piuttosto che pixel casuali qua e là (una proprietà non mi utilizzano attualmente a mio vantaggio ..). paura un po 'nuova alla matrice l'aritmetica, ma ho guardato in un certo numero di possibili soluzioni, tra le varie versioni di scipy matrici sparse. Finora coordinate (COO) matrici sembrano essere le più promettenti. Così, per esempio dove voglio incrementare forma un blocco, avrei dovuto fare qualcosa sulla falsariga di:

>>> from scipy import sparse 
>>> from numpy import array 
>>> I = array([0,0,0,0]) 
>>> J = array([0,1,2,3]) 
>>> V = array([1,1,1,1]) 
>>> incr_matrix = sparse.coo_matrix((V,(I,J)),shape=(100,100)) 
>>> main_matrix += incr_matrix #where main_matrix was previously defined 

in futuro, mi piacerebbe avere una rappresentazione valore di pixel più ricco di anycase (tuple per rappresentare RGB, ecc), qualcosa che NumPy serie doesnt sostegno fuori dalla scatola (o forse ho bisogno di usare this).

definitiva avrò un certo numero di queste matrici che avrei bisogno di fare semplici arithmitic, e avrei bisogno il codice per essere il più efficiente possibile - e distribuibili, quindi avrei bisogno di essere in grado perseverare e scambiare questi oggetti in una rappresentazione minuscola senza sanzioni sostanziali. Mi chiedo se questo è il modo giusto per andare, o dovrei cercare rotolare le mie strutture utilizzando dicts ecc?

Answer 1

La regola generale è, ottenere il codice di lavoro prima, quindi ottimizzare, se necessario ...

In questo caso, utilizzare un normale allineamento NumPy 2000x2000, o 2000x2000x3 per RGB. Questo sarà molto più facile e veloce da utilizzare, è solo un piccolo requisito di memoria e ha molti altri vantaggi, ad esempio, è possibile utilizzare gli strumenti di elaborazione delle immagini standard, ecc.

Quindi, se necessario, "per persistere e scambiare questi oggetti ", puoi semplicemente comprimerli usando gzip, pytables, jpeg o altro, ma non è necessario limitare i requisiti di archiviazione basati sulla manipolazione dei dati.

In questo modo si ottiene sia l'elaborazione più veloce e migliore compressione.

Answer 2

Si potrebbe prendere in considerazione esaminando un quadtree come un'implementazione. La struttura quadtree è piuttosto efficiente nella memorizzazione di dati sparsi e ha il vantaggio aggiunto che se si lavora con strutture composte da molti blocchi di dati simili, la rappresentazione può essere molto compatta. Non sono sicuro se ciò sarà particolarmente applicabile a quello che stai facendo, dal momento che non so cosa intendi con "lavorare in blocchi", ma è certamente da verificare come implementazione alternativa di una matrice sparsa.

Answer 3

Direi, sì, questa è la strada da percorrere. Sicuramente sopra la costruzione di qualcosa fuori dai dizionari! Quando si costruisce un "vettore", array, quindi utilizzare una matrice strutturata, cioè definire il proprio DTYPE:

rgbtype = [('r','uint8'),('g','uint8'),('b','uint8')] 

quando incrementare i vostri blocchi, sarà simile a questa:

main_matrix['r'][blk_slice] += incr_matrix['r'] 
main_matrix['g'][blk_slice] += incr_matrix['g'] 
main_matrix['b'][blk_slice] += incr_matrix['b'] 

Aggiornamento:

Sembra che non sia possibile eseguire operazioni matrice con una matrice coo, esistono semplicemente come un modo conveniente per popolare una matrice sparsa. Devi convertirli in un altro (sparse) tipo di matrice prima di fare gli aggiornamenti. documentation