@scanmate/image-fix 0.0.3 → 0.0.4

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

@@ -1 +0,0 @@
-{"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

@@ -1,30 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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"}

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

@@ -1,67 +0,0 @@
-import type { BinaryImage, GrayImage, Raster } from '../types.js';
-/**
- * Turning a photograph of paper into something two images can be compared on.
- *
- * A scan differs from its source in ways that have nothing to do with where
- * the page is: the lamp is brighter in the middle, the phone cast a shadow
- * down one side, the JPEG quantiser smeared the strokes. Comparing raw
- * greyscale means comparing all of that too. So every stage below the codec
- * works on **ink**: greyscale divided by its own slowly-varying background and
- * inverted, which is near zero on paper and near one on print no matter what
- * the lighting did.
- *
- * Think of it as reading a page through a sheet of tracing paper — you lose
- * the tint of the paper and the angle of the lamp, and keep the writing.
- */
-/** Rec. 601 luminance, alpha composited over white, scaled to `[0, 1]`. */
-export declare function toGrayscale(image: Raster): GrayImage;
-/** Render a single channel back to RGBA, for debugging and diff overlays. */
-export declare function grayToRaster(image: GrayImage): Raster;
-/** Summed-area table with a zero first row and column, so a window sum is four lookups. */
-export declare function integralImage(image: GrayImage): Float64Array;
-/**
- * Mean over a `(2 * radius + 1)` square, in time independent of the radius.
- *
- * Border windows are clipped and divided by their real area rather than padded,
- * so the blur never invents dark paper outside the page.
- */
-export declare function boxBlur(image: GrayImage, radius: number): GrayImage;
-export interface InkOptions {
-    /**
-     * Background window as a fraction of the shorter side. The window has to be
-     * wide enough that no glyph can fill it — otherwise a bold heading becomes
-     * its own background and disappears — and narrow enough to follow a shadow.
-     */
-    backgroundFraction?: number;
-    /** Ink below this fraction of full black is treated as paper noise and zeroed. */
-    floor?: number;
-}
-/**
- * Greyscale to ink: divide out the local background, invert, clip the noise floor.
- *
- * Division rather than subtraction because illumination is multiplicative —
- * a shadow halves what reaches the sensor, it does not subtract a constant —
- * so dividing restores the same contrast in the shadow as in the light.
- */
-export declare function inkMap(gray: GrayImage, options?: InkOptions): GrayImage;
-/** Otsu's threshold over a 256-bin histogram of `[0, 1]` values. */
-export declare function otsuThreshold(image: GrayImage): number;
-/**
- * Ink to a binary mask.
- *
- * `threshold` defaults to Otsu's, with a floor: a page that is genuinely blank
- * has no bimodal split to find, and Otsu will happily cut its noise in half
- * and report that 50% of the paper is ink.
- */
-export declare function binarize(image: GrayImage, threshold?: number): BinaryImage;
-/**
- * Morphological dilation by a square, done as two 1D max passes.
- *
- * Used to give the original's ink a tolerance band before asking what is new
- * in the scan: without it, alignment that is half a pixel off reports the edge
- * of every printed character as freshly written.
- */
-export declare function dilate(mask: BinaryImage, radius: number): BinaryImage;
-/** Fraction of pixels set in `mask`, restricted to a rectangle when one is given. */
-export declare function coverage(mask: BinaryImage, x0?: number, y0?: number, x1?: number, y1?: number): number;
-//# sourceMappingURL=gray.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"gray.d.ts","sourceRoot":"","sources":["../../../../src/lib/image/gray.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,SAAS,EAAE,MAAM,EAAE,MAAM,UAAU,CAAA;AAG9D;;;;;;;;;;;;;GAaG;AAEH,2EAA2E;AAC3E,wBAAgB,WAAW,CAAE,KAAK,EAAE,MAAM,GAAG,SAAS,CAcrD;AAED,6EAA6E;AAC7E,wBAAgB,YAAY,CAAE,KAAK,EAAE,SAAS,GAAG,MAAM,CAWtD;AAED,2FAA2F;AAC3F,wBAAgB,aAAa,CAAE,KAAK,EAAE,SAAS,GAAG,YAAY,CAiB7D;AAED;;;;;GAKG;AACH,wBAAgB,OAAO,CAAE,KAAK,EAAE,SAAS,EAAE,MAAM,EAAE,MAAM,GAAG,SAAS,CAwBpE;AAED,MAAM,WAAW,UAAU;IACzB;;;;OAIG;IACH,kBAAkB,CAAC,EAAE,MAAM,CAAA;IAC3B,kFAAkF;IAClF,KAAK,CAAC,EAAe,MAAM,CAAA;CAC5B;AAED;;;;;;GAMG;AACH,wBAAgB,MAAM,CAAE,IAAI,EAAE,SAAS,EAAE,OAAO,GAAE,UAAe,GAAG,SAAS,CAc5E;AAED,oEAAoE;AACpE,wBAAgB,aAAa,CAAE,KAAK,EAAE,SAAS,GAAG,MAAM,CAmCvD;AAED;;;;;;GAMG;AACH,wBAAgB,QAAQ,CAAE,KAAK,EAAE,SAAS,EAAE,SAAS,CAAC,EAAE,MAAM,GAAG,WAAW,CAM3E;AAED;;;;;;GAMG;AACH,wBAAgB,MAAM,CAAE,IAAI,EAAE,WAAW,EAAE,MAAM,EAAE,MAAM,GAAG,WAAW,CAsCtE;AAED,qFAAqF;AACrF,wBAAgB,QAAQ,CAAE,IAAI,EAAE,WAAW,EAAE,EAAE,SAAI,EAAE,EAAE,SAAI,EAAE,EAAE,SAAa,EAAE,EAAE,SAAc,GAAG,MAAM,CActG"}

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

@@ -1,19 +0,0 @@
-import type { BinaryImage, GrayImage, ImageInput, Raster } from '../types.js';
-/** Allocate an opaque RGBA raster, filled with `fill` (white by default). */
-export declare function createRaster(width: number, height: number, fill?: [number, number, number, number]): Raster;
-export declare function createGray(width: number, height: number): GrayImage;
-export declare function createBinary(width: number, height: number): BinaryImage;
-export declare function cloneRaster(image: Raster): Raster;
-/**
- * True when the value is already a decoded raster.
- *
- * The check is structural rather than `instanceof` because a raster is a plain
- * object on purpose: callers should be able to hand us a canvas `ImageData`,
- * or something they built themselves, without importing anything from here.
- */
-export declare function isRaster(value: unknown): value is Raster;
-/** Narrow any accepted input to the bytes of an encoded image, or `null` if it is already decoded. */
-export declare function toBytes(input: ImageInput): Uint8Array | null;
-/** Wrap bytes as a `Uint8ClampedArray` without copying when the alignment allows it. */
-export declare function asClamped(data: Uint8Array): Uint8ClampedArray;
-//# sourceMappingURL=raster.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"raster.d.ts","sourceRoot":"","sources":["../../../../src/lib/image/raster.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,SAAS,EAAE,UAAU,EAAE,MAAM,EAAE,MAAM,UAAU,CAAA;AAE1E,6EAA6E;AAC7E,wBAAgB,YAAY,CAAE,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,IAAI,GAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,CAAwB,GAAG,MAAM,CAYlI;AAED,wBAAgB,UAAU,CAAE,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,SAAS,CAIpE;AAED,wBAAgB,YAAY,CAAE,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,WAAW,CAIxE;AAED,wBAAgB,WAAW,CAAE,KAAK,EAAE,MAAM,GAAG,MAAM,CAElD;AAED;;;;;;GAMG;AACH,wBAAgB,QAAQ,CAAE,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,MAAM,CAUzD;AAED,sGAAsG;AACtG,wBAAgB,OAAO,CAAE,KAAK,EAAE,UAAU,GAAG,UAAU,GAAG,IAAI,CAM7D;AAED,wFAAwF;AACxF,wBAAgB,SAAS,CAAE,IAAI,EAAE,UAAU,GAAG,iBAAiB,CAI9D"}

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

@@ -1,32 +0,0 @@
-import type { GrayImage, Raster } from '../types.js';
-/**
- * Separable resampling: area-average going down, bilinear going up.
- *
- * Going down matters more than it sounds. Point-sampling a 300 dpi scan to
- * half size drops every other row, and on a page of 9pt text that deletes
- * roughly half the strokes — the thumbnail the matcher sees is not a smaller
- * version of the page, it is a different page. Averaging over the exact source
- * footprint of each destination pixel is what keeps the ink where it was.
- */
-/** Resize a single channel image to exactly `width x height`. */
-export declare function resizeGray(src: GrayImage, width: number, height: number): GrayImage;
-/**
- * Shrink so the longer side is at most `maxDimension`.
- *
- * Returns the factor applied, because every coordinate the caller recovers in
- * this smaller frame has to be scaled back up by it.
- */
-export declare function downscaleGray(src: GrayImage, maxDimension: number): {
-    image: GrayImage;
-    scale: number;
-};
-/**
- * Box blur an RGBA raster with two sliding-window passes.
- *
- * Lives here rather than with the other blurs because its only caller is the
- * warp prefilter, and because it has to work in bytes: a summed-area table over
- * four channels of a 12 megapixel scan is 400 MB, which is not a thing to
- * allocate inside a function app.
- */
-export declare function boxBlurRaster(src: Raster, radius: number): Raster;
-//# sourceMappingURL=resize.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"resize.d.ts","sourceRoot":"","sources":["../../../../src/lib/image/resize.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,EAAE,MAAM,UAAU,CAAA;AAGjD;;;;;;;;GAQG;AAEH,iEAAiE;AACjE,wBAAgB,UAAU,CAAE,GAAG,EAAE,SAAS,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,SAAS,CAUpF;AAED;;;;;GAKG;AACH,wBAAgB,aAAa,CAAE,GAAG,EAAE,SAAS,EAAE,YAAY,EAAE,MAAM,GAAG;IAAE,KAAK,EAAE,SAAS,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,CAUxG;AAED;;;;;;;GAOG;AACH,wBAAgB,aAAa,CAAE,GAAG,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,MAAM,CAsDlE"}

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

@@ -1,28 +0,0 @@
-import type { GrayImage, Matrix3, Raster } from '../types.js';
-/**
- * Resampling one image onto another image's grid.
- *
- * The matrix maps **destination coordinates to source coordinates** — we stand
- * on each output pixel and reach back into the scan for its colour. Doing it
- * the other way, pushing scan pixels forward, leaves the output full of pinholes
- * wherever the transform stretches, for the same reason a rotated stencil
- * sprays gaps.
- */
-export type Interpolation = 'nearest' | 'bilinear' | 'bicubic';
-export interface WarpOptions {
-    /** RGBA fill for destination pixels that fall outside the source. Opaque white by default. */
-    background?: [number, number, number, number];
-    interpolation?: Interpolation;
-    /**
-     * Low-pass the source before minifying, so shrinking a 300 dpi scan does not
-     * alias the text into stripes. On by default; it costs one blur.
-     */
-    prefilter?: boolean;
-}
-/** Warp an RGBA raster onto a `width x height` canvas. */
-export declare function warpRaster(source: Raster, matrix: Matrix3, width: number, height: number, options?: WarpOptions): Raster;
-/** Warp a single channel image. Used for scoring, where colour is noise. */
-export declare function warpGray(source: GrayImage, matrix: Matrix3, width: number, height: number, fill?: number): GrayImage;
-/** Bilinear read at a fractional index, returning `fill` outside the image. */
-export declare function sampleGrayBilinear(image: GrayImage, u: number, v: number, fill?: number): number;
-//# sourceMappingURL=warp.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"warp.d.ts","sourceRoot":"","sources":["../../../../src/lib/image/warp.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,UAAU,CAAA;AAI1D;;;;;;;;GAQG;AAEH,MAAM,MAAM,aAAa,GAAG,SAAS,GAAG,UAAU,GAAG,SAAS,CAAA;AAE9D,MAAM,WAAW,WAAW;IAC1B,8FAA8F;IAC9F,UAAU,CAAC,EAAK,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAA;IAChD,aAAa,CAAC,EAAE,aAAa,CAAA;IAC7B;;;OAGG;IACH,SAAS,CAAC,EAAM,OAAO,CAAA;CACxB;AAED,0DAA0D;AAC1D,wBAAgB,UAAU,CACxB,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,OAAO,EACf,KAAK,EAAE,MAAM,EACb,MAAM,EAAE,MAAM,EACd,OAAO,GAAE,WAAgB,GACxB,MAAM,CAsCR;AAED,4EAA4E;AAC5E,wBAAgB,QAAQ,CACtB,MAAM,EAAE,SAAS,EACjB,MAAM,EAAE,OAAO,EACf,KAAK,EAAE,MAAM,EACb,MAAM,EAAE,MAAM,EACd,IAAI,SAAI,GACP,SAAS,CAuBX;AAED,+EAA+E;AAC/E,wBAAgB,kBAAkB,CAAE,KAAK,EAAE,SAAS,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,IAAI,SAAI,GAAG,MAAM,CA2B5F"}

package/dist/src/lib/math/fft.d.ts

@@ -1,15 +0,0 @@
-/**
- * In-place radix-2 Cooley-Tukey FFT, real and imaginary parts in separate arrays.
- *
- * Only used by phase correlation, which needs a *global* translation estimate
- * that no amount of local feature matching can produce on a page with almost
- * nothing printed on it. Sizes must be powers of two; {@link nextPowerOfTwo}
- * and the caller's zero padding see to that.
- */
-export declare function nextPowerOfTwo(n: number): number;
-export declare function isPowerOfTwo(n: number): boolean;
-/** Transform `re`/`im` of length `n` in place. `inverse` also divides by `n`. */
-export declare function fft1d(re: Float64Array, im: Float64Array, inverse?: boolean): void;
-/** 2D transform of a `width x height` row-major complex image, rows then columns. */
-export declare function fft2d(re: Float64Array, im: Float64Array, width: number, height: number, inverse?: boolean): void;
-//# sourceMappingURL=fft.d.ts.map

package/dist/src/lib/math/fft.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"fft.d.ts","sourceRoot":"","sources":["../../../../src/lib/math/fft.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,wBAAgB,cAAc,CAAE,CAAC,EAAE,MAAM,GAAG,MAAM,CAKjD;AAED,wBAAgB,YAAY,CAAE,CAAC,EAAE,MAAM,GAAG,OAAO,CAEhD;AAED,iFAAiF;AACjF,wBAAgB,KAAK,CAAE,EAAE,EAAE,YAAY,EAAE,EAAE,EAAE,YAAY,EAAE,OAAO,UAAQ,GAAG,IAAI,CA0DhF;AAED,qFAAqF;AACrF,wBAAgB,KAAK,CACnB,EAAE,EAAE,YAAY,EAChB,EAAE,EAAE,YAAY,EAChB,KAAK,EAAE,MAAM,EACb,MAAM,EAAE,MAAM,EACd,OAAO,UAAQ,GACd,IAAI,CAyBN"}

package/dist/src/lib/math/linalg.d.ts

@@ -1,34 +0,0 @@
-/**
- * The two dense solvers the estimators need, and nothing more.
- *
- * Both work on plain row-major `Float64Array`s of a fixed, tiny size (n <= 9),
- * so there is no pivoting strategy worth agonising over and no allocation
- * pressure worth caring about.
- */
-/**
- * Solve `A x = b` by Gaussian elimination with partial pivoting.
- *
- * `a` is destroyed. Returns `null` when the system is singular, which for the
- * affine fit means the sample points were collinear — a real, common case, not
- * an exceptional one, so it is a return value rather than a throw.
- */
-export declare function solve(a: Float64Array, b: Float64Array, n: number): Float64Array | null;
-/**
- * Eigen-decompose a symmetric matrix with the cyclic Jacobi method.
- *
- * Jacobi is the right tool at this size: it is a dozen lines, it is
- * unconditionally stable for symmetric input, and it gives eigenvectors for
- * free. The homography fit needs the eigenvector of `A^T A` belonging to the
- * smallest eigenvalue — the direction the data constrains least, which is the
- * null-space direction we are after.
- *
- * @param input Row-major, `n * n`, symmetric. Not modified.
- * @returns `values[i]` paired with column `i` of `vectors` (`vectors[row * n + i]`).
- */
-export declare function jacobiEigen(input: Float64Array, n: number, maxSweeps?: number): {
-    values: Float64Array;
-    vectors: Float64Array;
-};
-/** The unit eigenvector of a symmetric `n x n` matrix belonging to its smallest eigenvalue. */
-export declare function smallestEigenvector(input: Float64Array, n: number): Float64Array;
-//# sourceMappingURL=linalg.d.ts.map

package/dist/src/lib/math/linalg.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"linalg.d.ts","sourceRoot":"","sources":["../../../../src/lib/math/linalg.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH;;;;;;GAMG;AACH,wBAAgB,KAAK,CAAE,CAAC,EAAE,YAAY,EAAE,CAAC,EAAE,YAAY,EAAE,CAAC,EAAE,MAAM,GAAG,YAAY,GAAG,IAAI,CA2CvF;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,WAAW,CACzB,KAAK,EAAE,YAAY,EACnB,CAAC,EAAE,MAAM,EACT,SAAS,SAAK,GACb;IAAE,MAAM,EAAE,YAAY,CAAC;IAAC,OAAO,EAAE,YAAY,CAAA;CAAE,CAgDjD;AAED,+FAA+F;AAC/F,wBAAgB,mBAAmB,CAAE,KAAK,EAAE,YAAY,EAAE,CAAC,EAAE,MAAM,GAAG,YAAY,CAgBjF"}

package/dist/src/lib/math/matrix.d.ts

@@ -1,75 +0,0 @@
-import type { Matrix3, Point, Rect, TransformModel, TransformSummary } from '../types.js';
-/**
- * 3x3 homogeneous matrix helpers.
- *
- * ## The one convention that matters
- *
- * Every matrix in this library maps **original coordinates to scanned
- * coordinates**, never the other way round. That reads backwards the first
- * time: we are producing an image on the original's canvas, so we walk the
- * output pixel by pixel and ask "where in the scan does this come from?".
- * Inverse mapping is what stops the output having holes — forward-splatting a
- * rotated source leaves gaps between the splats, like spray-painting through a
- * rotated stencil.
- *
- * Coordinates are continuous, with the centre of pixel `(i, j)` at
- * `(i + 0.5, j + 0.5)`. Sticking to that is what makes {@link conjugateScale}
- * a plain scale conjugation instead of a scale plus a half-pixel fudge.
- */
-export declare const IDENTITY: Matrix3;
-/** `a * b` — the transform that applies `b` first, then `a`. */
-export declare function multiply(a: Matrix3, b: Matrix3): Matrix3;
-export declare function determinant(m: Matrix3): number;
-/** Throws when `m` is singular — a transform that collapses the page to a line is never a usable answer. */
-export declare function invert(m: Matrix3): Matrix3;
-/** Divide through by `m8` so two matrices describing the same transform compare equal. */
-export declare function normalize(m: Matrix3): Matrix3;
-export declare function applyPoint(m: Matrix3, x: number, y: number): Point;
-export declare function translation(tx: number, ty: number): Matrix3;
-export declare function scaling(sx: number, sy?: number): Matrix3;
-/**
- * Scale `s` and rotation `angleRad` about `pivot`, then land that pivot on `target`.
- *
- * This is the shape the coarse stage produces: "the middle of the original's
- * printed content is the middle of the scan's printed content, turned by this
- * much and this many times bigger".
- */
-export declare function similarity(s: number, angleRad: number, pivot: Point, target: Point): Matrix3;
-/**
- * Re-express `m` in a coordinate frame scaled by `k`.
- *
- * Fitting runs on downscaled copies because matching 3000x4000 images is a
- * waste; the matrix that comes back speaks in those small pixels. `k` is
- * `working / full`, and the result speaks in full-resolution pixels.
- */
-export declare function conjugateScale(m: Matrix3, k: number): Matrix3;
-/**
- * Re-express a matrix whose two frames were scaled by different factors.
- *
- * The coarse stage measures on two independently shrunk copies - the original
- * and the scan rarely have the same pixel count, so they rarely shrink by the
- * same factor. `sourceScale` and `targetScale` are each `working / full` for
- * their own side, and the result speaks full-resolution pixels on both.
- */
-export declare function rebase(m: Matrix3, sourceScale: number, targetScale: number): Matrix3;
-/** The four corners of `rect` mapped through `m`, clockwise from the top-left. */
-export declare function mapRectCorners(m: Matrix3, rect: Rect): Point[];
-/**
- * Pull a matrix apart into scale, rotation and shear.
- *
- * The 2x2 linear part is factored as `R(theta) * [[sx, k], [0, sy]]`, which is
- * the order a scanner actually applies them: the page is stretched on the
- * glass, then the whole thing sits at an angle.
- */
-export declare function decompose(m: Matrix3, model: TransformModel): TransformSummary;
-/** Euclidean distance between `m * source` and `target`, in target pixels. */
-export declare function reprojectionError(m: Matrix3, source: Point, target: Point): number;
-/**
- * True when `m` is a plausible page-to-page transform rather than numerical debris.
- *
- * RANSAC on a minimal sample of near-collinear points loves to return a
- * matrix that folds the page in half. Cheaper to reject it here than to
- * discover it in the output.
- */
-export declare function isPlausible(m: Matrix3, maxScaleRatio?: number): boolean;
-//# sourceMappingURL=matrix.d.ts.map

package/dist/src/lib/math/matrix.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"matrix.d.ts","sourceRoot":"","sources":["../../../../src/lib/math/matrix.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,KAAK,EAAE,IAAI,EAAE,cAAc,EAAE,gBAAgB,EAAE,MAAM,UAAU,CAAA;AAEtF;;;;;;;;;;;;;;;;GAgBG;AAEH,eAAO,MAAM,QAAQ,EAAE,OAAqC,CAAA;AAE5D,gEAAgE;AAChE,wBAAgB,QAAQ,CAAE,CAAC,EAAE,OAAO,EAAE,CAAC,EAAE,OAAO,GAAG,OAAO,CAczD;AAED,wBAAgB,WAAW,CAAE,CAAC,EAAE,OAAO,GAAG,MAAM,CAM/C;AAED,4GAA4G;AAC5G,wBAAgB,MAAM,CAAE,CAAC,EAAE,OAAO,GAAG,OAAO,CAoB3C;AAED,0FAA0F;AAC1F,wBAAgB,SAAS,CAAE,CAAC,EAAE,OAAO,GAAG,OAAO,CAK9C;AAED,wBAAgB,UAAU,CAAE,CAAC,EAAE,OAAO,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,KAAK,CAKnE;AAED,wBAAgB,WAAW,CAAE,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,GAAG,OAAO,CAE5D;AAED,wBAAgB,OAAO,CAAE,EAAE,EAAE,MAAM,EAAE,EAAE,SAAK,GAAG,OAAO,CAErD;AAED;;;;;;GAMG;AACH,wBAAgB,UAAU,CAAE,CAAC,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,KAAK,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK,GAAG,OAAO,CAS7F;AAED;;;;;;GAMG;AACH,wBAAgB,cAAc,CAAE,CAAC,EAAE,OAAO,EAAE,CAAC,EAAE,MAAM,GAAG,OAAO,CAE9D;AAED;;;;;;;GAOG;AACH,wBAAgB,MAAM,CAAE,CAAC,EAAE,OAAO,EAAE,WAAW,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,GAAG,OAAO,CAErF;AAED,kFAAkF;AAClF,wBAAgB,cAAc,CAAE,CAAC,EAAE,OAAO,EAAE,IAAI,EAAE,IAAI,GAAG,KAAK,EAAE,CAS/D;AAED;;;;;;GAMG;AACH,wBAAgB,SAAS,CAAE,CAAC,EAAE,OAAO,EAAE,KAAK,EAAE,cAAc,GAAG,gBAAgB,CAiB9E;AAED,8EAA8E;AAC9E,wBAAgB,iBAAiB,CAAE,CAAC,EAAE,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK,GAAG,MAAM,CAInF;AAED;;;;;;GAMG;AACH,wBAAgB,WAAW,CAAE,CAAC,EAAE,OAAO,EAAE,aAAa,SAAI,GAAG,OAAO,CAenE"}

package/dist/src/lib/math/random.d.ts

@@ -1,13 +0,0 @@
-/**
- * A seeded PRNG, so that two runs on the same bytes give the same matrix.
- *
- * RANSAC samples at random and the BRIEF pattern is drawn at random; with
- * `Math.random` the library would return a slightly different answer every
- * time, which makes a regression test a coin toss and a production bug
- * impossible to reproduce from the inputs alone. mulberry32 is 32 bits of
- * state and passes the statistical tests that matter at this scale.
- */
-export declare function createRandom(seed: number): () => number;
-/** Box-Muller, used to draw the BRIEF sampling pattern from a Gaussian around the patch centre. */
-export declare function gaussian(random: () => number): number;
-//# sourceMappingURL=random.d.ts.map

package/dist/src/lib/math/random.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"random.d.ts","sourceRoot":"","sources":["../../../../src/lib/math/random.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,wBAAgB,YAAY,CAAE,IAAI,EAAE,MAAM,GAAG,MAAM,MAAM,CAWxD;AAED,mGAAmG;AACnG,wBAAgB,QAAQ,CAAE,MAAM,EAAE,MAAM,MAAM,GAAG,MAAM,CAKtD"}

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

@@ -1,75 +0,0 @@
-import type { InkOptions } from './image/gray.js';
-import type { ImageInput, Raster, Rect } from './types.js';
-/**
- * What changed, and where.
- *
- * Once the scan sits on the original's canvas, "was this box signed?" stops
- * being an image problem and becomes arithmetic: count the ink inside the
- * rectangle that is present in the scan and absent from the original.
- *
- * The one subtlety is the tolerance band. Alignment is good to a pixel or so,
- * never to zero, and printed text is mostly edges — so a half-pixel shift
- * lights up the outline of every character as "new ink". Dilating the
- * original's mask first (fattening every stroke by a couple of pixels) absorbs
- * that, the way a proofreader ignores a letter sitting a hair off the baseline.
- * What it cannot absorb is a signature, which is ink in places the original has
- * none.
- */
-export interface Region {
-    id: string;
-    /** In the *original's* pixel coordinates - the whole point of aligning first. */
-    rect: Rect;
-    /** Fraction of the region that must be new ink before `filled` is true. Overrides the global default. */
-    threshold?: number;
-}
-export interface RegionOptions {
-    ink?: InkOptions;
-    /**
-     * Radius, in pixels, that the original's ink is fattened by before diffing.
-     * Raise it if alignment is loose; lower it to catch very fine additions.
-     */
-    tolerance?: number;
-    /** Default fraction of new ink that counts as filled. */
-    threshold?: number;
-}
-export interface RegionReport {
-    id: string;
-    rect: Rect;
-    /** Ink coverage of the region in the original, in `[0, 1]`. */
-    originalInk: number;
-    /** Ink coverage of the region in the aligned scan. */
-    scanInk: number;
-    /** Coverage that is ink in the scan and not within `tolerance` of ink in the original. */
-    added: number;
-    /** Coverage that is ink in the original and missing from the scan. Mostly a faint-scan warning. */
-    removed: number;
-    filled: boolean;
-    /** `added` as a multiple of the threshold, clamped to `[0, 1]`. A reportable confidence. */
-    score: number;
-}
-export interface DocumentDiff {
-    /** Page-wide version of {@link RegionReport.added}. */
-    added: number;
-    removed: number;
-    regions: RegionReport[];
-}
-/**
- * Compare an aligned scan against its original over a set of known rectangles.
- *
- * `aligned` must be the output of `alignScan` - or anything else already on the
- * original's canvas. Feeding a raw scan in produces confident nonsense, because
- * every rectangle then names a different part of the page in each image.
- */
-export declare function compareRegions(original: ImageInput, aligned: ImageInput, regions: readonly Region[], options?: RegionOptions): RegionReport[];
-/** Page-wide added/removed ink, plus per-region detail for any regions supplied. */
-export declare function diffDocument(original: ImageInput, aligned: ImageInput, regions?: readonly Region[], options?: RegionOptions): DocumentDiff;
-/**
- * An RGBA overlay of the comparison, for looking at with your own eyes.
- *
- * Red is ink the scan added, blue is ink it lost, grey is ink both agree on.
- * A correctly aligned pair of a signed form is almost entirely grey with a red
- * signature; a misaligned one is red and blue confetti along every stroke,
- * which is the fastest way to tell the two failures apart.
- */
-export declare function renderDiff(original: ImageInput, aligned: ImageInput, options?: RegionOptions): Raster;
-//# sourceMappingURL=regions.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"regions.d.ts","sourceRoot":"","sources":["../../../src/lib/regions.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,cAAc,CAAA;AAE9C,OAAO,KAAK,EAAe,UAAU,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,SAAS,CAAA;AAEpE;;;;;;;;;;;;;;GAcG;AAEH,MAAM,WAAW,MAAM;IACrB,EAAE,EAAU,MAAM,CAAA;IAClB,iFAAiF;IACjF,IAAI,EAAQ,IAAI,CAAA;IAChB,yGAAyG;IACzG,SAAS,CAAC,EAAE,MAAM,CAAA;CACnB;AAED,MAAM,WAAW,aAAa;IAC5B,GAAG,CAAC,EAAQ,UAAU,CAAA;IACtB;;;OAGG;IACH,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,yDAAyD;IACzD,SAAS,CAAC,EAAE,MAAM,CAAA;CACnB;AAED,MAAM,WAAW,YAAY;IAC3B,EAAE,EAAW,MAAM,CAAA;IACnB,IAAI,EAAS,IAAI,CAAA;IACjB,+DAA+D;IAC/D,WAAW,EAAE,MAAM,CAAA;IACnB,sDAAsD;IACtD,OAAO,EAAM,MAAM,CAAA;IACnB,0FAA0F;IAC1F,KAAK,EAAQ,MAAM,CAAA;IACnB,mGAAmG;IACnG,OAAO,EAAM,MAAM,CAAA;IACnB,MAAM,EAAO,OAAO,CAAA;IACpB,4FAA4F;IAC5F,KAAK,EAAQ,MAAM,CAAA;CACpB;AAED,MAAM,WAAW,YAAY;IAC3B,uDAAuD;IACvD,KAAK,EAAI,MAAM,CAAA;IACf,OAAO,EAAE,MAAM,CAAA;IACf,OAAO,EAAE,YAAY,EAAE,CAAA;CACxB;AAED;;;;;;GAMG;AACH,wBAAgB,cAAc,CAC5B,QAAQ,EAAE,UAAU,EACpB,OAAO,EAAE,UAAU,EACnB,OAAO,EAAE,SAAS,MAAM,EAAE,EAC1B,OAAO,GAAE,aAAkB,GAC1B,YAAY,EAAE,CAKhB;AAED,oFAAoF;AACpF,wBAAgB,YAAY,CAC1B,QAAQ,EAAE,UAAU,EACpB,OAAO,EAAE,UAAU,EACnB,OAAO,GAAE,SAAS,MAAM,EAAO,EAC/B,OAAO,GAAE,aAAkB,GAC1B,YAAY,CAWd;AAED;;;;;;;GAOG;AACH,wBAAgB,UAAU,CACxB,QAAQ,EAAE,UAAU,EACpB,OAAO,EAAE,UAAU,EACnB,OAAO,GAAE,aAAkB,GAC1B,MAAM,CAoCR"}

package/dist/src/lib/testing/synthetic.d.ts

@@ -1,73 +0,0 @@
-import type { Matrix3, Raster, Rect } from '../types.js';
-/**
- * Synthetic pages, and synthetic scans of them.
- *
- * Alignment is awkward to test honestly: with two real images you have no
- * ground truth, only an opinion about whether the output looks right. Generate
- * the page and then the distortion yourself and you know the exact matrix the
- * estimator is supposed to recover, so a test can assert a number of pixels
- * instead of a feeling.
- *
- * It is exported rather than kept in the test folder because the same trick is
- * how you smoke-test a deployment: generate, distort, align, check the error is
- * small, all without shipping sample scans.
- */
-export interface DocumentOptions {
-    width?: number;
-    height?: number;
-    seed?: number;
-    /** Where a signature would go. Left empty by {@link createSyntheticDocument}. */
-    signatureBox?: Rect;
-}
-export interface SyntheticDocument {
-    raster: Raster;
-    /** Rectangles a caller may want to inspect later: the signature box, the tick boxes. */
-    regions: Record<string, Rect>;
-}
-export interface ScanOptions {
-    rotationDeg?: number;
-    /** Size of the scan relative to the page. `1.5` is roughly 300 dpi against a 200 dpi render. */
-    scale?: number;
-    translateX?: number;
-    translateY?: number;
-    /** Standard deviation of additive sensor noise, in `[0, 1]` units. */
-    noise?: number;
-    /** Box blur radius, standing in for an out-of-focus or low-quality scan. */
-    blur?: number;
-    /** Strength of a diagonal lighting ramp, in `[0, 1]`. `0.3` is a pronounced shadow. */
-    illumination?: number;
-    /** Scan canvas. Defaults to the page scaled by `scale`, so the whole page fits. */
-    canvas?: {
-        width: number;
-        height: number;
-    };
-    seed?: number;
-}
-export interface SimulatedScan {
-    raster: Raster;
-    /** Ground truth: maps original coordinates to scanned coordinates. */
-    matrix: Matrix3;
-}
-/**
- * A plausible printed form: header rule, paragraphs, a table, tick boxes, a
- * signature box. Deterministic for a given seed.
- */
-export declare function createSyntheticDocument(options?: DocumentOptions): SyntheticDocument;
-/** Scribble inside a rectangle, the way a signature crosses a signature box. */
-export declare function drawSignature(page: Raster, box: Rect, seed?: number): void;
-/** Fill a tick box, the way a pen does. */
-export declare function drawTick(page: Raster, box: Rect): void;
-/**
- * Put a page through everything a scanner does to it, and report the matrix used.
- *
- * Order matters and mirrors the physical one: the page is placed on the glass
- * somewhere, at some angle, and sampled at some resolution (the geometry);
- * then the lamp falls off towards one corner, the optics blur, and the sensor
- * adds noise (the photometry). Estimators that only ever see clean geometric
- * distortion pass tests and fail on real scans.
- */
-export declare function simulateScan(page: Raster, options?: ScanOptions): SimulatedScan;
-export declare function fillRect(page: Raster, rect: Rect, value: number): void;
-export declare function strokeRect(page: Raster, rect: Rect, thickness: number, value: number): void;
-export declare function drawLine(page: Raster, x0: number, y0: number, x1: number, y1: number, thickness: number, value: number): void;
-//# sourceMappingURL=synthetic.d.ts.map

package/dist/src/lib/testing/synthetic.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"synthetic.d.ts","sourceRoot":"","sources":["../../../../src/lib/testing/synthetic.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,UAAU,CAAA;AAErD;;;;;;;;;;;;GAYG;AAEH,MAAM,WAAW,eAAe;IAC9B,KAAK,CAAC,EAAS,MAAM,CAAA;IACrB,MAAM,CAAC,EAAQ,MAAM,CAAA;IACrB,IAAI,CAAC,EAAU,MAAM,CAAA;IACrB,iFAAiF;IACjF,YAAY,CAAC,EAAE,IAAI,CAAA;CACpB;AAED,MAAM,WAAW,iBAAiB;IAChC,MAAM,EAAG,MAAM,CAAA;IACf,wFAAwF;IACxF,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,IAAI,CAAC,CAAA;CAC9B;AAED,MAAM,WAAW,WAAW;IAC1B,WAAW,CAAC,EAAG,MAAM,CAAA;IACrB,gGAAgG;IAChG,KAAK,CAAC,EAAS,MAAM,CAAA;IACrB,UAAU,CAAC,EAAI,MAAM,CAAA;IACrB,UAAU,CAAC,EAAI,MAAM,CAAA;IACrB,sEAAsE;IACtE,KAAK,CAAC,EAAS,MAAM,CAAA;IACrB,4EAA4E;IAC5E,IAAI,CAAC,EAAU,MAAM,CAAA;IACrB,uFAAuF;IACvF,YAAY,CAAC,EAAE,MAAM,CAAA;IACrB,mFAAmF;IACnF,MAAM,CAAC,EAAQ;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAE,CAAA;IAChD,IAAI,CAAC,EAAU,MAAM,CAAA;CACtB;AAED,MAAM,WAAW,aAAa;IAC5B,MAAM,EAAE,MAAM,CAAA;IACd,sEAAsE;IACtE,MAAM,EAAE,OAAO,CAAA;CAChB;AAED;;;GAGG;AACH,wBAAgB,uBAAuB,CAAE,OAAO,GAAE,eAAoB,GAAG,iBAAiB,CAmFzF;AAED,gFAAgF;AAChF,wBAAgB,aAAa,CAAE,IAAI,EAAE,MAAM,EAAE,GAAG,EAAE,IAAI,EAAE,IAAI,SAAI,GAAG,IAAI,CActE;AAED,2CAA2C;AAC3C,wBAAgB,QAAQ,CAAE,IAAI,EAAE,MAAM,EAAE,GAAG,EAAE,IAAI,GAAG,IAAI,CAIvD;AAED;;;;;;;;GAQG;AACH,wBAAgB,YAAY,CAAE,IAAI,EAAE,MAAM,EAAE,OAAO,GAAE,WAAgB,GAAG,aAAa,CA+CpF;AAkDD,wBAAgB,QAAQ,CAAE,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,IAAI,EAAE,KAAK,EAAE,MAAM,GAAG,IAAI,CAevE;AAED,wBAAgB,UAAU,CAAE,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,IAAI,EAAE,SAAS,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,IAAI,CAM5F;AAED,wBAAgB,QAAQ,CACtB,IAAI,EAAE,MAAM,EACZ,EAAE,EAAE,MAAM,EACV,EAAE,EAAE,MAAM,EACV,EAAE,EAAE,MAAM,EACV,EAAE,EAAE,MAAM,EACV,SAAS,EAAE,MAAM,EACjB,KAAK,EAAE,MAAM,GACZ,IAAI,CAYN"}

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

@@ -1,86 +0,0 @@
-/**
- * Core data types.
- *
- * Everything in this library speaks two image shapes and nothing else:
- *
- * - {@link Raster} — what you get in and out: 8-bit RGBA, the same memory
- *   layout a `<canvas>` `ImageData` uses, so it needs no conversion to be
- *   re-encoded, handed to an OCR engine, or drawn.
- * - {@link GrayImage} — what the algorithms work on: one float per pixel.
- *   Float, not byte, because the pipeline divides by an estimated background
- *   and then correlates the result; doing that in 8 bits throws away the
- *   faint strokes that OCR cares about.
- */
-/** A decoded image: 8-bit RGBA, row-major, 4 bytes per pixel, no padding. */
-export interface Raster {
-    width: number;
-    height: number;
-    /** `width * height * 4` bytes, in R, G, B, A order. */
-    data: Uint8ClampedArray;
-}
-/** A single-channel image. Values are normally in `[0, 1]` but are not clamped. */
-export interface GrayImage {
-    width: number;
-    height: number;
-    data: Float32Array;
-}
-/** A single-channel mask. Every value is exactly `0` or `1`. */
-export interface BinaryImage {
-    width: number;
-    height: number;
-    data: Uint8Array;
-}
-/**
- * A row-major 3x3 matrix in homogeneous coordinates:
- *
- * ```text
- * [ m0 m1 m2 ]
- * [ m3 m4 m5 ]
- * [ m6 m7 m8 ]
- * ```
- */
-export type Matrix3 = readonly [number, number, number, number, number, number, number, number, number];
-export interface Point {
-    x: number;
-    y: number;
-}
-/** An axis-aligned rectangle in pixel coordinates. `x`/`y` are the top-left corner. */
-export interface Rect {
-    x: number;
-    y: number;
-    width: number;
-    height: number;
-}
-/** Anything the library will accept as an image: an encoded PNG/JPEG, or an already-decoded raster. */
-export type ImageInput = Raster | Uint8Array | ArrayBuffer;
-/** Which family of transform to fit. Fewer degrees of freedom is more robust; more is more expressive. */
-export type TransformModel = 
-/** 4 DOF: uniform scale, rotation, translation. A flatbed scan of a flat page. */
-'similarity' | 
-/** 6 DOF: adds non-uniform scale and shear. A scan whose feed stretched one axis. */
-'affine' | 
-/** 8 DOF: full projective warp. A photograph taken off-axis. */
-'homography';
-/** The geometric meaning of a fitted matrix, pulled apart into numbers a human can sanity-check. */
-export interface TransformSummary {
-    model: TransformModel;
-    /** Scale along the scan's x axis. `1` means the scan matches the original's pixel scale. */
-    scaleX: number;
-    scaleY: number;
-    /** Rotation in degrees, counter-clockwise positive in image coordinates. */
-    rotationDeg: number;
-    /** Residual shear in degrees. Non-zero only for `affine` and `homography`. */
-    shearDeg: number;
-    /** Where the original's top-left corner lands in the scan. */
-    translation: Point;
-    /** Perspective terms (`m6`, `m7`). Non-zero only for `homography`. */
-    perspective: Point;
-}
-/** One `(original, scanned)` correspondence produced by feature matching. */
-export interface PointMatch {
-    source: Point;
-    target: Point;
-    /** Hamming distance between the two descriptors. Lower is a better match. */
-    distance: number;
-}
-//# sourceMappingURL=types.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/lib/types.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,6EAA6E;AAC7E,MAAM,WAAW,MAAM;IACrB,KAAK,EAAG,MAAM,CAAA;IACd,MAAM,EAAE,MAAM,CAAA;IACd,uDAAuD;IACvD,IAAI,EAAI,iBAAiB,CAAA;CAC1B;AAED,mFAAmF;AACnF,MAAM,WAAW,SAAS;IACxB,KAAK,EAAG,MAAM,CAAA;IACd,MAAM,EAAE,MAAM,CAAA;IACd,IAAI,EAAI,YAAY,CAAA;CACrB;AAED,gEAAgE;AAChE,MAAM,WAAW,WAAW;IAC1B,KAAK,EAAG,MAAM,CAAA;IACd,MAAM,EAAE,MAAM,CAAA;IACd,IAAI,EAAI,UAAU,CAAA;CACnB;AAED;;;;;;;;GAQG;AACH,MAAM,MAAM,OAAO,GAAG,SAAS,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAA;AAEvG,MAAM,WAAW,KAAK;IACpB,CAAC,EAAE,MAAM,CAAA;IACT,CAAC,EAAE,MAAM,CAAA;CACV;AAED,uFAAuF;AACvF,MAAM,WAAW,IAAI;IACnB,CAAC,EAAO,MAAM,CAAA;IACd,CAAC,EAAO,MAAM,CAAA;IACd,KAAK,EAAG,MAAM,CAAA;IACd,MAAM,EAAE,MAAM,CAAA;CACf;AAED,uGAAuG;AACvG,MAAM,MAAM,UAAU,GAAG,MAAM,GAAG,UAAU,GAAG,WAAW,CAAA;AAE1D,0GAA0G;AAC1G,MAAM,MAAM,cAAc;AACxB,kFAAkF;AAChF,YAAY;AACd,qFAAqF;AACrF,QAAQ;AACR,gEAAgE;AAChE,YAAY,CAAA;AAEd,oGAAoG;AACpG,MAAM,WAAW,gBAAgB;IAC/B,KAAK,EAAQ,cAAc,CAAA;IAC3B,4FAA4F;IAC5F,MAAM,EAAO,MAAM,CAAA;IACnB,MAAM,EAAO,MAAM,CAAA;IACnB,4EAA4E;IAC5E,WAAW,EAAE,MAAM,CAAA;IACnB,8EAA8E;IAC9E,QAAQ,EAAK,MAAM,CAAA;IACnB,8DAA8D;IAC9D,WAAW,EAAE,KAAK,CAAA;IAClB,sEAAsE;IACtE,WAAW,EAAE,KAAK,CAAA;CACnB;AAED,6EAA6E;AAC7E,MAAM,WAAW,UAAU;IACzB,MAAM,EAAI,KAAK,CAAA;IACf,MAAM,EAAI,KAAK,CAAA;IACf,6EAA6E;IAC7E,QAAQ,EAAE,MAAM,CAAA;CACjB"}