Blender V5.3
source/blender/blenkernel/intern/image_test.cc
Go to the documentation of this file.
1/* SPDX-FileCopyrightText: 2022 Blender Authors
2 *
3 * SPDX-License-Identifier: GPL-2.0-or-later */
4
5#include "BLI_listbase.hh"
6#include "BLI_path_utils.hh"
7#include "BLI_string.hh"
8#include "BLI_string_ref.hh"
9#include "BLI_vector.hh"
10
11#include "BKE_appdir.hh"
12#include "BKE_global.hh"
13#include "BKE_gtest_base.hh"
14#include "BKE_idtype.hh"
15#include "BKE_image.hh"
16#include "BKE_main.hh"
17
18#include "MEM_guardedalloc.h"
19
20#include "testing/testing.h"
21#include "gmock/gmock.h"
22
23#include "IMB_cache.hh"
24#include "IMB_imbuf.hh"
25
26#include "DNA_image_types.h"
27
28#include "RE_pipeline.h"
29
30namespace blender::bke::tests {
31
32using testing::Eq;
33using testing::Pointwise;
34
35class UdimTest : public BlenderGTestBase {};
36
37TEST_F(UdimTest, image_ensure_tile_token)
38{
39 auto verify = [](const char *original, const char *expected) {
40 char result[FILE_MAX];
41
42 STRNCPY(result, original);
44 EXPECT_STREQ(result, expected);
45 };
46
47 /* Already present tokens. */
48 verify("test.<UDIM>.png", "test.<UDIM>.png");
49 verify("test.<UVTILE>.png", "test.<UVTILE>.png");
50
51 /* UDIM pattern detection. */
52 verify("test.1002.png", "test.<UDIM>.png");
53 verify("test-1002-ao.png", "test-<UDIM>-ao.png");
54 verify("test_1002_ao.png", "test_<UDIM>_ao.png");
55 verify("test.1002.ver0023.png", "test.<UDIM>.ver0023.png");
56 verify("test.ver0023.1002.png", "test.ver0023.<UDIM>.png");
57 verify("test.1002.1.png", "test.<UDIM>.1.png");
58 verify("test.1.1002.png", "test.1.<UDIM>.png");
59 verify("test-2022-01-01.1002.png", "test-2022-01-01.<UDIM>.png");
60 verify("1111_11.1002.png", "1111_11.<UDIM>.png");
61 verify("2111_01.1002.png", "2111_01.<UDIM>.png");
62 verify("2022_1002_100200.1002.png", "2022_1002_100200.<UDIM>.png");
63
64 /* UVTILE pattern detection. */
65 verify("uv-test.u2_v10.png", "uv-test.<UVTILE>.png");
66 verify("uv-test-u2_v10-ao.png", "uv-test-<UVTILE>-ao.png");
67 verify("uv-test_u2_v10_ao.png", "uv-test_<UVTILE>_ao.png");
68 verify("uv-test.u10_v100.png", "uv-test.<UVTILE>.png");
69 verify("u_v-test.u2_v10.png", "u_v-test.<UVTILE>.png");
70 verify("u2_v10uv-test.png", "<UVTILE>uv-test.png");
71 verify("u2_v10u_v-test.png", "<UVTILE>u_v-test.png");
72
73 /* Patterns which should not be detected as UDIMs. */
74 for (const char *incorrect : {"1002.png",
75 "1002test.png",
76 "test1002.png",
77 "test(1002).png",
78 "(1002)test.png",
79 "test-1080p.png",
80 "test-1920x1080.png",
81 "test.123.png",
82 "test.12345.png",
83 "test.uv.png",
84 "test.u1v.png",
85 "test.uv1.png",
86 "test.u_v.png",
87 "test.u1_v.png",
88 "test.u_v2.png",
89 "test.u2v3.png",
90 "test.u123_v1.png",
91 "test.u1_v12345.png"})
92 {
93 /* These should not result in modifications happening. */
94 verify(incorrect, incorrect);
95 }
96}
97
98TEST_F(UdimTest, image_get_tile_strformat)
99{
100 eUDIM_TILE_FORMAT tile_format;
101 char *udim_pattern;
102
103 /* Parameter validation. */
104 udim_pattern = BKE_image_get_tile_strformat(nullptr, &tile_format);
105 EXPECT_EQ(udim_pattern, nullptr);
106
107 udim_pattern = BKE_image_get_tile_strformat("", nullptr);
108 EXPECT_EQ(udim_pattern, nullptr);
109
110 /* Typical usage. */
111 udim_pattern = BKE_image_get_tile_strformat("", &tile_format);
112 EXPECT_EQ(tile_format, UDIM_TILE_FORMAT_NONE);
113 EXPECT_EQ(udim_pattern, nullptr);
114
115 udim_pattern = BKE_image_get_tile_strformat("test.<UNKNOWN>.png", &tile_format);
116 EXPECT_EQ(tile_format, UDIM_TILE_FORMAT_NONE);
117 EXPECT_EQ(udim_pattern, nullptr);
118
119 udim_pattern = BKE_image_get_tile_strformat("test.<UDIM>.png", &tile_format);
120 EXPECT_EQ(tile_format, UDIM_TILE_FORMAT_UDIM);
121 EXPECT_STREQ(udim_pattern, "test.%d.png");
122 MEM_delete(udim_pattern);
123
124 udim_pattern = BKE_image_get_tile_strformat("test.<UVTILE>.png", &tile_format);
126 EXPECT_STREQ(udim_pattern, "test.u%d_v%d.png");
127 MEM_delete(udim_pattern);
128}
129
130TEST_F(UdimTest, image_get_tile_number_from_filepath)
131{
132 eUDIM_TILE_FORMAT tile_format;
133 char *udim_pattern;
134 int tile_number;
135
136 udim_pattern = BKE_image_get_tile_strformat("test.<UDIM>.png", &tile_format);
137 EXPECT_EQ(tile_format, UDIM_TILE_FORMAT_UDIM);
138 EXPECT_NE(udim_pattern, nullptr);
139
140 /* Parameter validation. */
142 BKE_image_get_tile_number_from_filepath(nullptr, udim_pattern, tile_format, &tile_number));
144 "test.1004.png", nullptr, tile_format, &tile_number));
146 "test.1004.png", udim_pattern, UDIM_TILE_FORMAT_NONE, &tile_number));
148 "test.1004.png", udim_pattern, tile_format, nullptr));
149
150 /* UDIM tile format tests. */
152 "test.1004.png", udim_pattern, tile_format, &tile_number));
153 EXPECT_EQ(tile_number, 1004);
154
156 "has_no_number.png", udim_pattern, tile_format, &tile_number));
158 "test.X.png", udim_pattern, tile_format, &tile_number));
160 "wrong.1004.png", udim_pattern, tile_format, &tile_number));
161
162 MEM_delete(udim_pattern);
163
164 /* UVTILE tile format tests. */
165 udim_pattern = BKE_image_get_tile_strformat("test.<UVTILE>.png", &tile_format);
167 EXPECT_NE(udim_pattern, nullptr);
168
170 "test.u2_v2.png", udim_pattern, tile_format, &tile_number));
171 EXPECT_EQ(tile_number, 1012);
172
174 "has_no_number.png", udim_pattern, tile_format, &tile_number));
176 "test.u1_vX.png", udim_pattern, tile_format, &tile_number));
178 "test.uX_v1.png", udim_pattern, tile_format, &tile_number));
180 "wrong.u2_v2.png", udim_pattern, tile_format, &tile_number));
181
182 MEM_delete(udim_pattern);
183}
184
185TEST_F(UdimTest, image_set_filepath_from_tile_number)
186{
187 eUDIM_TILE_FORMAT tile_format;
188 char *udim_pattern;
189
190 udim_pattern = BKE_image_get_tile_strformat("test.<UDIM>.png", &tile_format);
191 EXPECT_EQ(tile_format, UDIM_TILE_FORMAT_UDIM);
192 EXPECT_NE(udim_pattern, nullptr);
193
194 char filepath[FILE_MAX];
195
196 /* Parameter validation. */
197 STRNCPY(filepath, "xxxx");
198
199 BKE_image_set_filepath_from_tile_number(nullptr, udim_pattern, tile_format, 1028);
200 BKE_image_set_filepath_from_tile_number(filepath, nullptr, tile_format, 1028);
201 EXPECT_STREQ(filepath, "xxxx");
203 EXPECT_STREQ(filepath, "xxxx");
204
205 /* UDIM tile format tests. */
206 BKE_image_set_filepath_from_tile_number(filepath, udim_pattern, tile_format, 1028);
207 EXPECT_STREQ(filepath, "test.1028.png");
208 MEM_delete(udim_pattern);
209
210 /* UVTILE tile format tests. */
211 udim_pattern = BKE_image_get_tile_strformat("test.<UVTILE>.png", &tile_format);
213 EXPECT_NE(udim_pattern, nullptr);
214
215 BKE_image_set_filepath_from_tile_number(filepath, udim_pattern, tile_format, 1028);
216 EXPECT_STREQ(filepath, "test.u8_v3.png");
217 MEM_delete(udim_pattern);
218}
219
221 Main *bmain_ = nullptr;
222
223 RenderResult *get_image_render_result(Image &image)
224 {
225 ImageUser iuser{};
226 BKE_imageuser_default(&iuser);
227
228 ImBuf *temp_ibuf = BKE_image_acquire_ibuf(&image, &iuser, nullptr);
229 BKE_image_release_ibuf(&image, temp_ibuf, nullptr);
230
231 return image.rr;
232 }
233
234 protected:
235 void SetUp() override
236 {
237 bmain_ = BKE_main_new();
238 G_MAIN = bmain_;
239 }
240
241 void TearDown() override
242 {
243 BKE_main_free(bmain_);
244 G_MAIN = nullptr;
245 }
246
247 Image *load_image(const char *path)
248 {
249 const std::string asset_dir = blender::tests::flags_test_asset_dir();
250 return BKE_image_load(bmain_, (asset_dir + SEP_STR + "imbuf_io" + SEP_STR + path).c_str());
251 }
252
254 {
255 RenderResult *render_result = get_image_render_result(image);
256 if (!render_result) {
257 ADD_FAILURE() << "Missing image RenderResult";
258 return {};
259 }
260
261 Vector<std::string> layer_names;
262 for (const RenderLayer &layer : render_result->layers) {
263 layer_names.append(layer.name);
264 }
265
266 return layer_names;
267 }
268
270 {
271 RenderResult *render_result = get_image_render_result(image);
272 if (!render_result) {
273 ADD_FAILURE() << "Missing image RenderResult";
274 return {};
275 }
276
277 for (const RenderLayer &layer : render_result->layers) {
278 if (layer.name == layer_name) {
279 Vector<std::string> pass_names;
280 for (const RenderPass &pass : layer.passes) {
281 pass_names.append(pass.name);
282 }
283 return pass_names;
284 }
285 }
286
287 return {};
288 }
289};
290
291TEST_F(ImageTest, multilayer)
292{
293 /* Multi-layer file from another DCC originally reported as #108980.
294 * The expected passes are obtained from Blender 4.2 Beta f069692caf8, with the
295 * !118867 reverted. File Scene_RenderLayer_000.exr from the report was used. */
296 {
297 Image *image = load_image("multilayer" SEP_STR "108980.exr");
298 ASSERT_NE(image, nullptr);
299
300 EXPECT_THAT(get_image_layer_names(*image), Pointwise(Eq(), {""}));
301 EXPECT_THAT(get_image_pass_names_for_layer(*image, ""),
302 Pointwise(Eq(),
303 {"Combined",
304 "Albedo",
305 "Nsx",
306 "Nsy",
307 "Nsz",
308 "Nx",
309 "Ny",
310 "Nz",
311 "Px",
312 "Py",
313 "Pz",
314 "RelativeVariance",
315 "Variance",
316 "dzdx",
317 "dzdy",
318 "u"}));
319 }
320
321 /* Multi-layer file from another DCC originally reported as #124217.
322 * The expected passes are obtained from Blender 4.2 Beta f069692caf8, with the
323 * !118867 reverted. File test.exr from the report was used. */
324 {
325 Image *image = load_image("multilayer" SEP_STR "124217.exr");
326 ASSERT_NE(image, nullptr);
327
328 EXPECT_THAT(get_image_layer_names(*image), Pointwise(Eq(), {""}));
329 EXPECT_THAT(get_image_pass_names_for_layer(*image, ""),
330 Pointwise(Eq(),
331 {"Combined",
332 "Depth",
333 "AO",
334 "ID",
335 "crypto_material",
336 "crypto_material00",
337 "crypto_material01",
338 "crypto_material02",
339 "crypto_material03",
340 "crypto_material04",
341 "crypto_material05",
342 "crypto_material06",
343 "crypto_object",
344 "crypto_object00",
345 "crypto_object01",
346 "crypto_object02",
347 "crypto_object03",
348 "crypto_object04",
349 "crypto_object05",
350 "crypto_object06",
351 "diffuse",
352 "opacity",
353 "specular",
354 "v"}));
355 }
356
357 /* Multi-part file from another DCC, originally reported as #101227.
358 * The expected passes are obtained from Blender 4.2 Beta f069692caf8, with the
359 * !118867 landed. */
360 {
361 Image *image = load_image("multilayer" SEP_STR "101227.exr");
362 ASSERT_NE(image, nullptr);
363
364 EXPECT_THAT(get_image_layer_names(*image), Pointwise(Eq(), {""}));
365 EXPECT_THAT(get_image_pass_names_for_layer(*image, ""),
366 Pointwise(Eq(), {"C", "N", "albedo", "depth"}));
367 }
368}
369
370} // namespace blender::bke::tests
#define G_MAIN
#define FILE_MAX
Read Blender memory allocation and freeing.
void append(const T &value)
Vector< std::string > get_image_pass_names_for_layer(Image &image, StringRefNull layer_name)
#define layer
#define EXPECT_FALSE(result)
#define EXPECT_NE(result, expect)
#define EXPECT_TRUE(result)
TEST_F(AnimDataTest, BKE_fcurves_id_cb_test)
char * BKE_image_get_tile_strformat(const char *filepath, eUDIM_TILE_FORMAT *r_tile_format)
char * STRNCPY(char(&dst)[N], const char *src)
Main * BKE_main_new()
Definition main.cc:93
void BKE_image_set_filepath_from_tile_number(char *filepath, const char *pattern, eUDIM_TILE_FORMAT tile_format, int tile_number)
void BKE_image_ensure_tile_token_filename_only(char *filename, size_t filename_maxncpy)
void BKE_main_free(Main *bmain)
Definition main.cc:202
EXPECT_EQ(BLI_expr_pylike_eval(expr, nullptr, 0, &result), EXPR_PYLIKE_INVALID)
ImBuf * BKE_image_acquire_ibuf(Image *ima, ImageUser *iuser, void **r_lock)
void BKE_imageuser_default(ImageUser *iuser)
eUDIM_TILE_FORMAT
Definition BKE_image.hh:505
@ UDIM_TILE_FORMAT_UVTILE
Definition BKE_image.hh:508
@ UDIM_TILE_FORMAT_NONE
Definition BKE_image.hh:506
@ UDIM_TILE_FORMAT_UDIM
Definition BKE_image.hh:507
bool BKE_image_get_tile_number_from_filepath(const char *filepath, const char *pattern, eUDIM_TILE_FORMAT tile_format, int *r_tile_number)
Image * BKE_image_load(Main *bmain, const char *filepath, bool check_open=true)
void BKE_image_release_ibuf(Image *ima, ImBuf *ibuf, void *lock)
ListBaseT< RenderLayer > layers
#define SEP_STR
Definition unit.cc:41