v1.0.0-rc.166 (#76)

* `rugnux --mode calibration` writes `<prefix>.json` beside the `.poni`, whose `dataset_settings` member is a `jfjoch_broker` `dataset_settings` body as it stands.
* `rugnux` and `jfjoch_viewer` read PILATUS miniCBF sweeps natively, without conversion.
* Masters written by other facilities open, including Eiger 1.x and third-party NXmx variants.
* `rugnux` measures the beam centre on every run, and indexes with it when the file's value indexes nothing.
* A detector swung out on a 2theta arm is placed where the file says it stands, and the calibration can hold the tilt fixed.
* `rugnux` writes the unmerged MTZ by default, and a P1 merge beside it, so a wrong space group can be re-merged without reprocessing.
* Significant improvements to symmetry handling in `rugnux`: the lattice, the point group, the setting and the systematic absences.
* The `rugnux` report gives the resolution the CC1/2 fit reached, beside the range the reflections were written to.
* The `rugnux` report gives the twinning statistics measured before the space group was decided, beside the ones measured after.
* The `rugnux` report gives the strong-direction diffraction limit, and warns when CC1/2 is not monotone with resolution.
* `rugnux` ranks screw axes on the evidence their absences carry, rather than on how many control reflections a candidate happens to have.
* Twinning is no longer reported when the L-test contradicts it.
* The `rugnux` report gives the detector tilt, the measured tilt and the direct beam beside the beam centre, and a post-refined beam centre is judged against the run's own measurement rather than the file's.
* `--no-refine-tilt` holds the detector tilt at the value in the file, instead of zeroing it, when the calibration starts from the spots.
* The `jfjoch_viewer` grid scan view draws the cells in the proportion of the scan steps, so the map has the shape of the scanned area.

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

tests/AdaptiveSpotFinderCPUTest.cpp

@@ -1,6 +1,7 @@
 // SPDX-FileCopyrightText: 2026 Filip Leonarski, Paul Scherrer Institute <filip.leonarski@psi.ch>
 // SPDX-License-Identifier: GPL-3.0-only
 
+#include <cmath>
 #include <algorithm>
 
 #include <catch2/catch_all.hpp>
@@ -190,3 +191,64 @@ TEST_CASE("AdaptiveSpotFinderCPU_RingBackgroundExcludesPeaks", "[AdaptiveSpotFin
     for (size_t b = 0; b < clean.size(); b++)
         CHECK(std::isfinite(clean[b]) == (pixels_per_bin[b] >= 40));
 }
+
+// The footprint of a bright reflection must not grow with its brightness. A whole-ring threshold is
+// an absolute contour, so the area a Gaussian puts above it grows as sigma^2 ln(peak/threshold) - the
+// same spot detected a hundred times brighter comes back tens of pixels larger, and an upper bound on
+// spot size becomes an upper bound on spot INTENSITY. Intersecting with the local-box test removes
+// that: the spot inflates the box's own variance, the peak divides out of the acceptance test, and the
+// contour lands at a fixed fraction of the spot's own height whatever that height is.
+TEST_CASE("AdaptiveSpotFinderCPU_FootprintDoesNotGrowWithBrightness", "[AdaptiveSpotFinder]") {
+    DiffractionExperiment x(DetJF4M());
+    x.DetectorDistance_mm(80).BeamX_pxl(1030).BeamY_pxl(1080);
+    x.QSpacingForAzimInt_recipA(0.05).QRangeForAzimInt_recipA(0.05, 5.0);
+    x.GeometryTransformation(false);
+
+    PixelMask pixel_mask(x);
+    AzimuthalIntegrationMapping mapping(x, pixel_mask);
+    const auto &pixel_to_bin = mapping.GetPixelToBin();
+
+    const size_t w = x.GetXPixelsNum();
+    const size_t h = x.GetYPixelsNum();
+
+    size_t spot_row = 0, spot_col = 0;
+    for (size_t row = 400; row < h - 400 && spot_row == 0; row++)
+        for (size_t col = 400; col < w - 400; col++)
+            if (pixel_to_bin[row * w + col] != UINT16_MAX) {
+                spot_row = row;
+                spot_col = col;
+                break;
+            }
+    REQUIRE(spot_row > 0);
+
+    std::vector<bool> res_mask(x.GetPixelsNum(), false);
+    auto settings = AdaptiveSettings();
+    settings.min_pix_per_spot = 2;
+    settings.max_pix_per_spot = 100000;   // no bound, so the footprint itself is what is measured
+
+    // One Gaussian of width 1.5 px on a flat background of 10, at three amplitudes a hundred apart.
+    auto footprint = [&](double amplitude) {
+        ImagePreprocessorBuffer buffer(x.GetPixelsNum());
+        for (size_t i = 0; i < w * h; i++)
+            buffer[i] = 10;
+        constexpr double sigma = 1.5;
+        for (int dr = -12; dr <= 12; dr++)
+            for (int dc = -12; dc <= 12; dc++) {
+                const double r2 = dr * dr + dc * dc;
+                buffer[(spot_row + dr) * w + spot_col + dc] =
+                    10 + static_cast<int32_t>(amplitude * std::exp(-r2 / (2 * sigma * sigma)));
+            }
+        AdaptiveSpotFinderCPU finder(mapping);
+        finder.SetResolutionMask(res_mask);
+        const auto spots = finder.Run(buffer, settings);
+        REQUIRE(spots.size() == 1);
+        return spots[0].PixelCount();
+    };
+
+    const int64_t small = footprint(300.0);
+    const int64_t large = footprint(30000.0);
+    CHECK(small > 0);
+    // A hundredfold in peak is 4.6 e-folds. An absolute contour would add sigma^2 ln(100) ~ 10 pixels
+    // per e-fold of AREA here, tens of pixels in all; a peak-relative one adds nothing.
+    CHECK(large - small <= 4);
+}