numpy 是否有可能在不更改 memory 顺序和迭代器的情况下交换矩阵的 x,y？

Question

I'm trying to switch to numpy from the world of fortran and c++ . Mainly I'm working with huge images, where coordinates directions are x: left to right, y: top down, and pixels are stored in rows, common for image format.

Numpy says that also stores matrices by rows. As far as good, it is the same as fortran/c++ saves images. But, see following example, grays from black to white in rows. Lets create image 3x3 where first row is 123 etc

Black to White image as expected, with matplotlib imshow(mat)

mat = np.array([1,2,3,4,5,6,7,8,9], 'i1').reshape(3,3)

next I've used following code to get info about matrix. Routine prints: value at position x=1, y=0 , position in memory to see if array is copied, strides and iterators.

def pr(a):
    x=1; y=0;
    print(a[x,y])
    print(a.ctypes.data, a.strides, a.ravel(order='K'), [x for x in a.flat], a.flatten(order='K'))
    print(a.flags)

for matrix mat in C-order I've got

4
94598176807408 (3, 1) [1 2 3 4 5 6 7 8 9] [1, 2, 3, 4, 5, 6, 7, 8, 9] [1 2 3 4 5 6 7 8 9]
  C_CONTIGUOUS : True
  F_CONTIGUOUS : False

So it is clear that x,y are swapped, because for x=1 and y=0 pixel value is 2 and not 4, so I've changed to F order.

# mat = mat.ravel(order='K').reshape(3,3, order='F')
mat.strides = (1,3)
# mat = np.swapaxes(mat, 0, 1)

Above are three possibilities to get F order with same results.

2
94598176807408 (1, 3) [1 2 3 4 5 6 7 8 9] [1, 4, 7, 2, 5, 8, 3, 6, 9] [1 2 3 4 5 6 7 8 9]
  C_CONTIGUOUS : False
  F_CONTIGUOUS : True

Now image is swapped when using F order with same memory layout as before

As you can see value 2 for x=1 y=2 is correct, using mat[x,y] is correct, memory order is correct, but iterator is wrong 1 4 7... . Consequences are that saving or showing image are bad, all are swapped. Iterator not in memory order has big performance penalties.

Question is: How to set numpy matrix with swapped x,y without copy of image and all other properties are as in C-order. I've tried to set C_CONTIGUOUS=True, but it is not possible.?

One way is to use C-order but on all such matrices one must use reversed indexes [y,x], problem is that it is very confusing, all vectors are normal (x,y,z) and some objects use swap index order.? Correct naming order of axes helps in further spatial operation of images.

Maybe there is possibility to extend numpy , with other index method like mat.swap2[x,y] that only returns mat[y,x] or eg. mat[*reversed((x,y))] . But is there better solution?

Next are two examples in fortran and c++ with eg. armadillo matrix library (as c/c++ doesn't seem to define own generic matrix object). Both examples uses F order, indexing is correct mat[x,y] , memory layout is same as binary layout of input images, row by row, iterator are in memory layout. It seems strange to me that numpy in F order does not support same behavior. Or simply I don't understand the philosophy of numpy.

Example in fortran , saving and iterating such matrix is in memory order (not shown here).

...
    integer(1) :: mat(0:2,0:2)      ! matrix 3x3 indexing 0,1,2
    data mat /1,2,3,4,5,6,7,8,9/    ! memory order
    print*, mat(1,0)                ! value for x=1 y=0 is 2 ok
...

Example in C++ with armadillo, saving and iterating again is in memory order (not shown here).

#define ARMA_U8_TYPE   uint8_t
#define ARMA_S8_TYPE    int8_t        // define support for int8 instead of char
#include <armadillo>
...
    using namespace arma;
    int8_t amem[] = {1,2,3,4,5,6,7,8,9};        // memory order
    Mat<int8_t> mat(amem, 3,3,  false,true);    // matrix 3x3
    cout << (int)mat(1,0) << "\n";              // value for x=1 y=0 is 2 ok
...

Answer 1

First numpy has confusing terms for column major mode, F_CONTIGUOUS is never contiguous in memory for 2D and more. It is just like view by design and memory layout is always C . For performance reasons and axis assignment as you specified it is more natural to use column major order as many do, but not easy in numpy.

Furthermore built-in/extension doesn't allow to use just setattr() to extend directly numpy classes, but you can derive own.

To be simple in numpy always use default C order (row major order) and swap axes as mat[z,y,x] . It seems to me to be the least confusing.