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() = default;
  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() = default;
  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