@xprite/pixelate 0.0.0-stage → 0.1.1

package/dist/grid-sampling.d.ts

@@ -0,0 +1,13 @@
+import type { PixelBuffer } from "./base.ts";
+import { type PixelGridAnalysis, type PixelGridSamplingStage } from "./types.ts";
+/** Internal image view. Its data stays in the source; only offset reads apply local shifts. */
+export interface GridImageView extends PixelBuffer {
+    offset?: (x: number, y: number) => number;
+    sampling?: readonly PixelGridSamplingStage[];
+}
+/** Compose inverse steps in reverse order, keeping clamping at each intermediate image. */
+export declare function shiftedGridImage(image: GridImageView, stage: PixelGridSamplingStage): GridImageView;
+/** Materialize only when a consumer needs a regular RGBA buffer, such as final coloring. */
+export declare function materializeGridImage(image: GridImageView): PixelBuffer;
+/** Use the same rotation and local inverse mapping selected by Auto during final recovery. */
+export declare function prepareGridSampling(image: PixelBuffer, grid: PixelGridAnalysis): PixelBuffer;

package/dist/grid-sampling.js

@@ -0,0 +1,132 @@
+import { straighten } from "./deskew.js";
+import { PixelGridSamplingAxis, } from "./types.js";
+const STRIDE = 4;
+/** Retain Auto's existing confidence gate for local correction during coloring. */
+const SAMPLING_MIN_CONFIDENCE = 0.35;
+/** Bounded coordinate metadata, with no corrected RGBA allocation. */
+const MAX_SHIFT_LOOKUP_ENTRIES = 1 << 18;
+const MAX_INT32_COORDINATE = 2 ** 31 - 1;
+/** Integer coordinates take the last interval starting at or before them, including ties. */
+function axisIndex(boundaries, length) {
+    const index = new Int32Array(length);
+    for (let band = 1; band + 1 < boundaries.length; band++)
+        index.fill(band, Math.max(0, Math.ceil(boundaries[band])), band + 2 === boundaries.length ? length : Math.max(0, Math.ceil(boundaries[band + 1])));
+    return index;
+}
+/** Compose inverse steps in reverse order, keeping clamping at each intermediate image. */
+export function shiftedGridImage(image, stage) {
+    const { width, height, data } = image;
+    const vertical = stage.axis === PixelGridSamplingAxis.Vertical;
+    const bands = axisIndex(stage.bands, vertical ? height : width);
+    const across = axisIndex(stage.across, vertical ? width : height);
+    const previous = image.offset;
+    const shifts = stage.shifts;
+    let offset;
+    if (vertical) {
+        offset = previous
+            ? (x, y) => previous(x, Math.max(0, Math.min(height - 1, y + shifts[bands[y]][across[x]])))
+            : (x, y) => (Math.max(0, Math.min(height - 1, y + shifts[bands[y]][across[x]])) * width + x) * STRIDE;
+    }
+    else {
+        offset = previous
+            ? (x, y) => previous(Math.max(0, Math.min(width - 1, x + shifts[bands[x]][across[y]])), y)
+            : (x, y) => (y * width + Math.max(0, Math.min(width - 1, x + shifts[bands[x]][across[y]]))) * STRIDE;
+    }
+    const length = vertical ? height : width;
+    const perpendicular = vertical ? width : height;
+    const intervals = stage.across.length - 1;
+    // Keep original reads for fractional/non-index coordinates and unsupported shift inputs.
+    const original = offset;
+    const matrixValid = stage.bands.length >= 2 &&
+        stage.across.length >= 2 &&
+        Array.isArray(stage.shifts) &&
+        stage.shifts.length === stage.bands.length - 1 &&
+        Array.from(stage.shifts).every((row) => row?.length === intervals);
+    if (matrixValid &&
+        Number.isSafeInteger(length) &&
+        length <= MAX_INT32_COORDINATE &&
+        Number.isSafeInteger(perpendicular) &&
+        length + 2 * stage.shifts.length + 2 * perpendicular + intervals <= MAX_SHIFT_LOOKUP_ENTRIES) {
+        const ids = new Int32Array(intervals);
+        const bySignature = new Map();
+        const patterns = [];
+        let valid = true;
+        for (let k = 0; k < intervals; k++) {
+            const pattern = stage.shifts.map((row) => row[k]);
+            if (!pattern.every(Number.isSafeInteger)) {
+                valid = false;
+                break;
+            }
+            const signature = pattern.join(",");
+            let id = bySignature.get(signature);
+            if (id === undefined) {
+                if ((patterns.length + 1) * (length + 2 * pattern.length) + 2 * perpendicular + intervals >
+                    MAX_SHIFT_LOOKUP_ENTRIES) {
+                    valid = false;
+                    break;
+                }
+                id = patterns.length;
+                bySignature.set(signature, id);
+                patterns.push(pattern);
+            }
+            ids[k] = id;
+        }
+        if (valid) {
+            const maps = patterns.map((pattern) => {
+                const coordinates = new Int32Array(length);
+                for (let p = 0; p < length; p++)
+                    coordinates[p] = Math.max(0, Math.min(length - 1, p + pattern[bands[p]]));
+                return coordinates;
+            });
+            const byLine = Array.from({ length: perpendicular }, (_, p) => maps[ids[across[p]]]);
+            if (vertical) {
+                offset = previous
+                    ? (x, y) => {
+                        const at = byLine[x]?.[y];
+                        return at === undefined ? original(x, y) : previous(x, at);
+                    }
+                    : (x, y) => {
+                        const at = byLine[x]?.[y];
+                        return at === undefined ? original(x, y) : (at * width + x) * STRIDE;
+                    };
+            }
+            else {
+                offset = previous
+                    ? (x, y) => {
+                        const at = byLine[y]?.[x];
+                        return at === undefined ? original(x, y) : previous(at, y);
+                    }
+                    : (x, y) => {
+                        const at = byLine[y]?.[x];
+                        return at === undefined ? original(x, y) : (y * width + at) * STRIDE;
+                    };
+            }
+        }
+    }
+    return { width, height, data, sampling: [...(image.sampling ?? []), stage], offset };
+}
+/** Materialize only when a consumer needs a regular RGBA buffer, such as final coloring. */
+export function materializeGridImage(image) {
+    const offset = image.offset;
+    if (!offset)
+        return image;
+    const data = new Uint8ClampedArray(image.width * image.height * STRIDE);
+    for (let y = 0; y < image.height; y++)
+        for (let x = 0; x < image.width; x++) {
+            const from = offset(x, y);
+            const to = (y * image.width + x) * STRIDE;
+            for (let channel = 0; channel < STRIDE; channel++)
+                data[to + channel] = image.data[from + channel];
+        }
+    return { width: image.width, height: image.height, data };
+}
+/** Use the same rotation and local inverse mapping selected by Auto during final recovery. */
+export function prepareGridSampling(image, grid) {
+    const upright = grid.rotation ? straighten(image, grid.rotation) : image;
+    if (!grid.sampling?.length || grid.confidence < SAMPLING_MIN_CONFIDENCE)
+        return upright;
+    let view = upright;
+    for (const stage of grid.sampling)
+        view = shiftedGridImage(view, stage);
+    return materializeGridImage(view);
+}

package/dist/grid-strip-shift.d.ts

@@ -0,0 +1,44 @@
+import { type GridImageView } from "./grid-sampling.ts";
+/**
+ * Pitch factors at which the chance evidence is measured: a quarter octave either side, clear of
+ * the grid's octaves and of its neighbouring cell counts.
+ */
+export declare const OFF_PITCH_FACTORS: readonly [number, number];
+/** Per described line, prefix sums along it of the premultiplied colour and of its squared norm. */
+export interface LinePrefix {
+    length: number;
+    /** The described lines, ascending. */
+    lines: Int32Array;
+    sums: Float64Array;
+}
+export declare function linePrefix(image: GridImageView, vertical: boolean): LinePrefix;
+/** The image's line prefixes along each axis, computed once for every grid read on it. */
+export declare class StripImage {
+    readonly image: GridImageView;
+    private readonly prefixes;
+    constructor(image: GridImageView);
+    prefix(vertical: boolean): LinePrefix;
+}
+/** Squared deviation from their mean of the pixels [from, to) of one line. */
+export declare function intervalEnergy(sums: Float64Array, base: number, from: number, to: number): number;
+/** A grid read through strip shifts. */
+export interface StripShear {
+    /** The image with every strip moved back by its shift. */
+    straight: GridImageView;
+    /** Nats the shifts cost: each strip names one of its options. */
+    cost: number;
+    /** The image straightened by the anti-phase search, for the twin. */
+    twin: () => GridImageView;
+}
+/** The grid's strip shifts, or null when no strip moves. */
+export declare function stripShear(strips: StripImage, cutsX: readonly number[], cutsY: readonly number[]): StripShear | null;
+/** Uniform cuts over the same extent at `factor` times the pitch. */
+export declare function offPitch(cuts: readonly number[], factor: number): number[] | null;
+export type ChanceEvidenceStop = (lowerBound: number) => boolean;
+/** Raw per-axis/per-factor measurements; totals depend on the caller's incumbent. */
+export type ChanceEvidenceFragments = (number | undefined)[];
+/**
+ * Phase evidence the strip search finds without the grid, per sample: on each axis, the most it
+ * finds at the off-pitch factors, averaged over the two axes.
+ */
+export declare function chanceEvidence(strips: StripImage, cutsX: readonly number[], cutsY: readonly number[], stopIfCannotWin?: ChanceEvidenceStop, fragments?: ChanceEvidenceFragments): number;

package/dist/grid-strip-shift.js

@@ -0,0 +1,223 @@
+import { RESIDUAL_FLOOR, describedLines, } from "./grid-description-length.js";
+import { shiftedGridImage } from "./grid-sampling.js";
+import { PixelGridSamplingAxis } from "./types.js";
+/**
+ * Strip shifts of a grid. Every strip of cells (a row of cells for the column cuts, a column of
+ * cells for the row cuts) may move the cuts across it by whole pixels, within half a cell, as a
+ * warped, sheared or row-jittered upscale displaces them. Each strip takes the shift that leaves
+ * the least variance inside its cells, and moving every strip back by its shift straightens the
+ * grid. The column cuts are settled first, the row cuts then on the straightened columns. The
+ * variance is read on the lines a description covers, so a large image costs no more than its
+ * description.
+ *
+ * The same search with every strip confined to the anti-phase of its shift (a quarter to three
+ * quarters of a cell away) straightens the twin. Because every strip picks its shift from the
+ * image, the search finds some phase evidence on any content; `chanceEvidence` measures how much
+ * at pitches the grid does not have.
+ */
+const STRIDE = 4;
+const CHANNELS = 3;
+const ALPHA_SCALE = 255;
+/** The anti-phase window of a shift, in cells. */
+const ANTI_PHASE_FROM = 0.25;
+const ANTI_PHASE_TO = 0.75;
+const HALF = 0.5;
+/**
+ * Pitch factors at which the chance evidence is measured: a quarter octave either side, clear of
+ * the grid's octaves and of its neighbouring cell counts.
+ */
+export const OFF_PITCH_FACTORS = [2 ** 0.25, 2 ** -0.25];
+/** Cells and pixels per cell an off-pitch lattice needs to be searched. */
+const MIN_OFF_PITCH_CELLS = 3;
+const MIN_OFF_PITCH = 1.5;
+const TIE = 1e-9;
+export function linePrefix(image, vertical) {
+    const { width, height, data, offset } = image;
+    const length = vertical ? height : width;
+    const lines = describedLines(vertical ? width : height, length);
+    const sums = new Float64Array(lines.length * (length + 1) * (CHANNELS + 1));
+    for (let k = 0; k < lines.length; k++) {
+        const line = lines[k], base = k * (length + 1) * (CHANNELS + 1);
+        for (let p = 0; p < length; p++) {
+            const o = offset
+                ? vertical
+                    ? offset(line, p)
+                    : offset(p, line)
+                : (vertical ? p * width + line : line * width + p) * STRIDE;
+            const alpha = data[o + CHANNELS] / ALPHA_SCALE;
+            const at = base + (p + 1) * (CHANNELS + 1), previous = base + p * (CHANNELS + 1);
+            if (alpha === 0) {
+                sums[at] = sums[previous];
+                sums[at + 1] = sums[previous + 1];
+                sums[at + 2] = sums[previous + 2];
+                sums[at + CHANNELS] = sums[previous + CHANNELS];
+                continue;
+            }
+            const red = data[o] * alpha, green = data[o + 1] * alpha, blue = data[o + 2] * alpha;
+            sums[at] = sums[previous] + red;
+            sums[at + 1] = sums[previous + 1] + green;
+            sums[at + 2] = sums[previous + 2] + blue;
+            let square = 0;
+            square += red * red;
+            square += green * green;
+            square += blue * blue;
+            sums[at + CHANNELS] = sums[previous + CHANNELS] + square;
+        }
+    }
+    return { length, lines, sums };
+}
+/** The image's line prefixes along each axis, computed once for every grid read on it. */
+export class StripImage {
+    image;
+    prefixes = [null, null];
+    constructor(image) {
+        this.image = image;
+    }
+    prefix(vertical) {
+        const axis = Number(vertical);
+        return (this.prefixes[axis] ??= linePrefix(this.image, vertical));
+    }
+}
+/** Squared deviation from their mean of the pixels [from, to) of one line. */
+export function intervalEnergy(sums, base, from, to) {
+    if (to <= from)
+        return 0;
+    const count = to - from, start = base + from * (CHANNELS + 1), end = base + to * (CHANNELS + 1);
+    let energy = sums[end + CHANNELS] - sums[start + CHANNELS];
+    const red = sums[end] - sums[start], green = sums[end + 1] - sums[start + 1], blue = sums[end + 2] - sums[start + 2];
+    if (energy === 0 && red === 0 && green === 0 && blue === 0)
+        return energy;
+    energy -= (red * red) / count;
+    energy -= (green * green) / count;
+    energy -= (blue * blue) / count;
+    return energy;
+}
+const pitchOf = (cuts) => (cuts[cuts.length - 1] - cuts[0]) / (cuts.length - 1);
+/** Index of the first described line at or after `line`. */
+function lineIndex(lines, line) {
+    let low = 0, high = lines.length;
+    while (low < high) {
+        const middle = (low + high) >> 1;
+        if (lines[middle] < line)
+            low = middle + 1;
+        else
+            high = middle;
+    }
+    return low;
+}
+/**
+ * For each strip of lines between consecutive `across` cuts, the shift of the inner `cuts` that
+ * leaves the least energy inside the cells. With `anchor`, each strip's shift is confined to the
+ * anti-phase window of the anchor's.
+ */
+function stripShifts(prefix, cuts, across, anchor) {
+    const { length, lines, sums } = prefix;
+    const cells = cuts.length - 1;
+    const pitch = pitchOf(cuts);
+    const low = -Math.floor((pitch - 1) * HALF), high = Math.floor(pitch * HALF);
+    const shifts = [];
+    const positions = new Float64Array(cells + 1);
+    let energy = 0;
+    for (let k = 0; k + 1 < across.length; k++) {
+        const from = anchor ? Math.ceil(anchor[k] + ANTI_PHASE_FROM * pitch) : low, to = anchor ? Math.floor(anchor[k] + ANTI_PHASE_TO * pitch) : high;
+        const first = lineIndex(lines, across[k]), last = lineIndex(lines, across[k + 1]);
+        let best = from, least = Infinity;
+        for (let shift = from; shift <= to; shift++) {
+            for (let i = 1; i <= cells; i++) {
+                const at = i === cells ? length : Math.max(0, Math.min(length, cuts[i] + shift));
+                positions[i] = Math.max(positions[i - 1], at);
+            }
+            let sum = 0;
+            for (let line = first; line < last; line++) {
+                const base = line * (length + 1) * (CHANNELS + 1);
+                for (let i = 1; i <= cells; i++)
+                    sum += intervalEnergy(sums, base, positions[i - 1], positions[i]);
+            }
+            const nearer = !anchor && Math.abs(shift) < Math.abs(best);
+            if (sum < least - TIE || (sum <= least + TIE && nearer)) {
+                best = shift;
+                least = sum;
+            }
+        }
+        shifts.push(best);
+        energy += least;
+    }
+    return { shifts, energy, options: high - low + 1 };
+}
+/** The image with each strip moved back by its shift: out(p) = in(p + shift). */
+function unshear(image, vertical, across, shifts) {
+    return shiftedGridImage(image, {
+        axis: vertical ? PixelGridSamplingAxis.Vertical : PixelGridSamplingAxis.Horizontal,
+        bands: [0, vertical ? image.height : image.width],
+        across,
+        shifts: [shifts],
+    });
+}
+const moved = (shifts) => shifts.some(Boolean);
+/** The grid's strip shifts, or null when no strip moves. */
+export function stripShear(strips, cutsX, cutsY) {
+    const { image } = strips;
+    const columns = stripShifts(strips.prefix(false), cutsX, cutsY);
+    const once = moved(columns.shifts) ? unshear(image, false, cutsY, columns.shifts) : image;
+    const rows = stripShifts(once === image ? strips.prefix(true) : linePrefix(once, true), cutsY, cutsX);
+    if (!moved(columns.shifts) && !moved(rows.shifts))
+        return null;
+    const straight = moved(rows.shifts) ? unshear(once, true, cutsX, rows.shifts) : once;
+    const cost = (cutsY.length - 1) * Math.log(columns.options) + (cutsX.length - 1) * Math.log(rows.options);
+    const twin = () => {
+        const columnTwin = stripShifts(strips.prefix(false), cutsX, cutsY, columns.shifts);
+        const twinOnce = unshear(image, false, cutsY, columnTwin.shifts);
+        const rowTwin = stripShifts(linePrefix(twinOnce, true), cutsY, cutsX, rows.shifts);
+        return unshear(twinOnce, true, cutsX, rowTwin.shifts);
+    };
+    return { straight, cost, twin };
+}
+/** Uniform cuts over the same extent at `factor` times the pitch. */
+export function offPitch(cuts, factor) {
+    const first = cuts[0], last = cuts[cuts.length - 1];
+    const cells = Math.round((cuts.length - 1) / factor);
+    if (cells < MIN_OFF_PITCH_CELLS || (last - first) / cells < MIN_OFF_PITCH)
+        return null;
+    return Array.from({ length: cells + 1 }, (_, i) => Math.round(first + ((last - first) * i) / cells));
+}
+/** Phase evidence, per sample, of one axis's strip search: its shifts against their anti-phase. */
+function axisEvidence(prefix, cuts, across) {
+    const samples = prefix.lines.length * prefix.length * CHANNELS;
+    const best = stripShifts(prefix, cuts, across);
+    const anti = stripShifts(prefix, cuts, across, best.shifts);
+    return (HALF *
+        Math.log((anti.energy / samples + RESIDUAL_FLOOR) / (best.energy / samples + RESIDUAL_FLOOR)));
+}
+/**
+ * Phase evidence the strip search finds without the grid, per sample: on each axis, the most it
+ * finds at the off-pitch factors, averaged over the two axes.
+ */
+export function chanceEvidence(strips, cutsX, cutsY, stopIfCannotWin, fragments) {
+    const axes = [false, true];
+    let total = 0, remaining = axes.length * OFF_PITCH_FACTORS.length, slot = 0;
+    for (const vertical of axes) {
+        const cuts = vertical ? cutsY : cutsX, across = vertical ? cutsX : cutsY;
+        let most = 0;
+        for (const factor of OFF_PITCH_FACTORS) {
+            const off = offPitch(cuts, factor);
+            if (off) {
+                let value = fragments?.[slot];
+                if (value === undefined) {
+                    value = axisEvidence(strips.prefix(vertical), off, across);
+                    if (fragments)
+                        fragments[slot] = value;
+                }
+                most = Math.max(most, value);
+            }
+            slot++;
+            remaining--;
+            if (stopIfCannotWin && remaining > 0) {
+                const lowerBound = (total + most) * HALF;
+                if (Number.isFinite(lowerBound) && lowerBound >= 0 && stopIfCannotWin(lowerBound))
+                    return Infinity;
+            }
+        }
+        total += most;
+    }
+    return total * HALF;
+}

package/dist/grid-test-images.d.ts

@@ -0,0 +1,69 @@
+import type { PixelBuffer } from "./base.ts";
+/** A flat-coloured blocky sprite: background, then overlapping rectangles and ellipses. */
+export declare function sprite(size: number, seed?: number): PixelBuffer;
+/**
+ * Detailed pixel art: a dithered two-tone sky, outlined blobs with a lit and a shaded tone,
+ * single-pixel highlights and scattered speckles, so many neighbouring cells share a colour while
+ * others change every pixel.
+ */
+export declare function detailedSprite(width: number, height: number, seed?: number): PixelBuffer;
+/** Non-integer square nearest upscale: cells alternate between two integer widths. */
+export declare function fractionalUpscale(source: PixelBuffer, scale: number): PixelBuffer;
+/** Nearest upscale whose cell size drifts smoothly across the image (a non-uniform grid). */
+export declare function driftUpscale(source: PixelBuffer, scale: number, drift: number, seed?: number): PixelBuffer;
+/** Nearest upscale whose every inner cut moves by up to `jitter` cells, as pixel-bench's jitter. */
+export declare function jitterUpscale(source: PixelBuffer, scale: number, jitter: number, seed?: number): PixelBuffer;
+export declare function checkerboard(cell: number, cells: number): PixelBuffer;
+/** Nearest-neighbour upscale by a possibly fractional factor. */
+export declare function upscaleNearest(source: PixelBuffer, fx: number, fy?: number): PixelBuffer;
+export declare function upscaleBilinear(source: PixelBuffer, scale: number): PixelBuffer;
+/** Bilinear resample with pixel-centre alignment (as image libraries do), by a possibly fractional factor. */
+export declare function resampleBilinear(source: PixelBuffer, scale: number): PixelBuffer;
+/** pixel-bench's soft_bilinear: a centred bilinear upscale, then a Gaussian blur. */
+export declare function softBilinear(source: PixelBuffer, scale: number, blur?: number): PixelBuffer;
+/**
+ * pixel-bench's mush: a centred bilinear upscale displaced by a smooth random field of up to
+ * `amplitude` pixels (correlated over about a cell), a soft-focus blend and a Gaussian blur.
+ */
+export declare function mushWarp(source: PixelBuffer, scale: number, seed?: number, amplitude?: number, blur?: number): PixelBuffer;
+/**
+ * pixel-bench's warp on a nearest upscale: a smooth shear that moves every row along x and every
+ * column along y by two sine waves of up to `amplitude` pixels.
+ */
+export declare function warpUpscale(source: PixelBuffer, scale: number, amplitude: number, seed?: number): PixelBuffer;
+/**
+ * pixel-bench's row_jitter: a nearest upscale whose every row of cells moves along x, and every
+ * column of cells along y, by up to `amplitude` pixels.
+ */
+export declare function rowJitterUpscale(source: PixelBuffer, scale: number, amplitude: number, seed?: number): PixelBuffer;
+/**
+ * pixel-bench's block_reset: a nearest upscale split into `blocks` by `blocks` parts, each of which
+ * samples the source at its own phase, up to half a cell either way on both axes.
+ */
+export declare function blockResetUpscale(source: PixelBuffer, scale: number, blocks: number, seed?: number): PixelBuffer;
+/**
+ * pixel-bench's cell_texture: a nearest upscale under a smooth multiplicative texture (correlated
+ * over a fifth of a cell) of standard deviation `amplitude`.
+ */
+export declare function texturedUpscale(source: PixelBuffer, scale: number, amplitude: number, seed?: number): PixelBuffer;
+/** A soft "AI upscale": centred bilinear, a further blur and mild noise. */
+export declare function mush(source: PixelBuffer, scale: number, seed?: number): PixelBuffer;
+/** Separable box blur with the given radius (radius 1 smears each edge over about 3 pixels). */
+export declare function boxBlur(source: PixelBuffer, radius: number): PixelBuffer;
+export declare function gradient(width: number, height: number): PixelBuffer;
+/** Smooth, photo-like colour field: low-frequency waves plus a few soft blobs, no hard edges. */
+export declare function smoothPhoto(width: number, height: number): PixelBuffer;
+/** Textured "photo": noise at several scales, so it has edges everywhere. */
+export declare function texturePhoto(width: number, height: number, seed?: number): PixelBuffer;
+export declare function addNoise(source: PixelBuffer, amplitude: number, seed?: number): PixelBuffer;
+/** Cells of 15 to 17 pixels with a margin, like a hand-resized sprite. */
+export declare function jitterWithMargin(source: PixelBuffer, margin?: number, seed?: number): PixelBuffer;
+/** A smooth backdrop with hard-edged, anti-aliased shapes at arbitrary positions (no pixel grid). */
+export declare function vectorShapes(width: number, height: number, seed?: number): PixelBuffer;
+/**
+ * A generated sprite: `art` on a clear margin of `margin` cells, drawn with cells of 1 ± `spread`
+ * of `pitch`, each on its own, then softened by a box blur of `blur` pixels. No lattice fits it.
+ */
+export declare function generatedSprite(art: PixelBuffer, pitch: number, spread: number, margin?: number, blur?: number, seed?: number): PixelBuffer;
+/** A sprite on a clear background: `sprite` with its background colour made transparent. */
+export declare function clearSprite(size: number, seed?: number): PixelBuffer;