vtkQuaternion.h

Go to the documentation of this file.

/*=========================================================================

  Program:   Visualization Toolkit
  Module:    vtkQuaternion.h

  Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen
  All rights reserved.
  See Copyright.txt or http://www.kitware.com/Copyright.htm for details.

     This software is distributed WITHOUT ANY WARRANTY; without even
     the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
     PURPOSE.  See the above copyright notice for more information.

=========================================================================*/
#ifndef vtkQuaternion_h
#define vtkQuaternion_h

#include "vtkTuple.h"

template<typename T> class vtkQuaternion : public vtkTuple<T, 4>
{
public:
  vtkQuaternion();

  explicit vtkQuaternion(const T& scalar) : vtkTuple<T, 4>(scalar) {}

  explicit vtkQuaternion(const T* init) : vtkTuple<T, 4>(init) {}

  vtkQuaternion(const T& w, const T& x, const T& y, const T& z);

  T SquaredNorm() const;

  T Norm() const;

  void ToIdentity();

  static vtkQuaternion<T> Identity();

  T Normalize();

  vtkQuaternion<T> Normalized() const;

  void Conjugate();

  vtkQuaternion<T> Conjugated() const;

  void Invert();

  vtkQuaternion<T> Inverse() const;

  void ToUnitLog();

  vtkQuaternion<T> UnitLog() const;

  void ToUnitExp();

  vtkQuaternion<T> UnitExp() const;

  void NormalizeWithAngleInDegrees();

  vtkQuaternion<T> NormalizedWithAngleInDegrees() const;


  void Set(const T& w, const T& x, const T& y, const T& z);
  void Set(T quat[4]);
  void Get(T quat[4]) const;


  void SetW(const T& w);
  const T& GetW() const;


  void SetX(const T& x);
  const T& GetX() const;


  void SetY(const T& y);
  const T& GetY() const;


  void SetZ(const T& z);
  const T& GetZ() const;


  T GetRotationAngleAndAxis(T axis[3]) const;
  void SetRotationAngleAndAxis(T angle, T axis[3]);
  void SetRotationAngleAndAxis(
    const T& angle, const T& x, const T& y, const T& z);

  template<typename CastTo> vtkQuaternion<CastTo> Cast() const;

  void ToMatrix3x3(T A[3][3]) const;

  void FromMatrix3x3(const T A[3][3]);

  vtkQuaternion<T> Slerp(T t, const vtkQuaternion<T>& q) const;

  vtkQuaternion<T> InnerPoint(const vtkQuaternion<T>& q1,
    const vtkQuaternion<T>& q2) const;

  vtkQuaternion<T> operator+(const vtkQuaternion<T>& q) const;

  vtkQuaternion<T> operator-(const vtkQuaternion<T>& q) const;

  vtkQuaternion<T> operator*(const vtkQuaternion<T>& q) const;

  vtkQuaternion<T> operator*(const T& scalar) const;

  void operator*=(const T& scalar) const;

  vtkQuaternion<T> operator/(const vtkQuaternion<T>& q) const;

  vtkQuaternion<T> operator/(const T& scalar) const;


  void operator/=(const T& scalar);
};

#define vtkQuaternionIdentity(quaternionType, type) \
quaternionType Identity() const \
{ \
  return quaternionType(vtkQuaternion<type>::Identity().GetData()); \
}
#define vtkQuaternionNormalized(quaternionType, type) \
quaternionType Normalized() const \
{ \
  return quaternionType(vtkQuaternion<type>::Normalized().GetData()); \
}
#define vtkQuaternionConjugated(quaternionType, type) \
quaternionType Conjugated() const \
{ \
  return quaternionType(vtkQuaternion<type>::Conjugated().GetData()); \
}
#define vtkQuaternionInverse(quaternionType, type) \
quaternionType Inverse() const \
{ \
  return quaternionType(vtkQuaternion<type>::Inverse().GetData()); \
}
#define vtkQuaternionUnitLog(quaternionType, type) \
quaternionType UnitLog() const \
{ \
  return quaternionType( \
    vtkQuaternion<type>::UnitLog().GetData()); \
}
#define vtkQuaternionUnitExp(quaternionType, type) \
quaternionType UnitExp() const \
{ \
  return quaternionType( \
    vtkQuaternion<type>::UnitExp().GetData()); \
}
#define vtkQuaternionNormalizedWithAngleInDegrees(quaternionType, type) \
quaternionType NormalizedWithAngleInDegrees() const \
{ \
  return quaternionType( \
    vtkQuaternion<type>::NormalizedWithAngleInDegrees().GetData()); \
}
#define vtkQuaternionSlerp(quaternionType, type) \
quaternionType Slerp(type t, const quaternionType& q) const \
{ \
  return quaternionType( \
    vtkQuaternion<type>::Slerp(t, q).GetData()); \
}
#define vtkQuaternionInnerPoint(quaternionType, type) \
quaternionType InnerPoint(const quaternionType& q1, \
                          const quaternionType& q2) const \
{ \
  return quaternionType( \
    vtkQuaternion<type>::InnerPoint(q1, q2).GetData()); \
}
#define vtkQuaternionOperatorPlus(quaternionType, type) \
inline quaternionType operator+(const quaternionType& q) const \
{ \
  return quaternionType( ( \
    static_cast< vtkQuaternion<type> > (*this) + \
    static_cast< vtkQuaternion<type> > (q)).GetData()); \
}
#define vtkQuaternionOperatorMinus(quaternionType, type) \
inline quaternionType operator-(const quaternionType& q) const \
{ \
  return quaternionType( ( \
    static_cast< vtkQuaternion<type> > (*this) - \
    static_cast< vtkQuaternion<type> > (q)).GetData()); \
}
#define vtkQuaternionOperatorMultiply(quaternionType, type) \
inline quaternionType operator*(const quaternionType& q) const \
{ \
  return quaternionType( ( \
    static_cast< vtkQuaternion<type> > (*this) * \
    static_cast< vtkQuaternion<type> > (q)).GetData()); \
}
#define vtkQuaternionOperatorMultiplyScalar(quaternionType, type) \
inline quaternionType operator*(const type& scalar) const \
{ \
  return quaternionType( ( \
    static_cast< vtkQuaternion<type> > (*this) * \
    scalar).GetData()); \
}
#define vtkQuaternionOperatorDivide(quaternionType, type) \
inline quaternionType operator/(const quaternionType& q) const \
{ \
  return quaternionType( ( \
    static_cast< vtkQuaternion<type> > (*this) / \
    static_cast< vtkQuaternion<type> > (q)).GetData()); \
}
#define vtkQuaternionOperatorDivideScalar(quaternionType, type) \
inline quaternionType operator/(const type& scalar) const \
{ \
  return quaternionType( ( \
    static_cast< vtkQuaternion<type> > (*this) / \
    scalar).GetData()); \
}

#define vtkQuaternionOperatorMacro(quaternionType, type) \
vtkQuaternionIdentity(quaternionType, type) \
vtkQuaternionNormalized(quaternionType, type) \
vtkQuaternionConjugated(quaternionType, type) \
vtkQuaternionInverse(quaternionType, type) \
vtkQuaternionUnitLog(quaternionType, type) \
vtkQuaternionUnitExp(quaternionType, type) \
vtkQuaternionNormalizedWithAngleInDegrees(quaternionType, type) \
vtkQuaternionSlerp(quaternionType, type) \
vtkQuaternionInnerPoint(quaternionType, type) \
vtkQuaternionOperatorPlus(quaternionType, type) \
vtkQuaternionOperatorMinus(quaternionType, type) \
vtkQuaternionOperatorMultiply(quaternionType, type) \
vtkQuaternionOperatorMultiplyScalar(quaternionType, type) \
vtkQuaternionOperatorDivide(quaternionType, type) \
vtkQuaternionOperatorDivideScalar(quaternionType, type)

// .NAME vtkQuaternionf - Float quaternion type.
//
// .SECTION Description
// This class is uses vtkQuaternion with float type data.
// For further description, see the templated class vtkQuaternion.
// @sa vtkQuaterniond vtkQuaternion
class vtkQuaternionf : public vtkQuaternion<float>
{
public:
  vtkQuaternionf() {}
  explicit vtkQuaternionf(float w, float x, float y, float z)
    : vtkQuaternion<float>(w, x, y, z) {}
  explicit vtkQuaternionf(float scalar) : vtkQuaternion<float>(scalar) {}
  explicit vtkQuaternionf(const float *init) : vtkQuaternion<float>(init) {}
  vtkQuaternionOperatorMacro(vtkQuaternionf, float)
};

// .NAME vtkQuaterniond - Double quaternion type.
//
// .SECTION Description
// This class is uses vtkQuaternion with double type data.
// For further description, seethe templated class vtkQuaternion.
// @sa vtkQuaternionf vtkQuaternion
class vtkQuaterniond : public vtkQuaternion<double>
{
public:
  vtkQuaterniond() {}
  explicit vtkQuaterniond(double w, double x, double y, double z)
    : vtkQuaternion<double>(w, x, y, z) {}
  explicit vtkQuaterniond(double scalar) : vtkQuaternion<double>(scalar) {}
  explicit vtkQuaterniond(const double *init) : vtkQuaternion<double>(init) {}
  vtkQuaternionOperatorMacro(vtkQuaterniond, double);
};

#include "vtkQuaternion.txx"

#endif // vtkQuaternion_h
// VTK-HeaderTest-Exclude: vtkQuaternion.h