1 /*
2 * Copyright 2013 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17 #define LOG_TAG "MatTest"
18
19 #include <stdlib.h>
20
21 #include <limits>
22 #include <random>
23 #include <functional>
24
25 #include <gtest/gtest.h>
26
27 #include <math/mat2.h>
28 #include <math/mat4.h>
29
30 namespace android {
31
32 class MatTest : public testing::Test {
33 protected:
34 };
35
TEST_F(MatTest,Basics)36 TEST_F(MatTest, Basics) {
37 mat4 m0;
38 EXPECT_EQ(sizeof(mat4), sizeof(float)*16);
39 }
40
TEST_F(MatTest,ComparisonOps)41 TEST_F(MatTest, ComparisonOps) {
42 mat4 m0;
43 mat4 m1(2);
44
45 EXPECT_TRUE(m0 == m0);
46 EXPECT_TRUE(m0 != m1);
47 EXPECT_FALSE(m0 != m0);
48 EXPECT_FALSE(m0 == m1);
49 }
50
TEST_F(MatTest,Constructors)51 TEST_F(MatTest, Constructors) {
52 mat4 m0;
53 ASSERT_EQ(m0[0].x, 1);
54 ASSERT_EQ(m0[0].y, 0);
55 ASSERT_EQ(m0[0].z, 0);
56 ASSERT_EQ(m0[0].w, 0);
57 ASSERT_EQ(m0[1].x, 0);
58 ASSERT_EQ(m0[1].y, 1);
59 ASSERT_EQ(m0[1].z, 0);
60 ASSERT_EQ(m0[1].w, 0);
61 ASSERT_EQ(m0[2].x, 0);
62 ASSERT_EQ(m0[2].y, 0);
63 ASSERT_EQ(m0[2].z, 1);
64 ASSERT_EQ(m0[2].w, 0);
65 ASSERT_EQ(m0[3].x, 0);
66 ASSERT_EQ(m0[3].y, 0);
67 ASSERT_EQ(m0[3].z, 0);
68 ASSERT_EQ(m0[3].w, 1);
69
70 mat4 m1(2);
71 mat4 m2(vec4(2));
72 mat4 m3(m2);
73
74 EXPECT_EQ(m1, m2);
75 EXPECT_EQ(m2, m3);
76 EXPECT_EQ(m3, m1);
77
78 mat4 m4(vec4(1), vec4(2), vec4(3), vec4(4));
79 }
80
TEST_F(MatTest,ArithmeticOps)81 TEST_F(MatTest, ArithmeticOps) {
82 mat4 m0;
83 mat4 m1(2);
84 mat4 m2(vec4(2));
85
86 m1 += m2;
87 EXPECT_EQ(mat4(4), m1);
88
89 m2 -= m1;
90 EXPECT_EQ(mat4(-2), m2);
91
92 m1 *= 2;
93 EXPECT_EQ(mat4(8), m1);
94
95 m1 /= 2;
96 EXPECT_EQ(mat4(4), m1);
97
98 m0 = -m0;
99 EXPECT_EQ(mat4(-1), m0);
100 }
101
TEST_F(MatTest,UnaryOps)102 TEST_F(MatTest, UnaryOps) {
103 const mat4 identity;
104 mat4 m0;
105
106 m0 = -m0;
107 EXPECT_EQ(mat4(vec4(-1, 0, 0, 0),
108 vec4(0, -1, 0, 0),
109 vec4(0, 0, -1, 0),
110 vec4(0, 0, 0, -1)), m0);
111
112 m0 = -m0;
113 EXPECT_EQ(identity, m0);
114 }
115
TEST_F(MatTest,MiscOps)116 TEST_F(MatTest, MiscOps) {
117 const mat4 identity;
118 mat4 m0;
119 EXPECT_EQ(4, trace(m0));
120
121 mat4 m1(vec4(1, 2, 3, 4), vec4(5, 6, 7, 8), vec4(9, 10, 11, 12), vec4(13, 14, 15, 16));
122 mat4 m2(vec4(1, 5, 9, 13), vec4(2, 6, 10, 14), vec4(3, 7, 11, 15), vec4(4, 8, 12, 16));
123 EXPECT_EQ(m1, transpose(m2));
124 EXPECT_EQ(m2, transpose(m1));
125 EXPECT_EQ(vec4(1, 6, 11, 16), diag(m1));
126
127 EXPECT_EQ(identity, inverse(identity));
128
129 mat4 m3(vec4(4, 3, 0, 0), vec4(3, 2, 0, 0), vec4(0, 0, 1, 0), vec4(0, 0, 0, 1));
130 mat4 m3i(inverse(m3));
131 EXPECT_FLOAT_EQ(-2, m3i[0][0]);
132 EXPECT_FLOAT_EQ(3, m3i[0][1]);
133 EXPECT_FLOAT_EQ(3, m3i[1][0]);
134 EXPECT_FLOAT_EQ(-4, m3i[1][1]);
135
136 mat4 m3ii(inverse(m3i));
137 EXPECT_FLOAT_EQ(m3[0][0], m3ii[0][0]);
138 EXPECT_FLOAT_EQ(m3[0][1], m3ii[0][1]);
139 EXPECT_FLOAT_EQ(m3[1][0], m3ii[1][0]);
140 EXPECT_FLOAT_EQ(m3[1][1], m3ii[1][1]);
141
142 EXPECT_EQ(m1, m1*identity);
143
144
145 for (size_t c=0 ; c<4 ; c++) {
146 for (size_t r=0 ; r<4 ; r++) {
147 EXPECT_FLOAT_EQ(m1[c][r], m1(r, c));
148 }
149 }
150 }
151
TEST_F(MatTest,ElementAccess)152 TEST_F(MatTest, ElementAccess) {
153 mat4 m(vec4(1, 2, 3, 4), vec4(5, 6, 7, 8), vec4(9, 10, 11, 12), vec4(13, 14, 15, 16));
154 for (size_t c=0 ; c<4 ; c++) {
155 for (size_t r=0 ; r<4 ; r++) {
156 EXPECT_FLOAT_EQ(m[c][r], m(r, c));
157 }
158 }
159
160 m(3,2) = 100;
161 EXPECT_FLOAT_EQ(m[2][3], 100);
162 EXPECT_FLOAT_EQ(m(3, 2), 100);
163 }
164
165 //------------------------------------------------------------------------------
166 // MAT 3
167 //------------------------------------------------------------------------------
168
169 class Mat3Test : public testing::Test {
170 protected:
171 };
172
TEST_F(Mat3Test,Basics)173 TEST_F(Mat3Test, Basics) {
174 mat3 m0;
175 EXPECT_EQ(sizeof(mat3), sizeof(float)*9);
176 }
177
TEST_F(Mat3Test,ComparisonOps)178 TEST_F(Mat3Test, ComparisonOps) {
179 mat3 m0;
180 mat3 m1(2);
181
182 EXPECT_TRUE(m0 == m0);
183 EXPECT_TRUE(m0 != m1);
184 EXPECT_FALSE(m0 != m0);
185 EXPECT_FALSE(m0 == m1);
186 }
187
TEST_F(Mat3Test,Constructors)188 TEST_F(Mat3Test, Constructors) {
189 mat3 m0;
190 ASSERT_EQ(m0[0].x, 1);
191 ASSERT_EQ(m0[0].y, 0);
192 ASSERT_EQ(m0[0].z, 0);
193 ASSERT_EQ(m0[1].x, 0);
194 ASSERT_EQ(m0[1].y, 1);
195 ASSERT_EQ(m0[1].z, 0);
196 ASSERT_EQ(m0[2].x, 0);
197 ASSERT_EQ(m0[2].y, 0);
198 ASSERT_EQ(m0[2].z, 1);
199
200 mat3 m1(2);
201 mat3 m2(vec3(2));
202 mat3 m3(m2);
203
204 EXPECT_EQ(m1, m2);
205 EXPECT_EQ(m2, m3);
206 EXPECT_EQ(m3, m1);
207 }
208
TEST_F(Mat3Test,ArithmeticOps)209 TEST_F(Mat3Test, ArithmeticOps) {
210 mat3 m0;
211 mat3 m1(2);
212 mat3 m2(vec3(2));
213
214 m1 += m2;
215 EXPECT_EQ(mat3(4), m1);
216
217 m2 -= m1;
218 EXPECT_EQ(mat3(-2), m2);
219
220 m1 *= 2;
221 EXPECT_EQ(mat3(8), m1);
222
223 m1 /= 2;
224 EXPECT_EQ(mat3(4), m1);
225
226 m0 = -m0;
227 EXPECT_EQ(mat3(-1), m0);
228 }
229
TEST_F(Mat3Test,UnaryOps)230 TEST_F(Mat3Test, UnaryOps) {
231 const mat3 identity;
232 mat3 m0;
233
234 m0 = -m0;
235 EXPECT_EQ(mat3(vec3(-1, 0, 0),
236 vec3(0, -1, 0),
237 vec3(0, 0, -1)), m0);
238
239 m0 = -m0;
240 EXPECT_EQ(identity, m0);
241 }
242
TEST_F(Mat3Test,MiscOps)243 TEST_F(Mat3Test, MiscOps) {
244 const mat3 identity;
245 mat3 m0;
246 EXPECT_EQ(3, trace(m0));
247
248 mat3 m1(vec3(1, 2, 3), vec3(4, 5, 6), vec3(7, 8, 9));
249 mat3 m2(vec3(1, 4, 7), vec3(2, 5, 8), vec3(3, 6, 9));
250 EXPECT_EQ(m1, transpose(m2));
251 EXPECT_EQ(m2, transpose(m1));
252 EXPECT_EQ(vec3(1, 5, 9), diag(m1));
253
254 EXPECT_EQ(identity, inverse(identity));
255
256 mat3 m3(vec3(4, 3, 0), vec3(3, 2, 0), vec3(0, 0, 1));
257 mat3 m3i(inverse(m3));
258 EXPECT_FLOAT_EQ(-2, m3i[0][0]);
259 EXPECT_FLOAT_EQ(3, m3i[0][1]);
260 EXPECT_FLOAT_EQ(3, m3i[1][0]);
261 EXPECT_FLOAT_EQ(-4, m3i[1][1]);
262
263 mat3 m3ii(inverse(m3i));
264 EXPECT_FLOAT_EQ(m3[0][0], m3ii[0][0]);
265 EXPECT_FLOAT_EQ(m3[0][1], m3ii[0][1]);
266 EXPECT_FLOAT_EQ(m3[1][0], m3ii[1][0]);
267 EXPECT_FLOAT_EQ(m3[1][1], m3ii[1][1]);
268
269 EXPECT_EQ(m1, m1*identity);
270 }
271
272 //------------------------------------------------------------------------------
273 // MAT 2
274 //------------------------------------------------------------------------------
275
276 class Mat2Test : public testing::Test {
277 protected:
278 };
279
TEST_F(Mat2Test,Basics)280 TEST_F(Mat2Test, Basics) {
281 mat2 m0;
282 EXPECT_EQ(sizeof(mat2), sizeof(float)*4);
283 }
284
TEST_F(Mat2Test,ComparisonOps)285 TEST_F(Mat2Test, ComparisonOps) {
286 mat2 m0;
287 mat2 m1(2);
288
289 EXPECT_TRUE(m0 == m0);
290 EXPECT_TRUE(m0 != m1);
291 EXPECT_FALSE(m0 != m0);
292 EXPECT_FALSE(m0 == m1);
293 }
294
TEST_F(Mat2Test,Constructors)295 TEST_F(Mat2Test, Constructors) {
296 mat2 m0;
297 ASSERT_EQ(m0[0].x, 1);
298 ASSERT_EQ(m0[0].y, 0);
299 ASSERT_EQ(m0[1].x, 0);
300 ASSERT_EQ(m0[1].y, 1);
301
302 mat2 m1(2);
303 mat2 m2(vec2(2));
304 mat2 m3(m2);
305
306 EXPECT_EQ(m1, m2);
307 EXPECT_EQ(m2, m3);
308 EXPECT_EQ(m3, m1);
309 }
310
TEST_F(Mat2Test,ArithmeticOps)311 TEST_F(Mat2Test, ArithmeticOps) {
312 mat2 m0;
313 mat2 m1(2);
314 mat2 m2(vec2(2));
315
316 m1 += m2;
317 EXPECT_EQ(mat2(4), m1);
318
319 m2 -= m1;
320 EXPECT_EQ(mat2(-2), m2);
321
322 m1 *= 2;
323 EXPECT_EQ(mat2(8), m1);
324
325 m1 /= 2;
326 EXPECT_EQ(mat2(4), m1);
327
328 m0 = -m0;
329 EXPECT_EQ(mat2(-1), m0);
330 }
331
TEST_F(Mat2Test,UnaryOps)332 TEST_F(Mat2Test, UnaryOps) {
333 const mat2 identity;
334 mat2 m0;
335
336 m0 = -m0;
337 EXPECT_EQ(mat2(vec2(-1, 0),
338 vec2(0, -1)), m0);
339
340 m0 = -m0;
341 EXPECT_EQ(identity, m0);
342 }
343
TEST_F(Mat2Test,MiscOps)344 TEST_F(Mat2Test, MiscOps) {
345 const mat2 identity;
346 mat2 m0;
347 EXPECT_EQ(2, trace(m0));
348
349 mat2 m1(vec2(1, 2), vec2(3, 4));
350 mat2 m2(vec2(1, 3), vec2(2, 4));
351 EXPECT_EQ(m1, transpose(m2));
352 EXPECT_EQ(m2, transpose(m1));
353 EXPECT_EQ(vec2(1, 4), diag(m1));
354
355 EXPECT_EQ(identity, inverse(identity));
356
357 EXPECT_EQ(m1, m1*identity);
358 }
359
360 //------------------------------------------------------------------------------
361 // MORE MATRIX TESTS
362 //------------------------------------------------------------------------------
363
364 template <typename T>
365 class MatTestT : public ::testing::Test {
366 public:
367 };
368
369 typedef ::testing::Types<float,float> TestMatrixValueTypes;
370
371 TYPED_TEST_CASE(MatTestT, TestMatrixValueTypes);
372
373 #define TEST_MATRIX_INVERSE(MATRIX, EPSILON) \
374 { \
375 typedef decltype(MATRIX) MatrixType; \
376 MatrixType inv1 = inverse(MATRIX); \
377 MatrixType ident1 = MATRIX * inv1; \
378 static const MatrixType IDENTITY; \
379 for (size_t row = 0; row < MatrixType::ROW_SIZE; ++row) { \
380 for (size_t col = 0; col < MatrixType::COL_SIZE; ++col) { \
381 EXPECT_NEAR(ident1[row][col], IDENTITY[row][col], EPSILON); \
382 } \
383 } \
384 }
385
TYPED_TEST(MatTestT,Inverse4)386 TYPED_TEST(MatTestT, Inverse4) {
387 typedef ::android::details::TMat44<TypeParam> M44T;
388
389 M44T m1(1, 0, 0, 0,
390 0, 1, 0, 0,
391 0, 0, 1, 0,
392 0, 0, 0, 1);
393
394 M44T m2(0, -1, 0, 0,
395 1, 0, 0, 0,
396 0, 0, 1, 0,
397 0, 0, 0, 1);
398
399 M44T m3(1, 0, 0, 0,
400 0, 2, 0, 0,
401 0, 0, 0, 1,
402 0, 0, -1, 0);
403
404 M44T m4(
405 4.683281e-01, 1.251189e-02, -8.834660e-01, -4.726541e+00,
406 -8.749647e-01, 1.456563e-01, -4.617587e-01, 3.044795e+00,
407 1.229049e-01, 9.892561e-01, 7.916244e-02, -6.737138e+00,
408 0.000000e+00, 0.000000e+00, 0.000000e+00, 1.000000e+00);
409
410 M44T m5(
411 4.683281e-01, 1.251189e-02, -8.834660e-01, -4.726541e+00,
412 -8.749647e-01, 1.456563e-01, -4.617587e-01, 3.044795e+00,
413 1.229049e-01, 9.892561e-01, 7.916244e-02, -6.737138e+00,
414 1.000000e+00, 2.000000e+00, 3.000000e+00, 4.000000e+00);
415
416 TEST_MATRIX_INVERSE(m1, 0);
417 TEST_MATRIX_INVERSE(m2, 0);
418 TEST_MATRIX_INVERSE(m3, 0);
419 TEST_MATRIX_INVERSE(m4, 20.0 * std::numeric_limits<TypeParam>::epsilon());
420 TEST_MATRIX_INVERSE(m5, 20.0 * std::numeric_limits<TypeParam>::epsilon());
421 }
422
423 //------------------------------------------------------------------------------
TYPED_TEST(MatTestT,Inverse3)424 TYPED_TEST(MatTestT, Inverse3) {
425 typedef ::android::details::TMat33<TypeParam> M33T;
426
427 M33T m1(1, 0, 0,
428 0, 1, 0,
429 0, 0, 1);
430
431 M33T m2(0, -1, 0,
432 1, 0, 0,
433 0, 0, 1);
434
435 M33T m3(2, 0, 0,
436 0, 0, 1,
437 0, -1, 0);
438
439 M33T m4(
440 4.683281e-01, 1.251189e-02, 0.000000e+00,
441 -8.749647e-01, 1.456563e-01, 0.000000e+00,
442 0.000000e+00, 0.000000e+00, 1.000000e+00);
443
444 M33T m5(
445 4.683281e-01, 1.251189e-02, -8.834660e-01,
446 -8.749647e-01, 1.456563e-01, -4.617587e-01,
447 1.229049e-01, 9.892561e-01, 7.916244e-02);
448
449 TEST_MATRIX_INVERSE(m1, 0);
450 TEST_MATRIX_INVERSE(m2, 0);
451 TEST_MATRIX_INVERSE(m3, 0);
452 TEST_MATRIX_INVERSE(m4, 20.0 * std::numeric_limits<TypeParam>::epsilon());
453 TEST_MATRIX_INVERSE(m5, 20.0 * std::numeric_limits<TypeParam>::epsilon());
454 }
455
456 //------------------------------------------------------------------------------
TYPED_TEST(MatTestT,Inverse2)457 TYPED_TEST(MatTestT, Inverse2) {
458 typedef ::android::details::TMat22<TypeParam> M22T;
459
460 M22T m1(1, 0,
461 0, 1);
462
463 M22T m2(0, -1,
464 1, 0);
465
466 M22T m3(
467 4.683281e-01, 1.251189e-02,
468 -8.749647e-01, 1.456563e-01);
469
470 M22T m4(
471 4.683281e-01, 1.251189e-02,
472 -8.749647e-01, 1.456563e-01);
473
474 TEST_MATRIX_INVERSE(m1, 0);
475 TEST_MATRIX_INVERSE(m2, 0);
476 TEST_MATRIX_INVERSE(m3, 20.0 * std::numeric_limits<TypeParam>::epsilon());
477 TEST_MATRIX_INVERSE(m4, 20.0 * std::numeric_limits<TypeParam>::epsilon());
478 }
479
480 //------------------------------------------------------------------------------
481 // A macro to help with vector comparisons within floating point range.
482 #define EXPECT_VEC_EQ(VEC1, VEC2) \
483 do { \
484 const decltype(VEC1) v1 = VEC1; \
485 const decltype(VEC2) v2 = VEC2; \
486 if (std::is_same<TypeParam,float>::value) { \
487 for (size_t i = 0; i < v1.size(); ++i) { \
488 EXPECT_FLOAT_EQ(v1[i], v2[i]); \
489 } \
490 } else if (std::is_same<TypeParam,float>::value) { \
491 for (size_t i = 0; i < v1.size(); ++i) { \
492 EXPECT_DOUBLE_EQ(v1[i], v2[i]); \
493 } \
494 } else { \
495 for (size_t i = 0; i < v1.size(); ++i) { \
496 EXPECT_EQ(v1[i], v2[i]); \
497 } \
498 } \
499 } while(0)
500
501 //------------------------------------------------------------------------------
502 // A macro to help with type comparisons within floating point range.
503 #define ASSERT_TYPE_EQ(T1, T2) \
504 do { \
505 const decltype(T1) t1 = T1; \
506 const decltype(T2) t2 = T2; \
507 if (std::is_same<TypeParam,float>::value) { \
508 ASSERT_FLOAT_EQ(t1, t2); \
509 } else if (std::is_same<TypeParam,float>::value) { \
510 ASSERT_DOUBLE_EQ(t1, t2); \
511 } else { \
512 ASSERT_EQ(t1, t2); \
513 } \
514 } while(0)
515
516 //------------------------------------------------------------------------------
517 // Test some translation stuff.
TYPED_TEST(MatTestT,Translation4)518 TYPED_TEST(MatTestT, Translation4) {
519 typedef ::android::details::TMat44<TypeParam> M44T;
520 typedef ::android::details::TVec4<TypeParam> V4T;
521
522 V4T translateBy(-7.3, 1.1, 14.4, 0.0);
523 V4T translation(translateBy[0], translateBy[1], translateBy[2], 1.0);
524 M44T translation_matrix = M44T::translate(translation);
525
526 V4T p1(9.9, 3.1, 41.1, 1.0);
527 V4T p2(-18.0, 0.0, 1.77, 1.0);
528 V4T p3(0, 0, 0, 1);
529 V4T p4(-1000, -1000, 1000, 1.0);
530
531 EXPECT_VEC_EQ(translation_matrix * p1, translateBy + p1);
532 EXPECT_VEC_EQ(translation_matrix * p2, translateBy + p2);
533 EXPECT_VEC_EQ(translation_matrix * p3, translateBy + p3);
534 EXPECT_VEC_EQ(translation_matrix * p4, translateBy + p4);
535 }
536
537 //------------------------------------------------------------------------------
538 template <typename MATRIX>
verifyOrthonormal(const MATRIX & A)539 static void verifyOrthonormal(const MATRIX& A) {
540 typedef typename MATRIX::value_type T;
541
542 static constexpr T value_eps = T(100) * std::numeric_limits<T>::epsilon();
543
544 const MATRIX prod = A * transpose(A);
545 for (size_t i = 0; i < MATRIX::NUM_COLS; ++i) {
546 for (size_t j = 0; j < MATRIX::NUM_ROWS; ++j) {
547 if (i == j) {
548 ASSERT_NEAR(prod[i][j], T(1), value_eps);
549 } else {
550 ASSERT_NEAR(prod[i][j], T(0), value_eps);
551 }
552 }
553 }
554 }
555
556 //------------------------------------------------------------------------------
557 // Test euler code.
TYPED_TEST(MatTestT,EulerZYX_44)558 TYPED_TEST(MatTestT, EulerZYX_44) {
559 typedef ::android::details::TMat44<TypeParam> M44T;
560
561 std::default_random_engine generator(82828);
562 std::uniform_real_distribution<float> distribution(-6.0 * 2.0*M_PI, 6.0 * 2.0*M_PI);
563 auto rand_gen = std::bind(distribution, generator);
564
565 for (size_t i = 0; i < 100; ++i) {
566 M44T m = M44T::eulerZYX(rand_gen(), rand_gen(), rand_gen());
567 verifyOrthonormal(m);
568 }
569
570 M44T m = M44T::eulerZYX(1, 2, 3);
571 verifyOrthonormal(m);
572 }
573
574 //------------------------------------------------------------------------------
575 // Test euler code.
TYPED_TEST(MatTestT,EulerZYX_33)576 TYPED_TEST(MatTestT, EulerZYX_33) {
577
578 typedef ::android::details::TMat33<TypeParam> M33T;
579
580 std::default_random_engine generator(112233);
581 std::uniform_real_distribution<float> distribution(-6.0 * 2.0*M_PI, 6.0 * 2.0*M_PI);
582 auto rand_gen = std::bind(distribution, generator);
583
584 for (size_t i = 0; i < 100; ++i) {
585 M33T m = M33T::eulerZYX(rand_gen(), rand_gen(), rand_gen());
586 verifyOrthonormal(m);
587 }
588
589 M33T m = M33T::eulerZYX(1, 2, 3);
590 verifyOrthonormal(m);
591 }
592
593 //------------------------------------------------------------------------------
594 // Test to quaternion with post translation.
TYPED_TEST(MatTestT,ToQuaternionPostTranslation)595 TYPED_TEST(MatTestT, ToQuaternionPostTranslation) {
596
597 typedef ::android::details::TMat44<TypeParam> M44T;
598 typedef ::android::details::TVec4<TypeParam> V4T;
599 typedef ::android::details::TQuaternion<TypeParam> QuatT;
600
601 std::default_random_engine generator(112233);
602 std::uniform_real_distribution<float> distribution(-6.0 * 2.0*M_PI, 6.0 * 2.0*M_PI);
603 auto rand_gen = std::bind(distribution, generator);
604
605 for (size_t i = 0; i < 100; ++i) {
606 M44T r = M44T::eulerZYX(rand_gen(), rand_gen(), rand_gen());
607 M44T t = M44T::translate(V4T(rand_gen(), rand_gen(), rand_gen(), 1));
608 QuatT qr = r.toQuaternion();
609 M44T tr = t * r;
610 QuatT qtr = tr.toQuaternion();
611
612 ASSERT_TYPE_EQ(qr.x, qtr.x);
613 ASSERT_TYPE_EQ(qr.y, qtr.y);
614 ASSERT_TYPE_EQ(qr.z, qtr.z);
615 ASSERT_TYPE_EQ(qr.w, qtr.w);
616 }
617
618 M44T r = M44T::eulerZYX(1, 2, 3);
619 M44T t = M44T::translate(V4T(20, -15, 2, 1));
620 QuatT qr = r.toQuaternion();
621 M44T tr = t * r;
622 QuatT qtr = tr.toQuaternion();
623
624 ASSERT_TYPE_EQ(qr.x, qtr.x);
625 ASSERT_TYPE_EQ(qr.y, qtr.y);
626 ASSERT_TYPE_EQ(qr.z, qtr.z);
627 ASSERT_TYPE_EQ(qr.w, qtr.w);
628 }
629
630 //------------------------------------------------------------------------------
631 // Test to quaternion with post translation.
TYPED_TEST(MatTestT,ToQuaternionPointTransformation33)632 TYPED_TEST(MatTestT, ToQuaternionPointTransformation33) {
633 static constexpr TypeParam value_eps =
634 TypeParam(1000) * std::numeric_limits<TypeParam>::epsilon();
635
636 typedef ::android::details::TMat33<TypeParam> M33T;
637 typedef ::android::details::TVec3<TypeParam> V3T;
638 typedef ::android::details::TQuaternion<TypeParam> QuatT;
639
640 std::default_random_engine generator(112233);
641 std::uniform_real_distribution<float> distribution(-100.0, 100.0);
642 auto rand_gen = std::bind(distribution, generator);
643
644 for (size_t i = 0; i < 100; ++i) {
645 M33T r = M33T::eulerZYX(rand_gen(), rand_gen(), rand_gen());
646 QuatT qr = r.toQuaternion();
647 V3T p(rand_gen(), rand_gen(), rand_gen());
648
649 V3T pr = r * p;
650 V3T pq = qr * p;
651
652 ASSERT_NEAR(pr.x, pq.x, value_eps);
653 ASSERT_NEAR(pr.y, pq.y, value_eps);
654 ASSERT_NEAR(pr.z, pq.z, value_eps);
655 }
656 }
657
658 //------------------------------------------------------------------------------
659 // Test to quaternion with post translation.
TYPED_TEST(MatTestT,ToQuaternionPointTransformation44)660 TYPED_TEST(MatTestT, ToQuaternionPointTransformation44) {
661 static constexpr TypeParam value_eps =
662 TypeParam(1000) * std::numeric_limits<TypeParam>::epsilon();
663
664 typedef ::android::details::TMat44<TypeParam> M44T;
665 typedef ::android::details::TVec4<TypeParam> V4T;
666 typedef ::android::details::TVec3<TypeParam> V3T;
667 typedef ::android::details::TQuaternion<TypeParam> QuatT;
668
669 std::default_random_engine generator(992626);
670 std::uniform_real_distribution<float> distribution(-100.0, 100.0);
671 auto rand_gen = std::bind(distribution, generator);
672
673 for (size_t i = 0; i < 100; ++i) {
674 M44T r = M44T::eulerZYX(rand_gen(), rand_gen(), rand_gen());
675 QuatT qr = r.toQuaternion();
676 V3T p(rand_gen(), rand_gen(), rand_gen());
677
678 V4T pr = r * V4T(p.x, p.y, p.z, 1);
679 pr.x /= pr.w;
680 pr.y /= pr.w;
681 pr.z /= pr.w;
682 V3T pq = qr * p;
683
684 ASSERT_NEAR(pr.x, pq.x, value_eps);
685 ASSERT_NEAR(pr.y, pq.y, value_eps);
686 ASSERT_NEAR(pr.z, pq.z, value_eps);
687 }
688 }
689
690 #undef TEST_MATRIX_INVERSE
691
692 }; // namespace android
693