beam stop: a shadow does not have to touch the direct beam

The shadow finder kept only the low region connected to the beam centre, flooding
outward from seeds within 4 px of it. That is written for the beam stop and its
holder arm, an object that touches the direct beam. Hardware that stands in the
beam further out - a pin, a loop - casts a shadow that begins some way out in
radius, with lit detector between it and the stop, and no bridge crosses that gap.
On a sweep where such a shadow covers 38 % of the detector the per-ring test found
the whole of it and connectivity then discarded 950 k pixels, leaving the beam-stop
disk alone; those pixels went into integration as measured-and-near-zero.

What makes the test specific instead is size: keep the connected components that
hold at least MIN_SHADOW_PIXELS core pixels. A shadow is cast by something physical
and is correspondingly large, while the background wanders a pixel or two at a time.
Measured on five clean in-house sweeps spanning 0.05 to 9.5 counts/px/frame of
background, every one returns exactly one such component - the beam stop - and the
largest spurious candidate anywhere is 74 pixels, a 27x margin.

MIN_EXPECTED_COUNTS becomes a Poisson significance. A ratio says nothing when the
background behind it is a handful of photons, so the deficit is now required to be
significant against its own scatter, sqrt(2 (E - N + N ln(N/E))) over the pooled
counts. This is what makes the comparison scale-free rather than tuned to one
exposure: rebuilt from six frames of a low-background sweep, the same thresholds
without it mask three quarters of the detector and with it mask none of it. The
index of dispersion, measured over the frames, does NOT do this job - it is 1.0
inside the shadow and 1.0 outside it, because a shadowed pixel is Poisson at a low
rate and a lit one is Poisson at a high rate. Only the rate relative to the ring
separates them.

The rest follows: the core ratio moves 0.35 -> 0.50 and the half-shadow reach 0.72
within 14 px -> 0.75 within 30 px, since a pin's penumbra is much wider than a beam
stop edge's; the ring walk that finds the rings lying wholly inside the stop keeps
its own threshold so the central disk does not move; and those rings join the region
after the size filter rather than being asked to be large themselves.

On the shadowed sweep this takes the mask from 16,587 px (0.66 %) to 818,184 px
(32.32 %), against 956,705 px (37.79 %) for the reference implementation, at a
precision of 0.92 against it. Clean sweeps move from 0.60 % to 0.82 %, the width of
the same arm.

One thing this costs: an empty mask used to be a statement about the beam centre,
because the seeds were placed at it. It no longer is, and a centre wrong by a couple
of hundred pixels now draws the rings across the background's own fall-off and
returns a large spurious mask instead of an empty one. The log message says so. The
fix is ordering - the centre is measured from this same projection a moment later -
and is not attempted here.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
This commit is contained in:
leonarski_fandClaude Opus 5 committed 2026-09-13 07:36:57 +02:00
1 parent 591c8cbc4b
commit d412306c77
5 files changed
+188 -73

No files matched your search

+56 -1
View File
@@ -103,7 +103,7 @@ TEST_CASE("ShadowFinder_FindsAnInjectedBeamStop", "[ShadowFinder]") {
// Pinned from the serial implementation. A rewrite of the dilation, the hole fill or the ring
// median that moves the mask by one pixel fails here, rather than in a merging statistic
// several stages downstream.
CHECK(std::count(mask.begin(), mask.end(), 1u) == 2669);
CHECK(std::count(mask.begin(), mask.end(), 1u) == 2612);
}
// The per-pixel passes are split across threads, so where the split falls must not be visible in the
@@ -175,3 +175,58 @@ TEST_CASE("ShadowFinder_ASymmetricSceneGivesASymmetricMask", "[ShadowFinder]") {
}
}
}
// Hardware that shadows the detector need not touch the direct beam: a pin or a loop begins some way
// out in radius, with lit detector between it and the stop. The scene here is that - a beam stop
// with its arm, and a separate opaque patch far from both - and the patch has to come back as
// shadow. Anchoring the search at the beam centre, as an earlier version did, returned the stop and
// discarded the patch however deep it was.
TEST_CASE("ShadowFinder_FindsAShadowThatDoesNotTouchTheBeam", "[ShadowFinder]") {
const DiffractionExperiment x = TestExperiment();
const PixelMask pixel_mask(x);
ShadowFinder finder(x, pixel_mask);
// Well clear of the stop, and wide enough that the ring it sits on still has lit pixels to be
// compared against - as a real pin shadow does, covering part of a ring and not all of it.
constexpr int PATCH_X0 = 175, PATCH_X1 = 245, PATCH_Y0 = 30, PATCH_Y1 = 90;
std::vector<std::vector<int32_t>> frames;
std::vector<uint8_t> buffer;
for (int f = 0; f < NFRAMES; f++) {
frames.push_back(Scene(/*cross=*/false, /*reflection=*/false));
for (int y = PATCH_Y0; y <= PATCH_Y1; y++)
for (int xi = PATCH_X0; xi <= PATCH_X1; xi++)
frames.back()[I(xi, y)] = 0;
DataMessage msg{};
msg.image = CompressedImage(frames.back(), W, H);
finder.AddImage(msg, buffer);
}
const auto mask = finder.GetMask();
CHECK(mask[I((PATCH_X0 + PATCH_X1) / 2, (PATCH_Y0 + PATCH_Y1) / 2)] == 1);
CHECK(mask[I(PATCH_X0 + 5, PATCH_Y0 + 5)] == 1);
CHECK(mask[I(C, C)] == 1); // the stop is still found
CHECK(mask[I(PATCH_X0 - 40, PATCH_Y0)] == 0); // and the lit detector between them is kept
CHECK(mask[I(0, H - 1)] == 0);
}
// A flat, unobstructed scene has no shadow in it. The per-pixel test no longer has to reach the
// beam centre, so what keeps it from calling a wandering background a shadow is size alone - and
// that has to hold on a scene where nothing is blocked at all.
TEST_CASE("ShadowFinder_FindsNothingOnAnUnobstructedScene", "[ShadowFinder]") {
const DiffractionExperiment x = TestExperiment();
const PixelMask pixel_mask(x);
ShadowFinder finder(x, pixel_mask);
std::vector<std::vector<int32_t>> frames;
std::vector<uint8_t> buffer;
for (int f = 0; f < NFRAMES; f++) {
frames.emplace_back(static_cast<size_t>(W) * H, BACKGROUND);
DataMessage msg{};
msg.image = CompressedImage(frames.back(), W, H);
finder.AddImage(msg, buffer);
}
const auto mask = finder.GetMask();
CHECK(std::count(mask.begin(), mask.end(), 1u) == 0);
}