126 lines
4.4 KiB
C++
126 lines
4.4 KiB
C++
// Copyright (2019-2022) Paul Scherrer Institute
|
|
// SPDX-License-Identifier: GPL-3.0-or-later
|
|
|
|
#include "TestImagePusher.h"
|
|
#include "../tests/FPGAUnitTest.h"
|
|
#include "JFJochCompressor.h"
|
|
#include "../compression/JFJochDecompress.h"
|
|
#include "../frame_serialize/JFJochFrameDeserializer.h"
|
|
|
|
TestImagePusher::TestImagePusher(int64_t image_number) {
|
|
image_id = image_number;
|
|
}
|
|
|
|
void TestImagePusher::StartDataCollection(const StartMessage& message) {
|
|
std::unique_lock<std::mutex> ul(m);
|
|
|
|
if (is_running)
|
|
correct_sequence = false;
|
|
else
|
|
is_running = true;
|
|
}
|
|
|
|
void TestImagePusher::EndDataCollection(const EndMessage& message) {
|
|
std::unique_lock<std::mutex> ul(m);
|
|
|
|
if (!is_running)
|
|
correct_sequence = false;
|
|
else
|
|
is_running = false;
|
|
}
|
|
|
|
void TestImagePusher::SendImage(const uint8_t *image_data, size_t image_size, int64_t image_number) {
|
|
std::unique_lock<std::mutex> ul(m);
|
|
|
|
frame_counter++;
|
|
if (image_number == image_id) {
|
|
|
|
JFJochFrameDeserializer deserializer;
|
|
deserializer.Process(image_data, image_size);
|
|
|
|
auto image_array = deserializer.GetDataMessage();
|
|
receiver_generated_image.resize(image_array.image.size);
|
|
memcpy(receiver_generated_image.data(), image_array.image.data, image_array.image.size);
|
|
}
|
|
}
|
|
|
|
void TestImagePusher::SendImage(const uint8_t *image_data, size_t image_size, int64_t image_number,
|
|
ZeroCopyReturnValue *z) {
|
|
std::unique_lock<std::mutex> ul(m);
|
|
|
|
frame_counter++;
|
|
if (image_number == image_id) {
|
|
JFJochFrameDeserializer deserializer;
|
|
deserializer.Process(image_data, image_size);
|
|
|
|
auto image_array = deserializer.GetDataMessage();
|
|
receiver_generated_image.resize(image_array.image.size);
|
|
memcpy(receiver_generated_image.data(), image_array.image.data, image_array.image.size);
|
|
}
|
|
z->release();
|
|
}
|
|
|
|
bool TestImagePusher::CheckSequence() const {
|
|
std::unique_lock<std::mutex> ul(m);
|
|
return correct_sequence;
|
|
}
|
|
|
|
const std::vector<uint8_t> &TestImagePusher::GetImage() const {
|
|
std::unique_lock<std::mutex> ul(m);
|
|
return receiver_generated_image;
|
|
}
|
|
|
|
size_t TestImagePusher::GetCounter() const {
|
|
std::unique_lock<std::mutex> ul(m);
|
|
return frame_counter;
|
|
}
|
|
|
|
bool TestImagePusher::CheckImage(const DiffractionExperiment &x, const std::vector<uint16_t> &raw_reference_image,
|
|
const JFCalibration &calibration,
|
|
Logger &logger) {
|
|
bool no_errors = true;
|
|
|
|
if (receiver_generated_image.empty()) {
|
|
logger.Error("Image empty");
|
|
no_errors = false;
|
|
} else {
|
|
std::vector<int16_t> decompressed_image;
|
|
// Image decompression
|
|
try {
|
|
JFJochDecompress(decompressed_image, x.GetCompressionAlgorithmEnum(),
|
|
receiver_generated_image, x.GetPixelsNum());
|
|
} catch (const JFJochException &e) {
|
|
logger.Error(e.what());
|
|
no_errors = false;
|
|
}
|
|
if (no_errors) {
|
|
// Check output
|
|
|
|
if (x.GetDetectorMode() == DetectorMode::Conversion) {
|
|
size_t storage_cell = 0;
|
|
if (x.GetStorageCellNumber() > 1)
|
|
storage_cell = image_id % x.GetStorageCellNumber();
|
|
|
|
double result = CheckConversionWithGeomTransform(x, calibration,
|
|
raw_reference_image.data(),
|
|
decompressed_image.data(),
|
|
storage_cell);
|
|
if (x.GetBinning2x2() && (result > 1.5)) {
|
|
logger.Error("Mean conversion error ({}) larger than threshold", result);
|
|
no_errors = false;
|
|
} else if (!x.GetBinning2x2() && (result > 0.5)) {
|
|
logger.Error("Mean conversion error ({}) larger than threshold", result);
|
|
no_errors = false;
|
|
} else
|
|
logger.Info("Mean conversion error: {}", result);
|
|
} else if (x.GetDetectorMode() == DetectorMode::Raw) {
|
|
if (memcmp(raw_reference_image.data(), decompressed_image.data(), sizeof(uint16_t) * x.GetPixelsNum()) !=
|
|
0) {
|
|
logger.Error("Raw data mismatch");
|
|
no_errors = false;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return no_errors;
|
|
} |