@xprite/pixelate 0.0.0-stage → 0.1.1

package/dist/line-guided/pixeloe-entry.d.ts

@@ -0,0 +1,15 @@
+import type { PixelBuffer } from "../base.ts";
+import { LineGuideMode, type PixelationSize } from "../types.ts";
+/**
+ * A recent PixelOE result for `image` under `variant` (the step and its settings), else computed
+ * and remembered. Callers get their own copy of the pixels.
+ */
+export declare function rememberPixeloe(image: PixelBuffer, variant: string, compute: () => PixelBuffer): PixelBuffer;
+/** Stock PixelOE pixelize (optionally line-guided) of the whole image to `size`. */
+export declare function runPixeloe(image: PixelBuffer, grid: PixelationSize, guide?: LineGuideMode): PixelBuffer;
+/**
+ * The binarised XDoG line mask at the image's own size (1 = line), for the image -> image PixelOE
+ * + lines pre-pass. Made like the stock guide (Otsu cut of the XDoG drawing at no more than 512 px on
+ * the long side), then enlarged to the image by nearest neighbour. Null when the drawing is uniform.
+ */
+export declare function sourceLineMask(image: PixelBuffer): Float32Array | null;

package/dist/line-guided/pixeloe-entry.js

@@ -0,0 +1,122 @@
+import { resizeArea8 } from "./cv-ops.js";
+import { legacyPixeloe, legacyPixeloeSizes, } from "./pixeloe-legacy.js";
+import { otsuThreshold, xdogLines } from "./xdog.js";
+import { resizeBox } from "../resize.js";
+import { LineGuideMode } from "../types.js";
+/**
+ * The line drawing is made at no more than this long side (or the working size, if larger): the
+ * XDoG parameters were tuned on sources of this size, where its 0.8 px blur finds drawn outlines
+ * rather than texture.
+ */
+const LINE_SOURCE_MAX = 512;
+const OPAQUE = 255;
+const ALPHA_CUTOFF = 128;
+const PAPER = 255;
+/** Recent results, so changing only colour settings does not rerun PixelOE. */
+const MEMO_SIZE = 4;
+/** Larger results (full-size pre-passes of big photos, 8 MB and up) are not kept. */
+const MAX_REMEMBERED_PIXELS = 2_097_152;
+const memo = [];
+const FNV_OFFSET = 0x811c9dc5;
+const FNV_PRIME = 0x01000193;
+const MIX_PRIME = 0x9e3779b1;
+/** Two independent 32-bit hashes of the pixels (FNV-1a and a multiplicative mix). */
+function fingerprint(data) {
+    const bytes = data.byteOffset % 4 ? data.slice() : data;
+    const words = new Uint32Array(bytes.buffer, bytes.byteOffset, bytes.byteLength >> 2);
+    let a = FNV_OFFSET, b = 0;
+    for (let i = 0; i < words.length; i++) {
+        a = Math.imul(a ^ words[i], FNV_PRIME);
+        b = Math.imul(b + words[i], MIX_PRIME) ^ (b >>> 15);
+    }
+    return `${(a >>> 0).toString(36)}${(b >>> 0).toString(36)}`;
+}
+/** RGB composited over white (transparent pixels would otherwise read as dark outlines). */
+function opaqueRgb(image) {
+    const { data } = image;
+    const rgb = new Uint8Array(image.width * image.height * 3);
+    let opaque = true;
+    for (let p = 0, i = 0; i < data.length; i += 4, p += 3) {
+        const alpha = data[i + 3];
+        if (alpha !== OPAQUE)
+            opaque = false;
+        for (let c = 0; c < 3; c++)
+            rgb[p + c] =
+                alpha === OPAQUE
+                    ? data[i + c]
+                    : Math.round((data[i + c] * alpha + PAPER * (OPAQUE - alpha)) / OPAQUE);
+    }
+    return { rgb, opaque };
+}
+function lineGuide(rgb, width, height, workLongSide, mode) {
+    const limit = Math.max(LINE_SOURCE_MAX, workLongSide);
+    const scale = Math.min(1, limit / Math.max(width, height));
+    const lw = Math.max(1, Math.round(width * scale)), lh = Math.max(1, Math.round(height * scale));
+    const source = scale < 1 ? resizeArea8(rgb, width, height, 3, lw, lh) : rgb;
+    const lines = xdogLines(source, lw, lh);
+    return { lines, width: lw, height: lh, threshold: otsuThreshold(lines), mode };
+}
+/**
+ * A recent PixelOE result for `image` under `variant` (the step and its settings), else computed
+ * and remembered. Callers get their own copy of the pixels.
+ */
+export function rememberPixeloe(image, variant, compute) {
+    const key = `${image.width}x${image.height}:${fingerprint(image.data)}:${variant}`;
+    const known = memo.find((entry) => entry.key === key);
+    if (known)
+        return { ...known.result, data: known.result.data.slice() };
+    const result = compute();
+    if (result.width * result.height > MAX_REMEMBERED_PIXELS)
+        return result;
+    memo.unshift({ key, result: { ...result, data: result.data.slice() } });
+    memo.length = Math.min(memo.length, MEMO_SIZE);
+    return result;
+}
+/** Stock PixelOE pixelize (optionally line-guided) of the whole image to `size`. */
+export function runPixeloe(image, grid, guide) {
+    return rememberPixeloe(image, `${grid.width}x${grid.height}:${guide ?? ""}`, () => pixeloe(image, grid, guide));
+}
+function pixeloe(image, grid, guide) {
+    const { width, height } = image;
+    const { rgb, opaque } = opaqueRgb(image);
+    const sizes = legacyPixeloeSizes(width, height, grid.width, grid.height);
+    const result = legacyPixeloe(rgb, width, height, {
+        width: grid.width,
+        height: grid.height,
+        guide: guide === undefined
+            ? undefined
+            : lineGuide(rgb, width, height, Math.max(...sizes.work), guide),
+    });
+    const data = new Uint8ClampedArray(result.width * result.height * 4);
+    const alpha = opaque ? null : resizeBox(image, result.width, result.height, "straight").data;
+    for (let p = 0, i = 0; p < result.rgb.length; p += 3, i += 4) {
+        data[i] = result.rgb[p];
+        data[i + 1] = result.rgb[p + 1];
+        data[i + 2] = result.rgb[p + 2];
+        // Pixel art keeps hard edges: a cell is either drawn or empty.
+        data[i + 3] = alpha && alpha[i + 3] < ALPHA_CUTOFF ? 0 : OPAQUE;
+    }
+    return { width: result.width, height: result.height, data };
+}
+/**
+ * The binarised XDoG line mask at the image's own size (1 = line), for the image -> image PixelOE
+ * + lines pre-pass. Made like the stock guide (Otsu cut of the XDoG drawing at no more than 512 px on
+ * the long side), then enlarged to the image by nearest neighbour. Null when the drawing is uniform.
+ */
+export function sourceLineMask(image) {
+    const { width, height } = image;
+    const { rgb } = opaqueRgb(image);
+    const { lines, width: lw, height: lh, threshold, } = lineGuide(rgb, width, height, 0, LineGuideMode.Union);
+    if (threshold === null)
+        return null;
+    const cut = Math.fround(threshold);
+    const mask = new Float32Array(width * height);
+    for (let y = 0; y < height; y++) {
+        const row = Math.min(lh - 1, Math.floor(((y + 0.5) * lh) / height)) * lw;
+        for (let x = 0; x < width; x++) {
+            const v = lines[row + Math.min(lw - 1, Math.floor(((x + 0.5) * lw) / width))];
+            mask[y * width + x] = Math.fround(v / 255) < cut ? 1 : 0;
+        }
+    }
+    return mask;
+}

package/dist/line-guided/pixeloe-legacy.d.ts

@@ -0,0 +1,31 @@
+import { LineGuideMode } from "../types.ts";
+export interface LegacyPixeloeOptions {
+    width: number;
+    height: number;
+    thickness?: number;
+    /** Line image (one byte per pixel, 255 = paper), its size and its 0..1 line threshold. */
+    guide?: LineGuide;
+}
+export interface LineGuide {
+    lines: Uint8Array;
+    width: number;
+    height: number;
+    /** Values below `threshold * 255` are line; null when the drawing has no lines at all. */
+    threshold: number | null;
+    mode: LineGuideMode;
+}
+export interface PixeloeSizes {
+    work: [number, number];
+    out: [number, number];
+}
+/**
+ * Use PixelOE's own sizing when some `target_size` gives exactly the requested output (then the
+ * result is the library's), otherwise work at the requested size x patch size.
+ */
+export declare function legacyPixeloeSizes(w: number, h: number, ow: number, oh: number): PixeloeSizes;
+/** Interleaved RGB at the source size to interleaved RGB at the requested output size. */
+export declare function legacyPixeloe(rgb: Uint8Array, w: number, h: number, options: LegacyPixeloeOptions): {
+    rgb: Uint8Array;
+    width: number;
+    height: number;
+};

package/dist/line-guided/pixeloe-legacy.js

@@ -0,0 +1,301 @@
+import { labToRgb8, rgbToLab8 } from "./cv-lab.js";
+import { MorphShape, gaussianBlur32, gaussianBlur8, morph8, pairwiseSum32, resizeArea32, resizeLinear64, resizeLinear8, resizeNearest, } from "./cv-ops.js";
+import { LineGuideMode } from "../types.js";
+/**
+ * PixelOE's legacy `pixelize()` (Apache-2.0, KohakuBlueleaf/PixelOE, `src/pixeloe/legacy`): resize
+ * to target x patch size, contrast-aware outline expansion, colour match, contrast-based downscale.
+ * Ported operation for operation from the OpenCV / NumPy / torch original with
+ * mode="contrast", patch_size=6, avg_scale=9, dist_scale=4 and no colour quantisation, so it matches
+ * the Python reference pixel for pixel. The expansion weight can be replaced by a line guide.
+ */
+const PIXELOE_PATCH_SIZE = 6;
+const PIXELOE_DEFAULT_THICKNESS = 2;
+const AVG_SCALE = 9;
+const DIST_SCALE = 4;
+const WEIGHT_STRIDE = Math.floor(PIXELOE_PATCH_SIZE / 4) * 2;
+const COLOR_LEVELS = 5;
+/** A guide mask cell counts as line when more than this share of it is line at working size. */
+const MASK_COVERAGE = 0.2;
+const ORIGINAL_MIX = 0.25;
+const ORIGINAL_SLOPE = 5;
+const f32 = Math.fround;
+/** pixelize() sizes for one `target_size`: working image and contrast-downscale output. */
+function pixeloeTargetSizes(w, h, target) {
+    const ratio = w / h;
+    const s = Math.sqrt((target ** 2 * PIXELOE_PATCH_SIZE ** 2) / ratio);
+    const work = [Math.trunc(s * ratio), Math.trunc(s)];
+    const r2 = work[0] / work[1];
+    const t = Math.sqrt(target ** 2 / r2);
+    return { work, out: [Math.trunc(t * r2), Math.trunc(t)] };
+}
+/**
+ * Largest working image (pixels). Outputs above ~330 px a side would otherwise need several
+ * hundred MB in a browser worker; they work at a smaller patch instead.
+ */
+const MAX_WORK_PIXELS = 2048 * 2048;
+/**
+ * Use PixelOE's own sizing when some `target_size` gives exactly the requested output (then the
+ * result is the library's), otherwise work at the requested size x patch size.
+ */
+export function legacyPixeloeSizes(w, h, ow, oh) {
+    const guess = Math.round(Math.sqrt(ow * oh));
+    for (const target of [Math.max(ow, oh), guess, guess - 1, guess + 1, guess - 2, guess + 2]) {
+        if (target < 1)
+            continue;
+        const sizes = pixeloeTargetSizes(w, h, target);
+        const [ww, wh] = sizes.work;
+        if (sizes.out[0] === ow &&
+            sizes.out[1] === oh &&
+            ww > 0 &&
+            wh > 0 &&
+            ww * wh <= MAX_WORK_PIXELS)
+            return sizes;
+    }
+    const patch = Math.max(1, Math.min(PIXELOE_PATCH_SIZE, Math.floor(Math.sqrt(MAX_WORK_PIXELS / (ow * oh)))));
+    return { work: [ow * patch, oh * patch], out: [ow, oh] };
+}
+/**
+ * utils.apply_chunk_torch: one statistic per `stride` block over an edge-padded `kernel` window.
+ * Every plane PixelOE takes statistics of holds 8-bit values (Lab bytes, or them / 255), so the
+ * window is gathered as bytes and the statistic reads a histogram instead of sorting.
+ */
+function chunkStat(data, w, h, kernel, stride, stat) {
+    const shift = Math.max(kernel - stride, 0);
+    const pad = shift >> 1;
+    const out = new Uint8Array(w * h);
+    const values = new Uint8Array(kernel * kernel);
+    const histogram = new Uint16Array(BYTE_VALUES);
+    const bw = Math.floor(w / stride), bh = Math.floor(h / stride);
+    const columns = new Int32Array(kernel);
+    for (let by = 0; by < bh; by++)
+        for (let bx = 0; bx < bw; bx++) {
+            for (let i = 0; i < kernel; i++)
+                columns[i] = Math.min(w - 1, Math.max(0, bx * stride - pad + i));
+            let n = 0;
+            for (let j = 0; j < kernel; j++) {
+                const row = Math.min(h - 1, Math.max(0, by * stride - pad + j)) * w;
+                for (let i = 0; i < kernel; i++)
+                    values[n++] = data[row + columns[i]];
+            }
+            const v = stat(values, histogram);
+            for (let y = by * stride; y < by * stride + stride; y++)
+                out.fill(v, y * w + bx * stride, y * w + bx * stride + stride);
+        }
+    return out;
+}
+const BYTE_VALUES = 256;
+/** Counts `values` into `histogram`; `release` empties it again for the next window. */
+function count(values, histogram) {
+    for (let i = 0; i < values.length; i++)
+        histogram[values[i]]++;
+}
+function release(values, histogram) {
+    for (let i = 0; i < values.length; i++)
+        histogram[values[i]] = 0;
+}
+/** The value at sorted position `rank` of the counted window. */
+function ranked(histogram, rank) {
+    let seen = 0;
+    for (let v = 0; v < BYTE_VALUES; v++) {
+        seen += histogram[v];
+        if (seen > rank)
+            return v;
+    }
+    return BYTE_VALUES - 1;
+}
+/** torch.median: the lower median. */
+const lowerMedian = (values, histogram) => {
+    count(values, histogram);
+    const median = ranked(histogram, (values.length - 1) >> 1);
+    release(values, histogram);
+    return median;
+};
+const minimum = (values) => {
+    let v = values[0];
+    for (let i = 1; i < values.length; i++)
+        if (values[i] < v)
+            v = values[i];
+    return v;
+};
+const maximum = (values) => {
+    let v = values[0];
+    for (let i = 1; i < values.length; i++)
+        if (values[i] > v)
+            v = values[i];
+    return v;
+};
+const sigmoid = (x) => 1 / (1 + Math.exp(-x));
+/** outline.expansion_weight(img, k=patch, stride, 9, 4) on interleaved RGB. */
+function expansionWeight(rgb, w, h) {
+    const lab = rgbToLab8(rgb);
+    const lum = new Uint8Array(w * h);
+    for (let i = 0; i < lum.length; i++)
+        lum[i] = lab[i * 3];
+    const k = PIXELOE_PATCH_SIZE;
+    // The reference takes these statistics of L / 255; the order statistics commute with it.
+    const median = chunkStat(lum, w, h, k * 2, WEIGHT_STRIDE, lowerMedian);
+    const high = chunkStat(lum, w, h, k, WEIGHT_STRIDE, maximum);
+    const low = chunkStat(lum, w, h, k, WEIGHT_STRIDE, minimum);
+    const raw = new Float64Array(w * h);
+    for (let i = 0; i < raw.length; i++) {
+        const avg = median[i] / 255, bright = high[i] / 255 - avg, dark = avg - low[i] / 255;
+        raw[i] = sigmoid((avg - 0.5) * AVG_SCALE - (bright - dark) * DIST_SCALE);
+    }
+    const hw = Math.floor(w / WEIGHT_STRIDE), hh = Math.floor(h / WEIGHT_STRIDE);
+    const weight = resizeLinear64(resizeLinear64(raw, w, h, hw, hh), hw, hh, w, h);
+    let lo = Infinity, hi = -Infinity;
+    for (const v of weight) {
+        if (v < lo)
+            lo = v;
+        if (v > hi)
+            hi = v;
+    }
+    for (let i = 0; i < weight.length; i++)
+        weight[i] = (weight[i] - lo) / hi;
+    return weight;
+}
+/** outline.outline_expansion with a given weight (erode = dilate = thickness). */
+function outlineExpansion(rgb, w, h, weight, thickness) {
+    const eroded = morph8(rgb, w, h, 3, MorphShape.Rect, true, thickness);
+    const dilated = morph8(rgb, w, h, 3, MorphShape.Rect, false, thickness);
+    const mixed = new Uint8Array(rgb.length);
+    for (let p = 0; p < w * h; p++) {
+        const wt = weight[p];
+        const orig = sigmoid((wt - 0.5) * ORIGINAL_SLOPE) * ORIGINAL_MIX;
+        for (let c = 0; c < 3; c++) {
+            const i = p * 3 + c;
+            const v = eroded[i] * wt + dilated[i] * (1 - wt);
+            mixed[i] = Math.trunc(v * (1 - orig) + rgb[i] * orig);
+        }
+    }
+    const once = morph8(mixed, w, h, 3, MorphShape.Cross, true, thickness);
+    const twice = morph8(once, w, h, 3, MorphShape.Cross, false, thickness * 2);
+    return morph8(twice, w, h, 3, MorphShape.Cross, true, thickness);
+}
+function labStats(lab) {
+    const n = lab.length;
+    const mean = f32(pairwiseSum32(lab) / n);
+    const sq = new Float32Array(n);
+    for (let i = 0; i < n; i++) {
+        const d = f32(lab[i] - mean);
+        sq[i] = f32(d * d);
+    }
+    return { mean, std: f32(Math.sqrt(f32(pairwiseSum32(sq) / n))) };
+}
+/** color.match_color(source, target, level=5) on interleaved RGB. */
+function matchColor(source, target, w, h) {
+    const toFloat = (rgb) => {
+        const lab = rgbToLab8(rgb);
+        const out = new Float32Array(lab.length);
+        for (let i = 0; i < lab.length; i++)
+            out[i] = lab[i] / 255;
+        return out;
+    };
+    const s = toFloat(source), t = toFloat(target);
+    const ss = labStats(s), ts = labStats(t);
+    const shifted = new Uint8Array(s.length);
+    for (let i = 0; i < s.length; i++) {
+        const v = f32(f32(f32(f32(s[i] - ss.mean) / ss.std) * ts.std) + ts.mean);
+        shifted[i] = Math.trunc(Math.min(255, Math.max(0, f32(v * 255))));
+    }
+    const rgb = labToRgb8(shifted);
+    const out = new Uint8Array(rgb.length);
+    const n = w * h;
+    for (let c = 0; c < 3; c++) {
+        let inp = new Float32Array(n);
+        let tgt = new Uint8Array(n);
+        for (let i = 0; i < n; i++) {
+            inp[i] = rgb[i * 3 + c];
+            tgt[i] = target[i * 3 + c];
+        }
+        const high = new Float32Array(n);
+        for (let level = 1; level <= COLOR_LEVELS; level++) {
+            const size = 2 * 2 ** level + 1;
+            const low = gaussianBlur32(inp, w, h, size, 0);
+            for (let i = 0; i < n; i++)
+                high[i] = f32(high[i] + f32(inp[i] - low[i]));
+            inp = low;
+            tgt = gaussianBlur8(tgt, w, h, size);
+        }
+        for (let i = 0; i < n; i++)
+            out[i * 3 + c] = Math.trunc(Math.min(255, Math.max(0, f32(high[i] + tgt[i]))));
+    }
+    return out;
+}
+/** downscale.contrast_based.find_pixel over one patch of L values. */
+const contrastPick = (values, histogram) => {
+    const mid = values[values.length >> 1];
+    count(values, histogram);
+    const med = ranked(histogram, (values.length - 1) >> 1);
+    release(values, histogram);
+    let sum = 0, mini = values[0], maxi = values[0];
+    for (let i = 0; i < values.length; i++) {
+        const v = values[i];
+        sum += v;
+        if (v < mini)
+            mini = v;
+        if (v > maxi)
+            maxi = v;
+    }
+    const mu = f32(sum / values.length);
+    if (med < mu && maxi - med > med - mini)
+        return mini;
+    if (med > mu && maxi - med < med - mini)
+        return maxi;
+    return mid;
+};
+/** downscale.contrast_based.contrast_based_downscale to an exact output size. */
+function contrastDownscale(rgb, w, h, ow, oh) {
+    const patch = Math.max(Math.floor(h / oh), Math.floor(w / ow));
+    const lab = rgbToLab8(rgb);
+    const planes = [0, 1, 2].map((c) => {
+        const plane = new Uint8Array(w * h);
+        for (let i = 0; i < plane.length; i++)
+            plane[i] = lab[i * 3 + c];
+        return plane;
+    });
+    const picked = [
+        chunkStat(planes[0], w, h, patch, patch, contrastPick),
+        chunkStat(planes[1], w, h, patch, patch, lowerMedian),
+        chunkStat(planes[2], w, h, patch, patch, lowerMedian),
+    ];
+    const merged = new Uint8Array(w * h * 3);
+    for (let i = 0; i < w * h; i++)
+        for (let c = 0; c < 3; c++)
+            merged[i * 3 + c] = picked[c][i];
+    return resizeNearest(labToRgb8(merged), w, h, 3, ow, oh);
+}
+/** Line pixels (value below `threshold * 255`) as the guide mask at working size. */
+function guideMask(lines, threshold, w, h, ww, wh) {
+    // NumPy compares a float32 array with a Python float in float32 (NEP 50), so both bounds are too.
+    const cut = f32(threshold), coverage = f32(MASK_COVERAGE);
+    const binary = new Float32Array(lines.length);
+    for (let i = 0; i < lines.length; i++)
+        binary[i] = f32(lines[i] / 255) < cut ? 1 : 0;
+    const area = resizeArea32(binary, w, h, ww, wh);
+    return area.map((v) => (v > coverage ? 1 : 0));
+}
+/** Interleaved RGB at the source size to interleaved RGB at the requested output size. */
+export function legacyPixeloe(rgb, w, h, options) {
+    const thickness = options.thickness ?? PIXELOE_DEFAULT_THICKNESS;
+    const { work: [ww, wh], out: [ow, oh], } = legacyPixeloeSizes(w, h, options.width, options.height);
+    const work = resizeLinear8(rgb, w, h, 3, ww, wh);
+    let expanded = work;
+    if (thickness > 0) {
+        const guide = options.guide;
+        // Lines only replaces the contrast weight outright, so it is not computed at all then.
+        let weight = guide?.mode === LineGuideMode.Replace ? [] : expansionWeight(work, ww, wh);
+        if (guide) {
+            const mask = guide.threshold === null
+                ? new Float32Array(ww * wh)
+                : guideMask(guide.lines, guide.threshold, guide.width, guide.height, ww, wh);
+            weight =
+                guide.mode === LineGuideMode.Replace
+                    ? mask
+                    : Float64Array.from(weight, (v, i) => Math.max(v, mask[i]));
+        }
+        expanded = outlineExpansion(work, ww, wh, weight, thickness);
+    }
+    const matched = matchColor(expanded, work, ww, wh);
+    return { rgb: contrastDownscale(matched, ww, wh, ow, oh), width: ow, height: oh };
+}

package/dist/line-guided/xdog.d.ts

@@ -0,0 +1,7 @@
+/** One byte per pixel: 255 = no line, lower = line. */
+export declare function xdogLines(rgb: Uint8Array, width: number, height: number): Uint8Array;
+/**
+ * skimage `threshold_otsu` of `line / 255` (256 bins over the value range), as a 0..1 threshold.
+ * Returns null when the image has a single value.
+ */
+export declare function otsuThreshold(line: Uint8Array): number | null;

package/dist/line-guided/xdog.js

@@ -0,0 +1,84 @@
+import { gaussianBlur32, gaussianSize, rgbToGray8, } from "./cv-ops.js";
+/**
+ * XDoG line drawing (Winnemöller 2012) with the parameters of the reference: sigma 0.8, k 1.6,
+ * p 20, eps 0, phi 10, on the 8-bit grey image. White (255) is paper, darker values are lines.
+ */
+const XDOG_SIGMA = 0.8;
+const XDOG_K = 1.6;
+const XDOG_P = 20;
+const XDOG_PHI = 10;
+const f32 = Math.fround;
+/** One byte per pixel: 255 = no line, lower = line. */
+export function xdogLines(rgb, width, height) {
+    const gray = rgbToGray8(rgb);
+    const g = new Float32Array(gray.length);
+    for (let i = 0; i < g.length; i++)
+        g[i] = f32(gray[i] / 255);
+    const sigmaB = XDOG_SIGMA * XDOG_K;
+    const a = gaussianBlur32(g, width, height, gaussianSize(XDOG_SIGMA), XDOG_SIGMA);
+    const b = gaussianBlur32(g, width, height, gaussianSize(sigmaB), sigmaB);
+    const out = new Uint8Array(g.length);
+    for (let i = 0; i < g.length; i++) {
+        const d = f32(f32((1 + XDOG_P) * a[i]) - f32(XDOG_P * b[i]));
+        const v = d >= 0 ? 1 : f32(1 + f32(Math.tanh(f32(XDOG_PHI * d))));
+        out[i] = Math.trunc(f32(Math.min(1, Math.max(0, v)) * 255));
+    }
+    return out;
+}
+/**
+ * skimage `threshold_otsu` of `line / 255` (256 bins over the value range), as a 0..1 threshold.
+ * Returns null when the image has a single value.
+ */
+export function otsuThreshold(line) {
+    let lo = 255, hi = 0;
+    for (const v of line) {
+        if (v < lo)
+            lo = v;
+        if (v > hi)
+            hi = v;
+    }
+    if (lo === hi)
+        return null;
+    const bins = 256;
+    const first = lo / 255, last = hi / 255;
+    const counts = new Float64Array(bins);
+    const norm = bins / (last - first);
+    for (const v of line) {
+        const x = v / 255;
+        let i = Math.floor((x - first) * norm);
+        if (i === bins)
+            i--;
+        counts[i]++;
+    }
+    const width = (last - first) / bins;
+    const centres = new Float64Array(bins);
+    for (let i = 0; i < bins; i++) {
+        const left = first + i * width, right = i === bins - 1 ? last : first + (i + 1) * width;
+        centres[i] = (left + right) / 2;
+    }
+    const w1 = new Float64Array(bins), m1 = new Float64Array(bins), w2 = new Float64Array(bins), m2 = new Float64Array(bins);
+    let cw = 0, cs = 0;
+    for (let i = 0; i < bins; i++) {
+        cw += counts[i];
+        cs += counts[i] * centres[i];
+        w1[i] = cw;
+        m1[i] = cs / cw;
+    }
+    cw = 0;
+    cs = 0;
+    for (let i = bins - 1; i >= 0; i--) {
+        cw += counts[i];
+        cs += counts[i] * centres[i];
+        w2[i] = cw;
+        m2[i] = cs / cw;
+    }
+    let best = -1, index = 0;
+    for (let i = 0; i < bins - 1; i++) {
+        const v = w1[i] * w2[i + 1] * (m1[i] - m2[i + 1]) ** 2;
+        if (v > best) {
+            best = v;
+            index = i;
+        }
+    }
+    return centres[index];
+}

package/dist/most-frequent.d.ts

@@ -0,0 +1,3 @@
+import { type PixelBuffer } from "./base.ts";
+/** Choose a cell's most frequent RGB, counting transparent pixels as empty samples. */
+export declare function resizeMostFrequent(source: Readonly<PixelBuffer>, width: number, height: number): PixelBuffer;

package/dist/most-frequent.js

@@ -0,0 +1,56 @@
+import { UINT8_MAX } from "./base.js";
+import { assertDimension, assertPixelCount } from "./base.js";
+const CHANNELS = 4;
+const RGB_BASE = 256;
+const EMPTY_SAMPLE = -1;
+const MAX_SAMPLES_PER_AXIS = 64;
+/** Choose a cell's most frequent RGB, counting transparent pixels as empty samples. */
+export function resizeMostFrequent(source, width, height) {
+    assertDimension(source.width, "source width");
+    assertDimension(source.height, "source height");
+    assertDimension(width, "width");
+    assertDimension(height, "height");
+    assertPixelCount(width, height);
+    if (source.data.length !== source.width * source.height * CHANNELS)
+        throw new Error("Invalid pixel buffer.");
+    const data = new Uint8ClampedArray(width * height * CHANNELS);
+    for (let row = 0; row < height; row++) {
+        const top = Math.floor((row * source.height) / height);
+        const bottom = Math.min(source.height, Math.max(top + 1, Math.floor(((row + 1) * source.height) / height)));
+        const yStep = Math.ceil((bottom - top) / MAX_SAMPLES_PER_AXIS);
+        for (let column = 0; column < width; column++) {
+            const left = Math.floor((column * source.width) / width);
+            const right = Math.min(source.width, Math.max(left + 1, Math.floor(((column + 1) * source.width) / width)));
+            const xStep = Math.ceil((right - left) / MAX_SAMPLES_PER_AXIS);
+            const counts = new Map();
+            let alphaSum = 0;
+            let samples = 0;
+            for (let y = top; y < bottom; y += yStep)
+                for (let x = left; x < right; x += xStep) {
+                    const offset = (y * source.width + x) * CHANNELS;
+                    alphaSum += source.data[offset + 3];
+                    samples++;
+                    const key = source.data[offset + 3] === 0
+                        ? EMPTY_SAMPLE
+                        : (source.data[offset] * RGB_BASE + source.data[offset + 1]) * RGB_BASE +
+                            source.data[offset + 2];
+                    counts.set(key, (counts.get(key) ?? 0) + 1);
+                }
+            let selected = EMPTY_SAMPLE;
+            let largest = 0;
+            for (const [color, count] of counts)
+                if (count > largest) {
+                    selected = color;
+                    largest = count;
+                }
+            if (selected === EMPTY_SAMPLE)
+                continue;
+            const offset = (row * width + column) * CHANNELS;
+            data[offset] = Math.floor(selected / (RGB_BASE * RGB_BASE));
+            data[offset + 1] = Math.floor(selected / RGB_BASE) % RGB_BASE;
+            data[offset + 2] = selected % RGB_BASE;
+            data[offset + 3] = Math.min(UINT8_MAX, Math.round(alphaSum / samples));
+        }
+    }
+    return { width, height, data };
+}

package/dist/outline-prepass.d.ts

@@ -0,0 +1,37 @@
+import type { PixelBuffer } from "./base.ts";
+import { CellColorPicker, LineGuideMode, OutlinePrepass, PixelationMode, type PixelGridGeometry } from "./types.ts";
+/**
+ * Whether these options run stock PixelOE end to end (its contrast downscale and colour match to the
+ * output size) instead of a pre-pass followed by the picker: a PixelOE pre-pass with the Contrast
+ * picker, when the cells are not a grid recovered from the source (a plain convert, or Custom size's
+ * even blocks). This is the PixelOE reference output.
+ */
+export declare function runsStockPixeloe(options: {
+    prepass?: OutlinePrepass;
+    colorPicker?: CellColorPicker;
+    mode?: PixelationMode;
+}, grid?: PixelGridGeometry): boolean;
+/**
+ * The image -> image pre-pass (the original PixelOE pre-pass, optionally line-guided). Recent
+ * results are reused, so a colour or picker change on the same image does not rerun it.
+ */
+export declare function applyOutlinePrepass(image: PixelBuffer, cell: number, prepass: OutlinePrepass, lineGuide?: LineGuideMode): PixelBuffer;
+/**
+ * The pre-pass every source opens with, whether or not a grid is found: PixelOE + lines (with the
+ * Contrast picker). None, the plain grid recovery, is one choice away in the controls.
+ */
+export declare const DEFAULT_OUTLINE_PREPASS = OutlinePrepass.PixeloeLines;
+/**
+ * The line guide PixelOE + lines starts with: Lines only (the line mask replaces PixelOE's outline
+ * weight). Add to outlines barely differs from plain PixelOE on line art, while Lines only keeps
+ * continuous drawn lines (e.g. an eye line) through the downscale.
+ */
+export declare const DEFAULT_LINE_GUIDE = LineGuideMode.Replace;
+/**
+ * A pre-pass from saved settings: the current value, or the old `pixeloePrepass` checkbox
+ * (true -> PixelOE, false -> None).
+ */
+export declare function readOutlinePrepass(saved: {
+    prepass?: unknown;
+    pixeloePrepass?: unknown;
+}): OutlinePrepass | undefined;