Debian Codegraph @

src/SPERR/test_scripts/stream_tools_unit_test.cpp

raw
1 #include "SPERR3D_OMP_C.h"
2 #include "SPERR3D_Stream_Tools.h"
3
4 #include "gtest/gtest.h"
5
6 namespace {
7
8 using sperr::RTNType;
9
10 // Test constant field
11 TEST(stream_tools, constant_1chunk)
12 {
13 // Produce a bitstream to disk
14 auto input = sperr::read_whole_file<float>("../test_data/const32x20x16.float");
15 assert(!input.empty());
16 auto encoder = sperr::SPERR3D_OMP_C();
17 encoder.set_dims_and_chunks({32, 20, 16}, {32, 20, 16});
18 encoder.set_psnr(99.0);
19 encoder.compress(input.data(), input.size());
20 auto stream = encoder.get_encoded_bitstream();
21 auto filename = std::string("./test.tmp");
22 sperr::write_n_bytes(filename, stream.size(), stream.data());
23
24 // Test progressive read!
25 auto tools = sperr::SPERR3D_Stream_Tools();
26 auto part = tools.progressive_read(filename, 100);
27
28 // The returned bitstream should remain the same.
29 EXPECT_EQ(part, stream);
30
31 // If truncate from memory, the result should remain the same.
32 auto trunc = tools.progressive_truncate(stream.data(), stream.size(), 100);
33 EXPECT_EQ(trunc, stream);
34 }
35
36 TEST(stream_tools, constant_nchunks)
37 {
38 // Produce a bitstream to disk
39 auto input = sperr::read_whole_file<float>("../test_data/const32x20x16.float");
40 assert(!input.empty());
41 auto encoder = sperr::SPERR3D_OMP_C();
42 encoder.set_dims_and_chunks({32, 20, 16}, {10, 10, 8});
43 encoder.set_psnr(99.0);
44 encoder.compress(input.data(), input.size());
45 auto stream = encoder.get_encoded_bitstream();
46 auto filename = std::string("./test.tmp");
47 sperr::write_n_bytes(filename, stream.size(), stream.data());
48
49 // Test progressive read!
50 auto tools = sperr::SPERR3D_Stream_Tools();
51 auto part = tools.progressive_read(filename, 50);
52
53 // The returned bitstream should still remain the same, except than one bit, because
54 // each chunk is so small that it's still kept in whole.
55 EXPECT_EQ(part.size(), stream.size());
56 EXPECT_EQ(part[0], stream[0]);
57 EXPECT_EQ(part[1], stream[1] + 128);
58 for (size_t i = 2; i < part.size(); i++)
59 EXPECT_EQ(part[i], stream[i]);
60
61 // If truncate from memory, the result should remain the same.
62 auto trunc = tools.progressive_truncate(stream.data(), stream.size(), 50);
63 EXPECT_EQ(trunc, part);
64 }
65
66 //
67 // Test a non-constant field.
68 //
69 TEST(stream_tools, regular_1chunk)
70 {
71 // Produce a bitstream to disk
72 auto filename = std::string("./test.tmp");
73 auto input = sperr::read_whole_file<float>("../test_data/vorticity.128_128_41");
74 assert(!input.empty());
75 auto encoder = sperr::SPERR3D_OMP_C();
76 encoder.set_dims_and_chunks({128, 128, 41}, {128, 128, 41});
77 encoder.set_psnr(100.0); // Resulting about 9.2bpp.
78 encoder.compress(input.data(), input.size());
79 auto stream = encoder.get_encoded_bitstream();
80 sperr::write_n_bytes(filename, stream.size(), stream.data());
81
82 // Test progressive read!
83 auto tools = sperr::SPERR3D_Stream_Tools();
84 auto header = tools.get_stream_header(stream.data());
85 auto part = tools.progressive_read(filename, 50);
86
87 // Header should (mostly) remain the same.
88 EXPECT_EQ(part[0], stream[0]);
89 EXPECT_EQ(part[1], stream[1] + 128);
90 for (size_t i = 2; i < header.header_len - 4; i++) // Exclude the last 4 bytes (chunk len).
91 EXPECT_EQ(part[i], stream[i]);
92
93 // The remaining bytes of each chunk should also remain the same.
94 auto header2 = tools.get_stream_header(part.data());
95 EXPECT_EQ(header.chunk_offsets.size(), header2.chunk_offsets.size());
96
97 for (size_t i = 0; i < header.chunk_offsets.size() / 2; i++) {
98 auto orig_start = header.chunk_offsets[i * 2];
99 auto part_start = header2.chunk_offsets[i * 2];
100 for (size_t j = 0; j < header2.chunk_offsets[i * 2 + 1]; j++)
101 EXPECT_EQ(stream[orig_start + j], part[part_start + j]);
102 }
103
104 // If truncate from memory, the result should remain the same.
105 auto trunc = tools.progressive_truncate(stream.data(), stream.size(), 50);
106 EXPECT_EQ(trunc, part);
107 }
108
109 TEST(stream_tools, regular_nchunks)
110 {
111 // Produce a bitstream to disk
112 auto filename = std::string("./test.tmp");
113 auto input = sperr::read_whole_file<float>("../test_data/vorticity.128_128_41");
114 assert(!input.empty());
115 auto encoder = sperr::SPERR3D_OMP_C();
116 encoder.set_dims_and_chunks({128, 128, 41}, {31, 40, 21});
117 encoder.set_psnr(100.0); // Resulting about 10bpp.
118 encoder.compress(input.data(), input.size());
119 auto stream = encoder.get_encoded_bitstream();
120 sperr::write_n_bytes(filename, stream.size(), stream.data());
121
122 // Test progressive read!
123 auto tools = sperr::SPERR3D_Stream_Tools();
124 auto header = tools.get_stream_header(stream.data());
125 auto part = tools.progressive_read(filename, 35);
126
127 // Header should (mostly) remain the same.
128 EXPECT_EQ(part[0], stream[0]);
129 EXPECT_EQ(part[1], stream[1] + 128);
130
131 // The remaining bytes should also remain the same.
132 auto header2 = tools.get_stream_header(part.data());
133 EXPECT_EQ(header.chunk_offsets.size(), header2.chunk_offsets.size());
134
135 for (size_t i = 0; i < header.chunk_offsets.size() / 2; i++) {
136 auto orig_start = header.chunk_offsets[i * 2];
137 auto part_start = header2.chunk_offsets[i * 2];
138 for (size_t j = 0; j < header2.chunk_offsets[i * 2 + 1]; j++)
139 EXPECT_EQ(stream[orig_start + j], part[part_start + j]);
140 }
141
142 // If truncate from memory, the result should remain the same.
143 auto trunc = tools.progressive_truncate(stream.data(), stream.size(), 35);
144 EXPECT_EQ(trunc, part);
145 }
146
147 TEST(stream_tools, min_chunk_len)
148 {
149 // Produce a bitstream to disk
150 auto filename = std::string("./test.tmp");
151 auto input = sperr::read_whole_file<float>("../test_data/wmag17.float");
152 assert(!input.empty());
153 auto encoder = sperr::SPERR3D_OMP_C();
154 encoder.set_dims_and_chunks({17, 17, 17}, {8, 8, 8});
155 encoder.set_psnr(100.0);
156 encoder.compress(input.data(), input.size());
157 auto stream = encoder.get_encoded_bitstream();
158 sperr::write_n_bytes(filename, stream.size(), stream.data());
159
160 // Test progressive read! The requested 1% of bytes results in every chunk to have ~10 bytes,
161 // which would be changed to 64 bytes eventually, and not resulting in failed assertions.
162 auto tools = sperr::SPERR3D_Stream_Tools();
163 auto header = tools.get_stream_header(stream.data());
164 auto part = tools.progressive_read(filename, 1);
165
166 // Header should (mostly) remain the same.
167 EXPECT_EQ(part[0], stream[0]);
168 EXPECT_EQ(part[1], stream[1] + 128);
169
170 // The header of each chunk (first 64 bytes) should also remain the same.
171 auto header2 = tools.get_stream_header(part.data());
172 EXPECT_EQ(header.chunk_offsets.size(), header2.chunk_offsets.size());
173
174 for (size_t i = 0; i < header.chunk_offsets.size() / 2; i++) {
175 auto orig_start = header.chunk_offsets[i * 2];
176 auto part_start = header2.chunk_offsets[i * 2];
177 for (size_t j = 0; j < header2.chunk_offsets[i * 2 + 1]; j++)
178 EXPECT_EQ(stream[orig_start + j], part[part_start + j]);
179 }
180
181 // If truncate from memory, the result should remain the same.
182 auto trunc = tools.progressive_truncate(stream.data(), stream.size(), 1);
183 EXPECT_EQ(trunc, part);
184 }
185
186 } // anonymous namespace