@scanmate/image-fix 0.0.3

package/dist/src/index.d.ts

@@ -0,0 +1,58 @@
+/**
+ * `@scanmate/image-fix` - put a scanned page back on top of the page it came from.
+ *
+ * ```ts
+ * import { readFile } from 'node:fs/promises'
+ * import { alignScan, compareRegions } from '@scanmate/image-fix'
+ *
+ * const original = await readFile('contract.page1.png')  // rendered from the PDF
+ * const scanned = await readFile('returned.jpg')         // what came back
+ *
+ * const result = alignScan(original, scanned)
+ * console.log(result.confidence, result.transform.rotationDeg)
+ *
+ * const [signature] = compareRegions(original, result.raster, [
+ *   { id: 'signature', rect: { x: 76, y: 905, width: 420, height: 78 } },
+ * ])
+ * console.log(signature.filled)
+ * ```
+ *
+ * `result.raster` is on the original's canvas, so every coordinate you already
+ * know from the PDF still means what it meant - which is what makes both an
+ * OCR diff and a "was this box signed" check possible.
+ *
+ * Everything here is pure JavaScript. No native bindings, so nothing to rebuild
+ * per platform when it deploys to an Azure Function app.
+ */
+export { alignScan, polishTranslation } from './lib/align.js';
+export type { AlignDiagnostics, AlignOptions, AlignResult } from './lib/align.js';
+export { compareRegions, diffDocument, renderDiff } from './lib/regions.js';
+export type { DocumentDiff, Region, RegionOptions, RegionReport } from './lib/regions.js';
+export type { BinaryImage, GrayImage, ImageInput, Matrix3, Point, PointMatch, Raster, Rect, TransformModel, TransformSummary, } from './lib/types.js';
+export { decodeImage, encodeImage, sniffFormat } from './lib/image/codec.js';
+export type { EncodeOptions, ImageFormat } from './lib/image/codec.js';
+export { binarize, boxBlur, coverage, dilate, grayToRaster, inkMap, otsuThreshold, toGrayscale } from './lib/image/gray.js';
+export type { InkOptions } from './lib/image/gray.js';
+export { createBinary, createGray, createRaster, cloneRaster, isRaster } from './lib/image/raster.js';
+export { boxBlurRaster, downscaleGray, resizeGray } from './lib/image/resize.js';
+export { sampleGrayBilinear, warpGray, warpRaster } from './lib/image/warp.js';
+export type { Interpolation, WarpOptions } from './lib/image/warp.js';
+export { contentExtent, estimateSkew } from './lib/analysis/content.js';
+export type { ContentExtent, SkewOptions } from './lib/analysis/content.js';
+export { correlation, intersectionOverUnion, mean } from './lib/analysis/score.js';
+export { applyPoint, conjugateScale, decompose, determinant, IDENTITY, invert, isPlausible, mapRectCorners, multiply, normalize, rebase, reprojectionError, scaling, similarity, translation, } from './lib/math/matrix.js';
+export { estimateCoarse } from './lib/estimate/coarse.js';
+export type { CoarseOptions, CoarseResult } from './lib/estimate/coarse.js';
+export { detectAndDescribe } from './lib/estimate/features.js';
+export type { FeatureOptions, FeatureSet, Keypoint } from './lib/estimate/features.js';
+export { hamming, matchFeatures, popcount } from './lib/estimate/match.js';
+export type { MatchOptions } from './lib/estimate/match.js';
+export { fitAffine, fitHomography, fitModel, fitSimilarity, minimumSamples } from './lib/estimate/models.js';
+export type { Correspondence } from './lib/estimate/models.js';
+export { phaseCorrelate } from './lib/estimate/phaseCorrelation.js';
+export type { PhaseCorrelationResult } from './lib/estimate/phaseCorrelation.js';
+export { findInliers, ransac } from './lib/estimate/ransac.js';
+export type { RansacOptions, RansacResult } from './lib/estimate/ransac.js';
+export { createSyntheticDocument, drawSignature, drawTick, simulateScan, } from './lib/testing/synthetic.js';
+export type { DocumentOptions, ScanOptions, SimulatedScan, SyntheticDocument, } from './lib/testing/synthetic.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/src/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"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"}

package/dist/src/lib/align.d.ts

@@ -0,0 +1,136 @@
+import type { ImageFormat } from './image/codec.js';
+import type { InkOptions } from './image/gray.js';
+import type { Interpolation } from './image/warp.js';
+import type { GrayImage, ImageInput, Matrix3, Raster, TransformModel, TransformSummary } from './types.js';
+/**
+ * Align a scan onto the page it was made from.
+ *
+ * ## What this is for
+ *
+ * Two questions about a returned form are easy to answer once the scan sits
+ * exactly on top of the original, and near-impossible before:
+ *
+ * 1. *Was anything in the printed text changed?* Run OCR on both and diff.
+ *    That only works if the two are the same page at the same size, otherwise
+ *    the OCR engine's own layout analysis is comparing different documents.
+ * 2. *Was the box at (x, y) signed?* That is a question about a fixed
+ *    rectangle, and a fixed rectangle only means something once both images
+ *    agree on where (x, y) is. See `compareRegions`.
+ *
+ * ## The pipeline
+ *
+ * ```text
+ *   decode ─► ink  ─► coarse guess ─► rough warp ─► features ─► RANSAC ─► warp
+ *                     (scale/skew)                  (ORB)       (model)
+ * ```
+ *
+ * The coarse guess exists to make the feature stage possible at all: binary
+ * descriptors compare fixed pixel offsets, so they only match between images
+ * at comparable scale, and nothing in a JPEG tells you what dpi it was scanned
+ * at. Once the scan has been resampled to roughly the right size, matching is
+ * easy and RANSAC can throw away the inevitable wrong matches — a page of text
+ * is full of genuinely identical-looking corners.
+ *
+ * If the feature stage comes up short (a nearly blank form has few corners to
+ * find), the coarse estimate is returned on its own, and `method` says so.
+ *
+ * ## Why it is synchronous
+ *
+ * All of it is CPU-bound with no I/O to wait on. An `async` signature would
+ * suggest the event loop is free during the call, and it is not. To align
+ * several pages at once, put this in a worker thread.
+ */
+export interface AlignOptions {
+    /**
+     * Transform family to fit.
+     *
+     * `similarity` (the default) covers a flatbed or sheet-fed scan: the page is
+     * flat, so it can only be turned, resized and moved. Use `affine` when one
+     * axis is stretched, and `homography` for photographs taken off-axis, where
+     * the far edge of the page is genuinely smaller than the near one.
+     */
+    model?: TransformModel;
+    /** Longest side used for feature detection. Bigger is more precise and quadratically slower. */
+    workingSize?: number;
+    /** Longest side used for the coarse guess. */
+    coarseSize?: number;
+    maxFeatures?: number;
+    /** Inlier radius for RANSAC, in working-resolution pixels. */
+    ransacThreshold?: number;
+    /** Fewer surviving correspondences than this and the feature stage is not trusted. */
+    minInliers?: number;
+    /** Largest per-page skew the coarse stage considers, in degrees. */
+    maxSkewDeg?: number;
+    /** Cap on how much bigger or smaller the scan may be than the original. */
+    maxScaleRatio?: number;
+    /** How far a correspondence may move, as a fraction of the page diagonal, after the coarse warp. */
+    maxDisplacementRatio?: number;
+    /** Background/ink separation. The defaults suit printed pages on white. */
+    ink?: InkOptions;
+    interpolation?: Interpolation;
+    /** RGBA fill where the scan does not cover the original's canvas. */
+    background?: [number, number, number, number];
+    /** Encoding of `result.image`. `'none'` skips encoding, which is most of the cost on a big page. */
+    output?: ImageFormat | 'none';
+    /** JPEG quality when `output` is `'jpeg'`. */
+    quality?: number;
+    /** Seeds RANSAC and the descriptor pattern, so the same input gives the same matrix. */
+    seed?: number;
+}
+export interface AlignDiagnostics {
+    coarseScore: number;
+    coarseStrategy: string;
+    /** Each page's own skew, in degrees, as measured independently. */
+    skewDeg: {
+        original: number;
+        scanned: number;
+    };
+    features: {
+        original: number;
+        scanned: number;
+    };
+    matches: number;
+    inliers: number;
+    inlierRatio: number;
+    /** Mean RANSAC reprojection error over the inliers, in working-resolution pixels. */
+    reprojectionError: number;
+    /** Ink correlation after alignment, in `[-1, 1]`. */
+    correlation: number;
+    /** Ink mask overlap after alignment, in `[0, 1]`. */
+    intersectionOverUnion: number;
+    /** Milliseconds spent, end to end. */
+    durationMs: number;
+}
+export interface AlignResult {
+    /** The scan resampled onto the original's canvas, same width and height as the original. */
+    raster: Raster;
+    /** `raster` encoded per `options.output`, or `null` when that was `'none'`. */
+    image: Uint8Array | null;
+    width: number;
+    height: number;
+    /** Maps original coordinates to scanned coordinates. */
+    matrix: Matrix3;
+    /** Maps scanned coordinates back to original coordinates. */
+    inverse: Matrix3;
+    transform: TransformSummary;
+    /**
+     * How much to trust the result, in `[0, 1]`.
+     *
+     * Derived from ink correlation after warping, so it measures agreement in the
+     * output rather than confidence in the process. Above ~0.6 is a solid match on
+     * a printed page; below ~0.3 treat the alignment as failed.
+     */
+    confidence: number;
+    method: 'features' | 'coarse';
+    diagnostics: AlignDiagnostics;
+}
+export declare function alignScan(original: ImageInput, scanned: ImageInput, options?: AlignOptions): AlignResult;
+/**
+ * Nudge an existing transform by whatever residual translation is still measurable.
+ *
+ * Exposed because it is occasionally useful on its own: if you already know the
+ * transform from a previous page of the same batch, this re-seats it on the
+ * current page for a fraction of the cost of a full alignment.
+ */
+export declare function polishTranslation(originalInk: GrayImage, scannedInk: GrayImage, matrix: Matrix3, workingSize?: number): Matrix3;
+//# sourceMappingURL=align.d.ts.map

package/dist/src/lib/align.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"align.d.ts","sourceRoot":"","sources":["../../../src/lib/align.ts"],"names":[],"mappings":"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"}

package/dist/src/lib/analysis/content.d.ts

@@ -0,0 +1,50 @@
+import type { GrayImage, Point } from '../types.js';
+/**
+ * Where the printing is, and which way up it is.
+ *
+ * Feature matching needs the two images at roughly the same scale before its
+ * descriptors mean anything, and nothing in the file headers tells us the dpi
+ * the scanner used. What does tell us is the printing itself: the block of ink
+ * on the page is the same physical object in both images, so the ratio of its
+ * measured sizes is the ratio of the resolutions. Measuring it needs the skew
+ * out of the way first, which is what {@link estimateSkew} is for.
+ */
+export interface ContentExtent {
+    /** Extent along the rotated axes, in pixels. */
+    width: number;
+    height: number;
+    /** Centre of the extent, back in unrotated image coordinates. */
+    center: Point;
+    /** The angle the extent was measured at, in radians. */
+    angle: number;
+    /** Mean ink over the whole image. Near zero means there was nothing to measure. */
+    density: number;
+}
+export interface SkewOptions {
+    /** Largest skew to consider, in degrees, in either direction. */
+    maxAngleDeg?: number;
+    /** Longest side of the image the search runs on. Skew does not need detail. */
+    workingSize?: number;
+}
+/**
+ * Extent of the ink along axes rotated by `angle`, trimming outliers.
+ *
+ * `trim` is a fraction of the total ink discarded from each end of each axis.
+ * A scanner that clips a black strip down one edge, or a speck of dust, would
+ * otherwise set the page boundary — and since this measurement becomes the
+ * scale estimate, a 2% error here is a 2% error in every coordinate downstream.
+ */
+export declare function contentExtent(ink: GrayImage, angle?: number, trim?: number): ContentExtent;
+/**
+ * The page's own skew, in radians, from the sharpness of its ink profile.
+ *
+ * Rotate the page until the rows of text stack up: at the right angle every
+ * line of type falls into one bin of the projection histogram and the profile
+ * is a comb of tall spikes; a degree off and each line smears across several
+ * bins. Sum of squares rewards exactly that concentration — same total ink,
+ * fewer bins, bigger number. Searched coarse to fine so the cost stays flat.
+ */
+export declare function estimateSkew(ink: GrayImage, options?: SkewOptions): number;
+/** Sum of squares of the ink profile projected onto the axis perpendicular to `angle`. */
+export declare function profileSharpness(ink: GrayImage, angle: number): number;
+//# sourceMappingURL=content.d.ts.map

package/dist/src/lib/analysis/content.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"content.d.ts","sourceRoot":"","sources":["../../../../src/lib/analysis/content.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,KAAK,EAAE,MAAM,UAAU,CAAA;AAEhD;;;;;;;;;GASG;AAEH,MAAM,WAAW,aAAa;IAC5B,gDAAgD;IAChD,KAAK,EAAI,MAAM,CAAA;IACf,MAAM,EAAG,MAAM,CAAA;IACf,iEAAiE;IACjE,MAAM,EAAG,KAAK,CAAA;IACd,wDAAwD;IACxD,KAAK,EAAI,MAAM,CAAA;IACf,mFAAmF;IACnF,OAAO,EAAE,MAAM,CAAA;CAChB;AAED,MAAM,WAAW,WAAW;IAC1B,iEAAiE;IACjE,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,+EAA+E;IAC/E,WAAW,CAAC,EAAE,MAAM,CAAA;CACrB;AAED;;;;;;;GAOG;AACH,wBAAgB,aAAa,CAAE,GAAG,EAAE,SAAS,EAAE,KAAK,SAAI,EAAE,IAAI,SAAQ,GAAG,aAAa,CAoErF;AAED;;;;;;;;GAQG;AACH,wBAAgB,YAAY,CAAE,GAAG,EAAE,SAAS,EAAE,OAAO,GAAE,WAAgB,GAAG,MAAM,CA2B/E;AAED,0FAA0F;AAC1F,wBAAgB,gBAAgB,CAAE,GAAG,EAAE,SAAS,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,CAsBvE"}

package/dist/src/lib/analysis/score.d.ts

@@ -0,0 +1,18 @@
+import type { BinaryImage, GrayImage } from '../types.js';
+/**
+ * How well two ink images actually overlap.
+ *
+ * Every stage of the pipeline proposes a transform; this is the referee. It
+ * has to be a *correlation*, not a difference: the scan is darker, or fainter,
+ * or contrast-stretched by the scanner's own firmware, and a sum of absolute
+ * differences would rank a badly aligned pale scan above a well aligned dark
+ * one. Zero-mean normalised cross correlation is invariant to both of those —
+ * it only asks whether the ink rises and falls in the same places.
+ */
+/** Zero-mean normalised cross correlation of two equally sized images, in `[-1, 1]`. */
+export declare function correlation(a: GrayImage, b: GrayImage): number;
+/** Intersection over union of two masks. The pixel-level version of "did it land on top of it". */
+export declare function intersectionOverUnion(a: BinaryImage, b: BinaryImage): number;
+/** Mean of a single channel image. */
+export declare function mean(image: GrayImage): number;
+//# sourceMappingURL=score.d.ts.map

package/dist/src/lib/analysis/score.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"score.d.ts","sourceRoot":"","sources":["../../../../src/lib/analysis/score.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,SAAS,EAAE,MAAM,UAAU,CAAA;AAEtD;;;;;;;;;GASG;AAEH,wFAAwF;AACxF,wBAAgB,WAAW,CAAE,CAAC,EAAE,SAAS,EAAE,CAAC,EAAE,SAAS,GAAG,MAAM,CA8B/D;AAED,mGAAmG;AACnG,wBAAgB,qBAAqB,CAAE,CAAC,EAAE,WAAW,EAAE,CAAC,EAAE,WAAW,GAAG,MAAM,CAa7E;AAED,sCAAsC;AACtC,wBAAgB,IAAI,CAAE,KAAK,EAAE,SAAS,GAAG,MAAM,CAM9C"}

package/dist/src/lib/estimate/coarse.d.ts

@@ -0,0 +1,43 @@
+import type { GrayImage, Matrix3 } from '../types.js';
+/**
+ * A first, cheap answer good enough to make the expensive one possible.
+ *
+ * Descriptor matching has a blind spot: BRIEF compares fixed pixel offsets, so
+ * a scan at 300 dpi and a page rendered at 150 describe the same corner with
+ * two unrelated bit strings. Something has to establish roughly how big the
+ * scan is before the matcher runs, and nothing in the file says.
+ *
+ * So guess, several ways, and let the pixels judge:
+ *
+ * - **frame** — assume the scan is the whole page, so the frames correspond.
+ * - **content** — assume the *printing* corresponds. Robust to a scan with
+ *   wider margins, which the frame guess gets badly wrong.
+ * - **deskew** — measure each page's own skew, and match the printing in the
+ *   frame where each sits straight. This is the one that usually wins.
+ *
+ * Each gets a phase-correlation nudge, then all of them are warped and scored
+ * on ink correlation. Guessing several times and measuring is far more robust
+ * than one clever guess, and at this resolution each attempt costs very little.
+ */
+export interface CoarseOptions {
+    /** Longest side of the images the search runs on. */
+    workingSize?: number;
+    /** Largest per-page skew considered, in degrees. */
+    maxSkewDeg?: number;
+    /** Largest scale ratio between the two images that will be entertained. */
+    maxScaleRatio?: number;
+}
+export interface CoarseResult {
+    /** Maps full-resolution original coordinates to full-resolution scan coordinates. */
+    matrix: Matrix3;
+    /** Ink correlation achieved by this transform, in `[-1, 1]`. */
+    score: number;
+    /** Which guess won, for diagnostics. */
+    strategy: string;
+    skew: {
+        original: number;
+        scanned: number;
+    };
+}
+export declare function estimateCoarse(originalInk: GrayImage, scannedInk: GrayImage, options?: CoarseOptions): CoarseResult;
+//# sourceMappingURL=coarse.d.ts.map

package/dist/src/lib/estimate/coarse.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"coarse.d.ts","sourceRoot":"","sources":["../../../../src/lib/estimate/coarse.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,SAAS,EAAE,OAAO,EAAE,MAAM,UAAU,CAAA;AAGlD;;;;;;;;;;;;;;;;;;;GAmBG;AAEH,MAAM,WAAW,aAAa;IAC5B,qDAAqD;IACrD,WAAW,CAAC,EAAI,MAAM,CAAA;IACtB,oDAAoD;IACpD,UAAU,CAAC,EAAK,MAAM,CAAA;IACtB,2EAA2E;IAC3E,aAAa,CAAC,EAAE,MAAM,CAAA;CACvB;AAED,MAAM,WAAW,YAAY;IAC3B,qFAAqF;IACrF,MAAM,EAAI,OAAO,CAAA;IACjB,gEAAgE;IAChE,KAAK,EAAK,MAAM,CAAA;IAChB,wCAAwC;IACxC,QAAQ,EAAE,MAAM,CAAA;IAChB,IAAI,EAAM;QAAE,QAAQ,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAA;KAAE,CAAA;CAChD;AAOD,wBAAgB,cAAc,CAC5B,WAAW,EAAE,SAAS,EACtB,UAAU,EAAE,SAAS,EACrB,OAAO,GAAE,aAAkB,GAC1B,YAAY,CAkEd"}

package/dist/src/lib/estimate/features.d.ts

@@ -0,0 +1,72 @@
+import type { GrayImage } from '../types.js';
+/**
+ * FAST corners with steered BRIEF descriptors — an ORB, written out.
+ *
+ * This is the piece OpenCV would normally hand you, and it is here because the
+ * deployment target rules out a native binding. The three parts each answer a
+ * separate question:
+ *
+ * - **FAST** answers *where*. A pixel is a corner when a contiguous arc of the
+ *   16 pixels on a circle around it is all clearly brighter, or all clearly
+ *   darker, than it is. On a page that fires on stroke ends, serifs, and the
+ *   corners of rules and boxes — landmarks that survive being rescanned.
+ * - **The intensity centroid** answers *which way up*. The vector from the
+ *   patch's centre to its centre of mass is a direction the ink itself defines,
+ *   so it turns with the page.
+ * - **BRIEF** answers *what it looks like*, as 256 yes/no questions of the form
+ *   "is this pixel darker than that one?", asked at positions rotated by that
+ *   angle. Comparing two of those is one XOR and a bit count, which is why
+ *   brute-force matching thousands of them is affordable.
+ *
+ * The descriptor is not scale invariant on its own, hence the pyramid: the same
+ * corner is described at several sizes so a scan at a different dpi still
+ * matches.
+ */
+export interface Keypoint {
+    /** Coordinates in the *input* image, pixel centres, regardless of the level found at. */
+    x: number;
+    y: number;
+    score: number;
+    /** Dominant ink direction in radians. */
+    angle: number;
+    level: number;
+    /** Pixel size of the patch described, in input pixels. */
+    size: number;
+}
+export interface FeatureSet {
+    keypoints: Keypoint[];
+    /** 8 x 32 bits per keypoint, laid out contiguously. */
+    descriptors: Uint32Array;
+}
+export interface FeatureOptions {
+    maxFeatures?: number;
+    /** Contrast a circle pixel must clear to count, in `[0, 1]` ink units. */
+    fastThreshold?: number;
+    /** Pyramid levels, including the original. */
+    levels?: number;
+    /** Ratio between consecutive levels. */
+    scaleFactor?: number;
+    /** Side of the described patch, in pixels of its own level. */
+    patchSize?: number;
+    /** Cells per axis used to spread keypoints over the page instead of over its densest paragraph. */
+    gridSize?: number;
+    seed?: number;
+}
+export declare const DESCRIPTOR_WORDS = 8;
+export declare function detectAndDescribe(image: GrayImage, options?: FeatureOptions): FeatureSet;
+interface Corner {
+    x: number;
+    y: number;
+    score: number;
+}
+/** FAST-9 with a 3x3 non-maximum suppression pass over the corner scores. */
+export declare function detectFast(image: GrayImage, threshold: number, border: number): Corner[];
+/**
+ * Angle from the patch centre to its centre of intensity mass.
+ *
+ * On an ink image the mass is the writing, so the angle turns with the page —
+ * which is the entire trick that makes a binary descriptor rotation invariant.
+ */
+export declare function orientation(image: GrayImage, cx: number, cy: number, radius: number): number;
+export {};
+//# sourceMappingURL=features.d.ts.map

package/dist/src/lib/estimate/features.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"features.d.ts","sourceRoot":"","sources":["../../../../src/lib/estimate/features.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,UAAU,CAAA;AAEzC;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAEH,MAAM,WAAW,QAAQ;IACvB,yFAAyF;IACzF,CAAC,EAAM,MAAM,CAAA;IACb,CAAC,EAAM,MAAM,CAAA;IACb,KAAK,EAAE,MAAM,CAAA;IACb,yCAAyC;IACzC,KAAK,EAAE,MAAM,CAAA;IACb,KAAK,EAAE,MAAM,CAAA;IACb,0DAA0D;IAC1D,IAAI,EAAG,MAAM,CAAA;CACd;AAED,MAAM,WAAW,UAAU;IACzB,SAAS,EAAI,QAAQ,EAAE,CAAA;IACvB,uDAAuD;IACvD,WAAW,EAAE,WAAW,CAAA;CACzB;AAED,MAAM,WAAW,cAAc;IAC7B,WAAW,CAAC,EAAI,MAAM,CAAA;IACtB,0EAA0E;IAC1E,aAAa,CAAC,EAAE,MAAM,CAAA;IACtB,8CAA8C;IAC9C,MAAM,CAAC,EAAS,MAAM,CAAA;IACtB,wCAAwC;IACxC,WAAW,CAAC,EAAI,MAAM,CAAA;IACtB,+DAA+D;IAC/D,SAAS,CAAC,EAAM,MAAM,CAAA;IACtB,mGAAmG;IACnG,QAAQ,CAAC,EAAO,MAAM,CAAA;IACtB,IAAI,CAAC,EAAW,MAAM,CAAA;CACvB;AAED,eAAO,MAAM,gBAAgB,IAAI,CAAA;AAajC,wBAAgB,iBAAiB,CAAE,KAAK,EAAE,SAAS,EAAE,OAAO,GAAE,cAAmB,GAAG,UAAU,CAuD7F;AAED,UAAU,MAAM;IACd,CAAC,EAAM,MAAM,CAAA;IACb,CAAC,EAAM,MAAM,CAAA;IACb,KAAK,EAAE,MAAM,CAAA;CACd;AAED,6EAA6E;AAC7E,wBAAgB,UAAU,CAAE,KAAK,EAAE,SAAS,EAAE,SAAS,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,MAAM,EAAE,CA6DzF;AAyED;;;;;GAKG;AACH,wBAAgB,WAAW,CAAE,KAAK,EAAE,SAAS,EAAE,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,MAAM,CAqB7F"}

package/dist/src/lib/estimate/match.d.ts

@@ -0,0 +1,38 @@
+import type { PointMatch } from '../types.js';
+import type { FeatureSet } from './features.js';
+/**
+ * Brute-force descriptor matching.
+ *
+ * Brute force is the right algorithm here, not a concession. A page yields
+ * around a thousand keypoints per side; a million 256-bit comparisons is eight
+ * million XOR-and-popcount operations, which is milliseconds. Building an index
+ * to avoid that would cost more than it saves and would only return
+ * approximate neighbours.
+ *
+ * The filters matter more than the search does:
+ *
+ * - **Ratio test.** Keep a match only when the best candidate is clearly better
+ *   than the runner-up. On a page of repeated letterforms the nearest neighbour
+ *   is often meaningless, and the giveaway is that the second nearest is just
+ *   as close.
+ * - **Cross-check.** Both sides must name each other. One-directional bests are
+ *   not symmetric, and the asymmetric ones are usually wrong.
+ * - **Displacement gate.** The images are already roughly aligned when this
+ *   runs, so a correspondence that jumps half the page is not a correspondence.
+ */
+export interface MatchOptions {
+    /** Lowe's ratio. Lower is stricter. */
+    ratio?: number;
+    /** Reject matches further apart than this many bits out of 256. */
+    maxDistance?: number;
+    /** Require both descriptors to pick each other. */
+    crossCheck?: boolean;
+    /** Reject correspondences that move further than this, in pixels. `Infinity` disables the gate. */
+    maxDisplacement?: number;
+}
+export declare function matchFeatures(source: FeatureSet, target: FeatureSet, options?: MatchOptions): PointMatch[];
+/** Hamming distance between two 256-bit descriptors. */
+export declare function hamming(a: Uint32Array, offsetA: number, b: Uint32Array, offsetB: number): number;
+/** SWAR bit count: pair off, then nibble off, then one multiply to sum the bytes. */
+export declare function popcount(value: number): number;
+//# sourceMappingURL=match.d.ts.map

package/dist/src/lib/estimate/match.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"match.d.ts","sourceRoot":"","sources":["../../../../src/lib/estimate/match.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,UAAU,CAAA;AAC1C,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,YAAY,CAAA;AAG5C;;;;;;;;;;;;;;;;;;;GAmBG;AAEH,MAAM,WAAW,YAAY;IAC3B,uCAAuC;IACvC,KAAK,CAAC,EAAY,MAAM,CAAA;IACxB,mEAAmE;IACnE,WAAW,CAAC,EAAM,MAAM,CAAA;IACxB,mDAAmD;IACnD,UAAU,CAAC,EAAO,OAAO,CAAA;IACzB,mGAAmG;IACnG,eAAe,CAAC,EAAE,MAAM,CAAA;CACzB;AAUD,wBAAgB,aAAa,CAC3B,MAAM,EAAE,UAAU,EAClB,MAAM,EAAE,UAAU,EAClB,OAAO,GAAE,YAAiB,GACzB,UAAU,EAAE,CA2Ed;AAED,wDAAwD;AACxD,wBAAgB,OAAO,CAAE,CAAC,EAAE,WAAW,EAAE,OAAO,EAAE,MAAM,EAAE,CAAC,EAAE,WAAW,EAAE,OAAO,EAAE,MAAM,GAAG,MAAM,CAKjG;AAED,qFAAqF;AACrF,wBAAgB,QAAQ,CAAE,KAAK,EAAE,MAAM,GAAG,MAAM,CAM/C"}

package/dist/src/lib/estimate/models.d.ts

@@ -0,0 +1,41 @@
+import type { Matrix3, PointMatch, TransformModel } from '../types.js';
+/**
+ * Fitting a transform to a set of correspondences.
+ *
+ * Three models, and the choice between them is a bet about what the scan went
+ * through. A flatbed scanner moves the page in one plane, so a **similarity**
+ * (turn it, resize it, slide it) is the whole story and its four parameters
+ * are pinned down by very few points — which is exactly what you want when
+ * most of your matches are wrong. A sheet-fed scanner can stretch one axis;
+ * that needs **affine**. A photograph taken at an angle needs the full
+ * **homography**, and pays for those eight parameters by being far easier to
+ * fit to nonsense.
+ *
+ * Prefer the simplest model the physical situation allows.
+ */
+/** Correspondences the fitters consume. `distance` is ignored here. */
+export type Correspondence = Pick<PointMatch, 'source' | 'target'>;
+/** How many correspondences the model needs before it is determined at all. */
+export declare function minimumSamples(model: TransformModel): number;
+export declare function fitModel(model: TransformModel, matches: readonly Correspondence[], indices?: readonly number[]): Matrix3 | null;
+/**
+ * Least-squares similarity, in closed form.
+ *
+ * No iteration and no matrix inverse: centre both point sets, and the rotation
+ * and scale fall out of two dot products. That closed form is why similarity
+ * survives a RANSAC sample that affine would choke on.
+ */
+export declare function fitSimilarity(matches: readonly Correspondence[], indices?: readonly number[]): Matrix3 | null;
+/** Least-squares affine: two independent 3x3 normal systems sharing one matrix. */
+export declare function fitAffine(matches: readonly Correspondence[], indices?: readonly number[]): Matrix3 | null;
+/**
+ * Direct Linear Transform with Hartley normalisation.
+ *
+ * The normalisation is not optional polish. Raw pixel coordinates put entries
+ * like `x * u` (order 10^6) next to a constant 1 in the same row, and the
+ * eigen solve then answers a question dominated by the big column. Centring
+ * each point set and scaling it to a mean radius of `sqrt(2)` puts every
+ * column on the same footing; the result is mapped back afterwards.
+ */
+export declare function fitHomography(matches: readonly Correspondence[], indices?: readonly number[]): Matrix3 | null;
+//# sourceMappingURL=models.d.ts.map

package/dist/src/lib/estimate/models.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"models.d.ts","sourceRoot":"","sources":["../../../../src/lib/estimate/models.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,OAAO,EAAE,UAAU,EAAE,cAAc,EAAE,MAAM,UAAU,CAAA;AAEnE;;;;;;;;;;;;;GAaG;AAEH,uEAAuE;AACvE,MAAM,MAAM,cAAc,GAAG,IAAI,CAAC,UAAU,EAAE,QAAQ,GAAG,QAAQ,CAAC,CAAA;AAElE,+EAA+E;AAC/E,wBAAgB,cAAc,CAAE,KAAK,EAAE,cAAc,GAAG,MAAM,CAS7D;AAED,wBAAgB,QAAQ,CACtB,KAAK,EAAE,cAAc,EACrB,OAAO,EAAE,SAAS,cAAc,EAAE,EAClC,OAAO,CAAC,EAAE,SAAS,MAAM,EAAE,GAC1B,OAAO,GAAG,IAAI,CAShB;AAED;;;;;;GAMG;AACH,wBAAgB,aAAa,CAC3B,OAAO,EAAE,SAAS,cAAc,EAAE,EAClC,OAAO,CAAC,EAAE,SAAS,MAAM,EAAE,GAC1B,OAAO,GAAG,IAAI,CA4ChB;AAED,mFAAmF;AACnF,wBAAgB,SAAS,CACvB,OAAO,EAAE,SAAS,cAAc,EAAE,EAClC,OAAO,CAAC,EAAE,SAAS,MAAM,EAAE,GAC1B,OAAO,GAAG,IAAI,CAmChB;AAED;;;;;;;;GAQG;AACH,wBAAgB,aAAa,CAC3B,OAAO,EAAE,SAAS,cAAc,EAAE,EAClC,OAAO,CAAC,EAAE,SAAS,MAAM,EAAE,GAC1B,OAAO,GAAG,IAAI,CAoChB"}

package/dist/src/lib/estimate/phaseCorrelation.d.ts

@@ -0,0 +1,34 @@
+import type { GrayImage } from '../types.js';
+/**
+ * Global translation from the Fourier shift theorem.
+ *
+ * Shifting an image does not change the magnitude of its spectrum, only the
+ * phase — and it changes the phase by an amount proportional to the shift. So
+ * divide out the magnitudes entirely, keep the phase difference, transform
+ * back, and what comes out is a single spike at the offset between the two
+ * images.
+ *
+ * Its value here is that it does not care what is *on* the page. Feature
+ * matching needs corners to match; a mostly blank form does not have enough of
+ * them, and neither does a page that scanned faint. Phase correlation uses
+ * every pixel at once, which makes it the fallback when features fail, and a
+ * good final polish when they succeed.
+ *
+ * It only finds translation. Rotation and scale have to be dealt with first.
+ */
+export interface PhaseCorrelationResult {
+    /** Shift that takes `a` onto `b`: a feature at `p` in `a` sits at `p + (dx, dy)` in `b`. */
+    dx: number;
+    dy: number;
+    /** Height of the correlation spike. Near 1 is a clean single answer; near 0 is noise. */
+    peak: number;
+}
+/**
+ * Correlate two equally sized images.
+ *
+ * Both are Hann-windowed first. Without it the FFT sees the frame edges as a
+ * hard discontinuity repeating forever, and that cross pattern in the spectrum
+ * can be a stronger signal than the page.
+ */
+export declare function phaseCorrelate(a: GrayImage, b: GrayImage): PhaseCorrelationResult;
+//# sourceMappingURL=phaseCorrelation.d.ts.map

package/dist/src/lib/estimate/phaseCorrelation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"phaseCorrelation.d.ts","sourceRoot":"","sources":["../../../../src/lib/estimate/phaseCorrelation.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,UAAU,CAAA;AAEzC;;;;;;;;;;;;;;;;GAgBG;AAEH,MAAM,WAAW,sBAAsB;IACrC,4FAA4F;IAC5F,EAAE,EAAI,MAAM,CAAA;IACZ,EAAE,EAAI,MAAM,CAAA;IACZ,yFAAyF;IACzF,IAAI,EAAE,MAAM,CAAA;CACb;AAED;;;;;;GAMG;AACH,wBAAgB,cAAc,CAAE,CAAC,EAAE,SAAS,EAAE,CAAC,EAAE,SAAS,GAAG,sBAAsB,CA6DlF"}

package/dist/src/lib/estimate/ransac.d.ts

@@ -0,0 +1,36 @@
+import type { Matrix3, TransformModel } from '../types.js';
+import type { Correspondence } from './models.js';
+/**
+ * RANSAC: fit the model that the largest number of correspondences agree with.
+ *
+ * Feature matching on a document produces a lot of confident nonsense, because
+ * the page is full of things that genuinely look identical — every lowercase
+ * "e", every corner of every table cell. Least squares over all of them is
+ * dragged wherever the wrong ones point. RANSAC ignores the average: it draws
+ * the smallest sample that determines a transform, counts how many of the rest
+ * that transform explains, and repeats. A wrong sample agrees with almost
+ * nothing; the right one agrees with everything real on the page.
+ */
+export interface RansacOptions {
+    model: TransformModel;
+    /** A correspondence is an inlier when it reprojects within this many pixels. */
+    threshold: number;
+    maxIterations?: number;
+    /** Probability of having drawn at least one all-inlier sample. Drives early exit. */
+    confidence?: number;
+    /** Below this many inliers the answer is rejected outright. */
+    minInliers?: number;
+    seed?: number;
+}
+export interface RansacResult {
+    matrix: Matrix3;
+    /** Indices into the input array. */
+    inliers: number[];
+    inlierRatio: number;
+    iterations: number;
+    /** Mean reprojection error over the inliers, in pixels. */
+    error: number;
+}
+export declare function ransac(matches: readonly Correspondence[], options: RansacOptions): RansacResult | null;
+export declare function findInliers(matches: readonly Correspondence[], matrix: Matrix3, threshold: number): number[];
+//# sourceMappingURL=ransac.d.ts.map

package/dist/src/lib/estimate/ransac.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ransac.d.ts","sourceRoot":"","sources":["../../../../src/lib/estimate/ransac.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,OAAO,EAAE,cAAc,EAAE,MAAM,UAAU,CAAA;AACvD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,UAAU,CAAA;AAG9C;;;;;;;;;;GAUG;AAEH,MAAM,WAAW,aAAa;IAC5B,KAAK,EAAW,cAAc,CAAA;IAC9B,gFAAgF;IAChF,SAAS,EAAO,MAAM,CAAA;IACtB,aAAa,CAAC,EAAE,MAAM,CAAA;IACtB,qFAAqF;IACrF,UAAU,CAAC,EAAK,MAAM,CAAA;IACtB,+DAA+D;IAC/D,UAAU,CAAC,EAAK,MAAM,CAAA;IACtB,IAAI,CAAC,EAAW,MAAM,CAAA;CACvB;AAED,MAAM,WAAW,YAAY;IAC3B,MAAM,EAAO,OAAO,CAAA;IACpB,oCAAoC;IACpC,OAAO,EAAM,MAAM,EAAE,CAAA;IACrB,WAAW,EAAE,MAAM,CAAA;IACnB,UAAU,EAAG,MAAM,CAAA;IACnB,2DAA2D;IAC3D,KAAK,EAAQ,MAAM,CAAA;CACpB;AAED,wBAAgB,MAAM,CACpB,OAAO,EAAE,SAAS,cAAc,EAAE,EAClC,OAAO,EAAE,aAAa,GACrB,YAAY,GAAG,IAAI,CAmErB;AAED,wBAAgB,WAAW,CACzB,OAAO,EAAE,SAAS,cAAc,EAAE,EAClC,MAAM,EAAE,OAAO,EACf,SAAS,EAAE,MAAM,GAChB,MAAM,EAAE,CAMV"}

package/dist/src/lib/image/codec.d.ts

@@ -0,0 +1,30 @@
+import type { ImageInput, Raster } from '../types.js';
+/**
+ * Encoding and decoding, in pure JavaScript on purpose.
+ *
+ * `sharp` would be faster, and it is the wrong choice here: it is a native
+ * binding to libvips, so the bytes that work on your laptop are not the bytes
+ * that run in the function app, and a deployment that skips the rebuild fails
+ * at *import* time — after the cold start, in production, with a stack trace
+ * about a missing `.node` file. `pngjs` and `jpeg-js` are slower and they are
+ * the same JavaScript everywhere, which is the whole point of the constraint
+ * this library was written under.
+ */
+export type ImageFormat = 'png' | 'jpeg';
+export interface EncodeOptions {
+    format?: ImageFormat;
+    /** JPEG only, 1-100. Ignored for PNG. */
+    quality?: number;
+}
+/** Identify a buffer by its magic bytes. Returns `null` when it is neither PNG nor JPEG. */
+export declare function sniffFormat(bytes: Uint8Array): ImageFormat | null;
+/**
+ * Decode PNG or JPEG bytes to RGBA, or pass a {@link Raster} straight through.
+ *
+ * Passing a raster through untouched is what makes it cheap to align a page
+ * against several scans: decode once, reuse.
+ */
+export declare function decodeImage(input: ImageInput): Raster;
+/** Encode a raster. PNG by default, because a scan re-encoded as JPEG is a scan with new artefacts. */
+export declare function encodeImage(image: Raster, options?: EncodeOptions): Uint8Array;
+//# sourceMappingURL=codec.d.ts.map

package/dist/src/lib/image/codec.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"codec.d.ts","sourceRoot":"","sources":["../../../../src/lib/image/codec.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,EAAE,MAAM,UAAU,CAAA;AAGlD;;;;;;;;;;GAUG;AAEH,MAAM,MAAM,WAAW,GAAG,KAAK,GAAG,MAAM,CAAA;AAExC,MAAM,WAAW,aAAa;IAC5B,MAAM,CAAC,EAAG,WAAW,CAAA;IACrB,yCAAyC;IACzC,OAAO,CAAC,EAAE,MAAM,CAAA;CACjB;AAKD,4FAA4F;AAC5F,wBAAgB,WAAW,CAAE,KAAK,EAAE,UAAU,GAAG,WAAW,GAAG,IAAI,CAKlE;AAED;;;;;GAKG;AACH,wBAAgB,WAAW,CAAE,KAAK,EAAE,UAAU,GAAG,MAAM,CAoBtD;AAED,uGAAuG;AACvG,wBAAgB,WAAW,CAAE,KAAK,EAAE,MAAM,EAAE,OAAO,GAAE,aAAkB,GAAG,UAAU,CAgBnF"}