TwistyPuzzleLib

///////////////////////////////////////////////////////////////////////////////////////////////////

// Copyright 2021 Leszek Koltunski                                                               //

//                                                                                               //

// This file is part of Magic Cube.                                                              //

//                                                                                               //

// Magic Cube is free software: you can redistribute it and/or modify                            //

// it under the terms of the GNU General Public License as published by                          //

// the Free Software Foundation, either version 2 of the License, or                             //

// (at your option) any later version.                                                           //

//                                                                                               //

// Magic Cube is distributed in the hope that it will be useful,                                 //

// but WITHOUT ANY WARRANTY; without even the implied warranty of                                //

// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the                                 //

// GNU General Public License for more details.                                                  //

//                                                                                               //

// You should have received a copy of the GNU General Public License                             //

// along with Magic Cube.  If not, see <http://www.gnu.org/licenses/>.                           //

///////////////////////////////////////////////////////////////////////////////////////////////////

package org.distorted.objectlib.objects;

import static org.distorted.objectlib.touchcontrol.TouchControl.TC_CUBOID;

import static org.distorted.objectlib.touchcontrol.TouchControl.TYPE_NOT_SPLIT;

import java.io.InputStream;

import org.distorted.library.main.DistortedLibrary;

import org.distorted.library.type.Static3D;

import org.distorted.library.type.Static4D;

import org.distorted.objectlib.helpers.FactoryBandagedCubit;

import org.distorted.objectlib.helpers.ObjectFaceShape;

import org.distorted.objectlib.helpers.ObjectSignature;

import org.distorted.objectlib.scrambling.ScrambleStateBandaged3x3;

import org.distorted.objectlib.touchcontrol.TouchControlHexahedron;

import org.distorted.objectlib.helpers.ObjectShape;

import org.distorted.objectlib.scrambling.ScrambleState;

import org.distorted.objectlib.main.ShapeHexahedron;

///////////////////////////////////////////////////////////////////////////////////////////////////

abstract class TwistyBandagedAbstract extends ShapeHexahedron

{

  private static final int CUBIT_111 = 0;

  private static final int CUBIT_211 = 1;

  private static final int CUBIT_311 = 2;

  private static final int CUBIT_221 = 3;

  private static final int CUBIT_222 = 4;

  private static final int CUBIT_OTH = 5;

  // the three rotation axis of a 3x3 Cube. Must be normalized.

  static final Static3D[] ROT_AXIS = new Static3D[]

         {

           new Static3D(1,0,0),

           new Static3D(0,1,0),

           new Static3D(0,0,1)

         };

  private static final int[][] mDims = new int[][]

        {

         {1,1,1},  // has to be X>=Z>=Y so that all

         {2,1,1},  // the faces are horizontal

         {3,1,1},

         {2,1,2},

         {2,2,2},

        };

  private int[][] mBasicAngle;

  private Static4D[] mInitQuats;

  private float[][] mCuts;

  private ScrambleState[] mStates;

  private int[] mCubitVariantMap;

  private int[] mTypeVariantMap;

  private int[][] mSolvedQuatsAbstract;

  float[][] POSITIONS;

///////////////////////////////////////////////////////////////////////////////////////////////////

  TwistyBandagedAbstract(int[] numL, int meshState, int iconMode, Static4D quat, Static3D move, float scale, InputStream stream)

    {

    super(numL, meshState, iconMode, (numL[0]+numL[1]+numL[2])/3.0f, quat, move, scale, stream);

    }

///////////////////////////////////////////////////////////////////////////////////////////////////

  abstract float[][] getPositions();

///////////////////////////////////////////////////////////////////////////////////////////////////

// return 0 if cubit is 'external' (it has at least two walls which belong to two different faces

// of the cuboid, faces which do not both rotate along the same axis! So: it is an edge, a corner,

// or a bandaged cubit which 'comes out' in two different, non-opposite, faces.

// Otherwise, if the cubit only comes out in one face or in two faces which are opposite to each other,

// return the index of the first of the three quats which rotate stuff in this face (so right or left

// return 1 because quats 1,2,3 are the ones rotating along the X axis)

  private int cubitIsExternal(float[] pos, float dx, float dy, float dz)

    {

    int len = pos.length/3;

    int x=0, y=0, z=0;

    for(int i=0; i<len; i++)

      {

      float cx = pos[3*i  ];

      float cy = pos[3*i+1];

      float cz = pos[3*i+2];

      if( cx>dx || cx<-dx ) x=1;

      if( cy>dy || cy<-dy ) y=1;

      if( cz>dz || cz<-dz ) z=1;

      }

    if( x+y+z>=2 ) return 0;

    if( x==1 ) return 1;

    if( y==1 ) return 4;

    if( z==1 ) return 7;

    android.util.Log.e("D", "ERROR: unsupported: internal cubit! ");

    return 0;

    }

///////////////////////////////////////////////////////////////////////////////////////////////////

// If we have a flat cuboid than retCubitSolvedStatus() wrongly reports that the internal cubits

// are edges (they do have two non-black faces after all!) which leads to wrong solvedQuats and

// mis-detection of a solved status. Correct this manually here.

//

// Note that this is still not completely good in case of bandaged cuboids - there can be a 4x4x2

// bandaged cuboid whose 4 'internal' cubits from the 4x4 face are fused with the other 4 internal

// cubits from the other 4x4 face - and those would again get mis-detected as edges...

  @Override

  public int[][] getSolvedQuats()

    {

    if( mSolvedQuatsAbstract==null )

      {

      int[] numLayers = getNumLayers();

      float dx = 0.5f*(numLayers[0]-1) - 0.1f;

      float dy = 0.5f*(numLayers[1]-1) - 0.1f;

      float dz = 0.5f*(numLayers[2]-1) - 0.1f;

      float[][] pos = getPositions();

      int numTotal = pos.length;

      boolean[] isExternal = new boolean[numTotal];

      int[] internalQuat = new int[numTotal];

      int numExternal = 0;

      int pointer = 0;

      for(int cubit=0; cubit<numTotal; cubit++)

        {

        int q = cubitIsExternal(pos[cubit],dx,dy,dz);

        if( q<=0 )

          {

          isExternal[cubit] = true;

          numExternal++;

          }

        else

          {

          isExternal[cubit] = false;

          internalQuat[pointer] = q;

          pointer++;

          }

        }

      int numInternal = numTotal - numExternal;

      mSolvedQuatsAbstract = new int[numInternal+1][];

      mSolvedQuatsAbstract[0] = new int[numExternal+1];

      mSolvedQuatsAbstract[0][0] = numExternal;

      for(int i=0; i<numInternal; i++)

        {

        int q = internalQuat[i];

        mSolvedQuatsAbstract[i+1] = new int[5];

        mSolvedQuatsAbstract[i+1][0] = 1;

        mSolvedQuatsAbstract[i+1][2] = q;

        mSolvedQuatsAbstract[i+1][3] = q+1;

        mSolvedQuatsAbstract[i+1][4] = q+2;

        }

      int pointerExternal = 1;

      int pointerInternal = 1;

      for(int cubit=0; cubit<numTotal; cubit++)

        {

        if( isExternal[cubit] ) mSolvedQuatsAbstract[0][pointerExternal++] = cubit;

        else                    mSolvedQuatsAbstract[pointerInternal++][1] = cubit;

        }

      }

    return mSolvedQuatsAbstract;

    }

///////////////////////////////////////////////////////////////////////////////////////////////////

  public ObjectSignature getSignature()

    {

    long signature = 0;

    float[][] positions = getPositions();

    for(float[] pos : positions ) signature = markConnections(signature,pos);

    return new ObjectSignature(signature);

    }

///////////////////////////////////////////////////////////////////////////////////////////////////

  public ScrambleState[] getScrambleStates()

    {

    if( mStates==null && !isInIconMode() )

      {

      ObjectSignature signature = getSignature();

      mStates = ScrambleStateBandaged3x3.computeGraph(signature.getLong3());

      }

    return mStates;

    }

///////////////////////////////////////////////////////////////////////////////////////////////////

  private int getType(float[] pos)

    {

    switch(pos.length)

      {

      case  3: return CUBIT_111;

      case  6: return CUBIT_211;

      case  9: boolean x1 = (pos[0]==pos[3] && pos[0]==pos[6]);

               boolean y1 = (pos[1]==pos[4] && pos[1]==pos[7]);

               boolean z1 = (pos[2]==pos[5] && pos[2]==pos[8]);

               return ( (x1&&y1) || (x1&&z1) || (y1&&z1) ) ? CUBIT_311 : CUBIT_OTH;

      case 12: float x = (pos[0]+pos[3]+pos[6]+pos[ 9])/4;

               float y = (pos[1]+pos[4]+pos[7]+pos[10])/4;

               float z = (pos[2]+pos[5]+pos[8]+pos[11])/4;

               float d1 = (pos[0]-x)*(pos[0]-x) + (pos[ 1]-y)*(pos[ 1]-y) + (pos[ 2]-z)*(pos[ 2]-z);

               float d2 = (pos[3]-x)*(pos[3]-x) + (pos[ 4]-y)*(pos[ 4]-y) + (pos[ 5]-z)*(pos[ 5]-z);

               float d3 = (pos[6]-x)*(pos[6]-x) + (pos[ 7]-y)*(pos[ 7]-y) + (pos[ 8]-z)*(pos[ 8]-z);

               float d4 = (pos[9]-x)*(pos[9]-x) + (pos[10]-y)*(pos[10]-y) + (pos[11]-z)*(pos[11]-z);

               return ( d1==0.5f && d2==0.5f && d3==0.5f && d4==0.5f ) ? CUBIT_221 : CUBIT_OTH;

      case 24: float x3 = pos[0];

               float y3 = pos[1];

               float z3 = pos[2];

               float x4=-10,y4=-10,z4=-10;

               int i;

               for(i=0; i<8; i++)

                 {

                 if( pos[3*i]!=x3 && pos[3*i+1]!=y3 && pos[3*i+2]!=z3 )

                   {

                   x4 = pos[3*i  ];

                   y4 = pos[3*i+1];

                   z4 = pos[3*i+2];

                   break;

                   }

                 }

               if( i==9 ) return CUBIT_OTH;

               float dX = x4-x3;

               float dY = y4-y3;

               float dZ = z4-z3;

               if( (dX==1.0f || dX==-1.0f) && (dY==1.0f || dY==-1.0f) && (dZ==1.0f || dZ==-1.0f) )

                 {

                 for(i=0; i<8; i++)

                   {

                   if( (pos[3*i  ]!=x3 && pos[3*i  ]!=x4) ||

                       (pos[3*i+1]!=y3 && pos[3*i+1]!=y4) ||

                       (pos[3*i+2]!=z3 && pos[3*i+2]!=z4)  ) return CUBIT_OTH;

                   }

                 return CUBIT_222;

                 }

      default: return CUBIT_OTH;

      }

    }

///////////////////////////////////////////////////////////////////////////////////////////////////

  private int getQuatIndex(int cubit)

    {

    float[][] positions = getPositions();

    int len = positions.length;

    if( cubit>=0 && cubit<len )

      {

      float[] pos = positions[cubit];

      int type = getType(pos);

      switch(type)

        {

        case CUBIT_222:

        case CUBIT_111: return 0;

        case CUBIT_211:

        case CUBIT_311: return (pos[1]==pos[4]) ? (pos[0]==pos[3] ? 2 : 0) : 3;

        case CUBIT_221: if( pos[0]==pos[3] && pos[0]==pos[6] ) return 3;

                        if( pos[1]==pos[4] && pos[1]==pos[7] ) return 0;

                        if( pos[2]==pos[5] && pos[2]==pos[8] ) return 1;

        }

      }

    return 0;

    }

///////////////////////////////////////////////////////////////////////////////////////////////////

  private int getSigIndex(float x, float y, float z)

    {

    if( x==-1.0f )

      {

           if( y==-1.0f ) return z==0.5f ? 4:9;

      else if( y==-0.5f ) return z==1.0f ? 14 : (z==0.0f ? 17:20);

      else if( y== 0.0f ) return z==0.5f ? 25:30;

      else if( y== 0.5f ) return z==1.0f ? 35 : (z==0.0f ? 38:41);

      else if( y== 1.0f ) return z==0.5f ? 46:51;

      }

    else if( x==-0.5f )

      {

           if( y==-1.0f ) return z==1.0f ? 1  : (z==0.0f ?  6:11);

      else if( y== 0.0f ) return z==1.0f ? 22 : (z==0.0f ? 27:32);

      else if( y== 1.0f ) return z==1.0f ? 43 : (z==0.0f ? 48:53);

      }

    else if( x==0.0f )

      {

           if( y==-1.0f ) return z==0.5f ? 3:8;

      else if( y==-0.5f ) return z==1.0f ? 13 : (z==0.0f ? 16:19);

      else if( y== 0.0f ) return z==0.5f ? 24:29;

      else if( y== 0.5f ) return z==1.0f ? 34 : (z==0.0f ? 37:40);

      else if( y== 1.0f ) return z==0.5f ? 45:50;

      }

    else if( x==0.5f )

      {

           if( y==-1.0f ) return z==1.0f ? 0  : (z==0.0f ?  5:10);

      else if( y== 0.0f ) return z==1.0f ? 21 : (z==0.0f ? 26:31);

      else if( y== 1.0f ) return z==1.0f ? 42 : (z==0.0f ? 47:52);

      }

    else if( x==1.0f )

      {

           if( y==-1.0f ) return z==0.5f ? 2:7;

      else if( y==-0.5f ) return z==1.0f ? 12 : (z==0.0f ? 15:18);

      else if( y== 0.0f ) return z==0.5f ? 23:28;

      else if( y== 0.5f ) return z==1.0f ? 33 : (z==0.0f ? 36:39);

      else if( y== 1.0f ) return z==0.5f ? 44:49;

      }

    else

      {

      android.util.Log.e("D", "ERROR! mx="+x);

      }

    return -1;

    }

///////////////////////////////////////////////////////////////////////////////////////////////////

  private long markConnection(float x1, float y1, float z1, float x2, float y2, float z2)

    {

    float dx = x1-x2;

    float dy = y1-y2;

    float dz = z1-z2;

    if( (dx==0 && dy==0 && (dz==1 || dz==-1) ) ||

        (dz==0 && dx==0 && (dy==1 || dy==-1) ) ||

        (dy==0 && dz==0 && (dx==1 || dx==-1) )  )

      {

      float mx = (x1+x2)/2;

      float my = (y1+y2)/2;

      float mz = (z1+z2)/2;

      int index = getSigIndex(mx,my,mz);

      return (1L<<index);

      }

    return 0;

    }

///////////////////////////////////////////////////////////////////////////////////////////////////

  long markConnections(long signature, float[] position)

    {

    int len = position.length/3;

    for(int i=0; i<len; i++)

      {

      float x = position[3*i  ];

      float y = position[3*i+1];

      float z = position[3*i+2];

      for(int j=i+1; j<len; j++)

        {

        signature |= markConnection(x,y,z,position[3*j],position[3*j+1],position[3*j+2]);

        }

      }

    return signature;

    }

///////////////////////////////////////////////////////////////////////////////////////////////////

  public ObjectShape getObjectShape(int variant)

    {

    int type,numTypes = mDims.length;

    for(type=0; type<numTypes; type++) if( mTypeVariantMap[type]==variant ) break;

    if( type<numTypes )

      {

      int X = mDims[type][0];

      int Y = mDims[type][1];

      int Z = mDims[type][2];

      float[][] vertices =

        {

          {+0.5f*X,+0.5f*Y,+0.5f*Z},

          {+0.5f*X,+0.5f*Y,-0.5f*Z},

          {+0.5f*X,-0.5f*Y,+0.5f*Z},

          {+0.5f*X,-0.5f*Y,-0.5f*Z},

          {-0.5f*X,+0.5f*Y,+0.5f*Z},

          {-0.5f*X,+0.5f*Y,-0.5f*Z},

          {-0.5f*X,-0.5f*Y,+0.5f*Z},

          {-0.5f*X,-0.5f*Y,-0.5f*Z}

        };

      int[][] indices =

        {

          {2,3,1,0},

          {7,6,4,5},

          {4,0,1,5},

          {7,3,2,6},

          {6,2,0,4},

          {3,7,5,1},

        };

      return new ObjectShape(vertices, indices);

      }

    float[][] positions = getPositions();

    int cubit,numCubits = positions.length;

    for(cubit=0; cubit<numCubits; cubit++)

      {

      if( mCubitVariantMap[cubit]==variant ) break;

      }

    if( cubit>=numCubits )

      {

      android.util.Log.e("D", "unknown variant: "+variant);

      return null;

      }

    FactoryBandagedCubit factory = FactoryBandagedCubit.getInstance();

    return factory.createIrregularShape(variant,positions[cubit]);

    }

///////////////////////////////////////////////////////////////////////////////////////////////////

  public ObjectFaceShape getObjectFaceShape(int variant)

    {

    boolean roundCorners = DistortedLibrary.fastCompilationTF();

    int type,numTypes = mDims.length;

    for(type=0; type<numTypes; type++) if( mTypeVariantMap[type]==variant ) break;

    if( type<numTypes )

      {

      int val = roundCorners ? 0 : -1;

      int X = mDims[type][0];

      int Y = mDims[type][1];

      int Z = mDims[type][2];

      float height        = isInIconMode() ? 0.001f : 0.048f;

      int[] bandIndices   = { 0,0,1,1,2,2 };

      float[][] corners   = { {0.04f,0.15f} };

      int[] cornerIndices = { val,val,val,val,val,val,val,val };

      int[] centerIndices = { 0,1,2,3,4,5,6,7 };

      int maxXY = Math.max(X,Y);

      int maxXZ = Math.max(X,Z);

      int maxYZ = Math.max(Y,Z);

      int angle = 45;

      float R = 0.25f;

      float S = 0.50f;

      float[][] bands =

        {

          {height/maxYZ,angle,R,S,5,0,0},

          {height/maxXZ,angle,R,S,5,0,0},

          {height/maxXY,angle,R,S,5,0,0}

        };

      float[][] centers =

        {

          {+0.5f*(X-1),+0.5f*(Y-1),+0.5f*(Z-1)},

          {+0.5f*(X-1),+0.5f*(Y-1),-0.5f*(Z-1)},

          {+0.5f*(X-1),-0.5f*(Y-1),+0.5f*(Z-1)},

          {+0.5f*(X-1),-0.5f*(Y-1),-0.5f*(Z-1)},

          {-0.5f*(X-1),+0.5f*(Y-1),+0.5f*(Z-1)},

          {-0.5f*(X-1),+0.5f*(Y-1),-0.5f*(Z-1)},

          {-0.5f*(X-1),-0.5f*(Y-1),+0.5f*(Z-1)},

          {-0.5f*(X-1),-0.5f*(Y-1),-0.5f*(Z-1)}

        };

      return new ObjectFaceShape(bands,bandIndices,corners,cornerIndices,centers,centerIndices,null);

      }

    FactoryBandagedCubit factory = FactoryBandagedCubit.getInstance();

    return factory.createIrregularFaceShape(variant, isInIconMode(), roundCorners );

    }

///////////////////////////////////////////////////////////////////////////////////////////////////

  public float[][] getCubitPositions(int[] numLayers)

    {

    return getPositions();

    }

///////////////////////////////////////////////////////////////////////////////////////////////////

  public Static4D getCubitQuats(int cubit, int[] numLayers)

    {

    if( mInitQuats ==null )

      {

      mInitQuats = new Static4D[]

        {

        new Static4D(  0.0f,   0.0f,   0.0f,   1.0f),  // NULL

        new Static4D( SQ2/2,   0.0f,   0.0f, -SQ2/2),  // X

        new Static4D(  0.0f,  SQ2/2,   0.0f, -SQ2/2),  // Y

        new Static4D(  0.0f,   0.0f,  SQ2/2, -SQ2/2),  // Z

        new Static4D( -0.5f,  +0.5f,  -0.5f,  +0.5f),  // ZX

        new Static4D( +0.5f,  +0.5f,  +0.5f,  -0.5f),  // YX

        };

      }

    return mInitQuats[getQuatIndex(cubit)];

    }

///////////////////////////////////////////////////////////////////////////////////////////////////

  public int getNumCubitVariants(int[] numLayers)

    {

    int numVariants = 0;

    float[][] positions = getPositions();

    boolean C111=false;

    boolean C211=false;

    boolean C311=false;

    boolean C221=false;

    boolean C222=false;

    int numCubits = positions.length;

    mCubitVariantMap = new int[numCubits];

    int numTypes = mDims.length;

    mTypeVariantMap = new int[numTypes];

    for(int i=0; i<numTypes; i++) mTypeVariantMap[i] = -1;

    for (int cubit=0; cubit<numCubits; cubit++)

      {

      int type = getType(positions[cubit]);

      switch (type)

        {

        case CUBIT_111: if (!C111) { C111 = true; mTypeVariantMap[CUBIT_111]=numVariants++; }

                        mCubitVariantMap[cubit]=mTypeVariantMap[CUBIT_111];

                        break;

        case CUBIT_211: if (!C211) { C211 = true; mTypeVariantMap[CUBIT_211]=numVariants++; }

                        mCubitVariantMap[cubit]=mTypeVariantMap[CUBIT_211];

                        break;

        case CUBIT_311: if (!C311) { C311 = true; mTypeVariantMap[CUBIT_311]=numVariants++; }

                        mCubitVariantMap[cubit]=mTypeVariantMap[CUBIT_311];

                        break;

        case CUBIT_221: if (!C221) { C221 = true; mTypeVariantMap[CUBIT_221]=numVariants++; }

                        mCubitVariantMap[cubit]=mTypeVariantMap[CUBIT_221];

                        break;

        case CUBIT_222: if (!C222) { C222 = true; mTypeVariantMap[CUBIT_222]=numVariants++; }

                        mCubitVariantMap[cubit]=mTypeVariantMap[CUBIT_222];

                        break;

        default       : mCubitVariantMap[cubit] = numVariants++;

        }

      }

    FactoryBandagedCubit factory = FactoryBandagedCubit.getInstance();

    factory.prepare(numVariants,numLayers[0],numLayers[1],numLayers[2]);

    return numVariants;

    }

///////////////////////////////////////////////////////////////////////////////////////////////////

  public int getCubitVariant(int cubit, int[] numLayers)

    {

    return mCubitVariantMap[cubit];

    }

///////////////////////////////////////////////////////////////////////////////////////////////////

  public float[][] getCuts(int[] numLayers)

    {

    if( mCuts==null )

      {

      mCuts = new float[3][];

      for(int axis=0; axis<3; axis++)

        {

        int len = numLayers[axis];

        float start = (2-len)*0.5f;

        if( len>=2 )

          {

          mCuts[axis] = new float[len-1];

          for(int i=0; i<len-1; i++) mCuts[axis][i] = start+i;

          }

        }

      }

    return mCuts;

    }

///////////////////////////////////////////////////////////////////////////////////////////////////

  public boolean[][] getLayerRotatable(int[] numLayers)

    {

    int numAxis = ROT_AXIS.length;

    boolean[][] layerRotatable = new boolean[numAxis][];

    for(int i=0; i<numAxis; i++)

      {

      layerRotatable[i] = new boolean[numLayers[i]];

      for(int j=0; j<numLayers[i]; j++) layerRotatable[i][j] = true;

      }

    return layerRotatable;

    }

///////////////////////////////////////////////////////////////////////////////////////////////////

  public int getTouchControlType()

    {

    return TC_CUBOID;

    }

///////////////////////////////////////////////////////////////////////////////////////////////////

  public int getTouchControlSplit()

    {

    return TYPE_NOT_SPLIT;

    }

///////////////////////////////////////////////////////////////////////////////////////////////////

  public int[][][] getEnabled()

    {

    return new int[][][] { {{1,2}},{{1,2}},{{0,2}},{{0,2}},{{0,1}},{{0,1}} };

    }

///////////////////////////////////////////////////////////////////////////////////////////////////

  public float[] getDist3D(int[] numLayers)

    {

    float x = numLayers[0];

    float y = numLayers[1];

    float z = numLayers[2];

    float a = (x+y+z)/1.5f;

    return new float[] {x/a,x/a,y/a,y/a,z/a,z/a};

    }

///////////////////////////////////////////////////////////////////////////////////////////////////

  public Static3D[] getFaceAxis()

    {

    return TouchControlHexahedron.FACE_AXIS;

    }

///////////////////////////////////////////////////////////////////////////////////////////////////

  public float getStickerRadius()

    {

    return 0.10f;

    }

///////////////////////////////////////////////////////////////////////////////////////////////////

  public float getStickerStroke()

    {

    return isInIconMode() ? 0.16f : 0.08f;

    }

///////////////////////////////////////////////////////////////////////////////////////////////////

  public float[][] getStickerAngles()

    {

    return null;

    }

///////////////////////////////////////////////////////////////////////////////////////////////////

// PUBLIC API

  public Static3D[] getRotationAxis()

    {

    return ROT_AXIS;

    }

///////////////////////////////////////////////////////////////////////////////////////////////////

  public int[][] getBasicAngles()

    {

     if( mBasicAngle==null )

      {

      int[] num = getNumLayers();

      int numX = num[0];

      int numY = num[1];

      int numZ = num[2];

      int x = numY==numZ ? 4 : 2;

      int y = numX==numZ ? 4 : 2;

      int z = numX==numY ? 4 : 2;

      int[] tmpX = new int[numX];

      for(int i=0; i<numX; i++) tmpX[i] = x;