HDK
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
dualQuath.h
Go to the documentation of this file.
1 //
2 // Copyright 2021 Pixar
3 //
4 // Licensed under the terms set forth in the LICENSE.txt file available at
5 // https://openusd.org/license.
6 //
7 ////////////////////////////////////////////////////////////////////////
8 // This file is generated by a script. Do not edit directly. Edit the
9 // dualQuat.template.h file to make changes.
10 
11 #ifndef PXR_BASE_GF_DUALQUATH_H
12 #define PXR_BASE_GF_DUALQUATH_H
13 
14 /// \file gf/dualQuath.h
15 /// \ingroup group_gf_LinearAlgebra
16 
17 #include "pxr/pxr.h"
18 #include "pxr/base/gf/api.h"
19 #include "pxr/base/gf/declare.h"
20 #include "pxr/base/gf/traits.h"
21 #include "pxr/base/gf/half.h"
22 
23 #include "pxr/base/gf/quath.h"
24 #include "pxr/base/tf/hash.h"
25 
26 #include <iosfwd>
27 
29 
30 template <>
31 struct GfIsGfDualQuat<class GfDualQuath> { static const bool value = true; };
32 
33 /// Return the dot (inner) product of two dual quaternions.
34 GfHalf GfDot(const GfDualQuath& dq1, const GfDualQuath& dq2);
35 
36 
37 /// \class GfDualQuath
38 /// \ingroup group_gf_LinearAlgebra
39 ///
40 /// Basic type: a real part quaternion and a dual part quaternion.
41 ///
42 /// This class represents a generalized dual quaternion that has a real part
43 /// and a dual part quaternions. Dual quaternions are used to represent a
44 /// combination of rotation and translation.
45 ///
46 /// References:
47 /// https://www.cs.utah.edu/~ladislav/kavan06dual/kavan06dual.pdf
48 /// https://faculty.sites.iastate.edu/jia/files/inline-files/dual-quaternion.pdf
49 ///
50 class GfDualQuath final
51 {
52  public:
53  typedef GfHalf ScalarType;
54 
55  /// The default constructor leaves the dual quaternion undefined.
57 
58  /// Initialize the real part to \p realVal and the imaginary part
59  /// to zero quaternion.
60  ///
61  /// Since quaternions typically must be normalized, reasonable values for
62  /// \p realVal are -1, 0, or 1. Other values are legal but are likely to
63  /// be meaningless.
64  ///
65  explicit GfDualQuath( GfHalf realVal ) : _real( realVal ), _dual( 0 ) {}
66 
67  /// Initialize the real part to \p real quaternion and the imaginary part
68  /// to zero quaternion.
69  ///
70  explicit GfDualQuath( const GfQuath &real )
71  : _real( real ), _dual( 0 ) {
72  }
73 
74  /// This constructor initializes the real and dual parts.
75  GfDualQuath( const GfQuath &real, const GfQuath &dual )
76  : _real( real ), _dual( dual ) {
77  }
78 
79  /// This constructor initializes from a rotation and a translation components.
80  GfDualQuath( const GfQuath &rotation, const GfVec3h &translation )
81  : _real( rotation ) {
82  SetTranslation( translation );
83  }
84 
85  /// Construct from GfDualQuatd.
86  GF_API
87  explicit GfDualQuath(const GfDualQuatd &other);
88  /// Construct from GfDualQuatf.
89  GF_API
90  explicit GfDualQuath(const GfDualQuatf &other);
91 
92  /// Sets the real part of the dual quaternion.
93  void SetReal(const GfQuath &real) {
94  _real = real;
95  }
96 
97  /// Sets the dual part of the dual quaternion.
98  void SetDual(const GfQuath &dual) {
99  _dual = dual;
100  }
101 
102  /// Returns the real part of the dual quaternion.
103  const GfQuath &GetReal() const {
104  return _real;
105  }
106 
107  /// Returns the dual part of the dual quaternion.
108  const GfQuath &GetDual() const {
109  return _dual;
110  }
111 
112  /// Returns the zero dual quaternion, which has a real part of (0,0,0,0) and
113  /// a dual part of (0,0,0,0).
114  static GfDualQuath GetZero() {
116  }
117 
118  /// Returns the identity dual quaternion, which has a real part of (1,0,0,0) and
119  /// a dual part of (0,0,0,0).
122  }
123 
124  /// Returns geometric length of this dual quaternion.
125  GF_API
126  std::pair<GfHalf, GfHalf> GetLength() const;
127 
128  /// Returns a normalized (unit-length) version of this dual quaternion.
129  /// If the length of this dual quaternion is smaller than \p
130  /// eps, this returns the identity dual quaternion.
131  GF_API
133 
134  /// Normalizes this dual quaternion in place.
135  /// Normalizes this dual quaternion in place to unit length, returning the
136  /// length before normalization. If the length of this dual quaternion is
137  /// smaller than \p eps, this sets the dual quaternion to identity.
138  GF_API
139  std::pair<GfHalf, GfHalf> Normalize(GfHalf eps = GF_MIN_VECTOR_LENGTH);
140 
141  /// Returns the conjugate of this dual quaternion.
142  GF_API
143  GfDualQuath GetConjugate() const;
144 
145  /// Returns the inverse of this dual quaternion.
146  GF_API
147  GfDualQuath GetInverse() const;
148 
149  /// Set the translation component of this dual quaternion.
150  GF_API
151  void SetTranslation( const GfVec3h &translation );
152 
153  /// Get the translation component of this dual quaternion.
154  GF_API
155  GfVec3h GetTranslation() const;
156 
157  /// Hash.
158  friend inline size_t hash_value(const GfDualQuath &dq) {
159  return TfHash::Combine(dq.GetReal(), dq.GetDual());
160  }
161 
162  /// Component-wise dual quaternion equality test. The real and dual parts
163  /// must match exactly for dual quaternions to be considered equal.
164  bool operator ==(const GfDualQuath &dq) const {
165  return (GetReal() == dq.GetReal() &&
166  GetDual() == dq.GetDual());
167  }
168 
169  /// Component-wise dual quaternion inequality test. The real and dual
170  /// parts must match exactly for dual quaternions to be considered equal.
171  bool operator !=(const GfDualQuath &dq) const {
172  return ! (*this == dq);
173  }
174 
175  /// Component-wise unary sum operator.
177  _real += dq._real;
178  _dual += dq._dual;
179  return *this;
180  }
181 
182  /// Component-wise unary difference operator.
184  _real -= dq._real;
185  _dual -= dq._dual;
186  return *this;
187  }
188 
189  /// Post-multiplies dual quaternion \p dq into this dual quaternion.
190  GF_API
191  GfDualQuath &operator *=(const GfDualQuath &dq);
192 
193  /// Scales this dual quaternion by \p s.
195  _real *= s;
196  _dual *= s;
197  return *this;
198  }
199 
200  /// Scales this dual quaternion by 1 / \p s.
202  return (*this) *= 1.0 / s;
203  }
204 
205  /// Component-wise binary sum operator.
206  friend GfDualQuath operator +(const GfDualQuath &dq1,
207  const GfDualQuath &dq2) {
208  GfDualQuath dqt = dq1;
209  return dqt += dq2;
210  }
211 
212  /// Component-wise binary difference operator.
213  friend GfDualQuath operator -(const GfDualQuath &dq1,
214  const GfDualQuath &dq2) {
215  GfDualQuath dqt = dq1;
216  return dqt -= dq2;
217  }
218 
219  /// Returns the product of dual quaternions \p dq1 and \p dq2.
220  friend GfDualQuath operator *(const GfDualQuath &dq1,
221  const GfDualQuath &dq2) {
222  GfDualQuath dqt = dq1;
223  return dqt *= dq2;
224  }
225 
226  /// Returns the product of dual quaternion \p dq and scalar \p s.
228  GfDualQuath dqt = dq;
229  return dqt *= s;
230  }
231 
232  /// Returns the product of dual quaternion \p dq and scalar \p s.
234  GfDualQuath dqt = dq;
235  return dqt *= s;
236  }
237 
238  /// Returns the product of dual quaternion \p dq and scalar 1 / \p s.
240  GfDualQuath dqt = dq;
241  return dqt /= s;
242  }
243 
244  /// Transforms the row vector \e vec by the dual quaternion.
245  GF_API
246  GfVec3h Transform(const GfVec3h &vec) const;
247 
248  private:
249  GfQuath _real; // for rotation
250  GfQuath _dual; // for translation
251 };
252 
253 
254 /// Output a GfDualQuath using the format ((rw, rx, ry, rz), (dw, dx, dy, dz)).
255 /// \ingroup group_gf_DebuggingOutput
256 GF_API std::ostream &operator<<(std::ostream &out, const GfDualQuath &dq);
257 
258 
259 /// Returns the dot (inner) product of two dual quaternions.
260 inline GfHalf
261 GfDot(const GfDualQuath& dq1, const GfDualQuath& dq2) {
262  return GfDot(dq1.GetReal(), dq2.GetReal()) + GfDot(dq1.GetDual(), dq2.GetDual());
263 }
264 
266 
267 #endif // PXR_BASE_GF_DUALQUATH_H
Definition: quath.h:43
GF_API GfDualQuath & operator*=(const GfDualQuath &dq)
Post-multiplies dual quaternion dq into this dual quaternion.
const GfQuath & GetReal() const
Returns the real part of the dual quaternion.
Definition: dualQuath.h:103
friend size_t hash_value(const GfDualQuath &dq)
Hash.
Definition: dualQuath.h:158
GF_API std::pair< GfHalf, GfHalf > Normalize(GfHalf eps=GF_MIN_VECTOR_LENGTH)
GfDualQuath(const GfQuath &real)
Definition: dualQuath.h:70
friend GfDualQuath operator+(const GfDualQuath &dq1, const GfDualQuath &dq2)
Component-wise binary sum operator.
Definition: dualQuath.h:206
*get result *(waiting if necessary)*A common idiom is to fire a bunch of sub tasks at the and then *wait for them to all complete We provide a helper class
Definition: thread.h:632
void SetDual(const GfQuath &dual)
Sets the dual part of the dual quaternion.
Definition: dualQuath.h:98
GfDualQuath(const GfQuath &real, const GfQuath &dual)
This constructor initializes the real and dual parts.
Definition: dualQuath.h:75
bool operator==(const GfDualQuath &dq) const
Definition: dualQuath.h:164
GLsizei const GLfloat * value
Definition: glcorearb.h:824
GF_API GfVec3h Transform(const GfVec3h &vec) const
Transforms the row vector vec by the dual quaternion.
static GfQuath GetZero()
Definition: quath.h:82
GfHalf GfDot(const GfDualQuath &dq1, const GfDualQuath &dq2)
Return the dot (inner) product of two dual quaternions.
Definition: dualQuath.h:261
GfHalf ScalarType
Definition: dualQuath.h:53
GLdouble s
Definition: glad.h:3009
GF_API GfVec3h GetTranslation() const
Get the translation component of this dual quaternion.
static GfQuath GetIdentity()
Definition: quath.h:86
GfDualQuath(const GfQuath &rotation, const GfVec3h &translation)
This constructor initializes from a rotation and a translation components.
Definition: dualQuath.h:80
GF_API GfDualQuath GetConjugate() const
Returns the conjugate of this dual quaternion.
const GfQuath & GetDual() const
Returns the dual part of the dual quaternion.
Definition: dualQuath.h:108
GF_API GfDualQuath GetNormalized(GfHalf eps=GF_MIN_VECTOR_LENGTH) const
friend GfDualQuath operator/(const GfDualQuath &dq, GfHalf s)
Returns the product of dual quaternion dq and scalar 1 / s.
Definition: dualQuath.h:239
SIM_API const UT_StringHolder rotation
friend GfDualQuath operator-(const GfDualQuath &dq1, const GfDualQuath &dq2)
Component-wise binary difference operator.
Definition: dualQuath.h:213
void SetReal(const GfQuath &real)
Sets the real part of the dual quaternion.
Definition: dualQuath.h:93
GF_API GfDualQuath GetInverse() const
Returns the inverse of this dual quaternion.
GfDualQuath()
The default constructor leaves the dual quaternion undefined.
Definition: dualQuath.h:56
GF_API void SetTranslation(const GfVec3h &translation)
Set the translation component of this dual quaternion.
static size_t Combine(Args &&...args)
Produce a hash code by combining the hash codes of several objects.
Definition: hash.h:487
PXR_NAMESPACE_CLOSE_SCOPE PXR_NAMESPACE_OPEN_SCOPE
Definition: path.h:1425
GfDualQuath & operator+=(const GfDualQuath &dq)
Component-wise unary sum operator.
Definition: dualQuath.h:176
GF_API std::pair< GfHalf, GfHalf > GetLength() const
Returns geometric length of this dual quaternion.
friend GfDualQuath operator*(const GfDualQuath &dq1, const GfDualQuath &dq2)
Returns the product of dual quaternions dq1 and dq2.
Definition: dualQuath.h:220
GF_API std::ostream & operator<<(std::ostream &out, const GfDualQuath &dq)
#define PXR_NAMESPACE_CLOSE_SCOPE
Definition: pxr.h:74
static GfDualQuath GetZero()
Definition: dualQuath.h:114
bool operator!=(const GfDualQuath &dq) const
Definition: dualQuath.h:171
GfDualQuath & operator/=(GfHalf s)
Scales this dual quaternion by 1 / s.
Definition: dualQuath.h:201
GfDualQuath(GfHalf realVal)
Definition: dualQuath.h:65
Definition: vec3h.h:46
GfDualQuath & operator-=(const GfDualQuath &dq)
Component-wise unary difference operator.
Definition: dualQuath.h:183
#define GF_MIN_VECTOR_LENGTH
Definition: limits.h:17
#define GF_API
Definition: api.h:23
static GfDualQuath GetIdentity()
Definition: dualQuath.h:120