tapirscan 1.2.1 → 1.3.0

package/dist/detail-20260914/source-evidence.mjs

@@ -1,94 +0,0 @@
-/** Cheap alternating-run evidence. It prioritizes geometry, never accepts digits. */
-export function sourceEvidence(image, polygon, local = false, target = Infinity) {
-    const { data, width, height } = image;
-    const gray = (x, y) => {
-        x = Math.max(0, Math.min(width - 1, x));
-        y = Math.max(0, Math.min(height - 1, y));
-        const x0 = Math.floor(x), y0 = Math.floor(y), x1 = Math.min(width - 1, x0 + 1), y1 = Math.min(height - 1, y0 + 1), fx = x - x0, fy = y - y0;
-        const v = (a, b) => {
-            const i = (b * width + a) * 4;
-            return (77 * data[i] + 150 * data[i + 1] + 29 * data[i + 2]) / 256;
-        };
-        return ((v(x0, y0) * (1 - fx) + v(x1, y0) * fx) * (1 - fy) +
-            (v(x0, y1) * (1 - fx) + v(x1, y1) * fx) * fy);
-    };
-    let best = 0, localBest = 0, rows = 0, contrast = 0;
-    for (let axis = 0; axis < 2; axis++)
-        for (const f of [0.2, 0.4, 0.6, 0.8]) {
-            const a = polygon[axis], b = polygon[(axis + 1) % 4], c = polygon[(axis + 2) % 4], d = polygon[(axis + 3) % 4];
-            const p = [a[0] * (1 - f) + d[0] * f, a[1] * (1 - f) + d[1] * f], q = [b[0] * (1 - f) + c[0] * f, b[1] * (1 - f) + c[1] * f];
-            const n = Math.min(2048, Math.max(64, Math.ceil(Math.hypot(q[0] - p[0], q[1] - p[1]) * 1.25)));
-            const samples = new Float32Array(n);
-            let lo = 255, hi = 0;
-            for (let i = 0; i < n; i++) {
-                const t = -0.125 + (1.25 * i) / (n - 1), v = gray(p[0] + (q[0] - p[0]) * t, p[1] + (q[1] - p[1]) * t);
-                samples[i] = v;
-                lo = Math.min(lo, v);
-                hi = Math.max(hi, v);
-            }
-            contrast = Math.max(contrast, hi - lo);
-            if (hi - lo < (local ? 12 : 20))
-                continue;
-            const threshold = (lo + hi) / 2, hysteresis = (hi - lo) * 0.06;
-            let state = samples[0] > threshold, runs = 0;
-            for (const v of samples) {
-                if (state ? v < threshold - hysteresis : v > threshold + hysteresis) {
-                    state = !state;
-                    runs++;
-                }
-            }
-            best = Math.max(best, runs);
-            if (runs >= 20)
-                rows++;
-            if (best >= target)
-                return { transitions: best, localTransitions: localBest, rows, contrast };
-            if (local) {
-                const sum = new Float64Array(n + 1);
-                for (let i = 0; i < n; i++)
-                    sum[i + 1] = sum[i] + samples[i];
-                let previous, localRuns = 0;
-                for (let i = 0; i < n; i++) {
-                    const left = Math.max(0, i - 8), right = Math.min(n, i + 9), mean = (sum[right] - sum[left]) / (right - left);
-                    const next = samples[i] > mean + 2 ? true : samples[i] < mean - 2 ? false : undefined;
-                    if (next !== undefined) {
-                        if (previous !== undefined && previous !== next)
-                            localRuns++;
-                        previous = next;
-                    }
-                }
-                localBest = Math.max(localBest, localRuns);
-                if (localBest >= target)
-                    return { transitions: best, localTransitions: localBest, rows, contrast };
-            }
-        }
-    return { transitions: best, localTransitions: localBest, rows, contrast };
-}
-export function evidenceFilter(image, localization, minimum = 20) {
-    const ranked = localization.proposals.map((p) => ({
-        ...p,
-        evidence: sourceEvidence(image, p.polygon),
-    }));
-    const proposals = ranked.filter((p) => p.evidence.transitions >= minimum), deferred = ranked.filter((p) => p.evidence.transitions < minimum);
-    return {
-        ...localization,
-        proposals,
-        deferred,
-        workLimited: localization.workLimited || deferred.length > 0,
-    };
-}
-/** Retain all candidates. Evidence stops once eligibility is established; counts are lower bounds. */
-export function evidencePlan(image, localization, minimum = 20) {
-    const proposals = localization.proposals.map((p) => ({
-        ...p,
-        evidence: sourceEvidence(image, p.polygon, false, minimum),
-    }));
-    const masks = [0, 0];
-    proposals.forEach((p, i) => {
-        if (p.evidence.transitions >= minimum)
-            masks[i >>> 5] |= 1 << (i & 31);
-    });
-    const fullFrame = proposals.length;
-    if (fullFrame < 64)
-        masks[fullFrame >>> 5] |= 1 << (fullFrame & 31);
-    return { ...localization, proposals, retryMask: masks.map((x) => x >>> 0) };
-}

package/dist/detail-canvas.d.ts

@@ -1,35 +0,0 @@
-/** Canvas interpolation in browsers; deterministic bilinear RGB interpolation in Node. */
-interface Pixels {
-    data: Uint8ClampedArray;
-    width: number;
-    height: number;
-}
-export declare function makeCanvas(width: number, height: number): {
-    width: number;
-    height: number;
-    getContext(): {
-        imageSmoothingEnabled: boolean;
-        putImageData(value: Pixels): void;
-        getImageData(): Pixels;
-        drawImage(source: {
-            getContext(): {
-                getImageData(): Pixels;
-            };
-        }, _x: number, _y: number, w: number, h: number): void;
-    };
-} | {
-    width: number;
-    height: number;
-    native: OffscreenCanvas;
-    getContext(_kind: string, options?: {
-        willReadFrequently?: boolean;
-    }): {
-        imageSmoothingEnabled: boolean;
-        putImageData(pixels: Pixels, x: number, y: number): void;
-        drawImage(source: {
-            native: OffscreenCanvas;
-        }, x: number, y: number, w: number, h: number): void;
-        getImageData(x: number, y: number, w: number, h: number): ImageData;
-    };
-};
-export {};

package/dist/detail-canvas.js

@@ -1,73 +0,0 @@
-export function makeCanvas(width, height) {
-    if (typeof OffscreenCanvas !== "undefined") {
-        const canvas = new OffscreenCanvas(width, height);
-        return {
-            get width() {
-                return canvas.width;
-            },
-            set width(value) {
-                canvas.width = value;
-            },
-            get height() {
-                return canvas.height;
-            },
-            set height(value) {
-                canvas.height = value;
-            },
-            native: canvas,
-            getContext(_kind, options) {
-                const context = canvas.getContext("2d", options);
-                if (!context)
-                    throw Error("Could not create recovery canvas");
-                return {
-                    imageSmoothingEnabled: true,
-                    putImageData(pixels, x, y) {
-                        context.putImageData(new ImageData(new Uint8ClampedArray(pixels.data), pixels.width, pixels.height), x, y);
-                    },
-                    drawImage(source, x, y, w, h) {
-                        context.imageSmoothingEnabled = true;
-                        context.drawImage(source.native, x, y, w, h);
-                    },
-                    getImageData(x, y, w, h) {
-                        return context.getImageData(x, y, w, h);
-                    },
-                };
-            },
-        };
-    }
-    let pixels = { data: new Uint8ClampedArray(), width, height };
-    const canvas = {
-        width,
-        height,
-        getContext() {
-            return {
-                imageSmoothingEnabled: true,
-                putImageData(value) {
-                    pixels = value;
-                },
-                getImageData() {
-                    return pixels;
-                },
-                drawImage(source, _x, _y, w, h) {
-                    const input = source.getContext().getImageData();
-                    const data = new Uint8ClampedArray(w * h * 4);
-                    for (let y = 0; y < h; y++) {
-                        const sy = Math.max(0, Math.min(input.height - 1, ((y + 0.5) * input.height) / h - 0.5));
-                        const y0 = Math.floor(sy), y1 = Math.min(input.height - 1, y0 + 1), fy = sy - y0;
-                        for (let x = 0; x < w; x++) {
-                            const sx = Math.max(0, Math.min(input.width - 1, ((x + 0.5) * input.width) / w - 0.5));
-                            const x0 = Math.floor(sx), x1 = Math.min(input.width - 1, x0 + 1), fx = sx - x0;
-                            for (let c = 0; c < 4; c++) {
-                                const a = input.data[(y0 * input.width + x0) * 4 + c], b = input.data[(y0 * input.width + x1) * 4 + c];
-                                const d = input.data[(y1 * input.width + x0) * 4 + c], e = input.data[(y1 * input.width + x1) * 4 + c];
-                                data[(y * w + x) * 4 + c] = Math.round((a * (1 - fx) + b * fx) * (1 - fy) + (d * (1 - fx) + e * fx) * fy);
-                            }
-                        }
-                    }
-                    pixels = { data, width: w, height: h };
-                },
-            };
-        },
-    };
-    return canvas;
-}

package/dist/detail-runtime/direct-recovery.d.mts

@@ -1,28 +0,0 @@
-/** Bounded source-guided hypotheses, without another localizer/shear search per crop. */
-export function recoverDirectSeed(image: any, scanner: any, policy: any, baseline: any, budget?: number, factor?: number, sequential?: boolean, scharr?: boolean, minimumSpan?: number, maxDirections?: number, coverage?: any[]): {
-    barcodes: any[];
-    additions: any[];
-    attempts: {
-        x: number;
-        y: number;
-        w: number;
-        h: number;
-        factor: number;
-        frame: any;
-        reads: any;
-        deferredReads: any;
-        proposals: {
-            polygon: number[][];
-            score: number;
-            text: string;
-        }[];
-        unfinished: any;
-    }[];
-    proposals: {
-        polygon: number[][];
-        score: number;
-        text: string;
-    }[];
-    extraMs: number;
-    searchLimited: boolean;
-};

package/dist/detail-runtime/direct-recovery.mjs

@@ -1,142 +0,0 @@
-import { makeCanvas } from "../detail-canvas.js";
-import { detailProposals } from "../detail-20260914/detail-proposals-rich.mjs";
-import { sourceEvidence } from "../detail-20260914/source-evidence.mjs";
-import { coveredByContinuousBars } from "../detail-20260914/continuity.mjs";
-function refinedAngle(image, seed) {
-    const gray = (x, y) => {
-        const i = (y * image.width + x) * 4;
-        return (77 * image.data[i] + 150 * image.data[i + 1] + 29 * image.data[i + 2]) / 256;
-    };
-    let xx = 0, yy = 0, xy = 0, sx = 0, sy = 0, n = 0;
-    for (let y = Math.max(1, Math.round(seed.y) - 12); y < Math.min(image.height - 1, seed.y + 12); y++)
-        for (let x = Math.max(1, Math.round(seed.x) - 12); x < Math.min(image.width - 1, seed.x + 12); x++) {
-            const a = gray(x - 1, y - 1), b = gray(x, y - 1), c = gray(x + 1, y - 1), d = gray(x - 1, y), e = gray(x + 1, y), f = gray(x - 1, y + 1), g = gray(x, y + 1), h = gray(x + 1, y + 1);
-            const gx = (3 * (c - a) + 10 * (e - d) + 3 * (h - f)) / 16, gy = (3 * (f - a) + 10 * (g - b) + 3 * (h - c)) / 16;
-            xx += gx * gx;
-            yy += gy * gy;
-            xy += gx * gy;
-            sx += gx;
-            sy += gy;
-            n++;
-        }
-    return 0.5 * Math.atan2(2 * (xy - (sx * sy) / n), xx - (sx * sx) / n - yy + (sy * sy) / n);
-}
-function contains(point, q) {
-    let hit = false;
-    for (let i = 0, j = q.length - 1; i < q.length; j = i++) {
-        if (q[i][1] > point[1] !== q[j][1] > point[1] &&
-            point[0] < ((q[j][0] - q[i][0]) * (point[1] - q[i][1])) / (q[j][1] - q[i][1]) + q[i][0])
-            hit = !hit;
-    }
-    return hit;
-}
-function covered(image, point, barcode) {
-    return contains(point, barcode.polygon) || coveredByContinuousBars(image, point, barcode);
-}
-function sourceSpan(p) {
-    const dx = p[1][0] - p[0][0], dy = p[1][1] - p[0][1];
-    return (Math.abs(dx * (p[3][1] - p[0][1]) - dy * (p[3][0] - p[0][0])) /
-        Math.max(1e-9, Math.hypot(dx, dy)));
-}
-/** Bounded source-guided hypotheses, without another localizer/shear search per crop. */
-export function recoverDirectSeed(image, scanner, policy, baseline, budget = 64, factor = 3, sequential = false, scharr = false, minimumSpan = 0, maxDirections = Infinity, coverage = []) {
-    const start = performance.now();
-    const seeds = detailProposals(image, 2, 256, 4);
-    const additions = [], attempts = [], proposals = [];
-    const tile = makeCanvas(1, 1), up = makeCanvas(1, 1);
-    const tc = tile.getContext("2d"), uc = up.getContext("2d", { willReadFrequently: true });
-    for (const seed of seeds) {
-        if (seed.score < seeds[0].score * 0.6)
-            continue;
-        if (coverage.some((quad) => containsPoint([seed.x, seed.y], quad)))
-            continue;
-        if ([...baseline.scan.barcodes, ...additions].some((b) => covered(image, [seed.x, seed.y], b)))
-            continue;
-        const quads = [];
-        const initialAngle = scharr ? refinedAngle(image, seed) : seed.angle;
-        const directions = (scharr ? [0, -3, 3] : [0, -5, 5, -10, 10, -15, 15, -20, 20]).map((offset) => initialAngle + (offset * Math.PI) / 180);
-        for (const angle of directions) {
-            const c = Math.cos(angle), s = Math.sin(angle);
-            const polygon = [
-                [-96, -24],
-                [96, -24],
-                [96, 24],
-                [-96, 24],
-            ].map(([u, v]) => [seed.x + u * c - v * s, seed.y + u * s + v * c]);
-            const evidence = sourceEvidence(image, polygon, true, 32);
-            if (Math.max(evidence.transitions, evidence.localTransitions) >= 32)
-                quads.push(polygon);
-            if (quads.length >= maxDirections)
-                break;
-        }
-        if (!quads.length)
-            continue;
-        const size = 256, w = Math.min(size, image.width), h = Math.min(size, image.height);
-        const x = Math.max(0, Math.min(image.width - w, Math.round(seed.x - w / 2)));
-        const y = Math.max(0, Math.min(image.height - h, Math.round(seed.y - h / 2)));
-        const bytes = new Uint8ClampedArray(w * h * 4);
-        for (let row = 0; row < h; row++) {
-            const from = ((y + row) * image.width + x) * 4;
-            bytes.set(image.data.subarray(from, from + w * 4), row * w * 4);
-        }
-        tile.width = w;
-        tile.height = h;
-        tc.putImageData({ data: bytes, width: w, height: h }, 0, 0);
-        up.width = w * factor;
-        up.height = h * factor;
-        uc.imageSmoothingEnabled = true;
-        uc.drawImage(tile, 0, 0, up.width, up.height);
-        const pixels = uc.getImageData(0, 0, up.width, up.height);
-        const batches = sequential ? quads.map((q) => [q]) : [quads];
-        for (const batch of batches) {
-            const result = scanner.scan({
-                data: new Uint8Array(pixels.data.buffer),
-                width: up.width,
-                height: up.height,
-                channels: 4,
-                stride: up.width * 4,
-            }, batch.map((q) => q.map(([a, b]) => [(a - x) * factor, (b - y) * factor])), {
-                ...policy,
-                maxRetryPathsPerCandidate: budget,
-                maxRetryPathsPerFrame: budget * batch.length,
-            });
-            const allReads = result.barcodes.map((b) => ({
-                ...b,
-                polygon: b.polygon.map(([a, b]) => [x + a / factor, y + b / factor]),
-            }));
-            const reads = allReads.filter((b) => sourceSpan(b.polygon) >= minimumSpan);
-            const deferredReads = allReads.filter((b) => sourceSpan(b.polygon) < minimumSpan);
-            for (const read of reads) {
-                const center = read.polygon.reduce((a, p) => [a[0] + p[0] / 4, a[1] + p[1] / 4], [0, 0]);
-                if (![...baseline.scan.barcodes, ...additions].some((old) => old.text === read.text && covered(image, center, old)))
-                    additions.push(read);
-            }
-            const localized = batch.map((polygon) => ({ polygon, score: seed.score, text: "" }));
-            proposals.push(...localized);
-            attempts.push({
-                x,
-                y,
-                w,
-                h,
-                factor,
-                // Raw evidence remains in crop coordinates with this explicit transform.
-                frame: result,
-                reads,
-                deferredReads,
-                proposals: localized,
-                unfinished: result.unfinished || deferredReads.length > 0,
-            });
-            if (sequential && reads.some((b) => covered(image, [seed.x, seed.y], b)))
-                break;
-        }
-    }
-    return {
-        barcodes: [...baseline.scan.barcodes, ...additions],
-        additions,
-        attempts,
-        proposals,
-        extraMs: performance.now() - start,
-        searchLimited: true,
-    };
-}
-import { containsPoint } from "../multiformat/coverage.js";

package/dist/detail-runtime/host.d.mts

@@ -1,40 +0,0 @@
-/** Explicit indices reject sparse arrays; nonfinite numeric geometry reaches Rust. */
-export function isQuadShape(value: any): boolean;
-/** Validate before asynchronous work; returned bytes are owned by the caller. */
-export function snapshotImage(image: any): {
-    data: Uint8Array<any>;
-    width: any;
-    height: any;
-    channels: any;
-    stride: any;
-};
-export function snapshotPolicy(policy: any): any;
-/** Uncalibrated support ordering; ties preserve spatial output order. */
-export function rankBarcodes(barcodes: any): any[];
-export class ScannerError extends Error {
-    constructor(code: any, message: any);
-    code: any;
-}
-export class IndependentScanner {
-    static create(bytes: any): Promise<IndependentScanner>;
-    constructor(exports: any);
-    /** All supplied regions receive the cheap pass; successful reads do not end scanning. */
-    scan(image: any, quads: any, policy?: {}): any;
-    /** Synchronous transaction: upload once, localize, decode the same owned pixels. */
-    scanLocalized(image: any, policy?: {}, fitLimit?: number, fullFrame?: boolean, transform?: undefined): {
-        localization: any;
-        searchWindows: {
-            kind: string;
-            polygon: number[][];
-            candidateIndex: any;
-        }[];
-        scan: any;
-        localizationMs: number;
-        decodingMs: number;
-        scanMs: number;
-    };
-    /** Separate convenience; it never changes find-all work or suppresses frame evidence. */
-    best(result: any): any;
-    dispose(): void;
-    #private;
-}