diff --git a/czi-format/16Bit-ZStack_c_1.jpg b/czi-format/benchmark_results/16Bit-ZStack_c_1.jpg
similarity index 100%
rename from czi-format/16Bit-ZStack_c_1.jpg
rename to czi-format/benchmark_results/16Bit-ZStack_c_1.jpg
diff --git a/czi-format/16Bit-ZStack_c_2.jpg b/czi-format/benchmark_results/16Bit-ZStack_c_2.jpg
similarity index 100%
rename from czi-format/16Bit-ZStack_c_2.jpg
rename to czi-format/benchmark_results/16Bit-ZStack_c_2.jpg
diff --git a/czi-format/benchmark_results/16bit_z_stack_continuous_sorted.csv b/czi-format/benchmark_results/16bit_z_stack_continuous_sorted.csv
new file mode 100644
index 0000000000000000000000000000000000000000..b21681d707a5730baff298f03ac8c1831dc6e996
--- /dev/null
+++ b/czi-format/benchmark_results/16bit_z_stack_continuous_sorted.csv
@@ -0,0 +1,4 @@
+filename;subblock;pixel;width;height;compression;level;originalSize;compressedSize;compressedZ;compressionRatio;compressionRatioZ;compressionTime;compressionTimeZ
+16Bit-ZStack.czi;999;Gray16;0;0;GZIP;8;31457280;21313063;21067526;1.47596;1.49316;2014.00000;1985.00000
+16Bit-ZStack.czi;999;Gray16;0;0;LZMA2;8;31457280;17217716;17057428;1.82703;1.84420;15858.00000;21924.00000
+16Bit-ZStack.czi;999;Gray16;0;0;BZIP2;8;31457280;16466766;16661084;1.91035;1.88807;2958.00000;3136.00000
diff --git a/czi-format/czi-parser/compression/benchmark.h b/czi-format/czi-parser/compression/benchmark.h
index c40bd5cb80af825e72a2ed700197851119f6a047..93c90e56165d6d82694643ebe9736fe92abc9670 100644
--- a/czi-format/czi-parser/compression/benchmark.h
+++ b/czi-format/czi-parser/compression/benchmark.h
@@ -69,131 +69,99 @@ void write_report(const std::vector<BenchmarkRecord> &results, const std::string
}
}
+static std::vector<BenchmarkRecord> benchmark_continuos_compression_one_level(const ByteArray &data, const ByteArray &zOrderedData, int compressionLevel)
+{
+
+ // CompressionMethod_GZIP
+ CompressionResult gzipResult = test_compression_method(data, CompressionMethod_GZIP, compressionLevel);
+ CompressionResult gzipZResult = test_compression_method(zOrderedData, CompressionMethod_GZIP, compressionLevel);
+
+ BenchmarkRecord gzipRecord(gzipResult, gzipZResult);
+ gzipRecord.compressionLevel = compressionLevel;
+ gzipRecord.compressionMethod = GZIP_NAME;
+
+ // CompressionMethod_LZMA
+ CompressionResult lzmaResult = test_compression_method(data, CompressionMethod_LZMA, compressionLevel);
+ CompressionResult lzmaZResult = test_compression_method(zOrderedData, CompressionMethod_LZMA, compressionLevel);
+
+ BenchmarkRecord lzmaRecord(lzmaResult, lzmaZResult);
+ lzmaRecord.compressionLevel = compressionLevel;
+ lzmaRecord.compressionMethod = LZMA2_NAME;
+
+ // CompressionMethod_BZIP2
+ CompressionResult bzip2Result = test_compression_method(data, CompressionMethod_BZIP2, compressionLevel);
+ CompressionResult bzip2ZResult = test_compression_method(zOrderedData, CompressionMethod_BZIP2, compressionLevel);
+
+ BenchmarkRecord bzip2Record(bzip2Result, bzip2ZResult);
+ bzip2Record.compressionLevel = compressionLevel;
+ bzip2Record.compressionMethod = BZIP2_NAME;
+
+ std::vector<BenchmarkRecord> results;
+ results.resize(3);
+ results[0] = gzipRecord;
+ results[1] = lzmaRecord;
+ results[2] = bzip2Record;
+ return results;
+}
+
static void benchmark_continuos_compression(CziFile &cziFile, const std::string &reportFile, bool verbose, int level = -1)
{
always_assert(cziFile.subBlockDirectory.entries.size() > 0);
- std::vector<BenchmarkRecord> benchmarkResults;
const int minCompressionLevel = 1;
const int maxCompressionLevel = 9;
- std::string fName = fs_wrapper::get_filename(cziFile.fileName);
-
- int fromCL = (level == -1) ? minCompressionLevel : minCompressionLevel; // level;
- int toCL = (level == -1) ? maxCompressionLevel : maxCompressionLevel; // level;
- std::vector<BenchmarkRecord> results;
- results.resize((toCL - fromCL + 1) * 3);
+ std::string fName = fs_wrapper::get_filename(cziFile.fileName);
auto entry = cziFile.subBlockDirectory.entries[0];
- // Normal order data.
- {
+ ByteArray data = cziFile.get_continuous_image_data(false);
+ ByteArray zOrderData = cziFile.get_continuous_image_data(true);
- ByteArray data = cziFile.get_continuous_image_data(false);
- if (verbose)
- printf("Loaded into memory...\n");
- int levelDone = 0;
- //#pragma omp parallel for
- for (int compressionLevel = fromCL; compressionLevel <= toCL; compressionLevel++)
+ std::vector<BenchmarkRecord> results;
+ if (level != -1)
+ {
+ results = benchmark_continuos_compression_one_level(data, zOrderData, level);
+ for (auto &&result : results)
{
- // CompressionMethod_GZIP
- CompressionResult gzipResult = test_compression_method(data, CompressionMethod_GZIP, compressionLevel);
- BenchmarkRecord gzipRecord = {};
- gzipRecord.originalSize = gzipResult.originalSize;
- gzipRecord.compressedSize = gzipResult.compressedSize;
- gzipRecord.compressionRatio = gzipResult.compressionRatio;
- gzipRecord.compressionTime = gzipResult.compressionTimeMS;
- gzipRecord.compressionLevel = compressionLevel;
- gzipRecord.compressionMethod = GZIP_NAME;
- results[((compressionLevel - 1) * 3)] = gzipRecord;
- printf("Gzip completed. Ratio: %.5f\n", gzipResult.compressionRatio);
- // CompressionMethod_LZMA
- CompressionResult lzmaResult = test_compression_method(data, CompressionMethod_LZMA, compressionLevel);
- BenchmarkRecord lzmaRecord = {};
- lzmaRecord.originalSize = lzmaResult.originalSize;
- lzmaRecord.compressedSize = lzmaResult.compressedSize;
- lzmaRecord.compressionRatio = lzmaResult.compressionRatio;
- lzmaRecord.compressionTime = lzmaResult.compressionTimeMS;
- lzmaRecord.compressionLevel = compressionLevel;
- lzmaRecord.compressionMethod = LZMA2_NAME;
- results[((compressionLevel - 1) * 3) + 1] = lzmaRecord;
- printf("Lzma completed\n");
-
- // CompressionMethod_BZIP2
- CompressionResult bzip2Result = test_compression_method(data, CompressionMethod_BZIP2, compressionLevel);
- BenchmarkRecord bzip2Record = {};
- bzip2Record.originalSize = bzip2Result.originalSize;
- bzip2Record.compressedSize = bzip2Result.compressedSize;
- bzip2Record.compressionRatio = bzip2Result.compressionRatio;
- bzip2Record.compressionTime = bzip2Result.compressionTimeMS;
- bzip2Record.compressionLevel = compressionLevel;
- bzip2Record.compressionMethod = BZIP2_NAME;
- results[((compressionLevel - 1) * 3) + 2] = bzip2Record;
- printf("Bzip2 completed\n");
- if (verbose)
- {
-#pragma omp critical
- {
-
- printf("\rFinished compression level %i/%i of normal order.", ++levelDone, toCL);
- fflush(stdout);
- }
- }
+ result.fileName = fName.c_str();
+ result.subblockId = 999;
+ result.pixelType = cziFile.pixel_type_str(entry.pixelType);
+ result.width = 0;
+ result.height = 0;
}
- if (verbose)
- printf("\n");
- }
- // Z order data.
+ write_report(results, reportFile);
+ }
+ else
{
- ByteArray zOrderedData = cziFile.get_continuous_image_data(true);
- if (verbose)
- printf("Loaded into memory...\n");
int levelDone = 0;
- //#pragma omp parallel for
- for (int compressionLevel = fromCL; compressionLevel <= toCL; compressionLevel++)
+#pragma omp parallel for
+ for (int compressionLevel = minCompressionLevel; compressionLevel <= maxCompressionLevel; compressionLevel++)
{
- // CompressionMethod_GZIP
- CompressionResult gzipZResult = test_compression_method(zOrderedData, CompressionMethod_GZIP, compressionLevel);
- results[((compressionLevel - 1) * 3)].zOrderCompressedSize = gzipZResult.compressedSize;
- results[((compressionLevel - 1) * 3)].zOrderCompressionRatio = gzipZResult.compressionRatio;
- results[((compressionLevel - 1) * 3)].zOrderCompressionTime = gzipZResult.compressionTimeMS;
- printf("gzip Z completed\n");
- // CompressionMethod_LZMA
- CompressionResult lzmaZResult = test_compression_method(zOrderedData, CompressionMethod_LZMA, compressionLevel);
- results[((compressionLevel - 1) * 3) + 1].zOrderCompressedSize = lzmaZResult.compressedSize;
- results[((compressionLevel - 1) * 3) + 1].zOrderCompressionRatio = lzmaZResult.compressionRatio;
- results[((compressionLevel - 1) * 3) + 1].zOrderCompressionTime = lzmaZResult.compressionTimeMS;
- printf("Lzma Z completed\n");
- // CompressionMethod_BZIP2
- CompressionResult bzip2ZResult = test_compression_method(zOrderedData, CompressionMethod_BZIP2, compressionLevel);
- results[((compressionLevel - 1) * 3) + 2].zOrderCompressedSize = bzip2ZResult.compressedSize;
- results[((compressionLevel - 1) * 3) + 2].zOrderCompressionRatio = bzip2ZResult.compressionRatio;
- results[((compressionLevel - 1) * 3) + 2].zOrderCompressionTime = bzip2ZResult.compressionTimeMS;
- printf("Bzip2 Z completed\n");
- if (verbose)
- {
+ auto levelResults = benchmark_continuos_compression_one_level(data, zOrderData, compressionLevel);
#pragma omp critical
- {
- printf("\rFinished compression level %i/%i of Z order.", ++levelDone, toCL);
- fflush(stdout);
- }
+ {
+ results.insert(results.end(), levelResults.begin(), levelResults.end());
+ printf("\rFinished compression level %i/%i of normal order.", ++levelDone, maxCompressionLevel);
+ fflush(stdout);
}
}
if (verbose)
printf("\n");
}
- for (size_t i = 0; i < results.size(); i++)
+ for (auto &&result : results)
{
- results[i].fileName = fName.c_str();
- results[i].subblockId = 999;
- results[i].pixelType = cziFile.pixel_type_str(entry.pixelType);
- results[i].width = 0;
- results[i].height = 0;
+ result.fileName = fName.c_str();
+ result.subblockId = 999;
+ result.pixelType = cziFile.pixel_type_str(entry.pixelType);
+ result.width = 0;
+ result.height = 0;
}
if (verbose)
printf("\nWriting report file...\n");
+
write_report(results, reportFile);
printf("\nFinished benchmark, results are written in: %s\n", reportFile.c_str());
diff --git a/czi-format/czi-parser/czi_file.cpp b/czi-format/czi-parser/czi_file.cpp
index 868ea7531d3dd86c763ba4ec35e3203d9c1b195e..0860e517678a43fe778076d044cfff01ed09c5a2 100644
--- a/czi-format/czi-parser/czi_file.cpp
+++ b/czi-format/czi-parser/czi_file.cpp
@@ -380,7 +380,7 @@ ByteArray CziFile::get_continuous_image_data(const bool ZCurveOrdered) const
vecUtil::vector_insert_at(data, zOrderSubblockData, bufferEnd, 0, zOrderSubblockData.size());
bufferEnd += zOrderSubblockData.size();
- printf("\rLoaded subblock %i/%i", ++loaded, (int)subBlockDirectory.entries.size());
+ printf("\rLoaded Z-ordered subblock %i/%i", ++loaded, (int)subBlockDirectory.entries.size());
fflush(stdout);
}
}