# 3D Data ... messing with shapes

Blog Post created by Dan_Patterson on Nov 10, 2016

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
``Array ... a :..shape  (2, 3, 4)[[[ 0  1  2  3]  [ 4  5  6  7]  [ 8  9 10 11]] [[12 13 14 15]  [16 17 18 19]  [20 21 22 23]]]# This is the base array...``
``Array ... a0 :..shape  (2, 4, 3)[[[ 0  1  2]  [ 3  4  5]  [ 6  7  8]  [ 9 10 11]] [[12 13 14]  [15 16 17]  [18 19 20]  [21 22 23]]]``

|-----------------------------------------------------
|
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 .... a13D array .... a2
``Array ... a1 :..shape  (3, 2, 4)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]]])``
``Array ... a2 :..shape  (3, 4, 2)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]]])``

|-----------------------------------------------------

3D array .... a2 to a conversion
``>>> from numpy.lib import stride_tricks as ast>>> back_to_a = a2.reshape(2, 3, 4)>>> again_to_a = ast.as_strided(a2, a.shape, a.strides)>>> back_to_aarray([[[ 0,  1,  2,  3],        [ 4,  5,  6,  7],        [ 8,  9, 10, 11]],       [[12, 13, 14, 15],        [16, 17, 18, 19],        [20, 21, 22, 23]]])>>> again_to_aarray([[[ 0,  1,  2,  3],        [ 4,  5,  6,  7],        [ 8,  9, 10, 11]],       [[12, 13, 14, 15],        [16, 17, 18, 19],        [20, 21, 22, 23]]])``

|-----------------------------------------------------

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)>>> barray([[[ 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

``... sub-array 'a' or ... sub-array '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.reshape(3,4,-1) # a0_r.shape = (3, 4, 1)array([[[ 0], [ 1], [ 2], [ 3]],[[ 4], [ 5], [ 6], [ 7]],[[ 8], [ 9], , ]])``

Enough for now.  Learning how to reshape and work with array structures can certainly make dealing with raster data much easier.