Trying to rotate a 3D matrix for full symmetry group (group theory)

Hi all,

I currently have a 32x32x32 matrix and I'm trying to get all possible rotations of it (the full symmetry set) and store them all.

My code is shown below;

It takes a dataset as matrix and then rotates it in 7 different ways around the x axis, this gives me 8 out of the 24 rotations of the full set. Are there functions that do the same as what I did below for the other 2 axes (y and z)? I cannot find a function that does this, and am hesitant to remap everything manually since there's a dataset of 800.000 matrices that I have to do this with.

    matrix = dataset(:,:,:,i);
    matrix2=flip(matrix);
    matrix3=flip(matrix,2);

    matrix5=rot90(matrix);
    matrix4=rot90(matrix,2);
    matrix7=rot90(matrix,3);
    
    matrix6=rot90(flip(matrix));
    matrix8=rot90(flip(matrix),3);

[David Goodmanson]

HI Simon

four of the rotations you show are not rotations, because the flip function performs a reflection. Reflections are not part of the symmetry group you are considering.

Do you have 8e5 matrices in all?

[Simon Penninag]

Hi David,

you're right, I didn't know this. I'm only trying to find the 24 rotations.

The code that I showed you is only part of the full code; I'll post the full code here.

Dataset is a 32x32x32x800000 matrix, and I'm trying to store it in the fullset matrix (the storing order in fullset is because of later steps, it shouldn't matter that much).

Thanks in advance!

n = length(dataset(1,1,1,:));
fullset = false(8*n,vertice,vertice,vertice);
for i=1:n
    matrix = dataset(:,:,:,i);
    matrix2=flip(matrix);
    matrix3=flip(matrix,2);

    matrix5=rot90(matrix);
    matrix4=rot90(matrix,2);
    matrix7=rot90(matrix,3);

    matrix6=rot90(flip(matrix));
    matrix8=rot90(flip(matrix),3);
    
    


    fullset(i,:,:,:)=matrix;
    fullset(i+n,:,:,:)=matrix2;
    fullset(i+2*n,:,:,:)=matrix3;
    fullset(i+3*n,:,:,:)=matrix4;
    fullset(i+4*n,:,:,:)=matrix5;
    fullset(i+5*n,:,:,:)=matrix6;
    fullset(i+6*n,:,:,:)=matrix7;
    fullset(i+7*n,:,:,:)=matrix8;


end

[Jan]

Note: Use size(dataset, 4) instead of length(dataset(1,1,1,:));

Your input array of size 32x32x32x800000 needs 26.2 GB of RAM, if it is a LOGICAL array. Creating a list of all 24 reflections and rotation will need 629 GB of RAM. Do you have a really large computer? Is there a good reason to store this huge redundant pile of arrays?

Which problem do you want to solve?

[Simon Penninag]

Hi Jan,

the problem is solved already, i found out about a function that someone in the community made. Yes you're right I'm currently running the code to create a 2.400.000x32x32x32 matrix (it was actually only 100.000*24 not 800.000) which is actually a logical. This comes down to ~80GB which seems to work fine after messing with virtual memory a bit on a 32GB system. For future readers that find this and are interested in the (hardcoded inefficient) solution:

for i=1:n
    matrix = dataset(:,:,:,i);
    
    matrix2 = rot3d90(matrix,1,1);
    matrix3 = rot3d90(matrix,1,2);
    matrix4 = rot3d90(matrix,1,3);
    
    matrix5 = rot3d90(matrix,2,2);
    matrix6 = rot3d90(matrix5,1,1);
    matrix7 = rot3d90(matrix5,1,2);
    matrix8 = rot3d90(matrix5,1,3);
    
    matrix9 = rot3d90(matrix,2,1);
    matrix10 = rot3d90(matrix,2,3);
    
    matrix11 = rot3d90(matrix9,3,1);
    matrix12 = rot3d90(matrix9,3,2);
    matrix13 = rot3d90(matrix9,3,3);
    
    matrix14 = rot3d90(matrix10,3,1);
    matrix15 = rot3d90(matrix10,3,2);
    matrix16 = rot3d90(matrix10,3,3);
    
    matrix17 = rot3d90(matrix,3,1);
    matrix18 = rot3d90(matrix,3,3);
    
    
    matrix19 = rot3d90(matrix17,2,1);
    matrix20 = rot3d90(matrix17,2,2);
    matrix21 = rot3d90(matrix17,2,3);
    
    matrix22 = rot3d90(matrix18,2,1);
    matrix23 = rot3d90(matrix18,2,2);
    matrix24 = rot3d90(matrix18,2,3);
    
    fullset(i,:,:,:,1)=matrix;
    fullset(i+n,:,:,:,1)=matrix2;
    fullset(i+2*n,:,:,:,1)=matrix3;
    fullset(i+3*n,:,:,:,1)=matrix4;
    fullset(i+4*n,:,:,:,1)=matrix5;
    fullset(i+5*n,:,:,:,1)=matrix6;
    fullset(i+6*n,:,:,:,1)=matrix7;
    fullset(i+7*n,:,:,:,1)=matrix8;
    fullset(i+8*n,:,:,:,1)=matrix9;
    fullset(i+9*n,:,:,:,1)=matrix10;
    fullset(i+10*n,:,:,:,1)=matrix11;
    fullset(i+11*n,:,:,:,1)=matrix12;
    fullset(i+12*n,:,:,:,1)=matrix13;
    fullset(i+13*n,:,:,:,1)=matrix14;
    fullset(i+14*n,:,:,:,1)=matrix15;
    fullset(i+15*n,:,:,:,1)=matrix16;
    fullset(i+16*n,:,:,:,1)=matrix17;
    fullset(i+17*n,:,:,:,1)=matrix18;
    fullset(i+18*n,:,:,:,1)=matrix19;
    fullset(i+19*n,:,:,:,1)=matrix20;
    fullset(i+20*n,:,:,:,1)=matrix21;
    fullset(i+21*n,:,:,:,1)=matrix22;
    fullset(i+22*n,:,:,:,1)=matrix23;
    fullset(i+23*n,:,:,:,1)=matrix24;    
end

[Jan]

I assume this is the used function: https://www.mathworks.com/matlabcentral/fileexchange/65753-rot3d90-a-x-k

[Simon Penninag]

Yes.

[Jan]

Note that rot3d90 handles multidimensional inputs directly. So you can omit the loop:

matrix2 = rot3d90(a,1,1);
matrix3 = rot3d90(a,1,2);
matrix4 = rot3d90(a,1,3);

matrix5 = rot3d90(a,2,2);
matrix6 = rot3d90(matrix5,1,1);
matrix7 = rot3d90(matrix5,1,2);
matrix8 = rot3d90(matrix5,1,3);

matrix9 = rot3d90(a,2,1);
matrix10 = rot3d90(a,2,3);

matrix11 = rot3d90(matrix9,3,1);
matrix12 = rot3d90(matrix9,3,2);
matrix13 = rot3d90(matrix9,3,3);

matrix14 = rot3d90(matrix10,3,1);
matrix15 = rot3d90(matrix10,3,2);
matrix16 = rot3d90(matrix10,3,3);

matrix17 = rot3d90(a,3,1);
matrix18 = rot3d90(a,3,3);

matrix19 = rot3d90(matrix17,2,1);
matrix20 = rot3d90(matrix17,2,2);
matrix21 = rot3d90(matrix17,2,3);

matrix22 = rot3d90(matrix18,2,1);
matrix23 = rot3d90(matrix18,2,2);
matrix24 = rot3d90(matrix18,2,3);

p = [4, 1, 2, 3];
fullset = cat(1, ...
   permute(a,        p), ...
   permute(matrix2,  p), ...
   permute(matrix3,  p), ...
   permute(matrix4,  p), ...
   permute(matrix5,  p), ...
   permute(matrix6,  p), ...
   permute(matrix7,  p), ...
   permute(matrix8,  p), ...
   permute(matrix9,  p), ...
   permute(matrix10, p), ...
   permute(matrix11, p), ...
   permute(matrix12, p), ...
   permute(matrix13, p), ...
   permute(matrix14, p), ...
   permute(matrix15, p), ...
   permute(matrix16, p), ...
   permute(matrix17, p), ...
   permute(matrix18, p), ...
   permute(matrix19, p), ...
   permute(matrix20, p), ...
   permute(matrix21, p), ...
   permute(matrix22, p), ...
   permute(matrix23, p), ...
   permute(matrix24, p));