VTK  9.0.2
vtkQuaternion.h
Go to the documentation of this file.
1 /*=========================================================================
2 
3  Program: Visualization Toolkit
4  Module: vtkQuaternion.h
5 
6  Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen
7  All rights reserved.
8  See Copyright.txt or http://www.kitware.com/Copyright.htm for details.
9 
10  This software is distributed WITHOUT ANY WARRANTY; without even
11  the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
12  PURPOSE. See the above copyright notice for more information.
13 
14 =========================================================================*/
33 #ifndef vtkQuaternion_h
34 #define vtkQuaternion_h
35 
36 #include "vtkTuple.h"
37 
38 template <typename T>
39 class vtkQuaternion : public vtkTuple<T, 4>
40 {
41 public:
46 
50  explicit vtkQuaternion(const T& scalar)
51  : vtkTuple<T, 4>(scalar)
52  {
53  }
54 
60  explicit vtkQuaternion(const T* init)
61  : vtkTuple<T, 4>(init)
62  {
63  }
64 
68  vtkQuaternion(const T& w, const T& x, const T& y, const T& z);
69 
73  T SquaredNorm() const;
74 
78  T Norm() const;
79 
83  void ToIdentity();
84 
90 
95  T Normalize();
96 
101 
105  void Conjugate();
106 
111 
117  void Invert();
118 
123 
129  void ToUnitLog();
130 
137 
143  void ToUnitExp();
144 
151 
157 
163 
165 
168  void Set(const T& w, const T& x, const T& y, const T& z);
169  void Set(T quat[4]);
170  void Get(T quat[4]) const;
172 
174 
177  void SetW(const T& w);
178  const T& GetW() const;
180 
182 
185  void SetX(const T& x);
186  const T& GetX() const;
188 
190 
193  void SetY(const T& y);
194  const T& GetY() const;
196 
198 
201  void SetZ(const T& z);
202  const T& GetZ() const;
204 
206 
210  T GetRotationAngleAndAxis(T axis[3]) const;
211  void SetRotationAngleAndAxis(T angle, T axis[3]);
212  void SetRotationAngleAndAxis(const T& angle, const T& x, const T& y, const T& z);
214 
218  template <typename CastTo>
220 
226  void ToMatrix3x3(T A[3][3]) const;
227 
234  void FromMatrix3x3(const T A[3][3]);
235 
243 
250 
255 
260 
265 
269  vtkQuaternion<T> operator*(const T& scalar) const;
270 
274  void operator*=(const T& scalar) const;
275 
280 
284  vtkQuaternion<T> operator/(const T& scalar) const;
285 
287 
290  void operator/=(const T& scalar);
292 };
293 
298 #define vtkQuaternionIdentity(quaternionType, type) \
299  quaternionType Identity() const \
300  { \
301  return quaternionType(vtkQuaternion<type>::Identity().GetData()); \
302  }
303 #define vtkQuaternionNormalized(quaternionType, type) \
304  quaternionType Normalized() const \
305  { \
306  return quaternionType(vtkQuaternion<type>::Normalized().GetData()); \
307  }
308 #define vtkQuaternionConjugated(quaternionType, type) \
309  quaternionType Conjugated() const \
310  { \
311  return quaternionType(vtkQuaternion<type>::Conjugated().GetData()); \
312  }
313 #define vtkQuaternionInverse(quaternionType, type) \
314  quaternionType Inverse() const \
315  { \
316  return quaternionType(vtkQuaternion<type>::Inverse().GetData()); \
317  }
318 #define vtkQuaternionUnitLog(quaternionType, type) \
319  quaternionType UnitLog() const \
320  { \
321  return quaternionType(vtkQuaternion<type>::UnitLog().GetData()); \
322  }
323 #define vtkQuaternionUnitExp(quaternionType, type) \
324  quaternionType UnitExp() const \
325  { \
326  return quaternionType(vtkQuaternion<type>::UnitExp().GetData()); \
327  }
328 #define vtkQuaternionNormalizedWithAngleInDegrees(quaternionType, type) \
329  quaternionType NormalizedWithAngleInDegrees() const \
330  { \
331  return quaternionType(vtkQuaternion<type>::NormalizedWithAngleInDegrees().GetData()); \
332  }
333 #define vtkQuaternionSlerp(quaternionType, type) \
334  quaternionType Slerp(type t, const quaternionType& q) const \
335  { \
336  return quaternionType(vtkQuaternion<type>::Slerp(t, q).GetData()); \
337  }
338 #define vtkQuaternionInnerPoint(quaternionType, type) \
339  quaternionType InnerPoint(const quaternionType& q1, const quaternionType& q2) const \
340  { \
341  return quaternionType(vtkQuaternion<type>::InnerPoint(q1, q2).GetData()); \
342  }
343 #define vtkQuaternionOperatorPlus(quaternionType, type) \
344  inline quaternionType operator+(const quaternionType& q) const \
345  { \
346  return quaternionType( \
347  (static_cast<vtkQuaternion<type> >(*this) + static_cast<vtkQuaternion<type> >(q)) \
348  .GetData()); \
349  }
350 #define vtkQuaternionOperatorMinus(quaternionType, type) \
351  inline quaternionType operator-(const quaternionType& q) const \
352  { \
353  return quaternionType( \
354  (static_cast<vtkQuaternion<type> >(*this) - static_cast<vtkQuaternion<type> >(q)) \
355  .GetData()); \
356  }
357 #define vtkQuaternionOperatorMultiply(quaternionType, type) \
358  inline quaternionType operator*(const quaternionType& q) const \
359  { \
360  return quaternionType( \
361  (static_cast<vtkQuaternion<type> >(*this) * static_cast<vtkQuaternion<type> >(q)) \
362  .GetData()); \
363  }
364 #define vtkQuaternionOperatorMultiplyScalar(quaternionType, type) \
365  inline quaternionType operator*(const type& scalar) const \
366  { \
367  return quaternionType((static_cast<vtkQuaternion<type> >(*this) * scalar).GetData()); \
368  }
369 #define vtkQuaternionOperatorDivide(quaternionType, type) \
370  inline quaternionType operator/(const quaternionType& q) const \
371  { \
372  return quaternionType( \
373  (static_cast<vtkQuaternion<type> >(*this) / static_cast<vtkQuaternion<type> >(q)) \
374  .GetData()); \
375  }
376 #define vtkQuaternionOperatorDivideScalar(quaternionType, type) \
377  inline quaternionType operator/(const type& scalar) const \
378  { \
379  return quaternionType((static_cast<vtkQuaternion<type> >(*this) / scalar).GetData()); \
380  }
381 
382 #define vtkQuaternionOperatorMacro(quaternionType, type) \
383  vtkQuaternionIdentity(quaternionType, type); \
384  vtkQuaternionNormalized(quaternionType, type); \
385  vtkQuaternionConjugated(quaternionType, type); \
386  vtkQuaternionInverse(quaternionType, type); \
387  vtkQuaternionUnitLog(quaternionType, type); \
388  vtkQuaternionUnitExp(quaternionType, type); \
389  vtkQuaternionNormalizedWithAngleInDegrees(quaternionType, type); \
390  vtkQuaternionSlerp(quaternionType, type); \
391  vtkQuaternionInnerPoint(quaternionType, type); \
392  vtkQuaternionOperatorPlus(quaternionType, type); \
393  vtkQuaternionOperatorMinus(quaternionType, type); \
394  vtkQuaternionOperatorMultiply(quaternionType, type); \
395  vtkQuaternionOperatorMultiplyScalar(quaternionType, type); \
396  vtkQuaternionOperatorDivide(quaternionType, type); \
397  vtkQuaternionOperatorDivideScalar(quaternionType, type)
398 
399 // .NAME vtkQuaternionf - Float quaternion type.
400 //
401 // .SECTION Description
402 // This class is uses vtkQuaternion with float type data.
403 // For further description, see the templated class vtkQuaternion.
404 // @sa vtkQuaterniond vtkQuaternion
405 class vtkQuaternionf : public vtkQuaternion<float>
406 {
407 public:
409  explicit vtkQuaternionf(float w, float x, float y, float z)
410  : vtkQuaternion<float>(w, x, y, z)
411  {
412  }
413  explicit vtkQuaternionf(float scalar)
414  : vtkQuaternion<float>(scalar)
415  {
416  }
417  explicit vtkQuaternionf(const float* init)
418  : vtkQuaternion<float>(init)
419  {
420  }
422 };
423 
424 // .NAME vtkQuaterniond - Double quaternion type.
425 //
426 // .SECTION Description
427 // This class is uses vtkQuaternion with double type data.
428 // For further description, seethe templated class vtkQuaternion.
429 // @sa vtkQuaternionf vtkQuaternion
430 class vtkQuaterniond : public vtkQuaternion<double>
431 {
432 public:
434  explicit vtkQuaterniond(double w, double x, double y, double z)
435  : vtkQuaternion<double>(w, x, y, z)
436  {
437  }
438  explicit vtkQuaterniond(double scalar)
439  : vtkQuaternion<double>(scalar)
440  {
441  }
442  explicit vtkQuaterniond(const double* init)
443  : vtkQuaternion<double>(init)
444  {
445  }
447 };
448 
449 #include "vtkQuaternion.txx"
450 
451 #endif // vtkQuaternion_h
452 // VTK-HeaderTest-Exclude: vtkQuaternion.h
templated base type for storage of quaternions.
Definition: vtkQuaternion.h:40
void SetRotationAngleAndAxis(T angle, T axis[3])
vtkQuaternion(const T &scalar)
Initialize all of the quaternion's elements with the supplied scalar.
Definition: vtkQuaternion.h:50
void SetX(const T &x)
Set/Get the x component of the quaternion, i.e.
void Set(T quat[4])
vtkQuaternion< T > operator-(const vtkQuaternion< T > &q) const
Performs subtraction of quaternions of the same basic type.
const T & GetY() const
void SetZ(const T &z)
Set/Get the y component of the quaternion, i.e.
void ToUnitExp()
Convert this quaternion to a unit exponential quaternion.
void SetRotationAngleAndAxis(const T &angle, const T &x, const T &y, const T &z)
void SetW(const T &w)
Set/Get the w component of the quaternion, i.e.
T Norm() const
Get the norm of the quaternion, i.e.
void SetY(const T &y)
Set/Get the y component of the quaternion, i.e.
vtkQuaternion< T > UnitLog() const
Return the unit log version of this quaternion.
void operator/=(const T &scalar)
Performs in place division of the quaternions by a scalar value.
void ToMatrix3x3(T A[3][3]) const
Convert a quaternion to a 3x3 rotation matrix.
vtkQuaternion< T > Slerp(T t, const vtkQuaternion< T > &q) const
Interpolate quaternions using spherical linear interpolation between this quaternion and q1 to produc...
vtkQuaternion< T > UnitExp() const
Return the unit exponential version of this quaternion.
vtkQuaternion(const T *init)
Initialize the quaternion's elements with the elements of the supplied array.
Definition: vtkQuaternion.h:60
vtkQuaternion< T > Conjugated() const
Return the conjugate form of this quaternion.
vtkQuaternion< T > InnerPoint(const vtkQuaternion< T > &q1, const vtkQuaternion< T > &q2) const
Interpolates between quaternions, using spherical quadrangle interpolation.
void Invert()
Invert the quaternion in place.
void Get(T quat[4]) const
void Set(const T &w, const T &x, const T &y, const T &z)
Set/Get the w, x, y and z components of the quaternion.
void operator*=(const T &scalar) const
Performs in place multiplication of the quaternions by a scalar value.
vtkQuaternion(const T &w, const T &x, const T &y, const T &z)
Initialize the quaternion element explicitly.
vtkQuaternion< T > operator+(const vtkQuaternion< T > &q) const
Performs addition of quaternion of the same basic type.
T SquaredNorm() const
Get the squared norm of the quaternion.
T Normalize()
Normalize the quaternion in place.
vtkQuaternion< T > Inverse() const
Return the inverted form of this quaternion.
const T & GetW() const
T GetRotationAngleAndAxis(T axis[3]) const
Set/Get the angle (in radians) and the axis corresponding to the axis-angle rotation of this quaterni...
const T & GetX() const
void ToUnitLog()
Convert this quaternion to a unit log quaternion.
vtkQuaternion< T > operator/(const vtkQuaternion< T > &q) const
Performs division of quaternions of the same type.
static vtkQuaternion< T > Identity()
Return the identity quaternion.
const T & GetZ() const
void FromMatrix3x3(const T A[3][3])
Convert a 3x3 matrix into a quaternion.
void Conjugate()
Conjugate the quaternion in place.
vtkQuaternion< T > operator/(const T &scalar) const
Performs division of the quaternions by a scalar value.
vtkQuaternion< T > operator*(const vtkQuaternion< T > &q) const
Performs multiplication of quaternion of the same basic type.
vtkQuaternion< CastTo > Cast() const
Cast the quaternion to the specified type and return the result.
void ToIdentity()
Set the quaternion to identity in place.
void NormalizeWithAngleInDegrees()
Normalize a quaternion in place and transform it to so its angle is in degrees and its axis normalize...
vtkQuaternion()
Default constructor.
vtkQuaternion< T > Normalized() const
Return the normalized form of this quaternion.
vtkQuaternion< T > NormalizedWithAngleInDegrees() const
Returns a quaternion normalized and transformed so its angle is in degrees and its axis normalized.
vtkQuaternion< T > operator*(const T &scalar) const
Performs multiplication of the quaternions by a scalar value.
vtkQuaterniond(double w, double x, double y, double z)
vtkQuaternionOperatorMacro(vtkQuaterniond, double)
vtkQuaterniond(const double *init)
vtkQuaterniond(double scalar)
vtkQuaternionf(float scalar)
vtkQuaternionf(const float *init)
vtkQuaternionOperatorMacro(vtkQuaternionf, float)
vtkQuaternionf(float w, float x, float y, float z)
templated base type for containers of constant size.
Definition: vtkTuple.h:36