libQuat
Loading...
Searching...
No Matches
3D Quaternion operations
Collaboration diagram for 3D Quaternion operations:

Classes

struct  quaternion_
 
struct  euler_
 

Typedefs

typedef struct quaternion_ quaternion
 
typedef struct euler_ euler
 

Functions

LIBQUAT_DLL_EXPORTED quaternion quat_from_euler (const euler *in_euler)
 
LIBQUAT_DLL_EXPORTED euler euler_from_quat (const quaternion *in_quat)
 
LIBQUAT_DLL_EXPORTED quaternion quaternion_multiply (const quaternion *in_quat1, const quaternion *in_quat2)
 
LIBQUAT_DLL_EXPORTED quaternion quaternion_add (const quaternion *in_quat1, const quaternion *in_quat2)
 
LIBQUAT_DLL_EXPORTED quaternion quaternion_sub (const quaternion *in_quat1, const quaternion *in_quat2)
 
LIBQUAT_DLL_EXPORTED quaternion get_conjugate (const quaternion *in_quat1)
 Get conjugate of a quaternion. The conjugate is defined as: More...
 
LIBQUAT_DLL_EXPORTED quaternion get_inverse (const quaternion *in_quat1)
 Get inverse of a quaternion. The inverse is defined as: More...
 
LIBQUAT_DLL_EXPORTED quaternion operator+ (const quaternion &in_quat1, const quaternion &in_quat2)
 
LIBQUAT_DLL_EXPORTED quaternion operator- (const quaternion &in_quat1, const quaternion &in_quat2)
 
LIBQUAT_DLL_EXPORTED quaternion operator* (const quaternion &in_quat1, const quaternion &in_quat2)
 
LIBQUAT_DLL_EXPORTED quaternion operator* (const float a, const quaternion &b)
 
LIBQUAT_DLL_EXPORTED quaternion operator* (const quaternion &a, const float b)
 
LIBQUAT_DLL_EXPORTED quaternion operator/ (const quaternion &a, const float b)
 
LIBQUAT_DLL_EXPORTED quaternion operator! (const quaternion &in_quat1)
 Get conjugate of a quaternion. The conjugate is defined as: More...
 
LIBQUAT_DLL_EXPORTED float operator~ (const quaternion &a)
 
LIBQUAT_DLL_EXPORTED quaternion operator+ (const quaternion &a)
 Get inverse of a quaternion. The inverse is defined as: More...
 

Detailed Description

Typedef Documentation

◆ euler

typedef struct euler_ euler

3D Euler or Tait-Bryan angles (in radian)

◆ quaternion

typedef struct quaternion_ quaternion

a Quaternion type represented using a scalar \(w\) or \(q_0\) and a 3D vector \(\left(q_1,q_2,q_3\right)\)

Function Documentation

◆ euler_from_quat()

LIBQUAT_DLL_EXPORTED euler euler_from_quat ( const quaternion *  in_quat)

Function to convert given quaternion to Euler angles.

\begin{eqnarray*} \phi & = & \tan^{-1}\left[\frac{2\left(q_0q_1+q_2q_3\right)}{1-2\left(q_1^2+q_2^2\right)}\right]\\ \theta & = &-\sin^{-1}\left[2\left(q_0q_2-q_3q_1\right)\right]\\ \psi & = & \tan^{-1}\left[\frac{2\left(q_0q_3+q_1q_2\right)}{1-2\left(q_2^2+q_3^2\right)}\right]\\ \end{eqnarray*}

Parameters
[in]in_quatinput quaternion instance
Returns
converted euler angles
40 {
41 euler temp = {0.f};
42
43 if (!in_quat) // if null
44 {
45 fprintf(stderr, "%s: Invalid input.", __func__);
46 return temp;
47 }
48
49 temp.roll = atan2f(
50 2.f * (in_quat->w * in_quat->q1 + in_quat->q2 * in_quat->q3),
51 1.f - 2.f * (in_quat->q1 * in_quat->q1 + in_quat->q2 * in_quat->q2));
52 temp.pitch =
53 asinf(2.f * (in_quat->w * in_quat->q2 + in_quat->q1 * in_quat->q3));
54 temp.yaw = atan2f(
55 2.f * (in_quat->w * in_quat->q3 + in_quat->q1 * in_quat->q2),
56 1.f - 2.f * (in_quat->q2 * in_quat->q2 + in_quat->q3 * in_quat->q3));
57
58 return temp;
59}
T fprintf(T... args)
Definition: libquat.h:208
float roll
Definition: libquat.h:210
float pitch
Definition: libquat.h:214
float yaw
Definition: libquat.h:218
float w
Definition: libquat.h:194

◆ get_conjugate()

LIBQUAT_DLL_EXPORTED quaternion get_conjugate ( const quaternion *  in_quat1)

Get conjugate of a quaternion. The conjugate is defined as:

\[ \mathbf{A}^* = q_0- i \vec{q} \]

Parameters
in_quat1input quaternion
Returns
conjugate of the input quaternion
131 {
132 if (!in_quat1) {
133 std::cerr << __func__ << ": Invalid input.\n";
134 return {0.f};
135 }
136
137 return !(*in_quat1);
138}

◆ get_inverse()

LIBQUAT_DLL_EXPORTED quaternion get_inverse ( const quaternion *  in_quat1)

Get inverse of a quaternion. The inverse is defined as:

\[ \mathbf{A}^{-1} = \frac{\mathbf{A}^*}{\left\lVert\mathbf{A}\right\rVert} \]

Parameters
in_quat1input quaternion
Returns
inverse of the input quaternion if exists
NULL quaternion if inverse does not exist
198{ return +(*quat); }

◆ operator!()

LIBQUAT_DLL_EXPORTED quaternion operator! ( const quaternion &  in_quat1)

Get conjugate of a quaternion. The conjugate is defined as:

\[ \mathbf{A}^* = q_0- i \vec{q} \]

Parameters
in_quat1input quaternion
Returns
conjugate of the input quaternion
120 {
121 quaternion temp = {0.f};
122
123 temp.w = in_quat1.w;
124 temp.q1 = -in_quat1.q1;
125 temp.q2 = -in_quat1.q2;
126 temp.q3 = -in_quat1.q3;
127
128 return temp;
129}
Definition: libquat.h:192

◆ operator*() [1/3]

LIBQUAT_DLL_EXPORTED quaternion operator* ( const float  a,
const quaternion &  b 
)

Scalar multiplication of a 3D quaternion.

Parameters
[in]apre-multiplying scalar
[in]bsecond quaternion
Returns
resulting dot product
76 {
77 quaternion temp = {0.f};
78
79 temp.w = in_quat.q0 * scalar;
80 temp.q1 = in_quat.q1 * scalar;
81 temp.q2 = in_quat.q2 * scalar;
82 temp.q3 = in_quat.q3 * scalar;
83
84 return temp;
85}

◆ operator*() [2/3]

LIBQUAT_DLL_EXPORTED quaternion operator* ( const quaternion &  a,
const float  b 
)

Scalar multiplication of a 3D quaternion.

Parameters
[in]apre-multiplying quaternion
[in]bpost-multiplying scalar
Returns
resulting product
87 {
88 quaternion temp = {0.f};
89
90 temp.w = in_quat.q0 * scalar;
91 temp.q1 = in_quat.q1 * scalar;
92 temp.q2 = in_quat.q2 * scalar;
93 temp.q3 = in_quat.q3 * scalar;
94
95 return temp;
96}

◆ operator*() [3/3]

LIBQUAT_DLL_EXPORTED quaternion operator* ( const quaternion &  in_quat1,
const quaternion &  in_quat2 
)

Function to multiply two quaternions.

\begin{eqnarray*} \mathbf{c} & = & \mathbf{a}\otimes\mathbf{b}\\ & = & \begin{bmatrix}a_{0} & a_{1} & a_{2} & a_{3}\end{bmatrix}\otimes\begin{bmatrix}b_{0} & b_{1} & b_{2} & b_{3}\end{bmatrix}\\ & = & \begin{bmatrix} a_{0}b_{0}-a_{1}b_{1}-a_{2}b_{2}-a_{3}b_{3}\\ a_{0}b_{1}+a_{1}b_{0}+a_{2}b_{3}-a_{3}b_{2}\\ a_{0}b_{2}-a_{1}b_{3}+a_{2}b_{0}+a_{3}b_{1}\\ a_{0}b_{3}+a_{1}b_{2}-a_{2}b_{1}+a_{3}b_{0} \end{bmatrix}^{T} \end{eqnarray*}

Parameters
[in]in_quat1first input quaternion instance
[in]in_quat2second input quaternion instance
Returns
resultant quaternion
61 {
62 quaternion temp = {0.f};
63
64 temp.w = in_quat1.w * in_quat2.w - in_quat1.q1 * in_quat2.q1 -
65 in_quat1.q2 * in_quat2.q2 - in_quat1.q3 * in_quat2.q3;
66 temp.q1 = in_quat1.w * in_quat2.q1 + in_quat1.q1 * in_quat2.w +
67 in_quat1.q2 * in_quat2.q3 - in_quat1.q3 * in_quat2.q2;
68 temp.q2 = in_quat1.w * in_quat2.q2 - in_quat1.q1 * in_quat2.q3 +
69 in_quat1.q2 * in_quat2.w + in_quat1.q3 * in_quat2.q1;
70 temp.q3 = in_quat1.w * in_quat2.q3 + in_quat1.q1 * in_quat2.q2 -
71 in_quat1.q2 * in_quat2.q1 + in_quat1.q3 * in_quat2.w;
72
73 return temp;
74}

◆ operator+() [1/2]

LIBQUAT_DLL_EXPORTED quaternion operator+ ( const quaternion &  a)

Get inverse of a quaternion. The inverse is defined as:

\[ \mathbf{A}^{-1} = \frac{\mathbf{A}^*}{\left\lVert\mathbf{A}\right\rVert} \]

Parameters
[in]ainput quaternion
Returns
resultant quaternion
189 {
190 float mag = ~quat; // get norm
191 if (mag == 0) {
192 std::cerr << __func__ << ": Inverse does not exist\n";
193 }
194 quaternion temp = !quat; // get conjugate
195 return temp / (mag * mag);
196}

◆ operator+() [2/2]

LIBQUAT_DLL_EXPORTED quaternion operator+ ( const quaternion &  in_quat1,
const quaternion &  in_quat2 
)

Function to add two quaternions.

Parameters
[in]in_quat1first input quaternion instance
[in]in_quat2second input quaternion instance
Returns
resultant quaternion
140 {
141 quaternion temp = {0.f};
142
143 temp.w = in_quat1.w + in_quat2.w;
144 temp.dual = in_quat1.dual + in_quat2.dual;
145
146 return temp;
147}
vec_3d dual
Definition: libquat.h:199

◆ operator-()

LIBQUAT_DLL_EXPORTED quaternion operator- ( const quaternion &  in_quat1,
const quaternion &  in_quat2 
)

Function to subtract two quaternions.

Parameters
[in]in_quat1quaternion to subtract from
[in]in_quat2quaternion to subtract
Returns
resultant quaternion
160 {
161 quaternion temp = {0.f};
162
163 temp.w = in_quat1.w - in_quat2.w;
164 temp.dual = in_quat1.dual - in_quat2.dual;
165
166 return temp;
167}

◆ operator/()

LIBQUAT_DLL_EXPORTED quaternion operator/ ( const quaternion &  a,
const float  b 
)

Scalar division of a 3D quaternion.

Parameters
[in]aquaternion to divide
[in]bscalar divisor
Returns
resulting quotient
98 {
99 quaternion temp = {0.f};
100
101 temp.w = in_quat.q0 / scalar;
102 temp.q1 = in_quat.q1 / scalar;
103 temp.q2 = in_quat.q2 / scalar;
104 temp.q3 = in_quat.q3 / scalar;
105
106 return temp;
107}

◆ operator~()

LIBQUAT_DLL_EXPORTED float operator~ ( const quaternion &  a)

Compute the norm a quaternion.

\[ \lVert A\rVert = \sqrt{q_0^2 + \vec{a}\cdot\vec{a}} \]

Parameters
[in]ainput vector
Returns
n norm of the given vector
180 {
181 float temp = 0.f;
182
183 temp += in_quat1.q0 * in_quat1.q0;
184 temp += in_quat1.dual * in_quat1.dual;
185
186 return sqrtf(temp);
187}

◆ quat_from_euler()

LIBQUAT_DLL_EXPORTED quaternion quat_from_euler ( const euler *  in_euler)

Function to convert given Euler angles to a quaternion.

\begin{eqnarray*} q_{0} & = &\cos\left(\frac{\phi}{2}\right)\cos\left(\frac{\theta}{2}\right)\cos\left(\frac{\psi}{2}\right) + \sin\left(\frac{\phi}{2}\right)\sin\left(\frac{\theta}{2}\right)\sin\left(\frac{\psi}{2}\right)\\ q_{1} & = &\sin\left(\frac{\phi}{2}\right)\cos\left(\frac{\theta}{2}\right)\cos\left(\frac{\psi}{2}\right) - \cos\left(\frac{\phi}{2}\right)\sin\left(\frac{\theta}{2}\right)\sin\left(\frac{\psi}{2}\right)\\ q_{2} & = &\cos\left(\frac{\phi}{2}\right)\sin\left(\frac{\theta}{2}\right)\cos\left(\frac{\psi}{2}\right) + \sin\left(\frac{\phi}{2}\right)\cos\left(\frac{\theta}{2}\right)\sin\left(\frac{\psi}{2}\right)\\ q_{3} & = &\cos\left(\frac{\phi}{2}\right)\cos\left(\frac{\theta}{2}\right)\sin\left(\frac{\psi}{2}\right) - \sin\left(\frac{\phi}{2}\right)\sin\left(\frac{\theta}{2}\right)\cos\left(\frac{\psi}{2}\right)\\ \end{eqnarray*}

Parameters
[in]in_eulerinput Euler angles instance
Returns
converted quaternion
16 {
17 quaternion temp = {0.f};
18
19 if (!in_euler) // if null
20 {
21 fprintf(stderr, "%s: Invalid input.", __func__);
22 return temp;
23 }
24
25 float cy = cosf(in_euler->yaw * 0.5f);
26 float sy = sinf(in_euler->yaw * 0.5f);
27 float cp = cosf(in_euler->pitch * 0.5f);
28 float sp = sinf(in_euler->pitch * 0.5f);
29 float cr = cosf(in_euler->roll * 0.5f);
30 float sr = sinf(in_euler->roll * 0.5f);
31
32 temp.w = cr * cp * cy + sr * sp * sy;
33 temp.q1 = sr * cp * cy - cr * sp * sy;
34 temp.q2 = cr * sp * cy + sr * cp * sy;
35 temp.q3 = cr * cp * sy - sr * sp * cy;
36
37 return temp;
38}

◆ quaternion_add()

LIBQUAT_DLL_EXPORTED quaternion quaternion_add ( const quaternion *  in_quat1,
const quaternion *  in_quat2 
)

Function to add two quaternions.

Parameters
[in]in_quat1first input quaternion instance
[in]in_quat2second input quaternion instance
Returns
resultant quaternion
150 {
151 if (!in_quat1 || !in_quat2) // if null
152 {
153 std::cerr << __func__ << ": Invalid input.";
154 return {0.f};
155 }
156
157 return *in_quat1 + *in_quat2;
158}

◆ quaternion_multiply()

LIBQUAT_DLL_EXPORTED quaternion quaternion_multiply ( const quaternion *  in_quat1,
const quaternion *  in_quat2 
)

Function to multiply two quaternions.

\begin{eqnarray*} \mathbf{c} & = & \mathbf{a}\otimes\mathbf{b}\\ & = & \begin{bmatrix}a_{0} & a_{1} & a_{2} & a_{3}\end{bmatrix}\otimes\begin{bmatrix}b_{0} & b_{1} & b_{2} & b_{3}\end{bmatrix}\\ & = & \begin{bmatrix} a_{0}b_{0}-a_{1}b_{1}-a_{2}b_{2}-a_{3}b_{3}\\ a_{0}b_{1}+a_{1}b_{0}+a_{2}b_{3}-a_{3}b_{2}\\ a_{0}b_{2}-a_{1}b_{3}+a_{2}b_{0}+a_{3}b_{1}\\ a_{0}b_{3}+a_{1}b_{2}-a_{2}b_{1}+a_{3}b_{0} \end{bmatrix}^{T} \end{eqnarray*}

Parameters
[in]in_quat1first input quaternion instance
[in]in_quat2second input quaternion instance
Returns
resultant quaternion
110 {
111 if (!in_quat1 || !in_quat2) // if null
112 {
113 fprintf(stderr, "%s: Invalid input.", __func__);
114 return {0.f};
115 }
116
117 return *in_quat1 * *in_quat2;
118}

◆ quaternion_sub()

LIBQUAT_DLL_EXPORTED quaternion quaternion_sub ( const quaternion *  in_quat1,
const quaternion *  in_quat2 
)

Function to subtract two quaternions.

Parameters
[in]in_quat1first input quaternion instance
[in]in_quat2second input quaternion instance
Returns
resultant quaternion
170 {
171 if (!in_quat1 || !in_quat2) // if null
172 {
173 std::cerr << __func__ << ": Invalid input.";
174 return {0.f};
175 }
176
177 return *in_quat1 - *in_quat2;
178}