Debian Codegraph @

src/SPERR/test_scripts/speck3d_flt_unit_test.cpp

raw
1 #include "SPECK3D_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(SPECK3D_FLT, ConstantField)
15 {
16 const auto dims = sperr::dims_type{12, 13, 15};
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::SPECK3D_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::SPECK3D_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 a minimal data set
62 //
63 TEST(SPECK3D_FLT, IntegerLen)
64 {
65 auto inputf = sperr::read_whole_file<float>("../test_data/wmag17.float");
66 const auto dims = sperr::dims_type{17, 17, 17};
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::SPECK3D_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::SPECK3D_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 = 190.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 = 210.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 outlier correction
151 //
152 TEST(SPECK3D_FLT, OutlierCorrection)
153 {
154 auto inputf = sperr::read_whole_file<float>("../test_data/vorticity.128_128_41");
155 const auto dims = sperr::dims_type{128, 128, 41};
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::SPECK3D_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::SPECK3D_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 } // namespace