@mohasinac/appkit 4.52.5 → 4.53.1

package/dist/_internal/shared/features/sticker-trace/trace/ridge.js

@@ -0,0 +1,344 @@
+/*
+ * WHY: This is the measurement the whole tool rests on, and the reason it
+ *      replaced the previous colour-threshold approach.
+ *
+ *      A kiss cut is a physical impression in the sheet, so under a scanner it
+ *      reads as a DOUBLET — a dark trough beside a light ridge — regardless of
+ *      what colour sits either side of it. Sampling four scanlines across known
+ *      cut lines on the reference scans, detrended against a local median:
+ *
+ *        yellow panel on yellow : luminance 173-240, doublet -40/+27, noise +-2
+ *        red field on red       : luminance  98-127, ridge      +22, noise +-1
+ *        white sticker on cream : luminance   6-224, spikes +75/+103, noise +-7
+ *        halftone green panel   : luminance  93-161, ridge +18..+47, noise +-6
+ *
+ *      The first two are the cases that defeated colour thresholding entirely —
+ *      there is no colour edge to find — and the doublet is 10-20x noise in
+ *      both. The third is the "white fades into the paper" failure: the colour
+ *      is gone but the cut line is still there at 10x. Only the halftone scan is
+ *      marginal, at ~3x, which is what the prefilter and the second detector
+ *      channel exist for.
+ * WHAT: Detrended local-range ridge detection with hysteresis linking.
+ *
+ * EXPORTS: RidgeResult, detectRidges
+ *
+ * @tag domain:sticker-trace
+ * @tag layer:shared
+ * @tag pattern:none
+ * @tag access:isomorphic
+ * @tag consumers:fuse,segment
+ * @tag sideEffects:none
+ */
+/**
+ * Separable box blur with running sums — O(n) regardless of radius.
+ *
+ * Used only to estimate the local BACKGROUND level, never to smooth the signal.
+ * A mean is the right tool here precisely because the cut line is thin: it
+ * barely moves a large-window mean, so subtracting that mean leaves the line
+ * standing while removing the gradient underneath it.
+ */
+function boxBlur(src, width, height, radius) {
+    const tmp = new Float32Array(src.length);
+    const out = new Float32Array(src.length);
+    const window = radius * 2 + 1;
+    for (let y = 0; y < height; y++) {
+        const row = y * width;
+        let sum = 0;
+        for (let i = -radius; i <= radius; i++) {
+            sum += src[row + Math.min(width - 1, Math.max(0, i))];
+        }
+        for (let x = 0; x < width; x++) {
+            tmp[row + x] = sum / window;
+            const outX = Math.min(width - 1, Math.max(0, x - radius));
+            const inX = Math.min(width - 1, Math.max(0, x + radius + 1));
+            sum += src[row + inX] - src[row + outX];
+        }
+    }
+    for (let x = 0; x < width; x++) {
+        let sum = 0;
+        for (let i = -radius; i <= radius; i++) {
+            sum += tmp[Math.min(height - 1, Math.max(0, i)) * width + x];
+        }
+        for (let y = 0; y < height; y++) {
+            out[y * width + x] = sum / window;
+            const outY = Math.min(height - 1, Math.max(0, y - radius));
+            const inY = Math.min(height - 1, Math.max(0, y + radius + 1));
+            sum += tmp[inY * width + x] - tmp[outY * width + x];
+        }
+    }
+    return out;
+}
+/**
+ * Hysteresis: seed at `high`, grow through anything above `low`.
+ *
+ * 🛑 This is what makes a FAINT but CONTINUOUS line beat a BRIGHT but isolated
+ * speck, which is the entire discrimination the detector needs. A single
+ * threshold cannot express it: set high enough to reject scanner speckle and
+ * the halftone scan's cut line disappears; set low enough to keep that line and
+ * every rosette dot becomes a barrier.
+ *
+ * Iterative with an explicit stack rather than recursion — a connected ridge on
+ * a 9 MP raster can run to hundreds of thousands of pixels.
+ */
+function hysteresis(response, width, height, low, high) {
+    const lowField = new Float32Array(response.length).fill(low);
+    const highField = new Float32Array(response.length).fill(high);
+    return hysteresisField(response, width, height, lowField, highField);
+}
+/**
+ * Hysteresis where each pixel carries its own pair of thresholds.
+ *
+ * The growth rule compares a candidate against the threshold at the CANDIDATE's
+ * position, not the seed's. That matters where a cut line crosses from a flat
+ * field into busy artwork: the line stays linked because each pixel is judged
+ * against its own surroundings, whereas carrying the seed's threshold along
+ * would either break the line at the boundary or flood the busy side.
+ */
+function hysteresisField(response, width, height, low, high) {
+    const out = new Uint8Array(response.length);
+    const stack = [];
+    for (let i = 0; i < response.length; i++) {
+        if (response[i] >= high[i]) {
+            out[i] = 1;
+            stack.push(i);
+        }
+    }
+    while (stack.length > 0) {
+        const i = stack.pop();
+        const x = i % width;
+        const y = (i / width) | 0;
+        // 8-connected growth, deliberately wider than the 4-connectivity used for
+        // components: a scanned line steps diagonally all the time, and refusing to
+        // follow it there would break the barrier at every stair-step.
+        for (let dy = -1; dy <= 1; dy++) {
+            const ny = y + dy;
+            if (ny < 0 || ny >= height)
+                continue;
+            for (let dx = -1; dx <= 1; dx++) {
+                const nx = x + dx;
+                if (nx < 0 || nx >= width)
+                    continue;
+                const j = ny * width + nx;
+                if (out[j] || response[j] < low[j])
+                    continue;
+                out[j] = 1;
+                stack.push(j);
+            }
+        }
+    }
+    return out;
+}
+/**
+ * Detect cut lines.
+ *
+ * Three steps, each answering one objection to the previous:
+ *
+ *   1. DETREND. Subtract a large-window mean. Without this, the detector sees
+ *      the airbrushed gradient under a sticker as a huge slow ramp and the cut
+ *      line as a rounding error on top of it. This is the step that exposed the
+ *      signal in the measurements above.
+ *   2. LOCAL RANGE. The doublet's signature is that a trough and a ridge sit
+ *      within a pixel or two of each other, so the local max-minus-min of the
+ *      detrended field is large on a cut line and ~0 on flat ink. A plain
+ *      gradient magnitude would fire equally on one-sided edges; the range
+ *      specifically rewards the paired shape an impression makes.
+ *   3. HYSTERESIS. Continuity beats amplitude — see above.
+ */
+/**
+ * A ROBUST estimate of "the typical response around here".
+ *
+ * 🛑 Robust is the operative word, and it is a measured correction. The first
+ * version used `localMean + k * localStdDev` over a 48px window, and on the
+ * `torch pegases` sheet that detected 0 of 10 cut-line pixels where the
+ * absolute threshold had found 10 — because the white "Gyro Engine" lettering
+ * inside the window inflated the standard deviation far above the cut line it
+ * sat next to. A mean and an SD are both wrecked by one bright feature, and
+ * printed artwork is nothing but bright features.
+ *
+ * So: block-average down by 8, MEDIAN-filter at that coarse scale, then
+ * bilinearly upsample. The median discards the lettering outright instead of
+ * averaging it in, and doing it on a 1/64-size grid makes a genuine median
+ * affordable — the same filter at full resolution would cost more than every
+ * other stage combined.
+ */
+function robustLocalBackground(response, width, height) {
+    const SHRINK = 8;
+    const cw = Math.max(1, Math.ceil(width / SHRINK));
+    const ch = Math.max(1, Math.ceil(height / SHRINK));
+    const coarse = new Float32Array(cw * ch);
+    for (let cy = 0; cy < ch; cy++) {
+        for (let cx = 0; cx < cw; cx++) {
+            let sum = 0;
+            let n = 0;
+            for (let y = cy * SHRINK; y < Math.min(height, (cy + 1) * SHRINK); y++) {
+                for (let x = cx * SHRINK; x < Math.min(width, (cx + 1) * SHRINK); x++) {
+                    sum += response[y * width + x];
+                    n++;
+                }
+            }
+            coarse[cy * cw + cx] = n > 0 ? sum / n : 0;
+        }
+    }
+    // Median over a 7x7 coarse window — ~56px at full resolution, wider than any
+    // cut line and narrower than any sticker.
+    const R = 3;
+    const smoothed = new Float32Array(cw * ch);
+    const buf = new Float32Array((R * 2 + 1) ** 2);
+    for (let cy = 0; cy < ch; cy++) {
+        for (let cx = 0; cx < cw; cx++) {
+            let n = 0;
+            for (let dy = -R; dy <= R; dy++) {
+                const sy = Math.min(ch - 1, Math.max(0, cy + dy));
+                for (let dx = -R; dx <= R; dx++) {
+                    const sx = Math.min(cw - 1, Math.max(0, cx + dx));
+                    buf[n++] = coarse[sy * cw + sx];
+                }
+            }
+            const slice = buf.subarray(0, n);
+            slice.sort();
+            smoothed[cy * cw + cx] = slice[n >> 1];
+        }
+    }
+    const out = new Float32Array(response.length);
+    for (let y = 0; y < height; y++) {
+        const fy = Math.min(ch - 1, y / SHRINK);
+        const y0 = Math.floor(fy);
+        const y1 = Math.min(ch - 1, y0 + 1);
+        const ty = fy - y0;
+        for (let x = 0; x < width; x++) {
+            const fx = Math.min(cw - 1, x / SHRINK);
+            const x0 = Math.floor(fx);
+            const x1 = Math.min(cw - 1, x0 + 1);
+            const tx = fx - x0;
+            const a = smoothed[y0 * cw + x0] * (1 - tx) + smoothed[y0 * cw + x1] * tx;
+            const b = smoothed[y1 * cw + x0] * (1 - tx) + smoothed[y1 * cw + x1] * tx;
+            out[y * width + x] = a * (1 - ty) + b * ty;
+        }
+    }
+    return out;
+}
+/**
+ * Hysteresis against a LOCAL threshold rather than a global one.
+ *
+ * 🛑 This replaced both a fixed-value and a fixed-percentile threshold, and the
+ * measurements that killed each are worth keeping:
+ *
+ *   absolute (low=9, high=18)  — barrier coverage 34-61% across the corpus. The
+ *     median response spans 0.1 (Driger: clean paper) to 14.1 (Poseidon: JPEG
+ *     cream field), so one pair of numbers is simultaneously far too low for
+ *     one scan and far too high for another.
+ *   percentile (p60/p80)       — coverage pinned at ~38% on EVERY scan, which is
+ *     what a quantile does by construction rather than what a detector does.
+ *     Worse, Poseidon's cream-field cut line (response 12-16) fell below that
+ *     scan's own p60 and vanished completely.
+ *
+ * The second failure is the informative one: a response of 12-16 is plainly a
+ * line on a flat cream field and plainly noise inside dense artwork, so NO
+ * single global number can separate them. Significance is local, so the
+ * threshold is local — Niblack/Sauvola-style, `localMean + k * localStdDev`
+ * over a window much larger than a cut line but much smaller than a sticker.
+ *
+ * Both statistics come from box blurs (mean, and mean-of-squares for the
+ * variance), so the whole thing stays O(n) and independent of window size.
+ */
+/**
+ * Threshold ANY response field against its own robust local background.
+ *
+ * Exported because the art path feeds it a Hessian line response rather than
+ * this module's edge response — the thresholding policy (local, robust,
+ * hysteresis-linked) is right for both and must not be written twice.
+ */
+export function thresholdAdaptive(response, width, height, kLow, kHigh) {
+    return adaptiveHysteresis(response, width, height, kLow, kHigh);
+}
+function adaptiveHysteresis(response, width, height, kLow, kHigh, assist, assistWeight = 0) {
+    const background = robustLocalBackground(response, width, height);
+    const lowField = new Float32Array(response.length);
+    const highField = new Float32Array(response.length);
+    for (let i = 0; i < response.length; i++) {
+        const bg = background[i];
+        // Multiplicative, not additive. The response is a local CONTRAST measure,
+        // so its scale rides with how busy the neighbourhood is; "k standard
+        // deviations above the mean" assumes a spread that printed artwork does not
+        // have. "A few times the typical local contrast" does hold across the
+        // corpus. The floors keep a perfectly flat region (Driger's paper sits at a
+        // median response of 0.1) from treating 8-bit quantisation as signal.
+        //
+        // 🛑 The assist LOWERS the bar; it never clears it. Where the colour
+        // channel also sees a boundary the ridge only has to be `1 - weight` as
+        // convincing — so a marginal ridge on the halftone sheet links, while a
+        // pure colour change with NO ridge behind it still fails both thresholds
+        // and does not become a cut line. Letting the assist seed on its own would
+        // turn every gradient band inside a sticker into an outline.
+        const relief = assist && assist[i] ? 1 - assistWeight : 1;
+        lowField[i] = Math.max(3, bg * kLow * relief);
+        highField[i] = Math.max(6, bg * kHigh * relief);
+    }
+    return hysteresisField(response, width, height, lowField, highField);
+}
+/**
+ * Detect cut lines.
+ *
+ * 🛑 Thresholds are PERCENTILES of this scan's own response, not absolute
+ * luminance values, and that is a measured correction rather than a
+ * preference. Across the reference corpus the median response spans two orders
+ * of magnitude — 0.1 on the Driger G sheet (clean white paper, almost no
+ * texture) against 14.1 on the Poseidon scan (JPEG, printed cream field) — so
+ * any fixed pair of numbers is simultaneously far too high for one scan and far
+ * too low for another. Measured with absolute low=9/high=18, barrier coverage
+ * came out between 34% and 61%, which floods nothing.
+ *
+ * The cut line is only ~2.8-3.2x the median on the two hardest sheets, so the
+ * separation that matters is NOT cut-line-versus-artwork — a logo edge is a
+ * genuine edge and will exceed a cut line. It is cut-line-versus-BACKGROUND.
+ * Interior artwork edges joining the barrier is harmless: the flood arrives
+ * from outside and is already stopped by the outer cut line before it can ever
+ * reach them.
+ *
+ * Three steps, each answering one objection to the previous:
+ *
+ *   1. DETREND. Subtract a large-window mean. Without this the detector sees
+ *      the airbrushed gradient under a sticker as a huge slow ramp and the cut
+ *      line as a rounding error on top of it. This is the step that exposed the
+ *      signal in the measurements above.
+ *   2. LOCAL RANGE. The doublet's signature is a trough and a ridge within a
+ *      pixel or two of each other, so the local max-minus-min of the detrended
+ *      field is large on a cut line and ~0 on flat ink. A plain gradient
+ *      magnitude fires equally on one-sided edges; the range specifically
+ *      rewards the paired shape an impression makes.
+ *   3. HYSTERESIS. Continuity beats amplitude — see above.
+ */
+export function detectRidges(luma, width, height, opts) {
+    const detrendRadius = Math.max(3, Math.round(7 * opts.kernelScale));
+    const background = boxBlur(luma, width, height, detrendRadius);
+    const dev = new Float32Array(luma.length);
+    for (let i = 0; i < dev.length; i++)
+        dev[i] = luma[i] - background[i];
+    const rangeRadius = Math.max(1, Math.round(opts.kernelScale));
+    const response = new Float32Array(luma.length);
+    for (let y = 0; y < height; y++) {
+        for (let x = 0; x < width; x++) {
+            let min = Infinity;
+            let max = -Infinity;
+            for (let dy = -rangeRadius; dy <= rangeRadius; dy++) {
+                const sy = Math.min(height - 1, Math.max(0, y + dy));
+                for (let dx = -rangeRadius; dx <= rangeRadius; dx++) {
+                    const sx = Math.min(width - 1, Math.max(0, x + dx));
+                    const v = dev[sy * width + sx];
+                    if (v < min)
+                        min = v;
+                    if (v > max)
+                        max = v;
+                }
+            }
+            response[y * width + x] = max - min;
+        }
+    }
+    const barrier = opts.absolute
+        ? hysteresis(response, width, height, opts.absolute.low, opts.absolute.high)
+        : adaptiveHysteresis(response, width, height, opts.low, opts.high, opts.assist, opts.assistWeight ?? 0);
+    let set = 0;
+    for (let i = 0; i < barrier.length; i++)
+        set += barrier[i];
+    return { response, barrier, coverage: set / barrier.length };
+}

package/dist/_internal/shared/features/sticker-trace/trace/segment.d.ts

@@ -0,0 +1,10 @@
+import { type ComponentStats } from "../math/label";
+import type { DecodedRaster, TraceDiagnostics, TraceParams } from "../types";
+export interface SegmentResult {
+    /** Per-pixel component id; 0 is background. */
+    readonly labels: Int32Array;
+    /** Surviving components, in label order. */
+    readonly parts: readonly ComponentStats[];
+    readonly diagnostics: TraceDiagnostics;
+}
+export declare function segmentSheet(raster: DecodedRaster, params: TraceParams): SegmentResult;

package/dist/_internal/shared/features/sticker-trace/trace/segment.js

@@ -0,0 +1,251 @@
+/*
+ * WHY: The pipeline from pixels to "here are the N stickers" has to be ONE
+ *      ordered sequence, because several of its steps are only correct in a
+ *      particular order and each ordering mistake fails silently.
+ * WHAT: paper -> prefilter -> quantise -> ridge(+assist) -> flood -> clean ->
+ *       label -> filter.
+ *
+ * 🛑 Fusion is implemented as the ridge detector's `assist` parameter rather
+ * than a separate `fuse` stage. A standalone module would have had to
+ * re-derive the ridge's own local-background field to know what "lower the
+ * bar" means, and two copies of that estimate is the drift this codebase keeps
+ * paying for (Root Cause #42/#75). The POLICY is documented at the assist
+ * branch in trace/ridge; this file only decides whether to supply it.
+ *
+ * EXPORTS: SegmentResult, segmentSheet
+ *
+ * @tag domain:sticker-trace
+ * @tag layer:shared
+ * @tag pattern:none
+ * @tag access:isomorphic
+ * @tag consumers:index,geometry,cluster
+ * @tag sideEffects:none
+ */
+import { labelComponents } from "../math/label.js";
+import { close, curvatureSmooth } from "../math/morphology.js";
+import { backgroundLikeMask, estimatePaper } from "./paper.js";
+import { sameMaterialScore } from "./cross-profile.js";
+import { floodFromBorder } from "./flood.js";
+import { mergeWeakBoundaries } from "./merge.js";
+import { applyPrefilter, toLuminance } from "./prefilter.js";
+import { quantiseBoundaries } from "./quantise.js";
+import { detectLines } from "./line-filter.js";
+import { detectRidges, thresholdAdaptive } from "./ridge.js";
+/**
+ * Re-derive per-component stats after a merge.
+ *
+ * The merge renumbers labels but cannot cheaply maintain areas and boxes — two
+ * merged regions' boxes are not the union of their stats unless you track it,
+ * and tracking it through union-find is more code than one more linear pass
+ * over a buffer already in cache.
+ */
+function recomputeStats(labels, count, width, height) {
+    const area = new Int32Array(count + 1);
+    const minX = new Int32Array(count + 1).fill(width);
+    const minY = new Int32Array(count + 1).fill(height);
+    const maxX = new Int32Array(count + 1).fill(-1);
+    const maxY = new Int32Array(count + 1).fill(-1);
+    const border = new Uint8Array(count + 1);
+    for (let y = 0; y < height; y++) {
+        for (let x = 0; x < width; x++) {
+            const l = labels[y * width + x];
+            if (l === 0)
+                continue;
+            area[l] = area[l] + 1;
+            if (x < minX[l])
+                minX[l] = x;
+            if (y < minY[l])
+                minY[l] = y;
+            if (x > maxX[l])
+                maxX[l] = x;
+            if (y > maxY[l])
+                maxY[l] = y;
+            if (x === 0 || y === 0 || x === width - 1 || y === height - 1)
+                border[l] = 1;
+        }
+    }
+    const stats = [];
+    for (let l = 1; l <= count; l++) {
+        if (area[l] === 0)
+            continue;
+        const bbox = {
+            x: minX[l],
+            y: minY[l],
+            width: maxX[l] - minX[l] + 1,
+            height: maxY[l] - minY[l] + 1,
+        };
+        stats.push({ label: l, area: area[l], bbox, touchesBorder: border[l] === 1 });
+    }
+    return { labels, count, stats };
+}
+/**
+ * A component covering more than this fraction of the raster is the SHEET, not
+ * a sticker — it means the flood never got in, usually because the barrier
+ * sealed the border or the scan has no background at all.
+ *
+ * Dropping it is right, and reporting it is what makes the failure legible:
+ * without the count in diagnostics, "the flood failed" and "this sheet has no
+ * stickers" look identical downstream.
+ *
+ * 🛑 KNOWN UNSUPPORTED, measured rather than assumed: a MONTAGE of several
+ * full-bleed sheets in one scan. `@ShayBlader Scan 18` is six sticker sheets in
+ * a 2x3 grid, each printed edge-to-edge in a different colour, white gutters
+ * between. At `standard` it returns ZERO parts by both models —
+ *
+ *     paper path   6 components, 1 sheet-sized, 5 specks, backgroundCoverage 7.8%
+ *     art path     1060 components, 1059 below the minimum area
+ *
+ * — because `estimatePaper` samples the outer frame and the gutters, gets
+ * 253,253,253, and reports `paper` for a scan that has no single background
+ * colour: the orange panel and the green panel disagree, and one estimate is
+ * wrong for five of the six.
+ *
+ * A projection-profile panel splitter was built for this and REVERTED. Measured
+ * over the corpus it was wrong in both directions at once: the montage still
+ * read as 1 panel, while single-sheet `driger G` (15 parts today) split into 5
+ * and `6894368129` into 2. The threshold had no separation to stand on — the
+ * highest non-gutter row reached 0.918 against a 0.92 cut-off, a margin of
+ * 0.002. Tightening it is the shape of tuning a constant until the numbers
+ * flatter it; the model is wrong for a montage, not the constant.
+ *
+ * So the honest handling is to DETECT and REPORT it — one sheet-sized component
+ * plus a low `backgroundCoverage` is the signature — and tell the admin to scan
+ * sheets individually or crop the montage. Every scan the user produces
+ * themselves is a single sheet; this one came from a third party.
+ */
+const MAX_PART_FRACTION = 0.6;
+export function segmentSheet(raster, params) {
+    const { width, height } = raster;
+    const pxPerMm = raster.dpi ? raster.dpi / 25.4 : null;
+    const paper = estimatePaper(raster, params.scanType);
+    const luma = toLuminance(raster);
+    const filtered = applyPrefilter(luma, width, height, params.prefilter, params.prefilterRadius);
+    // Quantisation reads the PREFILTERED-era raster conceptually, but operates on
+    // colour, so it takes the original pixels. The ordering that matters is that
+    // the prefilter has already decided how much halftone survives into the
+    // luminance channel the ridge reads; the colour channel is independent and
+    // posterises the sheet's real flat regions either way.
+    const quant = params.quantiseEnabled
+        ? quantiseBoundaries(raster, params.quantiseColours)
+        : null;
+    const ridge = detectRidges(filtered, width, height, {
+        low: params.ridgeHysteresisLow,
+        high: params.ridgeHysteresisHigh,
+        kernelScale: params.ridgeKernelScale,
+        ...(quant ? { assist: quant.boundary, assistWeight: params.quantiseWeight } : {}),
+    });
+    /*
+     * 🛑 TWO SEGMENTATION MODELS, and the choice is not a tuning preference.
+     *
+     * A PAPER sheet has real background: the flood starts outside every sticker
+     * and anything it cannot reach is a sticker. Interior artwork edges are
+     * harmless because the outer cut line stops the flood long before it reaches
+     * them.
+     *
+     * An ART sheet has none. The printed field runs to the raster edge, so the
+     * flood starts INSIDE the artwork, gets trapped in every pocket the artwork's
+     * own edges enclose, and emits each pocket as a part. Measured: 209 parts
+     * against ~12 real on torch-pegases, and a threshold sweep down to 1.0%
+     * barrier coverage still gave 36 — monotonic, no minimum. The model is wrong
+     * there, not the constants.
+     *
+     * So an art sheet is segmented by partitioning on the cut lines and then
+     * merging back across the weak ones. See trace/merge.
+     */
+    let labelled;
+    let beforeBridge;
+    let merges = 0;
+    let sameMaterialDropped = 0;
+    /*
+     * 1 on the art path, where the flood never runs and the question of "was
+     * there anything to flood through" does not arise. Reporting 0 there would
+     * read as a failure on every art sheet.
+     */
+    let backgroundCoverage = 1;
+    if (paper.detectedType === "art") {
+        /*
+         * 🛑 A LINE filter, not the edge detector the paper path uses.
+         *
+         * Measured on torch-pegases, as the percentile a known cut-line pixel
+         * reaches against a known artwork edge:
+         *
+         *   edge detector (local range)   cuts p77.3  artwork p71.3   sep  5.9
+         *   line filter   (Hessian)       cuts p69.2  artwork p50.2   sep 19.0
+         *
+         * The artwork drops from the 71st percentile to the 50th while the cuts
+         * hold, which is the whole difference: a groove has large curvature at its
+         * centre, a step edge has a zero crossing there.
+         */
+        const lines = detectLines(filtered, width, height);
+        const lineBarrier = thresholdAdaptive(lines.response, width, height, params.ridgeHysteresisLow, params.ridgeHysteresisHigh);
+        const material = sameMaterialScore(raster, lineBarrier, filtered, params.paperTolerance * 2);
+        sameMaterialDropped = Math.round(material.meanScore * 1000);
+        const open = new Uint8Array(width * height);
+        for (let i = 0; i < open.length; i++)
+            open[i] = lineBarrier[i] ? 0 : 1;
+        const regions = labelComponents(open, width, height);
+        beforeBridge = regions.count;
+        const merged = mergeWeakBoundaries(regions.labels, regions.count, material.score, width, height, params.mergeStrengthFactor);
+        merges = merged.mergesApplied;
+        labelled = recomputeStats(merged.labels, merged.regionCount, width, height);
+    }
+    else {
+        const backgroundLike = backgroundLikeMask(raster, paper, params.paperTolerance);
+        let bgCount = 0;
+        for (let i = 0; i < backgroundLike.length; i++)
+            if (backgroundLike[i])
+                bgCount++;
+        backgroundCoverage = bgCount / (width * height);
+        const flood = floodFromBorder(backgroundLike, ridge.barrier, width, height, params.seedBandPx);
+        // Clean in this order: smooth the silhouette first so the bridge closing is
+        // not fighting comb teeth, then bridge. Reversing them bridges the teeth to
+        // each other and fuses neighbours.
+        let mask = curvatureSmooth(flood.inside, width, height, pxPerMm ? params.smoothMm * pxPerMm : 1);
+        beforeBridge = labelComponents(mask, width, height).count;
+        if (params.bridgeMm > 0) {
+            mask = close(mask, width, height, pxPerMm ? params.bridgeMm * pxPerMm : 2);
+        }
+        labelled = labelComponents(mask, width, height);
+    }
+    const minAreaPx = pxPerMm
+        ? Math.max(16, params.minPartAreaMm2 * pxPerMm * pxPerMm)
+        : // No DPI: fall back to a fraction of the raster so the filter still
+            // removes speckle rather than being disabled entirely.
+            Math.max(16, width * height * 0.00002);
+    const maxAreaPx = width * height * MAX_PART_FRACTION;
+    let droppedSmall = 0;
+    let droppedSheet = 0;
+    const parts = [];
+    for (const stat of labelled.stats) {
+        if (stat.area > maxAreaPx) {
+            droppedSheet++;
+            continue;
+        }
+        if (stat.area < minAreaPx) {
+            droppedSmall++;
+            continue;
+        }
+        parts.push(stat);
+    }
+    // Largest first, so ordinal 1 is the most prominent sticker rather than
+    // whichever happened to be scanned top-left. A human renaming parts works
+    // down a list; starting with a 4mm registration dot reads as broken.
+    parts.sort((a, b) => b.area - a.area);
+    return {
+        labels: labelled.labels,
+        parts,
+        diagnostics: {
+            workingSize: { x: 0, y: 0, width, height },
+            paperColour: paper.detectedType === "paper" ? paper.colour : null,
+            ridgeCoverage: ridge.coverage,
+            quantiseCoverage: quant?.coverage ?? 0,
+            fusedCoverage: ridge.coverage,
+            componentsFound: labelled.count,
+            droppedBelowMinArea: droppedSmall,
+            droppedSheetSized: droppedSheet,
+            backgroundCoverage,
+            bridgedComponents: merges || Math.max(0, beforeBridge - labelled.count),
+            artBackgroundUnsupported: false,
+        },
+    };
+}