JMATH::JSVD3D::JQuaternion Struct Reference

Auxiliary class for quaternion computation. More...

Inheritance diagram for JMATH::JSVD3D::JQuaternion:

Public Member Functions
	JQuaternion (JMatrix3S &S)
	Constructor.

Private Member Functions
void	conjugate (const int x, const int y, const int z, JMatrix3S &S)
	Get conjugate of symmetric matrix for given order.

Detailed Description

Auxiliary class for quaternion computation.

Definition at line 233 of file JSVD3D.hh.

Constructor & Destructor Documentation

JQuaternion()

JMATH::JSVD3D::JQuaternion::JQuaternion ( JMatrix3S & S )

inline

Constructor.

Finds transformation that diagonalizes the given symmetric matrix by using Jacobi eigen analysis.

Parameters

S

matrix

Definition at line 243 of file JSVD3D.hh.

      {
        // follow same indexing convention as GLM
 
        (*this)[3] = 1.0; 
        (*this)[0] = 0.0; 
        (*this)[1] = 0.0; 
        (*this)[2] = 0.0;
 
        for (int i = 0; i != 4; ++i) {
 
          // eliminate maximum off-diagonal element on every iteration,
          // while cycling over all 3 possible rotations in fixed order.
          // (p,q) = (0,1), (1,2), (0,2) still retains asymptotic convergence.
 
          conjugate(0, 1, 2, S);  // (p,q) = (0,1)
          conjugate(1, 2, 0, S);  // (p,q) = (1,2)
          conjugate(2, 0, 1, S);  // (p,q) = (0,2)
        }
      }

Member Function Documentation

conjugate()

void JMATH::JSVD3D::JQuaternion::conjugate ( const int x, const int y, const int z, JMatrix3S & S )

inlineprivate

Get conjugate of symmetric matrix for given order.

Parameters

x	1st index
y	2nd index
z	3rd index
S	matrix

Definition at line 274 of file JSVD3D.hh.

      {
        static const double GAMMA  =  sqrt(8.0) + 3.0;
        static const double CSTAR  =  cos(PI/8.0);
        static const double SSTAR  =  sin(PI/8.0);
 
        // approximate Givens quaternion
 
        double ch = 2.0*(S.a00 - S.a11);
        double sh = S.a10;
 
        if (GAMMA*sh*sh < ch*ch) {
 
          const double w = 1.0 / sqrt(ch*ch+sh*sh);
 
          ch *= w;
          sh *= w;
 
        } else {
 
          ch  = CSTAR;
          sh  = SSTAR;
        }
 
        const double scale =  ch*ch + sh*sh;
        const double a     = (ch+sh)*(ch-sh) / scale;
        const double b     = (2.0*sh*ch)     / scale;
 
        // make temporary copy of S
 
        double s00 = S.a00;
        double s10 = S.a10;  double s11 = S.a11;
        double s20 = S.a20;  double s21 = S.a21;  double s22 = S.a22;
 
        // perform conjugation S = Q' * S * Q
        // where Q is already implicitly solved from a and b
 
        S.a00 =  a*( a*s00 + b*s10) + b*( a*s10 + b*s11);
        S.a10 =  a*(-b*s00 + a*s10) + b*(-b*s10 + a*s11);
        S.a11 = -b*(-b*s00 + a*s10) + a*(-b*s10 + a*s11);
        S.a20 =  a*s20 + b*s21;
        S.a21 = -b*s20 + a*s21;
        S.a22 =  s22;
 
        // update cumulative rotation
 
        double tmp[] = {
          (*this)[0]*sh,
          (*this)[1]*sh,
          (*this)[2]*sh
        };
 
        sh *= (*this)[3];
 
        (*this)[0] *= ch;
        (*this)[1] *= ch;
        (*this)[2] *= ch;
        (*this)[3] *= ch;
 
        // (x,y,z) corresponds to {(0,1,2), (1,2,0), (2,0,1)}
        // for (p,q) = {(0,1), (1,2), (0,2)}, respectively.
 
        (*this)[z] += sh;
        (*this)[3] -= tmp[z]; // w
        (*this)[x] += tmp[y];
        (*this)[y] -= tmp[x];
 
        // re-arrange matrix for next iteration
 
        s00   = S.a11;
        s10   = S.a21; s11   = S.a22;
        s20   = S.a10; s21   = S.a20; s22   = S.a00;
 
        S.a00 = s00;
        S.a10 = s10;   S.a11 = s11;
        S.a20 = s20;   S.a21 = s21;   S.a22 = s22;
      }

---

The documentation for this struct was generated from the following file:

• JSVD3D.hh