2

I'm trying to save a 3D numpy array to my disk so that I can later read it in matlab. I've had some difficulty using numpy.savetxt() on a 3D array, so my solution has been to first convert it to a 1D array using the following code:

import numpy

array = numpy.array([[0, 1, 2, 3],
       [0, 1, 1, 3],
       [3, 1, 3, 1]])

ndarray = numpy.dstack((array, array, array))

darray = ndarray.reshape(36,1)

numpy.savetxt('test.txt', darray, fmt = '%i')

Then in matlab it can be read with the following code:

file = fopen('test.txt')
array = fscanf(file, '%f')

My issue now is converting it back to the original shape. Using reshape(array, 3,4,3) yields the following:

ans(:,:,1) =

     0     1     2     3
     0     1     2     3
     0     1     2     3


ans(:,:,2) =

     0     1     1     3
     0     1     1     3
     0     1     1     3


ans(:,:,3) =

     3     1     3     1
     3     1     3     1
     3     1     3     1

I've tried to transpose the 1D matlab array, then use reshape() but get the same array.

What matlab function can I apply to achieve my original python array?

Improve this question
0

1 Answer 1

Reset to default
6

You want to permute the dimensions. In numpy this is transpose. There are two complications - the 'F' order of MATLAB matrices, and the display pattern, using blocks on the last dimension (which is the outer one with F order). Jump to the end of this answer for details.

===

In [72]: arr = np.array([[0, 1, 2, 3],
    ...:        [0, 1, 1, 3],
    ...:        [3, 1, 3, 1]])
    ...:        
In [80]: np.dstack((arr,arr+1))
Out[80]: 
array([[[0, 1],
        [1, 2],
        [2, 3],
        [3, 4]],

       [[0, 1],
        [1, 2],
        [1, 2],
        [3, 4]],

       [[3, 4],
        [1, 2],
        [3, 4],
        [1, 2]]])
In [81]: np.dstack((arr,arr+1)).shape
Out[81]: (3, 4, 2)

In [75]: from scipy.io import loadmat, savemat
In [76]: pwd
Out[76]: '/home/paul/mypy'
In [83]: savemat('test3',{'arr':arr, 'arr3':arr3})

In Octave

>> load 'test3.mat'
>> arr
arr =

  0  1  2  3
  0  1  1  3
  3  1  3  1

>> arr3
arr3 =

ans(:,:,1) =

  0  1  2  3
  0  1  1  3
  3  1  3  1

ans(:,:,2) =

  1  2  3  4
  1  2  2  4
  4  2  4  2

>> size(arr3)
ans =

   3   4   2

back in numpy I can display the array as 2 3x4 blocks with:

In [95]: arr3[:,:,0]
Out[95]: 
array([[0, 1, 2, 3],
       [0, 1, 1, 3],
       [3, 1, 3, 1]])
In [96]: arr3[:,:,1]
Out[96]: 
array([[1, 2, 3, 4],
       [1, 2, 2, 4],
       [4, 2, 4, 2]])

These arrays, ravelled to 1d (showing in effect the layout of values in the underlying databuffer):

In [100]: arr.ravel()
Out[100]: array([0, 1, 2, 3, 0, 1, 1, 3, 3, 1, 3, 1])
In [101]: arr3.ravel()
Out[101]: 
array([0, 1, 1, 2, 2, 3, 3, 4, 0, 1, 1, 2, 1, 2, 3, 4, 3, 4, 1, 2, 3, 4, 1, 2])

The corresponding ravel in Octave:

>> arr(:).'
ans =
  0  0  3  1  1  1  2  1  3  3  3  1

>> arr3(:).'
ans =
  0  0  3  1  1  1  2  1  3  3  3  1  1  1  4  2  2  2  3  2  4  4  4  2

MATLAB uses F (fortran) order, with the first dimension changing fastest. Thus it is natural to display blocks arr(:,:i). You can specify order='F' when creating and working with numpy arrays. But it can be tricky keeping the order straight, especially when working with 3d. loadmat/savemat try to do some of the reordering for us. For example a 2d MATLAB matrix loads as an order F array in numpy.

In [107]: np.array([0,0,3,1,1,1,2,1,3,3,3,1])
Out[107]: array([0, 0, 3, 1, 1, 1, 2, 1, 3, 3, 3, 1])
In [108]: np.array([0,0,3,1,1,1,2,1,3,3,3,1]).reshape(4,3)
Out[108]: 
array([[0, 0, 3],
       [1, 1, 1],
       [2, 1, 3],
       [3, 3, 1]])
In [109]: np.array([0,0,3,1,1,1,2,1,3,3,3,1]).reshape(4,3).T
Out[109]: 
array([[0, 1, 2, 3],
       [0, 1, 1, 3],
       [3, 1, 3, 1]])
In [111]: np.array([0,0,3,1,1,1,2,1,3,3,3,1]).reshape((3,4),order='F')
Out[111]: 
array([[0, 1, 2, 3],
       [0, 1, 1, 3],
       [3, 1, 3, 1]])

It might easier to keep track of shapes with this array:

In [112]: arr3 = np.arange(2*3*4).reshape(2,3,4)
In [113]: arr3f = np.arange(2*3*4).reshape(2,3,4, order='F')
In [114]: arr3
Out[114]: 
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]]])
In [115]: arr3f
Out[115]: 
array([[[ 0,  6, 12, 18],
        [ 2,  8, 14, 20],
        [ 4, 10, 16, 22]],

       [[ 1,  7, 13, 19],
        [ 3,  9, 15, 21],
        [ 5, 11, 17, 23]]])
In [116]: arr3f.ravel()
Out[116]: 
array([ 0,  6, 12, 18,  2,  8, 14, 20,  4, 10, 16, 22,  1,  7, 13, 19,  3,
        9, 15, 21,  5, 11, 17, 23])
In [117]: arr3f.ravel(order='F')
Out[117]: 
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])
In [118]: savemat('test3',{'arr3':arr3, 'arr3f':arr3f})

In Octave:

>> arr3
arr3 =
ans(:,:,1) =
   0   4   8
  12  16  20

ans(:,:,2) =
   1   5   9
  13  17  21
....
>> arr3f
arr3f =
ans(:,:,1) =
   0   2   4
   1   3   5

ans(:,:,2) =
   6   8  10
   7   9  11
...
>> arr3.ravel()'
error: int32 matrix cannot be indexed with .
>> arr3(:)'
ans =
 Columns 1 through 20:
   0  12   4  16   8  20   1  13   5  17   9  21   2  14   6  18  10  22   3  15
 Columns 21 through 24:
   7  19  11  23
>> arr3f(:)'
ans =
 Columns 1 through 20:
   0   1   2   3   4   5   6   7   8   9  10  11  12  13  14  15  16  17  18  19
 Columns 21 through 24:
  20  21  22  23

arr3f still looks 'messedup' when printed by blocks, but when raveled we see that values are in same F order. That's also evident if we print the last 'block' of the numpy array:

In [119]: arr3f[:,:,0]
Out[119]: 
array([[0, 2, 4],
       [1, 3, 5]])

So to match up numpy and matlab we have to keep 2 things straight - the order, and the block display style.

My MATLAB is rusty, but I found permute with is similar to the np.transpose. Using that to reorder the dimensions:

>> permute(arr3,[3,2,1])
ans =
ans(:,:,1) =
   0   4   8
   1   5   9
   2   6  10
   3   7  11

ans(:,:,2) =
  12  16  20
  13  17  21
  14  18  22
  15  19  23
>> permute(arr3,[3,2,1])(:)'
ans =
 Columns 1 through 20:
   0   1   2   3   4   5   6   7   8   9  10  11  12  13  14  15  16  17  18  19
 Columns 21 through 24:
  20  21  22  23

The equivalent transpose in numpy

In [121]: arr3f.transpose(2,1,0).ravel()
Out[121]: 
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])

(Sorry for the rambling answer. I may go back an edit it. Hopefully it gives you something to work with.)

===

Let's try to apply that rambling more explicitly to your case

In [122]: x = np.array([[0, 1, 2, 3],
     ...:        [0, 1, 1, 3],
     ...:        [3, 1, 3, 1]])
     ...:        
In [123]: x3 = np.dstack((x,x,x))
In [125]: dx3 = x3.reshape(36,1)
In [126]: np.savetxt('test3.txt',dx3, fmt='%i')
In [127]: cat test3.txt
0
0
0
....
3
3
1
1
1

In Octave

>> file = fopen('test3.txt')
file =  21
>> array = fscanf(file,'%f')
array =
   0
   0
   ....

>> reshape(array,3,4,3)
ans =
ans(:,:,1) =
   0   1   2   3
   0   1   2   3
   0   1   2   3
ans(:,:,2) =
   0   1   1   3
   0   1   1   3
   0   1   1   3
ans(:,:,3) =
   3   1   3   1
   3   1   3   1
   3   1   3   1

and with the perumtation

>> permute(reshape(array,3,4,3),[3,2,1])
ans =
ans(:,:,1) =
   0   1   2   3
   0   1   1   3
   3   1   3   1
ans(:,:,2) =
   0   1   2   3
   0   1   1   3
   3   1   3   1
ans(:,:,3) =
   0   1   2   3
   0   1   1   3
   3   1   3   1
Improve this answer
Sign up to request clarification or add additional context in comments.

Comments

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.