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

package/dist/render/coverage.d.ts

@@ -0,0 +1,154 @@
+/**
+ * Exact pixel coverage of a filled outline, one row at a time.
+ *
+ * The scan check rasterises a design and then decodes it, and its verdict has
+ * to be the same in Node, Chromium, WebKit and Firefox. A canvas cannot
+ * promise that: each engine anti-aliases its own way. So coverage is computed
+ * here, analytically, in float64 arithmetic that IEEE 754 fixes bit for bit.
+ *
+ * What is computed is the area of each pixel where the winding number is not
+ * zero, which is what the nonzero fill rule means, to within rounding. The
+ * usual signed-area accumulator (sum each edge's trapezoid, take the absolute
+ * value, clamp to one) is exact only while the winding inside a pixel stays at
+ * 0 or 1. It over-inks a pixel where two shapes overlap at their edges and
+ * under-inks one where opposite windings meet, which is exactly where a module
+ * shape that reaches into its neighbour's cell sits. So instead, within each
+ * pixel row:
+ *
+ * 1. The edges crossing the row are grouped into clusters whose horizontal
+ *    extents overlap. Between clusters no edge passes, so the winding there is
+ *    the same from the top of the row to the bottom.
+ * 2. Each cluster is cut into horizontal sub-bands at every edge end point
+ *    and every crossing of two edges. Within a sub-band no two edges cross, so
+ *    they keep one left to right order.
+ * 3. Walking that order from the winding on the cluster's left, the edges
+ *    where the winding changes between zero and not zero are the boundary of
+ *    the filled region. Only those are accumulated, entering as +1 and leaving
+ *    as -1, so the running sum along the row is the filled area of each pixel
+ *    directly, between 0 and 1.
+ *
+ * Horizontal edges take no part in the winding, but they do separate regions,
+ * so they count when clusters are formed.
+ *
+ * Geometry is clipped as it is added: everything outside the rows is dropped,
+ * everything right of the image is dropped, and everything left of it is
+ * pressed onto x = 0, where it still contributes its winding to every pixel to
+ * its right. The winding at a point is decided only by the edges to its left,
+ * so neither change moves a pixel.
+ */
+import type { Path } from '../geometry/path.js';
+/**
+ * The furthest a chord may stray from its curve, in device pixels.
+ *
+ * The sliver a chord cuts off is then under 1/64 of any pixel it crosses:
+ * four levels of coverage at the very most, on a long gentle curve, and under
+ * one on a curve the size of a module. The four arc circle that the curve
+ * itself approximates is further than that from a true circle once its radius
+ * passes 60 pixels, so a finer tolerance would buy nothing anyone could see.
+ */
+export declare const FLATTEN_TOLERANCE: number;
+/**
+ * Add one straight boundary piece to an accumulation row.
+ *
+ * The piece runs from x0 at the top of a strip to x1 at the bottom, `dy` high
+ * (at most one pixel), and `sign` says whether the filled region lies to its
+ * right (+1) or ends there (-1). After a prefix sum each column holds the area
+ * to the right of the pieces within it, which is the pixel's coverage.
+ *
+ * Exact for a straight line. The line is linear in y, so the share of the
+ * strip it leaves to the right within each column is a rectangle (the height
+ * where the line is still to the column's left) plus a trapezoid (the height
+ * where it crosses the column, at its mean distance from the column's right
+ * side). Each column gets the difference from the one before.
+ */
+export declare function accumulate(acc: Float64Array, x0: number, x1: number, dy: number, sign: number): void;
+/**
+ * Buffers one row's work needs, shared by every outline in a picture.
+ *
+ * Outlines are covered one at a time and each leaves the accumulation row
+ * zeroed behind it, so one set serves a scene of any number of layers: the
+ * memory stays a row, not a row per layer.
+ */
+export declare class CoverageScratch {
+    readonly width: number;
+    readonly acc: Float64Array;
+    bandTop: Float64Array<ArrayBuffer>;
+    bandBottom: Float64Array<ArrayBuffer>;
+    bandXTop: Float64Array<ArrayBuffer>;
+    bandXBottom: Float64Array<ArrayBuffer>;
+    bandMin: Float64Array<ArrayBuffer>;
+    bandMax: Float64Array<ArrayBuffer>;
+    constructor(width: number);
+    /** Room for the band data of `size` edges. */
+    grow(size: number): void;
+}
+/**
+ * The edges of one filled outline, in device pixels, and the coverage of each
+ * row of pixels they enclose.
+ *
+ * Rows must be asked for in increasing order, though any may be skipped. An
+ * edge becomes active when its first row arrives and is dropped after its
+ * last, so the work for a row is proportional to what crosses it and the
+ * memory is the edges plus one row.
+ */
+export declare class EdgeSet {
+    private readonly scratch;
+    readonly height: number;
+    /** x0, y0, x1, y1 for each sloped edge, with y0 < y1. */
+    private readonly lines;
+    /** +1 for an edge that ran down the page, -1 for one that ran up. */
+    private readonly directions;
+    /** y, x from, x to, for each horizontal edge strictly inside a row. */
+    private readonly flats;
+    private ready;
+    /** Sloped edges ordered by first row, and where each row's run starts. */
+    private byRow;
+    private rowStart;
+    private flatByRow;
+    private flatRowStart;
+    private active;
+    private nextRow;
+    private touchedLo;
+    private touchedHi;
+    private splitsLeft;
+    /** The last row's coverage is zero outside [start, end). */
+    start: number;
+    end: number;
+    readonly width: number;
+    constructor(scratch: CoverageScratch, height: number);
+    /** Every edge of `path`, scaled by (sx, sy) into device pixels. */
+    static fromPath(path: Path, scratch: CoverageScratch, height: number, sx: number, sy: number): EdgeSet;
+    /** Add an edge in device coordinates, clipped as described at the top of the file. */
+    addLine(x0: number, y0: number, x1: number, y1: number): void;
+    /** Cut a sloped edge where it crosses x = 0 and x = width, and keep or press each piece. */
+    private splitAtSides;
+    /**
+     * Store one piece. Every piece has height: the edge was clipped to rows it
+     * crosses, and it is only cut strictly between its ends.
+     */
+    private keepPiece;
+    /** Order the edges by their first row, once, with a counting sort. */
+    private prepare;
+    private emit;
+    /**
+     * Fill `out` with the coverage of row `row`, and say whether any pixel has
+     * any. When it does, `start` and `end` bound the pixels that do.
+     */
+    coverage(row: number, out: Float64Array): boolean;
+    /** Insertion sort of the active edges by their left end in this row, carrying the band data. */
+    private sortActive;
+    /**
+     * Accumulate one cluster's boundary, given the winding to its left, and
+     * return the winding to its right.
+     */
+    private cluster;
+    /**
+     * Accumulate the boundary within one sub-band of a cluster, splitting it
+     * at the first crossing if two edges cross inside it. Returns the winding
+     * to the cluster's right.
+     */
+    private subBand;
+    /** The fallback past the split budget: thin strips, each walked as if nothing crossed in it. */
+    private strips;
+}
+//# sourceMappingURL=coverage.d.ts.map

package/dist/render/coverage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"coverage.d.ts","sourceRoot":"","sources":["../../src/render/coverage.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AAGH,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,qBAAqB,CAAC;AAEhD;;;;;;;;GAQG;AACH,eAAO,MAAM,iBAAiB,QAAS,CAAC;AAuBxC;;;;;;;;;;;;;GAaG;AACH,wBAAgB,UAAU,CACzB,GAAG,EAAE,YAAY,EACjB,EAAE,EAAE,MAAM,EACV,EAAE,EAAE,MAAM,EACV,EAAE,EAAE,MAAM,EACV,IAAI,EAAE,MAAM,GACV,IAAI,CAsBN;AAyCD;;;;;;GAMG;AACH,qBAAa,eAAe;IASf,QAAQ,CAAC,KAAK,EAAE,MAAM;IARlC,QAAQ,CAAC,GAAG,EAAE,YAAY,CAAC;IAC3B,OAAO,4BAAwB;IAC/B,UAAU,4BAAwB;IAClC,QAAQ,4BAAwB;IAChC,WAAW,4BAAwB;IACnC,OAAO,4BAAwB;IAC/B,OAAO,4BAAwB;gBAEV,KAAK,EAAE,MAAM;IAIlC,8CAA8C;IAC9C,IAAI,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI;CAgBxB;AAED;;;;;;;;GAQG;AACH,qBAAa,OAAO;IA4BlB,OAAO,CAAC,QAAQ,CAAC,OAAO;IACxB,QAAQ,CAAC,MAAM,EAAE,MAAM;IA5BxB,yDAAyD;IACzD,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAgB;IACtC,qEAAqE;IACrE,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAgB;IAC3C,uEAAuE;IACvE,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAgB;IAEtC,OAAO,CAAC,KAAK,CAAS;IACtB,0EAA0E;IAC1E,OAAO,CAAC,KAAK,CAAqB;IAClC,OAAO,CAAC,QAAQ,CAAqB;IACrC,OAAO,CAAC,SAAS,CAAqB;IACtC,OAAO,CAAC,YAAY,CAAqB;IAEzC,OAAO,CAAC,MAAM,CAAgB;IAC9B,OAAO,CAAC,OAAO,CAAK;IACpB,OAAO,CAAC,SAAS,CAAK;IACtB,OAAO,CAAC,SAAS,CAAK;IACtB,OAAO,CAAC,UAAU,CAAK;IAEvB,4DAA4D;IAC5D,KAAK,SAAK;IACV,GAAG,SAAK;IAER,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;gBAGL,OAAO,EAAE,eAAe,EAChC,MAAM,EAAE,MAAM;IAKxB,mEAAmE;IACnE,MAAM,CAAC,QAAQ,CACd,IAAI,EAAE,IAAI,EACV,OAAO,EAAE,eAAe,EACxB,MAAM,EAAE,MAAM,EACd,EAAE,EAAE,MAAM,EACV,EAAE,EAAE,MAAM,GACR,OAAO;IAeV,sFAAsF;IACtF,OAAO,CAAC,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,GAAG,IAAI;IA0B7D,4FAA4F;IAC5F,OAAO,CAAC,YAAY;IAiBpB;;;OAGG;IACH,OAAO,CAAC,SAAS;IAWjB,sEAAsE;IACtE,OAAO,CAAC,OAAO;IAyCf,OAAO,CAAC,IAAI;IASZ;;;OAGG;IACH,QAAQ,CAAC,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,YAAY,GAAG,OAAO;IA4GjD,gGAAgG;IAChG,OAAO,CAAC,UAAU;IAiClB;;;OAGG;IACH,OAAO,CAAC,OAAO;IA+Cf;;;;OAIG;IACH,OAAO,CAAC,OAAO;IAyDf,gGAAgG;IAChG,OAAO,CAAC,MAAM;CAWd"}