quat.h

Go to the documentation of this file.

/**********************************************************************
 *<
   FILE: quat.h

   DESCRIPTION: Class definitions for Quat

   CREATED BY: Dan Silva

   HISTORY:

 *>   Copyright (c) 1994, All Rights Reserved.
 **********************************************************************/
#pragma once

#include "GeomExport.h"
#include "maxheap.h"
#include "matrix3.h"
#include "assert1.h"

#include <iosfwd>

class Quat;
class AngAxis;

class AngAxis: public MaxHeapOperators {
public:
   Point3 axis;
   float angle;        // This angle is left-handed!

   AngAxis() { /* NO INIT */ }
   AngAxis(float x, float y, float z, float ang)
      { axis.x = x; axis.y = y; axis.z = z; angle = ang; }
   AngAxis(const Point3& axis,float angle) { this->axis=axis; this->angle=angle; }  
   GEOMEXPORT AngAxis(const Quat &q);
   GEOMEXPORT AngAxis(const Matrix3& m); // GEOMEXPORT added in R5.1

   AngAxis& Set(float x, float y, float z, float ang)
      {axis.x = x; axis.y = y; axis.z = z; angle = ang; return *this; }
   AngAxis& Set(const Point3& ax, float ang)
      {axis = ax; angle = ang; return *this; }
   GEOMEXPORT AngAxis& Set(const Quat& q);
   GEOMEXPORT AngAxis& Set(const Matrix3& m);
    
   GEOMEXPORT int GetNumRevs();
   GEOMEXPORT void SetNumRevs(int num);
   };

class Quat: public MaxHeapOperators {
public:
   float x,y,z,w;

   // Constructors
   Quat(): x(0.0f),y(0.0f),z(0.0f),w(1.0f) {}
   Quat(float X, float Y, float Z, float W)  { x = X; y = Y; z = Z; w = W; }
   Quat(double X, double Y, double Z, double W)  { 
      x = (float)X; y = (float)Y; z = (float)Z; w = (float)W;  
      }
   Quat(const Quat& a) { x = a.x; y = a.y; z = a.z; w = a.w; } 
   Quat(float af[4]) { x = af[0]; y = af[1]; z = af[2]; w = af[3]; }
   GEOMEXPORT Quat(const Matrix3& mat);
   GEOMEXPORT Quat(const AngAxis& aa);
   GEOMEXPORT Quat(const Point3& V, float W);

   // Access operators
   float& operator[](int i) { return (&x)[i]; }     
   const float& operator[](int i) const { return (&x)[i]; }
    
   float Scalar() { return w; }
   Point3 Vector() { return Point3(x, y, z); }

   // Conversion function
   operator float*() { return(&x); }

   // Unary operators
   Quat operator-() const { return(Quat(-x,-y,-z,-w)); } 
   Quat operator+() const { return *this; }
    
    // Math functions
   GEOMEXPORT Quat Inverse() const;
   GEOMEXPORT Quat Conjugate() const;
   GEOMEXPORT Quat LogN() const;
   GEOMEXPORT Quat Exp() const;

   // Assignment operators
   GEOMEXPORT Quat& operator-=(const Quat&);
   GEOMEXPORT Quat& operator+=(const Quat&);
   GEOMEXPORT Quat& operator*=(const Quat&);
   GEOMEXPORT Quat& operator*=(float);
   GEOMEXPORT Quat& operator/=(float);

   Quat& Set(float X, float Y, float Z, float W)
      { x = X; y = Y; z = Z; w = W; return *this; }
   Quat& Set(double X, double Y, double Z, double W)
      { x = (float)X; y = (float)Y; z = (float)Z; w = (float)W;
        return *this; }
   GEOMEXPORT Quat& Set(const Matrix3& mat);
   GEOMEXPORT Quat& Set(const AngAxis& aa);
   Quat& Set(const Point3& V, float W)
      { x = V.x; y = V.y; z = V.z; w = W; return *this; } 
   GEOMEXPORT Quat& SetEuler(float X, float Y, float Z);
   GEOMEXPORT Quat& Invert();                 // in place

   GEOMEXPORT Quat& MakeClosest(const Quat& qto);

   // Comparison
   GEOMEXPORT int operator==(const Quat& a) const;
   GEOMEXPORT int Equals(const Quat& a, float epsilon = 1E-6f) const;

   void Identity() { x = y = z = 0.0f; w = 1.0f; }
   GEOMEXPORT int IsIdentity() const;
   GEOMEXPORT void Normalize();  // normalize
   GEOMEXPORT void MakeMatrix(Matrix3 &mat, bool flag=false) const;   // flag added 001031  --prs.
   GEOMEXPORT void GetEuler(float *X, float *Y, float *Z) const;

   // Binary operators
   GEOMEXPORT Quat operator-(const Quat&) const;  //RB: Changed these to    // difference of two quaternions
   GEOMEXPORT Quat operator+(const Quat&) const;  // duplicate * and /         // sum of two quaternions
   GEOMEXPORT Quat operator*(const Quat&) const;  // product of two quaternions
   GEOMEXPORT Quat operator/(const Quat&) const;  // ratio of two quaternions
   GEOMEXPORT float operator%(const Quat&) const;   // dot product
   GEOMEXPORT Quat Plus(const Quat&) const;       // what + should have done
   GEOMEXPORT Quat Minus(const Quat&) const;      // what - should have done
    };

GEOMEXPORT Quat operator*(float, const Quat&);   // multiply by scalar
GEOMEXPORT Quat operator*(const Quat&, float);   // multiply by scalar
GEOMEXPORT Quat operator/(const Quat&, float);   // divide by scalar
GEOMEXPORT Quat Inverse(const Quat& q);  // Inverse of quaternion (1/q)
GEOMEXPORT Quat Conjugate(const Quat& q); 
GEOMEXPORT Quat LogN(const Quat& q);
GEOMEXPORT Quat Exp(const Quat& q);
GEOMEXPORT Quat Slerp(const Quat& p, const Quat& q, float t);
GEOMEXPORT Quat LnDif(const Quat& p, const Quat& q);
GEOMEXPORT Quat QCompA(const Quat& qprev,const Quat& q, const Quat& qnext);
GEOMEXPORT Quat Squad(const Quat& p, const Quat& a, const Quat &b, const Quat& q, float t); 
GEOMEXPORT Quat qorthog(const Quat& p, const Point3& axis);

GEOMEXPORT Quat squadrev(
      float angle,   // angle of rotation 
      const Point3& axis,  // the axis of rotation 
      const Quat& p,    // start quaternion 
      const Quat& a,       // start tangent quaternion 
      const Quat& b,       // end tangent quaternion 
      const Quat& q,    // end quaternion 
      float t     // parameter, in range [0.0,1.0] 
      );

GEOMEXPORT void RotateMatrix(Matrix3& mat, const Quat& q);     
GEOMEXPORT void PreRotateMatrix(Matrix3& mat, const Quat& q);
GEOMEXPORT Quat QFromAngAxis(float ang, const Point3& axis);
GEOMEXPORT void AngAxisFromQ(const Quat& q, float *ang, Point3& axis);
GEOMEXPORT float QangAxis(const Quat& p, const Quat& q, Point3& axis);
GEOMEXPORT void DecomposeMatrix(const Matrix3& mat, Point3& p, Quat& q, Point3& s);
GEOMEXPORT Quat TransformQuat(const Matrix3 &m, const Quat&q );
inline Quat IdentQuat() { return(Quat(0.0,0.0,0.0,1.0)); }

// Assumes Euler angles are of the form:
// RotateX(ang[0])
// RotateY(ang[1])
// RotateZ(ang[2])
//
GEOMEXPORT void QuatToEuler(Quat &q, float *ang);
GEOMEXPORT void EulerToQuat(float *ang, Quat &q);

GEOMEXPORT std::ostream &operator<<(std::ostream&, const Quat&);