Blender V5.3
util_math_float3x3_test.cpp
Go to the documentation of this file.
1/* SPDX-FileCopyrightText: 2011-2026 Blender Foundation
2 *
3 * SPDX-License-Identifier: Apache-2.0 */
4
5/* Note: These fixtures test default micro-architecture optimization defined in the
6 * util/optimization.h. */
7
9
10#include <gmock/gmock.h>
11#include <gtest/gtest.h>
12
13#include "util/log.h"
14#include "util/transform.h"
15
16#include <iostream>
17
19
20using testing::Not;
21
22/* Use as:
23 * float3 vector1;
24 * float3 vector2;
25 * EXPECT_THAT(vector1, IsNearFloat3(vector2)); */
26MATCHER_P2(IsNearFloat3, expected, eps, "")
27{
28 for (int i = 0; i < 3; ++i) {
29 if (fabsf(arg[i] - expected[i]) > eps) {
30 *result_listener << "component " << i << " should be " << expected[i];
31 return false;
32 }
33 }
34 return true;
35}
36
37/* Use as:
38 * float3x3 matrix1;
39 * float3x3 matrix2;
40 * EXPECT_THAT(matrix1, IsNearFloat3x3(matrix2)); */
41MATCHER_P2(IsNearFloat3x3, expected, eps, "")
42{
43 for (int row = 0; row < 3; ++row) {
44 for (int col = 0; col < 3; ++col) {
45 if (fabsf(arg[row][col] - expected[row][col]) > eps) {
46 *result_listener << "component (" << row << ", " << col << ") should be "
47 << expected[row][col];
48 return false;
49 }
50 }
51 }
52 return true;
53}
54
55/* TODO(sergey): Move to log.h? */
56std::ostream &operator<<(std::ostream &os, const float3x3 &m)
57{
58 os << "(" << m.x << ", " << m.y << ", " << m.z << ")";
59 return os;
60}
61
62class Float3x3Test : public ::testing::Test {
63 void SetUp() override
64 {
65 /* The micro-architecture check is not needed here, but use it here as a demonstration of how
66 * it can be implemented in a clear way. */
67 // GTEST_SKIP() << "Test skipped due to uarch capability";
68 }
69};
70
71/* Basic test for user-defined matcher. */
72TEST_F(Float3x3Test, IsNearFloat3x3)
73{
74 const float3x3 identity = identity_float3x3();
75 const float3x3 zero = zero_float3x3();
76
77 EXPECT_THAT(identity, IsNearFloat3x3(identity, 1e-6f));
78 EXPECT_THAT(zero, Not(IsNearFloat3x3(identity, 1e-6f)));
79}
80
81TEST_F(Float3x3Test, multiply_scalar_by_matrix)
82{
83 /* >>> import numpy as np
84 * >>> a = np.array([[0.1, 0.2, 0.3], [1.1, 1.2, 1.3], [2.1, 2.2, 2.3]])
85 * >>> 3.2 * a
86 * array([[0.32, 0.64, 0.96],
87 * [3.52, 3.84, 4.16],
88 * [6.72, 7.04, 7.36]]) */
89 EXPECT_THAT(3.2f * make_float3x3(make_float3(0.1f, 0.2f, 0.3f),
90 make_float3(1.1f, 1.2f, 1.3f),
91 make_float3(2.1f, 2.2f, 2.3f)),
92 IsNearFloat3x3(make_float3x3(make_float3(0.32f, 0.64f, 0.96f),
93 make_float3(3.52f, 3.84f, 4.16f),
94 make_float3(6.72f, 7.04f, 7.36f)),
95 1e-6f));
96}
97
98TEST_F(Float3x3Test, multiply_matrix_by_scalar)
99{
100 /* >>> import numpy as np
101 * >>> a = np.array([[0.1, 0.2, 0.3], [1.1, 1.2, 1.3], [2.1, 2.2, 2.3]])
102 * >>> a * 3.2
103 * array([[0.32, 0.64, 0.96],
104 * [3.52, 3.84, 4.16],
105 * [6.72, 7.04, 7.36]]) */
106 EXPECT_THAT(make_float3x3(make_float3(0.1f, 0.2f, 0.3f),
107 make_float3(1.1f, 1.2f, 1.3f),
108 make_float3(2.1f, 2.2f, 2.3f)) *
109 3.2f,
110 IsNearFloat3x3(make_float3x3(make_float3(0.32f, 0.64f, 0.96f),
111 make_float3(3.52f, 3.84f, 4.16f),
112 make_float3(6.72f, 7.04f, 7.36f)),
113 1e-6f));
114}
115
116TEST_F(Float3x3Test, multiply_matrix_by_matrix)
117{
118 /* >>> import numpy as np
119 * >>> a = np.array([[0.1, 0.2, 0.3], [1.1, 1.2, 1.3], [2.1, 2.2, 2.3]])
120 * >>> b = np.array([[3.1, 3.2, 3.3], [4.1, 4.2, 4.3], [5.1, 5.2, 5.3]])
121 * >>> a @ b
122 * array([[ 2.66, 2.72, 2.78],
123 * [14.96, 15.32, 15.68],
124 * [27.26, 27.92, 28.58]]) */
125 EXPECT_THAT(make_float3x3(make_float3(0.1f, 0.2f, 0.3f),
126 make_float3(1.1f, 1.2f, 1.3f),
127 make_float3(2.1f, 2.2f, 2.3f)) *
128 make_float3x3(make_float3(3.1f, 3.2f, 3.3f),
129 make_float3(4.1f, 4.2f, 4.3f),
130 make_float3(5.1f, 5.2f, 5.3f)),
131 IsNearFloat3x3(make_float3x3(make_float3(2.66f, 2.72f, 2.78f),
132 make_float3(14.96f, 15.32f, 15.68f),
133 make_float3(27.26f, 27.92f, 28.58f)),
134 1e-5f));
135}
136
137TEST_F(Float3x3Test, multiply_matrix_by_vector)
138{
139 /* >>> import numpy as np
140 * >>> a = np.array([[0.1, 0.2, 0.3], [1.1, 1.2, 1.3], [2.1, 2.2, 2.3]])
141 * >>> b = np.array([3.1, 3.2, 3.3])
142 * >>> a @ b
143 * array([ 1.94, 11.54, 21.14]) */
144 EXPECT_THAT(make_float3x3(make_float3(0.1f, 0.2f, 0.3f),
145 make_float3(1.1f, 1.2f, 1.3f),
146 make_float3(2.1f, 2.2f, 2.3f)) *
147 make_float3(3.1f, 3.2f, 3.3f),
148 IsNearFloat3(make_float3(1.94f, 11.54f, 21.14f), 1e-6f));
149}
150
151TEST_F(Float3x3Test, divide_matrix_by_scalar)
152{
153 /* >>> import numpy as np
154 * >>> a = np.array([[0.1, 0.2, 0.3], [1.1, 1.2, 1.3], [2.1, 2.2, 2.3]])
155 * >>> a / 3.2
156 * array([[0.03125, 0.0625 , 0.09375],
157 * [0.34375, 0.375 , 0.40625],
158 * [0.65625, 0.6875 , 0.71875]]) */
159 EXPECT_THAT(make_float3x3(make_float3(0.1f, 0.2f, 0.3f),
160 make_float3(1.1f, 1.2f, 1.3f),
161 make_float3(2.1f, 2.2f, 2.3f)) /
162 3.2f,
163 IsNearFloat3x3(make_float3x3(make_float3(0.03125f, 0.0625f, 0.09375f),
164 make_float3(0.34375f, 0.375f, 0.40625f),
165 make_float3(0.65625f, 0.6875f, 0.71875f)),
166 1e-6f));
167}
168
170{
171 EXPECT_THAT(float3x3_scale(make_float3(0.1f, 1.2f, 2.3f)),
172 IsNearFloat3x3(make_float3x3(make_float3(0.1f, 0.0f, 0.0f),
173 make_float3(0.0f, 1.2f, 0.0f),
174 make_float3(0.0f, 0.0f, 2.3f)),
175 1e-6f));
176}
177
179{
180 EXPECT_THAT(transposed(make_float3x3(make_float3(0.0f, 0.1f, 0.2f),
181 make_float3(1.0f, 1.1f, 1.2f),
182 make_float3(2.0f, 2.1f, 2.2f))),
183 IsNearFloat3x3(make_float3x3(make_float3(0.0f, 1.0f, 2.0f),
184 make_float3(0.1f, 1.1f, 2.1f),
185 make_float3(0.2f, 1.2f, 2.2f)),
186 1e-6f));
187}
188
190{
191 /* >>> import numpy as np
192 * >>> a = np.array([[0.1, 0.2, 0.3], [1.3, 1.2, 1.1], [2.2, 2.1, 2.3]])
193 * >>> np.linalg.det(a)
194 * np.float64(-0.04199999999999992) */
196 make_float3(1.3f, 1.2f, 1.1f),
197 make_float3(2.2f, 2.1f, 2.3f))),
198 -0.042f,
199 1e-6f);
200}
201
203{
204 EXPECT_THAT(adjoint(make_float3x3(make_float3(-3.0f, 2.0f, -5.0f),
205 make_float3(-1.0f, 0.0f, -2.0f),
206 make_float3(3.0f, -4.0f, 1.0f))),
207 IsNearFloat3x3(make_float3x3(make_float3(-8.0f, 18.0f, -4.0f),
208 make_float3(-5.0f, 12.0f, -1.0f),
209 make_float3(4.0f, -6.0f, 2.0f)),
210 1e-6f));
211}
212
214{
215 /* >>> import numpy as np
216 * >>> a = np.array([[0.1, 0.2, 0.3], [1.3, 1.2, 1.1], [2.2, 2.1, 2.3]])
217 * >>> np.linalg.inv(a)
218 * array([[-10.71428571, -4.04761905, 3.33333333],
219 [ 13.57142857, 10.23809524, -6.66666667],
220 [ -2.14285714, -5.47619048, 3.33333333]]) */
221 const float3x3 matrix = make_float3x3(
222 make_float3(0.1f, 0.2f, 0.3f), make_float3(1.3f, 1.2f, 1.1f), make_float3(2.2f, 2.1f, 2.3f));
223 EXPECT_THAT(inverted(matrix),
224 IsNearFloat3x3(make_float3x3(make_float3(-10.71428571f, -4.04761905f, 3.33333333f),
225 make_float3(13.57142857f, 10.23809524f, -6.66666667f),
226 make_float3(-2.14285714f, -5.47619048f, 3.33333333f)),
227 1e-4f));
228 EXPECT_THAT(matrix * inverted(matrix), IsNearFloat3x3(identity_float3x3(), 1e-5f));
229 EXPECT_THAT(inverted(matrix) * matrix, IsNearFloat3x3(identity_float3x3(), 1e-5f));
230}
231
233{
235 make_quaternion(2.0f * cosf(M_PI_F / 4.0f), 0, 0, 2.0f * sinf(M_PI_F / 4.0f))),
236 IsNearFloat3x3(make_float3x3(make_float3(0.0f, -4.0f, 0.0f),
237 make_float3(4.0f, 0.0f, 0.0f),
238 make_float3(0.0f, 0.0f, 4.0f)),
239 1e-6f));
240}
241
243{
244 /* >>> from scipy.spatial.transform import Rotation as R
245 * >>> import numpy as np
246 * >>> r = R.from_quat([np.cos(np.pi/4), 0, 0, np.sin(np.pi/4)], scalar_first=True)
247 * >>> r.as_matrix()
248 * array([[ 2.22044605e-16, -1.00000000e+00, 0.00000000e+00],
249 * [ 1.00000000e+00, 2.22044605e-16, 0.00000000e+00],
250 * [ 0.00000000e+00, 0.00000000e+00, 1.00000000e+00]]) */
251 EXPECT_THAT(
253 IsNearFloat3x3(make_float3x3(make_float3(0.0f, -1.0f, 0.0f),
254 make_float3(1.0f, 0.0f, 0.0f),
255 make_float3(0.0f, 0.0f, 1.0f)),
256 1e-6f));
257 EXPECT_THAT(quaternion_to_rotation(
258 make_quaternion(2.0f * cosf(M_PI_F / 4.0f), 0, 0, 2.0f * sinf(M_PI_F / 4.0f))),
259 IsNearFloat3x3(make_float3x3(make_float3(0.0f, -1.0f, 0.0f),
260 make_float3(1.0f, 0.0f, 0.0f),
261 make_float3(0.0f, 0.0f, 1.0f)),
262 1e-6f));
263
264 {
265 Transform tfm = transform_euler(make_float3(0.1f, -0.2f, 0.3f));
266 const float4 q = transform_to_quat(tfm);
267 const float3x3 R = quaternion_to_rotation(make_quaternion(q.w, q.x, q.y, q.z));
268 EXPECT_THAT(R.x, IsNearFloat3(tfm.x, 1e-6f));
269 EXPECT_THAT(R.y, IsNearFloat3(tfm.y, 1e-6f));
270 EXPECT_THAT(R.z, IsNearFloat3(tfm.z, 1e-6f));
271 }
272}
273
275
276TEST_F(PackedFloat3x3Test, init_from_float3x3)
277{
278 const packed_float3x3 packed(make_float3x3(make_float3(0.0f, 0.1f, 0.2f),
279 make_float3(1.0f, 1.1f, 1.2f),
280 make_float3(2.0f, 2.1f, 2.2f)));
281 EXPECT_NEAR(packed.x.x, 0.0f, 1e-6f);
282 EXPECT_NEAR(packed.x.y, 0.1f, 1e-6f);
283 EXPECT_NEAR(packed.x.z, 0.2f, 1e-6f);
284
285 EXPECT_NEAR(packed.y.x, 1.0f, 1e-6f);
286 EXPECT_NEAR(packed.y.y, 1.1f, 1e-6f);
287 EXPECT_NEAR(packed.y.z, 1.2f, 1e-6f);
288
289 EXPECT_NEAR(packed.z.x, 2.0f, 1e-6f);
290 EXPECT_NEAR(packed.z.y, 2.1f, 1e-6f);
291 EXPECT_NEAR(packed.z.z, 2.2f, 1e-6f);
292}
293
294TEST_F(PackedFloat3x3Test, cast_to_float3x3)
295{
296 const packed_float3x3 packed(make_float3x3(make_float3(0.0f, 0.1f, 0.2f),
297 make_float3(1.0f, 1.1f, 1.2f),
298 make_float3(2.0f, 2.1f, 2.2f)));
299 const float3x3 unpacked = packed;
300 EXPECT_THAT(unpacked,
301 IsNearFloat3x3(make_float3x3(make_float3(0.0f, 0.1f, 0.2f),
302 make_float3(1.0f, 1.1f, 1.2f),
303 make_float3(2.0f, 2.1f, 2.2f)),
304 1e-6f));
305}
306
307TEST_F(PackedFloat3x3Test, assign_from_float3x3)
308{
310 packed = make_float3x3(
311 make_float3(0.0f, 0.1f, 0.2f), make_float3(1.0f, 1.1f, 1.2f), make_float3(2.0f, 2.1f, 2.2f));
312 EXPECT_THAT(float3x3(packed),
313 IsNearFloat3x3(make_float3x3(make_float3(0.0f, 0.1f, 0.2f),
314 make_float3(1.0f, 1.1f, 1.2f),
315 make_float3(2.0f, 2.1f, 2.2f)),
316 1e-6f));
317}
318
#define CCL_NAMESPACE_END
std::ostream & operator<<(std::ostream &os, DeviceKernel kernel)
ccl_device_forceinline float3 make_float3(const float x, const float y, const float z)
TEST_F(FFmpegTest, libaom_av1_AV_PIX_FMT_YUV420P)
b[1] b &&[1] b &&[1] b &&[1] b &&[1] b[3] b &&[1] b[3] float determinant(MatBase< C, R >) RET
void quaternion_to_rotation(float w, float x, float y, float z, float4 &rotation)
float2x2 adjoint(float2x2 mat)
#define EXPECT_NEAR(result, expect, threshold)
ccl_device_inline float3x3 transposed(const float3x3 m)
ccl_device_inline float3x3 inverted(const float3x3 m)
ccl_device_inline float3x3 quaternion_to_scaled_rotation(const Quaternion q)
ccl_device_inline float3x3 float3x3_scale(const float3 s)
#define R
const btScalar eps
Definition poly34.cpp:11
#define fabsf
#define sinf
#define M_PI_F
#define cosf
float4 y
Definition transform.h:53
float4 x
Definition transform.h:53
float4 z
Definition transform.h:53
float y
Definition sky_math.h:225
float z
Definition sky_math.h:225
float x
Definition sky_math.h:225
float w
Definition sky_math.h:225
packed_float3 z
packed_float3 x
packed_float3 y
float4 transform_to_quat(const Transform &tfm)
Definition transform.cpp:23
ccl_device_inline Transform transform_euler(const float3 euler)
Definition transform.h:348
ccl_device_inline float3x3 identity_float3x3()
ccl_device_inline float3x3 zero_float3x3()
ccl_device_inline float3x3 make_float3x3(const float3 x, const float3 y, const float3 z)
ccl_device_inline Quaternion make_quaternion(const float w, const float x, const float y, const float z)
MATCHER_P2(IsNearFloat3, expected, eps, "")