v1.0.0-rc.124 (#31)

This is an UNSTABLE release. This version significantly rewrites code to predict reflection position and integrate them,
especially in case of rotation crystallography. If things go wrong with analysis, it is better to revert to 1.0.0-rc.123.

* jfjoch_broker: Improve refection position prediction and Bragg integration code.
* jfjoch_broker: Align with XDS way of calculating Lorentz correction and general notation.
* jfjoch_writer: Fix saving mosaicity properly in HDF5 file.
* jfjoch_viewer: Introduce high-dynamic range mode for images
* jfjoch_viewer: Ctrl+mouse wheel has exponential change in foreground (+/-15%)
* jfjoch_viewer: Zoom-in numbers have better readability

Reviewed-on: #31
Co-authored-by: Filip Leonarski <filip.leonarski@psi.ch>
Co-committed-by: Filip Leonarski <filip.leonarski@psi.ch>

image_analysis/bragg_integration/BraggIntegrate2D.cpp

@@ -2,14 +2,11 @@
 // SPDX-License-Identifier: GPL-3.0-only
 
 #include "BraggIntegrate2D.h"
-#include "BraggPrediction.h"
 
 template<class T>
-bool IntegrateReflection(Reflection &r, const T *image, size_t xpixel, size_t ypixel,
+void IntegrateReflection(Reflection &r, const T *image, size_t xpixel, size_t ypixel,
                          int64_t special_value, int64_t saturation,
                          float r_3, float r_1_sq, float r_2_sq, float r_3_sq) {
-    r.I = 0;
-    r.bkg = 0;
 
     int64_t x0 = std::floor(r.predicted_x - r_3 - 1.0);
     int64_t x1 = std::ceil(r.predicted_x + r_3 + 1.0);
@@ -58,92 +55,83 @@ bool IntegrateReflection(Reflection &r, const T *image, size_t xpixel, size_t yp
             r.sigma = std::sqrt(static_cast<float>(I_sum));
         else
             r.sigma = 1;
-        return true;
+        r.observed = true;
+    } else {
+        r.I = 0;
+        r.bkg = 0;
+        r.observed = false;
     }
-    return false;
 }
 
+#include <iostream>
 
 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,
+                                          size_t npredicted,
                                           int64_t special_value,
                                           int64_t saturation,
-                                          int64_t image_number,
-                                          char centering) {
+                                          int64_t image_number) {
+
+    std::vector<Reflection> ret;
+    ret.reserve(npredicted);
+
     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
-    };
+    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();
 
-    auto count = prediction.Calc(experiment, latt, settings_prediction);
+    const Coord S0 = geom.GetScatteringVector();
+    Coord m2 = Coord(0,0,0); // zero vector
+    if (experiment.GetGoniometer().has_value())
+        m2 = experiment.GetGoniometer()->GetAxis().Normalize();
 
-    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();
-
-    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()) {
-                float pol = geom.CalcAzIntPolarizationCorr(r.predicted_x, r.predicted_y,
+    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) {
+            if (experiment.GetPolarizationFactor())
+                r.rlp *= geom.CalcAzIntPolarizationCorr(r.predicted_x, r.predicted_y,
                                                            experiment.GetPolarizationFactor().value());
-                r.I /= pol;
-                r.bkg /= pol;
-                r.sigma /= pol;
-            }
-
-            r.image_number = static_cast<int>(image_number);
-            ret.push_back(r);
+            r.I *= r.rlp;
+            r.bkg *= r.rlp;
+            r.sigma *= r.rlp;
+            r.image_number = static_cast<float>(image_number);
+            ret.emplace_back(r);
         }
     }
-
     return ret;
 }
 
 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,
+                                         size_t npredicted,
+                                         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, npredicted, 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, npredicted, 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, npredicted, 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, npredicted, 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, npredicted, 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, npredicted, UINT32_MAX, UINT32_MAX, image_number);
         default:
             throw JFJochException(JFJochExceptionCategory::InputParameterInvalid,
                                   "Image mode not supported");