python - ndarray - Matriz tridimensional en número

numpy python 3.6 windows

Question

Nuevo en Python y Numpy, intentando crear matrices tridimensionales. Mi problema es que el orden de las dimensiones está desactivado en comparación con Matlab. De hecho, el orden no tiene sentido en absoluto.

Creando una matriz:

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

En mi mundo, esto debería resultar en 2 filas, 3 columnas y 4 dimensiones de profundidad y debería presentarse como:

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

Separando en cada profundidad las dimensiones. En su lugar se presenta como

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

Es decir, 3 filas, 4 columnas y 2 dimensiones de profundidad. Es decir, la primera dimensión es la "profundidad". Para agregar más a este problema, al importar una imagen con OpenCV, la dimensión de color es la última dimensión, es decir, veo la información de color como la dimensión de profundidad. Esto complica mucho las cosas si lo único que quiero hacer es probar algo en una matriz tridimensional más pequeña conocida.

¿He entendido mal algo? Si no es así, ¿por qué diablos está mal el uso de una forma tan poco intuitiva de trabajar con matrices tridimensionales?

Answer 1

Tienes razón, estás creando una matriz con 2 filas, 3 columnas y 4 profundidades. Numpy imprime matrices diferentes a 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

Sin embargo estás calculando la misma matriz. Eche un vistazo a Numpy para usuarios de Matlab , le guiará en la conversión de código Matlab a Numpy.

Por ejemplo, si está utilizando OpenCV, puede crear una imagen usando un número teniendo en cuenta que OpenCV utiliza la representación de BGR:

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)

Si le da un vistazo a la matriz c , verá que es una matriz de 100x200x3, que es exactamente lo que se muestra en la imagen (en rojo, ya que hemos establecido la coordenada R en 255 y las otras dos permanecen en 0).

Answer 2

Tienes una representación de matriz truncada. Veamos un ejemplo completo:

>>> 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.]]])

Las matrices en NumPy se imprimen como la array palabras seguida de una estructura, similar a las listas Python incrustadas. Vamos a crear una lista similar:

>>> 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]]]

El primer nivel de esta lista compuesta l tiene exactamente 2 elementos, al igual que la primera dimensión de la matriz a (número de filas). Cada uno de estos elementos es en sí mismo una lista con 3 elementos, que es igual a la segunda dimensión de (número de columnas). Finalmente, las listas más anidadas tienen 4 elementos cada una, igual que la tercera dimensión de a (profundidad / número de colores).

Así que tienes exactamente la misma estructura (en términos de dimensiones) que en Matlab, solo se imprime de otra manera.

Algunas advertencias:

1. Matlab almacena datos columna por columna ("orden de Fortran"), mientras que NumPy los almacena fila por fila ("orden C"). Esto no afecta a la indexación, pero puede afectar el rendimiento. Por ejemplo, en Matlab, el ciclo eficiente estará sobre las columnas (por ejemplo, for n = 1:10 a(:, n) end ), mientras que en NumPy es preferible iterar sobre filas (por ejemplo, for n in range(10): a[n, :] - note n en la primera posición, no en la última).

2. Si trabajas con imágenes coloreadas en OpenCV, recuerda que:

   2.1. Almacena imágenes en formato BGR y no en RGB, como hacen la mayoría de las bibliotecas de Python.

   2.2. La mayoría de las funciones trabajan en coordenadas de imagen ( x, y ), que son opuestas a las coordenadas de la matriz ( i, j ).