diff --git a/image_analysis/IndexAndRefine.cpp b/image_analysis/IndexAndRefine.cpp
index ebe8f013..1851280e 100644
--- a/image_analysis/IndexAndRefine.cpp
+++ b/image_analysis/IndexAndRefine.cpp
@@ -146,21 +146,10 @@ void IndexAndRefine::QuickPredictAndIntegrate(DataMessage &msg,
         .centering = outcome.symmetry.centering
     };
 
-    prediction.Calc(experiment, *outcome.lattice_candidate, settings_prediction);
+    auto nrefl = prediction.Calc(experiment, *outcome.lattice_candidate, settings_prediction);
+    auto refl_ret = BraggIntegrate2D(outcome.experiment, image, prediction.GetReflections(), nrefl, msg.number);
 
-    auto refl = prediction.GetReflections();
-
-    BraggIntegrate2D(outcome.experiment, image, refl, msg.number);
-
-    std::vector<Reflection> refl_ret;
-    refl_ret.reserve(refl.size());
-
-    for (const auto& r : refl) {
-        if (r.observed)
-            refl_ret.push_back(r);
-    }
-
-    constexpr size_t kMaxReflections = 20000;
+    constexpr size_t kMaxReflections = 10000;
     if (refl_ret.size() > kMaxReflections) {
         // Keep only smallest d (highest resolution)
         std::nth_element(refl_ret.begin(),
diff --git a/image_analysis/bragg_integration/BraggIntegrate2D.cpp b/image_analysis/bragg_integration/BraggIntegrate2D.cpp
index 2206157b..a511fc12 100644
--- a/image_analysis/bragg_integration/BraggIntegrate2D.cpp
+++ b/image_analysis/bragg_integration/BraggIntegrate2D.cpp
@@ -64,12 +64,17 @@ void IntegrateReflection(Reflection &r, const T *image, size_t xpixel, size_t yp
 }
 
 template<class T>
-void IntegrateInternal(const DiffractionExperiment &experiment,
+std::vector<Reflection> IntegrateInternal(const DiffractionExperiment &experiment,
                                           const CompressedImage &image,
-                                          std::vector<Reflection> &predicted,
+                                          const std::vector<Reflection> &predicted,
+                                          size_t npredicted,
                                           int64_t special_value,
                                           int64_t saturation,
                                           int64_t image_number) {
+
+    std::vector<Reflection> ret;
+    ret.reserve(npredicted);
+
     auto settings = experiment.GetBraggIntegrationSettings();
     auto geom = experiment.GetDiffractionGeometry();
 
@@ -81,7 +86,8 @@ void IntegrateInternal(const DiffractionExperiment &experiment,
     const float r_2_sq = settings.GetR2() * settings.GetR2();
     const float r_3_sq = settings.GetR3() * settings.GetR3();
 
-    for (auto &r: predicted) {
+    for (int i = 0; i < npredicted; i++) {
+        auto r = predicted.at(i);
         IntegrateReflection(r, ptr, image.GetWidth(), image.GetHeight(), special_value, saturation,
                                 r_3, r_1_sq, r_2_sq, r_3_sq);
         if (r.observed) {
@@ -94,36 +100,32 @@ void IntegrateInternal(const DiffractionExperiment &experiment,
             }
 
             r.image_number = static_cast<float>(image_number);
+            ret.emplace_back(r);
         }
     }
 }
 
-void BraggIntegrate2D(const DiffractionExperiment &experiment,
+std::vector<Reflection> BraggIntegrate2D(const DiffractionExperiment &experiment,
                                          const CompressedImage &image,
-                                         std::vector<Reflection> &predicted,
+                                         const std::vector<Reflection> &predicted,
+                                         size_t npredicted,
                                          int64_t image_number) {
     if (image.GetCompressedSize() == 0 || predicted.empty())
-        return;
+        return {};
 
     switch (image.GetMode()) {
         case CompressedImageMode::Int8:
-           IntegrateInternal<int8_t>(experiment, image, predicted, INT8_MIN, INT8_MAX, image_number);
-            break;
+           return IntegrateInternal<int8_t>(experiment, image, predicted, npredicted, INT8_MIN, INT8_MAX, image_number);
         case CompressedImageMode::Int16:
-            IntegrateInternal<int16_t>(experiment, image, predicted, INT16_MIN, INT16_MAX, image_number);
-            break;
+            return IntegrateInternal<int16_t>(experiment, image, predicted, npredicted, INT16_MIN, INT16_MAX, image_number);
         case CompressedImageMode::Int32:
-            IntegrateInternal<int32_t>(experiment, image, predicted, INT32_MIN, INT32_MAX, image_number);
-            break;
+            return IntegrateInternal<int32_t>(experiment, image, predicted, npredicted, INT32_MIN, INT32_MAX, image_number);
         case CompressedImageMode::Uint8:
-            IntegrateInternal<uint8_t>(experiment, image, predicted, UINT8_MAX, UINT8_MAX, image_number);
-            break;
+            return IntegrateInternal<uint8_t>(experiment, image, predicted, npredicted, UINT8_MAX, UINT8_MAX, image_number);
         case CompressedImageMode::Uint16:
-            IntegrateInternal<uint16_t>(experiment, image, predicted, UINT16_MAX, UINT16_MAX, image_number);
-            break;
+            return IntegrateInternal<uint16_t>(experiment, image, predicted, npredicted, UINT16_MAX, UINT16_MAX, image_number);
         case CompressedImageMode::Uint32:
-            IntegrateInternal<uint16_t>(experiment, image, predicted, UINT32_MAX, UINT32_MAX, image_number);
-            break;
+            return IntegrateInternal<uint16_t>(experiment, image, predicted, npredicted, 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 c46bb894..353757b5 100644
--- a/image_analysis/bragg_integration/BraggIntegrate2D.h
+++ b/image_analysis/bragg_integration/BraggIntegrate2D.h
@@ -8,9 +8,10 @@
 #include "../../common/DiffractionExperiment.h"
 #include "../../common/Reflection.h"
 
-void BraggIntegrate2D(const DiffractionExperiment &experiment,
-                      const CompressedImage &image,
-                      std::vector<Reflection> &predicted,
-                      int64_t image_number);
+std::vector<Reflection> BraggIntegrate2D(const DiffractionExperiment &experiment,
+                                         const CompressedImage &image,
+                                         const std::vector<Reflection> &predicted,
+                                         size_t npredicted,
+                                         int64_t image_number);
 
 #endif //JFJOCH_BRAGGINTEGRATE2D_H