From eaf7792459db97db36ad77c444b9bbc400190a98 Mon Sep 17 00:00:00 2001 From: Filip Leonarski Date: Sat, 11 Nov 2023 18:48:38 +0100 Subject: [PATCH] DataProcessingSettings has equivalent C++ and ProtoBuf structures --- broker/JFJochServices.cpp | 19 ++++++++- broker/JFJochServices.h | 2 +- broker/JFJochStateMachine.cpp | 44 ++++++++++++++++++-- broker/JFJochStateMachine.h | 3 +- common/DiffractionExperiment.cpp | 55 ++++++++++++------------- common/DiffractionExperiment.h | 5 ++- image_analysis/CMakeLists.txt | 3 +- image_analysis/DataProcessingSettings.h | 21 ++++++++++ image_analysis/GPUImageAnalysis.cu | 12 +++--- image_analysis/GPUImageAnalysis.h | 4 +- image_analysis/StrongPixelSet.cpp | 10 ++--- image_analysis/StrongPixelSet.h | 3 +- receiver/JFJochReceiver.cpp | 14 +++---- receiver/JFJochReceiver.h | 6 +-- receiver/JFJochReceiverService.cpp | 23 +++++++++-- receiver/JFJochReceiverService.h | 2 +- tests/SpotAnalyzeUnitTest.cpp | 10 ++--- tests/SpotFinderIntegration.cpp | 8 ++-- 18 files changed, 167 insertions(+), 77 deletions(-) create mode 100644 image_analysis/DataProcessingSettings.h diff --git a/broker/JFJochServices.cpp b/broker/JFJochServices.cpp index 71213f26..abe2b908 100644 --- a/broker/JFJochServices.cpp +++ b/broker/JFJochServices.cpp @@ -157,8 +157,23 @@ JFJochProtoBuf::RadialIntegrationProfiles JFJochServices::GetRadialIntegrationPr } } -void JFJochServices::SetDataProcessingSettings(const JFJochProtoBuf::DataProcessingSettings &settings) { - receiver.SetDataProcessingSettings(settings); +inline JFJochProtoBuf::DataProcessingSettings Convert(const DataProcessingSettings &input) { + JFJochProtoBuf::DataProcessingSettings ret; + ret.set_signal_to_noise_threshold(input.signal_to_noise_threshold); + ret.set_photon_count_threshold(input.photon_count_threshold); + ret.set_min_pix_per_spot(input.min_pix_per_spot); + ret.set_max_pix_per_spot(input.max_pix_per_spot); + ret.set_local_bkg_size(input.local_bkg_size); + ret.set_high_resolution_limit(input.high_resolution_limit); + ret.set_low_resolution_limit(input.low_resolution_limit); + ret.set_bkg_estimate_low_q(input.bkg_estimate_low_q); + ret.set_bkg_estimate_high_q(input.bkg_estimate_high_q); + ret.set_preview_indexed_only(input.preview_indexed_only); + return ret; +} + +void JFJochServices::SetDataProcessingSettings(const DataProcessingSettings &settings) { + receiver.SetDataProcessingSettings(Convert(settings)); } void JFJochServices::Trigger() { diff --git a/broker/JFJochServices.h b/broker/JFJochServices.h index 72d69790..d6294ea7 100644 --- a/broker/JFJochServices.h +++ b/broker/JFJochServices.h @@ -32,7 +32,7 @@ public: JFJochProtoBuf::Plot GetPlots(const JFJochProtoBuf::PlotRequest &request); JFJochProtoBuf::RadialIntegrationProfiles GetRadialIntegrationProfiles(); - void SetDataProcessingSettings(const JFJochProtoBuf::DataProcessingSettings &settings); + void SetDataProcessingSettings(const DataProcessingSettings &settings); JFJochServices& Receiver(const std::string &addr); JFJochServices& Writer(const std::string &addr, const std::string &zmq_push_addr); JFJochServices& Detector(const std::string &addr); diff --git a/broker/JFJochStateMachine.cpp b/broker/JFJochStateMachine.cpp index bbaf27dc..1017f03b 100644 --- a/broker/JFJochStateMachine.cpp +++ b/broker/JFJochStateMachine.cpp @@ -5,6 +5,36 @@ #include "JFJochStateMachine.h" #include "../common/JFJochException.h" +inline DataProcessingSettings Convert(const JFJochProtoBuf::DataProcessingSettings &input) { + DataProcessingSettings ret; + ret.signal_to_noise_threshold = input.signal_to_noise_threshold(); + ret.photon_count_threshold = input.photon_count_threshold(); + ret.min_pix_per_spot = input.min_pix_per_spot(); + ret.max_pix_per_spot = input.max_pix_per_spot(); + ret.local_bkg_size = input.local_bkg_size(); + ret.high_resolution_limit = input.high_resolution_limit(); + ret.low_resolution_limit = input.low_resolution_limit(); + ret.bkg_estimate_low_q = input.bkg_estimate_low_q(); + ret.bkg_estimate_high_q = input.bkg_estimate_high_q(); + ret.preview_indexed_only = input.preview_indexed_only(); + return ret; +} + +inline JFJochProtoBuf::DataProcessingSettings Convert(const DataProcessingSettings &input) { + JFJochProtoBuf::DataProcessingSettings ret; + ret.set_signal_to_noise_threshold(input.signal_to_noise_threshold); + ret.set_photon_count_threshold(input.photon_count_threshold); + ret.set_min_pix_per_spot(input.min_pix_per_spot); + ret.set_max_pix_per_spot(input.max_pix_per_spot); + ret.set_local_bkg_size(input.local_bkg_size); + ret.set_high_resolution_limit(input.high_resolution_limit); + ret.set_low_resolution_limit(input.low_resolution_limit); + ret.set_bkg_estimate_low_q(input.bkg_estimate_low_q); + ret.set_bkg_estimate_high_q(input.bkg_estimate_high_q); + ret.set_preview_indexed_only(input.preview_indexed_only); + return ret; +} + JFJochStateMachine::JFJochStateMachine(JFJochServices &in_services, Logger &in_logger) : services(in_services), logger(in_logger), data_processing_settings(DiffractionExperiment::DefaultDataProcessingSettings()) { @@ -194,7 +224,7 @@ void JFJochStateMachine::Start(const JFJochProtoBuf::DatasetSettings& settings) try { state = JFJochState::Busy; - services.SetDataProcessingSettings(GetDataProcessingSettings()); + services.SetDataProcessingSettings(GetDataAnalysisSettings()); services.Start(experiment, *calibration); state = JFJochState::Measuring; @@ -523,12 +553,18 @@ JFJochProtoBuf::RadialIntegrationProfiles JFJochStateMachine::GetRadialIntegrati void JFJochStateMachine::SetDataProcessingSettings(const JFJochProtoBuf::DataProcessingSettings &settings) { std::unique_lock ul(data_processing_settings_mutex); - DiffractionExperiment::CheckDataProcessingSettings(settings); - data_processing_settings = settings; - services.SetDataProcessingSettings(data_processing_settings); + auto tmp = Convert(settings); + DiffractionExperiment::CheckDataProcessingSettings(tmp); + data_processing_settings = tmp; + services.SetDataProcessingSettings(tmp); } JFJochProtoBuf::DataProcessingSettings JFJochStateMachine::GetDataProcessingSettings() const { + std::unique_lock ul(data_processing_settings_mutex); + return Convert(data_processing_settings); +} + +DataProcessingSettings JFJochStateMachine::GetDataAnalysisSettings() const { std::unique_lock ul(data_processing_settings_mutex); return data_processing_settings; } diff --git a/broker/JFJochStateMachine.h b/broker/JFJochStateMachine.h index a8c6b430..2756d235 100644 --- a/broker/JFJochStateMachine.h +++ b/broker/JFJochStateMachine.h @@ -46,7 +46,7 @@ class JFJochStateMachine { JFJochProtoBuf::BrokerFullStatus GetFullMeasurementOutput() const; mutable std::mutex data_processing_settings_mutex; - JFJochProtoBuf::DataProcessingSettings data_processing_settings; + DataProcessingSettings data_processing_settings; // Private functions assume that lock m is acquired void SetDatasetDefaults(JFJochProtoBuf::DatasetSettings& settings); @@ -94,6 +94,7 @@ public: void SetDataProcessingSettings(const JFJochProtoBuf::DataProcessingSettings& settings); JFJochProtoBuf::DataProcessingSettings GetDataProcessingSettings() const; + DataProcessingSettings GetDataAnalysisSettings() const; JFJochState GetState() const; diff --git a/common/DiffractionExperiment.cpp b/common/DiffractionExperiment.cpp index a3f0f020..ac33e45e 100644 --- a/common/DiffractionExperiment.cpp +++ b/common/DiffractionExperiment.cpp @@ -907,38 +907,37 @@ JFJochProtoBuf::DetectorSettings DiffractionExperiment::GetDetectorSettings() co return ret; } -void DiffractionExperiment::CheckDataProcessingSettings(const JFJochProtoBuf::DataProcessingSettings &settings) { - check_min("Signal to noise threshold", settings.signal_to_noise_threshold(), 1); - check_min("Photon count threshold", settings.photon_count_threshold(), 0); - check_min("Minimum pixels per spot", settings.min_pix_per_spot(), 1); - check_min("Maximum pixels per spot", settings.max_pix_per_spot(), settings.min_pix_per_spot() + 1); - check_min("Local background size", settings.local_bkg_size(), 2); - check_max("Local background size", settings.local_bkg_size(), 7); - if (settings.high_resolution_limit() > 0) { - check_min("Spot finding high resolution limit", settings.high_resolution_limit(), 0.5); - check_max("Spot finding high resolution limit", settings.high_resolution_limit(), 50.0); - if (settings.low_resolution_limit() > 0) { - check_min("Spot finding low resolution limit", settings.low_resolution_limit(), - settings.high_resolution_limit()); +void DiffractionExperiment::CheckDataProcessingSettings(const DataProcessingSettings &settings) { + check_min("Signal to noise threshold", settings.signal_to_noise_threshold, 1); + check_min("Photon count threshold", settings.photon_count_threshold, 0); + check_min("Minimum pixels per spot", settings.min_pix_per_spot, 1); + check_min("Maximum pixels per spot", settings.max_pix_per_spot, settings.min_pix_per_spot + 1); + check_min("Local background size", settings.local_bkg_size, 2); + check_max("Local background size", settings.local_bkg_size, 7); + if (settings.high_resolution_limit > 0) { + check_min("Spot finding high resolution limit", settings.high_resolution_limit, 0.5); + check_max("Spot finding high resolution limit", settings.high_resolution_limit, 50.0); + if (settings.low_resolution_limit > 0) { + check_min("Spot finding low resolution limit", settings.low_resolution_limit, + settings.high_resolution_limit); } - } else if (settings.low_resolution_limit() > 0) { - check_min("Spot finding low resolution limit", settings.low_resolution_limit(), 1.0); - check_max("Spot finding low resolution limit", settings.low_resolution_limit(), 50.0); + } else if (settings.low_resolution_limit > 0) { + check_min("Spot finding low resolution limit", settings.low_resolution_limit, 1.0); + check_max("Spot finding low resolution limit", settings.low_resolution_limit, 50.0); } - check_min("Background estimate lowQ", settings.bkg_estimate_low_q(), 0.0); - check_min("Background estimate highQ", settings.bkg_estimate_high_q(), settings.bkg_estimate_low_q()); - + check_min("Background estimate lowQ", settings.bkg_estimate_low_q, 0.0); + check_min("Background estimate highQ", settings.bkg_estimate_high_q, settings.bkg_estimate_low_q); } -JFJochProtoBuf::DataProcessingSettings DiffractionExperiment::DefaultDataProcessingSettings() { - JFJochProtoBuf::DataProcessingSettings ret; - ret.set_local_bkg_size(5); - ret.set_signal_to_noise_threshold(3); - ret.set_photon_count_threshold(16); - ret.set_min_pix_per_spot(1); - ret.set_max_pix_per_spot(50); - ret.set_bkg_estimate_low_q(2 * M_PI / 5.0); - ret.set_bkg_estimate_high_q(2 * M_PI / 3.0); +DataProcessingSettings DiffractionExperiment::DefaultDataProcessingSettings() { + DataProcessingSettings ret{}; + ret.local_bkg_size = 5; + ret.signal_to_noise_threshold = 3; + ret.photon_count_threshold = 16; + ret.min_pix_per_spot = 1; + ret.max_pix_per_spot = 50; + ret.bkg_estimate_low_q = 2 * M_PI / 5.0; + ret.bkg_estimate_high_q= 2 * M_PI / 3.0; return ret; } diff --git a/common/DiffractionExperiment.h b/common/DiffractionExperiment.h index f03647fe..5bf255c5 100644 --- a/common/DiffractionExperiment.h +++ b/common/DiffractionExperiment.h @@ -16,6 +16,7 @@ #include "Definitions.h" #include "../frame_serialize/CBORMessages.h" #include "DetectorSetup.h" +#include "../image_analysis/DataProcessingSettings.h" enum class DetectorMode : int { Conversion, Raw, PedestalG0, PedestalG1, PedestalG2 @@ -94,8 +95,8 @@ public: void LoadDetectorSettings(const JFJochProtoBuf::DetectorSettings &settings); JFJochProtoBuf::DetectorSettings GetDetectorSettings() const; - static void CheckDataProcessingSettings(const JFJochProtoBuf::DataProcessingSettings& settings); - static JFJochProtoBuf::DataProcessingSettings DefaultDataProcessingSettings(); + static void CheckDataProcessingSettings(const DataProcessingSettings& settings); + static DataProcessingSettings DefaultDataProcessingSettings(); DetectorMode GetDetectorMode() const; int64_t GetPixelDepth() const; diff --git a/image_analysis/CMakeLists.txt b/image_analysis/CMakeLists.txt index ccb2c8a9..e9de92c3 100644 --- a/image_analysis/CMakeLists.txt +++ b/image_analysis/CMakeLists.txt @@ -3,7 +3,8 @@ ADD_LIBRARY(ImageAnalysis STATIC IndexerWrapper.cpp IndexerWrapper.h GPUImageAnalysis.h RadialIntegrationMapping.cpp RadialIntegrationMapping.h - StrongPixelSet.cpp StrongPixelSet.h GPUImageAnalysis.cpp RadialIntegrationProfile.cpp RadialIntegrationProfile.h) + StrongPixelSet.cpp StrongPixelSet.h GPUImageAnalysis.cpp RadialIntegrationProfile.cpp RadialIntegrationProfile.h + DataProcessingSettings.h) TARGET_LINK_LIBRARIES(ImageAnalysis CommonFunctions) diff --git a/image_analysis/DataProcessingSettings.h b/image_analysis/DataProcessingSettings.h new file mode 100644 index 00000000..13155857 --- /dev/null +++ b/image_analysis/DataProcessingSettings.h @@ -0,0 +1,21 @@ +// Copyright (2019-2023) Paul Scherrer Institute + +#ifndef JUNGFRAUJOCH_DATAPROCESSINGSETTINGS_H +#define JUNGFRAUJOCH_DATAPROCESSINGSETTINGS_H + +#include + +struct DataProcessingSettings { + float signal_to_noise_threshold; // STRONG_PIXEL in XDS + int64_t photon_count_threshold; // Threshold in photon counts + int64_t min_pix_per_spot; // Minimum pixels per spot + int64_t max_pix_per_spot; // Maximum pixels per spot + int64_t local_bkg_size; // NBX/NBY parameter + float high_resolution_limit; + float low_resolution_limit; + float bkg_estimate_low_q; + float bkg_estimate_high_q; + bool preview_indexed_only; +}; + +#endif //JUNGFRAUJOCH_DATAPROCESSINGSETTINGS_H diff --git a/image_analysis/GPUImageAnalysis.cu b/image_analysis/GPUImageAnalysis.cu index 37c3b71a..1ce9ee9d 100644 --- a/image_analysis/GPUImageAnalysis.cu +++ b/image_analysis/GPUImageAnalysis.cu @@ -279,17 +279,17 @@ bool GPUImageAnalysis::GPUPresent() { return (device_count > 0); } -void GPUImageAnalysis::RunSpotFinder(const JFJochProtoBuf::DataProcessingSettings &settings) { +void GPUImageAnalysis::RunSpotFinder(const DataProcessingSettings &settings) { // data_in is CUDA registered memory // Run COLSPOT (GPU version) spot_parameters spot_params; - spot_params.strong_pixel_threshold2 = settings.signal_to_noise_threshold() * settings.signal_to_noise_threshold(); - spot_params.nbx = settings.local_bkg_size(); - spot_params.nby = settings.local_bkg_size(); + spot_params.strong_pixel_threshold2 = settings.signal_to_noise_threshold * settings.signal_to_noise_threshold; + spot_params.nbx = settings.local_bkg_size; + spot_params.nby = settings.local_bkg_size; spot_params.lines = ypixels; spot_params.cols = xpixels; - spot_params.count_threshold = settings.photon_count_threshold(); + spot_params.count_threshold = settings.photon_count_threshold; spot_params.min_viable_number = INT16_MIN + 5; if (2 * spot_params.nbx + 1 > windowSizeLimit) @@ -345,7 +345,7 @@ void GPUImageAnalysis::GetSpotFinderResults(StrongPixelSet &pixel_set) { } void GPUImageAnalysis::GetSpotFinderResults(const DiffractionExperiment &experiment, - const JFJochProtoBuf::DataProcessingSettings &settings, + const DataProcessingSettings &settings, std::vector &vec) { StrongPixelSet pixel_set(experiment); GetSpotFinderResults(pixel_set); diff --git a/image_analysis/GPUImageAnalysis.h b/image_analysis/GPUImageAnalysis.h index 8e20818e..ab9d777c 100644 --- a/image_analysis/GPUImageAnalysis.h +++ b/image_analysis/GPUImageAnalysis.h @@ -43,9 +43,9 @@ public: void SetInputBuffer(void *host_in); void LoadDataToGPU(); - void RunSpotFinder(const JFJochProtoBuf::DataProcessingSettings &settings); + void RunSpotFinder(const DataProcessingSettings &settings); void GetSpotFinderResults(StrongPixelSet &pixel_set); - void GetSpotFinderResults(const DiffractionExperiment &experiment, const JFJochProtoBuf::DataProcessingSettings &settings, + void GetSpotFinderResults(const DiffractionExperiment &experiment, const DataProcessingSettings &settings, std::vector &vec); static bool GPUPresent(); diff --git a/image_analysis/StrongPixelSet.cpp b/image_analysis/StrongPixelSet.cpp index da355d46..1dd9395f 100644 --- a/image_analysis/StrongPixelSet.cpp +++ b/image_analysis/StrongPixelSet.cpp @@ -89,7 +89,7 @@ void StrongPixelSet::ExtendSpot(DiffractionSpot &spot, std::unordered_map &spots) { std::multimap spots_map; @@ -98,10 +98,10 @@ void StrongPixelSet::FindSpots(const DiffractionExperiment &experiment, const JF DiffractionSpot spot = BuildSpot(iter); double d = spot.GetResolution(experiment); - if ((spot.PixelCount() <= settings.max_pix_per_spot()) - && (spot.PixelCount() >= settings.min_pix_per_spot()) - && ((settings.low_resolution_limit() < 0) || (d <= settings.low_resolution_limit())) - && ((settings.high_resolution_limit() < 0) || (d >= settings.high_resolution_limit()))) + if ((spot.PixelCount() <= settings.max_pix_per_spot) + && (spot.PixelCount() >= settings.min_pix_per_spot) + && ((settings.low_resolution_limit < 0) || (d <= settings.low_resolution_limit)) + && ((settings.high_resolution_limit < 0) || (d >= settings.high_resolution_limit))) spots_map.insert(std::make_pair(-static_cast(d), spot)); } diff --git a/image_analysis/StrongPixelSet.h b/image_analysis/StrongPixelSet.h index 36e79579..9347f3fd 100644 --- a/image_analysis/StrongPixelSet.h +++ b/image_analysis/StrongPixelSet.h @@ -9,6 +9,7 @@ #include "../common/Coord.h" #include "../common/DiffractionSpot.h" #include "../acquisition_device/AcquisitionDevice.h" +#include "DataProcessingSettings.h" inline uint32_t strong_pixel_coord(uint16_t col, uint16_t line) { return col + (static_cast(line) << 16u); @@ -35,7 +36,7 @@ public: StrongPixelSet(const DiffractionExperiment& experiment); size_t Count() const; void AddStrongPixel(uint16_t col, uint16_t line, int32_t photons = 1); - void FindSpots(const DiffractionExperiment &experiment, const JFJochProtoBuf::DataProcessingSettings &settings, std::vector &spots); + void FindSpots(const DiffractionExperiment &experiment, const DataProcessingSettings &settings, std::vector &spots); size_t Common(const StrongPixelSet &set) const; }; diff --git a/receiver/JFJochReceiver.cpp b/receiver/JFJochReceiver.cpp index e63a5eac..c15cc8cc 100644 --- a/receiver/JFJochReceiver.cpp +++ b/receiver/JFJochReceiver.cpp @@ -446,9 +446,9 @@ void JFJochReceiver::FrameTransformationThread() { if (rad_int_profile_image) { uint16_t rad_int_min_bin = std::floor( - rad_int_mapping->QToBin(local_data_processing_settings.bkg_estimate_low_q())); + rad_int_mapping->QToBin(local_data_processing_settings.bkg_estimate_low_q)); uint16_t rad_int_max_bin = std::ceil( - rad_int_mapping->QToBin(local_data_processing_settings.bkg_estimate_high_q())); + rad_int_mapping->QToBin(local_data_processing_settings.bkg_estimate_high_q)); float bkg_estimate_val = rad_int_profile_image->GetMeanValueOfBins(rad_int_min_bin, rad_int_max_bin); bkg_estimate.AddElement(image_number, bkg_estimate_val); @@ -473,7 +473,7 @@ void JFJochReceiver::FrameTransformationThread() { size_t image_size = transformation.SaveCompressedImage(ptr + serializer.GetImageAppendOffset()); serializer.AppendImage(image_size); - if (preview_publisher && (!local_data_processing_settings.preview_indexed_only() || indexed)) + if (preview_publisher && (!local_data_processing_settings.preview_indexed_only || indexed)) preview_publisher->SendImage(ptr, serializer.GetBufferSize(), image_number); if (push_images_to_writer) { @@ -632,13 +632,13 @@ void JFJochReceiver::FinalizeMeasurement() { logger.Info("Receiving data done"); } -void JFJochReceiver::SetDataProcessingSettings(const JFJochProtoBuf::DataProcessingSettings &in_data_processing_settings) { +void JFJochReceiver::SetDataProcessingSettings(const DataProcessingSettings &in_data_processing_settings) { std::unique_lock ul(data_processing_settings_mutex); DiffractionExperiment::CheckDataProcessingSettings(in_data_processing_settings); data_processing_settings = in_data_processing_settings; for (int i = 0; i < ndatastreams; i++) { - acquisition_device[i]->SetSpotFinderParameters(data_processing_settings.photon_count_threshold(), - data_processing_settings.signal_to_noise_threshold()); + acquisition_device[i]->SetSpotFinderParameters(data_processing_settings.photon_count_threshold, + data_processing_settings.signal_to_noise_threshold); } } @@ -655,7 +655,7 @@ JFJochReceiver::~JFJochReceiver() { free(send_buffer); } -JFJochProtoBuf::DataProcessingSettings JFJochReceiver::GetDataProcessingSettings() { +DataProcessingSettings JFJochReceiver::GetDataProcessingSettings() { std::unique_lock ul(data_processing_settings_mutex); return data_processing_settings; } diff --git a/receiver/JFJochReceiver.h b/receiver/JFJochReceiver.h index fc97dda9..da90ea5c 100644 --- a/receiver/JFJochReceiver.h +++ b/receiver/JFJochReceiver.h @@ -97,7 +97,7 @@ class JFJochReceiver { std::chrono::time_point start_time; std::chrono::time_point end_time; - JFJochProtoBuf::DataProcessingSettings data_processing_settings; + DataProcessingSettings data_processing_settings; std::mutex data_processing_settings_mutex; StatusVector bkg_estimate; @@ -126,7 +126,7 @@ class JFJochReceiver { void MeasurePedestalThread(uint16_t data_stream, uint16_t module_number, uint16_t storage_cell); void Cancel(const JFJochException &e); void FinalizeMeasurement(); - JFJochProtoBuf::DataProcessingSettings GetDataProcessingSettings(); + DataProcessingSettings GetDataProcessingSettings(); void UpdateMaxImage(int64_t image_number); void UpdateMaxDelay(int64_t delay); @@ -149,7 +149,7 @@ public: void Cancel(); float GetProgress() const; float GetIndexingRate() const; - void SetDataProcessingSettings(const JFJochProtoBuf::DataProcessingSettings &data_processing_settings); + void SetDataProcessingSettings(const DataProcessingSettings &data_processing_settings); float GetAvailableSendBuffers() const; Plot GetPlots(const PlotRequest& request); diff --git a/receiver/JFJochReceiverService.cpp b/receiver/JFJochReceiverService.cpp index ccb2463e..125c9441 100644 --- a/receiver/JFJochReceiverService.cpp +++ b/receiver/JFJochReceiverService.cpp @@ -2,7 +2,7 @@ #include "JFJochReceiverService.h" -PlotRequest Convert(const JFJochProtoBuf::PlotRequest& request) { +inline PlotRequest Convert(const JFJochProtoBuf::PlotRequest& request) { PlotRequest ret; ret.binning = request.binning(); switch (request.type()) { @@ -29,7 +29,7 @@ PlotRequest Convert(const JFJochProtoBuf::PlotRequest& request) { return ret; } -void Convert(const Plot& input, JFJochProtoBuf::Plot &output) { +inline void Convert(const Plot& input, JFJochProtoBuf::Plot &output) { if (!input.x.empty()) *output.mutable_x() = {input.x.begin(), input.x.end()}; if (!input.y.empty()) @@ -37,6 +37,21 @@ void Convert(const Plot& input, JFJochProtoBuf::Plot &output) { } +inline DataProcessingSettings Convert(const JFJochProtoBuf::DataProcessingSettings &input) { + DataProcessingSettings ret; + ret.signal_to_noise_threshold = input.signal_to_noise_threshold(); + ret.photon_count_threshold = input.photon_count_threshold(); + ret.min_pix_per_spot = input.min_pix_per_spot(); + ret.max_pix_per_spot = input.max_pix_per_spot(); + ret.local_bkg_size = input.local_bkg_size(); + ret.high_resolution_limit = input.high_resolution_limit(); + ret.low_resolution_limit = input.low_resolution_limit(); + ret.bkg_estimate_low_q = input.bkg_estimate_low_q(); + ret.bkg_estimate_high_q = input.bkg_estimate_high_q(); + ret.preview_indexed_only = input.preview_indexed_only(); + return ret; +} + void Convert(const RadialIntegrationProfiles& input, JFJochProtoBuf::RadialIntegrationProfiles& output) { for (const auto &i: input.profiles) { auto tmp = output.add_profiles(); @@ -237,9 +252,9 @@ grpc::Status JFJochReceiverService::SetDataProcessingSettings(grpc::ServerContex JFJochProtoBuf::Empty *response) { try { std::unique_lock ul(state_mutex); - data_processing_settings = *request; + data_processing_settings = Convert(*request); if (state != ReceiverState::Idle) - receiver->SetDataProcessingSettings(*request); + receiver->SetDataProcessingSettings(data_processing_settings); return grpc::Status::OK; } catch (std::exception &e) { diff --git a/receiver/JFJochReceiverService.h b/receiver/JFJochReceiverService.h index 10a387d1..5b40f719 100644 --- a/receiver/JFJochReceiverService.h +++ b/receiver/JFJochReceiverService.h @@ -30,7 +30,7 @@ class JFJochReceiverService final : public JFJochProtoBuf::gRPC_JFJochReceiver:: std::condition_variable measurement_done; std::future measurement; void FinalizeMeasurement(); - JFJochProtoBuf::DataProcessingSettings data_processing_settings; + DataProcessingSettings data_processing_settings; public: JFJochReceiverService(std::vector &open_capi_device, Logger &logger, ImagePusher &pusher); diff --git a/tests/SpotAnalyzeUnitTest.cpp b/tests/SpotAnalyzeUnitTest.cpp index cea1ac58..3fbc8e57 100644 --- a/tests/SpotAnalyzeUnitTest.cpp +++ b/tests/SpotAnalyzeUnitTest.cpp @@ -28,11 +28,11 @@ TEST_CASE("StrongPixelSet_BuildSpots","[StrongPixelSet]") { DiffractionExperiment experiment; experiment.Mode(DetectorMode::Raw); - JFJochProtoBuf::DataProcessingSettings settings; - settings.set_low_resolution_limit(200.0); - settings.set_high_resolution_limit(0.5); - settings.set_min_pix_per_spot(3); - settings.set_max_pix_per_spot(200); + DataProcessingSettings settings; + settings.low_resolution_limit = 200.0; + settings.high_resolution_limit = 0.5; + settings.min_pix_per_spot = 3; + settings.max_pix_per_spot = 200; std::vector spots; StrongPixelSet strong_pixel_set(experiment); diff --git a/tests/SpotFinderIntegration.cpp b/tests/SpotFinderIntegration.cpp index 8eb52d4b..e3f9ce1a 100644 --- a/tests/SpotFinderIntegration.cpp +++ b/tests/SpotFinderIntegration.cpp @@ -90,10 +90,10 @@ TEST_CASE("SpotFinder_GPU", "[GPUImageAnalysis]") { spot_params.cols = experiment.GetXPixelsNum(); spot_params.min_viable_number = 1; - JFJochProtoBuf::DataProcessingSettings settings; - settings.set_local_bkg_size(nbx); - settings.set_photon_count_threshold(1); - settings.set_signal_to_noise_threshold(threshold); + DataProcessingSettings settings; + settings.local_bkg_size = nbx; + settings.photon_count_threshold = 1; + settings.signal_to_noise_threshold = threshold; StrongPixelSet colspot_gpu(experiment); spot_finder.LoadDataToGPU();