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>

image_analysis/spot_finding/AdaptiveSpotFinderCPU.cpp

@@ -9,8 +9,8 @@
 #include "AdaptiveThreshold.h"
 
 AdaptiveSpotFinderCPU::AdaptiveSpotFinderCPU(const AzimuthalIntegrationMapping &in_mapping)
-    : ImageSpotFinder(static_cast<int32_t>(in_mapping.GetWidth()),
-                      static_cast<int32_t>(in_mapping.GetHeight())),
+    : ImageSpotFinderCPU(static_cast<int32_t>(in_mapping.GetWidth()),
+                         static_cast<int32_t>(in_mapping.GetHeight())),
       mapping(in_mapping) {
     const size_t nbins = mapping.GetBinNumber();
     ring_sum.assign(nbins, 0);
@@ -20,8 +20,11 @@ AdaptiveSpotFinderCPU::AdaptiveSpotFinderCPU(const AzimuthalIntegrationMapping &
     ring_sigma.assign(nbins, 0.0f);
     ring_thr.assign(nbins, 0.0f);
     ring_bkg.assign(nbins, NAN);
+    ring_bits.assign(OutputSize(), 0);
 }
 
+// Per-ring background statistics with iterated peak exclusion following peakfinder8:
+// Barty et al. (2014) J. Appl. Cryst. 47, 1118-1131
 // Accumulate per-ring mean/variance from the raw (photon) image. clip_k <= 0 -> use every valid
 // pixel (first pass); clip_k > 0 -> keep only pixels within clip_k sigma of the current ring mean,
 // which removes the Bragg peaks from the background estimate.
@@ -61,9 +64,7 @@ void AdaptiveSpotFinderCPU::AccumulateRings(const ImagePreprocessorBuffer &image
 
 void AdaptiveSpotFinderCPU::Detect(const ImagePreprocessorBuffer &image,
                                    const SpotFindingSettings &settings) {
-    const auto &pixel_to_bin = mapping.GetPixelToBin();
     const size_t nbins = ring_sum.size();
-    const size_t npix = static_cast<size_t>(width) * height;
 
     // --- Stage A: robust per-ring background (one plain pass + two sigma-clip passes) ---
     AccumulateRings(image, 0.0f);
@@ -104,9 +105,28 @@ void AdaptiveSpotFinderCPU::Detect(const ImagePreprocessorBuffer &image,
                           ? g_thr
                           : adaptive_threshold::RingThreshold(ring_mean[b], ring_sigma[b], p, z);
 
-    // --- Stage C: flag strong pixels into the bit buffer (value >= ring threshold) ---
+    // --- Stage C: the ring threshold, intersected with the classic local-box SNR test ---
+    FlagRings(image);
+
+    if (settings.signal_to_noise_threshold <= 0.0f) {
+        // No local test asked for: the ring threshold alone decides, as the fixed photon floor
+        // alone would in the classic finder.
+        output_buffer = ring_bits;
+        return;
+    }
+
+    // The ring threshold IS the photon floor here, so the local pass must not apply another one.
+    SpotFindingSettings local = settings;
+    local.photon_count_threshold = 0;
+    ImageSpotFinderCPU::Detect(image, local);
     for (size_t i = 0; i < OutputSize(); ++i)
-        output_buffer[i] = 0;
+        output_buffer[i] &= ring_bits[i];
+}
+
+void AdaptiveSpotFinderCPU::FlagRings(const ImagePreprocessorBuffer &image) {
+    const auto &pixel_to_bin = mapping.GetPixelToBin();
+    const size_t nbins = ring_thr.size();
+    const size_t npix = static_cast<size_t>(width) * height;
 
     std::bitset<32> out = 0;
     for (size_t pxl = 0; pxl < npix; ++pxl) {
@@ -122,10 +142,10 @@ void AdaptiveSpotFinderCPU::Detect(const ImagePreprocessorBuffer &image,
         if (strong)
             out.set(bit);
         if (bit == 31) {
-            output_buffer[pxl / 32] = out.to_ulong();
+            ring_bits[pxl / 32] = out.to_ulong();
             out.reset();
         }
     }
     if (npix % 32 != 0)
-        output_buffer[OutputSize() - 1] = out.to_ulong();
+        ring_bits[OutputSize() - 1] = out.to_ulong();
 }