v1.0.0-rc.153 (#63)

This is an UNSTABLE release. It includes many experimental features, as well as many AI generated fixes. We recommend using rc.152 for production use.

* jfjoch_broker: Add EXPERIMENTAL pixelrefine mode for image processing
* jfjoch_broker: Allow to load user mask from 8-bit and 16-bit TIFF files
* jfjoch_broker: Add ROI calculation in non-FPGA workflow
* jfjoch_broker: Fixes to TCP image pusher
* jfjoch_broker: Remove NUMA bindings
* jfjoch_broker: Improvements to indexing
* jfjoch_broker: For PSI EIGER, trimming energies are taken from the detector configuration (now compulsory) instead of hardcoded values
* jfjoch_writer: Save ROI definitions and the per-pixel ROI bitmap in the master file; azimuthal ROIs support phi (angular) sectors
* jfjoch_viewer: Major redesign with dockable panels and saved layouts, plus on-canvas creation/move/resize of box, circle and azimuthal ROIs
* jfjoch_viewer: Run jfjoch_process reprocessing jobs from inside the GUI and overlay per-run results

Reviewed-on: #63

image_analysis/MXAnalysisWithoutFPGA.cpp

@@ -11,9 +11,11 @@
 #include "image_preprocessing/ImagePreprocessorCPU.h"
 
 #include "azint/AzIntEngineCPU.h"
+#include "roi/ROIIntegrationCPU.h"
 #include "spot_finding/ImageSpotFinderCPU.h"
 #ifdef JFJOCH_USE_CUDA
 #include "azint/AzIntEngineGPU.h"
+#include "roi/ROIIntegrationGPU.h"
 #include "spot_finding/ImageSpotFinderGPU.h"
 #include "image_preprocessing/ImagePreprocessorGPU.h"
 #include "image_preprocessing/ImagePreprocessorBufferGPU.h"
@@ -42,13 +44,17 @@ MXAnalysisWithoutFPGA::MXAnalysisWithoutFPGA(const DiffractionExperiment &in_exp
         spotFinder = std::make_unique<ImageSpotFinderCPU>(experiment.GetXPixelsNum(), experiment.GetYPixelsNum());
         azint = std::make_unique<AzIntEngineCPU>(integration);
         preprocessor = std::make_unique<ImagePreprocessorCPU>(in_experiment, in_mask);
+        if (experiment.ROI().size() >= 1)
+            roi = std::make_unique<ROIIntegrationCPU>(experiment);
 #ifdef JFJOCH_USE_CUDA
     } else {
-        auto stream = std::make_shared<CudaStream>();
+        stream = std::make_shared<CudaStream>();
         preprocessor_buffer = std::make_unique<ImagePreprocessorBufferGPU>(experiment.GetPixelsNum());
         preprocessor = std::make_unique<ImagePreprocessorGPU>(in_experiment, in_mask, stream);
         spotFinder = std::make_unique<ImageSpotFinderGPU>(experiment.GetXPixelsNum(), experiment.GetYPixelsNum(), stream);
         azint = std::make_unique<AzIntEngineGPU>(integration, stream);
+        if (experiment.ROI().size() >= 1)
+            roi = std::make_unique<ROIIntegrationGPU>(experiment, stream);
     }
 #endif
 }
@@ -77,6 +83,9 @@ void MXAnalysisWithoutFPGA::Analyze(DataMessage &output,
     const auto azint_end_time = std::chrono::steady_clock::now();
     output.azint_time_s = std::chrono::duration<float>(azint_end_time - azint_start_time).count();
 
+    if (roi)
+        roi->Run(*preprocessor_buffer, output.roi);
+
     if (spot_finding_settings.enable) {
         // Update resolution mask
         if (mask_high_res != spot_finding_settings.high_resolution_limit
@@ -106,6 +115,37 @@ void MXAnalysisWithoutFPGA::Analyze(DataMessage &output,
     output.bkg_estimate = profile.GetBkgEstimate(integration.Settings());
 }
 
+void MXAnalysisWithoutFPGA::RebuildROI() {
+    if (experiment.ROI().empty()) {
+        roi.reset();
+        return;
+    }
+#ifdef JFJOCH_USE_CUDA
+    if (stream) {
+        roi = std::make_unique<ROIIntegrationGPU>(experiment, stream);
+        return;
+    }
+#endif
+    roi = std::make_unique<ROIIntegrationCPU>(experiment);
+}
+
+void MXAnalysisWithoutFPGA::AnalyzeROIOnly(DataMessage &output) {
+    if ((output.image.GetWidth() != xpixels)
+        || (output.image.GetWidth() * output.image.GetHeight() != npixels))
+        throw JFJochException(JFJochExceptionCategory::InputParameterInvalid,
+                              "Mismatch in pixel size");
+
+    const uint8_t *image_ptr = output.image.GetUncompressedPtr(decompression_buffer);
+    preprocessor->Analyze(*preprocessor_buffer, image_ptr, output.image.GetMode());
+    RunROIOnly(output);
+}
+
+void MXAnalysisWithoutFPGA::RunROIOnly(DataMessage &output) {
+    output.roi.clear();
+    if (roi)
+        roi->Run(*preprocessor_buffer, output.roi);
+}
+
 void MXAnalysisWithoutFPGA::UpdateMaskResolution(const SpotFindingSettings &settings) {
     mask_low_res = settings.low_resolution_limit;
     mask_high_res = settings.high_resolution_limit;