5#include "testing/testing.h"
23 float in_quat[4] = {
w,
x,
y,
z};
24 float norm_quat[4], matrix[3][3], out_quat[4];
38TEST(math_rotation, quat_to_mat_to_quat_rot180)
46TEST(math_rotation, quat_to_mat_to_quat_rot180n)
54TEST(math_rotation, quat_to_mat_to_quat_rot90)
56 const float s2 = 1 /
sqrtf(2);
65TEST(math_rotation, quat_to_mat_to_quat_rot90n)
67 const float s2 = 1 /
sqrtf(2);
76TEST(math_rotation, quat_to_mat_to_quat_bad_T83196)
85TEST(math_rotation, quat_to_mat_to_quat_bad_negative)
91TEST(math_rotation, quat_to_mat_to_quat_near_1000)
105TEST(math_rotation, quat_to_mat_to_quat_near_0100)
119TEST(math_rotation, quat_to_mat_to_quat_near_0010)
133TEST(math_rotation, quat_to_mat_to_quat_near_0001)
148TEST(math_rotation, quat_to_mat_to_quat_zeroed_matrix)
150 float matrix_zeroed[3][3] = {{0.0f}};
151 float matrix_result[3][3];
152 float matrix_unit[3][3];
159 EXPECT_M3_NEAR(matrix_unit, matrix_result,
FLT_EPSILON);
162TEST(math_rotation, quat_split_swing_and_twist_negative)
164 const float input[4] = {-0.5f, 0,
sqrtf(3) / 2, 0};
165 const float expected_swing[4] = {1.0f, 0, 0, 0};
166 const float expected_twist[4] = {0.5f, 0, -
sqrtf(3) / 2, 0};
167 float swing[4], twist[4];
172 EXPECT_V4_NEAR(swing, expected_swing,
FLT_EPSILON);
173 EXPECT_V4_NEAR(twist, expected_twist,
FLT_EPSILON);
176TEST(math_rotation, mat3_normalized_to_quat_fast_degenerate)
182 const float input[3][3] = {
183 {1.0000000000, -0.0000006315, -0.0000000027},
184 {0.0000009365, 1.0000000000, -0.0000000307},
185 {0.0000001964, 0.2103530765, 0.9776254892},
187 const float expect_quat[4] = {
189 -0.052810292690992355,
190 4.9985139582986449e-08,
191 -3.93654971730939e-07,
193 ASSERT_FLOAT_EQ(1.0f,
dot_qtqt(expect_quat, expect_quat))
194 <<
"expected quaternion should be normal";
196 float actual_quat[4];
198 EXPECT_FLOAT_EQ(1.0f,
dot_qtqt(actual_quat, actual_quat));
199 EXPECT_V4_NEAR(expect_quat, actual_quat,
FLT_EPSILON);
208 for (
int i = 0; i < range; i++) {
212 const float sin_cos_test_fl[2] = {
sinf(phi),
cosf(phi)};
213 EXPECT_V2_NEAR(sin_cos_fl, sin_cos_test_fl, expected_eps);
218TEST(math_rotation, sin_cos_from_fraction_accuracy)
220 for (
int range = 1; range <= 64; range++) {
233 } multiple_of = (range & 1) ? MULTIPLE_OF_1 : ((range & 3) ? MULTIPLE_OF_2 : MULTIPLE_OF_4);
237 for (
int i = 0; i < range; i++) {
240 switch (multiple_of) {
241 case MULTIPLE_OF_1: {
242 sin_cos_fl[0] =
fabsf(sin_cos_fl[0]);
245 case MULTIPLE_OF_2: {
246 sin_cos_fl[0] =
fabsf(sin_cos_fl[0]);
247 sin_cos_fl[1] =
fabsf(sin_cos_fl[1]);
250 case MULTIPLE_OF_4: {
251 sin_cos_fl[0] =
fabsf(sin_cos_fl[0]);
252 sin_cos_fl[1] =
fabsf(sin_cos_fl[1]);
253 if (sin_cos_fl[0] > sin_cos_fl[1]) {
254 std::swap(sin_cos_fl[0], sin_cos_fl[1]);
262 std::ranges::sort(coords, [](
const float2 &a,
const float2 &
b) {
263 float delta =
b[0] - a[0];
269 int unique_coords_count = 1;
272 for (
int i = 1; i < range; i_prev = i++) {
273 if (coords[i_prev] != coords[i]) {
274 unique_coords_count += 1;
278 switch (multiple_of) {
279 case MULTIPLE_OF_1: {
280 EXPECT_EQ(unique_coords_count, (range / 2) + 1);
283 case MULTIPLE_OF_2: {
284 EXPECT_EQ(unique_coords_count, (range / 4) + 1);
287 case MULTIPLE_OF_4: {
288 EXPECT_EQ(unique_coords_count, (range / 8) + 1);
294TEST(math_rotation, sin_cos_from_fraction_symmetry)
296 for (
int range = 1; range <= 64; range++) {
305TEST(math_rotation, DefaultConstructor)
319TEST(math_rotation, RotateDirectionAroundAxis)
335TEST(math_rotation, AxisAngleConstructors)
338 EXPECT_V3_NEAR(a.axis(),
float3(0, 0, 1), 1
e-4);
344 EXPECT_V3_NEAR(
b.axis(),
float3(0, 0, 1), 1
e-4);
353 AxisAngle c({1.0f, 0.0f, 0.0f}, {0.0f, 1.0f, 0.0f});
354 EXPECT_V3_NEAR(c.axis(),
float3(0, 0, 1), 1
e-4);
357 AxisAngle d({1.0f, 0.0f, 0.0f}, {0.0f, -1.0f, 0.0f});
358 EXPECT_V3_NEAR(d.axis(),
float3(0, 0, -1), 1
e-4);
362TEST(math_rotation, QuaternionDot)
369TEST(math_rotation, QuaternionConjugate)
375TEST(math_rotation, QuaternionNormalize)
379 float4(0.1825741827, 0.3651483654, 0.5477225780, 0.7302967309),
383TEST(math_rotation, QuaternionInvert)
386 EXPECT_V4_NEAR(
float4(
invert(q1)),
float4(0.0333333f, -0.0666667f, -0.1f, -0.133333f), 1e-4f);
388 Quaternion q2(0.927091f, 0.211322f, -0.124857f, 0.283295f);
390 EXPECT_V4_NEAR(
float4(
result),
float4(0.927091f, -0.211322f, 0.124857f, -0.283295f), 1e-4f);
393TEST(math_rotation, QuaternionCanonicalize)
396 float4(0.5f, 2.0f, 3.0f, 4.0f),
399 float4(0.5f, -2.0f, -3.0f, -4.0f),
403TEST(math_rotation, QuaternionAngleBetween)
408 EXPECT_V4_NEAR(
float4(q3),
float4(-0.394478f, 0.00330195f, 0.284119f, -0.873872f), 1e-4f);
419TEST(math_rotation, QuaternionPower)
442TEST(math_rotation, QuaternionFromTriangle)
444 float3 v1(0.927091f, 0.211322f, -0.124857f);
445 float3 v2(-0.051681f, 0.498261f, -0.86146f);
446 float3 v3(0.211322f, -0.124857f, 0.283295f);
448 float4(0.255566f, -0.213799f, 0.454253f, 0.826214f),
451 float4(0.103802f, 0.295067f, -0.812945f, 0.491204f),
455TEST(math_rotation, QuaternionFromVector)
457 float3 v1(0.927091f, 0.211322f, -0.124857f);
458 float3 v2(-0.051681f, 0.498261f, -0.86146f);
460 float4(0.129047, 0, -0.50443, -0.853755),
463 float4(0.12474, 0.0330631, -0.706333, -0.696017),
466 float4(0.111583, -0.0648251, -0.00729451, -0.991612),
469 float4(0.476074, 0.580363, -0.403954, 0.522832),
472 float4(0.62436, 0.104259, 0, 0.774148),
475 float4(0.622274, 0.0406802, 0.0509963, 0.780077),
478 float4(0.747014, 0.0737433, -0.655337, 0.0840594),
481 float4(0.751728, 0.146562, -0.642981, 0),
484 float4(0.751728, 0.146562, -0.642981, 0),
487 float4(0.991638, 0, 0.0656442, 0.111104),
490 float4(0.706333, 0.696017, 0.12474, 0.0330631),
493 float4(0.991612, -0.0072946, 0.0648251, 0.111583),
496 float4(0.580363, -0.476074, -0.522832, -0.403954),
499 float4(0.781137, -0.083334, 0, -0.618774),
502 float4(0.780077, -0.0509963, 0.0406802, -0.622274),
505 float4(0.0737433, -0.747014, -0.0840594, -0.655337),
508 float4(0.659473, -0.167065, 0.732929, 0),
511 float4(0.659473, -0.167065, 0.732929, 0),
515 float4(0.725211, 0, -0.596013, -0.344729),
518 float4(0.691325, 0.219092, -0.672309, -0.148561),
521 float4(0.643761, -0.333919, -0.370346, -0.580442),
524 float4(0.320473, 0.593889, 0.383792, 0.630315),
527 float4(0.499999, 0.864472, 0, -0.0518617),
530 float4(0.0447733, 0.0257574, -0.49799, -0.865643),
533 float4(0.646551, 0.193334, -0.174318, 0.717082),
536 float4(0.965523, 0.258928, 0.0268567, 0),
539 float4(0.965523, 0.258928, 0.0268567, 0),
542 float4(0.688527, 0, 0.627768, 0.363095),
545 float4(0.672309, 0.148561, 0.691325, 0.219092),
548 float4(0.580442, -0.370345, 0.333919, 0.643761),
551 float4(0.593889, -0.320473, -0.630315, 0.383792),
554 float4(0.866026, -0.499102, 0, 0.0299423),
557 float4(0.865643, -0.49799, -0.0257574, 0.0447733),
560 float4(0.193334, -0.646551, -0.717082, -0.174318),
563 float4(0.260317, -0.960371, -0.0996123, 0),
566 float4(0.260317, -0.960371, -0.0996123, 0),
570TEST(math_rotation, QuaternionWrappedAround)
580TEST(math_rotation, QuaternionFromTracking)
587 if (forward_axis.
axis() == up_axis) {
605TEST(math_rotation, EulerWrappedAround)
613TEST(math_rotation, Euler3ToGimbal)
616 float3 ijk{0.350041, -0.358896, 0.528994};
625 float3x3({0.808309, -0.504665, 0}, {0.47251, 0.863315, 0}, {0.351241, 0, 1}));
627 float3x3({0.808309, 0, -0.351241}, {0.504665, 1, -0}, {0.303232, 0, 0.936285}));
629 float3x3({0.863315, -0.474062, 0}, {0.504665, 0.810963, 0}, {-0, 0.342936, 1}));
631 float3x3({1, -0.504665, 0}, {0, 0.810963, -0.342936}, {0, 0.296062, 0.939359}));
633 float3x3({0.936285, 0, -0.329941}, {0, 1, -0.342936}, {0.351241, 0, 0.879508}));
635 float3x3({1, -0, -0.351241}, {0, 0.939359, -0.321086}, {0, 0.342936, 0.879508}));
656 if ((
abs(src_forward) ==
abs(src_up)) || (
abs(dst_forward) ==
abs(dst_up))) {
662 if (src_forward == dst_forward && src_up == dst_up) {
678 if (src_forward == dst_forward) {
689 float3 point(1.0f, 2.0f, 3.0f);
701 Quaternion q(0.927091f, 0.211322f, -0.124857f, 0.283295f);
703 float3 p(0.576f, -0.6546f, 46.354f);
705 EXPECT_V3_NEAR(
result,
float3(-4.33722f, -21.661f, 40.7608f), 1e-4f);
708 float3 p2(1.0f, 2.0f, 3.0f);
723TEST(math_rotation, DualQuaternionNormalize)
737 EXPECT_V4_NEAR(
float4(sum.
trans), (
float4(0.777778, 0.666667, 0.444444, 0.666667) /
len), 1e-4f);
743TEST(math_rotation, DualQuaternionFromMatrix)
747 {-1.28264, 2.87361, 0.0230992, 12.8871},
748 {3.27343, 0.812993, -0.895575, -13.5216},
751 {0.16104, -0.406549, 0.899324, 22.8871},
752 {0.981987, -0.0252451, -0.187255, -3.52155},
755 {-0.445021, 2.97151, -0.250095, -42.5586},
756 {0.146173, 0.473002, 1.62645, -9.75092},
760 EXPECT_V4_NEAR(
float4(dq.
quat),
float4(0.502368, 0.0543716, -0.854483, -0.120535), 1e-4f);
761 EXPECT_V4_NEAR(
float4(dq.
trans),
float4(22.674, -0.878616, 11.2762, 14.167), 1e-4f);
762 EXPECT_M4_NEAR(dq.
scale, expected_scale_mat, 1e-4f);
768 {-1.04583, -0.150756, -0.385074, -22.2225},
769 {-0.123402, 2.32698, 1.66357, 5.397},
772 {-0.271734, 0.421514, -0.865151, -12.2225},
773 {-0.960477, -0.0623834, 0.27128, 15.397},
776 {0.971507, -0.382422, 1.09917, -69.5943},
777 {-0.331274, 0.8794, 2.67787, -2.88715},
781 EXPECT_V4_NEAR(
float4(dq.
quat),
float4(0.149898, -0.319339, -0.0441496, -0.934668), 1e-4f);
782 EXPECT_V4_NEAR(
float4(dq.
trans),
float4(-2.20019, 39.6236, 49.052, -16.2077), 1e-4f);
783 EXPECT_M4_NEAR(dq.
scale, expected_scale_mat, 1e-4f);
789 for (
int i = 0; i < 1000; i++) {
790 auto frand = []() {
return (std::rand() - RAND_MAX / 2) /
float(RAND_MAX); };
792 float3{frand(), frand(), frand()} * 100.0f,
793 EulerXYZ{frand() * 10.0f, frand() * 10.0f, frand() * 10.0f},
794 float3{frand(), frand(), frand()} * 10.0f);
796 mat.
location() + 10,
EulerXYZ{frand() * 10.0f, frand() * 10.0f, frand() * 10.0f});
804 EXPECT_M4_NEAR(dq.
scale, expect.
scale, 2e-4f);
810TEST(math_rotation, DualQuaternionTransform)
814 {-0.445021, 2.97151, -0.250095, -42.5586},
815 {0.146173, 0.473002, 1.62645, -9.75092},
819 {22.674, -0.878616, 11.2762, 14.167},
822 float3 p0{51.0f, 1647.0f, 12.0f};
823 float3 p1{58.0f, 0.0054f, 10.0f};
824 float3 p2{0.0f, 7854.0f, 111.0f};
839 {-1.28264, 2.87361, 0.0230978},
840 {3.27343, 0.812991, -0.895574}))};
842 EXPECT_V3_NEAR(p0_result, p0_expect, 1e-2f);
843 EXPECT_V3_NEAR(p1_result, p1_expect, 1e-2f);
844 EXPECT_V3_NEAR(p2_result, p2_expect, 1e-2f);
845 EXPECT_M3_NEAR(crazy_space_mat, expected_crazy_space_mat, 1e-4f);
849 {0.971507, -0.382422, 1.09917, -69.5943},
850 {-0.331274, 0.8794, 2.67787, -2.88715},
854 {-2.20019, 39.6236, 49.052, -16.207},
857 float3 p0{51.0f, 1647.0f, 12.0f};
858 float3 p1{58.0f, 0.0054f, 10.0f};
859 float3 p2{0.0f, 7854.0f, 111.0f};
874 {-1.04583, -0.150754, -0.385079},
875 {-0.123401, 2.32698, 1.66357}))};
877 EXPECT_V3_NEAR(p0_result,
float3(-2591.83, -328.472, 3851.6), 1e-2f);
878 EXPECT_V3_NEAR(p1_result,
float3(46.6121, -86.7318, 14.8882), 1e-2f);
879 EXPECT_V3_NEAR(p2_result,
float3(-12309.5, -1248.99, 18466.1), 6e-2f);
880 EXPECT_M3_NEAR(crazy_space_mat, expected_crazy_space_mat, 1e-4f);
884TEST(math_axis_angle, AxisAngleFromQuaternion)
890 EXPECT_V3_NEAR(axis_angle.axis(), from_quaternion.axis(), 1
e-6);
891 EXPECT_NEAR(axis_angle.angle().radian(), from_quaternion.angle().radian(), 1
e-6);
897 EXPECT_V3_NEAR(axis_angle.axis(), from_quaternion.axis(), 1
e-6);
898 EXPECT_NEAR(axis_angle.angle().radian(), from_quaternion.angle().radian(), 1
e-6);
SIMD_FORCE_INLINE const btScalar & z() const
Return the z value.
SIMD_FORCE_INLINE const btScalar & w() const
Return the w value.
constexpr IndexRange()=default
void append_unchecked(const T &value)
void reserve(const int64_t min_capacity)
constexpr int as_int() const
static constexpr Value Z_POS
static constexpr Value Y_NEG
static constexpr Value Z_NEG
static constexpr AxisSigned from_int(int axis_int)
static constexpr Value X_NEG
static constexpr Value Y_POS
static constexpr Value X_POS
constexpr Axis axis() const
constexpr int as_int() const
static constexpr Axis from_int(const int axis_int)
#define EXPECT_NEAR(result, expect, threshold)
ccl_device_inline dual1 len(const ccl_private dual< T > &a)
TEST(math_rotation, DefaultConstructor)
AngleCartesianBase< float > AngleCartesian
QuaternionBase< T > from_triangle(const VecBase< T, 3 > &v1, const VecBase< T, 3 > &v2, const VecBase< T, 3 > &v3, const VecBase< T, 3 > &normal)
AngleRadianBase< float > AngleRadian
QuaternionBase< T > conjugate(const QuaternionBase< T > &a)
QuaternionBase< float > Quaternion
T cos(const AngleRadianBase< T > &a)
MatBase< T, NumCol, NumRow > transpose(const MatBase< T, NumRow, NumCol > &mat)
T pow(const T &x, const T &power)
QuaternionBase< T > from_vector(const VecBase< T, 3 > &vector, const AxisSigned track_flag, const Axis up_flag)
QuaternionBase< T > to_quaternion(const AxisAngleBase< T, AngleT > &axis_angle)
T length(const VecBase< T, Size > &a)
CartesianBasis rotation_between(const CartesianBasis &a, const CartesianBasis &b)
AngleRadianBase< T > angle_between(const QuaternionBase< T > &a, const QuaternionBase< T > &b)
MatT from_loc_rot(const typename MatT::loc_type &location, const RotationT &rotation)
AxisAngleBase< float, AngleRadianBase< float > > AxisAngle
AngleRadianBase< T > angle_between_signed(const QuaternionBase< T > &a, const QuaternionBase< T > &b)
EulerXYZBase< float > EulerXYZ
T dot(const QuaternionBase< T > &a, const QuaternionBase< T > &b)
MatBase< T, 3, 3 > to_gimbal_axis(const Euler3Base< T > &rotation)
CartesianBasis invert(const CartesianBasis &basis)
float3 rotate_direction_around_axis(const float3 &direction, const float3 &axis, float angle)
AngleRadianBase< T > angle_of(const QuaternionBase< T > &q)
DualQuaternionBase< float > DualQuaternion
QuaternionBase< T > invert_normalized(const QuaternionBase< T > &q)
AxisAngleBase< T, AngleT > to_axis_angle(const EulerXYZBase< T > &euler)
MatBase< T, NumCol, NumRow > normalize(const MatBase< T, NumCol, NumRow > &a)
AxisAngleBase< float, AngleCartesianBase< float > > AxisAngleCartesian
QuaternionBase< T > canonicalize(const QuaternionBase< T > &q)
T sin(const AngleRadianBase< T > &a)
Euler3Base< float > Euler3
AngleRadianBase< T > angle_of_signed(const QuaternionBase< T > &q)
CartesianBasis from_orthonormal_axes(const AxisSigned forward, const AxisSigned up)
MatT from_rotation(const RotationT &rotation)
DualQuaternionBase< T > to_dual_quaternion(const MatBase< T, 4, 4 > &mat, const MatBase< T, 4, 4 > &basemat)
MatT from_loc_rot_scale(const typename MatT::loc_type &location, const RotationT &rotation, const VecBase< typename MatT::base_type, ScaleDim > &scale)
VecBase< T, 3 > transform_point(const CartesianBasis &basis, const VecBase< T, 3 > &v)
float quat_split_swing_and_twist(const float q_in[4], int axis, float r_swing[4], float r_twist[4])
ATTR_WARN_UNUSED_RESULT const BMLoop * l
void mat3_normalized_to_quat(float q[4], const float mat[3][3])
float dot_qtqt(const float a[4], const float b[4])
static void test_quat_to_mat_to_quat(float w, float x, float y, float z)
static void test_sin_cos_from_fraction_symmetry(const int range)
MatBase< float, 4, 4 > float4x4
void sin_cos_from_fraction(int numerator, int denominator, float *r_sin, float *r_cos)
bool mat3_from_axis_conversion_single(int src_axis, int dst_axis, float r_mat[3][3])
VecBase< float, 4 > float4
void quat_to_mat3(float m[3][3], const float q[4])
VecBase< float, 2 > float2
void mat3_normalized_to_quat_fast(float q[4], const float mat[3][3])
bool mat3_from_axis_conversion(int src_forward, int src_up, int dst_forward, int dst_up, float r_mat[3][3])
MatBase< float, 3, 3 > float3x3
void quat_apply_track(float quat[4], short axis, short upflag)
void mat4_to_dquat(DualQuat *dq, const float basemat[4][4], const float mat[4][4])
EXPECT_EQ(BLI_expr_pylike_eval(expr, nullptr, 0, &result), EXPR_PYLIKE_INVALID)
void unit_m3(float m[3][3])
ATTR_WARN_UNUSED_RESULT const BMVert * v2
static void test_sin_cos_from_fraction_accuracy(const int range, const float expected_eps)
VecBase< float, 3 > float3
void mul_v3m3_dq(float r[3], float R[3][3], DualQuat *dq)
void mul_qt_fl(float q[4], float f)
ATTR_WARN_UNUSED_RESULT const BMVert const BMEdge * e
float normalize_qt_qt(float r[4], const float q[4])
KERNEL_FEATURE_LIGHT_PASSES KERNEL_FEATURE_PATH_GUIDING float
const c_style_mat & ptr() const
static MatBase identity()
const AngleT & angle() const
const vec3_type & axis() const
QuaternionBase< T > trans
EulerXYZBase wrapped_around(const EulerXYZBase &reference) const
static QuaternionBase identity()
QuaternionBase wrapped_around(const QuaternionBase &reference) const