mx/Jungfraujoch
2
1
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases 66 Wiki Activity

v1.0.0-rc.38

Browse Source
This commit is contained in:
leonarski_f
2025-05-12 14:17:24 +02:00
parent 19d6f22136
commit b245967df3
201 changed files with 2376 additions and 1428 deletions
Download Patch File Download Diff File Expand all files Collapse all files
reader/JFJochReader.cpp
+41 -75
View File
@@ -4,94 +4,60 @@
#include "JFJochReader.h"
#include "../common/PixelMask.h"
void JFJochReader::LoadImage(int64_t image_number) {
void JFJochReader::LoadImage(int64_t image_number, int64_t summation_factor) {
// It would be a mess to load two images at the same time
// so loading is protected via mutex
// yet copying share_ptr pointer is atomic and needs no mutex protection
std::unique_lock ul(current_image_mutex);
current_image = LoadImageInternal(image_number);
CalcImageStatistics(current_image);
CalcROI(current_image);
auto image = LoadImageInternal(image_number);
if (image) {
for (int i = 1; i < summation_factor; i++) {
auto tmp = LoadImageInternal(image_number + i);
if (tmp)
image->AddImage(*tmp);
}
}
current_image = image;
CalcROI();
}
std::shared_ptr<JFJochReaderImage> JFJochReader::CopyImage() {
return current_image;
}
void JFJochReader::CalcImageStatistics(const std::shared_ptr<JFJochReaderImage> &image) {
if (!image || (!image->dataset))
void JFJochReader::CalcROI() {
if (!current_image)
return;
size_t good_pixel = 0;
for (int i = 0; i < image->image.size(); i++) {
int32_t value = image->image[i];
uint32_t mask_val = 0;
if (!image->dataset->pixel_mask.empty())
mask_val = image->dataset->pixel_mask.at(i);
if ((mask_val & (
(1<<PixelMask::ModuleGapPixelBit)
| (1<<PixelMask::ChipGapPixelBit)
| (1<<PixelMask::ModuleEdgePixelBit))) != 0) {
image->image[i] = GAP_PXL_VALUE;
} else if (image->image[i] <= image->dataset->error_value || (mask_val != 0)) {
image->image[i] = ERROR_PXL_VALUE;
image->error_pixel.emplace(i);
} else if (image->image[i] >= image->dataset->saturation_value) {
image->image[i] = SATURATED_PXL_VALUE;
image->saturated_pixel.emplace(i);
} else {
good_pixel++;
image->valid_pixel.emplace(value, i);
}
}
current_image->CalcROI(roi.get());
}
void JFJochReader::CalcROI(const std::shared_ptr<JFJochReaderImage> &image) {
if (!image || (!image->dataset))
return;
if (!roi) {
image->roi = {};
return;
}
int64_t width = image->dataset->image_size_x;
int64_t height = image->dataset->image_size_y;
int64_t roi_val = 0;
uint64_t roi_val_2 = 0;
int64_t roi_max = INT64_MIN;
uint64_t roi_npixel = 0;
for (int64_t y = roi->GetYMin(); y < std::min(roi->GetYMax(), height); y++) {
for (int64_t x = roi->GetXMin(); x < std::min(roi->GetXMax(), width); x++) {
int32_t val = image->image[x + width * y];
if ((val != SATURATED_PXL_VALUE) && (val != ERROR_PXL_VALUE) && (val != GAP_PXL_VALUE)) {
roi_val += val;
roi_val_2 += val * val;
if (val > roi_max) roi_max = val;
roi_npixel++;
}
}
}
image->roi = ROIMessage{
.sum = roi_val,
.sum_square = roi_val_2,
.max_count = roi_max,
.pixels = roi_npixel
};
}
void JFJochReader::SetROI(const std::optional<ROIBox> &input) {
void JFJochReader::ClearROI() {
std::unique_lock lg(current_image_mutex);
if (input && (input->GetArea() == 0)) {
// Empty ROI is reset
roi = {};
} else {
roi = input;
CalcROI(current_image);
}
roi = {};
CalcROI();
}
void JFJochReader::SetROI(const ROIBox &input) {
std::unique_lock lg(current_image_mutex);
roi = std::make_unique<ROIBox>(input);
CalcROI();
}
void JFJochReader::SetROI(const ROICircle &input) {
std::unique_lock lg(current_image_mutex);
roi = std::make_unique<ROICircle>(input);
CalcROI();
}
void JFJochReader::SetStartMessage(const std::shared_ptr<JFJochReaderDataset> &val) {
std::unique_lock ul(start_message_mutex);
start_message = val;
}
std::shared_ptr<JFJochReaderDataset> JFJochReader::GetStartMessage() const {
std::unique_lock ul(start_message_mutex);
if (!start_message)
throw JFJochException(JFJochExceptionCategory::InputParameterInvalid, "File not loaded");
return start_message;
}