numpy：连续 2d 切片的连续 3d 体积？

Question

I want to load several 2D C contiguous image arrays into a 3D volume and access them in via intuitive indexing, eg slice3 = volume[:,:,2] which requires some reshaping from the original concatenated 1D representation.

Now, since I load a lot of images and calculate even more new volumes from it which has to work on your average PC I'm concerned about memory usage as well as calculation performance.

Q: How can I achieve for the 3D volume as well as the 2D slices to remain contiguous, so I can efficiently do some stuff on the volume and some on individual slices.

Here's some example to play with:

import numpy as np

# dimensions:
rows   = 2
cols   = 2
slices = 3

# create array
a = np.arange(rows*cols*slices)
print(a)
# [ 0  1  2  3  4  5  6  7  8  9 10 11]
# this is the original concatenated input of the slices [[0,1],[2,3]], [[4,5],[6,7]], [[8,9],[10,11]]

# a contiguous?
print(a.flags['C_CONTIGUOUS'])
# True

a = a.reshape(rows,cols,slices)
print(a)
# a still contiguous?
print(a.flags['C_CONTIGUOUS'])
# True

# what about a slice?
print(a[:,:,0])
# [[0 3]
#  [6 9]]
# ouch! that's not the slice I wanted! I wanted to keep [[0,1],[2,3]] together
# this slice is of course also not contiguous:
print(a[:,:,0].flags['C_CONTIGUOUS'])
# False

# ok, let's start over
a = a.ravel()
print(a)
# [ 0  1  2  3  4  5  6  7  8  9 10 11]
a = a.reshape(slices,rows,cols)
a = a.swapaxes(0,1)
a = a.swapaxes(1,2)
# what about a slice?
print(a[:,:,0])
# [[0 1]
#  [2 3]]
# now that's the kind of slice I wanted!

# a still contiguous?
print(a.flags['C_CONTIGUOUS'])
# False

# slice contiguous?
print(a[:,:,0].flags['C_CONTIGUOUS'])
# True
# only halfway there.. :(

Again: Is there a way to achieve the desired slice indexing while keeping volume as well as individual slices C contiguous?

Answer 1

Option 1

Don't get too hung up on which dimension corresponds to slices :

a = a.reshape(slices, rows, cols)

Leave it at that. A nice side-effect is that to get say slice 1 , you just do

a[1]

No need for a[1, :, :] or even a[1, ...] .

Option 2

If you do get hung up on which dimension slices corresponds to, you have to copy the data to maintain contiguity. However, you can get there with just one copy, rather than using swapaxes twice.

One way is to use transpose :

a = a.reshape(slices, rows, cols).transpose(1, 2, 0)

Or you can use np.moveaxis :

a = np.moveaxis(a.reshape(slices, rows, cols), 0, -1)

Answer 2

No, it is impossible for a 3D array a to be C-contiguous, and also for a[:,:,0] to be C-contiguous.

Why? By definition, a C-contiguous array has a unit stride in the last dimension, For example

>>> a = np.arange(rows*cols*slices)
>>> a = a.reshape(slices,rows,cols)
>>> print([stride // a.itemsize for stride in a.strides])
[4, 2, 1]

For any C-contiguous array, slicing the last dimension will create a non-C-contiguous array, because it cannot have a unit stride in the last dimension:

>>> b = a[:, :, 0]
>>> print([stride // b.itemsize for stride in b.strides])
[4, 2]

If you want your slices to be C-contiguous, you will need to slice in the first dimension and only the first dimension:

>>> c = a[0, :, :]
>>> print([stride // c.itemsize for stride in c.strides])
[2, 1]