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

+3 -1
View File
@@ -105,7 +105,9 @@ cell" (1982), J. Appl. Cryst. 15, 255-259
**[XDS](https://xds.mr.mpg.de/)** — rotation geometry and notation, the reciprocal Lorentz and
partiality treatment, the maximum-likelihood mosaicity estimate, the `MINPK` criterion for rejecting
a reflection whose predicted profile is not cleanly its own, the intensity-based test for a
centred lattice, and the scaling correction surfaces indexed by image number and detector region. W. Kabsch, "XDS" (2010), Acta Cryst. D66, 125-132
centred lattice, the recognition of shaded detector regions by comparing a pixel's background
against the background at its own resolution (`DEFPIX`), and the scaling correction surfaces
indexed by image number and detector region. W. Kabsch, "XDS" (2010), Acta Cryst. D66, 125-132
[doi:10.1107/S0907444909047337](https://doi.org/10.1107/S0907444909047337); W. Kabsch, "Integration,
scaling, space-group assignment and post-refinement" (2010), Acta Cryst. D66, 133-144
[doi:10.1107/S0907444909047374](https://doi.org/10.1107/S0907444909047374).
+35 -18
View File
@@ -1,9 +1,9 @@
# Beam-stop shadow finder
`ShadowFinder` detects the beam-stop shadow — the central **disk** plus its **holder arm** —
from a small number of images, and returns a per-pixel mask of the shadowed region. It exists
so the pipeline can mask the beam stop **automatically** instead of relying on a hand-drawn user
mask.
`ShadowFinder` detects shadowed detector regions — the beam stop's central **disk** and **holder
arm**, and any other hardware standing in the beam, such as a pin or a loop — from a small number
of images, and returns a per-pixel mask of the shadowed region. It exists so the pipeline can mask
them **automatically** instead of relying on a hand-drawn user mask.
It is written in the accumulate-then-finalize shape of `DarkMaskAnalysis`: feed frames with
`AddImage()`, then read the mask once with `GetMask()`. It is built as part of
@@ -48,28 +48,38 @@ own radius**, not to a global threshold.
Iterate 3×, excluding the shadow it finds, so the baseline is not pulled down by the shadow.
3. **Ratio.** `ratio = mean / baseline(r)`. Shadowed pixels sit far below 1; the smooth halo and
symmetric ice rings cancel to ≈1 and are **not** flagged.
4. **Core + connectivity.** `core = ratio < shadow_ratio`, then keep only the part **connected to
the beam centre** (flood from a small central seed through a `bridge_px`-dilated copy, so the
arm crosses module gaps). The centre anchor is what makes it specific to the beam stop rather
than any random low patch.
5. **Reflection guard.** A pixel whose **max**-projection reached `min_reflection` recorded a real
4. **Counting statistics.** A ratio on its own says nothing when the background it is made of is a
handful of photons, so the deficit is also required to be significant against its own Poisson
scatter: `sigma = sqrt(2 (E - N + N ln(N/E)))` for the pooled counts `N` observed against the
`E` the ring expects, cut at `min_deficit_sigma`. This is what makes the test scale-free — a
third of the background missing is overwhelming on a well-exposed sweep and is noise on six
low-background frames, and without it such a pre-scan masks three quarters of a detector.
5. **Core + size.** `core = ratio < shadow_ratio && sigma > min_deficit_sigma`, then keep only
components holding at least `min_shadow_pixels` core pixels (components taken through a
`bridge_px`-dilated copy, so the arm crosses module gaps). **Nothing anchors the region to the
beam centre**: hardware that shadows the detector need not touch the direct beam, and a pin or a
loop typically does not — it begins some way out in radius with lit detector between it and the
stop, which an anchored search discards however deep it is. Size is what makes the test specific
instead; the background wanders a pixel or two at a time, hardware does not.
6. **Reflection guard.** A pixel whose **max**-projection reached `min_reflection` recorded a real
reflection — a beam stop cannot block a reflection that was measured — so it is **never masked**
(a small-cluster test drops single-pixel zingers).
6. **Central disk (low-res guard).** From the azimuthal **blocked fraction** about the beam centre,
7. **Central disk (low-res guard).** From the azimuthal **blocked fraction** about the beam centre,
mask a full disk out to the radius where nearly every azimuth is blocked (a disk blocks all
directions; a thin arm/gap does not). Returns nothing when the centre is not behind a disk, and
is **capped just inside the innermost reflection** so a real edge spot is never swallowed. This
guards the low-resolution zone the stop makes un-measurable, including a disk the raw data has
already voided.
7. **Soft boundary.** Grow the core+disk into partially-shadowed pixels (`ratio < penumbra_ratio`)
8. **Soft boundary.** Grow the core+disk into partially-shadowed pixels (`ratio < penumbra_ratio`)
within `penumbra_max_px`, then a morphological close rounds the contour and hole-filling closes
the disk interior.
8. **Carve reflections last.** Remove any lit pixel from the final mask (no fill afterwards) so a
9. **Carve reflections last.** Remove any lit pixel from the final mask (no fill afterwards) so a
spot the geometry still covered is given back rather than re-enclosed.
Three findings from the prototype are baked in: the **mean** ratio (not the max) does the
detecting — the max projection is a great *picture* but a noisier detector; the **centre anchor**
is what distinguishes the stop from stray low patches; and **a lit pixel is never masked**.
Three findings are baked in: the **mean** ratio (not the max) does the detecting — the max
projection is a great *picture* but a noisier detector; **size and counting statistics**, not a
position, are what distinguish hardware from a stray low patch; and **a lit pixel is never
masked**.
Detection converges in **~2–3 frames** (the shadow cuts the halo present in every frame); 20–50 is
just safe headroom.
@@ -77,9 +87,11 @@ just safe headroom.
| field | default | meaning |
|---|---|---|
| `shadow_ratio` | 0.35 | core threshold: mean below this fraction of the radial baseline |
| `penumbra_ratio` | 0.72 | soft boundary grows out to this ratio … |
| `penumbra_max_px` | 14 | … but no further than this from the core |
| `shadow_ratio` | 0.50 | core threshold: mean below this fraction of the radial baseline |
| `min_deficit_sigma` | 6 | … and the deficit significant to this many Poisson standard deviations |
| `min_shadow_pixels` | 2000 | smallest region the per-pixel test may return |
| `penumbra_ratio` | 0.75 | soft boundary grows out to this ratio … |
| `penumbra_max_px` | 30 | … but no further than this from the core |
| `bridge_px` | 6 | bridge module gaps / breaks the arm crosses |
| `min_reflection` | 25 | max-projection value at/above which a pixel is a protected reflection |
@@ -136,6 +148,11 @@ beam-stop mask is an **offline** (Rugnux + viewer) feature and never goes to the
- **Off-centre disk**: the low-res disk guard keys on the *stored* beam centre. If that is off the
physical stop (seen on one stills detector), a small already-dead disk gets no extra circular
guard — a data-driven disk centre would close it.
- **A grossly wrong beam centre**: the rings are drawn about the centre in the file. A centre off by
tens of pixels costs nothing, but one off by a couple of hundred draws the rings across the
background's own fall-off rather than along it, and a large region then falls below the ratio for
reasons that have nothing to do with hardware. Measuring the centre before the shadow, rather than
after it, would close this.
- **Unsigned saturation**: for unsigned images a detector-saturating reflection collides with the
no-data sentinel and is skipped; harmless in practice (such reflections do not sit under the
stop), and absent entirely on the signed/preprocessed path.
+84 -45
View File
@@ -20,12 +20,13 @@
// A pixel is shadow when its background is below this fraction of the background it is
// compared against.
constexpr float SHADOW_RATIO = 0.35f;
constexpr float SHADOW_RATIO = 0.50f;
// The boundary grows outward into partially shadowed pixels down to this fraction, but no
// further than PENUMBRA_MAX_PX from the core.
constexpr float PENUMBRA_RATIO = 0.72f;
constexpr int PENUMBRA_MAX_PX = 14;
// further than PENUMBRA_MAX_PX from the core. A pin or a loop casts a wide half-shadow, so the
// reach is a good deal more than the beam stop's own edge needs.
constexpr float PENUMBRA_RATIO = 0.75f;
constexpr int PENUMBRA_MAX_PX = 30;
// Bridge module gaps and small breaks that the holder arm crosses.
constexpr int BRIDGE_PX = 6;
@@ -34,10 +35,18 @@ constexpr int BRIDGE_PX = 6;
// beam stop cannot block a reflection that was measured.
constexpr int64_t MIN_REFLECTION = 25;
// Counts the background must have accumulated over the frames and the pooled pixels before
// a dip in it is believable. Below this a Poisson hole is indistinguishable from a shadow,
// and testing anyway masks whole detectors on low-background data.
constexpr double MIN_EXPECTED_COUNTS = 60;
// How far below the background it is compared against a pixel must sit before the dip is
// believed, in standard deviations of the counts that back it. The counts are photons, so their
// scatter is Poisson and the deficit is measured against it rather than against a fixed number:
// on a well-exposed sweep a third of the background missing is overwhelming, and on a handful of
// low-background frames the same third is noise. Without this a six-frame pre-scan of a
// low-background sweep masks three quarters of the detector.
constexpr double MIN_DEFICIT_SIGMA = 6.0;
// Smallest region the per-pixel test may return. A shadow is cast by something physical and is
// correspondingly large; an isolated patch this small is the background wandering, not hardware.
// This is what keeps the test specific now that a shadow no longer has to touch the direct beam.
constexpr int MIN_SHADOW_PIXELS = 2000;
// Side of the box the background is pooled over before testing. Its area is how many pixels back
// a ring's countability test, which decides where an azimuthal comparison is possible at all.
@@ -47,10 +56,25 @@ constexpr double MEAN_POOLED_PIXELS = POOL_PX * POOL_PX;
// A ring with fewer valid pixels than this says nothing about whether it was counted.
constexpr int MIN_RING_PIXELS = 32;
// A ring lies wholly inside the stop when its background is below this fraction of the background
// further out. This asks about a whole ring rather than about a pixel, so it keeps a threshold of
// its own and does not follow SHADOW_RATIO.
constexpr float BLOCKED_RING_RATIO = 0.35f;
// Binary-image helpers on a width*height frame stored row-major as char (0/1). All run once,
// at GetMask() time; the BFS forms keep them O(pixels) rather than O(pixels * radius).
namespace {
// Deficit of an observed count against its expectation, in standard deviations, from the Poisson
// likelihood ratio. Zero when the observation is not below the expectation.
double poisson_deficit_sigma(double observed, double expected) {
if (expected <= 0.0 || observed >= expected)
return 0.0;
const double ll = 2.0 * (expected - observed
+ (observed > 0.0 ? observed * std::log(observed / expected) : 0.0));
return ll > 0.0 ? std::sqrt(ll) : 0.0;
}
// 8-connected dilation by `r` pixels, i.e. every pixel within Chebyshev distance r of a set one.
//
// This was a multi-source BFS, which is what the distance is defined by - but on a full rectangle
@@ -122,27 +146,6 @@ std::vector<char> erode(const std::vector<char> &in, int W, int H, int r, size_t
return out;
}
// Pixels of `passable` reachable from any of `seeds` (8-connected flood).
std::vector<char> flood(const std::vector<char> &passable, int W, int H, const std::vector<int> &seeds) {
std::vector<char> visited(passable.size(), 0);
std::queue<int> q;
for (const int s : seeds)
if (passable[s] && !visited[s]) { visited[s] = 1; q.push(s); }
while (!q.empty()) {
const int i = q.front(); q.pop();
const int y = i / W, x = i % W;
for (int dy = -1; dy <= 1; dy++)
for (int dx = -1; dx <= 1; dx++) {
const int yy = y + dy, xx = x + dx;
if (yy < 0 || yy >= H || xx < 0 || xx >= W)
continue;
const int j = yy * W + xx;
if (passable[j] && !visited[j]) { visited[j] = 1; q.push(j); }
}
}
return visited;
}
// Fill holes: background not reachable from the image border becomes region.
//
// The flood is run over the bounding box of `region` grown by one, not the whole detector. Outside
@@ -572,7 +575,9 @@ std::vector<uint32_t> ShadowFinder::GetMask(size_t nthreads) const {
// Azimuthal comparison: the median of the ring, iterated so the shadow stays out of the
// baseline it is measured against.
// baseline it is measured against. Comparing a pixel's background against the background at its
// own resolution is how DEFPIX recognises a shaded detector region.
// Following Kabsch (2010) Acta Cryst. D66, 125-132
//
// The iteration only ever excludes pixels whose pooled background is below a cut, and dividing by
// a positive baseline is monotone - so the excluded pixels of a ring are exactly the lowest ones,
@@ -636,36 +641,70 @@ std::vector<uint32_t> ShadowFinder::GetMask(size_t nthreads) const {
for (int rad = 0; rad <= max_radius; rad++) {
if (ring_pixels[rad] < MIN_RING_PIXELS)
continue;
if (baseline[rad] >= SHADOW_RATIO * outward_max[rad])
if (baseline[rad] >= BLOCKED_RING_RATIO * outward_max[rad])
break;
blocked_out_to = rad;
}
// The counts a pixel's pooled background is made of, and the counts the ring says it should
// have had. The test is on the deficit between them, in units of its own Poisson scatter.
std::vector<float> deficit(n_pixels, 0.0f);
std::vector<char> low(n_pixels, 0);
ParallelChunks(n_pixels, nthreads, [&](int lo, int hi) {
for (int i = lo; i < hi; i++) {
if (!valid[i])
continue;
if (radius[i] <= blocked_out_to) {
low[i] = 1;
continue;
}
const double counted = static_cast<double>(frames) * pooled_count[i];
low[i] = ratio[i] < SHADOW_RATIO && baseline[radius[i]] * counted >= MIN_EXPECTED_COUNTS;
deficit[i] = static_cast<float>(poisson_deficit_sigma(pooled[i] * counted,
baseline[radius[i]] * counted));
low[i] = ratio[i] < SHADOW_RATIO && deficit[i] > MIN_DEFICIT_SIGMA;
}
});
// The shadow is the low region connected to the beam centre, bridging the gaps it crosses.
// The shadow is a low region large enough to have been cast by something. Nothing anchors it to
// the beam centre: hardware that shadows the detector need not touch the direct beam, and a pin
// or a loop typically does not - it begins some way out in radius, with lit detector between it
// and the stop. What keeps the test specific instead is size, since the background wanders by a
// pixel or two at a time and hardware does not.
const std::vector<char> bridged = dilate(low, W, H, BRIDGE_PX, nthreads);
std::vector<int> seeds;
std::vector<char> region(n_pixels, 0);
{
std::vector<char> seen(n_pixels, 0);
std::vector<int> component;
std::queue<int> q;
for (int start = 0; start < n_pixels; start++) {
if (!bridged[start] || seen[start])
continue;
component.clear();
int n_low = 0;
seen[start] = 1;
q.push(start);
while (!q.empty()) {
const int i = q.front(); q.pop();
component.push_back(i);
n_low += low[i];
const int y = i / W, x = i % W;
for (int dy = -1; dy <= 1; dy++)
for (int dx = -1; dx <= 1; dx++) {
const int yy = y + dy, xx = x + dx;
if (yy < 0 || yy >= H || xx < 0 || xx >= W)
continue;
const int j = yy * W + xx;
if (bridged[j] && !seen[j]) { seen[j] = 1; q.push(j); }
}
}
if (n_low >= MIN_SHADOW_PIXELS)
for (const int i : component)
region[i] = low[i];
}
}
// The rings that lie wholly inside the stop are decided by the ring walk above rather than by
// the per-pixel test, so they join the region after it and are not asked to be large.
for (int i = 0; i < n_pixels; i++)
if (radius[i] < 4)
seeds.push_back(i);
const std::vector<char> connected = flood(bridged, W, H, seeds);
std::vector<char> region(n_pixels);
for (int i = 0; i < n_pixels; i++)
region[i] = low[i] && connected[i];
if (valid[i] && radius[i] <= blocked_out_to)
region[i] = 1;
// Recorded reflections. A small cluster is required so a single-frame zinger does not count.
@@ -695,7 +734,7 @@ std::vector<uint32_t> ShadowFinder::GetMask(size_t nthreads) const {
// Grow the soft boundary, round it and fill the disk interior.
const std::vector<char> penumbra = dilate(region, W, H, PENUMBRA_MAX_PX, nthreads);
for (int i = 0; i < n_pixels; i++)
if (penumbra[i] && valid[i] && ratio[i] < PENUMBRA_RATIO)
if (penumbra[i] && valid[i] && ratio[i] < PENUMBRA_RATIO && deficit[i] > MIN_DEFICIT_SIGMA)
region[i] = 1;
+10 -8
View File
@@ -1158,15 +1158,17 @@ void Rugnux::PreScan(int start_image, int images_to_process, int frame_count, Ru
const auto shadow = finder.GetMask(config_.nthreads);
const auto shadowed = std::count(shadow.begin(), shadow.end(), 1u);
pixel_mask_.LoadBeamStopMask(experiment_, shadow);
// Not "this beamline has no beam stop". The search floods outwards from seeds within 4 px of
// the ASSUMED beam centre, so a centre far enough out puts every seed in a module gap and the
// flood finds nothing - which makes an empty shadow a statement about the centre. It is the
// sharpest free predicate there is: over 29 non-SLS datasets it fires on 3, all 3 of which had
// a bad outcome, with no false alarm in 39 in-house sweeps (which report 0.44-1.51 % masked).
// Not "this beamline has no beam stop". Every pixel is compared against the ring it sits on,
// and the rings are drawn about the beam centre in the file: a centre far enough out draws
// them across the background's own fall-off instead of along it, and what comes back stops
// describing the hardware. That reads both ways - it has been seen as an empty mask, and on
// a deliberately displaced centre as a large spurious one - so an unexpected answer here is
// worth reading as a statement about the centre first.
if (shadowed == 0)
logger.Warning("Beam stop: no shadow found in {} images. The search starts from the beam "
"centre in the file, so this points at that centre rather than at the "
"experiment; --estimate-beam-center measures it", finder.GetFrameCount());
logger.Warning("Beam stop: no shadow found in {} images. The comparison is made around "
"the beam centre in the file, so this may point at that centre rather "
"than at the experiment; --estimate-beam-center measures it",
finder.GetFrameCount());
else
logger.Info("Beam stop shadow: {} pixels ({:.2f}% of the detector) found in {} images",
shadowed, 100.0 * static_cast<double>(shadowed) / static_cast<double>(shadow.size()),
+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);
}