Debian Codegraph @

src/SPERR/test_scripts/sperr3d_omp_unit_test.cpp

raw
1 #include "SPERR3D_OMP_C.h"
2 #include "SPERR3D_OMP_D.h"
3
4 #include <cstring>
5 #include "gtest/gtest.h"
6
7 namespace {
8
9 using sperr::RTNType;
10
11 //
12 // Test constant fields.
13 //
14 TEST(sperr3d_constant, one_chunk)
15 {
16 auto input = sperr::read_whole_file<float>("../test_data/const32x20x16.float");
17 assert(!input.empty());
18 const auto dims = sperr::dims_type{32, 20, 16};
19 const auto total_len = dims[0] * dims[1] * dims[2];
20 auto inputd = sperr::vecd_type(total_len);
21 std::copy(input.cbegin(), input.cend(), inputd.begin());
22
23 // Use an encoder
24 auto encoder = sperr::SPERR3D_OMP_C();
25 encoder.set_dims_and_chunks(dims, dims);
26 encoder.set_psnr(99.0);
27 auto rtn = encoder.compress(input.data(), input.size());
28 EXPECT_EQ(rtn, RTNType::Good);
29 auto stream1 = encoder.get_encoded_bitstream();
30
31 // Use a decoder
32 auto decoder = sperr::SPERR3D_OMP_D();
33 rtn = decoder.use_bitstream(stream1.data(), stream1.size());
34 EXPECT_EQ(rtn, RTNType::Good);
35 decoder.decompress(stream1.data());
36 auto& output = decoder.view_decoded_data();
37 auto output_dims = decoder.get_dims();
38 EXPECT_EQ(inputd, output);
39 EXPECT_EQ(output_dims, dims);
40
41 // Re-use the same objects, and test specifying PWE instead of PSNR.
42 encoder.set_tolerance(1.0);
43 encoder.compress(input.data(), input.size());
44 auto stream2 = encoder.get_encoded_bitstream();
45
46 decoder.use_bitstream(stream2.data(), stream2.size());
47 decoder.decompress(stream2.data());
48 auto& output2 = decoder.view_decoded_data();
49 EXPECT_EQ(inputd, output2);
50 EXPECT_EQ(stream2, stream1);
51 }
52
53 TEST(sperr3d_constant, omp_chunks)
54 {
55 auto input = sperr::read_whole_file<float>("../test_data/const32x32x59.float");
56 const auto dims = sperr::dims_type{32, 32, 59};
57 const auto chunks = sperr::dims_type{32, 16, 32};
58 const auto total_len = dims[0] * dims[1] * dims[2];
59 auto inputd = sperr::vecd_type(total_len);
60 std::copy(input.cbegin(), input.cend(), inputd.begin());
61
62 // Use an encoder
63 auto encoder = sperr::SPERR3D_OMP_C();
64 encoder.set_dims_and_chunks(dims, chunks);
65 encoder.set_psnr(99.0);
66 encoder.set_num_threads(3);
67 encoder.compress(inputd.data(), inputd.size());
68 auto stream = encoder.get_encoded_bitstream();
69
70 // Use a decoder
71 auto decoder = sperr::SPERR3D_OMP_D();
72 decoder.set_num_threads(4);
73 decoder.use_bitstream(stream.data(), stream.size());
74 decoder.decompress(stream.data());
75 auto& output = decoder.view_decoded_data();
76 auto output_dims = decoder.get_dims();
77 EXPECT_EQ(inputd, output);
78 EXPECT_EQ(output_dims, dims);
79 }
80
81 //
82 // Test target PWE
83 //
84 TEST(sperr3d_target_pwe, small_data_range)
85 {
86 auto input = sperr::read_whole_file<float>("../test_data/vorticity.128_128_41");
87 const auto dims = sperr::dims_type{128, 128, 41};
88 const auto chunks = sperr::dims_type{64, 64, 41};
89 const auto total_len = dims[0] * dims[1] * dims[2];
90
91 // Use an encoder
92 double tol = 1.5e-7;
93 auto encoder = sperr::SPERR3D_OMP_C();
94 encoder.set_dims_and_chunks(dims, chunks);
95 encoder.set_tolerance(tol);
96 encoder.set_num_threads(4);
97 encoder.compress(input.data(), input.size());
98 auto stream = encoder.get_encoded_bitstream();
99
100 // Use a decoder
101 auto decoder = sperr::SPERR3D_OMP_D();
102 decoder.set_num_threads(4);
103 decoder.use_bitstream(stream.data(), stream.size());
104 decoder.decompress(stream.data());
105 auto output_dims = decoder.get_dims();
106 EXPECT_EQ(output_dims, dims);
107 const auto& output = decoder.view_decoded_data();
108 for (size_t i = 0; i < input.size(); i++)
109 EXPECT_NEAR(input[i], output[i], tol);
110
111 // Test a new tolerance
112 tol = 6.7e-6;
113 encoder.set_tolerance(tol);
114 encoder.compress(input.data(), input.size());
115 stream = encoder.get_encoded_bitstream();
116
117 decoder.use_bitstream(stream.data(), stream.size());
118 decoder.decompress(stream.data());
119 const auto& output2 = decoder.view_decoded_data();
120 for (size_t i = 0; i < input.size(); i++)
121 EXPECT_NEAR(input[i], output2[i], tol);
122 }
123
124 TEST(sperr3d_target_pwe, big)
125 {
126 auto input = sperr::read_whole_file<float>("../test_data/wmag128.float");
127 const auto dims = sperr::dims_type{128, 128, 128};
128 const auto chunks = sperr::dims_type{64, 70, 80};
129 const auto total_len = dims[0] * dims[1] * dims[2];
130
131 // Use an encoder
132 double tol = 1.5e-2;
133 auto encoder = sperr::SPERR3D_OMP_C();
134 encoder.set_dims_and_chunks(dims, chunks);
135 encoder.set_tolerance(tol);
136 encoder.set_num_threads(4);
137 encoder.compress(input.data(), input.size());
138 auto stream = encoder.get_encoded_bitstream();
139
140 // Use a decoder
141 auto decoder = sperr::SPERR3D_OMP_D();
142 decoder.set_num_threads(3);
143 decoder.use_bitstream(stream.data(), stream.size());
144 decoder.decompress(stream.data());
145 auto output_dims = decoder.get_dims();
146 EXPECT_EQ(output_dims, dims);
147 const auto& output = decoder.view_decoded_data();
148 for (size_t i = 0; i < input.size(); i++)
149 EXPECT_NEAR(input[i], output[i], tol);
150
151 // Test a new tolerance
152 tol = 6.7e-1;
153 encoder.set_tolerance(tol);
154 encoder.compress(input.data(), input.size());
155 stream = encoder.get_encoded_bitstream();
156
157 decoder.use_bitstream(stream.data(), stream.size());
158 decoder.decompress(stream.data());
159 const auto& output2 = decoder.view_decoded_data();
160 for (size_t i = 0; i < input.size(); i++)
161 EXPECT_NEAR(input[i], output2[i], tol);
162 }
163
164 //
165 // Test target PSNR
166 //
167 TEST(sperr3d_target_psnr, big)
168 {
169 auto input = sperr::read_whole_file<float>("../test_data/wmag128.float");
170 const auto dims = sperr::dims_type{128, 128, 128};
171 const auto chunks = sperr::dims_type{64, 70, 80};
172 const auto total_len = dims[0] * dims[1] * dims[2];
173 auto inputd = sperr::vecd_type(total_len);
174 std::copy(input.begin(), input.end(), inputd.begin());
175
176 // Use an encoder
177 double psnr = 88.0;
178 auto encoder = sperr::SPERR3D_OMP_C();
179 encoder.set_dims_and_chunks(dims, chunks);
180 encoder.set_psnr(psnr);
181 encoder.set_num_threads(4);
182 encoder.compress(inputd.data(), inputd.size());
183 auto stream = encoder.get_encoded_bitstream();
184
185 // Use a decoder
186 auto decoder = sperr::SPERR3D_OMP_D();
187 decoder.set_num_threads(3);
188 decoder.use_bitstream(stream.data(), stream.size());
189 decoder.decompress(stream.data());
190 auto output_dims = decoder.get_dims();
191 EXPECT_EQ(output_dims, dims);
192 const auto& output = decoder.view_decoded_data();
193 auto stats = sperr::calc_stats(inputd.data(), output.data(), total_len, 4);
194 EXPECT_GT(stats[2], 92.9321);
195 EXPECT_LT(stats[2], 92.9322);
196
197 // Test a new psnr
198 psnr = 130.0;
199 encoder.set_psnr(psnr);
200 encoder.compress(input.data(), input.size());
201 stream = encoder.get_encoded_bitstream();
202
203 decoder.use_bitstream(stream.data(), stream.size());
204 decoder.decompress(stream.data());
205 const auto& output2 = decoder.view_decoded_data();
206 stats = sperr::calc_stats(inputd.data(), output2.data(), total_len, 4);
207 EXPECT_GT(stats[2], 134.6098);
208 EXPECT_LT(stats[2], 134.6099);
209 }
210
211 TEST(sperr3d_target_psnr, small_data_range)
212 {
213 auto input = sperr::read_whole_file<float>("../test_data/vorticity.128_128_41");
214 const auto dims = sperr::dims_type{128, 128, 41};
215 const auto chunks = sperr::dims_type{64, 64, 64};
216 const auto total_len = dims[0] * dims[1] * dims[2];
217 auto inputd = sperr::vecd_type(total_len);
218 std::copy(input.begin(), input.end(), inputd.begin());
219
220 // Use an encoder
221 double psnr = 88.0;
222 auto encoder = sperr::SPERR3D_OMP_C();
223 encoder.set_dims_and_chunks(dims, chunks);
224 encoder.set_psnr(psnr);
225 encoder.set_num_threads(3);
226 encoder.compress(inputd.data(), inputd.size());
227 auto stream = encoder.get_encoded_bitstream();
228
229 // Use a decoder
230 auto decoder = sperr::SPERR3D_OMP_D();
231 decoder.set_num_threads(0);
232 decoder.use_bitstream(stream.data(), stream.size());
233 decoder.decompress(stream.data());
234 auto output_dims = decoder.get_dims();
235 EXPECT_EQ(output_dims, dims);
236 const auto& output = decoder.view_decoded_data();
237 auto stats = sperr::calc_stats(inputd.data(), output.data(), total_len, 4);
238 EXPECT_GT(stats[2], 89.1123);
239 EXPECT_LT(stats[2], 89.1124);
240
241 // Test a new psnr
242 psnr = 125.0;
243 encoder.set_psnr(psnr);
244 encoder.compress(input.data(), input.size());
245 stream = encoder.get_encoded_bitstream();
246
247 decoder.use_bitstream(stream.data(), stream.size());
248 decoder.decompress(stream.data());
249 const auto& output2 = decoder.view_decoded_data();
250 stats = sperr::calc_stats(inputd.data(), output2.data(), total_len, 4);
251 EXPECT_GT(stats[2], 126.8866);
252 EXPECT_LT(stats[2], 126.8867);
253 }
254
255 //
256 // Test fixed-size mode
257 //
258 TEST(sperr3d_bit_rate, big)
259 {
260 auto input = sperr::read_whole_file<float>("../test_data/wmag128.float");
261 const auto dims = sperr::dims_type{128, 128, 128};
262 const auto chunks = sperr::dims_type{64, 64, 64};
263 const auto total_len = dims[0] * dims[1] * dims[2];
264 auto inputd = sperr::vecd_type(total_len);
265 std::copy(input.begin(), input.end(), inputd.begin());
266
267 // Use an encoder
268 double bpp = 2.0;
269 auto encoder = sperr::SPERR3D_OMP_C();
270 encoder.set_dims_and_chunks(dims, chunks);
271 encoder.set_bitrate(bpp);
272 encoder.set_num_threads(4);
273 encoder.compress(inputd.data(), inputd.size());
274 auto stream = encoder.get_encoded_bitstream();
275
276 // Use a decoder
277 auto decoder = sperr::SPERR3D_OMP_D();
278 decoder.set_num_threads(0);
279 decoder.use_bitstream(stream.data(), stream.size());
280 decoder.decompress(stream.data());
281 auto output_dims = decoder.get_dims();
282 EXPECT_EQ(output_dims, dims);
283 const auto& output = decoder.view_decoded_data();
284 auto stats = sperr::calc_stats(inputd.data(), output.data(), total_len, 4);
285 EXPECT_LT(stats[1], 9.6434);
286 EXPECT_GT(stats[2], 53.73996);
287 EXPECT_LT(stats[2], 53.73997);
288
289 // Test a new bitrate
290 bpp = 1.0;
291 encoder.set_bitrate(bpp);
292 encoder.compress(input.data(), input.size());
293 stream = encoder.get_encoded_bitstream();
294 decoder.use_bitstream(stream.data(), stream.size());
295 decoder.decompress(stream.data());
296 const auto& output2 = decoder.view_decoded_data();
297 stats = sperr::calc_stats(inputd.data(), output2.data(), total_len, 4);
298 EXPECT_LT(stats[1], 22.3381);
299 EXPECT_GT(stats[2], 47.1664);
300 EXPECT_LT(stats[2], 47.1665);
301 }
302
303 //
304 // Test multi-resolution
305 //
306 TEST(sperr3d_multi_res, canonical)
307 {
308 auto input = sperr::read_whole_file<float>("../test_data/wmag128.float");
309 const auto dims = sperr::dims_type{128, 128, 128};
310 const auto chunks = sperr::dims_type{64, 64, 64};
311 const auto total_len = dims[0] * dims[1] * dims[2];
312 auto inputd = sperr::vecd_type(total_len);
313 std::copy(input.begin(), input.end(), inputd.begin());
314
315 // Use an encoder
316 double bpp = 2.0;
317 auto encoder = sperr::SPERR3D_OMP_C();
318 encoder.set_dims_and_chunks(dims, chunks);
319 encoder.set_bitrate(bpp);
320 encoder.set_num_threads(4);
321 encoder.compress(inputd.data(), inputd.size());
322 auto stream = encoder.get_encoded_bitstream();
323
324 // Use a decoder, test the native resolution results.
325 auto decoder = sperr::SPERR3D_OMP_D();
326 decoder.set_num_threads(0);
327 decoder.use_bitstream(stream.data(), stream.size());
328 decoder.decompress(stream.data(), true);
329 auto output_dims = decoder.get_dims();
330 EXPECT_EQ(output_dims, dims);
331 const auto& output = decoder.view_decoded_data();
332 auto stats = sperr::calc_stats(inputd.data(), output.data(), total_len, 4);
333 EXPECT_LT(stats[1], 9.6434);
334 EXPECT_GT(stats[2], 53.73996);
335 EXPECT_LT(stats[2], 53.73997);
336
337 // Also test the lower-resolution reconstructions.
338 auto hierarchy = decoder.release_hierarchy();
339 auto resolutions = sperr::coarsened_resolutions(dims, chunks);
340 EXPECT_EQ(hierarchy.size(), resolutions.size());
341 for (size_t i = 0; i < hierarchy.size(); i++) {
342 auto res = resolutions[i];
343 EXPECT_EQ(hierarchy[i].size(), res[0] * res[1] * res[2]);
344 }
345 }
346
347 } // anonymous namespace