diff --git a/image_analysis/IndexAndRefine.cpp b/image_analysis/IndexAndRefine.cpp
index 99e96df75..afd6c3992 100644
--- a/image_analysis/IndexAndRefine.cpp
+++ b/image_analysis/IndexAndRefine.cpp
@@ -141,8 +141,16 @@ void IndexAndRefine::ProcessImage(DataMessage &msg,
                                     * 3.0f;
 
             if (spot_finding_settings.quick_integration) {
-                auto res = BraggIntegrate2D(experiment_copy, image, *lattice_candidate,
-                                            prediction, ewald_dist_cutoff, msg.number, symmetry.centering);
+                BraggPredictionSettings settings_prediction{
+                    .high_res_A = experiment.GetBraggIntegrationSettings().GetDMinLimit_A(),
+                    .ewald_dist_cutoff = ewald_dist_cutoff,
+                    .max_hkl = 100,
+                    .centering = symmetry.centering
+                };
+
+                prediction.Calc(experiment, *lattice_candidate, settings_prediction);
+
+                auto res = BraggIntegrate2D(experiment_copy, image, prediction.GetReflections(), msg.number);
 
                 constexpr size_t kMaxReflections = 10000;
                 if (res.size() > kMaxReflections) {
diff --git a/image_analysis/bragg_integration/BraggIntegrate2D.cpp b/image_analysis/bragg_integration/BraggIntegrate2D.cpp
index 1d6431646..04d0e582a 100644
--- a/image_analysis/bragg_integration/BraggIntegrate2D.cpp
+++ b/image_analysis/bragg_integration/BraggIntegrate2D.cpp
@@ -63,40 +63,30 @@ bool IntegrateReflection(Reflection &r, const T *image, size_t xpixel, size_t yp
     return false;
 }
 
-
 template<class T>
 std::vector<Reflection> IntegrateInternal(const DiffractionExperiment &experiment,
                                           const CompressedImage &image,
-                                          const CrystalLattice &latt,
-                                          BraggPrediction &prediction,
-                                          float dist_from_ewald_sphere,
+                                          const std::vector<Reflection> &predicted,
                                           int64_t special_value,
                                           int64_t saturation,
-                                          int64_t image_number,
-                                          char centering) {
+                                          int64_t image_number) {
     auto settings = experiment.GetBraggIntegrationSettings();
     auto geom = experiment.GetDiffractionGeometry();
 
     std::vector<uint8_t> buffer;
     auto ptr = reinterpret_cast<const T *>(image.GetUncompressedPtr(buffer));
 
-    BraggPredictionSettings settings_prediction{
-        .high_res_A = settings.GetDMinLimit_A(),
-        .ewald_dist_cutoff = dist_from_ewald_sphere,
-        .max_hkl = 100,
-        .centering = centering
-    };
-
-    auto count = prediction.Calc(experiment, latt, settings_prediction);
-
     std::vector<Reflection> ret;
-    float r_3 = settings.GetR3();
-    float r_1_sq = settings.GetR1() * settings.GetR1();
-    float r_2_sq = settings.GetR2() * settings.GetR2();
-    float r_3_sq = settings.GetR3() * settings.GetR3();
+    ret.reserve(predicted.size());
+
+    const float r_3 = settings.GetR3();
+    const float r_1_sq = settings.GetR1() * settings.GetR1();
+    const float r_2_sq = settings.GetR2() * settings.GetR2();
+    const float r_3_sq = settings.GetR3() * settings.GetR3();
+
+    for (const auto &pred: predicted) {
+        Reflection r = pred; // copy, because we will write I/bkg/sigma/image_number
 
-    for (int i = 0; i < count; i++) {
-        Reflection r = prediction.GetReflections().at(i);
         if (IntegrateReflection(r, ptr, image.GetWidth(), image.GetHeight(), special_value, saturation,
                                 r_3, r_1_sq, r_2_sq, r_3_sq)) {
             if (experiment.GetPolarizationFactor()) {
@@ -107,7 +97,10 @@ std::vector<Reflection> IntegrateInternal(const DiffractionExperiment &experimen
                 r.sigma /= pol;
             }
 
-            r.image_number = static_cast<int>(image_number);
+            // In mixed-mode, keep the prediction's angle_deg if it exists,
+            // but stamp which image produced the integrated contribution.
+            r.image_number = static_cast<float>(image_number);
+
             ret.push_back(r);
         }
     }
@@ -117,33 +110,24 @@ std::vector<Reflection> IntegrateInternal(const DiffractionExperiment &experimen
 
 std::vector<Reflection> BraggIntegrate2D(const DiffractionExperiment &experiment,
                                          const CompressedImage &image,
-                                         const CrystalLattice &latt,
-                                         BraggPrediction &prediction,
-                                         float dist_from_ewald_sphere,
-                                         int64_t image_number,
-                                         char centering) {
-    if (image.GetCompressedSize() == 0)
+                                         const std::vector<Reflection> &predicted,
+                                         int64_t image_number) {
+    if (image.GetCompressedSize() == 0 || predicted.empty())
         return {};
 
     switch (image.GetMode()) {
         case CompressedImageMode::Int8:
-            return IntegrateInternal<int8_t>(experiment, image, latt, prediction, dist_from_ewald_sphere, INT8_MIN,
-                                             INT8_MAX, image_number, centering);
+            return IntegrateInternal<int8_t>(experiment, image, predicted, INT8_MIN, INT8_MAX, image_number);
         case CompressedImageMode::Int16:
-            return IntegrateInternal<int16_t>(experiment, image, latt, prediction, dist_from_ewald_sphere, INT16_MIN,
-                                              INT16_MAX, image_number, centering);
+            return IntegrateInternal<int16_t>(experiment, image, predicted, INT16_MIN, INT16_MAX, image_number);
         case CompressedImageMode::Int32:
-            return IntegrateInternal<int32_t>(experiment, image, latt, prediction, dist_from_ewald_sphere, INT32_MIN,
-                                              INT32_MAX, image_number, centering);
+            return IntegrateInternal<int32_t>(experiment, image, predicted, INT32_MIN, INT32_MAX, image_number);
         case CompressedImageMode::Uint8:
-            return IntegrateInternal<uint8_t>(experiment, image, latt, prediction, dist_from_ewald_sphere, UINT8_MAX,
-                                              UINT8_MAX, image_number, centering);
+            return IntegrateInternal<uint8_t>(experiment, image, predicted, UINT8_MAX, UINT8_MAX, image_number);
         case CompressedImageMode::Uint16:
-            return IntegrateInternal<uint16_t>(experiment, image, latt, prediction, dist_from_ewald_sphere, UINT16_MAX,
-                                               UINT16_MAX, image_number, centering);
+            return IntegrateInternal<uint16_t>(experiment, image, predicted, UINT16_MAX, UINT16_MAX, image_number);
         case CompressedImageMode::Uint32:
-            return IntegrateInternal<uint16_t>(experiment, image, latt, prediction, dist_from_ewald_sphere, UINT32_MAX,
-                                               UINT32_MAX, image_number, centering);
+            return IntegrateInternal<uint16_t>(experiment, image, predicted, UINT32_MAX, UINT32_MAX, image_number);
         default:
             throw JFJochException(JFJochExceptionCategory::InputParameterInvalid,
                                   "Image mode not supported");
diff --git a/image_analysis/bragg_integration/BraggIntegrate2D.h b/image_analysis/bragg_integration/BraggIntegrate2D.h
index 593bba6ae..b557084f9 100644
--- a/image_analysis/bragg_integration/BraggIntegrate2D.h
+++ b/image_analysis/bragg_integration/BraggIntegrate2D.h
@@ -12,10 +12,7 @@
 
 std::vector<Reflection> BraggIntegrate2D(const DiffractionExperiment &experiment,
                                          const CompressedImage &image,
-                                         const CrystalLattice &latt,
-                                         BraggPrediction &prediction,
-                                         float dist_from_ewald_sphere,
-                                         int64_t image_number,
-                                         char centering = 'P');
+                                         const std::vector<Reflection> &predicted,
+                                         int64_t image_number);
 
 #endif //JFJOCH_BRAGGINTEGRATE2D_H