Magic Cube

    api project(':distorted-library')

import org.distorted.objectlib.TwistyObject;

import org.distorted.objectlib.QuatHelper;

import org.distorted.objectlib.TwistyObject;

  private TextView[] mDurationText;

import org.distorted.objectlib.ObjectList;

import org.distorted.objectlib.ObjectList;

  private Context mContext;

  private int mTab, mWidth;

  private FragmentActivity mAct;

  private RubikDialogPatternView[] mViews;

  private RubikDialogPattern mDialog;

  private int mNumTabs;

import org.distorted.objectlib.ObjectList;

import android.view.WindowManager;

import org.distorted.objectlib.ObjectList;

import org.distorted.objectlib.ObjectList;

import org.distorted.objectlib.ObjectList;

import org.distorted.objectlib.ObjectList;

import android.view.WindowManager;

import org.distorted.objectlib.ObjectList;

import org.distorted.library.main.DistortedScreen;

import org.distorted.helpers.MovesFinished;

import org.distorted.objectlib.TwistyObject;

import org.distorted.effects.BaseEffect;

import org.distorted.effects.EffectController;

import org.distorted.objectlib.TwistyObject;

import java.lang.reflect.Method;

import org.distorted.effects.BaseEffect;

import org.distorted.helpers.MovesFinished;

import org.distorted.effects.EffectController;

import org.distorted.objectlib.ObjectList;

import org.distorted.objectlib.TwistyObject;

import java.lang.reflect.Method;

import java.util.Random;

import java.util.Random;

import org.distorted.effects.BaseEffect;

import org.distorted.effects.EffectController;

import org.distorted.objectlib.TwistyObject;

import java.lang.reflect.Method;

import org.distorted.effects.BaseEffect;

import org.distorted.effects.EffectController;

import org.distorted.objectlib.TwistyObject;

import java.lang.reflect.Method;

import org.distorted.library.message.EffectMessageSender;

import org.distorted.main.BuildConfig;

import java.util.ArrayList;

import java.util.Timer;

import java.util.TimerTask;

import android.content.res.Resources;

import org.distorted.library.main.DistortedEffects;

import org.distorted.library.main.DistortedLibrary;

import org.distorted.library.main.DistortedScreen;

import org.distorted.library.main.DistortedTexture;

import org.distorted.library.mesh.MeshSquare;

import org.distorted.library.type.Static4D;

import org.distorted.objectlib.TwistyObject;

import org.distorted.objectlib.ObjectList;

import org.distorted.objects.TwistyBandaged2Bar;

import org.distorted.objects.TwistyBandaged3Plate;

import org.distorted.objects.TwistyBandagedEvil;

import org.distorted.objects.TwistyBandagedFused;

import org.distorted.objects.TwistyCube;

import org.distorted.objects.TwistyDiamond;

import org.distorted.objects.TwistyDino4;

import org.distorted.objects.TwistyDino6;

import org.distorted.objects.TwistyHelicopter;

import org.distorted.objects.TwistyIvy;

import org.distorted.objects.TwistyJing;

import org.distorted.objects.TwistyKilominx;

import org.distorted.objects.TwistyMegaminx;

import org.distorted.objects.TwistyMirror;

import org.distorted.objects.TwistyPyraminx;

import org.distorted.objects.TwistyRedi;

import org.distorted.objects.TwistyRex;

import org.distorted.objects.TwistySkewb;

import org.distorted.objects.TwistySquare1;

import org.distorted.objects.TwistySquare2;

import org.distorted.objects.TwistyUltimate;

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

  public static TwistyObject create(ObjectList object, int size, Static4D quat, int[][] moves, Resources res, int scrWidth)

    {

    DistortedTexture texture = new DistortedTexture();

    DistortedEffects effects = new DistortedEffects();

    MeshSquare mesh          = new MeshSquare(20,20);   // mesh of the node, not of the cubits

    switch(object.ordinal())

      {

      case  0: return new TwistyCube           (size, quat, texture, mesh, effects, moves, res, scrWidth);

      case  1: return new TwistyJing           (size, quat, texture, mesh, effects, moves, res, scrWidth);

      case  2: return new TwistyPyraminx       (size, quat, texture, mesh, effects, moves, res, scrWidth);

      case  3: return new TwistyKilominx       (size, quat, texture, mesh, effects, moves, res, scrWidth);

      case  4: return new TwistyMegaminx       (size, quat, texture, mesh, effects, moves, res, scrWidth);

      case  5: return new TwistyUltimate       (size, quat, texture, mesh, effects, moves, res, scrWidth);

      case  6: return new TwistyDiamond        (size, quat, texture, mesh, effects, moves, res, scrWidth);

      case  7: return new TwistyDino6          (size, quat, texture, mesh, effects, moves, res, scrWidth);

      case  8: return new TwistyDino4          (size, quat, texture, mesh, effects, moves, res, scrWidth);

      case  9: return new TwistyRedi           (size, quat, texture, mesh, effects, moves, res, scrWidth);

      case 10: return new TwistyHelicopter     (size, quat, texture, mesh, effects, moves, res, scrWidth);

      case 11: return new TwistySkewb          (size, quat, texture, mesh, effects, moves, res, scrWidth);

      case 12: return new TwistyIvy            (size, quat, texture, mesh, effects, moves, res, scrWidth);

      case 13: return new TwistyRex            (size, quat, texture, mesh, effects, moves, res, scrWidth);

      case 14: return new TwistyBandagedFused  (size, quat, texture, mesh, effects, moves, res, scrWidth);

      case 15: return new TwistyBandaged2Bar   (size, quat, texture, mesh, effects, moves, res, scrWidth);

      case 16: return new TwistyBandaged3Plate (size, quat, texture, mesh, effects, moves, res, scrWidth);

      case 17: return new TwistyBandagedEvil   (size, quat, texture, mesh, effects, moves, res, scrWidth);

      case 18: return new TwistySquare1        (size, quat, texture, mesh, effects, moves, res, scrWidth);

      case 19: return new TwistySquare2        (size, quat, texture, mesh, effects, moves, res, scrWidth);

      case 20: return new TwistyMirror         (size, quat, texture, mesh, effects, moves, res, scrWidth);

      }

    return null;

    }

import org.distorted.objectlib.TwistyObject;

import org.distorted.objectlib.ObjectList;

    mNewObject = RubikActivity.create(object,size, mView.getQuat(), moves, res, mScreenWidth);

import org.distorted.objectlib.QuatHelper;

import org.distorted.objectlib.TwistyObject;

import org.distorted.objectlib.Movement;

import org.distorted.solvers.SolverMain;

import org.distorted.objectlib.ObjectList;

import java.io.InputStream;

import java.net.HttpURLConnection;

import java.net.URL;

import java.net.UnknownHostException;

import java.security.MessageDigest;

import java.security.NoSuchAlgorithmException;

import static org.distorted.objectlib.ObjectList.MAX_LEVEL;

import org.distorted.main.BuildConfig;

import org.distorted.objectlib.ObjectList;

import java.util.UUID;

import static org.distorted.objectlib.ObjectList.MAX_NUM_OBJECTS;

import static org.distorted.objectlib.ObjectList.NUM_OBJECTS;

import static org.distorted.objectlib.ObjectList.MAX_LEVEL;

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

// Copyright 2019 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;

import android.content.SharedPreferences;

import org.distorted.library.type.Static4D;

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

public class Cubit

  {

  private final float[] mOrigPosition;

  private final float[] mCurrentPosition;

  private final int mNumAxis;

  private final int mLen;

  private final int[] mRotationRow;

  private TwistyObject mParent;

  int mQuatIndex;

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

  Cubit(TwistyObject parent, float[] position, int numAxis)

    {

    mQuatIndex= 0;

    mParent   = parent;

    mLen      = position.length;

    mOrigPosition    = new float[mLen];

    mCurrentPosition = new float[mLen];

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

      {

      mOrigPosition[i]    = position[i];

      mCurrentPosition[i] = position[i];

      }

    mNumAxis     = numAxis;

    mRotationRow = new int[mNumAxis];

    computeRotationRow();

    }

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

// Because of quatMultiplication, errors can accumulate - so to avoid this, we

// correct the value of the 'scramble' quat to what it should be - one of the legal quats from the

// list QUATS.

//

// We also have to remember that the group of unit quaternions is a double-cover of rotations

// in 3D ( q represents the same rotation as -q ) - so invert if needed.

  private int normalizeScrambleQuat(Static4D quat)

    {

    float x = quat.get0();

    float y = quat.get1();

    float z = quat.get2();

    float w = quat.get3();

    float xd,yd,zd,wd;

    float diff, mindiff = Float.MAX_VALUE;

    int ret=0;

    int num_quats = mParent.OBJECT_QUATS.length;

    Static4D qt;

    for(int q=0; q<num_quats; q++)

      {

      qt = mParent.OBJECT_QUATS[q];

      xd = x - qt.get0();

      yd = y - qt.get1();

      zd = z - qt.get2();

      wd = w - qt.get3();

      diff = xd*xd + yd*yd + zd*zd + wd*wd;

      if( diff < mindiff )

        {

        ret = q;

        mindiff = diff;

        }

      xd = x + qt.get0();

      yd = y + qt.get1();

      zd = z + qt.get2();

      wd = w + qt.get3();

      diff = xd*xd + yd*yd + zd*zd + wd*wd;

      if( diff < mindiff )

        {

        ret = q;

        mindiff = diff;

        }

      }

    return ret;

    }

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

  private void computeRotationRow()

    {

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

      {

      mRotationRow[i] = mParent.computeRow(mCurrentPosition,i);

      }

    }

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

  void modifyCurrentPosition(Static4D quat)

    {

    Static4D cubitCenter;

    Static4D rotatedCenter;

    int len = mLen/3;

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

      {

      cubitCenter =  new Static4D(mCurrentPosition[3*i], mCurrentPosition[3*i+1], mCurrentPosition[3*i+2], 0);

      rotatedCenter = QuatHelper.rotateVectorByQuat( cubitCenter, quat);

      mCurrentPosition[3*i  ] = rotatedCenter.get0();

      mCurrentPosition[3*i+1] = rotatedCenter.get1();

      mCurrentPosition[3*i+2] = rotatedCenter.get2();

      mParent.clampPos(mCurrentPosition, 3*i);

      }

    computeRotationRow();

    }

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

  int computeAssociation()

    {

    int result = 0, accumulativeShift = 0;

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

      {

      result += (mRotationRow[axis]<<accumulativeShift);

      accumulativeShift += ObjectList.MAX_OBJECT_SIZE;

      }

    return result;

    }

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

  void savePreferences(SharedPreferences.Editor editor)

    {

    String number = mOrigPosition[0]+"_"+mOrigPosition[1]+"_"+mOrigPosition[2];

    editor.putInt("q_"+number, mQuatIndex);

    }

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

  int restorePreferences(SharedPreferences preferences)

    {

    String number = mOrigPosition[0]+"_"+mOrigPosition[1]+"_"+mOrigPosition[2];

    mQuatIndex = preferences.getInt("q_"+number, 0);

    return mQuatIndex;

    }

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

  int removeRotationNow(Static4D quat)

    {

    Static4D q = QuatHelper.quatMultiply(quat,mParent.OBJECT_QUATS[mQuatIndex]);

    mQuatIndex = normalizeScrambleQuat(q);

    modifyCurrentPosition(quat);

    return mQuatIndex;

    }

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

  void solve()

    {

    mQuatIndex = 0;

    System.arraycopy(mOrigPosition, 0, mCurrentPosition, 0, mCurrentPosition.length);

    computeRotationRow();

    }

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

  void releaseResources()

    {

    mParent = null;

    }

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

// this is only needed for MODE_REPLACE objects (i.e. - currently - CUBE_3), so it is enough to only

// take into consideration the first position.

  float getDistSquared(float[] point)

    {

    float dx = mCurrentPosition[0] - point[0];

    float dy = mCurrentPosition[1] - point[1];

    float dz = mCurrentPosition[2] - point[2];

    return dx*dx + dy*dy + dz*dz;

    }

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

  public int getRotRow(int index)

    {

    return mRotationRow[index];

    }

}

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

// Copyright 2020 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;

import org.distorted.library.effect.MatrixEffectMove;

import org.distorted.library.effect.MatrixEffectQuaternion;

import org.distorted.library.effect.MatrixEffectScale;

import org.distorted.library.effect.VertexEffect;

import org.distorted.library.effect.VertexEffectDeform;

import org.distorted.library.mesh.MeshBase;

import org.distorted.library.mesh.MeshJoined;

import org.distorted.library.mesh.MeshPolygon;

import org.distorted.library.type.Static1D;

import org.distorted.library.type.Static3D;

import org.distorted.library.type.Static4D;

import java.util.ArrayList;

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

public class FactoryCubit

  {

  private static final Static1D RADIUS = new Static1D(1);

  private static FactoryCubit mThis;

  private static final double[] mBuffer = new double[3];

  private static final double[] mQuat1  = new double[4];

  private static final double[] mQuat2  = new double[4];

  private static final double[] mQuat3  = new double[4];

  private static final double[] mQuat4  = new double[4];

  private static class StickerCoords

    {

    double[] vertices;

    }

  private static class FaceTransform

    {

    int sticker;

    double vx,vy,vz;

    double scale;

    double qx,qy,qz,qw;

    boolean flip;

    }

  private static final ArrayList<FaceTransform> mNewFaceTransf = new ArrayList<>();

  private static final ArrayList<FaceTransform> mOldFaceTransf = new ArrayList<>();

  private static final ArrayList<StickerCoords> mStickerCoords = new ArrayList<>();

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

  private FactoryCubit()

    {

    }

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

  public static FactoryCubit getInstance()

    {

    if( mThis==null ) mThis = new FactoryCubit();

    return mThis;

    }

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

// H - height of the band in the middle

// alpha - angle of the edge  [0,90]

// dist - often in a polygon the distance from edge to center is not 1, but something else.

// This is the distance.

// K - where to begin the second, much more flat part of the band. [0,1]

// N - number of bands. N>=3

//

// theory: two distinct parts to the band:

// 1) (0,B) - steep

// 2) (B,1) - flat

//

// In first part, we have y = g(x) ; in second - y = g(f(x)) where

//

// g(x) = sqrt( R^2 - (x-D)^2 ) - R*cos(alpha)

// f(x) = ((D-B)/(1-B)*x + B*(1-D)/(1-B)

// h(x) = R*(sin(alpha) - sin(x))

// R = H/(1-cos(alpha))

// D = H*sin(alpha)

// B = h(K*alpha)

//

// The N points are taken at:

//

// 1) in the second part, there are K2 = (N-3)/3 such points

// 2) in the first - K1 = (N-3) - K2

// 3) also, the 3 points 0,B,1

//

// so we have the sequence A[i] of N points

//

// 0

// h((i+1)*(1-K)*alpha/(K1+1)) (i=0,1,...,K1-1)

// B

// (1-B)*(i+1)/(K2+1) + B   (i=0,i,...,K2-1)

// 1

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

  private float f(float D, float B, float x)

    {

    return ((D-B)*x + B*(1-D))/(1-B);

    }

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

  private float g(float R, float D, float x, float cosAlpha)

    {

    float d = x-D;

    return (float)(Math.sqrt(R*R-d*d)-R*cosAlpha);

    }

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

  private float h(float R, float sinAlpha, float x)

    {

    return R*(sinAlpha-(float)Math.sin(x));

    }

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

  private boolean areColinear(double[][] vertices, int index1, int index2, int index3)

    {

    double x1 = vertices[index1][0];

    double y1 = vertices[index1][1];

    double z1 = vertices[index1][2];

    double x2 = vertices[index2][0];

    double y2 = vertices[index2][1];

    double z2 = vertices[index2][2];

    double x3 = vertices[index3][0];

    double y3 = vertices[index3][1];

    double z3 = vertices[index3][2];

    double v1x = x2-x1;

    double v1y = y2-y1;

    double v1z = z2-z1;

    double v2x = x3-x1;

    double v2y = y3-y1;

    double v2z = z3-z1;

    double A = Math.sqrt( (v1x*v1x+v1y*v1y+v1z*v1z) / (v2x*v2x+v2y*v2y+v2z*v2z) );

    return (v1x==A*v2x && v1y==A*v2y && v1z==A*v2z);

    }

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

  private void computeNormalVector(double[][] vertices, int index1, int index2, int index3)

    {

    double x1 = vertices[index1][0];

    double y1 = vertices[index1][1];

    double z1 = vertices[index1][2];

    double x2 = vertices[index2][0];

    double y2 = vertices[index2][1];

    double z2 = vertices[index2][2];

    double x3 = vertices[index3][0];

    double y3 = vertices[index3][1];

    double z3 = vertices[index3][2];

    double v1x = x2-x1;

    double v1y = y2-y1;

    double v1z = z2-z1;

    double v2x = x3-x1;

    double v2y = y3-y1;

    double v2z = z3-z1;

    mBuffer[0] = v1y*v2z - v2y*v1z;

    mBuffer[1] = v1z*v2x - v2z*v1x;

    mBuffer[2] = v1x*v2y - v2x*v1y;

    double len = mBuffer[0]*mBuffer[0] + mBuffer[1]*mBuffer[1] + mBuffer[2]*mBuffer[2];

    len = Math.sqrt(len);

    mBuffer[0] /= len;

    mBuffer[1] /= len;

    mBuffer[2] /= len;

    }

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

// return quat1*quat2

  private static void quatMultiply( double[] quat1, double[] quat2, double[] result )

    {

    double qx = quat1[0];

    double qy = quat1[1];

    double qz = quat1[2];

    double qw = quat1[3];

    double rx = quat2[0];

    double ry = quat2[1];

    double rz = quat2[2];

    double rw = quat2[3];

    result[0] = rw*qx - rz*qy + ry*qz + rx*qw;

    result[1] = rw*qy + rz*qx + ry*qw - rx*qz;

    result[2] = rw*qz + rz*qw - ry*qx + rx*qy;

    result[3] = rw*qw - rz*qz - ry*qy - rx*qx;

    }

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

  private void fitInSquare(FaceTransform info, double[][] vert3D)

    {

    double minX = Double.MAX_VALUE;

    double maxX =-Double.MAX_VALUE;

    double minY = Double.MAX_VALUE;

    double maxY =-Double.MAX_VALUE;

    for (double[] vert : vert3D)

      {

      double x = vert[0];

      double y = vert[1];

      if (x > maxX) maxX = x;

      if (x < minX) minX = x;

      if (y > maxY) maxY = y;

      if (y < minY) minY = y;

      }

    minX = minX<0 ? -minX:minX;

    maxX = maxX<0 ? -maxX:maxX;

    minY = minY<0 ? -minY:minY;

    maxY = maxY<0 ? -maxY:maxY;

    double max1 = Math.max(minX,minY);

    double max2 = Math.max(maxX,maxY);

    double max3 = Math.max(max1,max2);

    info.scale = max3/0.5;

    int len = vert3D.length;

    StickerCoords sInfo = new StickerCoords();

    sInfo.vertices = new double[2*len];

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

      {

      sInfo.vertices[2*vertex  ] = vert3D[vertex][0] / info.scale;

      sInfo.vertices[2*vertex+1] = vert3D[vertex][1] / info.scale;

      }

    mStickerCoords.add(sInfo);

    info.sticker = mStickerCoords.size() -1;

    info.flip = false;

    }

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

  private FaceTransform constructNewTransform(final double[][] vert3D)

    {

    FaceTransform ft = new FaceTransform();

    // compute center of gravity

    ft.vx = 0.0f;

    ft.vy = 0.0f;

    ft.vz = 0.0f;

    int len = vert3D.length;

    for (double[] vert : vert3D)

      {

      ft.vx += vert[0];

      ft.vy += vert[1];

      ft.vz += vert[2];

      }

    ft.vx /= len;

    ft.vy /= len;

    ft.vz /= len;

    // move all vertices so that their center of gravity is at (0,0,0)

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

      {

      vert3D[i][0] -= ft.vx;

      vert3D[i][1] -= ft.vy;

      vert3D[i][2] -= ft.vz;

      }

    // find 3 non-colinear vertices

    int foundIndex = -1;

    for(int vertex=2; vertex<len; vertex++)

      {

      if( !areColinear(vert3D,0,1,vertex) )

        {

        foundIndex = vertex;

        break;

        }

      }

    // compute the normal vector

    if( foundIndex==-1 )

      {

      throw new RuntimeException("all vertices colinear");

      }

    computeNormalVector(vert3D,0,1,foundIndex);

    // rotate so that the normal vector becomes (0,0,1)

    double axisX, axisY, axisZ;

    if( mBuffer[0]!=0.0f || mBuffer[1]!=0.0f )

      {

      axisX = -mBuffer[1];

      axisY =  mBuffer[0];

      axisZ = 0.0f;

      double axiLen = axisX*axisX + axisY*axisY;

      axiLen = Math.sqrt(axiLen);

      axisX /= axiLen;

      axisY /= axiLen;

      axisZ /= axiLen;

      }

    else

      {

      axisX = 0.0f;

      axisY = 1.0f;

      axisZ = 0.0f;

      }

    double cosTheta = mBuffer[2];

    double sinTheta = Math.sqrt(1-cosTheta*cosTheta);

    double sinHalfTheta = computeSinHalf(cosTheta);

    double cosHalfTheta = computeCosHalf(sinTheta,cosTheta);

    mQuat1[0] = axisX*sinHalfTheta;

    mQuat1[1] = axisY*sinHalfTheta;

    mQuat1[2] = axisZ*sinHalfTheta;

    mQuat1[3] = cosHalfTheta;

    mQuat2[0] =-axisX*sinHalfTheta;

    mQuat2[1] =-axisY*sinHalfTheta;

    mQuat2[2] =-axisZ*sinHalfTheta;

    mQuat2[3] = cosHalfTheta;

    for (double[] vert : vert3D)

      {

      quatMultiply(mQuat1, vert  , mQuat3);

      quatMultiply(mQuat3, mQuat2, vert  );

      }

    // fit the whole thing in a square and remember the scale & 2D vertices

    fitInSquare(ft, vert3D);

    // remember the rotation

    ft.qx =-mQuat1[0];

    ft.qy =-mQuat1[1];

    ft.qz =-mQuat1[2];

    ft.qw = mQuat1[3];

    return ft;

    }

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

  private void rotateAllVertices(double[] result, int len, double[] vertices, double sin, double cos)

    {

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

      {

      result[2*i  ] = vertices[2*i  ]*cos - vertices[2*i+1]*sin;

      result[2*i+1] = vertices[2*i  ]*sin + vertices[2*i+1]*cos;

      }

    }

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

  private double computeScale(double[] v1, double[] v2, int v1i, int v2i)

    {

    double v1x = v1[2*v1i];

    double v1y = v1[2*v1i+1];

    double v2x = v2[2*v2i];

    double v2y = v2[2*v2i+1];

    double lenSq1 = v1x*v1x + v1y*v1y;

    double lenSq2 = v2x*v2x + v2y*v2y;

    return Math.sqrt(lenSq2/lenSq1);

    }

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

// valid for 0<angle<2*PI

  private double computeSinHalf(double cos)

    {

    return Math.sqrt((1-cos)/2);

    }

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

// valid for 0<angle<2*PI

  private double computeCosHalf(double sin, double cos)

    {

    double cosHalf = Math.sqrt((1+cos)/2);

    return sin<0 ? -cosHalf : cosHalf;

    }

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

  private int computeRotatedIndex(int oldVertex, int len, int rotatedVertex, boolean inverted)

    {

    int v = (rotatedVertex + (inverted? -oldVertex : oldVertex));

    if( v>=len ) v-=len;

    if( v< 0   ) v+=len;

    return v;

    }

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

  private boolean isScaledVersionOf(double[] newVert, double[] oldVert, int len, int vertex, boolean inverted)

    {

    int newZeroIndex = computeRotatedIndex(0,len,vertex,inverted);

    double EPSILON = 0.001;

    double scale = computeScale(newVert,oldVert,newZeroIndex,0);

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

      {

      int index = computeRotatedIndex(i,len,vertex,inverted);

      double horz = oldVert[2*i  ] - scale*newVert[2*index  ];

      double vert = oldVert[2*i+1] - scale*newVert[2*index+1];

      if( horz>EPSILON || horz<-EPSILON || vert>EPSILON || vert<-EPSILON ) return false;

      }

    return true;

    }

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

  private void mirrorAllVertices(double[] output, int len, double[] input)

    {

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

      {

      output[2*vertex  ] = input[2*vertex  ];

      output[2*vertex+1] =-input[2*vertex+1];

      }

    }

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

  private void correctInfo(FaceTransform info, double scale, double sin, double cos, int oldSticker, boolean flip)

    {

    mStickerCoords.remove(info.sticker);

    info.flip    = flip;

    info.sticker = oldSticker;

    info.scale  *= scale;

    mQuat1[0] = info.qx;

    mQuat1[1] = info.qy;

    mQuat1[2] = info.qz;

    mQuat1[3] = info.qw;

    double sinHalf = computeSinHalf(cos);

    double cosHalf = computeCosHalf(sin,cos);

    if( flip )

      {

      mQuat3[0] = 0.0f;

      mQuat3[1] = 0.0f;

      mQuat3[2] = sinHalf;

      mQuat3[3] = cosHalf;

      mQuat4[0] = 1.0;

      mQuat4[1] = 0.0;

      mQuat4[2] = 0.0;

      mQuat4[3] = 0.0;

      quatMultiply( mQuat3, mQuat4, mQuat2 );

      }

    else

      {

      mQuat2[0] = 0.0f;

      mQuat2[1] = 0.0f;

      mQuat2[2] = sinHalf;

      mQuat2[3] = cosHalf;

      }

    quatMultiply( mQuat1, mQuat2, mQuat3 );

    info.qx = mQuat3[0];

    info.qy = mQuat3[1];

    info.qz = mQuat3[2];

    info.qw = mQuat3[3];

    }

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

  private void printVert(double[] buffer)

    {

    int len = buffer.length/2;

    String str = "";

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

      {

      str += (" ("+buffer[2*i]+" , "+buffer[2*i+1]+" ) ");

      }

    android.util.Log.d("D", str);

    }

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

  private boolean foundVertex(FaceTransform info, double[] buffer, int len, double[] newVert,

                              double[] oldVert, double lenFirstOld, int oldSticker, boolean inverted)

    {

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

      {

      double newX = newVert[2*vertex  ];

      double newY = newVert[2*vertex+1];

      double lenIthNew = Math.sqrt(newX*newX + newY*newY);

      double cos = QuatHelper.computeCos( oldVert[0], oldVert[1], newX, newY, lenIthNew, lenFirstOld);

      double sin = QuatHelper.computeSin( oldVert[0], oldVert[1], newX, newY, lenIthNew, lenFirstOld);