Debian Codegraph @

src/ImathTest/testQuat.cpp

raw
1 //
2 // SPDX-License-Identifier: BSD-3-Clause
3 // Copyright Contributors to the OpenEXR Project.
4 //
5
6 #ifdef NDEBUG
7 # undef NDEBUG
8 #endif
9
10 #include <ImathFun.h>
11 #include <ImathMatrixAlgo.h>
12 #include <ImathPlatform.h>
13 #include <ImathQuat.h>
14 #include <cassert>
15 #include <cmath>
16 #include <iostream>
17 #include "testQuat.h"
18
19 // Include ImathForward *after* other headers to validate forward declarations
20 #include <ImathForward.h>
21
22 using namespace std;
23 using namespace IMATH_INTERNAL_NAMESPACE;
24
25 namespace
26 {
27
28 template <class T>
29 void
30 testQuatT ()
31 {
32 const T s = std::numeric_limits<T>::min();
33 const T e = 4 * std::numeric_limits<T>::epsilon();
34
35 //
36 // constructors, r(), v()
37 //
38
39 {
40 Quat<T> q = Quat<T>();
41 assert (q.r == 1 && q.v == Vec3<T> (0, 0, 0));
42
43 q = Quat<T> (2, 3, 4, 5);
44 assert (q.r == 2 && q.v == Vec3<T> (3, 4, 5));
45
46 q = Quat<T> (6, Vec3<T> (7, 8, 9));
47 assert (q.r == 6 && q.v == Vec3<T> (7, 8, 9));
48
49 Quat<T> q1 = Quat<T> (q);
50 assert (q1.r == 6 && q1.v == Vec3<T> (7, 8, 9));
51 }
52
53 //
54 // invert(), inverse()
55 //
56
57 {
58 Quat<T> q = Quat<T> (1, 0, 0, 1);
59 assert (q.inverse() == Quat<T> (0.5, 0, 0, -0.5));
60
61 q.invert();
62 assert (q == Quat<T> (0.5, 0, 0, -0.5));
63 }
64
65 //
66 // normalize(), normalized()
67 //
68
69 {
70 Quat<T> q = Quat<T> (2, Vec3<T> (0, 0, 0));
71 assert (q.normalized() == Quat<T> (1, 0, 0, 0));
72
73 q.normalize();
74 assert (q == Quat<T> (1, 0, 0, 0));
75
76 q = Quat<T> (0, Vec3<T> (0, 2, 0));
77 assert (q.normalized() == Quat<T> (0, 0, 1, 0));
78
79 q.normalize();
80 assert (q == Quat<T> (0, 0, 1, 0));
81 }
82
83 //
84 // length()
85 //
86
87 {
88 Quat<T> q = Quat<T> (3, 0, 4, 0);
89 assert (q.length() == 5);
90 }
91
92 //
93 // setAxisAngle(), angle(), axis()
94 //
95
96 {
97 Quat<T> q;
98 q.setAxisAngle (Vec3<T> (0, 0, 1), T(M_PI_2));
99 Vec3<T> v = q.axis ();
100 T a = q.angle ();
101 assert (v.equalWithAbsError (Vec3<T> (0, 0, 1), e));
102 assert (IMATH_INTERNAL_NAMESPACE::equal (a, T (M_PI_2), e));
103 }
104
105 //
106 // Accuracy of angle() for very small angles
107 // and when real part is slightly greater than 1.
108 //
109
110 {
111 T t = 10 * std::sqrt (s);
112
113 Quat<T> q;
114 q.setAxisAngle (Vec3<T> (0, 0, 1), t);
115 Vec3<T> v = q.axis ();
116 T a = q.angle ();
117 assert (v.equalWithAbsError (Vec3<T> (0, 0, 1), e));
118 assert (IMATH_INTERNAL_NAMESPACE::equal (a, t, t * e));
119
120 q.r *= T(1.1);
121 q.v *= T(1.1);
122 v = q.axis ();
123 a = q.angle ();
124 assert (v.equalWithAbsError (Vec3<T> (0, 0, 1), e));
125 assert (IMATH_INTERNAL_NAMESPACE::equal (a, t, t * e));
126 }
127
128 {
129 T t = T(0.001) * std::sqrt (s);
130
131 Quat<T> q;
132 q.setAxisAngle (Vec3<T> (0, 0, 1), t);
133 Vec3<T> v = q.axis ();
134 T a = q.angle ();
135 assert (v.equalWithAbsError (Vec3<T> (0, 0, 1), e));
136 assert (IMATH_INTERNAL_NAMESPACE::equal (a, t, t * e));
137
138 q.r *= T(1.1);
139 q.v *= T(1.1);
140 v = q.axis ();
141 a = q.angle ();
142 assert (v.equalWithAbsError (Vec3<T> (0, 0, 1), e));
143 assert (IMATH_INTERNAL_NAMESPACE::equal (a, t, t * e));
144 }
145
146 //
147 // toMatrix33(), toMatrix44()
148 //
149
150 {
151 Quat<T> q;
152 q.setRotation (Vec3<T> (1, 0, 0), Vec3<T> (0, 1, 0));
153
154 Matrix33<T> m1 = q.toMatrix33();
155
156 // clang-format off
157
158 assert (m1.equalWithAbsError (Matrix33<T> (0, 1, 0,
159 -1, 0, 0,
160 0, 0, 1),
161 e));
162
163 Matrix44<T> m2 = q.toMatrix44();
164
165 assert (m2.equalWithAbsError (Matrix44<T> (0, 1, 0, 0,
166 -1, 0, 0, 0,
167 0, 0, 1, 0,
168 0, 0, 0, 1),
169 e));
170 // clang-format on
171 }
172
173 //
174 // +, - (unary and binary), ~ *, /, ^
175 //
176
177 assert (Quat<T> (1, 2, 3, 4) + Quat<T> (5, 6, 7, 8) == Quat<T> (6, 8, 10, 12));
178
179 assert (Quat<T> (-1, -2, -3, -4) - Quat<T> (5, 6, 7, 8) == Quat<T> (-6, -8, -10, -12));
180
181 assert (-Quat<T> (1, 2, 3, 4) == Quat<T> (-1, -2, -3, -4));
182
183 assert (~Quat<T> (1, 2, 3, 4) == Quat<T> (1, -2, -3, -4));
184
185 assert (T (2) * Quat<T> (1, 2, 3, 4) == Quat<T> (2, 4, 6, 8));
186
187 assert (Quat<T> (1, 2, 3, 4) * T (2 )== Quat<T> (2, 4, 6, 8));
188
189 assert (Quat<T> (1, 0, 0, 1) * Quat<T> (1, 1, 0, 0) == Quat<T> (1, 1, 1, 1));
190
191 assert (Quat<T> (1, 1, 0, 0) * Quat<T> (1, 0, 0, 1) == Quat<T> (1, 1, -1, 1));
192
193 assert (Quat<T> (1, 0, 0, 1) / Quat<T> (0.5, -0.5, 0, 0) == Quat<T> (1, 1, 1, 1));
194
195 assert (Quat<T> (2, 4, 6, 8) / T (2) == Quat<T> (1, 2, 3, 4));
196
197 assert ((Quat<T> (1, 2, 3, 4) ^ Quat<T> (2, 2, 2, 2)) == 20);
198
199 //
200 // extract()
201 //
202
203 {
204 Vec3<T> vFrom (1, 0, 0);
205 Vec3<T> vTo (0, 1, 1);
206 Matrix44<T> m1 = rotationMatrix (vFrom, vTo);
207
208 Quat<T> q = extractQuat (m1);
209 ;
210
211 Matrix44<T> m2 = q.toMatrix44();
212
213 assert (m2.equalWithAbsError (m1, 2 * e));
214 }
215 }
216
217
218 void
219 testQuatConversions ()
220 {
221 {
222 Quatf q (1, V3f (2, 3, 4));
223 Quatd q1 = Quatd (q);
224 assert (q1.r == 1 && q1.v == V3d (2, 3, 4));
225 }
226
227 {
228 Quatd q (1, V3d (2, 3, 4));
229 Quatf q1 = Quatf (q);
230 assert (q1.r == 1 && q1.v == V3f (2, 3, 4));
231 }
232 }
233
234 } // namespace
235
236
237 void
238 testQuat ()
239 {
240 cout << "Testing basic quaternion operations" << endl;
241
242 testQuatT<float>();
243 testQuatT<double>();
244 testQuatConversions();
245
246 cout << "ok\n" << endl;
247 }