1.0.0-rc.174 (#84)

* Rugnux: Performance improvements on GPU and CPU (more of the pre-scan and of scaling on the GPU, faster CPU spot finding and crystal refinement), with unchanged results.
* Rugnux: More robust processing - patches of persistently hot pixels are masked, an inconsistent merge triggers a retry at the measured beam centre, and builds targeting different CPU levels give the same results.
* Rugnux: Improved scaling and merging - reflections with an overloaded pixel are dropped, as in XDS, sparse rotation sweeps are scaled more reliably, and French-Wilson amplitudes use an anisotropic Wilson prior.
* Rugnux: Improved space-group determination - glide planes in groups without a centre of symmetry, screw axes from short or weak axial rows kept when a higher group is adopted, and more reliable decisions on twinned and pseudo-symmetric crystals.
* Rugnux: Improved small-molecule processing - spots that grow wider than the integration disk and split spots are integrated over their measured footprint, sparse lattices are integrated on every frame, and the `.hkl` file holds unmerged scaled reflections (SHELX HKLF 4).
* Rugnux: Reads Rigaku d*TREK SMV images (Saturn CCD), including detector 2theta and encoded pixel overflows; home-source (rotating-anode) datasets were added to the validation battery.
* jfjoch_viewer: Fixed processing failing at the end with "Wrong JPEG library version" on Linux; the merge window shows the space group with proper subscripts and a checklist of crystal pathologies.

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

tests/BraggIntegrationEngineCPUTest.cpp

@@ -48,7 +48,7 @@ TEST_CASE("BraggIntegrationEngineCPU_NeighbourMaskFollowsPartiality", "[Integrat
                 r.partiality = (gx == 0 && gy == 0) ? 0.5f : neighbour_partiality;
                 predicted.push_back(r);
             }
-        BraggIntegrationEngineCPU engine(experiment);
+        BraggIntegrationEngineCPU engine(experiment, PixelMask(experiment));
         const auto out = engine.Run(image, predicted, predicted.size(), 0);
         counts = engine.Counts();
         std::vector<Reflection> spot;
@@ -76,3 +76,40 @@ TEST_CASE("BraggIntegrationEngineCPU_NeighbourMaskFollowsPartiality", "[Integrat
     CHECK(on_frame.bkg_starved_by_neighbour == on_frame.bkg_starved);
     CHECK(on_frame.bkg_starved_by_neighbour == tails.bkg_starved_by_neighbour);
 }
+
+// A saturated pixel (INT32_MAX, as the preprocessor marks it) at the peak of a spot: the reflection is
+// not measured but kept, flagged overloaded, so that a rotation merge can drop its whole rocking event.
+// The same spot without the saturated pixel is an ordinary measurement.
+TEST_CASE("BraggIntegrationEngineCPU_SaturatedPeakIsFlaggedNotDropped", "[Integration][portable]") {
+    DiffractionExperiment experiment(DetJF(2));
+    experiment.DetectorDistance_mm(100.0f).IncidentEnergy_keV(WVL_1A_IN_KEV).BeamX_pxl(400.0f).BeamY_pxl(400.0f);
+    experiment.ImportBraggIntegrationSettings(BraggIntegrationSettings());
+    const size_t width = experiment.GetXPixelsNum(), npixel = experiment.GetPixelsNum();
+
+    const int cx = 600, cy = 300;
+    ImagePreprocessorBuffer image(npixel);
+    for (size_t i = 0; i < npixel; ++i)
+        image[i] = 12;
+    for (int dy = -6; dy <= 6; ++dy)
+        for (int dx = -6; dx <= 6; ++dx)
+            image[(cy + dy) * width + cx + dx] += static_cast<int32_t>(std::lround(800.0 * std::exp(-(dx * dx + dy * dy) / (2 * 1.3 * 1.3))));
+
+    Reflection r{};
+    r.h = 1; r.k = 2; r.l = 3;
+    r.predicted_x = cx; r.predicted_y = cy;
+    r.d = 2.0f;
+    r.prescaling_corr = 1.0f;
+    r.partiality = 1.0f;
+    const std::vector<Reflection> predicted{r};
+
+    BraggIntegrationEngineCPU engine(experiment, PixelMask(experiment));
+    const auto clean = engine.Run(image, predicted, 1, 0);
+    REQUIRE(clean.size() == 1);
+    CHECK_FALSE(clean[0].overloaded);
+
+    image[cy * width + cx] = INT32_MAX;
+    const auto saturated = engine.Run(image, predicted, 1, 0);
+    REQUIRE(saturated.size() == 1);
+    CHECK(saturated[0].overloaded);
+    CHECK(saturated[0].clipped);
+}