@funpixel/tools 0.0.0-stage → 0.1.1

package/dist/fidelity/match.js

@@ -0,0 +1,675 @@
+export const N = 384;
+const r1 = (v) => Math.round(v * 10) / 10;
+export function rgbOf(img) {
+    const data = new Uint8Array(img.width * img.height * 3);
+    for (let i = 0, j = 0; i < img.data.length; i += 4, j += 3) {
+        data[j] = img.data[i];
+        data[j + 1] = img.data[i + 1];
+        data[j + 2] = img.data[i + 2];
+    }
+    return { width: img.width, height: img.height, data };
+}
+export function renderOf(img) {
+    const n = img.width * img.height;
+    const rgb = new Uint8Array(n * 3), mask = new Uint8Array(n);
+    for (let p = 0; p < n; p++) {
+        const on = img.data[p * 4 + 3] > 20;
+        mask[p] = on ? 1 : 0;
+        for (let c = 0; c < 3; c++)
+            rgb[p * 3 + c] = on ? img.data[p * 4 + c] : 255;
+    }
+    return { rgb: { width: img.width, height: img.height, data: rgb }, mask: { width: img.width, height: img.height, data: mask } };
+}
+const count = (m) => { let s = 0; const d = m.data; for (let i = 0; i < d.length; i++)
+    s += d[i]; return s; };
+function morph(m, k, grow) {
+    const { width: w, height: h } = m;
+    const r = k >> 1;
+    const pass = (src, horizontal) => {
+        const out = new Uint8Array(src.length);
+        for (let y = 0; y < h; y++)
+            for (let x = 0; x < w; x++) {
+                let v = grow ? 0 : 1;
+                for (let d = -r; d <= r; d++) {
+                    const xx = horizontal ? x + d : x, yy = horizontal ? y : y + d;
+                    if (xx < 0 || yy < 0 || xx >= w || yy >= h)
+                        continue;
+                    const s = src[yy * w + xx];
+                    if (grow ? s : !s) {
+                        v = grow ? 1 : 0;
+                        break;
+                    }
+                }
+                out[y * w + x] = v;
+            }
+        return out;
+    };
+    return { width: w, height: h, data: pass(pass(m.data, true), false) };
+}
+export const dilate = (m, k) => morph(m, k, true);
+export const erode = (m, k) => morph(m, k, false);
+function components(m) {
+    const { width: w, height: h } = m;
+    const labels = new Int32Array(w * h);
+    const areas = [0];
+    const stack = [];
+    for (let p = 0; p < w * h; p++) {
+        if (!m.data[p] || labels[p])
+            continue;
+        const id = areas.length;
+        let area = 0;
+        labels[p] = id;
+        stack.push(p);
+        while (stack.length) {
+            const q = stack.pop();
+            area++;
+            const x = q % w, y = (q - x) / w;
+            for (let dy = -1; dy <= 1; dy++)
+                for (let dx = -1; dx <= 1; dx++) {
+                    const xx = x + dx, yy = y + dy;
+                    if (xx < 0 || yy < 0 || xx >= w || yy >= h)
+                        continue;
+                    const o = yy * w + xx;
+                    if (m.data[o] && !labels[o]) {
+                        labels[o] = id;
+                        stack.push(o);
+                    }
+                }
+        }
+        areas.push(area);
+    }
+    return { labels, areas };
+}
+function fillHoles(m) {
+    const { width: w, height: h } = m;
+    const outside = new Uint8Array(w * h);
+    const stack = [];
+    const seed = (p) => { if (!m.data[p] && !outside[p]) {
+        outside[p] = 1;
+        stack.push(p);
+    } };
+    for (let x = 0; x < w; x++) {
+        seed(x);
+        seed((h - 1) * w + x);
+    }
+    for (let y = 0; y < h; y++) {
+        seed(y * w);
+        seed(y * w + w - 1);
+    }
+    while (stack.length) {
+        const q = stack.pop();
+        const x = q % w, y = (q - x) / w;
+        if (x > 0)
+            seed(q - 1);
+        if (x < w - 1)
+            seed(q + 1);
+        if (y > 0)
+            seed(q - w);
+        if (y < h - 1)
+            seed(q + w);
+    }
+    const data = new Uint8Array(w * h);
+    for (let p = 0; p < w * h; p++)
+        data[p] = outside[p] ? 0 : 1;
+    return { width: w, height: h, data };
+}
+function median(values) {
+    const s = [...values].sort((a, b) => a - b);
+    const mid = s.length >> 1;
+    return s.length % 2 ? s[mid] : (s[mid - 1] + s[mid]) / 2;
+}
+export function refMask(img) {
+    const { width: w, height: h, data } = img;
+    const k = Math.max(4, Math.floor(Math.min(h, w) / 40));
+    const corner = [[], [], []];
+    for (const [x0, y0] of [[0, 0], [w - k, 0], [0, h - k], [w - k, h - k]]) {
+        for (let y = y0; y < y0 + k; y++)
+            for (let x = x0; x < x0 + k; x++)
+                for (let c = 0; c < 3; c++)
+                    corner[c].push(data[(y * w + x) * 3 + c]);
+    }
+    const bg = corner.map(median);
+    let m = { width: w, height: h, data: new Uint8Array(w * h) };
+    for (let p = 0; p < w * h; p++) {
+        const d = Math.hypot(data[p * 3] - bg[0], data[p * 3 + 1] - bg[1], data[p * 3 + 2] - bg[2]);
+        m.data[p] = d > 28 ? 1 : 0;
+    }
+    m = dilate(erode(m, 3), 3);
+    m = erode(dilate(m, 9), 9);
+    const { labels, areas } = components(m);
+    if (areas.length > 2) {
+        const big = Math.max(...areas.slice(1));
+        const keep = areas.map((a, i) => i > 0 && a > 0.02 * big);
+        for (let p = 0; p < labels.length; p++)
+            m.data[p] = keep[labels[p]] ? 1 : 0;
+    }
+    return fillHoles(m);
+}
+function weights(src, dst) {
+    const scale = src / dst;
+    const out = [];
+    for (let d = 0; d < dst; d++) {
+        if (scale >= 1) {
+            const a = d * scale, b = Math.min(src, (d + 1) * scale);
+            const ws = [];
+            for (let s = Math.floor(a); s < Math.ceil(b); s++) {
+                const cover = Math.min(b, s + 1) - Math.max(a, s);
+                if (cover > 1e-9)
+                    ws.push([s, cover / (b - a)]);
+            }
+            out.push(ws);
+        }
+        else {
+            const x = Math.min(src - 1, Math.max(0, (d + 0.5) * scale - 0.5));
+            const i = Math.floor(x), f = x - i;
+            out.push(f > 0 && i + 1 < src ? [[i, 1 - f], [i + 1, f]] : [[i, 1]]);
+        }
+    }
+    return out;
+}
+export function resizeArea(data, w, h, c, dw, dh) {
+    const wx = weights(w, dw), wy = weights(h, dh);
+    const mid = new Float32Array(dw * h * c);
+    for (let y = 0; y < h; y++)
+        for (let x = 0; x < dw; x++)
+            for (const [s, wt] of wx[x]) {
+                for (let k = 0; k < c; k++)
+                    mid[(y * dw + x) * c + k] += wt * data[(y * w + s) * c + k];
+            }
+    const out = new Uint8Array(dw * dh * c);
+    for (let y = 0; y < dh; y++)
+        for (let x = 0; x < dw; x++)
+            for (let k = 0; k < c; k++) {
+                let v = 0;
+                for (const [s, wt] of wy[y])
+                    v += wt * mid[(s * dw + x) * c + k];
+                out[(y * dw + x) * c + k] = Math.min(255, Math.max(0, Math.round(v)));
+            }
+    return out;
+}
+function resizeNearest(m, dw, dh) {
+    const data = new Uint8Array(dw * dh);
+    const sx = m.width / dw, sy = m.height / dh;
+    for (let y = 0; y < dh; y++) {
+        const yy = Math.min(m.height - 1, Math.floor(y * sy));
+        for (let x = 0; x < dw; x++)
+            data[y * dw + x] = m.data[yy * m.width + Math.min(m.width - 1, Math.floor(x * sx))];
+    }
+    return { width: dw, height: dh, data };
+}
+function bbox(m) {
+    const { width: w, height: h, data } = m;
+    let x0 = w, y0 = h, x1 = -1, y1 = -1;
+    for (let y = 0; y < h; y++) {
+        const row = y * w;
+        let first = -1, last = -1;
+        for (let x = 0; x < w; x++)
+            if (data[row + x]) {
+                if (first < 0)
+                    first = x;
+                last = x;
+            }
+        if (first < 0)
+            continue;
+        if (first < x0)
+            x0 = first;
+        if (last > x1)
+            x1 = last;
+        if (y < y0)
+            y0 = y;
+        y1 = y;
+    }
+    return x1 < 0 ? null : [x0, y0, x1 + 1, y1 + 1];
+}
+function fit(m, n) {
+    const b = bbox(m);
+    if (!b)
+        return null;
+    const [x0, y0, x1, y1] = b;
+    const cw = x1 - x0, ch = y1 - y0, s = n / Math.max(cw, ch);
+    const dw = Math.max(1, Math.round(cw * s)), dh = Math.max(1, Math.round(ch * s));
+    return { x0, y0, cw, ch, dw, dh, ox: (n - dw) >> 1, oy: (n - dh) >> 1 };
+}
+function crop(data, w, c, x0, y0, cw, ch) {
+    const out = new Uint8Array(cw * ch * c);
+    for (let y = 0; y < ch; y++)
+        out.set(data.subarray(((y0 + y) * w + x0) * c, ((y0 + y) * w + x0 + cw) * c), y * cw * c);
+    return out;
+}
+export function normMask(m, n = N) {
+    const f = fit(m, n);
+    if (!f)
+        return null;
+    const small = resizeNearest({ width: f.cw, height: f.ch, data: crop(m.data, m.width, 1, f.x0, f.y0, f.cw, f.ch) }, f.dw, f.dh);
+    const data = new Uint8Array(n * n);
+    for (let y = 0; y < f.dh; y++)
+        data.set(small.data.subarray(y * f.dw, (y + 1) * f.dw), (f.oy + y) * n + f.ox);
+    return { width: n, height: n, data };
+}
+export function norm(img, m, n = N) {
+    const f = fit(m, n);
+    if (!f)
+        return null;
+    const pic = resizeArea(crop(img.data, img.width, 3, f.x0, f.y0, f.cw, f.ch), f.cw, f.ch, 3, f.dw, f.dh);
+    const mask = normMask(m, n);
+    const data = new Uint8Array(n * n * 3).fill(255);
+    for (let y = 0; y < f.dh; y++)
+        data.set(pic.subarray(y * f.dw * 3, (y + 1) * f.dw * 3), ((f.oy + y) * n + f.ox) * 3);
+    return { img: { width: n, height: n, data }, mask };
+}
+function rotation(w, h, deg) {
+    const a = Math.cos((deg * Math.PI) / 180), b = Math.sin((deg * Math.PI) / 180), cx = w / 2, cy = h / 2;
+    return (x, y) => [a * (x - cx) - b * (y - cy) + cx, b * (x - cx) + a * (y - cy) + cy];
+}
+export function rotateMask(m, deg, box = bbox(m)) {
+    if (!deg)
+        return m;
+    const { width: w, height: h } = m;
+    const a = Math.cos((deg * Math.PI) / 180), b = Math.sin((deg * Math.PI) / 180), cx = w / 2, cy = h / 2;
+    const data = new Uint8Array(w * h);
+    if (!box)
+        return { width: w, height: h, data };
+    let lx = w, ly = h, hx = 0, hy = 0;
+    for (const [px, py] of [[box[0], box[1]], [box[2], box[1]], [box[0], box[3]], [box[2], box[3]]]) {
+        const dx = a * (px - cx) + b * (py - cy) + cx, dy = -b * (px - cx) + a * (py - cy) + cy;
+        lx = Math.min(lx, dx);
+        hx = Math.max(hx, dx);
+        ly = Math.min(ly, dy);
+        hy = Math.max(hy, dy);
+    }
+    const x0 = Math.max(0, Math.floor(lx) - 2), x1 = Math.min(w, Math.ceil(hx) + 2);
+    const y0 = Math.max(0, Math.floor(ly) - 2), y1 = Math.min(h, Math.ceil(hy) + 2);
+    for (let y = y0; y < y1; y++) {
+        let sx = a * (x0 - cx) - b * (y - cy) + cx, sy = b * (x0 - cx) + a * (y - cy) + cy;
+        for (let x = x0; x < x1; x++, sx += a, sy += b) {
+            const xi = Math.round(sx), yi = Math.round(sy);
+            if (xi >= 0 && yi >= 0 && xi < w && yi < h)
+                data[y * w + x] = m.data[yi * w + xi];
+        }
+    }
+    return { width: w, height: h, data };
+}
+export function rotateRgb(img, deg) {
+    if (!deg)
+        return img;
+    const { width: w, height: h } = img;
+    const src = rotation(w, h, deg);
+    const data = new Uint8Array(w * h * 3);
+    const at = (x, y, c) => (x < 0 || y < 0 || x >= w || y >= h ? 255 : img.data[(y * w + x) * 3 + c]);
+    for (let y = 0; y < h; y++)
+        for (let x = 0; x < w; x++) {
+            const [sx, sy] = src(x, y);
+            const x0 = Math.floor(sx), y0 = Math.floor(sy), fx = sx - x0, fy = sy - y0;
+            for (let c = 0; c < 3; c++) {
+                const v = (at(x0, y0, c) * (1 - fx) + at(x0 + 1, y0, c) * fx) * (1 - fy) + (at(x0, y0 + 1, c) * (1 - fx) + at(x0 + 1, y0 + 1, c) * fx) * fy;
+                data[(y * w + x) * 3 + c] = Math.round(v);
+            }
+        }
+    return { width: w, height: h, data };
+}
+function iou(a, b) {
+    let and = 0, or = 0;
+    for (let p = 0; p < a.data.length; p++) {
+        and += a.data[p] & b.data[p];
+        or += a.data[p] | b.data[p];
+    }
+    return and / Math.max(1, or);
+}
+const srgb = (v) => { const c = v / 255; return c <= 0.04045 ? c / 12.92 : ((c + 0.055) / 1.055) ** 2.4; };
+const SRGB = Array.from({ length: 256 }, (_, i) => srgb(i));
+const fLab = (t) => (t > 0.008856 ? Math.cbrt(t) : 7.787 * t + 16 / 116);
+export function lab(r, g, b) {
+    const R = SRGB[r], G = SRGB[g], B = SRGB[b];
+    const X = (0.412453 * R + 0.35758 * G + 0.180423 * B) / 0.950456;
+    const Y = 0.212671 * R + 0.71516 * G + 0.072169 * B;
+    const Z = (0.019334 * R + 0.119193 * G + 0.950227 * B) / 1.088754;
+    const L = Y > 0.008856 ? 116 * Math.cbrt(Y) - 16 : 903.3 * Y;
+    const a = 500 * (fLab(X) - fLab(Y)), bb = 200 * (fLab(Y) - fLab(Z));
+    const q = (v) => Math.min(255, Math.max(0, Math.round(v)));
+    return [(q((L * 255) / 100) * 100) / 255, q(a + 128) - 128, q(bb + 128) - 128];
+}
+function rng(seed) {
+    let s = seed >>> 0;
+    return () => {
+        s = (s + 0x6d2b79f5) >>> 0;
+        let t = s;
+        t = Math.imul(t ^ (t >>> 15), t | 1);
+        t ^= t + Math.imul(t ^ (t >>> 7), t | 61);
+        return ((t ^ (t >>> 14)) >>> 0) / 4294967296;
+    };
+}
+export function kmeans(points, k, seed = 1) {
+    const n = points.length / 3;
+    if (n === 0)
+        return { centers: [], weights: [] };
+    const kk = Math.min(k, n);
+    const random = rng(seed);
+    const d2 = (i, c) => {
+        const x = points[i * 3] - c[0], y = points[i * 3 + 1] - c[1], z = points[i * 3 + 2] - c[2];
+        return x * x + y * y + z * z;
+    };
+    let best = null;
+    for (let attempt = 0; attempt < 3; attempt++) {
+        const centers = [];
+        const first = Math.floor(random() * n);
+        centers.push([points[first * 3], points[first * 3 + 1], points[first * 3 + 2]]);
+        const dist = new Float64Array(n);
+        let sum = 0;
+        for (let i = 0; i < n; i++) {
+            dist[i] = d2(i, centers[0]);
+            sum += dist[i];
+        }
+        for (let c = 1; c < kk; c++) {
+            let bestSum = Infinity, bestIdx = 0;
+            for (let trial = 0; trial < 3; trial++) {
+                let target = random() * sum, idx = 0;
+                for (; idx < n - 1; idx++) {
+                    target -= dist[idx];
+                    if (target <= 0)
+                        break;
+                }
+                const cand = [points[idx * 3], points[idx * 3 + 1], points[idx * 3 + 2]];
+                let s = 0;
+                for (let i = 0; i < n; i++)
+                    s += Math.min(dist[i], d2(i, cand));
+                if (s < bestSum) {
+                    bestSum = s;
+                    bestIdx = idx;
+                }
+            }
+            const pick = [points[bestIdx * 3], points[bestIdx * 3 + 1], points[bestIdx * 3 + 2]];
+            centers.push(pick);
+            sum = 0;
+            for (let i = 0; i < n; i++) {
+                dist[i] = Math.min(dist[i], d2(i, pick));
+                sum += dist[i];
+            }
+        }
+        const labels = new Int32Array(n);
+        let compact = 0;
+        for (let iter = 0; iter < 30; iter++) {
+            compact = 0;
+            for (let i = 0; i < n; i++) {
+                let bi = 0, bd = Infinity;
+                for (let c = 0; c < kk; c++) {
+                    const d = d2(i, centers[c]);
+                    if (d < bd) {
+                        bd = d;
+                        bi = c;
+                    }
+                }
+                labels[i] = bi;
+                compact += bd;
+            }
+            const acc = Array.from({ length: kk }, () => [0, 0, 0, 0]);
+            for (let i = 0; i < n; i++) {
+                const a = acc[labels[i]];
+                a[0] += points[i * 3];
+                a[1] += points[i * 3 + 1];
+                a[2] += points[i * 3 + 2];
+                a[3]++;
+            }
+            let shift = 0;
+            for (let c = 0; c < kk; c++) {
+                const a = acc[c];
+                if (!a[3])
+                    continue;
+                const next = [a[0] / a[3], a[1] / a[3], a[2] / a[3]];
+                shift = Math.max(shift, (next[0] - centers[c][0]) ** 2 + (next[1] - centers[c][1]) ** 2 + (next[2] - centers[c][2]) ** 2);
+                centers[c] = next;
+            }
+            if (shift <= 0.25)
+                break;
+        }
+        if (!best || compact < best.compact)
+            best = { centers: centers.map((c) => [...c]), labels: labels.slice(), compact };
+    }
+    const counts = new Array(kk).fill(0);
+    for (const l of best.labels)
+        counts[l]++;
+    return { centers: best.centers, weights: counts.map((c) => c / n) };
+}
+export function palette(img, m, k = 6, seed = 1) {
+    const pts = [];
+    for (let p = 0; p < m.data.length; p++)
+        if (m.data[p])
+            pts.push(...lab(img.data[p * 3], img.data[p * 3 + 1], img.data[p * 3 + 2]));
+    return kmeans(Float32Array.from(pts), k, seed);
+}
+export function paletteDistance(a, b) {
+    if (!a.centers.length || !b.centers.length)
+        return Infinity;
+    const near = (c, set) => Math.min(...set.map((d) => Math.hypot(c[0] - d[0], c[1] - d[1], c[2] - d[2])));
+    const one = a.centers.reduce((s, c, i) => s + a.weights[i] * near(c, b.centers), 0);
+    const two = b.centers.reduce((s, c, i) => s + b.weights[i] * near(c, a.centers), 0);
+    return (one + two) / 2;
+}
+export function grey(img) {
+    const out = new Uint8Array(img.width * img.height);
+    for (let p = 0; p < out.length; p++)
+        out[p] = Math.round(0.299 * img.data[p * 3] + 0.587 * img.data[p * 3 + 1] + 0.114 * img.data[p * 3 + 2]);
+    return out;
+}
+function blur3(g, w, h) {
+    const refl = (i, n) => (i < 0 ? -i : i >= n ? 2 * n - 2 - i : i);
+    const mid = new Float32Array(w * h), out = new Uint8Array(w * h);
+    for (let y = 0; y < h; y++)
+        for (let x = 0; x < w; x++)
+            mid[y * w + x] = 0.25 * g[y * w + refl(x - 1, w)] + 0.5 * g[y * w + x] + 0.25 * g[y * w + refl(x + 1, w)];
+    for (let y = 0; y < h; y++)
+        for (let x = 0; x < w; x++)
+            out[y * w + x] = Math.round(0.25 * mid[refl(y - 1, h) * w + x] + 0.5 * mid[y * w + x] + 0.25 * mid[refl(y + 1, h) * w + x]);
+    return out;
+}
+export function canny(g, w, h, low = 60, high = 150) {
+    const at = (x, y) => g[Math.min(h - 1, Math.max(0, y)) * w + Math.min(w - 1, Math.max(0, x))];
+    const dx = new Int32Array(w * h), dy = new Int32Array(w * h), mag = new Int32Array(w * h);
+    for (let y = 0; y < h; y++)
+        for (let x = 0; x < w; x++) {
+            const gx = at(x + 1, y - 1) + 2 * at(x + 1, y) + at(x + 1, y + 1) - at(x - 1, y - 1) - 2 * at(x - 1, y) - at(x - 1, y + 1);
+            const gy = at(x - 1, y + 1) + 2 * at(x, y + 1) + at(x + 1, y + 1) - at(x - 1, y - 1) - 2 * at(x, y - 1) - at(x + 1, y - 1);
+            const p = y * w + x;
+            dx[p] = gx;
+            dy[p] = gy;
+            mag[p] = Math.abs(gx) + Math.abs(gy);
+        }
+    const m = (x, y) => (x < 0 || y < 0 || x >= w || y >= h ? 0 : mag[y * w + x]);
+    const state = new Uint8Array(w * h);
+    const stack = [];
+    for (let y = 0; y < h; y++)
+        for (let x = 0; x < w; x++) {
+            const p = y * w + x, v = mag[p];
+            if (v <= low)
+                continue;
+            const ax = Math.abs(dx[p]), ay = Math.abs(dy[p]);
+            const tg22 = ax * 0.4142135623730951;
+            let peak;
+            if (ay < tg22)
+                peak = v > m(x - 1, y) && v >= m(x + 1, y);
+            else if (ay > tg22 + 2 * ax)
+                peak = v > m(x, y - 1) && v >= m(x, y + 1);
+            else {
+                const s = (dx[p] ^ dy[p]) < 0 ? -1 : 1;
+                peak = v > m(x - s, y - 1) && v > m(x + s, y + 1);
+            }
+            if (!peak)
+                continue;
+            if (v > high) {
+                state[p] = 2;
+                stack.push(p);
+            }
+            else
+                state[p] = 1;
+        }
+    while (stack.length) {
+        const p = stack.pop();
+        const x = p % w, y = (p - x) / w;
+        for (let yy = y - 1; yy <= y + 1; yy++)
+            for (let xx = x - 1; xx <= x + 1; xx++) {
+                if (xx < 0 || yy < 0 || xx >= w || yy >= h)
+                    continue;
+                const q = yy * w + xx;
+                if (state[q] === 1) {
+                    state[q] = 2;
+                    stack.push(q);
+                }
+            }
+    }
+    const out = new Uint8Array(w * h);
+    for (let p = 0; p < out.length; p++)
+        out[p] = state[p] === 2 ? 1 : 0;
+    return out;
+}
+function near(e, w, h, r = 3) {
+    const out = new Uint8Array(w * h);
+    const offs = [];
+    for (let dy = -r; dy <= r; dy++)
+        for (let dx = -r; dx <= r; dx++)
+            if (dx * dx + dy * dy <= r * r)
+                offs.push([dx, dy]);
+    for (let y = 0; y < h; y++)
+        for (let x = 0; x < w; x++) {
+            if (!e[y * w + x])
+                continue;
+            for (const [dx, dy] of offs) {
+                const xx = x + dx, yy = y + dy;
+                if (xx >= 0 && yy >= 0 && xx < w && yy < h)
+                    out[yy * w + xx] = 1;
+            }
+        }
+    return out;
+}
+export function prepareRef(ref, rm, seed = 1) {
+    const n = ref.width, g = grey(ref);
+    const edges = canny(blur3(g, n, n), n, n);
+    return {
+        img: ref, mask: rm, grown: dilate(rm, 5), palette: palette(ref, rm, 6, seed),
+        small: resizeArea(g, n, n, 1, 32, 32), edges, near: near(edges, n, n),
+    };
+}
+export function score(ref, rm, rnd, dm, seed = 1) {
+    return scoreAgainst(prepareRef(ref, rm, seed), rnd, dm, seed);
+}
+export function scoreAgainst(p, rnd, dm, seed = 1) {
+    const rm = p.mask;
+    const raw = iou(rm, dm);
+    const sil = iou(p.grown, dilate(dm, 5));
+    const de = paletteDistance(p.palette, palette(rnd, dm, 6, seed + 1));
+    const pal = Number.isFinite(de) ? Math.max(0, 1 - de / 35) : 0;
+    const n = rnd.width;
+    const g2 = grey(rnd);
+    const s1 = p.small, s2 = resizeArea(g2, n, n, 1, 32, 32);
+    const union = { width: n, height: n, data: rm.data.map((v, i) => v | dm.data[i]) };
+    const mm = resizeNearest(union, 32, 32);
+    const a = [], b = [];
+    for (let q = 0; q < 1024; q++)
+        if (mm.data[q]) {
+            a.push(s1[q]);
+            b.push(s2[q]);
+        }
+    const mean = (v) => v.reduce((s, x) => s + x, 0) / Math.max(1, v.length);
+    const ma = mean(a), mb = mean(b);
+    let num = 0, va = 0, vb = 0;
+    for (let i = 0; i < a.length; i++) {
+        num += (a[i] - ma) * (b[i] - mb);
+        va += (a[i] - ma) ** 2;
+        vb += (b[i] - mb) ** 2;
+    }
+    const st = Math.max(0, num / (Math.sqrt(va * vb) + 1e-6));
+    const e1 = p.edges, e2 = canny(blur3(g2, n, n), n, n);
+    const n1 = p.near, n2 = near(e2, n, n);
+    let c1 = 0, c2 = 0, hit1 = 0, hit2 = 0;
+    for (let q = 0; q < e1.length; q++) {
+        if (e2[q]) {
+            c2++;
+            hit2 += n1[q];
+        }
+        if (e1[q]) {
+            c1++;
+            hit1 += n2[q];
+        }
+    }
+    const prec = c2 ? hit2 / c2 : 0, rec = c1 ? hit1 / c1 : 0;
+    const ln = (2 * prec * rec) / (prec + rec + 1e-6);
+    const tot = 0.35 * sil + 0.3 * pal + 0.2 * st + 0.15 * ln;
+    return {
+        total: r1(100 * tot), silhouette: r1(100 * sil), silhouette_raw: r1(100 * raw), palette: r1(100 * pal),
+        palette_dE: Number.isFinite(de) ? r1(de) : -1, structure: r1(100 * st), lines: r1(100 * ln),
+    };
+}
+export function nudges(quarter = false) {
+    const around = (c) => Array.from({ length: 13 }, (_, i) => c - 12 + 2 * i);
+    return [...around(0), ...around(180), ...(quarter ? [...around(90), ...around(270)] : [])];
+}
+export function bestMatch(reference, renders, opts = {}) {
+    const rm0 = refMask(reference);
+    const refn = norm(reference, rm0);
+    if (!refn)
+        return null;
+    const prep = prepareRef(refn.img, refn.mask);
+    let best = null;
+    for (const r of renders) {
+        let local = null;
+        const box = bbox(r.mask);
+        for (const ang of nudges(opts.quarterTurns)) {
+            const mr = rotateMask(r.mask, ang, box);
+            if (count(mr) < 50)
+                continue;
+            const dmn = normMask(mr);
+            if (!dmn)
+                continue;
+            const v = iou(refn.mask, dmn);
+            if (!local || v > local.iou)
+                local = { iou: v, ang };
+        }
+        if (!local)
+            continue;
+        const rn = norm(rotateRgb(r.rgb, local.ang), rotateMask(r.mask, local.ang));
+        const s = scoreAgainst(prep, rn.img, rn.mask);
+        const vs = { ...s, view: r.name, nudge_deg: local.ang };
+        if (!best || vs.total > best.score.total)
+            best = { score: vs, ref: refn.img, refMask: refn.mask, render: rn.img, renderMask: rn.mask, source: rm0 };
+    }
+    if (best)
+        best.score = { ...best.score, ...steadyPalette(prep, best.render, best.renderMask, best.score) };
+    return best;
+}
+export const PALETTE_SEEDS = 5;
+function steadyPalette(p, rnd, dm, s) {
+    const ds = [];
+    for (let i = 0; i < PALETTE_SEEDS; i++) {
+        const ref = i === 0 ? p.palette : palette(p.img, p.mask, 6, 1 + 2 * i);
+        ds.push(paletteDistance(ref, palette(rnd, dm, 6, 2 + 2 * i)));
+    }
+    const de = median(ds);
+    if (!Number.isFinite(de))
+        return { palette: s.palette, palette_dE: s.palette_dE, total: s.total };
+    const pal = Math.max(0, 1 - de / 35);
+    const others = 0.35 * (s.silhouette / 100) + 0.2 * (s.structure / 100) + 0.15 * (s.lines / 100);
+    return { palette: r1(100 * pal), palette_dE: r1(de), total: r1(100 * (others + 0.3 * pal)) };
+}
+export function sheet(m) {
+    const n = m.ref.width, w = n * 3;
+    const data = new Uint8Array(w * n * 4);
+    const put = (x, y, rgb, o) => {
+        const p = (y * w + x) * 4;
+        data[p] = rgb[o];
+        data[p + 1] = rgb[o + 1];
+        data[p + 2] = rgb[o + 2];
+        data[p + 3] = 255;
+    };
+    const edge = dilate({ width: n, height: n, data: m.renderMask.data.map((v, i) => {
+            if (!v)
+                return 0;
+            const x = i % n, y = (i - x) / n;
+            return x === 0 || y === 0 || x === n - 1 || y === n - 1 || !m.renderMask.data[i - 1] || !m.renderMask.data[i + 1] || !m.renderMask.data[i - n] || !m.renderMask.data[i + n] ? 1 : 0;
+        }) }, 2);
+    for (let y = 0; y < n; y++)
+        for (let x = 0; x < n; x++) {
+            const o = (y * n + x) * 3;
+            put(x, y, m.ref.data, o);
+            put(n + x, y, m.render.data, o);
+            put(2 * n + x, y, edge.data[y * n + x] ? [224, 51, 60] : m.ref.data, edge.data[y * n + x] ? 0 : o);
+        }
+    return { width: w, height: n, data };
+}