/////////////////////////////////////////////////////////////////////////////// 
// Copyright (C) 2002-2016, Open Design Alliance (the "Alliance"). 
// All rights reserved. 
// 
// This software and its documentation and related materials are owned by 
// the Alliance. The software may only be incorporated into application 
// programs owned by members of the Alliance, subject to a signed 
// Membership Agreement and Supplemental Software License Agreement with the
// Alliance. The structure and organization of this software are the valuable  
// trade secrets of the Alliance and its suppliers. The software is also 
// protected by copyright law and international treaty provisions. Application  
// programs incorporating this software must include the following statement 
// with their copyright notices:
//   
//   This application incorporates Teigha(R) software pursuant to a license 
//   agreement with Open Design Alliance.
//   Teigha(R) Copyright (C) 2002-2016 by Open Design Alliance. 
//   All rights reserved.
//
// By use of this software, its documentation or related materials, you 
// acknowledge and accept the above terms.
///////////////////////////////////////////////////////////////////////////////



#ifndef OD_GEQUATERNION_H
#define OD_GEQUATERNION_H /*!DOM*/

#include "Ge/GeExport.h"
#include "Ge/GeMatrix3d.h"


#include "TD_PackPush.h"

/** \details
    This class represents a rotation quaternion in 3D space.

    \remarks
    OdGeQuaternion may be viewed as an array[4] of doubles.

    Library: TD_Ge

   <group OdGe_Classes>
*/
class GE_TOOLKIT_EXPORT OdGeQuaternion
{
public:

  /** Quaternions are used to specify the rotations necessary for 3d planar orientation.
    It stores 4 Double variables w, x, y, and z.



    \remarks
    When called with no arguments, constructs a zero quaternion.
  */
  OdGeQuaternion ()
    : w( 1. ), x( 0. ), y( 0. ), z( 0. )
  {
  }
  OdGeQuaternion (double ww, double xx, double yy, double zz)
    : w(ww), x(xx), y(yy), z(zz)
  {
  }

  OdGeQuaternion& set (double ww, double xx, double yy, double zz)
  {
    w = ww;
    x = xx;
    y = yy;
    z = zz;
    return *this;
  }

  OdGeQuaternion& set( const OdGeMatrix3d& matrix )
  {
      double trace = matrix[0][0] + matrix[1][1] + matrix[2][2];
      if ( trace > 0.0 )
      {
          w = sqrt(1.0 + trace) / 2.0;

          double w4 = (4.0 * w);
          x = (matrix[1][2] - matrix[2][1]) / w4;
          y = (matrix[2][0] - matrix[0][2]) / w4;
          z = (matrix[0][1] - matrix[1][0]) / w4;
      }
      else
      {
          OdUInt32 i = 0;
          if (matrix[1][1] > matrix[0][0]) i = 1;
          if (matrix[2][2] > matrix[i][i]) i = 2;
          OdUInt32 j = (2 == i ? 0 : i + 1);
          OdUInt32 k = (2 == j ? 0 : j + 1);

          double s = sqrt((matrix[i][i] - (matrix[j][j] + matrix[k][k])) + 1.0);
          double q[ 4 ];

          q[i] = s * 0.5;
          if (s != 0.0) s = 0.5/s;

          q[3] = (matrix[j][k] - matrix[k][j]) * s;
          q[j] = (matrix[i][j] + matrix[j][i]) * s;
          q[k] = (matrix[i][k] + matrix[k][i]) * s;

          x = q[0];
          y = q[1];
          z = q[2];
          w = q[3];
      }
      return( *this );
  }

  OdGeMatrix3d getMatrix() const
  {
    OdGeMatrix3d matrix;

    matrix( 0, 0 ) = w * w + x * x - y * y - z * z;
    matrix( 1, 0 ) = 2. * ( x * y - w * z );
    matrix( 2, 0 ) = 2. * ( w * y + x * z );

    matrix( 0, 1 ) = 2. * ( w * z + x * y );
    matrix( 1, 1 ) = w * w - x * x + y * y - z * z;
    matrix( 2, 1 ) = 2. * ( y * z - w * x );

    matrix( 0, 2 ) = 2. * ( x * z - w * y );
    matrix( 1, 2 ) = 2. * ( w * x + y * z );
    matrix( 2, 2 ) = w * w - x * x - y * y + z * z;

    return matrix;
  }

  OdGePoint3d rotate( OdGePoint3d& sourcePoint ) const
  {
    OdGeMatrix3d matrix = getMatrix();

    return sourcePoint.transformBy( matrix );
  }

  OdGeVector3d rotate( OdGeVector3d& vector ) const
  {
    OdGeMatrix3d matrix = getMatrix();

    return vector.transformBy( matrix );
  }

  /** \details
    Returns true if and only if quat is identical to this quaternion,
    within the specified tolerance.

    \param quat [in]  Any quaternion.
    \param tol [in]  Geometric tolerance.
  */
  bool isEqualTo(
    const OdGeQuaternion& quat,
    const OdGeTol& tol = OdGeContext::gTol) const
  {
    return fabs(x - quat.x) <= tol.equalVector() &&
           fabs(y - quat.y) <= tol.equalVector() &&
           fabs(z - quat.z) <= tol.equalVector() &&
           fabs(w - quat.w) <= tol.equalVector();
  }

  bool operator == (const OdGeQuaternion& quat) const
  {
    return isEqualTo(quat);
  }
  bool operator != (const OdGeQuaternion& quat) const
  {
    return !isEqualTo(quat);
  }

  double w;
  double x;
  double y;
  double z;

  GE_STATIC_EXPORT static const OdGeQuaternion kOrigin;

};

#include "TD_PackPop.h"


#endif // OD_GEQUATERNION_H