SbRotation.h

/*=======================================================================
 *** THE CONTENT OF THIS WORK IS PROPRIETARY TO FEI S.A.S, (FEI S.A.S.),            ***
 ***              AND IS DISTRIBUTED UNDER A LICENSE AGREEMENT.                     ***
 ***                                                                                ***
 ***  REPRODUCTION, DISCLOSURE,  OR USE,  IN WHOLE OR IN PART,  OTHER THAN AS       ***
 ***  SPECIFIED  IN THE LICENSE ARE  NOT TO BE  UNDERTAKEN  EXCEPT WITH PRIOR       ***
 ***  WRITTEN AUTHORIZATION OF FEI S.A.S.                                           ***
 ***                                                                                ***
 ***                        RESTRICTED RIGHTS LEGEND                                ***
 ***  USE, DUPLICATION, OR DISCLOSURE BY THE GOVERNMENT OF THE CONTENT OF THIS      ***
 ***  WORK OR RELATED DOCUMENTATION IS SUBJECT TO RESTRICTIONS AS SET FORTH IN      ***
 ***  SUBPARAGRAPH (C)(1) OF THE COMMERCIAL COMPUTER SOFTWARE RESTRICTED RIGHT      ***
 ***  CLAUSE  AT FAR 52.227-19  OR SUBPARAGRAPH  (C)(1)(II)  OF  THE RIGHTS IN      ***
 ***  TECHNICAL DATA AND COMPUTER SOFTWARE CLAUSE AT DFARS 52.227-7013.             ***
 ***                                                                                ***
 ***                   COPYRIGHT (C) 1996-2018 BY FEI S.A.S,                        ***
 ***                        BORDEAUX, FRANCE                                        ***
 ***                      ALL RIGHTS RESERVED                                       ***
**=======================================================================*/
/*=======================================================================
** Author      : VSG (MMM YYYY)
**=======================================================================*/
#ifndef _SB_ROTATION_
#define _SB_ROTATION_
 
#include <Inventor/SbVec.h>
 
class SbRotationd;
class SbMatrix;
class SbMatrix3;
class SbMatrixd;
 
//
//  Class: SbRotation
//
//  Rotation specfication. It is stored internally as a quaternion,
//  which has 4 floating-point components.
//
 
 
 
class  SbRotation {
public:
 
  SbRotation()
  { setValue(0.0f, 0.0f, 0.0f, 1.0f);}
 
  SbRotation(const float v[4])
  { setValue(v); }
 
  SbRotation(float q0, float q1, float q2, float q3)
  { setValue(q0, q1, q2, q3); }
 
  SbRotation(const SbMatrix &m)
  { setValue(m); }
 
  SbRotation(const SbMatrix3 &m)
  { setValue(m); }
 
  SbRotation(const SbVec3f &axis, float radians)
  { setValue(axis, radians); }
 
  SbRotation(const SbVec3f &rotateFrom, const SbVec3f &rotateTo)
  { setValue(rotateFrom, rotateTo); }
 
  const float  *  getValue() const
  { return (quat); }
 
  void    getValue(float &q0, float &q1,
    float &q2, float &q3) const;
 
  void    getValue(SbVec3f &axis, float &radians) const;
 
  void    getValue(SbMatrix &matrix) const;
 
  void    getValue(SbMatrix3 &matrix) const;
 
  void    getValue(SbMatrixd &matrix) const;
 
  SbRotation &invert();
 
  SbRotation    inverse() const
  { SbRotation q = *this; return q.invert(); }
 
  SbRotation &setValue(const float q[4]);
 
  SbRotation &setValue(float q0, float q1, float q2, float q3);
 
  SbRotation &setValue(const SbMatrix &m);
 
  SbRotation &setValue(const SbMatrix3 &m) ;
 
  SbRotation &setValue(const SbVec3f &axis, float radians);
 
  SbRotation &setValue(const SbVec3f &rotateFrom,
    const SbVec3f &rotateTo);
 
  SbRotation &setValue(const SbRotationd &rotated) ;
 
  SbRotation &setValue(const SbMatrixd &md) ;
 
  SbRotation & operator *=(const SbRotation &q);
 
   friend int operator ==(const SbRotation &q1, const SbRotation &q2);
   friend int operator !=(const SbRotation &q1, const SbRotation &q2)
  { return !(q1 == q2); }
 
  SbBool    equals(const SbRotation &r, float tolerance) const;
 
   friend SbRotation operator *(const SbRotation &q1, const SbRotation &q2);
 
  void  multVec(const SbVec3f &src, SbVec3f &dst) const;
 
  void scaleAngle( float scaleFactor );
 
  static SbRotation  slerp(const SbRotation &rot0,
    const SbRotation &rot1, float t);
 
  static SbRotation  identity()
  { return SbRotation(0.0f, 0.0f, 0.0f, 1.0f); }
 
private:
  mutable float  quat[4];  // Storage for quaternion components
 
  // Returns the norm (square of the 4D length) of a rotation's quaterion
  float  norm() const;
 
  // Normalizes a rotation quaternion to unit 4D length
  void  normalize() const;
 
};
 
//
//  Class: SbRotationd
//
//  Rotation specfication. It is stored internally as a quaternion,
//  which has 4 double precision floating-point components.
//
 
class  SbRotationd {
public:
 
  SbRotationd()
  { setValue(0.0, 0.0, 0.0, 1.0); }
 
  SbRotationd(const double v[4])
  { setValue(v); }
 
  SbRotationd(double q0, double q1, double q2, double q3)
  { setValue(q0, q1, q2, q3); }
 
  SbRotationd(const SbMatrixd &m)
  { setValue(m); }
 
  SbRotationd(const SbMatrix3 &m)
  { setValue(m); }
 
  SbRotationd(const SbVec3d &axis, double radians)
  { setValue(axis, radians); }
 
  SbRotationd(const SbVec3d &rotateFrom, const SbVec3d &rotateTo)
  { setValue(rotateFrom, rotateTo); }
 
  const double *getValue() const
  { return (quat); }
 
  void getValue(double &q0, double &q1,
    double &q2, double &q3) const;
 
  void    getValue(SbVec3d &axis, double &radians) const;
 
  void    getValue(SbMatrixd &matrix) const;
 
  void    getValue(SbMatrix &matrix) const;
 
  void    getValue(SbMatrix3 &matrix) const;
 
  SbRotationd &invert();
 
  SbRotationd    inverse() const
  { SbRotationd q = *this; return q.invert(); }
 
  SbRotationd &setValue(const double q[4]);
 
  SbRotationd &setValue(double q0, double q1, double q2, double q3);
 
  SbRotationd &setValue(const SbMatrixd &m);
 
  SbRotationd &setValue(const SbVec3d &axis, double radians);
 
  SbRotationd &setValue(const SbVec3d &rotateFrom,
    const SbVec3d &rotateTo);
 
  SbRotationd &setValue(const SbRotation &rotate) ;
 
  SbRotationd &setValue(const SbMatrix &m) ;
 
  SbRotationd &setValue(const SbMatrix3 &m) ;
 
  SbRotationd & operator *=(const SbRotationd &q);
 
   friend int operator ==(const SbRotationd &q1, const SbRotationd &q2);
   friend int operator !=(const SbRotationd &q1, const SbRotationd &q2)
  { return !(q1 == q2); }
 
  SbBool    equals(const SbRotationd &r, double tolerance) const;
 
   friend SbRotationd operator *(const SbRotationd &q1, const SbRotationd &q2);
 
  void  multVec(const SbVec3d &src, SbVec3d &dst) const;
 
  void scaleAngle( double scaleFactor );
 
  static SbRotationd  slerp(const SbRotationd &rot0,
    const SbRotationd &rot1, double t);
 
  static SbRotationd  identity()
  { return SbRotationd(0.0, 0.0, 0.0, 1.0); }
 
private:
  double  quat[4];  // Storage for quaternion components
 
  // Returns the norm (square of the 4D length) of a rotation's quaterion
  double  norm() const;
 
  // Normalizes a rotation quaternion to unit 4D length
  void  normalize();
 
};
 
#endif /* _SB_ROTATION_ */