Serie tridimensionale in numpy

Question

Novità in Python e Numpy, cercando di creare matrici tridimensionali. Il mio problema è che l'ordine delle dimensioni è spento rispetto a Matlab. In realtà l'ordine non ha alcun senso.

Creazione di una matrice:

x = np.zeros((2,3,4)) 

Nel mio mondo ciò dovrebbe comportare 2 righe, 3 colonne e 4 dimensioni di profondità e dovrebbe essere presentata come:

[0 0 0  [0 0 0  [0 0 0  [0 0 0 
0 0 0]  0 0 0]  0 0 0]  0 0 0] 

Seperating su ogni dimensione di profondità . Invece è presentato come

[0 0 0 0  [0 0 0 0 
0 0 0 0  0 0 0 0 
0 0 0 0]  0 0 0 0] 

Cioè, 3 righe, 4 colonne e 2 dimensioni di profondità. Cioè, la prima dimensione è la "profondità". Per aggiungere ulteriore a questo problema, importando un'immagine con OpenCV la dimensione del colore è l'ultima dimensione, cioè, vedo le informazioni sul colore come la dimensione della profondità. Ciò complica notevolmente le cose se tutto ciò che voglio fare è provare qualcosa su un array tridimensionale più piccolo conosciuto.

Ho frainteso qualcosa? In caso contrario, perché diamine è numpy usando un modo così poco intuitivo di lavorare con array 3D dimensionali?

Answer 1

Hai ragione, stai creando una matrice con 2 righe, 3 colonne e 4 profondità. stampe NumPy matrici diverse per Matlab:

NumPy:

>>> import numpy as np 
>>> np.zeros((2,3,2)) 
array([[[ 0., 0.], 
    [ 0., 0.], 
    [ 0., 0.]], 

    [[ 0., 0.], 
    [ 0., 0.], 
    [ 0., 0.]]]) 

Matlab

>> zeros(2, 3, 2) 
ans(:,:,1) = 
    0  0  0 
    0  0  0 
ans(:,:,2) = 
    0  0  0 
    0  0  0 

Tuttavia si sta calcolando la stessa matrice. Dai uno sguardo a Numpy for Matlab users, ti guiderà nella conversione del codice Matlab in Numpy.

---

Per esempio, se si sta utilizzando OpenCV, si può costruire un'immagine utilizzando NumPy tenendo conto che OpenCV utilizza BGR rappresentazione:

import cv2 
import numpy as np 

a = np.zeros((100, 100,3)) 
a[:,:,0] = 255 

b = np.zeros((100, 100,3)) 
b[:,:,1] = 255 

c = np.zeros((100, 200,3)) 
c[:,:,2] = 255 

img = np.vstack((c, np.hstack((a, b)))) 

cv2.imshow('image', img) 
cv2.waitKey(0) 

Se si dà un'occhiata alla matrice c vedrai che è una matrice 100x200x3 che è esattamente ciò che viene mostrato nell'immagine (in rosso dato che abbiamo impostato la coordinata R su 255 e gli altri due rimangono su 0).

Answer 2

Si dispone di una rappresentazione di array troncata. Diamo un'occhiata a pieno esempio:

>>> a = np.zeros((2, 3, 4)) 
>>> a 
array([[[ 0., 0., 0., 0.], 
     [ 0., 0., 0., 0.], 
     [ 0., 0., 0., 0.]], 

     [[ 0., 0., 0., 0.], 
     [ 0., 0., 0., 0.], 
     [ 0., 0., 0., 0.]]]) 

array in NumPy vengono stampati come parola array seguita dalla struttura, simile alle liste Python embedded. Creiamo elenco simile:

>>> l = [[[ 0., 0., 0., 0.], 
      [ 0., 0., 0., 0.], 
      [ 0., 0., 0., 0.]], 

      [[ 0., 0., 0., 0.], 
      [ 0., 0., 0., 0.], 
      [ 0., 0., 0., 0.]]] 

>>> l 
[[[0.0, 0.0, 0.0, 0.0], [0.0, 0.0, 0.0, 0.0], [0.0, 0.0, 0.0, 0.0]], 
[[0.0, 0.0, 0.0, 0.0], [0.0, 0.0, 0.0, 0.0], [0.0, 0.0, 0.0, 0.0]]] 

primo livello di questo elenco composto l ha esattamente 2 elementi, proprio come prima dimensione dell'array a (# di righe). Ognuno di questi elementi è di per sé elenco con 3 elementi, che è uguale alla seconda dimensione di a (numero di colonne). Infine, gli elenchi più annidati hanno 4 elementi ciascuno, come la terza dimensione di a (profondità/numero di colori).

Quindi hai esattamente la stessa struttura (in termini di dimensioni) come in Matlab, appena stampato in altro modo.

Alcuni avvertimenti.

1. Matlab colonna memorizza dati per colonna ("ordine Fortran"), mentre NumPy da archivi predefiniti loro riga per riga ("ordine C"). Ciò non influisce sull'indicizzazione, ma può influire sulle prestazioni. Ad esempio, in Matlab il ciclo efficiente si sovrapporrà alle colonne (ad esempio for n = 1:10 a(:, n) end), mentre in NumPy è preferibile iterare su righe (ad esempio for n in range(10): a[n, :] - nota n in prima posizione, non l'ultima).

2. Se si lavora con immagini a colori in OpenCV, ricordate che:

   2.1. Memorizza le immagini in formato BGR e non RGB, come fa la maggior parte delle librerie Python.

   2.2. La maggior parte delle funzioni funziona sulle coordinate dell'immagine (x, y), che sono opposte alle coordinate matriciali (i, j).