rotation.h

Go to the documentation of this file.

#ifndef MATH3D_ROTATION_H
#define MATH3D_ROTATION_H

#include <KrisLibrary/math/complex.h>
#include "primitives.h"

namespace Math3D {

  using namespace Math;

class EulerAngleRotation;
class AngleAxisRotation;
class MomentRotation;
class QuaternionRotation;

class EulerAngleRotation : public Vector3
{
public:
  EulerAngleRotation();
  EulerAngleRotation(const EulerAngleRotation&);
  explicit EulerAngleRotation(const Vector3&);
  explicit EulerAngleRotation(Real a, Real b, Real c);

  //inline operator const Vector3&() const { return *this; }
  //inline operator Vector3&()  { return *this; }

  //inline void set(const EulerAngleRotation& r) { Vector3::set(r.x,r.y,r.z); }
  inline void setIdentity() { setZero(); }

  bool setMatrix(int u,int v,int w,const Matrix3&);
  bool setMatrixXYZ(const Matrix3&);
  bool setMatrixXZY(const Matrix3&);
  bool setMatrixYZX(const Matrix3&);
  bool setMatrixYXZ(const Matrix3&);
  bool setMatrixZXY(const Matrix3&);
  bool setMatrixZYX(const Matrix3&);

  void getMatrix(int u,int v,int w,Matrix3&) const;
  void getMatrixXYZ(Matrix3&) const;
  void getMatrixXZY(Matrix3&) const;
  void getMatrixYZY(Matrix3&) const;
  void getMatrixYXZ(Matrix3&) const;
  void getMatrixZXY(Matrix3&) const;
  void getMatrixZYX(Matrix3&) const;
};

class AngleAxisRotation
{
public:
  AngleAxisRotation();
  AngleAxisRotation(const AngleAxisRotation&);
  explicit AngleAxisRotation(Real angle, const Vector3& axis);
  explicit AngleAxisRotation(const MomentRotation&);

  void set(const AngleAxisRotation&);
  void set(Real angle, const Vector3& axis);
  void setAxis(const Vector3& axis);
  void setIdentity();
  void transformPoint(const Vector3& in,Vector3& out) const;

  bool setMatrix(const Matrix3&);
  void getMatrix(Matrix3&) const;

  void setMoment(const MomentRotation&);
  void getMoment(MomentRotation&) const;

  Real angle;
  Vector3 axis;
};

class MomentRotation : public Vector3
{
public:
  MomentRotation();
  MomentRotation(const MomentRotation&);
  explicit MomentRotation(Real x,Real y,Real z);
  explicit MomentRotation(const Vector3& v);
  explicit MomentRotation(const AngleAxisRotation&);

  //inline operator const Vector3&() const { return *this; }
  //inline operator Vector3&()  { return *this; }

  inline void set(const MomentRotation& r) { Vector3::set(r); }
  inline void set(const Vector3& v)  { Vector3::set(v); }
  inline void set(Real x, Real y, Real z)  { Vector3::set(x,y,z); }
  inline void setIdentity() { Vector3::setZero(); }
  void transformPoint(const Vector3& in,Vector3& out) const;

  bool setMatrix(const Matrix3&);
  void getMatrix(Matrix3&) const;

  void setAngleAxis(const AngleAxisRotation&);
  void getAngleAxis(AngleAxisRotation&) const;
};

class QuaternionRotation : public Quaternion
{
public:
  QuaternionRotation();
  QuaternionRotation(const QuaternionRotation&);
  QuaternionRotation(const Quaternion&);
  QuaternionRotation(Real w, Real x, Real y, Real z);

  //inline operator Quaternion&() { return *this; }
  //inline operator const Quaternion&() const { return *this; }
  void slerp(const Quaternion& a, const Quaternion& b, Real t);
  void mag(const Quaternion& a, Real t);
  void transform(const Vector3& a, Vector3& out) const;

  inline void set(const QuaternionRotation& q) { Quaternion::set(q); }
  inline void setIdentity() { Quaternion::set(One); }
  void setAngleAxis(const AngleAxisRotation&);
  void setMoment(const MomentRotation&);
  bool setMatrix(const Matrix3&);

  void getAngleAxis(AngleAxisRotation&) const;
  void getMoment(MomentRotation&) const;
  void getMatrix(Matrix3&) const;
};

void SetMatrixRotationZYX(Matrix3&, const Vector3&);            //euler
void SetMatrixRotationZYX(Matrix4&, const Vector3&);
void SetMatrixRotationVector(Matrix3&, const Vector3&);         //moment
void SetMatrixRotationVector(Matrix4&, const Vector3&);
void SetMatrixRotationVector(Matrix3&, const Vector3&, Real angle);  //angle axis
void SetMatrixRotationVector(Matrix4&, const Vector3&, Real angle);
void SetMatrixRotationQuaternion(Matrix3&, const Quaternion&);  //quaternion
void SetMatrixRotationQuaternion(Matrix4&, const Quaternion&);


void SLerp(const Quaternion& q0,
           const Quaternion& q1,
           Quaternion& out,
           Real t);

void SCerp(const Quaternion& q_1,
           const Quaternion& q0,
           const Quaternion& q1,
           const Quaternion& q2,
           Quaternion& out,
           Real t);

void SBezier(const Quaternion& q0,
             const Quaternion& c0,
             const Quaternion& c1,
             const Quaternion& q1,
             Quaternion& out,
             Real t);

}

#endif