metodo veloce per creare array 2D NumPy cui elementi sono nella gamma

Question

voglio creare una matrice NumPy 2D dove voglio memorizzare le coordinate dei pixel tale matrice NumPy assomiglia a questo

[(0, 0), (0, 1), (0, 2), ...., (0, 510), (0, 511) 
(1, 0), (1, 1), (1, 2), ...., (1, 510), (1, 511) 
.. 
.. 
.. 
(511, 0), (511, 1), (511, 2), ...., (511, 510), (511, 511)] 

Questo è un domanda ridicola ma non ho ancora trovato nulla.

Answer 1

Può usare np.indices o np.meshgrid per più l'indicizzazione avanzata:

>>> data=np.indices((512,512)).swapaxes(0,2).swapaxes(0,1) 
>>> data.shape 
(512, 512, 2) 

>>> data[5,0] 
array([5, 0]) 
>>> data[5,25] 
array([ 5, 25]) 

Questo può sembrare strano perché la sua davvero fatto per fare qualcosa di simile:

>>> a=np.ones((3,3)) 
>>> ind=np.indices((2,1)) 
>>> a[ind[0],ind[1]]=0 
>>> a 
array([[ 0., 1., 1.], 
     [ 0., 1., 1.], 
     [ 1., 1., 1.]]) 

A mgrid esempio:

np.mgrid[0:512,0:512].swapaxes(0,2).swapaxes(0,1) 

Esempio meshgrid:

>>> a=np.arange(0,512) 
>>> x,y=np.meshgrid(a,a) 
>>> ind=np.dstack((y,x)) 
>>> ind.shape 
(512, 512, 2) 

>>> ind[5,0] 
array([5, 0]) 

Tutti sono modi equivalenti per farlo; tuttavia, è possibile utilizzare meshgrid per creare griglie non uniformi.

Se non ti dispiace cambiare gli indici riga/colonna, puoi rilasciare l'ultimo swapaxes(0,1).

Answer 2

Qui è possibile utilizzare np.ogrid. Invece di memorizzare uno tuple, memorizzarlo in un array 3D.

>>> t_row, t_col = np.ogrid[0:512, 0:512] 
>>> a = np.zeros((512, 512, 2), dtype=np.uint8) 
>>> t_row, t_col = np.ogrid[0:512, 0:512] 
>>> a[t_row, t_col, 0] = t_row 
>>> a[t_row, t_col, 1] = t_col 

Questo dovrebbe fare il trucco. Spero che tu possa usare questo, invece della tupla.

Chintak

Answer 3

L'esempio nella questione non è del tutto chiaro - o virgole in più sono mancanti o parentesi extra.

Questo - esempio gamme 3, 4 per chiarezza - fornisce la soluzione per la prima variante e produce una matrice 2D in effetti (come il titolo della domanda suggerisce) - "lista" tutte le coordinate:

>>> np.indices((3,4)).reshape(2,-1).T 
array([[0, 0], 
     [0, 1], 
     [0, 2], 
     [0, 3], 
     [1, 0], 
     [1, 1], 
     [1, 2], 
     [1, 3], 
     [2, 0], 
     [2, 1], 
     [2, 2], 
     [2, 3]]) 

---

l'altra variante è stato già mostrato in un'altra risposta utilizzando 2x .swapaxes() - ma potrebbe anche essere fatto con uno np.rollaxis() (o la nuova np.moveaxis()):

>>> np.rollaxis(np.indices((3,4)), 0, 2+1) 
array([[[0, 0], 
     [0, 1], 
     [0, 2], 
     [0, 3]], 

     [[1, 0], 
     [1, 1], 
     [1, 2], 
     [1, 3]], 

     [[2, 0], 
     [2, 1], 
     [2, 2], 
     [2, 3]]]) 
>>> _[0,1] 
array([0, 1]) 

Questo metodo funziona anche lo stesso per indici N-dimensionali, per es .:

>>> np.rollaxis(np.indices((5,6,7)), 0, 3+1) 

Nota: La funzione np.indices funziona davvero (C-velocità) veloce per grandi cucine.