So ... new interface, time to try out some formatting and stuff. What a better topic than how to order, structure and view 3D data like images or raster data of mixed data types for the same location or uniform data type where the 3rd dimension represents time.
I will make it simple. Begin with 24 integer numbers and arange them into all the possible configurations in 3D. Then it is time to mess with your mind and show you how to convert from one arrangement to another. Sort of like Rubic's Cube, but simpler.
So here is the generating script (note the new cool python syntax highlighting... nice! ... but you still can't change the brownish background color, stifling any personal code preferences). The def just happens to be number 37... it has no meaning, just 37 in a collection of functions
def num_37():
"""(num_37) playing with 3D arrangements...
:Requires:
:
: Arrays are generated within... nothing required
:Returns:
:
: An array of 24 sequential integers with shape = (2, 3, 4)
:Notes:
:
: References to numpy, transpose, rollaxis, swapaxes and einsum.
: The arrays below are all the possible combinations of axes that can be
: constructed from a sequence size of 24 values to form 3D arrays.
: Higher dimensionalities will be considered at a later time.
:
: After this, there is some fancy formatting as covered in my previous blogs.
"""
nums = np.arange(24) # whatever, just shape appropriately
a = nums.reshape(2,3,4) # the base 3D array shaped as (z, y, x)
a0 = nums.reshape(2,4,3) # y, x axes, swapped
a1 = nums.reshape(3,2,4) # add to z, reshape y, x accordingly to main size
a2 = nums.reshape(3,4,2) # swap y, x
a3 = nums.reshape(4,2,3) # add to z again, resize as befor
a4 = nums.reshape(4,3,2) # swap y, x
frmt = """
Array ... {} :..shape {}
{}
"""
args = [['nums', nums.shape, nums],
['a', a.shape, a], ['a0', a0.shape, a0],
['a1', a1.shape, a1], ['a2', a2.shape, a2],
['a3', a3.shape, a3], ['a4', a4.shape, a4],
]
for i in args:
print(dedent(frmt).format(*i))
return a
And here are the results


3D Array .... a  3D array .... a0 





In any event, I prefer to think of a 3D array as consisting of ( Z, Y, X ) if they do indeed represent the spatial component. In this context, however, Z is not simply taken as elevation as might be the case for a 2D raster. The mere fact that the first axis is denoted with a 2 or above, indicates to me that it is a change array. Do note that the arrays need not represent anything spatial at all, but this being a place for GIS commentary, there is often an implicit assumption that at least two of the dimensions will be spatial.
To go from array a to a0, and conversely, we need to reshape the array. Array shaping can be accomplished using a variety of numpy methods, including rollaxes, swapaxes, transpose and einsum to name a few.
The following can be summarized:
R rollaxis  roll the chosen axis back by the specified positions
E einsum  for now, just see the swapping of letters in the ijk sequence
S swapaxes  change the position of specified axes
T transpose  similar to swapaxes, but with multiple changes
a0 = np.rollaxis(a, 2, 1) # a = np.rollaxis(a0, 2, 1)
a0 = np.swapaxes(a, 2, 1) # a = np.swapaxes(a0, 1, 2)
a0 = a.swapaxes(2, 1) # a = a0.swapaxes(1, 2)
a0 = np. transpose(a, (0, 2, 1)) # a = np.transpose(a0, (0, 2, 1))
a0 = a.transpose(0, 2, 1) # a = np.transpose(a0, 2, 1)
a0 = np.einsum('ijk > ikj', a) # a = np.einsum('ijk > ikj', a0)
When you move on to higher values for the first dimension you have to be careful about which of these you can use, and it is generally just better to use reshape or stride tricks to perform the reshaping


3D array .... a1  3D array .... a2 




3D array .... a2 to a conversion 



Now for something a little bit different
Array 'a' which has been used before. It has a shape of (2, 3, 4). Consider it as 2 layers or bands occupying the same space.
array([[[ 0, 1, 2, 3],
[ 4, 5, 6, 7],
[ 8, 9, 10, 11]],
[[12, 13, 14, 15],
[16, 17, 18, 19],
[20, 21, 22, 23]]])
A second array, 'b', can be constructed using the same data, but shaped differently, (3, 4, 2). The dimension consisting of two parts is effectively swapped between the two arrays. It can be constructed from:
>>> x = np.arange(12)
>>> y = np.arange(12, 24)
>>>
>>> b = np.array(list(zip(x,y))).reshape(3,4,2)
>>> b
array([[[ 0, 12],
[ 1, 13],
[ 2, 14],
[ 3, 15]],
[[ 4, 16],
[ 5, 17],
[ 6, 18],
[ 7, 19]],
[[ 8, 20],
[ 9, 21],
[10, 22],
[11, 23]]])
If you look closely, you can see that the numeric values from 0 to 11 are order in a 4x3 block in array 'a', but appear as 12 entries in a column, split between 3 subarrays. The same data can be sliced from their respetive array dimensions to yield
... subarray 'a[0]' or ... subarray 'b[...,0]'
yields
[[ 0 1 2 3]
[ 4 5 6 7]
[ 8 9 10 11]]
The arrays can be raveled to reveal their internal structure.
>>> b.strides # (64, 16, 8)
>>> a.strides # (96, 32, 8)
a.ravel()...[ 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23]
b.ravel()...[ 0 12 1 13 2 14 3 15 4 16 5 17 6 18 7 19 8 20 9 21 10 22 11 23]
a0_r = a[0].reshape(3,4,1) # a0_r.shape = (3, 4, 1)
array([[[ 0],
[ 1],
[ 2],
[ 3]],
[[ 4],
[ 5],
[ 6],
[ 7]],
[[ 8],
[ 9],
[10],
[11]]])
Enough for now. Learning how to reshape and work with array structures can certainly make dealing with raster data much easier.