@xprite/pixelate 0.0.0-stage → 0.1.0

package/dist/grid-description-length.js

@@ -0,0 +1,697 @@
+/**
+ * Description length of an image under a grid hypothesis: the cost of the cuts and the cell
+ * colours plus the residual left by rebuilding the image from them. Grids from every proposer
+ * compete on this one scale, so a finer grid has to buy its extra cells with a smaller residual,
+ * and a free mesh its cut positions. Every grid is measured on the content inside the image's
+ * frame (outer lines of one colour, such as padding), where each grid's cuts are clipped.
+ *
+ * - The residual is Gaussian at the rebuild's own mean squared error. The variance floor stands
+ *   for the few pixels a correct grid still misplaces (rounded cuts, compression), so that a
+ *   residual near zero is not worth any number of extra cells.
+ * - A cell colour is coded against its left or upper neighbour at the residual's precision: a cell
+ *   that repeats its neighbour costs almost nothing, while a cell of new colour costs about the
+ *   precision it is given to.
+ * - Each cell costs CELL_PARAMETERS parameters of half the log of the samples (as in BIC). A
+ *   lattice costs four cut parameters; a lattice snapped to edges adds each cut's offset within
+ *   its radius; a free mesh pays MESH_CUT_PARAMETERS per cut.
+ *
+ * The cells structure the image; how a cell's colour spreads over its pixels is the rendering,
+ * and the cheapest of several renderings stands:
+ *
+ * - Nearest: every pixel takes its cell's mean.
+ * - Bilinear: pixels blend the colours of the neighbouring cell centres, which are fitted to the
+ *   pixels.
+ * - Planar: a cell may carry a colour slope, which pays for itself only where it removes enough
+ *   residual (shaded or gradient-filled cells).
+ * - Blurred: cell colours seen through a Gaussian of one of BLUR_WIDTHS, as a soft or resampled
+ *   upscale renders them. The colours are the cell means sharpened by one deconvolution step.
+ */
+const STRIDE = 4;
+const CHANNELS = 3;
+const ALPHA_CHANNEL = 3;
+const ALPHA_SCALE = 255;
+export const RESIDUAL_FLOOR = 16;
+/** Pixels a description covers; larger images are described on evenly spread whole rows. */
+const PIXEL_BUDGET = 1 << 19;
+/** Pixels a cell's centre sits from its first pixel, as a share of the cell. */
+const HALF = 0.5;
+/** Cut parameters of a uniform lattice: a pitch and a phase per axis. */
+const LATTICE_CUT_PARAMETERS = 4;
+/**
+ * Parameters a free mesh cut costs. Native pixel grids are regular, so a mesh must explain
+ * markedly more than a lattice of the same edges; a drifting or warped grid does.
+ */
+const MESH_CUT_PARAMETERS = 80;
+/**
+ * Weight on the snapped cut offsets. Snapping chooses each offset from the image, so the offsets
+ * cost more than a free choice within the radius would: mild snaps that only chase content edges
+ * must not pay for themselves.
+ */
+const SNAP_OFFSET_WEIGHT = 400;
+/**
+ * Parameters per described cell. Below one, so that a better residual at the true count can win
+ * over a coarser covering lattice on painterly scale noise, while invented fine grids still lose.
+ */
+const CELL_PARAMETERS = 0.55;
+/** Parameters of a planar cell's slope: one per channel and axis. */
+const SLOPE_PARAMETERS = CHANNELS * 2;
+/** Gaussian widths, in pixels, of the blurred renderings. */
+const BLUR_WIDTHS = [1.2, 2];
+/**
+ * The widest blur a cell may carry, as a share of its pitch: the rendering mixes only the
+ * neighbouring cells, so a wider blur would reach cells it does not model.
+ */
+const MAX_BLUR_SHARE = 0.5;
+/** Deconvolution steps from the cell means to the blurred colours. */
+const DECONVOLUTION_STEPS = 1;
+/** Neighbours on each side a blurred pixel mixes. */
+const BLUR_REACH = 1;
+const BLUR_TAPS = 2 * BLUR_REACH + 1;
+/** Coefficients of the Abramowitz-Stegun approximation of erf (7.1.26). */
+const ERF_P = 0.3275911;
+const ERF_A = [0.254829592, -0.284496736, 1.421413741, -1.453152027, 1.061405429];
+const MIN_PLANAR_PIXELS = 3;
+const MIN_PLANAR_AREA = 4;
+const SINGULAR = 1e-9;
+export var CutModel;
+(function (CutModel) {
+    /** One lattice per axis. */
+    CutModel["Lattice"] = "lattice";
+    /** A lattice whose cuts each moved within a radius. */
+    CutModel["Snapped"] = "snapped";
+    /** Every cut placed on its own. */
+    CutModel["Free"] = "free";
+})(CutModel || (CutModel = {}));
+/** Premultiplied RGBA of a pixel as one number, so every clear pixel reads the same. */
+function packedColour(data, o) {
+    const alpha = data[o + ALPHA_CHANNEL];
+    if (!alpha)
+        return 0;
+    let packed = alpha;
+    for (let c = 0; c < CHANNELS; c++)
+        packed = packed * (ALPHA_SCALE + 1) + data[o + c];
+    return packed;
+}
+/**
+ * The image less its frame: the outer rows and columns of the corner's colour. A frame describes
+ * the same for every grid, so it says nothing about which one fits; only what it encloses does.
+ */
+function contentOf(image) {
+    const { width, height, data, offset } = image;
+    const frame = packedColour(data, offset ? offset(0, 0) : 0);
+    const framed = offset
+        ? (x, y) => packedColour(data, offset(x, y)) === frame
+        : (x, y) => packedColour(data, (y * width + x) * STRIDE) === frame;
+    const column = (x) => {
+        for (let y = 0; y < height; y++)
+            if (!framed(x, y))
+                return false;
+        return true;
+    };
+    const row = (y) => {
+        for (let x = 0; x < width; x++)
+            if (!framed(x, y))
+                return false;
+        return true;
+    };
+    let left = 0;
+    while (left < width && column(left))
+        left++;
+    if (left === width)
+        return { content: image, left: 0, top: 0 };
+    let right = width, top = 0, bottom = height;
+    while (column(right - 1))
+        right--;
+    while (row(top))
+        top++;
+    while (row(bottom - 1))
+        bottom--;
+    if (right - left === width && bottom - top === height)
+        return { content: image, left, top };
+    const content = {
+        width: right - left,
+        height: bottom - top,
+        data,
+        offset: offset
+            ? (x, y) => offset(x + left, y + top)
+            : (x, y) => ((y + top) * width + x + left) * STRIDE,
+    };
+    return { content, left, top };
+}
+/** Cuts of the input seen inside the content: those within it, plus its two ends. */
+function contentCuts(cuts, start, length) {
+    const inside = [0];
+    for (const cut of cuts)
+        if (cut - start > 0 && cut - start < length)
+            inside.push(cut - start);
+    inside.push(length);
+    return inside;
+}
+/** The lines a description covers: every one, or as many evenly spread as PIXEL_BUDGET allows. */
+export function describedLines(lines, length) {
+    const count = Math.min(lines, Math.max(1, Math.floor(PIXEL_BUDGET / length)));
+    return Int32Array.from({ length: count }, (_, i) => Math.floor(((i + HALF) * lines) / count));
+}
+export function describeImage(input) {
+    const { content: image, left, top } = contentOf(input);
+    const { width, height, data, offset } = image;
+    const lines = describedLines(height, width);
+    const count = lines.length;
+    const values = new Float64Array(count * width * CHANNELS);
+    for (let r = 0; r < count; r++)
+        for (let x = 0; x < width; x++) {
+            const o = offset ? offset(x, lines[r]) : (lines[r] * width + x) * STRIDE, v = (r * width + x) * CHANNELS;
+            const alpha = data[o + ALPHA_CHANNEL] / ALPHA_SCALE;
+            for (let c = 0; c < CHANNELS; c++)
+                values[v + c] = data[o + c] * alpha;
+        }
+    const samples = count * width * CHANNELS;
+    return { content: image, left, top, lines, values, samples, parameter: Math.log(samples) / 2 };
+}
+function cellOf(cuts, length) {
+    const index = new Int32Array(length);
+    for (let cell = 0; cell + 1 < cuts.length; cell++)
+        index.fill(cell, cuts[cell], cuts[cell + 1]);
+    return index;
+}
+function centres(cuts, length) {
+    const points = Array.from({ length: cuts.length - 1 }, (_, i) => (cuts[i] + cuts[i + 1]) * HALF - HALF);
+    const lower = new Int32Array(length), weight = new Float64Array(length);
+    let a = 0;
+    for (let p = 0; p < length; p++) {
+        while (a + 1 < points.length && points[a + 1] <= p)
+            a++;
+        lower[p] = a;
+        weight[p] =
+            a + 1 < points.length
+                ? Math.min(1, Math.max(0, (p - points[a]) / (points[a + 1] - points[a])))
+                : 0;
+    }
+    return { lower, weight };
+}
+/**
+ * Cost of the described cells' colours, each coded against the nearer of its left and upper
+ * neighbours (or against black when it has neither).
+ */
+function colourCost(colours, described, across, down, variance) {
+    let cost = 0;
+    const distance = (a, b) => {
+        let sum = 0;
+        for (let c = 0; c < CHANNELS; c++)
+            sum += (colours[a * CHANNELS + c] - colours[b * CHANNELS + c]) ** 2;
+        return sum;
+    };
+    for (let j = 0; j < down; j++)
+        for (let i = 0; i < across; i++) {
+            const cell = j * across + i;
+            if (!described[cell])
+                continue;
+            let step = Infinity;
+            if (i > 0 && described[cell - 1])
+                step = distance(cell, cell - 1);
+            if (j > 0 && described[cell - across])
+                step = Math.min(step, distance(cell, cell - across));
+            if (!Number.isFinite(step)) {
+                step = 0;
+                for (let c = 0; c < CHANNELS; c++)
+                    step += colours[cell * CHANNELS + c] ** 2;
+            }
+            cost += (CHANNELS / 2) * Math.log1p(step / (CHANNELS * variance));
+        }
+    return cost;
+}
+function erf(x) {
+    const t = 1 / (1 + ERF_P * Math.abs(x));
+    let polynomial = 0;
+    for (let k = ERF_A.length - 1; k >= 0; k--)
+        polynomial = (polynomial + ERF_A[k]) * t;
+    return Math.sign(x) * (1 - polynomial * Math.exp(-x * x));
+}
+/** Share of a Gaussian at `centre` that falls left of `edge`. */
+const below = (edge, centre, sigma) => HALF * (1 + erf((edge - centre) / (sigma * Math.SQRT2)));
+/** Per pixel, the weights of the cell before, at and after its own under a Gaussian blur. */
+function blurWeights(cuts, cells, sigma) {
+    const length = cells.length, count = cuts.length - 1;
+    const weights = new Float64Array(length * BLUR_TAPS);
+    for (let p = 0; p < length; p++) {
+        const centre = p + HALF;
+        let sum = 0;
+        for (let d = -BLUR_REACH; d <= BLUR_REACH; d++) {
+            const k = cells[p] + d;
+            if (k < 0 || k >= count)
+                continue;
+            const w = below(cuts[k + 1], centre, sigma) - below(cuts[k], centre, sigma);
+            weights[p * BLUR_TAPS + d + BLUR_REACH] = w;
+            sum += w;
+        }
+        if (sum)
+            for (let d = 0; d < BLUR_TAPS; d++)
+                weights[p * BLUR_TAPS + d] /= sum;
+    }
+    return weights;
+}
+function cellMoments(described, cutsX, cutsY) {
+    const { content: image, lines, values } = described;
+    const { width } = image;
+    const across = cutsX.length - 1, down = cutsY.length - 1, cells = across * down;
+    const counts = new Float64Array(cells), means = new Float64Array(cells * CHANNELS), slopes = new Float64Array(cells);
+    let flat = 0, first = 0;
+    for (let j = 0; j < down; j++) {
+        const bottom = Math.trunc(cutsY[j + 1]);
+        let last = first;
+        while (last < lines.length && lines[last] < bottom)
+            last++;
+        for (let i = 0; i < across; i++) {
+            const cell = j * across + i, left = Math.trunc(cutsX[i]), right = Math.trunc(cutsX[i + 1]);
+            let n = 0, sx = 0, sy = 0, sxx = 0, syy = 0, sxy = 0, squares = 0, sr = 0, sg = 0, sb = 0, srx = 0, sgx = 0, sbx = 0, sry = 0, sgy = 0, sby = 0;
+            for (let r = first; r < last; r++) {
+                const ly = lines[r] - cutsY[j], row = r * width * CHANNELS;
+                for (let x = left; x < right; x++) {
+                    const lx = x - cutsX[i], at = row + x * CHANNELS, red = values[at], green = values[at + 1], blue = values[at + 2];
+                    n++;
+                    sx += lx;
+                    sy += ly;
+                    sxx += lx * lx;
+                    syy += ly * ly;
+                    sxy += lx * ly;
+                    sr += red;
+                    srx += red * lx;
+                    sry += red * ly;
+                    squares += red * red;
+                    sg += green;
+                    sgx += green * lx;
+                    sgy += green * ly;
+                    squares += green * green;
+                    sb += blue;
+                    sbx += blue * lx;
+                    sby += blue * ly;
+                    squares += blue * blue;
+                }
+            }
+            if (!n)
+                continue;
+            counts[cell] = n;
+            const mxx = sxx - (sx * sx) / n, myy = syy - (sy * sy) / n, mxy = sxy - (sx * sy) / n, det = mxx * myy - mxy * mxy;
+            let residual = squares, removed = 0;
+            means[cell * CHANNELS] = sr / n;
+            residual -= (sr * sr) / n;
+            const grx = srx - (sx * sr) / n, gry = sry - (sy * sr) / n;
+            if (det > SINGULAR && n >= MIN_PLANAR_AREA)
+                removed += (myy * grx * grx - 2 * mxy * grx * gry + mxx * gry * gry) / det;
+            else if (mxx > SINGULAR && n >= MIN_PLANAR_PIXELS)
+                removed += (grx * grx) / mxx;
+            else if (myy > SINGULAR && n >= MIN_PLANAR_PIXELS)
+                removed += (gry * gry) / myy;
+            means[cell * CHANNELS + 1] = sg / n;
+            residual -= (sg * sg) / n;
+            const ggx = sgx - (sx * sg) / n, ggy = sgy - (sy * sg) / n;
+            if (det > SINGULAR && n >= MIN_PLANAR_AREA)
+                removed += (myy * ggx * ggx - 2 * mxy * ggx * ggy + mxx * ggy * ggy) / det;
+            else if (mxx > SINGULAR && n >= MIN_PLANAR_PIXELS)
+                removed += (ggx * ggx) / mxx;
+            else if (myy > SINGULAR && n >= MIN_PLANAR_PIXELS)
+                removed += (ggy * ggy) / myy;
+            means[cell * CHANNELS + 2] = sb / n;
+            residual -= (sb * sb) / n;
+            const gbx = sbx - (sx * sb) / n, gby = sby - (sy * sb) / n;
+            if (det > SINGULAR && n >= MIN_PLANAR_AREA)
+                removed += (myy * gbx * gbx - 2 * mxy * gbx * gby + mxx * gby * gby) / det;
+            else if (mxx > SINGULAR && n >= MIN_PLANAR_PIXELS)
+                removed += (gbx * gbx) / mxx;
+            else if (myy > SINGULAR && n >= MIN_PLANAR_PIXELS)
+                removed += (gby * gby) / myy;
+            residual = Math.max(0, residual);
+            flat += residual;
+            slopes[cell] = Math.max(0, Math.min(removed, residual));
+        }
+        first = last;
+    }
+    return { counts, means, flat, slopes };
+}
+/** Gram matrix of one axis's blend weights over the given positions: diagonal and next entry. */
+function blendGram(axis, count, positions) {
+    const diagonal = new Float64Array(count).fill(SINGULAR), next = new Float64Array(count);
+    for (let k = 0; k < positions.length; k++) {
+        const i = axis.lower[positions[k]], t = axis.weight[positions[k]];
+        diagonal[i] += (1 - t) * (1 - t);
+        if (i + 1 < count) {
+            diagonal[i + 1] += t * t;
+            next[i] += (1 - t) * t;
+        }
+    }
+    return { diagonal, next };
+}
+/** Solves a symmetric tridiagonal system in place, on every `stride`th value from `base`. */
+function solveTridiagonal({ diagonal, next }, values, base, stride, scratch) {
+    const count = diagonal.length;
+    let pivot = diagonal[0];
+    scratch[0] = next[0] / pivot;
+    values[base] /= pivot;
+    for (let k = 1; k < count; k++) {
+        pivot = diagonal[k] - next[k - 1] * scratch[k - 1];
+        scratch[k] = next[k] / pivot;
+        values[base + k * stride] =
+            (values[base + k * stride] - next[k - 1] * values[base + (k - 1) * stride]) / pivot;
+    }
+    for (let k = count - 2; k >= 0; k--)
+        values[base + k * stride] -= scratch[k] * values[base + (k + 1) * stride];
+}
+/**
+ * Residual of the bilinear blend of the cell centres, with the centre colours that rebuild the
+ * described pixels best. The blend is separable, so the least-squares colours solve one
+ * tridiagonal system along each axis.
+ */
+function bilinearError(described, cutsX, cutsY, bound) {
+    const { content: image, lines, values, samples, parameter } = described;
+    const useBound = bound !== undefined &&
+        Number.isFinite(bound.best) &&
+        Number.isFinite(bound.structure) &&
+        Number.isFinite(samples) &&
+        samples > 0 &&
+        Number.isFinite(parameter);
+    const { width, height } = image;
+    const across = cutsX.length - 1, down = cutsY.length - 1;
+    const cx = centres(cutsX, width), cy = centres(cutsY, height);
+    const finiteWeights = cx.weight.every(Number.isFinite) && cy.weight.every(Number.isFinite);
+    const colours = new Float64Array(across * down * CHANNELS);
+    const lefts = new Int32Array(width), rights = new Int32Array(width);
+    for (let x = 0; x < width; x++) {
+        lefts[x] = cx.lower[x] * CHANNELS;
+        rights[x] = Math.min(across - 1, cx.lower[x] + 1) * CHANNELS;
+    }
+    for (let r = 0; r < lines.length; r++) {
+        const y = lines[r], top = cy.lower[y] * across * CHANNELS, bottom = Math.min(down - 1, cy.lower[y] + 1) * across * CHANNELS, ty = cy.weight[y];
+        for (let x = 0; x < width; x++) {
+            const v = (r * width + x) * CHANNELS;
+            // Finite interpolation weights add only zeros here; the other additions keep their order.
+            if (finiteWeights && values[v] === 0 && values[v + 1] === 0 && values[v + 2] === 0)
+                continue;
+            const tx = cx.weight[x], o0 = top + lefts[x], o1 = top + rights[x], o2 = bottom + lefts[x], o3 = bottom + rights[x], s0 = (1 - tx) * (1 - ty), s1 = tx * (1 - ty), s2 = (1 - tx) * ty, s3 = tx * ty;
+            colours[o0] += s0 * values[v];
+            colours[o0 + 1] += s0 * values[v + 1];
+            colours[o0 + 2] += s0 * values[v + 2];
+            colours[o1] += s1 * values[v];
+            colours[o1 + 1] += s1 * values[v + 1];
+            colours[o1 + 2] += s1 * values[v + 2];
+            colours[o2] += s2 * values[v];
+            colours[o2 + 1] += s2 * values[v + 1];
+            colours[o2 + 2] += s2 * values[v + 2];
+            colours[o3] += s3 * values[v];
+            colours[o3 + 1] += s3 * values[v + 1];
+            colours[o3 + 2] += s3 * values[v + 2];
+        }
+    }
+    const columns = Int32Array.from({ length: width }, (_, x) => x);
+    const gramX = blendGram(cx, across, columns), gramY = blendGram(cy, down, lines);
+    const scratch = new Float64Array(Math.max(across, down));
+    for (let j = 0; j < down; j++)
+        for (let c = 0; c < CHANNELS; c++)
+            solveTridiagonal(gramX, colours, j * across * CHANNELS + c, CHANNELS, scratch);
+    for (let i = 0; i < across; i++)
+        for (let c = 0; c < CHANNELS; c++)
+            solveTridiagonal(gramY, colours, i * CHANNELS + c, across * CHANNELS, scratch);
+    const fittedBound = useBound && finiteWeights && colours.every(Number.isFinite);
+    let error = 0;
+    for (let r = 0; r < lines.length; r++) {
+        const y = lines[r], top = cy.lower[y] * across * CHANNELS, bottom = Math.min(down - 1, cy.lower[y] + 1) * across * CHANNELS, ty = cy.weight[y];
+        for (let x = 0; x < width; x++) {
+            const tx = cx.weight[x], o0 = top + lefts[x], o1 = top + rights[x], o2 = bottom + lefts[x], o3 = bottom + rights[x], s0 = (1 - tx) * (1 - ty), s1 = tx * (1 - ty), s2 = (1 - tx) * ty, s3 = tx * ty, v = (r * width + x) * CHANNELS;
+            const rebuilt0 = s0 * colours[o0] + s1 * colours[o1] + s2 * colours[o2] + s3 * colours[o3];
+            const difference0 = values[v] - rebuilt0;
+            error += difference0 * difference0;
+            const rebuilt1 = s0 * colours[o0 + 1] + s1 * colours[o1 + 1] + s2 * colours[o2 + 1] + s3 * colours[o3 + 1];
+            const difference1 = values[v + 1] - rebuilt1;
+            error += difference1 * difference1;
+            const rebuilt2 = s0 * colours[o0 + 2] + s1 * colours[o1 + 2] + s2 * colours[o2 + 2] + s3 * colours[o3 + 2];
+            const difference2 = values[v + 2] - rebuilt2;
+            error += difference2 * difference2;
+        }
+        if (fittedBound) {
+            // Remaining squared residuals and the colour code cannot reduce this rendering length.
+            const lower = (samples / 2) * Math.log(error / samples + RESIDUAL_FLOOR) + 0 + bound.structure + 0;
+            const slack = LENGTH_BOUND_ROUNDING_ULPS * Number.EPSILON * (Math.abs(lower) + Math.abs(bound.best) + 1);
+            if (Number.isFinite(lower) && Number.isFinite(slack) && lower - bound.best > slack)
+                return { error, colours, discarded: true };
+        }
+    }
+    return { error, colours, discarded: false };
+}
+/** Numerical slack keeps a bound evaluation away from libm and comparison rounding edges. */
+const LENGTH_BOUND_ROUNDING_ULPS = 64;
+/** Residual of the cell colours seen through a Gaussian of `sigma`, after deconvolution. */
+function blurredError(described, moments, cutsX, cutsY, columns, rows, sigma, bound) {
+    const { lines, values: pixels, samples, parameter } = described;
+    const useBound = bound !== undefined &&
+        Number.isFinite(bound.best) &&
+        Number.isFinite(bound.structure) &&
+        Number.isFinite(samples) &&
+        samples > 0 &&
+        Number.isFinite(parameter);
+    const width = columns.length;
+    const across = cutsX.length - 1, down = cutsY.length - 1;
+    const wx = blurWeights(cutsX, columns, sigma), wy = blurWeights(cutsY, rows, sigma);
+    const colours = new Float64Array(moments.means);
+    const correction = new Float64Array(colours.length);
+    const finiteHorizontalWeights = wx.every(Number.isFinite);
+    const zeroBlend = new Uint8Array(across);
+    // One cell of zeros pads each end of a row's vertical blend.
+    const blend = new Float64Array((across + 2 * BLUR_REACH) * CHANNELS);
+    let error = 0;
+    for (let step = 0; step <= DECONVOLUTION_STEPS; step++) {
+        // Each pass before the last only corrects the colours; the last only measures the residual.
+        const last = step === DECONVOLUTION_STEPS;
+        error = 0;
+        if (!last)
+            correction.fill(0);
+        for (let r = 0; r < lines.length; r++) {
+            const y = lines[r], j = rows[y];
+            blend.fill(0);
+            for (let d = -BLUR_REACH; d <= BLUR_REACH; d++) {
+                const w = wy[y * BLUR_TAPS + d + BLUR_REACH], jj = j + d;
+                if (!w || jj < 0 || jj >= down)
+                    continue;
+                for (let k = 0; k < across * CHANNELS; k++)
+                    blend[BLUR_REACH * CHANNELS + k] += w * colours[jj * across * CHANNELS + k];
+            }
+            // Mark exact zero blends only when multiplying them cannot introduce a nonfinite value.
+            if (finiteHorizontalWeights)
+                for (let i = 0; i < across; i++) {
+                    const b = i * CHANNELS;
+                    zeroBlend[i] = Number(blend[b] === 0 &&
+                        blend[b + 1] === 0 &&
+                        blend[b + 2] === 0 &&
+                        blend[b + CHANNELS] === 0 &&
+                        blend[b + CHANNELS + 1] === 0 &&
+                        blend[b + CHANNELS + 2] === 0 &&
+                        blend[b + 2 * CHANNELS] === 0 &&
+                        blend[b + 2 * CHANNELS + 1] === 0 &&
+                        blend[b + 2 * CHANNELS + 2] === 0);
+                }
+            if (last) {
+                for (let x = 0; x < width; x++) {
+                    const i = columns[x], v = (r * width + x) * CHANNELS, t = x * BLUR_TAPS, b = i * CHANNELS, w0 = wx[t], w1 = wx[t + 1], w2 = wx[t + 2];
+                    if (zeroBlend[i] && pixels[v] === 0 && pixels[v + 1] === 0 && pixels[v + 2] === 0)
+                        continue;
+                    let red = 0;
+                    red += w0 * blend[b];
+                    red += w1 * blend[b + CHANNELS];
+                    red += w2 * blend[b + 2 * CHANNELS];
+                    const dr = pixels[v] - red;
+                    let green = 0;
+                    green += w0 * blend[b + 1];
+                    green += w1 * blend[b + CHANNELS + 1];
+                    green += w2 * blend[b + 2 * CHANNELS + 1];
+                    const dg = pixels[v + 1] - green;
+                    let blue = 0;
+                    blue += w0 * blend[b + 2];
+                    blue += w1 * blend[b + CHANNELS + 2];
+                    blue += w2 * blend[b + 2 * CHANNELS + 2];
+                    const db = pixels[v + 2] - blue;
+                    error += dr * dr;
+                    error += dg * dg;
+                    error += db * db;
+                }
+            }
+            else {
+                for (let x = 0; x < width; x++) {
+                    const i = columns[x], v = (r * width + x) * CHANNELS, t = x * BLUR_TAPS, b = i * CHANNELS, w0 = wx[t], w1 = wx[t + 1], w2 = wx[t + 2];
+                    if (zeroBlend[i] && pixels[v] === 0 && pixels[v + 1] === 0 && pixels[v + 2] === 0)
+                        continue;
+                    let red = 0;
+                    red += w0 * blend[b];
+                    red += w1 * blend[b + CHANNELS];
+                    red += w2 * blend[b + 2 * CHANNELS];
+                    const dr = pixels[v] - red;
+                    let green = 0;
+                    green += w0 * blend[b + 1];
+                    green += w1 * blend[b + CHANNELS + 1];
+                    green += w2 * blend[b + 2 * CHANNELS + 1];
+                    const dg = pixels[v + 1] - green;
+                    let blue = 0;
+                    blue += w0 * blend[b + 2];
+                    blue += w1 * blend[b + CHANNELS + 2];
+                    blue += w2 * blend[b + 2 * CHANNELS + 2];
+                    const db = pixels[v + 2] - blue;
+                    const cell = (j * across + i) * CHANNELS;
+                    correction[cell] += dr;
+                    correction[cell + 1] += dg;
+                    correction[cell + 2] += db;
+                }
+            }
+            if (last && useBound) {
+                // Remaining squared residuals and the color code can only increase this length.
+                // Keep the additions in the same order as renderingLength's length() below.
+                const lower = (samples / 2) * Math.log(error / samples + RESIDUAL_FLOOR) +
+                    0 +
+                    bound.structure +
+                    parameter;
+                const slack = LENGTH_BOUND_ROUNDING_ULPS *
+                    Number.EPSILON *
+                    (Math.abs(lower) + Math.abs(bound.best) + 1);
+                if (Number.isFinite(lower) && Number.isFinite(slack) && lower - bound.best > slack)
+                    return { error, colours, discarded: true };
+            }
+        }
+        if (last)
+            break;
+        for (let cell = 0; cell < across * down; cell++) {
+            const n = moments.counts[cell];
+            if (n)
+                for (let c = 0; c < CHANNELS; c++)
+                    colours[cell * CHANNELS + c] += correction[cell * CHANNELS + c] / n;
+        }
+    }
+    return { error, colours, discarded: false };
+}
+/** Description length per sample of the cell colours and residual, cheapest rendering first. */
+function renderingLength(described, cutsX, cutsY) {
+    const { content: image, samples, parameter } = described;
+    const across = cutsX.length - 1, down = cutsY.length - 1;
+    const columns = cellOf(cutsX, image.width), rows = cellOf(cutsY, image.height);
+    const moments = cellMoments(described, cutsX, cutsY);
+    let cells = 0;
+    for (const count of moments.counts)
+        if (count)
+            cells++;
+    const structure = cells * parameter * CELL_PARAMETERS;
+    const length = (error, colours, extra = 0) => {
+        const variance = error / samples + RESIDUAL_FLOOR;
+        return ((samples / 2) * Math.log(variance) +
+            colourCost(colours, moments.counts, across, down, variance) +
+            structure +
+            extra);
+    };
+    let best = length(moments.flat, moments.means);
+    // A slope pays for itself where the residual it removes, at the flat cells' precision, beats
+    // its parameters; every cell also says whether it carries one.
+    const precision = 2 * (moments.flat / samples + RESIDUAL_FLOOR);
+    const slopeCost = SLOPE_PARAMETERS * parameter;
+    let planarError = moments.flat, planarCost = cells * Math.LN2;
+    for (const removed of moments.slopes)
+        if (removed / precision > slopeCost) {
+            planarError -= removed;
+            planarCost += slopeCost;
+        }
+    best = Math.min(best, length(planarError, moments.means, planarCost));
+    const bilinear = bilinearError(described, cutsX, cutsY, { best, structure });
+    if (!bilinear.discarded)
+        best = Math.min(best, length(bilinear.error, bilinear.colours));
+    const pitch = Math.min(image.width / across, image.height / down);
+    for (const sigma of BLUR_WIDTHS) {
+        if (sigma > MAX_BLUR_SHARE * pitch)
+            break;
+        const blurred = blurredError(described, moments, cutsX, cutsY, columns, rows, sigma, {
+            best,
+            structure,
+        });
+        if (!blurred.discarded)
+            best = Math.min(best, length(blurred.error, blurred.colours, parameter));
+    }
+    return best / samples;
+}
+/** Description length per sample of the cuts alone. */
+function cutLength(described, cuts) {
+    const across = cuts.cutsX.length - 1, down = cuts.cutsY.length - 1;
+    const lattice = LATTICE_CUT_PARAMETERS * described.parameter;
+    let cost = lattice;
+    switch (cuts.model) {
+        case CutModel.Lattice:
+            break;
+        case CutModel.Snapped:
+            cost +=
+                SNAP_OFFSET_WEIGHT *
+                    ((across - 1) * Math.log(2 * (cuts.radiusX ?? 0) + 1) +
+                        (down - 1) * Math.log(2 * (cuts.radiusY ?? 0) + 1));
+            break;
+        case CutModel.Free:
+            cost = MESH_CUT_PARAMETERS * described.parameter * (across + down - 2);
+            break;
+    }
+    return cost / described.samples;
+}
+/** Rendering costs shared by the cut models and phase readings of one description. */
+const renderingLengths = new WeakMap();
+/** Description length per sample (pixel channel of a described row), in nats. */
+export function descriptionLength(described, cuts) {
+    const { content, left, top } = described;
+    const cutsX = contentCuts(cuts.cutsX, left, content.width), cutsY = contentCuts(cuts.cutsY, top, content.height);
+    // The rendering depends on the clipped cuts; the cut model's cost is added separately.
+    // Arbitration revisits these cuts for snapped readings, twins and octave evidence.
+    const key = `${cutsX.join(",")}|${cutsY.join(",")}`;
+    let lengths = renderingLengths.get(described);
+    if (!lengths) {
+        lengths = new Map();
+        renderingLengths.set(described, lengths);
+    }
+    let rendering = lengths.get(key);
+    if (rendering === undefined) {
+        rendering = renderingLength(described, cutsX, cutsY);
+        lengths.set(key, rendering);
+    }
+    return rendering + cutLength(described, cuts);
+}
+/**
+ * Nats of a pixel's colour coded against a neighbour `step` (squared premultiplied distance) away,
+ * beyond the residual floor every sample pays, as `pixelLength` codes every pixel.
+ */
+export function colourStepCost(step) {
+    return (CHANNELS / 2) * Math.log1p(step / (CHANNELS * RESIDUAL_FLOOR));
+}
+/**
+ * Description length per sample of the image as it is: one cell per pixel, which rebuilds it
+ * exactly, each pixel coded against its left or upper neighbour.
+ */
+export function pixelLength(described) {
+    const { content: image, lines, values, samples, parameter } = described;
+    const { width } = image;
+    let colours = 0;
+    for (let r = 0; r < lines.length; r++) {
+        const above = r > 0 && lines[r - 1] === lines[r] - 1;
+        for (let x = 0; x < width; x++) {
+            const v = (r * width + x) * CHANNELS;
+            let step = Infinity;
+            const distance = (o) => {
+                let sum = 0;
+                for (let c = 0; c < CHANNELS; c++)
+                    sum += (values[v + c] - values[o + c]) ** 2;
+                return sum;
+            };
+            if (x > 0)
+                step = distance(v - CHANNELS);
+            if (above)
+                step = Math.min(step, distance(v - width * CHANNELS));
+            if (!Number.isFinite(step)) {
+                step = 0;
+                for (let c = 0; c < CHANNELS; c++)
+                    step += values[v + c] ** 2;
+            }
+            colours += colourStepCost(step);
+        }
+    }
+    const cells = lines.length * width;
+    return (((samples / 2) * Math.log(RESIDUAL_FLOOR) +
+        colours +
+        cells * parameter * CELL_PARAMETERS +
+        LATTICE_CUT_PARAMETERS * parameter) /
+        samples);
+}