@xprite/pixelate 0.0.0-stage → 0.1.1

package/dist/grid-warp.js

@@ -0,0 +1,252 @@
+/** Knot spacing in cells. */
+const KNOT_CELLS = 2;
+/** Smoothness weight per knot, relative to the mean edge weight per knot. */
+const SMOOTHNESS = 4;
+const RIDGE = 1e-9;
+/** Gaps of at least this many cells (one hidden cut or more) may gain or lose a cell. */
+const MIN_RELABEL_CELLS = 2;
+const RELABEL_PASSES = 3;
+/** Relative drop of the penalised error that a changed gap must earn. */
+const RELABEL_GAIN = 0.03;
+/** Range of local pitches the labelling considers, around the proposed pitch. */
+const PITCH_LOW = 0.7;
+const PITCH_HIGH = 1.6;
+/** Relative step between pitch states. */
+const PITCH_RESOLUTION = 0.006;
+/** Standard deviation of one gap's length in pixels between soft (sub-pixel) edges. */
+const GAP_NOISE = 0.45;
+/**
+ * Least likelihood of a crisp gap's misfit. Crisp edges are cuts rounded to the raster, so a gap
+ * misses its cells by less than a pixel (a triangular density on (-1, 1)); the floor bounds the
+ * cost of a stray edge.
+ */
+const ROUNDING_FLOOR = 1e-3;
+/**
+ * Standard deviation of the log pitch's wander across the whole axis. Distortions bend the grid
+ * over the image, not per cell, so the allowance per cell shrinks as the cells grow in number.
+ */
+const DRIFT = 0.2;
+/**
+ * Bounds of the share of cuts that show no edge (neighbouring cells of one colour). A gap of
+ * several cells hides a cut, at -log of that share: detailed art, where most cuts show, keeps the
+ * coarser of two labellings that fit equally well. Hidden cuts come in flat runs, so each further
+ * cell of the gap costs only CELL_COST and long gaps follow the neighbouring pitch.
+ */
+const MIN_HIDDEN = 0.02;
+const MAX_HIDDEN = 0.9;
+const CELL_COST = 0.02;
+export function warpAt(warp, x) {
+    const { spacing, values } = warp;
+    const last = values.length - 1;
+    const t = x / spacing;
+    const m = Math.max(0, Math.min(last - 1, Math.floor(t)));
+    const a = t - m;
+    return values[m] * (1 - a) + values[m + 1] * a;
+}
+/** Local pitch (pixels per cell) at x. */
+export function warpPitch(warp, x) {
+    const { spacing, values } = warp;
+    const m = Math.max(0, Math.min(values.length - 2, Math.floor(x / spacing)));
+    const slope = (values[m + 1] - values[m]) / spacing;
+    return slope > 0 ? 1 / slope : Infinity;
+}
+/** Position in [from, to] where u reaches `index` (u is increasing there); NaN when it does not. */
+export function warpInverse(warp, index, from, to) {
+    let lo = from, hi = to;
+    if (warpAt(warp, lo) > index || warpAt(warp, hi) < index)
+        return NaN;
+    for (let i = 0; i < 40 && hi - lo > 1e-4; i++) {
+        const mid = (lo + hi) / 2;
+        if (warpAt(warp, mid) < index)
+            lo = mid;
+        else
+            hi = mid;
+    }
+    return (lo + hi) / 2;
+}
+/** Solves the symmetric positive definite pentadiagonal system (band Cholesky). */
+export function solveBanded(diag, off1, off2, rhs) {
+    const n = diag.length;
+    // l0 = L[i][i], l1 = L[i][i-1], l2 = L[i][i-2]
+    const l0 = new Float64Array(n), l1 = new Float64Array(n), l2 = new Float64Array(n);
+    for (let i = 0; i < n; i++) {
+        const a2 = i >= 2 ? off2[i - 2] / l0[i - 2] : 0;
+        const a1 = i >= 1 ? (off1[i - 1] - (i >= 2 ? a2 * l1[i - 1] : 0)) / l0[i - 1] : 0;
+        l0[i] = Math.sqrt(Math.max(diag[i] - a1 * a1 - a2 * a2, RIDGE));
+        l1[i] = a1;
+        l2[i] = a2;
+    }
+    const y = new Float64Array(n);
+    for (let i = 0; i < n; i++)
+        y[i] = (rhs[i] - (i >= 1 ? l1[i] * y[i - 1] : 0) - (i >= 2 ? l2[i] * y[i - 2] : 0)) / l0[i];
+    const x = new Float64Array(n);
+    for (let i = n - 1; i >= 0; i--)
+        x[i] =
+            (y[i] - (i + 1 < n ? l1[i + 1] * x[i + 1] : 0) - (i + 2 < n ? l2[i + 2] * x[i + 2] : 0)) /
+                l0[i];
+    return x;
+}
+/**
+ * Least-squares knot values for edges at integer `targets`, under the smoothness penalty, and the
+ * penalised squared error they leave.
+ */
+function solve(length, spacing, edges, targets) {
+    const n = Math.max(2, Math.ceil(length / spacing) + 1);
+    const diag = new Float64Array(n), off1 = new Float64Array(n), off2 = new Float64Array(n), rhs = new Float64Array(n);
+    let total = 0;
+    for (let j = 0; j < edges.length; j++) {
+        const { position, weight: w } = edges[j];
+        const t = position / spacing;
+        const m = Math.max(0, Math.min(n - 2, Math.floor(t)));
+        const a = t - m;
+        diag[m] += w * (1 - a) * (1 - a);
+        diag[m + 1] += w * a * a;
+        off1[m] += w * a * (1 - a);
+        rhs[m] += w * (1 - a) * targets[j];
+        rhs[m + 1] += w * a * targets[j];
+        total += w;
+    }
+    const lambda = (SMOOTHNESS * total) / n;
+    const c = [1, -2, 1];
+    for (let m = 1; m + 1 < n; m++)
+        for (let p = 0; p < 3; p++)
+            for (let q = p; q < 3; q++) {
+                const v = lambda * c[p] * c[q];
+                const row = m - 1 + p;
+                if (q === p)
+                    diag[row] += v;
+                else if (q - p === 1)
+                    off1[row] += v;
+                else
+                    off2[row] += v;
+            }
+    for (let m = 0; m < n; m++)
+        diag[m] += RIDGE * (lambda + 1);
+    const warp = { spacing, values: solveBanded(diag, off1, off2, rhs) };
+    let cost = 0;
+    for (let j = 0; j < edges.length; j++) {
+        const residual = warpAt(warp, edges[j].position) - targets[j];
+        cost += edges[j].weight * residual * residual;
+    }
+    const v = warp.values;
+    for (let m = 1; m + 1 < n; m++) {
+        const bend = v[m - 1] - 2 * v[m] + v[m + 1];
+        cost += lambda * bend * bend;
+    }
+    return { warp, cost };
+}
+/**
+ * The labelling's random walk lets the pitch wander over a long run without edges, where one cell
+ * more or less fits equally well. The warp's smoothness then decides: each gap of several cells
+ * tries one cell more and one less (shifting every later edge), kept when the penalised error drops.
+ */
+function relabel(length, spacing, edges, labels) {
+    let best = solve(length, spacing, edges, labels);
+    for (let pass = 0; pass < RELABEL_PASSES; pass++) {
+        let changed = false;
+        for (let j = 0; j + 1 < labels.length; j++) {
+            const cells = labels[j + 1] - labels[j];
+            if (cells < MIN_RELABEL_CELLS)
+                continue;
+            for (const step of [-1, 1]) {
+                if (cells + step < MIN_RELABEL_CELLS)
+                    continue;
+                const trial = labels.slice();
+                for (let k = j + 1; k < trial.length; k++)
+                    trial[k] += step;
+                const fit = solve(length, spacing, edges, trial);
+                if (fit.cost < best.cost * (1 - RELABEL_GAIN)) {
+                    best = fit;
+                    labels = trial;
+                    changed = true;
+                    break;
+                }
+            }
+        }
+        if (!changed)
+            break;
+    }
+    return best.warp;
+}
+/** Cell index of every edge (the first is 0), by the jointly best labelling of the gaps. */
+function labelEdges(positions, proposed, minPitch, crisp) {
+    const ratio = 1 + PITCH_RESOLUTION;
+    const pitches = [];
+    for (let p = Math.max(minPitch, proposed * PITCH_LOW); p <= proposed * PITCH_HIGH; p *= ratio)
+        pitches.push(p);
+    const states = pitches.length;
+    const logs = pitches.map(Math.log);
+    const gaps = positions.length - 1;
+    const from = new Int16Array(gaps * states);
+    const cellsOf = new Int32Array(gaps * states);
+    let cost = new Float64Array(states);
+    let next = new Float64Array(states);
+    const obsScale = 1 / (2 * GAP_NOISE * GAP_NOISE);
+    const span = positions[gaps] - positions[0];
+    const hidden = Math.min(MAX_HIDDEN, Math.max(MIN_HIDDEN, 1 - gaps / Math.max(1, span / proposed)));
+    const shownCost = -Math.log(1 - hidden), hiddenCost = -Math.log(hidden);
+    const driftScale = Math.max(1, span / proposed) / (2 * DRIFT * DRIFT);
+    for (let j = 0; j < gaps; j++) {
+        const gap = positions[j + 1] - positions[j];
+        for (let b = 0; b < states; b++) {
+            const cells = Math.max(1, Math.round(gap / pitches[b]));
+            const misfit = gap - cells * pitches[b];
+            let best = Infinity, arg = 0;
+            for (let a = 0; a < states; a++) {
+                const d = logs[b] - logs[a];
+                const between = j > 0 ? (cellsOf[(j - 1) * states + a] + cells) / 2 : cells;
+                const value = cost[a] + (d * d * driftScale) / between;
+                if (value < best) {
+                    best = value;
+                    arg = a;
+                }
+            }
+            const observation = crisp
+                ? -Math.log(Math.max(ROUNDING_FLOOR, 1 - Math.abs(misfit)))
+                : misfit * misfit * obsScale;
+            const hiding = cells > 1 ? hiddenCost + CELL_COST * (cells - 2) : 0;
+            next[b] = best + observation + shownCost + hiding;
+            from[j * states + b] = arg;
+            cellsOf[j * states + b] = cells;
+        }
+        [cost, next] = [next, cost];
+    }
+    let state = 0;
+    for (let b = 1; b < states; b++)
+        if (cost[b] < cost[state])
+            state = b;
+    const labels = new Float64Array(positions.length);
+    const steps = new Int32Array(gaps);
+    for (let j = gaps - 1; j >= 0; j--) {
+        steps[j] = cellsOf[j * states + state];
+        state = from[j * states + state];
+    }
+    for (let j = 0; j < gaps; j++)
+        labels[j + 1] = labels[j] + steps[j];
+    return labels;
+}
+/**
+ * Fits u over [0, length] to `edges` with local pitches near `proposed`, none below `minPitch`
+ * (where the edges of narrower cells would merge); null with too few edges. `crisp` edges sit on
+ * whole pixels of a nearest-neighbour upscale.
+ * u(0) is shifted to the integer nearest zero, so a grid that starts on the image border starts at
+ * index 0.
+ */
+export function fitWarp(edges, length, proposed, minPitch, crisp) {
+    if (edges.length < 3 || !(proposed > 0))
+        return null;
+    const weights = edges.map((edge) => edge.weight).sort((a, b) => a - b);
+    const median = weights[Math.floor(weights.length / 2)] || 1;
+    const normalised = edges.map((edge) => ({
+        position: edge.position,
+        weight: Math.min(2, Math.max(0.25, Math.sqrt(edge.weight / median))),
+    }));
+    const labels = labelEdges(normalised.map((edge) => edge.position), proposed, minPitch, crisp);
+    const span = normalised[normalised.length - 1].position - normalised[0].position;
+    const mean = labels[labels.length - 1] > 0 ? span / labels[labels.length - 1] : proposed;
+    let warp = relabel(length, Math.max(1, KNOT_CELLS * mean), normalised, labels);
+    const shift = Math.round(warpAt(warp, 0));
+    if (shift)
+        warp = { spacing: warp.spacing, values: warp.values.map((v) => v - shift) };
+    return warp;
+}

package/dist/grid.d.ts

@@ -0,0 +1,8 @@
+import type { PixelBuffer } from "./base.ts";
+import type { PixelGridGeometry } from "./types.ts";
+export declare const MAX_RECOVERED_GRID_SIZE = 512;
+export declare const MAX_GRID_CELL_SIZE = 128;
+export declare function pixelGridCuts(length: number, step: number, offset?: number): number[];
+export declare function manualPixelGrid(image: Pick<PixelBuffer, "width" | "height">, cellWidth: number, cellHeight: number): PixelGridGeometry;
+/** Even partition of the image into `width` x `height` blocks (clamped to one pixel per block). */
+export declare function blockPartition(image: Pick<PixelBuffer, "width" | "height">, width: number, height: number): PixelGridGeometry;

package/dist/grid.js

@@ -0,0 +1,43 @@
+export const MAX_RECOVERED_GRID_SIZE = 512;
+export const MAX_GRID_CELL_SIZE = 128;
+const PHASE_SNAP = 0.2;
+const PIXEL_CENTER_OFFSET = 0.5;
+export function pixelGridCuts(length, step, offset = 0) {
+    if (!Number.isFinite(step) || step < 1 || !Number.isFinite(offset))
+        throw new RangeError("Grid cells must be at least one pixel wide.");
+    const phase = ((offset % step) + step) % step;
+    const cuts = [0];
+    let position = phase > PHASE_SNAP ? phase : phase + step;
+    for (; position < length - PHASE_SNAP; position += step) {
+        // Quantize one regular lattice to raster edges; never chase individual content edges.
+        const cut = Math.max(0, Math.min(length, Math.ceil(position - PIXEL_CENTER_OFFSET)));
+        if (cut > cuts[cuts.length - 1] && cut < length)
+            cuts.push(cut);
+    }
+    cuts.push(length);
+    return cuts;
+}
+export function manualPixelGrid(image, cellWidth, cellHeight) {
+    if (cellWidth > MAX_GRID_CELL_SIZE || cellHeight > MAX_GRID_CELL_SIZE)
+        throw new RangeError("Choose cell sizes no larger than 128 pixels.");
+    const width = pixelGridCuts(image.width, cellWidth).length - 1, height = pixelGridCuts(image.height, cellHeight).length - 1;
+    if (width > MAX_RECOVERED_GRID_SIZE || height > MAX_RECOVERED_GRID_SIZE)
+        throw new RangeError("Choose larger cells to restore this image.");
+    return { width, height, cellWidth, cellHeight, offsetX: 0, offsetY: 0 };
+}
+/** Even partition of the image into `width` x `height` blocks (clamped to one pixel per block). */
+export function blockPartition(image, width, height) {
+    const columns = Math.max(1, Math.min(image.width, Math.round(width)));
+    const rows = Math.max(1, Math.min(image.height, Math.round(height)));
+    const cuts = (length, count) => Array.from({ length: count + 1 }, (_, index) => Math.round((index * length) / count));
+    return {
+        width: columns,
+        height: rows,
+        cellWidth: image.width / columns,
+        cellHeight: image.height / rows,
+        offsetX: 0,
+        offsetY: 0,
+        cutsX: cuts(image.width, columns),
+        cutsY: cuts(image.height, rows),
+    };
+}

package/dist/index.d.ts

@@ -0,0 +1,16 @@
+export { analyzePixelArt, analyzePixelArtAsync } from "./analyze.ts";
+export { extractPalette, extractPixelationPalette, countDistinctColors, reduceToPalette, } from "./palette.ts";
+export { snapPalette } from "./palette-snap.ts";
+export { estimateTilt, straighten, MAX_TILT_DEGREES } from "./deskew.ts";
+export { resizeNearest } from "./resize.ts";
+export { pixelateImage, pixelateImageAsync } from "./pixelate.ts";
+export { PixelArtClassification, PixelationMethod, PixelationMode, PixelationAlgorithm, CellColorPicker, LineGuideMode, OutlinePrepass, PixelationDither, PaletteColorMode, PixelGridSamplingAxis, } from "./types.ts";
+export { DEFAULT_LINE_GUIDE, readOutlinePrepass, runsStockPixeloe, } from "./outline-prepass.ts";
+export type { ExtractPaletteOptions, PaletteEntry, PixelArtAnalysis, PixelArtAnalysisOptions, PixelArtMetrics, PaletteSnapOptions, PixelateOptions, PixelationSize, PixelationSettings, PixelGridGeometry, PixelGridAnalysis, PixelGridSamplingStage, } from "./types.ts";
+export { defaultPixelationSettings, updatePixelationSettings, applyPixelationGrid, pixelationSizeFromAxis, pixelationSettingsOptions, MAX_PIXELATION_SIZE, PIXELATION_SIZES, PIXELATION_METHOD_OPTIONS, } from "./settings.ts";
+export { manualPixelGrid, MAX_GRID_CELL_SIZE } from "./grid.ts";
+export { removeBackground, modeBorderColor, edgeSeededFloodAlpha, colorKeyDistance, adaptiveTolerance, sampleKeyColor, RemoveBackgroundMode, DEFAULT_REMOVE_BACKGROUND, } from "./remove-background.ts";
+export type { RemoveBackgroundOptions, RemoveBackgroundSettings, } from "./remove-background.ts";
+export { getAlgorithmEntry, getAllAlgorithms, getListedAlgorithms, getGridSources, pixelationMethodOf, detectWithAlgorithm, detectWithAlgorithmAsync, type PixelationAlgorithmEntry, } from "./pixelation-algorithm-registry.ts";
+export { getAllColorPickers, getColorPickerEntry, type CellColorPickerEntry, } from "./cell-color-picker.ts";
+export { preloadWasm, beginAcRlConsensusJob, finishAcRlConsensusJob, beginAcRlConsensusJobAsync, finishAcRlConsensusJobAsync, setAcRlBrowserWorkerFactory, warmAcRlBrowserWorker, acRlWorkerOverlapActive, acRlBrowserWorkerOverlapActive, } from "./grid-ac-rl-consensus.ts";

package/dist/index.js

@@ -0,0 +1,14 @@
+export { analyzePixelArt, analyzePixelArtAsync } from "./analyze.js";
+export { extractPalette, extractPixelationPalette, countDistinctColors, reduceToPalette, } from "./palette.js";
+export { snapPalette } from "./palette-snap.js";
+export { estimateTilt, straighten, MAX_TILT_DEGREES } from "./deskew.js";
+export { resizeNearest } from "./resize.js";
+export { pixelateImage, pixelateImageAsync } from "./pixelate.js";
+export { PixelArtClassification, PixelationMethod, PixelationMode, PixelationAlgorithm, CellColorPicker, LineGuideMode, OutlinePrepass, PixelationDither, PaletteColorMode, PixelGridSamplingAxis, } from "./types.js";
+export { DEFAULT_LINE_GUIDE, readOutlinePrepass, runsStockPixeloe, } from "./outline-prepass.js";
+export { defaultPixelationSettings, updatePixelationSettings, applyPixelationGrid, pixelationSizeFromAxis, pixelationSettingsOptions, MAX_PIXELATION_SIZE, PIXELATION_SIZES, PIXELATION_METHOD_OPTIONS, } from "./settings.js";
+export { manualPixelGrid, MAX_GRID_CELL_SIZE } from "./grid.js";
+export { removeBackground, modeBorderColor, edgeSeededFloodAlpha, colorKeyDistance, adaptiveTolerance, sampleKeyColor, RemoveBackgroundMode, DEFAULT_REMOVE_BACKGROUND, } from "./remove-background.js";
+export { getAlgorithmEntry, getAllAlgorithms, getListedAlgorithms, getGridSources, pixelationMethodOf, detectWithAlgorithm, detectWithAlgorithmAsync, } from "./pixelation-algorithm-registry.js";
+export { getAllColorPickers, getColorPickerEntry, } from "./cell-color-picker.js";
+export { preloadWasm, beginAcRlConsensusJob, finishAcRlConsensusJob, beginAcRlConsensusJobAsync, finishAcRlConsensusJobAsync, setAcRlBrowserWorkerFactory, warmAcRlBrowserWorker, acRlWorkerOverlapActive, acRlBrowserWorkerOverlapActive, } from "./grid-ac-rl-consensus.js";

package/dist/line-guided/cv-lab.d.ts

@@ -0,0 +1,4 @@
+/** Interleaved RGB (3 bytes per pixel) to interleaved 8-bit Lab. */
+export declare function rgbToLab8(rgb: Uint8Array): Uint8Array;
+/** Interleaved 8-bit Lab to interleaved RGB. */
+export declare function labToRgb8(lab: Uint8Array): Uint8Array;

package/dist/line-guided/cv-lab.js

@@ -0,0 +1,134 @@
+/**
+ * 8-bit sRGB <-> CIE Lab exactly as OpenCV's bit-exact `COLOR_RGB2LAB` / `COLOR_LAB2RGB`
+ * (modules/imgproc/src/color_lab.cpp, `RGB2Lab_b` and `Lab2RGBinteger`): the same lookup tables
+ * (built in single precision like OpenCV's softfloat) and the same fixed-point arithmetic, so the
+ * legacy PixelOE port reproduces the reference pixel for pixel. L is 0..255 (L*255/100), a and b
+ * are offset by 128.
+ */
+const f32 = Math.fround;
+const GAMMA_SHIFT = 3;
+const LAB_SHIFT = 12;
+const LAB_SHIFT2 = LAB_SHIFT + GAMMA_SHIFT;
+const CBRT_TABLE_SIZE = (256 * 3 * (1 << GAMMA_SHIFT)) / 2;
+const INV_GAMMA_SHIFT = 12;
+const INV_GAMMA_SIZE = 1 << INV_GAMMA_SHIFT;
+const LUT_BASE = 1 << 14;
+const MIN_AB = -8145;
+const AB_TABLE_SIZE = (LUT_BASE * 9) / 4;
+const RGB_SHIFT = LAB_SHIFT + 14 - INV_GAMMA_SHIFT;
+/** D65 white point and the sRGB matrices, as the doubles OpenCV stores. */
+const D65 = [0.950456, 1, 1.088754];
+const RGB_TO_XYZ = [
+    0.412453, 0.35758, 0.180423, 0.212671, 0.71516, 0.072169, 0.019334, 0.119193, 0.950227,
+];
+const XYZ_TO_RGB = [
+    3.240479, -1.53715, -0.498535, -0.969256, 1.875991, 0.041556, 0.055648, -0.204043, 1.057311,
+];
+/** The one cube-root table entry where softfloat and a correctly rounded cbrt disagree. */
+const CBRT_SOFTFLOAT_ENTRY = 324;
+const L_THRESH = f32(216 / 24389);
+const L_SCALE = f32(841 / 108);
+const L_BIAS = f32(16 / 116);
+/** cvRound: round half to even. */
+function round(v) {
+    const r = Math.round(v);
+    return r - v === 0.5 && r % 2 !== 0 ? r - 1 : r;
+}
+const descale = (v, n) => (v + (1 << (n - 1))) >> n;
+const clampByte = (v) => (v < 0 ? 0 : v > 255 ? 255 : v);
+function applyGamma(x) {
+    return f32(x <= 809 / 20000 ? x / (323 / 25) : ((x + 11 / 200) / (1 + 11 / 200)) ** (12 / 5));
+}
+function applyInvGamma(x) {
+    return f32(x <= 7827 / 2500000 ? x * (323 / 25) : x ** (1 / (12 / 5)) * (1 + 11 / 200) - 11 / 200);
+}
+let tables = null;
+function labTables() {
+    if (tables)
+        return tables;
+    const gamma = new Int32Array(256);
+    for (let i = 0; i < 256; i++)
+        gamma[i] = round(f32(f32(255 * 8) * applyGamma(f32(i / 255))));
+    const cbrt = new Int32Array(CBRT_TABLE_SIZE);
+    const cbScale = f32(1 / f32(255 * (1 << GAMMA_SHIFT)));
+    for (let i = 0; i < CBRT_TABLE_SIZE; i++) {
+        const x = f32(cbScale * i);
+        const v = x < L_THRESH ? f32(x * L_SCALE + L_BIAS) : f32(Math.cbrt(x));
+        cbrt[i] = round(f32((1 << LAB_SHIFT2) * v));
+    }
+    // OpenCV's softfloat cbrt is not correctly rounded here: it lands one float lower, so the
+    // scaled value is just under the .5 tie the correctly rounded cube root hits.
+    cbrt[CBRT_SOFTFLOAT_ENTRY] -= 1;
+    const forward = new Int32Array(9);
+    for (let i = 0; i < 3; i++)
+        for (let j = 0; j < 3; j++)
+            forward[i * 3 + j] = round(((1 << LAB_SHIFT) * RGB_TO_XYZ[i * 3 + j]) / D65[i]);
+    const yf = new Int32Array(512);
+    for (let i = 0; i < 256; i++) {
+        let y, ify;
+        if (i <= 20) {
+            y = round(f32(f32(i * LUT_BASE * 20 * 9) / f32(17 * 29 * 29 * 29)));
+            ify = round(f32(LUT_BASE * f32(f32(16 / 116) + f32(f32(i * 5) / f32(3 * 17 * 29)))));
+        }
+        else {
+            const fy = f32(f32(f32(i * 100 * LUT_BASE) / f32(255 * 116)) + f32(f32(16 * LUT_BASE) / f32(116)));
+            ify = round(fy);
+            y = round(f32(f32(f32(fy * fy) * fy) / f32(LUT_BASE * LUT_BASE)));
+        }
+        yf[i * 2] = y;
+        yf[i * 2 + 1] = ify;
+    }
+    const abToXz = new Int32Array(AB_TABLE_SIZE);
+    for (let i = MIN_AB; i < AB_TABLE_SIZE + MIN_AB; i++)
+        abToXz[i - MIN_AB] =
+            i <= 3390
+                ? Math.trunc((i * 108) / 841) - Math.trunc((Math.trunc((LUT_BASE * 16) / 116) * 108) / 841)
+                : Math.trunc((Math.trunc((i * i) / LUT_BASE) * i) / LUT_BASE);
+    const invGamma = new Uint8Array(INV_GAMMA_SIZE);
+    for (let i = 0; i < INV_GAMMA_SIZE; i++)
+        invGamma[i] = clampByte(round(f32(255 * applyInvGamma(f32(i / INV_GAMMA_SIZE)))));
+    const inverse = new Int32Array(9);
+    for (let i = 0; i < 3; i++)
+        for (let j = 0; j < 3; j++)
+            inverse[i * 3 + j] = round((1 << LAB_SHIFT) * XYZ_TO_RGB[i * 3 + j] * D65[j]);
+    tables = { gamma, cbrt, forward, yf, abToXz, invGamma, inverse };
+    return tables;
+}
+/** Interleaved RGB (3 bytes per pixel) to interleaved 8-bit Lab. */
+export function rgbToLab8(rgb) {
+    const { gamma, cbrt, forward: c } = labTables();
+    const out = new Uint8Array(rgb.length);
+    const lScale = Math.trunc((116 * 255 + 50) / 100);
+    const lShift = -Math.trunc((16 * 255 * (1 << LAB_SHIFT2) + 50) / 100);
+    const abShift = 128 * (1 << LAB_SHIFT2);
+    for (let i = 0; i < rgb.length; i += 3) {
+        const r = gamma[rgb[i]], g = gamma[rgb[i + 1]], b = gamma[rgb[i + 2]];
+        const fx = cbrt[descale(r * c[0] + g * c[1] + b * c[2], LAB_SHIFT)];
+        const fy = cbrt[descale(r * c[3] + g * c[4] + b * c[5], LAB_SHIFT)];
+        const fz = cbrt[descale(r * c[6] + g * c[7] + b * c[8], LAB_SHIFT)];
+        out[i] = clampByte(descale(lScale * fy + lShift, LAB_SHIFT2));
+        out[i + 1] = clampByte(descale(500 * (fx - fy) + abShift, LAB_SHIFT2));
+        out[i + 2] = clampByte(descale(200 * (fy - fz) + abShift, LAB_SHIFT2));
+    }
+    return out;
+}
+/** Interleaved 8-bit Lab to interleaved RGB. */
+export function labToRgb8(lab) {
+    const { yf, abToXz, invGamma, inverse: c } = labTables();
+    const out = new Uint8Array(lab.length);
+    const top = INV_GAMMA_SIZE - 1;
+    const aOffset = Math.trunc((128 * LUT_BASE) / 500);
+    const bOffset = Math.trunc((128 * LUT_BASE) / 200) - 1;
+    for (let i = 0; i < lab.length; i += 3) {
+        const l = lab[i], a = lab[i + 1], b = lab[i + 2];
+        const y = yf[l * 2], ify = yf[l * 2 + 1];
+        const adiv = ((5 * a * 53687 + (1 << 7)) >> 13) - aOffset;
+        const bdiv = ((b * 41943 + (1 << 4)) >> 9) - bOffset;
+        const x = abToXz[ify + adiv - MIN_AB], z = abToXz[ify - bdiv - MIN_AB];
+        for (let k = 0; k < 3; k++) {
+            const v = descale(c[k * 3] * x + c[k * 3 + 1] * y + c[k * 3 + 2] * z, RGB_SHIFT);
+            out[i + k] = invGamma[v < 0 ? 0 : v > top ? top : v];
+        }
+    }
+    return out;
+}

package/dist/line-guided/cv-ops.d.ts

@@ -0,0 +1,29 @@
+export declare function rgbToGray8(rgb: Uint8Array): Uint8Array;
+/** cv::resize INTER_LINEAR for 8-bit images with `cn` interleaved channels. */
+export declare function resizeLinear8(src: Uint8Array, sw: number, sh: number, cn: number, dw: number, dh: number): Uint8Array;
+/** cv::resize INTER_LINEAR for one-channel float64 images, as OpenCV 5's IPP HAL computes it. */
+export declare function resizeLinear64(src: Float64Array, sw: number, sh: number, dw: number, dh: number): Float64Array;
+/** cv::resize INTER_AREA of a one-channel float32 image. Enlarging uses OpenCV's area-weighted bilinear. */
+export declare function resizeArea32(src: Float32Array, sw: number, sh: number, dw: number, dh: number): Float32Array;
+/** cv::resize INTER_AREA of an 8-bit image with `cn` channels, when shrinking. */
+export declare function resizeArea8(src: Uint8Array, sw: number, sh: number, cn: number, dw: number, dh: number): Uint8Array;
+/** cv::resize INTER_NEAREST with `cn` interleaved channels. */
+export declare function resizeNearest<T extends Uint8Array | Float32Array>(src: T, sw: number, sh: number, cn: number, dw: number, dh: number): T;
+/** Kernel size OpenCV derives from sigma for float images. */
+export declare const gaussianSize: (sigma: number) => number;
+/** cv::GaussianBlur of a one-channel float32 image (separable, REFLECT_101, FMA accumulation). */
+export declare function gaussianBlur32(src: Float32Array, w: number, h: number, size: number, sigma: number): Float32Array;
+/** 3x3 rectangle or cross structuring element. */
+export declare enum MorphShape {
+    Rect = "rect",
+    Cross = "cross"
+}
+/**
+ * cv::erode / cv::dilate of an interleaved 8-bit image with a 3x3 element, `iterations` times.
+ * Pixels outside the image are ignored, as with OpenCV's default border value.
+ */
+export declare function morph8(src: Uint8Array, w: number, h: number, cn: number, shape: MorphShape, erode: boolean, iterations: number): Uint8Array;
+/** NumPy's float32 pairwise summation (np.add.reduce over a contiguous array). */
+export declare function pairwiseSum32(a: ArrayLike<number>, start?: number, n?: number): number;
+/** cv::GaussianBlur of a one-channel 8-bit image with sigma 0 (OpenCV's bit-exact fixed point). */
+export declare function gaussianBlur8(src: Uint8Array, w: number, h: number, size: number): Uint8Array;