@driftengine/capture 4.0.0

package/dist/gaussians/projectGradient.js

@@ -0,0 +1,213 @@
+/**
+ * The screen-space gradients of one Gaussian carried back to its own parameters.
+ *
+ * **`project.ts` run backwards**, term for term: the perspective Jacobian, the covariance it acts
+ * on, the rotation and scale that covariance is built from, and the quaternion behind the rotation.
+ * Nothing here knows about pixels or compositing — it takes what `gradients.ts` gathered over a
+ * Gaussian's own pixels and answers what that means for where it stands and how it is shaped.
+ */
+import { rotationFromQuaternion } from './project.js';
+/**
+ * The screen-space gradients carried back to a Gaussian's position, scale and rotation, by the
+ * same chain the projection is built from.
+ */
+export function screenToParameters(set, at, camera, dMeanX, dMeanY, dA, dB, dD, out) {
+    const [fx, fy] = camera.intrinsics;
+    const m = camera.worldToCamera;
+    const view = [0, 0, 0];
+    for (let r = 0; r < 3; r += 1) {
+        view[r] =
+            m[r * 4] * set.positions[at * 3] +
+                m[r * 4 + 1] * set.positions[at * 3 + 1] +
+                m[r * 4 + 2] * set.positions[at * 3 + 2] +
+                m[r * 4 + 3];
+    }
+    const z = view[2];
+    const invZ = 1 / z;
+    const invZ2 = invZ * invZ;
+    const invZ3 = invZ2 * invZ;
+    /* The world covariance in the camera's frame, which the Jacobian acts on. */
+    const rotation = new Float64Array(9);
+    rotationFromQuaternion(set.rotations, at, rotation);
+    const scaled = new Float64Array(9);
+    for (let r = 0; r < 3; r += 1) {
+        for (let c = 0; c < 3; c += 1) {
+            scaled[r * 3 + c] = rotation[r * 3 + c] * set.scales[at * 3 + c];
+        }
+    }
+    const world = new Float64Array(9);
+    for (let r = 0; r < 3; r += 1) {
+        for (let c = 0; c < 3; c += 1) {
+            let sum = 0;
+            for (let k = 0; k < 3; k += 1)
+                sum += scaled[r * 3 + k] * scaled[c * 3 + k];
+            world[r * 3 + c] = sum;
+        }
+    }
+    const viewRotation = new Float64Array(9);
+    for (let r = 0; r < 3; r += 1) {
+        for (let c = 0; c < 3; c += 1)
+            viewRotation[r * 3 + c] = m[r * 4 + c];
+    }
+    const inCamera = new Float64Array(9);
+    for (let r = 0; r < 3; r += 1) {
+        for (let c = 0; c < 3; c += 1) {
+            let sum = 0;
+            for (let k = 0; k < 3; k += 1) {
+                for (let j = 0; j < 3; j += 1) {
+                    sum +=
+                        viewRotation[r * 3 + k] *
+                            world[k * 3 + j] *
+                            viewRotation[c * 3 + j];
+                }
+            }
+            inCamera[r * 3 + c] = sum;
+        }
+    }
+    const j = [
+        [fx * invZ, 0, -fx * view[0] * invZ2],
+        [0, fy * invZ, -fy * view[1] * invZ2],
+    ];
+    /* dΣ'/dΣcam, then the same into the world and the Gaussian's own axes. */
+    const dScreen = [
+        [dA, dB / 2],
+        [dB / 2, dD],
+    ];
+    const dCamera = new Float64Array(9);
+    for (let k = 0; k < 3; k += 1) {
+        for (let l = 0; l < 3; l += 1) {
+            let sum = 0;
+            for (let r = 0; r < 2; r += 1) {
+                for (let c = 0; c < 2; c += 1) {
+                    sum +=
+                        dScreen[r][c] *
+                            j[r][k] *
+                            j[c][l];
+                }
+            }
+            dCamera[k * 3 + l] = sum;
+        }
+    }
+    const dWorld = new Float64Array(9);
+    for (let k = 0; k < 3; k += 1) {
+        for (let l = 0; l < 3; l += 1) {
+            let sum = 0;
+            for (let r = 0; r < 3; r += 1) {
+                for (let c = 0; c < 3; c += 1) {
+                    sum +=
+                        viewRotation[r * 3 + k] *
+                            dCamera[r * 3 + c] *
+                            viewRotation[c * 3 + l];
+                }
+            }
+            dWorld[k * 3 + l] = sum;
+        }
+    }
+    /* Σ = M · Mᵀ with M = R · diag(s), so dΣ/dM = 2 · dΣ · M for a symmetric dΣ. */
+    const dM = new Float64Array(9);
+    for (let r = 0; r < 3; r += 1) {
+        for (let c = 0; c < 3; c += 1) {
+            let sum = 0;
+            for (let k = 0; k < 3; k += 1)
+                sum += dWorld[r * 3 + k] * scaled[k * 3 + c];
+            dM[r * 3 + c] = 2 * sum;
+        }
+    }
+    for (let c = 0; c < 3; c += 1) {
+        let sum = 0;
+        for (let r = 0; r < 3; r += 1)
+            sum += dM[r * 3 + c] * rotation[r * 3 + c];
+        out.scales[at * 3 + c] = out.scales[at * 3 + c] + sum;
+    }
+    /* And through the rotation to the quaternion, by its own derivatives. */
+    const dRotation = new Float64Array(9);
+    for (let r = 0; r < 3; r += 1) {
+        for (let c = 0; c < 3; c += 1) {
+            dRotation[r * 3 + c] = dM[r * 3 + c] * set.scales[at * 3 + c];
+        }
+    }
+    quaternionGradient(set.rotations, at, dRotation, out.rotations);
+    /*
+     * The position moves the mean and, through the Jacobian, the covariance. The second term is what
+     * a gradient written from the mean alone misses — it is small at the centre of the frame and is
+     * not small at its edges.
+     */
+    const dView = [
+        dMeanX * fx * invZ,
+        dMeanY * fy * invZ,
+        -dMeanX * fx * view[0] * invZ2 - dMeanY * fy * view[1] * invZ2,
+    ];
+    /* dJ/dview, the only part of Σ' that the position enters. */
+    const dJ = [
+        [
+            [0, 0, -fx * invZ2],
+            [0, 0, 0],
+        ],
+        [
+            [0, 0, 0],
+            [0, 0, -fy * invZ2],
+        ],
+        [
+            [-fx * invZ2, 0, 2 * fx * view[0] * invZ3],
+            [0, -fy * invZ2, 2 * fy * view[1] * invZ3],
+        ],
+    ];
+    for (let k = 0; k < 3; k += 1) {
+        for (let l = 0; l < 3; l += 1) {
+            for (let axis = 0; axis < 3; axis += 1) {
+                let sum = 0;
+                for (let r = 0; r < 2; r += 1) {
+                    for (let c = 0; c < 2; c += 1) {
+                        const term = dJ[axis][r][k] *
+                            j[c][l] +
+                            j[r][k] *
+                                dJ[axis][c][l];
+                        sum += dScreen[r][c] * term * inCamera[k * 3 + l];
+                    }
+                }
+                dView[axis] = dView[axis] + sum;
+            }
+        }
+    }
+    for (let axis = 0; axis < 3; axis += 1) {
+        let sum = 0;
+        for (let r = 0; r < 3; r += 1)
+            sum += dView[r] * m[r * 4 + axis];
+        out.positions[at * 3 + axis] = out.positions[at * 3 + axis] + sum;
+    }
+}
+/** A rotation matrix's gradient carried back to the quaternion it came from. */
+function quaternionGradient(q, at, dRotation, out) {
+    const x = q[at * 4];
+    const y = q[at * 4 + 1];
+    const z = q[at * 4 + 2];
+    const w = q[at * 4 + 3];
+    const length = Math.sqrt(x * x + y * y + z * z + w * w) || 1;
+    const nx = x / length;
+    const ny = y / length;
+    const nz = z / length;
+    const nw = w / length;
+    /* dR/d(normalised quaternion), the nine entries against each of the four. */
+    const d = [
+        [0, 2 * ny, 2 * nz, 2 * ny, -4 * nx, -2 * nw, 2 * nz, 2 * nw, -4 * nx],
+        [-4 * ny, 2 * nx, 2 * nw, 2 * nx, 0, 2 * nz, -2 * nw, 2 * nz, -4 * ny],
+        [-4 * nz, -2 * nw, 2 * nx, 2 * nw, -4 * nz, 2 * ny, 2 * nx, 2 * ny, 0],
+        [0, -2 * nz, 2 * ny, 2 * nz, 0, -2 * nx, -2 * ny, 2 * nx, 0],
+    ];
+    /* Through the normalisation: the part of a change that lengthens the quaternion does nothing. */
+    const raw = [0, 0, 0, 0];
+    for (let p = 0; p < 4; p += 1) {
+        let sum = 0;
+        for (let i = 0; i < 9; i += 1)
+            sum += d[p][i] * dRotation[i];
+        raw[p] = sum;
+    }
+    const unit = [nx, ny, nz, nw];
+    let along = 0;
+    for (let p = 0; p < 4; p += 1)
+        along += raw[p] * unit[p];
+    for (let p = 0; p < 4; p += 1) {
+        out[at * 4 + p] =
+            out[at * 4 + p] + (raw[p] - along * unit[p]) / length;
+    }
+}

package/dist/gaussians/rasterise.d.ts

@@ -0,0 +1,13 @@
+import { type GaussianSet, type RasterCamera } from './project.ts';
+/**
+ * A frame this rasteriser writes: **single precision where it stands in for a render target, double
+ * where the caller is differentiating through it.** The fitting loop accumulates its loss in double
+ * and a frame quantised to single is a floor under every difference taken through one — measured at
+ * about a part in five hundred of the slope, against a part in ten million when the frame is double.
+ */
+export type Frame = Float32Array | Float64Array;
+/**
+ * `set` through `camera` into `out`, four floats a pixel: linear colour, premultiplied as it
+ * composites, and the alpha the cloud covered the pixel with.
+ */
+export declare function rasteriseGaussians(set: GaussianSet, camera: RasterCamera, out: Frame): void;

package/dist/gaussians/rasterise.js

@@ -0,0 +1,65 @@
+/**
+ * A cloud of Gaussians drawn on the CPU: `project.ts`'s ellipses, composited nearest first.
+ *
+ * **It exists to be differentiated**, which is what separates it from the shader that draws splats
+ * in a game. A reference rasteriser is how the gradients in `gradients.ts` are checked — a central
+ * difference of this against the analytic answer — and how a fitted cloud is compared with the
+ * frames it was fitted to. It is thousands of times slower than the shader, and per-frame rules
+ * about allocation do not reach it.
+ */
+import { exactExp } from '@driftengine/core';
+import { cameraCentre, sh1Basis, splatColour, viewDirection } from './harmonics.js';
+import { visibleGaussians, } from './project.js';
+/** Below this the Gaussian contributes nothing worth compositing. */
+const FAINT = 1 / 255 / 4;
+/**
+ * `set` through `camera` into `out`, four floats a pixel: linear colour, premultiplied as it
+ * composites, and the alpha the cloud covered the pixel with.
+ */
+export function rasteriseGaussians(set, camera, out) {
+    const { width, height } = camera;
+    out.fill(0);
+    const transmittance = new Float64Array(width * height).fill(1);
+    const { order, projected } = visibleGaussians(set, camera);
+    /* A Gaussian's colour is a function of where it is seen from, so it is resolved once a frame. */
+    const eye = new Float64Array(3);
+    cameraCentre(camera.worldToCamera, eye);
+    const direction = new Float64Array(3);
+    const basis = new Float64Array(3);
+    const colour = new Float64Array(3);
+    for (const at of order) {
+        const one = projected[at];
+        viewDirection(set.positions, at, eye, direction);
+        sh1Basis(direction, basis);
+        splatColour(set.colors, set.sh1, at, basis, colour);
+        const determinant = one.a * one.d - one.b * one.b;
+        const inverse = [one.d / determinant, -one.b / determinant, one.a / determinant];
+        const left = Math.max(0, Math.floor(one.x - one.radius));
+        const right = Math.min(width - 1, Math.ceil(one.x + one.radius));
+        const top = Math.max(0, Math.floor(one.y - one.radius));
+        const bottom = Math.min(height - 1, Math.ceil(one.y + one.radius));
+        const opacity = set.opacities[at];
+        for (let y = top; y <= bottom; y += 1) {
+            for (let x = left; x <= right; x += 1) {
+                const dx = x + 0.5 - one.x;
+                const dy = y + 0.5 - one.y;
+                const power = -0.5 *
+                    (inverse[0] * dx * dx +
+                        2 * inverse[1] * dx * dy +
+                        inverse[2] * dy * dy);
+                /* The inverse of a positive definite covariance is positive definite, so `power` is at
+                   most zero and the exponential at most one: there is nothing to guard against here. */
+                const alpha = opacity * exactExp(power);
+                if (alpha < FAINT)
+                    continue;
+                const pixel = y * width + x;
+                const share = alpha * transmittance[pixel];
+                for (let c = 0; c < 3; c += 1) {
+                    out[pixel * 4 + c] = out[pixel * 4 + c] + share * colour[c];
+                }
+                out[pixel * 4 + 3] = out[pixel * 4 + 3] + share;
+                transmittance[pixel] = transmittance[pixel] * (1 - alpha);
+            }
+        }
+    }
+}

package/dist/gaussians/refine.d.ts

@@ -0,0 +1,36 @@
+import { type Family } from './adam.ts';
+/** Below this a Gaussian contributes less than a quarter of one value of an eight-bit channel. */
+export declare const FADED: number;
+export interface RefineOptions {
+    /** The most Gaussians the cloud may hold. */
+    readonly budget: number;
+    /** A Gaussian wider than this is split rather than cloned, in metres. */
+    readonly splitAbove: number;
+    readonly random: () => number;
+}
+/** Everything the plan rewrites, in one place. */
+export interface RefineCloud {
+    count: number;
+    readonly families: readonly Family[];
+    readonly positions: Family;
+    readonly logScales: Family;
+    readonly rotations: Family;
+    readonly opacities: Float64Array;
+    /** How hard the frames have pulled on each Gaussian since the last refinement. */
+    readonly motion: Float64Array;
+    readonly sources: Int32Array;
+    /** Where each of today's Gaussians ended up after a prune, so a split can find its own half. */
+    readonly reverse: Int32Array;
+    readonly fresh: Uint8Array;
+    readonly scratch: Float64Array;
+}
+/**
+ * Prune, then grow, then rewrite every family; answers the new count.
+ *
+ * The cloud's own arrays are rewritten in place through its scratch, so nothing is reallocated and
+ * the caller's view of it stays valid. **The materialised scales and opacities are not**: a slot
+ * that has just been split holds the logarithm it was given and the metres of whatever stood there
+ * before, so the caller materialises again before drawing. The fit does that at the top of every
+ * step, which is why this does not do it twice.
+ */
+export declare function refineCloud(cloud: RefineCloud, options: RefineOptions): number;

package/dist/gaussians/refine.js

@@ -0,0 +1,136 @@
+/**
+ * Where the cloud grows and where it is thrown away: densification and pruning, as one plan.
+ *
+ * **A fit that only moves the Gaussians it started with cannot see detail its seeds did not.** The
+ * seeds come from a sparse reconstruction — a few hundred corners — and a room has more surface
+ * than that. So the busiest Gaussians are made into two: a small one is **cloned**, which puts a
+ * second Gaussian where one was not enough, and a large one is **split**, which replaces a blur
+ * covering several surfaces with two that can each take one. The reference implementation decides
+ * between the two by the same test.
+ *
+ * **Busiest by rank rather than by a threshold.** The reference compares an accumulated screen-space
+ * gradient against 0.0002, a number in units of that implementation's own normalisation, and a
+ * number in units nobody can check is a number nobody can tune. This takes a fixed fraction of the
+ * cloud — the most-moved fifth — which says the same thing scale-free: *these are the Gaussians the
+ * frames keep pulling on.* What it gives up is the reference's property that a converged fit stops
+ * growing on its own; the budget is what stops it here, and the pruning below is what keeps the
+ * budget spent on Gaussians that are doing something.
+ *
+ * **Pruning is by opacity, and it happens first.** A Gaussian the fit has faded to nothing is
+ * carrying a slot and contributing less light than a pixel can hold.
+ */
+import { exactExp, exactLog } from '@driftengine/core';
+import { gather } from './adam.js';
+import { rotationFromQuaternion } from './project.js';
+/** Below this a Gaussian contributes less than a quarter of one value of an eight-bit channel. */
+export const FADED = 1 / 255 / 4;
+/** How much of the cloud is made into two, where there is room. */
+const BUSIEST = 0.2;
+/** A split halves what it divides, near enough: the reference's own divisor. */
+const SPLIT_SHRINK = 1.6;
+/**
+ * Prune, then grow, then rewrite every family; answers the new count.
+ *
+ * The cloud's own arrays are rewritten in place through its scratch, so nothing is reallocated and
+ * the caller's view of it stays valid. **The materialised scales and opacities are not**: a slot
+ * that has just been split holds the logarithm it was given and the metres of whatever stood there
+ * before, so the caller materialises again before drawing. The fit does that at the top of every
+ * step, which is why this does not do it twice.
+ */
+export function refineCloud(cloud, options) {
+    const { budget, splitAbove, random } = options;
+    const { sources, fresh, motion } = cloud;
+    /* Everything still worth drawing, in order, with its history intact. */
+    const { reverse } = cloud;
+    let kept = 0;
+    for (let at = 0; at < cloud.count; at += 1) {
+        reverse[at] = -1;
+        if (cloud.opacities[at] < FADED)
+            continue;
+        reverse[at] = kept;
+        sources[kept] = at;
+        fresh[kept] = 0;
+        kept += 1;
+    }
+    /* A prune that emptied the cloud would leave the fit nothing to descend, so it is refused. */
+    if (kept === 0)
+        return cloud.count;
+    /* The busiest fifth of what is left, most-pulled first, as far as the budget allows. */
+    const order = Array.from({ length: kept }, (_, slot) => slot);
+    order.sort((a, b) => {
+        const first = motion[sources[a]];
+        const second = motion[sources[b]];
+        return first === second ? sources[a] - sources[b] : second - first;
+    });
+    /*
+     * At least one where there is room and something is pulling, because a fifth of a small cloud
+     * rounds to none — and a cloud of four that can never grow however long it is fitted is a cliff
+     * nobody would look for.
+     */
+    const room = budget - kept;
+    const share = Math.floor(kept * BUSIEST);
+    const wanted = Math.min(room, share > 1 ? share : 1);
+    let total = kept;
+    const rotation = new Float64Array(9);
+    for (let taken = 0; taken < wanted; taken += 1) {
+        const slot = order[taken];
+        const from = sources[slot];
+        if (!(motion[from] > 0))
+            break;
+        sources[total] = from;
+        fresh[total] = 1;
+        total += 1;
+    }
+    gather(cloud.families, sources, fresh, total, cloud.scratch);
+    /*
+     * Now the two halves are told apart. A clone is left where it was — its own gradient is what
+     * separates it, and its Adam state is empty where its parent's is not. A split is shrunk and both
+     * halves are moved, because two Gaussians of the parent's size in the parent's place are one
+     * blur drawn twice.
+     */
+    for (let slot = kept; slot < total; slot += 1) {
+        const parent = sources[slot];
+        let widest = 0;
+        for (let c = 0; c < 3; c += 1) {
+            const scale = exactExp(cloud.logScales.values[slot * 3 + c]);
+            widest = scale > widest ? scale : widest;
+        }
+        if (widest <= splitAbove)
+            continue;
+        rotationFromQuaternion(cloud.rotations.values, slot, rotation);
+        shrinkAndDisplace(cloud, slot, rotation, random);
+        shrinkAndDisplace(cloud, reverse[parent], rotation, random);
+    }
+    cloud.count = total;
+    motion.fill(0);
+    return total;
+}
+/** One half of a split: smaller than what it came from, and somewhere inside it. */
+function shrinkAndDisplace(cloud, slot, rotation, random) {
+    if (slot < 0)
+        return;
+    displace(cloud, slot, rotation, random);
+    for (let c = 0; c < 3; c += 1) {
+        cloud.logScales.values[slot * 3 + c] =
+            cloud.logScales.values[slot * 3 + c] - exactLog(SPLIT_SHRINK);
+    }
+}
+/** One sample from a Gaussian's own shape, added to where it stands. */
+function displace(cloud, slot, rotation, random) {
+    /*
+     * A sum of three uniforms either side of zero rather than a normal deviate: the fit only needs
+     * two halves to land somewhere inside the shape they came from, and a Box–Muller transform would
+     * want a logarithm and a cosine for no gain the picture can show.
+     */
+    const local = [0, 0, 0];
+    for (let c = 0; c < 3; c += 1) {
+        const spread = random() + random() + random() - 1.5;
+        local[c] = spread * exactExp(cloud.logScales.values[slot * 3 + c]);
+    }
+    for (let r = 0; r < 3; r += 1) {
+        let sum = 0;
+        for (let c = 0; c < 3; c += 1)
+            sum += rotation[r * 3 + c] * local[c];
+        cloud.positions.values[slot * 3 + r] = cloud.positions.values[slot * 3 + r] + sum;
+    }
+}

package/dist/gaussians/similarity.d.ts

@@ -0,0 +1,25 @@
+/**
+ * How alike two pictures are, structure included.
+ *
+ * **A squared difference is not a likeness.** It is what the fit descends, because it has a
+ * gradient, and it is the wrong thing to judge the result by: a cloud that is uniformly a little
+ * dark scores badly on it and looks right, and one that is right on average with the structure
+ * smeared away scores well and looks wrong. Structural similarity compares local means, variances
+ * and covariance, so it answers the question a reader actually asks of a capture.
+ *
+ * **Uniform windows rather than a Gaussian one.** The original weights each window by an 11 × 11
+ * Gaussian; this walks 8 × 8 blocks with equal weight, which is the same three terms over a
+ * different support and is what every fast implementation does. What it gives up is comparability
+ * with a number quoted from the paper — so a floor here is measured against this implementation
+ * and not lifted from one written elsewhere.
+ */
+/** The side of the block the three statistics are taken over. */
+export declare const SIMILARITY_WINDOW = 8;
+/**
+ * The mean structural similarity of `a` and `b`, one value a pixel, over every window.
+ *
+ * A picture narrower or shorter than a window is compared as one window rather than refused: it
+ * has a mean and a variance like any other, and the alternative is a measure that cannot answer
+ * for a thumbnail.
+ */
+export declare function structuralSimilarity(a: ArrayLike<number>, b: ArrayLike<number>, width: number, height: number): number;

package/dist/gaussians/similarity.js

@@ -0,0 +1,80 @@
+/**
+ * How alike two pictures are, structure included.
+ *
+ * **A squared difference is not a likeness.** It is what the fit descends, because it has a
+ * gradient, and it is the wrong thing to judge the result by: a cloud that is uniformly a little
+ * dark scores badly on it and looks right, and one that is right on average with the structure
+ * smeared away scores well and looks wrong. Structural similarity compares local means, variances
+ * and covariance, so it answers the question a reader actually asks of a capture.
+ *
+ * **Uniform windows rather than a Gaussian one.** The original weights each window by an 11 × 11
+ * Gaussian; this walks 8 × 8 blocks with equal weight, which is the same three terms over a
+ * different support and is what every fast implementation does. What it gives up is comparability
+ * with a number quoted from the paper — so a floor here is measured against this implementation
+ * and not lifted from one written elsewhere.
+ */
+/** The side of the block the three statistics are taken over. */
+export const SIMILARITY_WINDOW = 8;
+/*
+ * The stabilisers, for values on 0 to 1. They keep a window where both pictures are flat from
+ * dividing zero by zero, and they are the reason two dark patches are not declared identical on
+ * the strength of a rounding difference.
+ */
+const C1 = 0.01 * 0.01;
+const C2 = 0.03 * 0.03;
+/**
+ * The mean structural similarity of `a` and `b`, one value a pixel, over every window.
+ *
+ * A picture narrower or shorter than a window is compared as one window rather than refused: it
+ * has a mean and a variance like any other, and the alternative is a measure that cannot answer
+ * for a thumbnail.
+ */
+export function structuralSimilarity(a, b, width, height) {
+    let total = 0;
+    let windows = 0;
+    for (let top = 0; top < height; top += SIMILARITY_WINDOW) {
+        for (let left = 0; left < width; left += SIMILARITY_WINDOW) {
+            const right = Math.min(width, left + SIMILARITY_WINDOW);
+            const bottom = Math.min(height, top + SIMILARITY_WINDOW);
+            const pixels = (right - left) * (bottom - top);
+            if (pixels === 0)
+                continue;
+            let sumA = 0;
+            let sumB = 0;
+            for (let y = top; y < bottom; y += 1) {
+                for (let x = left; x < right; x += 1) {
+                    sumA += a[y * width + x];
+                    sumB += b[y * width + x];
+                }
+            }
+            const meanA = sumA / pixels;
+            const meanB = sumB / pixels;
+            let varianceA = 0;
+            let varianceB = 0;
+            let covariance = 0;
+            for (let y = top; y < bottom; y += 1) {
+                for (let x = left; x < right; x += 1) {
+                    const offA = a[y * width + x] - meanA;
+                    const offB = b[y * width + x] - meanB;
+                    varianceA += offA * offA;
+                    varianceB += offB * offB;
+                    covariance += offA * offB;
+                }
+            }
+            /*
+             * Divided by n − 1 where there is more than one pixel, which is the unbiased estimate the
+             * original uses. A single-pixel window has no spread to estimate and is compared by its
+             * means alone.
+             */
+            const spread = pixels > 1 ? pixels - 1 : 1;
+            varianceA /= spread;
+            varianceB /= spread;
+            covariance /= spread;
+            const luminance = (2 * meanA * meanB + C1) / (meanA * meanA + meanB * meanB + C1);
+            const structure = (2 * covariance + C2) / (varianceA + varianceB + C2);
+            total += luminance * structure;
+            windows += 1;
+        }
+    }
+    return windows === 0 ? 1 : total / windows;
+}