PixelRefine: Simplify (remove Lorentz correction, remove background from azimuthal integration)

image_analysis/IndexAndRefine.cpp

@@ -238,9 +238,7 @@ void IndexAndRefine::QuickPredictAndIntegrate(DataMessage &msg,
                                               const SpotFindingSettings &spot_finding_settings,
                                               const CompressedImage &image,
                                               BraggPrediction &prediction,
-                                              const IndexAndRefine::IndexingOutcome &outcome,
-                                              const AzimuthalIntegrationMapping *mapping,
-                                              const AzimuthalIntegrationProfile *profile) {
+                                              const IndexAndRefine::IndexingOutcome &outcome) {
     if (!outcome.lattice_candidate)
         return;
 
@@ -299,11 +297,11 @@ void IndexAndRefine::QuickPredictAndIntegrate(DataMessage &msg,
     // integrated reflections that flow into the normal save/merge).
     const bool use_pixel_refine =
         experiment.GetIndexingSettings().GetGeomRefinementAlgorithm() == GeomRefinementAlgorithmEnum::PixelRefine
-        && !pixel_reference_.empty() && mapping && profile;
+        && !pixel_reference_.empty();
 
     if (use_pixel_refine) {
         auto integration_start_time = std::chrono::steady_clock::now();
-        PixelRefineIntegrate(msg, image, prediction, outcome, *mapping, *profile, i_outcome);
+        PixelRefineIntegrate(msg, image, prediction, outcome, i_outcome);
         msg.integrated_reflections = i_outcome.reflections.size();
         auto integration_end_time = std::chrono::steady_clock::now();
         msg.integration_time_s = std::chrono::duration<float>(integration_end_time - integration_start_time).count();
@@ -356,9 +354,7 @@ void IndexAndRefine::QuickPredictAndIntegrate(DataMessage &msg,
 void IndexAndRefine::ProcessImage(DataMessage &msg,
                                   const SpotFindingSettings &spot_finding_settings,
                                   const CompressedImage &image,
-                                  BraggPrediction &prediction,
-                                  const AzimuthalIntegrationMapping *mapping,
-                                  const AzimuthalIntegrationProfile *profile) {
+                                  BraggPrediction &prediction) {
     if (!indexer_ || !spot_finding_settings.indexing)
         return;
 
@@ -388,7 +384,7 @@ void IndexAndRefine::ProcessImage(DataMessage &msg,
     msg.lattice_type = outcome.symmetry;
 
     if (spot_finding_settings.quick_integration)
-        QuickPredictAndIntegrate(msg, spot_finding_settings, image, prediction, outcome, mapping, profile);
+        QuickPredictAndIntegrate(msg, spot_finding_settings, image, prediction, outcome);
 }
 
 std::optional<RotationIndexerResult> IndexAndRefine::FinalizeRotationIndexing() {
@@ -428,15 +424,13 @@ bool IndexAndRefine::PixelRefineIntegrate(DataMessage &msg,
                                           const CompressedImage &image,
                                           BraggPrediction &prediction,
                                           const IndexAndRefine::IndexingOutcome &outcome,
-                                          const AzimuthalIntegrationMapping &mapping,
-                                          const AzimuthalIntegrationProfile &profile,
                                           IntegrationOutcome &i_outcome) {
     if (!outcome.lattice_candidate)
         return false;
 
-    // Build the engine once (lazy: needs the azimuthal mapping, known only here).
+    // Build the engine once (lazy).
     std::call_once(pixel_refine_once_, [&] {
-        pixel_refine_ = std::make_unique<PixelRefine>(experiment, mapping, pixel_reference_);
+        pixel_refine_ = std::make_unique<PixelRefine>(experiment, pixel_reference_);
     });
     if (!pixel_refine_)
         return false;
@@ -455,17 +449,17 @@ bool IndexAndRefine::PixelRefineIntegrate(DataMessage &msg,
     const uint8_t *ptr = image.GetUncompressedPtr(buffer);
     switch (image.GetMode()) {
         case CompressedImageMode::Int8:
-            pixel_refine_->Run(reinterpret_cast<const int8_t *>(ptr), profile, prediction, prd); break;
+            pixel_refine_->Run(reinterpret_cast<const int8_t *>(ptr), prediction, prd); break;
         case CompressedImageMode::Int16:
-            pixel_refine_->Run(reinterpret_cast<const int16_t *>(ptr), profile, prediction, prd); break;
+            pixel_refine_->Run(reinterpret_cast<const int16_t *>(ptr), prediction, prd); break;
         case CompressedImageMode::Int32:
-            pixel_refine_->Run(reinterpret_cast<const int32_t *>(ptr), profile, prediction, prd); break;
+            pixel_refine_->Run(reinterpret_cast<const int32_t *>(ptr), prediction, prd); break;
         case CompressedImageMode::Uint8:
-            pixel_refine_->Run(reinterpret_cast<const uint8_t *>(ptr), profile, prediction, prd); break;
+            pixel_refine_->Run(reinterpret_cast<const uint8_t *>(ptr), prediction, prd); break;
         case CompressedImageMode::Uint16:
-            pixel_refine_->Run(reinterpret_cast<const uint16_t *>(ptr), profile, prediction, prd); break;
+            pixel_refine_->Run(reinterpret_cast<const uint16_t *>(ptr), prediction, prd); break;
         case CompressedImageMode::Uint32:
-            pixel_refine_->Run(reinterpret_cast<const uint32_t *>(ptr), profile, prediction, prd); break;
+            pixel_refine_->Run(reinterpret_cast<const uint32_t *>(ptr), prediction, prd); break;
         default:
             return false;
     }