@hexpro/qr-code-studio 0.0.0-stage → 0.1.1

package/dist/decode/sample.js

@@ -0,0 +1,154 @@
+/**
+ * Reading modules out of a picture through a fitted transform.
+ *
+ * The estimating half of reading ends here; everything downstream is exact.
+ *
+ * Sampling is soft. Each module gets a hard decision, dark or light, and a
+ * confidence: how far its grey sat from the threshold that made the decision,
+ * relative to the symbol's own contrast. A clean render samples at 1 every
+ * where. A module under a mid-grey logo, or smeared across an edge by blur,
+ * samples near 0, and the lenient reader hands Reed-Solomon those positions
+ * as erasures, which cost half what an error does.
+ *
+ * Lifted from the authenticator package's reader
+ * (google-auth-secret-retriever, `src/qr/decode/sample.ts`), which sampled
+ * hard bits only.
+ */
+import { BitMatrix } from '../core/bit-matrix.js';
+/** Below this confidence a module is uncertain: an erasure candidate, and drawn as such. */
+export const UNCERTAIN = 0.2;
+/**
+ * The floor under the contrast a confidence is measured against, in grey
+ * levels, so a picture with no contrast at all gives confidences near zero
+ * rather than dividing by it.
+ */
+const MIN_CONTRAST = 8;
+/**
+ * Where within a module the majority vote looks: the centre and four points a
+ * quarter of a module from it. One blown out pixel in the middle of a module
+ * no longer flips it.
+ */
+const VOTE_OFFSETS = [
+    [0.5, 0.5],
+    [0.25, 0.5],
+    [0.75, 0.5],
+    [0.5, 0.25],
+    [0.5, 0.75],
+];
+const CENTRE_ONLY = [[0.5, 0.5]];
+/**
+ * Sample a `width` by `height` module grid, module (x, y) spanning [x, x + 1)
+ * by [y, y + 1) in the transform's source coordinates. Null when the grid
+ * falls further outside the picture than `options.outside` allows, which means
+ * the fit is wrong rather than the code is damaged.
+ */
+export function sampleGrid(source, transform, width, height, options) {
+    const { grey, binarised } = source;
+    const offsets = options.majorityVote ? VOTE_OFFSETS : CENTRE_ONLY;
+    const points = offsets.length;
+    const modules = width * height;
+    // Signed distance from the threshold per sample point, positive towards
+    // dark, and the hard bit per point. NaN marks a point off the picture.
+    const distances = new Float32Array(modules * points);
+    const bits = new Uint8Array(modules * points);
+    const [a11, a21, a31, a12, a22, a32, a13, a23, a33] = transform;
+    let outside = 0;
+    const allowed = Math.floor(modules * options.outside);
+    for (let y = 0; y < height; y += 1) {
+        for (let x = 0; x < width; x += 1) {
+            const module = y * width + x;
+            for (let k = 0; k < points; k += 1) {
+                const offset = offsets[k];
+                const sx = x + offset[0];
+                const sy = y + offset[1];
+                const d = a13 * sx + a23 * sy + a33;
+                const px = Math.floor((a11 * sx + a21 * sy + a31) / d);
+                const py = Math.floor((a12 * sx + a22 * sy + a32) / d);
+                const at = module * points + k;
+                // Written as a negated range test so NaN, from a degenerate fit, lands
+                // outside too.
+                if (!(px >= 0 && py >= 0 && px < grey.width && py < grey.height)) {
+                    distances[at] = Number.NaN;
+                    if (k === 0) {
+                        outside += 1;
+                        if (outside > allowed)
+                            return null;
+                    }
+                    continue;
+                }
+                const pixel = py * grey.width + px;
+                const level = grey.data[pixel];
+                const threshold = binarised.threshold(px, py);
+                distances[at] = threshold - level;
+                bits[at] = binarised.bits[pixel];
+            }
+        }
+    }
+    const contrast = symbolContrast(distances, points);
+    const matrix = new BitMatrix(width, height);
+    const confidence = new Float32Array(modules);
+    const uncertain = new Uint8Array(modules);
+    let minConfidence = 1;
+    for (let module = 0; module < modules; module += 1) {
+        const base = module * points;
+        if (Number.isNaN(distances[base])) {
+            // Off the picture: light, and as uncertain as a module can be.
+            uncertain[module] = 1;
+            minConfidence = 0;
+            continue;
+        }
+        let votes = 0;
+        let sum = 0;
+        let counted = 0;
+        for (let k = 0; k < points; k += 1) {
+            const distance = distances[base + k];
+            // A vote point off the picture is light, as the authenticator's
+            // bounds-checked read made it; it carries no distance.
+            if (Number.isNaN(distance))
+                continue;
+            votes += bits[base + k];
+            sum += Math.max(-contrast, Math.min(contrast, distance));
+            counted += 1;
+        }
+        const dark = votes * 2 > points;
+        if (dark)
+            matrix.data[module] = 1;
+        // How far the evidence leans the way the vote went. When the mean of the
+        // distances disagrees with the vote, the module is a coin toss.
+        const lean = (dark ? sum : -sum) / counted / contrast;
+        const value = Math.max(0, Math.min(1, lean));
+        confidence[module] = value;
+        if (value < UNCERTAIN)
+            uncertain[module] = 1;
+        if (value < minConfidence)
+            minConfidence = value;
+    }
+    return { matrix, confidence, uncertain, minConfidence };
+}
+/**
+ * The symbol's own contrast: the 90th percentile of how far the centre samples
+ * sit from their thresholds. Most modules of any readable symbol sit well
+ * clear, so this is the distance a confident module has; a logo or a smear
+ * covering a fifth of the symbol does not move it.
+ */
+function symbolContrast(distances, points) {
+    const histogram = new Uint32Array(256);
+    let total = 0;
+    for (let i = 0; i < distances.length; i += points) {
+        const distance = distances[i];
+        if (Number.isNaN(distance))
+            continue;
+        histogram[Math.min(255, Math.floor(Math.abs(distance)))] += 1;
+        total += 1;
+    }
+    const target = total * 0.9;
+    let seen = 0;
+    let level = 0;
+    for (; level < 255; level += 1) {
+        seen += histogram[level];
+        if (seen >= target)
+            break;
+    }
+    return Math.max(MIN_CONTRAST, level);
+}
+//# sourceMappingURL=sample.js.map

package/dist/decode/sample.js.map

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

package/dist/decode/strict.d.ts

@@ -0,0 +1,255 @@
+/**
+ * The strict profile, strict-v1: what the scan check reads with.
+ *
+ * The scan check's promise is that a design it passes scans on the phones
+ * people use, so this reader has to be at least as hard to satisfy as any of
+ * them. Whatever it reads, zxing-cpp and jsQR must read too, which
+ * tests/decode/conservative.test.ts holds it to over a seeded corpus of
+ * damaged captures, styled-conservative.test.ts over every design preset
+ * photographed, tilted and damaged, and tilt.test.ts over large symbols at
+ * an angle; the verify layer's own captures of every preset, on all nine of
+ * its axes, were the survey that set the newer rules below. Against the
+ * scanner, it gives up:
+ *
+ * - every threshold but one: the hybrid binariser the common readers use
+ *   (`binariseHybridMean`), at the picture's own scale;
+ * - every sample but one: the pixel under each module's centre;
+ * - the other polarity: only the design's own, dark-on-light unless told;
+ * - mirror images, erasures, and any format information more than one bit
+ *   out or with its copies disagreeing (the symbology's strict read);
+ * - slack in the finders: their runs within 0.35 of a module of 1:1:3:1:1
+ *   along the axes, and within half a module on both diagonals (see
+ *   `STRICT_FINDER_TOLERANCE`);
+ * - guessing: one finder triple and one grid, the size and (from version 2)
+ *   the alignment pattern whose grid lays the timing patterns down
+ *   straightest, or no grid at all; a grid whose timing pattern does not
+ *   read is not read, and from version 7 its version information has to
+ *   agree with its size;
+ *
+ * and then asks these things of a symbol that did read, all about the picture
+ * rather than the symbol:
+ *
+ * - Its modules must be at least 2.25 pixels across
+ *   (`STRICT_MIN_MODULE_PIXELS`), and drawn out no more than 1.8 times one
+ *   way over the other, a tilt of about 56 degrees
+ *   (`STRICT_MAX_FORESHORTENING`).
+ * - The thresholded picture must not break up into speckle. Noise that leaves
+ *   the symbol itself readable turns a flat background into isolated dark
+ *   pixels, and a reader that finds finder patterns by their run ratios finds
+ *   them everywhere in it and picks the wrong three: measured against jsQR
+ *   over the corpus, that is where it fails, from about one pixel in sixteen.
+ *   More than one in fifty is refused.
+ * - The grid a plain reader would lay must read to the same bytes (see
+ *   `plain.ts`).
+ * - For Micro QR and rMQR, the fixed patterns (finders, separators, timing
+ *   and alignment patterns) must read the same under both of the thresholds
+ *   the common readers use, the block mean jsQR and ZXing take and zxing-cpp's
+ *   (`binariseLocalAverage`), wherever the picture around them keeps its
+ *   contrast. Where they differ on a module whose neighbourhood has gone
+ *   pale, the picture has lost the pattern, nearly always to glare, and a
+ *   reader that finds its way by it is lost too. Where they differ on a
+ *   module whose neighbourhood keeps its contrast, the centre sits on a drawn
+ *   edge, which styled designs do on purpose. QR leaves this out: the rules
+ *   below model what zxing-cpp makes of its own threshold, and over verify's
+ *   captures and the plain corpus they caught everything this did.
+ * - The finders' rings must be ones zxing-cpp can trace: no ring of dots,
+ *   at a slant or under a smear no circle, and on a steep tilt no ring
+ *   nearly round at its corners (see `finderRingsTraceable`);
+ *   and their centres ones it can settle on (see `finderCentresClosed`).
+ * - From version 7, the grid zxing-cpp lays in tiles, cornered on the
+ *   finders' rings, must read as well (see `tiled.ts`).
+ *
+ * The reserve of ceil(0.25 t) unused corrections per block is the last part
+ * of the profile and is not here: the verify layer applies it, from
+ * `MatrixRead.errorsPerBlock` and `capacityPerBlock`.
+ */
+import type { SymbolLayout } from '../symbology/types.js';
+import type { Binarised } from './binarise.js';
+import type { GreyImage } from './grey.js';
+import type { Homography } from './transform.js';
+import type { Point } from './types.js';
+/**
+ * The fewest pixels a module the strict profile reads at. Nyquist is two, and
+ * between two and two and a quarter zxing-cpp starts to miss symbols jsQR and
+ * this reader still read (2 of 71 in the 20,000-capture corpus); above it, it
+ * missed none. The scan check draws at more than this, so the floor costs a
+ * design nothing.
+ */
+export declare const STRICT_MIN_MODULE_PIXELS = 2.25;
+/**
+ * The most a module may be drawn out one way over the other at the middle of
+ * the symbol: 1.8, a tilt of about 56 degrees. Past it the readers find the
+ * far corner by tracing the finders' sides a long way across a steep
+ * perspective, and zxing-cpp put it tens of pixels out on a symbol tilted 60
+ * degrees that the strict reader read: one of the 127 it read there, and none
+ * of the 586 at 50 degrees (1.56).
+ */
+export declare const STRICT_MAX_FORESHORTENING = 1.8;
+/**
+ * How much longer a module is drawn one way than the other at (u, v): the
+ * ratio of the largest to the smallest stretch of the transform's derivative
+ * there, 1 for a square module and 1 / cos t for a tilt of t.
+ */
+export declare function foreshortening(transform: Homography, u: number, v: number): number;
+/**
+ * Whether the strict profile samples a grid at all: modules wide enough, and
+ * not drawn out past `STRICT_MAX_FORESHORTENING`, at the middle of the symbol.
+ *
+ * Version 7 and up once had a floor of three pixels a module of their own:
+ * below it the tiled grid (see tiled.ts), laid on a midrange threshold, let
+ * through symbols zxing-cpp missed. Laid on zxing-cpp's own threshold and
+ * from each centre zxing-cpp could take, it catches them: over verify's
+ * captures at 2.5 pixels a module it let none through, so the one floor
+ * serves every version.
+ */
+export declare function strictSamples(transform: Homography, width: number, height: number): boolean;
+/** The most speckle, as a fraction of all pixels, the strict profile accepts. */
+export declare const STRICT_MAX_SPECKLE = 0.02;
+/**
+ * The fraction of pixels that are dark with at most one dark neighbour of
+ * four: isolated specks. A symbol's own modules are at least two pixels
+ * across at any size the strict reader samples, so none of its pixels is one.
+ */
+export declare function speckle(image: Binarised): number;
+/**
+ * Below this share of the symbol's own contrast, the picture around a
+ * fixed-pattern module has lost the contrast that tells dark from light.
+ *
+ * Measured, not chosen: where the two thresholds split on a fixed-pattern
+ * module under glare, the 3 by 3 modules around it span 0.28 to 0.53 of the
+ * symbol's range; where they split on a styled design (a round finder centre
+ * whose corner module's centre sits on the curve, a dot or a rounded corner
+ * in the timing pattern), 0.96 to 1.03. Three quarters sits between them with
+ * room either side.
+ */
+export declare const WASHED_OUT = 0.75;
+/**
+ * Whether the fixed-pattern modules read the same in two thresholded
+ * versions of one picture, at the pixel under each centre, wherever the
+ * picture there still has its contrast.
+ *
+ * A module the two split on is forgiven when the 3 by 3 modules around it
+ * span at least `WASHED_OUT` of the symbol's range: then the split is a
+ * centre that sits on a drawn edge, which a styled design puts there on
+ * purpose and every reader resolves by its neighbours. Where the
+ * neighbourhood itself has gone pale, the split is the picture losing the
+ * pattern, and that refuses.
+ */
+export declare function fixedPatternsAgree(a: Binarised, b: Binarised, grey: GreyImage, transform: Homography, layout: SymbolLayout): boolean;
+/**
+ * Past this ratio between the largest and smallest finder, the symbol is seen
+ * at a slant, and zxing-cpp stops trusting the finders' centres alone: it
+ * traces the straight outer sides of the finders' rings and intersects them
+ * to find the far corner. Its switch is at a tenth by its own measure; by
+ * this one, taken through the fitted grid, it starts failing round rings at
+ * about 1.06 (a tilt of 8 to 10 degrees), so the strict reader asks for
+ * traceable sides from half that.
+ */
+export declare const STRICT_SLANT = 1.03;
+/** A finder ring's outer side over its middle stretch: how far it wanders, and how far the ring reaches into its corners. */
+export interface RingShape {
+    readonly wander: number;
+    readonly corner: number;
+}
+/** The ring of the finder centred on module (u, v), or null where it runs off the picture. */
+export declare function ringShape(grey: GreyImage, transform: Homography, u: number, v: number): RingShape | null;
+/**
+ * Past this difference, in modules, between the widest and narrowest blur of
+ * a finder's outer edge across sixteen directions, the camera moved during
+ * the exposure. Measured, not chosen: square on and under a defocus the
+ * difference is under 0.3 of a module for every preset; a smear of 0.75 of a
+ * module puts it at 0.45 and more, and each of the 23 round and dotted
+ * finders zxing-cpp missed under a smear that the strict reader read was at
+ * 0.52 or more.
+ */
+export declare const STRICT_MAX_SMEAR = 0.45;
+/**
+ * How unevenly a finder's outer edge is blurred: the widest blur over the
+ * sixteen directions less the narrowest, in modules. A lens blurs evenly; a
+ * moving camera smears one way. Infinite where no two directions measure.
+ */
+export declare function finderSmear(grey: GreyImage, transform: Homography, u: number, v: number): number;
+/**
+ * Whether each of a QR symbol's finders has a centre zxing-cpp can settle on,
+ * in its own threshold `bits`: one dark patch whose edge, walked from the
+ * centre's pixel, goes all the way round it, with the middle of the walk on
+ * a dark pixel.
+ *
+ * zxing-cpp, having found a finder by its runs, settles its centre by walking
+ * the edge of the dark centre and taking the middle of the walk, and drops the
+ * finder when the walk does not close round the centre or its middle is
+ * light. Glare that leaves a light hole in the centre does that: a two-tone
+ * design under glare that jsQR and the strict reader read was one zxing-cpp
+ * found no symbol in at all, with its bottom left finder's centre holed in
+ * zxing-cpp's threshold and solid in the strict reader's own.
+ *
+ * Asked first of a midrange threshold, this refused 7 in 1,000 symbols over
+ * verify's captures that zxing-cpp read, most of them two-tone designs whose
+ * finder centres that threshold holed and zxing-cpp's does not; asked of
+ * `binariseLocalAverage`, the two-tone shortfalls went with it.
+ */
+export declare function finderCentresClosed(bits: Binarised, transform: Homography, size: number): boolean;
+/**
+ * Whether a QR symbol's finder rings are ones zxing-cpp can trace.
+ *
+ * zxing-cpp, once the finders differ in size by a tenth, finds the symbol's
+ * far corner by tracing the straight outer sides of the finders' rings and
+ * intersecting them. A circular ring has no straight side, and a ring of dots
+ * has a scalloped one. Over the styled corpus zxing-cpp read none of the
+ * circle-ringed presets tilted 15 degrees and every one of them square on;
+ * the dot-ringed one it missed a quarter of the time even square on, and
+ * most of the time tilted. jsQR, which never looks at the sides, read them
+ * all, and so did the strict reader until it asked this.
+ *
+ * Measured through the fitted grid, so slant and roll drop out: over the
+ * middle 2.4 modules of each side, a straight side wanders 0.03 to 0.06 of a
+ * module (squares, rounded and extra-rounded corners, squircles, leaves,
+ * octagons, cushions) and a circle or a ring of dots 0.20 to 0.25. A circle
+ * reaches no further along its diagonals than its axes; every cornered ring,
+ * dots included, at least 1.12 times further.
+ *
+ * So a ring of dots, cornered and scalloped, is refused outright, and a
+ * circle when the symbol is seen at a slant.
+ *
+ * A camera that moves during the exposure does to a round ring what a slant
+ * does: over verify's captures zxing-cpp missed round rings smeared by a
+ * module or more one time in four that jsQR and the strict reader read, and
+ * square ones next to never. A smear also hides a ring of dots, joining them
+ * along it and leaving them apart across it, so that the ring measures
+ * straight and zxing-cpp still misses it. Smeared past `STRICT_MAX_SMEAR`,
+ * then, every ring has to be straight, cornered and, in zxing-cpp's own
+ * threshold `bits`, one closed ring. And tilted steeply, past
+ * `STRICT_STEEP_FORESHORTENING`, a ring's corners have to be well short of
+ * round (`STEEP_CORNER_RATIO`).
+ */
+export declare function finderRingsTraceable(grey: GreyImage, bits: Binarised, transform: Homography, size: number): boolean;
+/**
+ * Past this foreshortening, a tilt of about 37 degrees, zxing-cpp's traced
+ * finder sides need corners well short of round (`STEEP_CORNER_RATIO`).
+ */
+export declare const STRICT_STEEP_FORESHORTENING = 1.25;
+/**
+ * What a finder's ring is to a reader that traces its sides, by its shape
+ * (see `finderRingsTraceable`): `cornered`, straight-sided with corners, which
+ * every reader follows; `round`, without corners, which zxing-cpp loses at a
+ * slant or under a smear; `dotted`, cornered but scalloped, which it loses
+ * anywhere. Null where the ring cannot be measured on the picture.
+ *
+ * The design layer can ask this of a ring and centre it draws, through the
+ * grid it drew them on, to know before any photograph how the strict profile
+ * will take them.
+ */
+export declare function ringKind(grey: GreyImage, transform: Homography, u: number, v: number): RingKind | null;
+export type RingKind = 'cornered' | 'round' | 'dotted';
+/**
+ * Whether the strict profile's finder search, thresholding a picture as the
+ * strict reader does, finds a finder centred within a module of `centre`.
+ *
+ * The design layer's conformance test measures a ring and centre with
+ * sub-pixel edges at four pixels a module; the strict reader measures whole
+ * pixels from the pixels nearest a centre it knows to a fraction of one. This
+ * is the strict reader's own measure, for a caller that wants the verdict of
+ * the reader that will judge the finder rather than a model of it.
+ */
+export declare function strictFindsFinder(image: GreyImage, centre: Point, modulePixels: number): boolean;
+//# sourceMappingURL=strict.d.ts.map

package/dist/decode/strict.d.ts.map

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