Mathias Agopian | 595ea77 | 2013-08-21 23:10:41 -0700 | [diff] [blame] | 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 | |
Romain Guy | 5d4bae7 | 2016-11-08 09:49:25 -0800 | [diff] [blame] | 17 | #define LOG_TAG "MatTest" |
Mathias Agopian | 595ea77 | 2013-08-21 23:10:41 -0700 | [diff] [blame] | 18 | |
| 19 | #include <stdlib.h> |
Romain Guy | 5d4bae7 | 2016-11-08 09:49:25 -0800 | [diff] [blame] | 20 | |
| 21 | #include <limits> |
| 22 | #include <random> |
| 23 | #include <functional> |
| 24 | |
Mathias Agopian | 595ea77 | 2013-08-21 23:10:41 -0700 | [diff] [blame] | 25 | #include <gtest/gtest.h> |
| 26 | |
Mathias Agopian | 1d77b71 | 2017-02-17 15:46:13 -0800 | [diff] [blame] | 27 | #include <math/mat2.h> |
| 28 | #include <math/mat4.h> |
Mathias Agopian | 595ea77 | 2013-08-21 23:10:41 -0700 | [diff] [blame] | 29 | |
| 30 | namespace android { |
| 31 | |
| 32 | class MatTest : public testing::Test { |
| 33 | protected: |
| 34 | }; |
| 35 | |
| 36 | TEST_F(MatTest, Basics) { |
| 37 | mat4 m0; |
| 38 | EXPECT_EQ(sizeof(mat4), sizeof(float)*16); |
| 39 | } |
| 40 | |
| 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 | |
| 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 | |
| 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 | |
| 102 | TEST_F(MatTest, UnaryOps) { |
| 103 | const mat4 identity; |
| 104 | mat4 m0; |
| 105 | |
Romain Guy | 5d4bae7 | 2016-11-08 09:49:25 -0800 | [diff] [blame] | 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); |
Mathias Agopian | 595ea77 | 2013-08-21 23:10:41 -0700 | [diff] [blame] | 111 | |
Romain Guy | 5d4bae7 | 2016-11-08 09:49:25 -0800 | [diff] [blame] | 112 | m0 = -m0; |
Mathias Agopian | 595ea77 | 2013-08-21 23:10:41 -0700 | [diff] [blame] | 113 | EXPECT_EQ(identity, m0); |
| 114 | } |
| 115 | |
| 116 | TEST_F(MatTest, MiscOps) { |
| 117 | const mat4 identity; |
| 118 | mat4 m0; |
| 119 | EXPECT_EQ(4, trace(m0)); |
| 120 | |
Romain Guy | 5d4bae7 | 2016-11-08 09:49:25 -0800 | [diff] [blame] | 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)); |
Mathias Agopian | 595ea77 | 2013-08-21 23:10:41 -0700 | [diff] [blame] | 123 | EXPECT_EQ(m1, transpose(m2)); |
| 124 | EXPECT_EQ(m2, transpose(m1)); |
Romain Guy | 5d4bae7 | 2016-11-08 09:49:25 -0800 | [diff] [blame] | 125 | EXPECT_EQ(vec4(1, 6, 11, 16), diag(m1)); |
Mathias Agopian | 595ea77 | 2013-08-21 23:10:41 -0700 | [diff] [blame] | 126 | |
| 127 | EXPECT_EQ(identity, inverse(identity)); |
| 128 | |
Romain Guy | 5d4bae7 | 2016-11-08 09:49:25 -0800 | [diff] [blame] | 129 | mat4 m3(vec4(4, 3, 0, 0), vec4(3, 2, 0, 0), vec4(0, 0, 1, 0), vec4(0, 0, 0, 1)); |
Mathias Agopian | 595ea77 | 2013-08-21 23:10:41 -0700 | [diff] [blame] | 130 | mat4 m3i(inverse(m3)); |
| 131 | EXPECT_FLOAT_EQ(-2, m3i[0][0]); |
Romain Guy | 5d4bae7 | 2016-11-08 09:49:25 -0800 | [diff] [blame] | 132 | EXPECT_FLOAT_EQ(3, m3i[0][1]); |
| 133 | EXPECT_FLOAT_EQ(3, m3i[1][0]); |
Mathias Agopian | 595ea77 | 2013-08-21 23:10:41 -0700 | [diff] [blame] | 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); |
Romain Guy | 5d4bae7 | 2016-11-08 09:49:25 -0800 | [diff] [blame] | 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 | } |
Mathias Agopian | 595ea77 | 2013-08-21 23:10:41 -0700 | [diff] [blame] | 150 | } |
| 151 | |
Romain Guy | 5d4bae7 | 2016-11-08 09:49:25 -0800 | [diff] [blame] | 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 | |
| 173 | TEST_F(Mat3Test, Basics) { |
| 174 | mat3 m0; |
| 175 | EXPECT_EQ(sizeof(mat3), sizeof(float)*9); |
| 176 | } |
| 177 | |
| 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 | |
| 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 | |
| 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 | |
| 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 | |
| 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 | |
| 280 | TEST_F(Mat2Test, Basics) { |
| 281 | mat2 m0; |
| 282 | EXPECT_EQ(sizeof(mat2), sizeof(float)*4); |
| 283 | } |
| 284 | |
| 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 | |
| 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 | |
| 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 | |
| 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 | |
| 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 | |
| 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 | //------------------------------------------------------------------------------ |
| 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 | //------------------------------------------------------------------------------ |
| 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 | } \ |
Scott Randolph | beb3942 | 2017-05-16 11:06:29 -0700 | [diff] [blame^] | 490 | } else if (std::is_same<TypeParam,double>::value) { \ |
Romain Guy | 5d4bae7 | 2016-11-08 09:49:25 -0800 | [diff] [blame] | 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); \ |
Scott Randolph | beb3942 | 2017-05-16 11:06:29 -0700 | [diff] [blame^] | 509 | } else if (std::is_same<TypeParam,double>::value) { \ |
Romain Guy | 5d4bae7 | 2016-11-08 09:49:25 -0800 | [diff] [blame] | 510 | ASSERT_DOUBLE_EQ(t1, t2); \ |
| 511 | } else { \ |
| 512 | ASSERT_EQ(t1, t2); \ |
| 513 | } \ |
| 514 | } while(0) |
| 515 | |
| 516 | //------------------------------------------------------------------------------ |
| 517 | // Test some translation stuff. |
| 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> |
| 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. |
| 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. |
| 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. |
| 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. |
| 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. |
| 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 | |
Mathias Agopian | 595ea77 | 2013-08-21 23:10:41 -0700 | [diff] [blame] | 692 | }; // namespace android |