Debian Codegraph @

src/SPERR/test_scripts/speck2d_flt_unit_test.cpp

raw
1 #include "SPECK2D_FLT.h"
2
3 #include "gtest/gtest.h"
4
5 #include <algorithm>
6 #include <cstdio>
7 #include <iostream>
8
9 namespace {
10
11 //
12 // Test a constant data field
13 //
14 TEST(SPECK2D_FLT, ConstantField)
15 {
16 const auto dims = sperr::dims_type{12, 13, 1};
17 const auto total_vals = dims[0] * dims[1] * dims[2];
18 auto input = std::vector<double>(total_vals, 4.332);
19 auto tmp = input;
20
21 auto encoder = sperr::SPECK2D_FLT();
22 encoder.set_dims(dims);
23 encoder.set_tolerance(1.2e-2);
24 encoder.take_data(std::move(tmp));
25 auto rtn = encoder.compress();
26 ASSERT_EQ(rtn, sperr::RTNType::Good);
27 auto bitstream = sperr::vec8_type();
28 encoder.append_encoded_bitstream(bitstream);
29 EXPECT_EQ(bitstream.size(), 17); // Constant storage to record a constant field.
30
31 auto decoder = sperr::SPECK2D_FLT();
32 decoder.set_dims(dims);
33 rtn = decoder.use_bitstream(bitstream.data(), bitstream.size());
34 ASSERT_EQ(rtn, sperr::RTNType::Good);
35 rtn = decoder.decompress();
36 ASSERT_EQ(rtn, sperr::RTNType::Good);
37 auto output = decoder.release_decoded_data();
38 EXPECT_EQ(input, output);
39
40 // Test specifying PSNR
41 encoder.set_dims(dims);
42 encoder.set_psnr(89.0);
43 tmp = input;
44 encoder.take_data(std::move(tmp));
45 rtn = encoder.compress();
46 ASSERT_EQ(rtn, sperr::RTNType::Good);
47 bitstream.clear();
48 encoder.append_encoded_bitstream(bitstream);
49 EXPECT_EQ(bitstream.size(), 17); // Constant storage to record a constant field.
50
51 decoder.set_dims(dims);
52 rtn = decoder.use_bitstream(bitstream.data(), bitstream.size());
53 ASSERT_EQ(rtn, sperr::RTNType::Good);
54 rtn = decoder.decompress();
55 ASSERT_EQ(rtn, sperr::RTNType::Good);
56 output = decoder.release_decoded_data();
57 EXPECT_EQ(input, output);
58 }
59
60 //
61 // Test integer length using a minimal data set
62 //
63 TEST(SPECK2D_FLT, IntegerLen)
64 {
65 auto inputf = sperr::read_whole_file<float>("../test_data/90x90.float");
66 const auto dims = sperr::dims_type{90, 90, 1};
67 const auto total_vals = inputf.size();
68 auto inputd = sperr::vecd_type(total_vals);
69 std::copy(inputf.cbegin(), inputf.cend(), inputd.begin());
70 double psnr = 40.0;
71
72 // Encode
73 auto encoder = sperr::SPECK2D_FLT();
74 encoder.set_dims(dims);
75 encoder.set_psnr(psnr);
76 encoder.copy_data(inputd.data(), total_vals);
77 auto rtn = encoder.compress();
78 ASSERT_EQ(rtn, sperr::RTNType::Good);
79 auto bitstream = sperr::vec8_type();
80 encoder.append_encoded_bitstream(bitstream);
81
82 // Decode
83 auto decoder = sperr::SPECK2D_FLT();
84 decoder.set_dims(dims);
85 rtn = decoder.use_bitstream(bitstream.data(), bitstream.size());
86 ASSERT_EQ(rtn, sperr::RTNType::Good);
87 rtn = decoder.decompress();
88 ASSERT_EQ(rtn, sperr::RTNType::Good);
89 auto outputd = decoder.release_decoded_data();
90 #ifdef PRINT
91 auto stats = sperr::calc_stats(inputd.data(), outputd.data(), total_vals);
92 std::printf("bpp = %.2f, PSNR = %.2f\n", 8.0 * bitstream.size() / total_vals, stats[2]);
93 #endif
94 EXPECT_EQ(encoder.integer_len(), 1);
95 EXPECT_EQ(decoder.integer_len(), 1);
96
97 // Test a new PSNR target.
98 psnr = 50.0;
99 encoder.set_psnr(psnr);
100 encoder.copy_data(inputd.data(), total_vals);
101 encoder.compress();
102 bitstream.clear();
103 encoder.append_encoded_bitstream(bitstream);
104 decoder.use_bitstream(bitstream.data(), bitstream.size());
105 decoder.decompress();
106 outputd = decoder.release_decoded_data();
107 #ifdef PRINT
108 stats = sperr::calc_stats(inputd.data(), outputd.data(), total_vals);
109 std::printf("bpp = %.2f, PSNR = %.2f\n", 8.0 * bitstream.size() / total_vals, stats[2]);
110 #endif
111 EXPECT_EQ(encoder.integer_len(), 2);
112 EXPECT_EQ(decoder.integer_len(), 2);
113
114 // Test a new PSNR target.
115 psnr = 100.0;
116 encoder.set_psnr(psnr);
117 encoder.copy_data(inputd.data(), total_vals);
118 encoder.compress();
119 bitstream.clear();
120 encoder.append_encoded_bitstream(bitstream);
121 decoder.use_bitstream(bitstream.data(), bitstream.size());
122 decoder.decompress();
123 outputd = decoder.release_decoded_data();
124 #ifdef PRINT
125 stats = sperr::calc_stats(inputd.data(), outputd.data(), total_vals);
126 std::printf("bpp = %.2f, PSNR = %.2f\n", 8.0 * bitstream.size() / total_vals, stats[2]);
127 #endif
128 EXPECT_EQ(encoder.integer_len(), 4);
129 EXPECT_EQ(decoder.integer_len(), 4);
130
131 // Test a new PSNR target.
132 psnr = 190.0;
133 encoder.set_psnr(psnr);
134 encoder.copy_data(inputd.data(), total_vals);
135 encoder.compress();
136 bitstream.clear();
137 encoder.append_encoded_bitstream(bitstream);
138 decoder.use_bitstream(bitstream.data(), bitstream.size());
139 decoder.decompress();
140 outputd = decoder.release_decoded_data();
141 #ifdef PRINT
142 stats = sperr::calc_stats(inputd.data(), outputd.data(), total_vals);
143 std::printf("bpp = %.2f, PSNR = %.2f\n", 8.0 * bitstream.size() / total_vals, stats[2]);
144 #endif
145 EXPECT_EQ(encoder.integer_len(), 8);
146 EXPECT_EQ(decoder.integer_len(), 8);
147 }
148
149 //
150 // Test target PWE
151 //
152 TEST(SPECK2D_FLT, OutlierCorrection)
153 {
154 auto inputf = sperr::read_whole_file<float>("../test_data/vorticity.512_512");
155 const auto dims = sperr::dims_type{512, 512, 1};
156 const auto total_vals = inputf.size();
157 auto inputd = sperr::vecd_type(total_vals);
158 std::copy(inputf.cbegin(), inputf.cend(), inputd.begin());
159 double tol = 1.0e-5;
160
161 // Encode
162 auto encoder = sperr::SPECK2D_FLT();
163 encoder.set_dims(dims);
164 encoder.set_tolerance(tol);
165 encoder.copy_data(inputd.data(), total_vals);
166 auto rtn = encoder.compress();
167 ASSERT_EQ(rtn, sperr::RTNType::Good);
168 auto bitstream = sperr::vec8_type();
169 encoder.append_encoded_bitstream(bitstream);
170
171 // Decode
172 auto decoder = sperr::SPECK2D_FLT();
173 decoder.set_dims(dims);
174 decoder.set_tolerance(tol);
175 rtn = decoder.use_bitstream(bitstream.data(), bitstream.size());
176 ASSERT_EQ(rtn, sperr::RTNType::Good);
177 rtn = decoder.decompress();
178 ASSERT_EQ(rtn, sperr::RTNType::Good);
179 auto outputd = decoder.release_decoded_data();
180 #ifdef PRINT
181 auto stats = sperr::calc_stats(inputd.data(), outputd.data(), total_vals);
182 std::printf("bpp = %.2f, PSNR = %.2f\n", 8.0 * bitstream.size() / total_vals, stats[2]);
183 #endif
184 for (size_t i = 0; i < inputd.size(); i++)
185 EXPECT_NEAR(inputd[i], outputd[i], tol);
186
187 //
188 // Test a smaller-than-32-bit-epsilon tolerance
189 //
190 tol = 2.9e-9;
191 encoder.set_tolerance(tol);
192 encoder.copy_data(inputd.data(), total_vals);
193 rtn = encoder.compress();
194 ASSERT_EQ(rtn, sperr::RTNType::Good);
195 bitstream.clear();
196 encoder.append_encoded_bitstream(bitstream);
197
198 decoder.set_tolerance(tol);
199 rtn = decoder.use_bitstream(bitstream.data(), bitstream.size());
200 ASSERT_EQ(rtn, sperr::RTNType::Good);
201 rtn = decoder.decompress();
202 ASSERT_EQ(rtn, sperr::RTNType::Good);
203 outputd = decoder.release_decoded_data();
204 #ifdef PRINT
205 stats = sperr::calc_stats(inputd.data(), outputd.data(), total_vals);
206 std::printf("bpp = %.2f, PSNR = %.2f\n", 8.0 * bitstream.size() / total_vals, stats[2]);
207 #endif
208 for (size_t i = 0; i < inputd.size(); i++)
209 EXPECT_NEAR(inputd[i], outputd[i], tol);
210
211 //
212 // Test a big tolerance which essentially produces all zero integer arrays.
213 // The compression should still carry on, and tolerance being honored.
214 //
215 tol = 1e-2;
216 encoder.set_tolerance(tol);
217 encoder.copy_data(inputd.data(), total_vals);
218 rtn = encoder.compress();
219 ASSERT_EQ(rtn, sperr::RTNType::Good);
220 bitstream.clear();
221 encoder.append_encoded_bitstream(bitstream);
222
223 decoder.set_tolerance(tol);
224 rtn = decoder.use_bitstream(bitstream.data(), bitstream.size());
225 ASSERT_EQ(rtn, sperr::RTNType::Good);
226 rtn = decoder.decompress();
227 ASSERT_EQ(rtn, sperr::RTNType::Good);
228 outputd = decoder.release_decoded_data();
229 #ifdef PRINT
230 stats = sperr::calc_stats(inputd.data(), outputd.data(), total_vals);
231 std::printf("bpp = %.2f, PSNR = %.2f\n", 8.0 * bitstream.size() / total_vals, stats[2]);
232 std::printf(" -- bitstream size = %lu bytes\n", bitstream.size());
233 #endif
234 for (size_t i = 0; i < inputd.size(); i++)
235 EXPECT_NEAR(inputd[i], outputd[i], tol);
236 }
237
238 //
239 // Test target PSNR
240 //
241 TEST(SPECK2D_FLT, TargetPSNR)
242 {
243 auto inputf = sperr::read_whole_file<float>("../test_data/lena512.float");
244 const auto dims = sperr::dims_type{512, 512, 1};
245 const auto total_vals = inputf.size();
246 auto inputd = sperr::vecd_type(total_vals);
247 std::copy(inputf.cbegin(), inputf.cend(), inputd.begin());
248
249 // Encode
250 auto psnr = 40.0;
251 auto encoder = sperr::SPECK2D_FLT();
252 encoder.set_dims(dims);
253 encoder.set_psnr(psnr);
254 encoder.copy_data(inputd.data(), total_vals);
255 auto rtn = encoder.compress();
256 ASSERT_EQ(rtn, sperr::RTNType::Good);
257 auto bitstream = sperr::vec8_type();
258 encoder.append_encoded_bitstream(bitstream);
259
260 // Decode
261 auto decoder = sperr::SPECK2D_FLT();
262 decoder.set_dims(dims);
263 rtn = decoder.use_bitstream(bitstream.data(), bitstream.size());
264 ASSERT_EQ(rtn, sperr::RTNType::Good);
265 rtn = decoder.decompress();
266 ASSERT_EQ(rtn, sperr::RTNType::Good);
267 auto outputd = decoder.release_decoded_data();
268 auto stats = sperr::calc_stats(inputd.data(), outputd.data(), total_vals);
269 #ifdef PRINT
270 std::printf("bpp = %.2f, PSNR = %.2f\n", 8.0 * bitstream.size() / total_vals, stats[2]);
271 #endif
272 EXPECT_GT(stats[2], psnr);
273
274 // Test a higher PSNR
275 //
276 psnr = 100.0;
277 encoder.set_dims(dims);
278 encoder.set_psnr(psnr);
279 encoder.copy_data(inputd.data(), total_vals);
280 rtn = encoder.compress();
281 ASSERT_EQ(rtn, sperr::RTNType::Good);
282 bitstream.clear();
283 encoder.append_encoded_bitstream(bitstream);
284
285 decoder.set_dims(dims);
286 rtn = decoder.use_bitstream(bitstream.data(), bitstream.size());
287 ASSERT_EQ(rtn, sperr::RTNType::Good);
288 rtn = decoder.decompress();
289 ASSERT_EQ(rtn, sperr::RTNType::Good);
290 outputd = decoder.release_decoded_data();
291 stats = sperr::calc_stats(inputd.data(), outputd.data(), total_vals);
292 #ifdef PRINT
293 std::printf("bpp = %.2f, PSNR = %.2f\n", 8.0 * bitstream.size() / total_vals, stats[2]);
294 #endif
295 EXPECT_GT(stats[2], psnr - 0.16); // An example of not exactly reaching the target PSNR.
296
297 // Test a higher PSNR
298 //
299 psnr = 130.0;
300 encoder.set_dims(dims);
301 encoder.set_psnr(psnr);
302 encoder.copy_data(inputd.data(), total_vals);
303 rtn = encoder.compress();
304 ASSERT_EQ(rtn, sperr::RTNType::Good);
305 bitstream.clear();
306 encoder.append_encoded_bitstream(bitstream);
307
308 decoder.set_dims(dims);
309 rtn = decoder.use_bitstream(bitstream.data(), bitstream.size());
310 ASSERT_EQ(rtn, sperr::RTNType::Good);
311 rtn = decoder.decompress();
312 ASSERT_EQ(rtn, sperr::RTNType::Good);
313 outputd = decoder.release_decoded_data();
314 stats = sperr::calc_stats(inputd.data(), outputd.data(), total_vals);
315 #ifdef PRINT
316 std::printf("bpp = %.2f, PSNR = %.2f\n", 8.0 * bitstream.size() / total_vals, stats[2]);
317 #endif
318 EXPECT_GT(stats[2], psnr - 0.16); // Another example of not exactly reaching the target PSNR.
319 }
320
321 TEST(SPECK2D_FLT, TargetBPP)
322 {
323 auto inputf = sperr::read_whole_file<float>("../test_data/vorticity.512_512");
324 ASSERT_EQ(inputf.size(), 512 * 512);
325 const auto dims = sperr::dims_type{512, 512, 1};
326 const auto total_vals = inputf.size();
327 auto inputd = sperr::vecd_type(total_vals);
328 std::copy(inputf.cbegin(), inputf.cend(), inputd.begin());
329
330 // Encode
331 auto bpp = 4.0;
332 auto encoder = sperr::SPECK2D_FLT();
333 encoder.set_dims(dims);
334 encoder.set_bitrate(bpp);
335 encoder.copy_data(inputd.data(), total_vals);
336 auto rtn = encoder.compress();
337 ASSERT_EQ(rtn, sperr::RTNType::Good);
338 auto bitstream = sperr::vec8_type();
339 encoder.append_encoded_bitstream(bitstream);
340
341 // Decode
342 auto decoder = sperr::SPECK2D_FLT();
343 decoder.set_dims(dims);
344 rtn = decoder.use_bitstream(bitstream.data(), bitstream.size());
345 ASSERT_EQ(rtn, sperr::RTNType::Good);
346 rtn = decoder.decompress();
347 ASSERT_EQ(rtn, sperr::RTNType::Good);
348 auto outputd = decoder.release_decoded_data();
349 auto stats = sperr::calc_stats(inputd.data(), outputd.data(), total_vals);
350 #ifdef PRINT
351 std::printf("bpp = %.2f, PSNR = %.4f, PWE = %.4e\n", 8.0 * bitstream.size() / total_vals,
352 stats[2], stats[1]);
353 #endif
354 EXPECT_GT(stats[2], 71.43);
355 EXPECT_LT(stats[1], 2.048e-06);
356
357 // Test a another bitrate
358 //
359 bpp = 2.0;
360 encoder.set_bitrate(bpp);
361 encoder.copy_data(inputd.data(), total_vals);
362 rtn = encoder.compress();
363 ASSERT_EQ(rtn, sperr::RTNType::Good);
364 bitstream.clear();
365 encoder.append_encoded_bitstream(bitstream);
366
367 // Decode
368 rtn = decoder.use_bitstream(bitstream.data(), bitstream.size());
369 ASSERT_EQ(rtn, sperr::RTNType::Good);
370 rtn = decoder.decompress();
371 ASSERT_EQ(rtn, sperr::RTNType::Good);
372 outputd = decoder.release_decoded_data();
373 stats = sperr::calc_stats(inputd.data(), outputd.data(), total_vals);
374 #ifdef PRINT
375 std::printf("bpp = %.2f, PSNR = %.4f, PWE = %.4e\n", 8.0 * bitstream.size() / total_vals,
376 stats[2], stats[1]);
377 #endif
378 EXPECT_GT(stats[2], 59.6859);
379 EXPECT_LT(stats[1], 8.173e-06);
380 }
381
382 } // namespace