Inventor/SbRotation.h

Go to the documentation of this file.

/*=======================================================================
 *** 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_ */

---

Open Inventor Toolkit reference manual, generated on 15 Mar 2023
Copyright © Thermo Fisher Scientific All rights reserved. http://www.openinventor.com/