@driftengine/capture 4.0.0

package/dist/features.d.ts

@@ -0,0 +1,33 @@
+/** The features of one frame, in the arrays a caller owns. */
+export interface FeatureSet {
+    readonly x: Float32Array;
+    readonly y: Float32Array;
+    /** Shi–Tomasi's smaller eigenvalue: how strong a corner it is. */
+    readonly response: Float32Array;
+    /** The orientation, as a unit vector rather than an angle. */
+    readonly cos: Float32Array;
+    readonly sin: Float32Array;
+    count: number;
+}
+/** The descriptions of a frame's features: `BYTES` bytes each, bit by comparison. */
+export interface Descriptors {
+    readonly bits: Uint8Array;
+    readonly count: number;
+}
+/** A description is 256 bits, which is 32 bytes. */
+export declare const DESCRIPTOR_BYTES = 32;
+export declare function createFeatureSet(budget: number): FeatureSet;
+/**
+ * The strongest corners of `image`, RGBA at `width × height`, into `out` — at most `budget` of
+ * them, strongest first.
+ */
+export declare function detectFeatures(image: Uint8Array, width: number, height: number, out: FeatureSet, budget: number): void;
+/** A description of every feature in `features`, 32 bytes each. */
+export declare function describeFeatures(image: Uint8Array, width: number, height: number, features: FeatureSet): Descriptors;
+/**
+ * The matches between two frames' descriptions into `out`, two indices each, and how many there
+ * are. A match is mutual and clears Lowe's `ratio`, which defaults to 0.8.
+ */
+export declare function matchFeatures(a: Descriptors, b: Descriptors, out: Int32Array, options?: {
+    readonly ratio?: number;
+}): number;

package/dist/features.js

@@ -0,0 +1,260 @@
+/**
+ * Corners in a frame, a binary description of each, and the matches between two frames.
+ *
+ * **A corner is a place where the image moves in two directions at once**, which is the one thing
+ * that can be found again from another angle: an edge slides along itself and a flat patch could be
+ * anywhere. So the response is Shi–Tomasi's — the smaller eigenvalue of the gradient's structure
+ * tensor, which is how much the weaker direction moves — kept where it is the largest in its own
+ * neighbourhood, and the strongest `budget` of those are the frame's features.
+ *
+ * **Each carries an orientation, and it is a vector rather than an angle.** The intensity centroid
+ * of a patch points away from its darker side; normalised, that is the cosine and sine the
+ * descriptor's pattern is turned by, so no inverse tangent is taken — which matters because this
+ * package is inside the determinism gate and `atan2` is one of the twenty-two functions no two
+ * engines must agree on.
+ *
+ * **The description is 256 comparisons of a blurred patch**, at pairs of places drawn once from a
+ * seed and turned by the feature's own orientation: a bit per pair, so two features compare in a
+ * few instructions and a frame's worth fits in memory. Blurred, because a comparison of two raw
+ * pixels is a comparison of two samples of the noise.
+ *
+ * **A match is mutual and unambiguous.** Each feature's nearest description in the other frame must
+ * also have it as its nearest, and each must be clearly nearer than its own second nearest —
+ * Lowe's ratio, applied from both sides — because a repeated texture answers every query equally
+ * well and a wrong match at this stage is a wrong camera later. **From both sides rather than one**,
+ * so matching the frames the other way round gives the same pairs; tested one-sided, it gave 46
+ * pairs one way and 48 the other, which would make a capture's answer depend on which frame it
+ * called first.
+ */
+import { mulberry32 } from '@driftengine/core';
+/** A description is 256 bits, which is 32 bytes. */
+export const DESCRIPTOR_BYTES = 32;
+const PAIRS = DESCRIPTOR_BYTES * 8;
+/** The patch a description is drawn from, and the one an orientation is measured over. */
+const PATCH = 15;
+const SUPPRESS = 3;
+/** A corner must reach this share of the frame's strongest to be one at all. */
+const FLOOR = 0.01;
+/**
+ * And this much movement outright, in luma squared. **A share alone is not enough**: a wall carries
+ * a level or two of sensor noise, and a share of the strongest noise is still noise — measured, an
+ * uncorrelated level of ±1 answers with 265 "corners" of up to 6, and ±2 with 268 of up to 17,
+ * while the test scene's weakest real corner is 180 and its strongest 12,100. **25 sits between
+ * them**, three orders below what a texture scores and above what noise reaches.
+ */
+const LEAST = 25;
+export function createFeatureSet(budget) {
+    return {
+        x: new Float32Array(budget),
+        y: new Float32Array(budget),
+        response: new Float32Array(budget),
+        cos: new Float32Array(budget),
+        sin: new Float32Array(budget),
+        count: 0,
+    };
+}
+/* The pattern, drawn once: pairs of offsets inside the patch, the same on every machine. */
+const PATTERN = (() => {
+    const random = mulberry32(0x0c0ffee1);
+    const out = new Int8Array(PAIRS * 4);
+    const reach = (PATCH - 1) / 2;
+    for (let i = 0; i < PAIRS * 4; i += 1) {
+        /* A rounded draw over the patch, which keeps the pairs inside it once they are turned. */
+        out[i] = Math.round((random() * 2 - 1) * reach * 0.7);
+    }
+    return out;
+})();
+/** The frame as luma, one byte a pixel, which everything below reads. */
+function luma(image, width, height) {
+    const out = new Float32Array(width * height);
+    for (let at = 0; at < width * height; at += 1) {
+        out[at] =
+            0.299 * image[at * 4] +
+                0.587 * image[at * 4 + 1] +
+                0.114 * image[at * 4 + 2];
+    }
+    return out;
+}
+/** A 3 × 3 box blur, which is what a description compares rather than raw samples. */
+function blurred(grey, width, height) {
+    const out = new Float32Array(grey.length);
+    for (let y = 0; y < height; y += 1) {
+        for (let x = 0; x < width; x += 1) {
+            let sum = 0;
+            for (let dy = -1; dy <= 1; dy += 1) {
+                const row = Math.min(height - 1, Math.max(0, y + dy)) * width;
+                for (let dx = -1; dx <= 1; dx += 1) {
+                    sum += grey[row + Math.min(width - 1, Math.max(0, x + dx))];
+                }
+            }
+            out[y * width + x] = sum / 9;
+        }
+    }
+    return out;
+}
+/**
+ * The strongest corners of `image`, RGBA at `width × height`, into `out` — at most `budget` of
+ * them, strongest first.
+ */
+export function detectFeatures(image, width, height, out, budget) {
+    const grey = luma(image, width, height);
+    const response = new Float32Array(width * height);
+    const border = (PATCH - 1) / 2 + 1;
+    let strongest = 0;
+    for (let y = border; y < height - border; y += 1) {
+        for (let x = border; x < width - border; x += 1) {
+            /* The structure tensor over a 3 × 3 window of central differences. */
+            let xx = 0;
+            let yy = 0;
+            let xy = 0;
+            for (let dy = -1; dy <= 1; dy += 1) {
+                for (let dx = -1; dx <= 1; dx += 1) {
+                    const at = (y + dy) * width + x + dx;
+                    const gx = (grey[at + 1] - grey[at - 1]) / 2;
+                    const gy = (grey[at + width] - grey[at - width]) / 2;
+                    xx += gx * gx;
+                    yy += gy * gy;
+                    xy += gx * gy;
+                }
+            }
+            const half = (xx + yy) / 2;
+            const side = (xx - yy) / 2;
+            /* Shi–Tomasi: the smaller eigenvalue, which is the weaker direction's movement. */
+            const smaller = half - Math.sqrt(side * side + xy * xy);
+            response[y * width + x] = smaller;
+            strongest = Math.max(strongest, smaller);
+        }
+    }
+    /* Keep a response that is the largest within its neighbourhood and above the floor. */
+    const floor = Math.max(strongest * FLOOR, LEAST);
+    const kept = [];
+    for (let y = border; y < height - border; y += 1) {
+        for (let x = border; x < width - border; x += 1) {
+            const here = response[y * width + x];
+            if (here < floor)
+                continue;
+            let best = true;
+            for (let dy = -SUPPRESS; dy <= SUPPRESS && best; dy += 1) {
+                for (let dx = -SUPPRESS; dx <= SUPPRESS; dx += 1) {
+                    if (dx === 0 && dy === 0)
+                        continue;
+                    const other = response[(y + dy) * width + x + dx];
+                    /* A tie goes to the earlier pixel, so the answer does not depend on the scan. */
+                    if (other > here || (other === here && (dy < 0 || (dy === 0 && dx < 0)))) {
+                        best = false;
+                        break;
+                    }
+                }
+            }
+            if (best)
+                kept.push(y * width + x);
+        }
+    }
+    kept.sort((a, b) => response[b] - response[a] || a - b);
+    const reach = (PATCH - 1) / 2;
+    out.count = Math.min(budget, out.x.length, kept.length);
+    for (let i = 0; i < out.count; i += 1) {
+        const at = kept[i];
+        const x = at % width;
+        const y = (at - x) / width;
+        out.x[i] = x;
+        out.y[i] = y;
+        out.response[i] = response[at];
+        /* The intensity centroid of the patch, as a direction. */
+        let mx = 0;
+        let my = 0;
+        for (let dy = -reach; dy <= reach; dy += 1) {
+            for (let dx = -reach; dx <= reach; dx += 1) {
+                if (dx * dx + dy * dy > reach * reach)
+                    continue;
+                const value = grey[(y + dy) * width + x + dx];
+                mx += dx * value;
+                my += dy * value;
+            }
+        }
+        const length = Math.sqrt(mx * mx + my * my);
+        out.cos[i] = length === 0 ? 1 : mx / length;
+        out.sin[i] = length === 0 ? 0 : my / length;
+    }
+}
+/** A description of every feature in `features`, 32 bytes each. */
+export function describeFeatures(image, width, height, features) {
+    const smooth = blurred(luma(image, width, height), width, height);
+    const bits = new Uint8Array(features.count * DESCRIPTOR_BYTES);
+    for (let i = 0; i < features.count; i += 1) {
+        const x = features.x[i];
+        const y = features.y[i];
+        const cos = features.cos[i];
+        const sin = features.sin[i];
+        for (let pair = 0; pair < PAIRS; pair += 1) {
+            const sample = (at) => {
+                const dx = PATTERN[pair * 4 + at * 2];
+                const dy = PATTERN[pair * 4 + at * 2 + 1];
+                /* The pattern turns with the feature, which is what makes it survive a rotation. */
+                const rx = Math.round(x + cos * dx - sin * dy);
+                const ry = Math.round(y + sin * dx + cos * dy);
+                const cx = Math.min(width - 1, Math.max(0, rx));
+                const cy = Math.min(height - 1, Math.max(0, ry));
+                return smooth[cy * width + cx];
+            };
+            if (sample(0) < sample(1)) {
+                bits[i * DESCRIPTOR_BYTES + (pair >> 3)] |= 1 << (pair & 7);
+            }
+        }
+    }
+    return { bits, count: features.count };
+}
+const ONES = (() => {
+    const out = new Uint8Array(256);
+    for (let i = 0; i < 256; i += 1)
+        out[i] = (i & 1) + out[i >> 1];
+    return out;
+})();
+function distance(a, at, b, to) {
+    let sum = 0;
+    for (let byte = 0; byte < DESCRIPTOR_BYTES; byte += 1) {
+        sum += ONES[a[at + byte] ^ b[to + byte]];
+    }
+    return sum;
+}
+/**
+ * The matches between two frames' descriptions into `out`, two indices each, and how many there
+ * are. A match is mutual and clears Lowe's `ratio`, which defaults to 0.8.
+ */
+export function matchFeatures(a, b, out, options = {}) {
+    const ratio = options.ratio ?? 0.8;
+    const bestOf = (from, to, index) => {
+        let at = -1;
+        let best = Infinity;
+        let second = Infinity;
+        for (let j = 0; j < to.count; j += 1) {
+            const off = distance(from.bits, index * DESCRIPTOR_BYTES, to.bits, j * DESCRIPTOR_BYTES);
+            if (off < best) {
+                second = best;
+                best = off;
+                at = j;
+            }
+            else if (off < second) {
+                second = off;
+            }
+        }
+        return { at, best, second };
+    };
+    let count = 0;
+    for (let i = 0; i < a.count && count * 2 + 1 < out.length; i += 1) {
+        const forward = bestOf(a, b, i);
+        if (forward.at < 0)
+            continue;
+        /* Unambiguous: the nearest must be clearly nearer than whatever came second. */
+        if (!(forward.best < ratio * forward.second))
+            continue;
+        /* And mutual, by the same rule from the other side: matching either way gives one answer. */
+        const back = bestOf(b, a, forward.at);
+        if (back.at !== i || !(back.best < ratio * back.second))
+            continue;
+        out[count * 2] = i;
+        out[count * 2 + 1] = forward.at;
+        count += 1;
+    }
+    return count;
+}

package/dist/frames.d.ts

@@ -0,0 +1,47 @@
+/**
+ * A clip's frames, and which of them a capture keeps.
+ *
+ * **The engine never opens a file.** A host hands it a `FrameSource` — a video element in a
+ * browser, a decoder on a native host, a folder of stills in a test — and the engine reads it one
+ * frame at a time, in order, into a buffer of its own. A minute of 1080p is eight gigabytes of
+ * pixels, so a clip is walked rather than held, and what a capture keeps is chosen as it goes past.
+ *
+ * **A frame may arrive later than it is asked for**, since every browser decoder is asynchronous, so
+ * `frameAt` may answer a promise and the two readers here are `async`. A host with its frames
+ * already in hand answers without one and pays nothing: an awaited value that is not a promise
+ * costs a microtask, and this is a clip's pace rather than a frame's.
+ *
+ * **Frames are chosen by motion, not by number.** What reconstruction needs is baseline: two views
+ * far enough apart to triangulate, and no more of them than the budget allows. So the frames kept
+ * are spaced by equal motion — a slow pan gives up most of its frames, a fast one keeps them — and
+ * a clip that never moves is one frame, which is what it holds. `every` is the other way to choose,
+ * for a caller that knows its clip: every Nth frame, under the same budget.
+ *
+ * **Motion is the mean absolute difference between one frame and the last**, over the colours and
+ * not the alpha, which is a measure of how much the picture changed rather than of how far anything
+ * travelled. **What it gives up** is telling a pan from a light being switched on; what would make
+ * it wrong is a clip whose brightness swings without the camera moving, and the answer then is the
+ * feature matching of Task 9 rather than a cleverer average.
+ */
+export interface FrameSize {
+    readonly width: number;
+    readonly height: number;
+}
+export interface FrameSource {
+    frameCount(): number;
+    /**
+     * Writes frame `index` as RGBA into `out` and answers the frame's size. A buffer too small for
+     * the frame is left untouched, so a caller may ask with an empty one to learn the size first.
+     */
+    frameAt(index: number, out: Uint8Array): FrameSize | Promise<FrameSize>;
+}
+export interface FrameChoice {
+    /** At most this many frames. */
+    readonly budget: number;
+    /** Every Nth frame instead of by motion. */
+    readonly every?: number;
+}
+/** Every frame in order, each read over the last into one buffer the visitor must not keep. */
+export declare function eachFrame(source: FrameSource, visit: (index: number, pixels: Uint8Array, width: number, height: number) => void): Promise<void>;
+/** The frames a capture keeps, in order, the first among them. */
+export declare function selectFrames(source: FrameSource, choice: FrameChoice): Promise<number[]>;

package/dist/frames.js

@@ -0,0 +1,87 @@
+/**
+ * A clip's frames, and which of them a capture keeps.
+ *
+ * **The engine never opens a file.** A host hands it a `FrameSource` — a video element in a
+ * browser, a decoder on a native host, a folder of stills in a test — and the engine reads it one
+ * frame at a time, in order, into a buffer of its own. A minute of 1080p is eight gigabytes of
+ * pixels, so a clip is walked rather than held, and what a capture keeps is chosen as it goes past.
+ *
+ * **A frame may arrive later than it is asked for**, since every browser decoder is asynchronous, so
+ * `frameAt` may answer a promise and the two readers here are `async`. A host with its frames
+ * already in hand answers without one and pays nothing: an awaited value that is not a promise
+ * costs a microtask, and this is a clip's pace rather than a frame's.
+ *
+ * **Frames are chosen by motion, not by number.** What reconstruction needs is baseline: two views
+ * far enough apart to triangulate, and no more of them than the budget allows. So the frames kept
+ * are spaced by equal motion — a slow pan gives up most of its frames, a fast one keeps them — and
+ * a clip that never moves is one frame, which is what it holds. `every` is the other way to choose,
+ * for a caller that knows its clip: every Nth frame, under the same budget.
+ *
+ * **Motion is the mean absolute difference between one frame and the last**, over the colours and
+ * not the alpha, which is a measure of how much the picture changed rather than of how far anything
+ * travelled. **What it gives up** is telling a pan from a light being switched on; what would make
+ * it wrong is a clip whose brightness swings without the camera moving, and the answer then is the
+ * feature matching of Task 9 rather than a cleverer average.
+ */
+const NOTHING = new Uint8Array(0);
+/** Every frame in order, each read over the last into one buffer the visitor must not keep. */
+export async function eachFrame(source, visit) {
+    const count = source.frameCount();
+    if (count <= 0)
+        return;
+    const { width, height } = await source.frameAt(0, NOTHING);
+    const pixels = new Uint8Array(width * height * 4);
+    for (let index = 0; index < count; index += 1) {
+        const size = await source.frameAt(index, pixels);
+        visit(index, pixels, size.width, size.height);
+    }
+}
+/** The frames a capture keeps, in order, the first among them. */
+export async function selectFrames(source, choice) {
+    const count = source.frameCount();
+    const budget = Math.max(1, Math.floor(choice.budget));
+    if (count <= 0)
+        return [];
+    if (choice.every !== undefined) {
+        const kept = [];
+        for (let index = 0; index < count && kept.length < budget; index += choice.every) {
+            kept.push(index);
+        }
+        return kept;
+    }
+    if (count <= budget)
+        return Array.from({ length: count }, (_, index) => index);
+    /* One pass for the motion between each frame and the last, keeping a copy of that last frame. */
+    const travelled = new Float64Array(count);
+    let last = null;
+    await eachFrame(source, (index, pixels) => {
+        if (last !== null) {
+            let sum = 0;
+            for (let at = 0; at < pixels.length; at += 4) {
+                sum +=
+                    Math.abs(pixels[at] - last[at]) +
+                        Math.abs(pixels[at + 1] - last[at + 1]) +
+                        Math.abs(pixels[at + 2] - last[at + 2]);
+            }
+            travelled[index] = travelled[index - 1] + sum / ((pixels.length / 4) * 3);
+        }
+        else {
+            last = new Uint8Array(pixels.length);
+        }
+        last.set(pixels);
+    });
+    const total = travelled[count - 1];
+    if (total === 0)
+        return [0];
+    /* Spaced so the whole clip's motion divides into the budget's frames, the last one included. */
+    const step = total / (budget - 1);
+    const kept = [0];
+    let since = 0;
+    for (let index = 1; index < count && kept.length < budget; index += 1) {
+        if (travelled[index] - since >= step * (1 - 1e-9)) {
+            kept.push(index);
+            since = travelled[index];
+        }
+    }
+    return kept;
+}

package/dist/fusion.d.ts

@@ -0,0 +1,77 @@
+/**
+ * Many views of a scene fused into one volume: a truncated signed distance, weighted by how
+ * squarely each view saw the surface.
+ *
+ * **Why a volume rather than the depth maps themselves.** Every view has a surface in it and no two
+ * agree exactly — noise, a fit's own error, and the silhouettes where a splat cloud thins out. A
+ * volume is where they are averaged: each view writes its opinion of the distance to the nearest
+ * surface into the samples along its own rays, and what comes out is the surface every view agrees
+ * on. `marchVolume` then reads the crossing.
+ *
+ * **Negative inside**, which is `ObjectSdf`'s convention in `@driftengine/assets` and the one the
+ * rest of this engine reads a distance field by. A sample nearer the camera than the surface is
+ * outside it and positive.
+ *
+ * **Truncated, because a depth map knows nothing about the far side of what it sees.** Past a few
+ * samples behind the surface a view has no information at all — the space there might be solid,
+ * might be another room — so writing a large negative distance would be inventing one. Everything
+ * beyond the truncation on the far side is left alone; everything beyond it on the near side is
+ * free space and is written as such, which is what carves the empty air out.
+ *
+ * **Weighted by the angle, which is what stops a grazing view winning.** A surface seen almost
+ * edge-on is a few pixels wide and every one of them is uncertain in depth by the whole width of
+ * the surface; seen square on, the same surface is measured well. The weight is the cosine between
+ * the view's own ray and the surface's normal, taken from the depth map's own gradient, so a
+ * grazing view contributes what it is worth rather than as much as any other.
+ *
+ * **A surface one view saw is kept, at the weight one view is worth.** Dropping it would leave a
+ * hole where the capture only ever looked once, which is most of a real clip's edges.
+ */
+import type { RasterCamera } from './gaussians/project.ts';
+/**
+ * One view's opinion: its depth, how well covered each pixel was, and where it stood.
+ *
+ * **Not `DepthView`, which is the depth *model's* shape** — that one carries a confidence and its
+ * own 3 × 3 intrinsics and does not know the size of its own frame. The two say much the same thing
+ * in two forms, and the pipeline that joins them is the place to convert, not here.
+ */
+export interface SurfaceView {
+    /** Along the camera's own axis, in metres; zero where nothing was seen. */
+    readonly depth: Float32Array;
+    /** Nought to one, as `renderDepth` answers it. */
+    readonly coverage: Float32Array;
+    readonly camera: RasterCamera;
+}
+/** A field of samples over a box of the world, `x` fastest, then `y`, then `z`. */
+export interface Volume {
+    readonly dims: readonly [number, number, number];
+    /** Where the first sample sits, in the capture's world. */
+    readonly origin: readonly [number, number, number];
+    /** Metres between samples, the same on every axis. */
+    readonly spacing: number;
+    /** Truncated signed distance in metres, **negative inside**. */
+    readonly distance: Float32Array;
+    /** How much evidence each sample has; zero where no view ever saw it. */
+    readonly weight: Float32Array;
+}
+export interface FuseOptions {
+    /**
+     * How far either side of a surface a view is believed, in metres.
+     *
+     * Three samples by default: enough that the crossing is bracketed by samples with real evidence
+     * on both sides, which is what marching needs, and short enough that one view's surface does not
+     * reach through a wall into the next room.
+     */
+    readonly truncation?: number;
+    /** Below this coverage a pixel's depth is an average of too little light to believe. */
+    readonly minimumCoverage?: number;
+}
+export declare function createVolume(dims: readonly [number, number, number], origin: readonly [number, number, number], spacing: number): Volume;
+/**
+ * Every view's surface written into `volume`, which accumulates rather than replaces.
+ *
+ * Calling this twice with two halves of the views is the same as calling it once with all of them,
+ * because a weighted mean is what each sample holds — which is what lets a clip be fused as it
+ * arrives rather than all at once.
+ */
+export declare function fuseDepth(views: readonly SurfaceView[], volume: Volume, options?: FuseOptions): void;

package/dist/fusion.js

@@ -0,0 +1,152 @@
+const DEFAULT_COVERAGE = 0.5;
+export function createVolume(dims, origin, spacing) {
+    const [nx, ny, nz] = dims;
+    return {
+        dims,
+        origin,
+        spacing,
+        distance: new Float32Array(nx * ny * nz),
+        weight: new Float32Array(nx * ny * nz),
+    };
+}
+/**
+ * Every view's surface written into `volume`, which accumulates rather than replaces.
+ *
+ * Calling this twice with two halves of the views is the same as calling it once with all of them,
+ * because a weighted mean is what each sample holds — which is what lets a clip be fused as it
+ * arrives rather than all at once.
+ */
+export function fuseDepth(views, volume, options = {}) {
+    const [nx, ny, nz] = volume.dims;
+    const truncation = options.truncation ?? volume.spacing * 3;
+    const minimumCoverage = options.minimumCoverage ?? DEFAULT_COVERAGE;
+    if (!(truncation > 0))
+        throw new RangeError('capture: a fusion needs a truncation above zero');
+    for (const view of views) {
+        const { width, height, intrinsics } = view.camera;
+        const [fx, fy, cx, cy] = intrinsics;
+        const m = view.camera.worldToCamera;
+        const normals = surfaceNormals(view);
+        for (let k = 0; k < nz; k += 1) {
+            for (let j = 0; j < ny; j += 1) {
+                for (let i = 0; i < nx; i += 1) {
+                    const world = [
+                        volume.origin[0] + i * volume.spacing,
+                        volume.origin[1] + j * volume.spacing,
+                        volume.origin[2] + k * volume.spacing,
+                    ];
+                    let viewX = 0;
+                    let viewY = 0;
+                    let viewZ = 0;
+                    for (let r = 0; r < 3; r += 1) {
+                        const value = m[r * 4] * world[0] +
+                            m[r * 4 + 1] * world[1] +
+                            m[r * 4 + 2] * world[2] +
+                            m[r * 4 + 3];
+                        if (r === 0)
+                            viewX = value;
+                        else if (r === 1)
+                            viewY = value;
+                        else
+                            viewZ = value;
+                    }
+                    if (!(viewZ > 0))
+                        continue;
+                    const px = Math.floor((fx * viewX) / viewZ + cx);
+                    const py = Math.floor((fy * viewY) / viewZ + cy);
+                    if (px < 0 || px >= width || py < 0 || py >= height)
+                        continue;
+                    const pixel = py * width + px;
+                    if (view.coverage[pixel] < minimumCoverage)
+                        continue;
+                    const measured = view.depth[pixel];
+                    if (!(measured > 0))
+                        continue;
+                    /*
+                     * How squarely this view saw that surface: the ray through the pixel against the
+                     * surface's own normal, both in the camera's frame. A view looking straight at it is
+                     * worth one and a grazing view almost nothing.
+                     */
+                    const rayX = (px + 0.5 - cx) / fx;
+                    const rayY = (py + 0.5 - cy) / fy;
+                    const rayLength = Math.sqrt(rayX * rayX + rayY * rayY + 1);
+                    const facing = -((rayX * normals[pixel * 3] +
+                        rayY * normals[pixel * 3 + 1] +
+                        normals[pixel * 3 + 2]) /
+                        rayLength);
+                    const angle = facing > 0 ? facing : 0;
+                    const weight = angle * view.coverage[pixel];
+                    if (!(weight > 0))
+                        continue;
+                    /*
+                     * **In front of the surface is outside it, and the distance is measured along the
+                     * surface's normal rather than along the camera's axis.** The difference of two depths is
+                     * a distance along the view's own ray, which is the perpendicular distance only where the
+                     * surface faces the camera squarely; everywhere else it overstates it by the obliquity.
+                     * For a plane the correction is exact, and for a curved surface it is the first-order
+                     * term — measured on a sphere fused from eight views, it took the median error in the
+                     * band from 25 mm to 11 and the ninetieth percentile from 55 mm to 43. **The worst sample
+                     * does not move**, because it is one at the very edge of the band whose distance
+                     * saturates at the truncation either way.
+                     */
+                    const signed = (measured - viewZ) * rayLength * angle;
+                    if (signed < -truncation)
+                        continue;
+                    const clamped = signed > truncation ? truncation : signed;
+                    const at = (k * ny + j) * nx + i;
+                    const held = volume.weight[at];
+                    const total = held + weight;
+                    volume.distance[at] = (volume.distance[at] * held + clamped * weight) / total;
+                    volume.weight[at] = total;
+                }
+            }
+        }
+    }
+}
+/**
+ * A normal per pixel, in the camera's frame, from the depth map's own gradient.
+ *
+ * **Central differences, and a pixel whose neighbours are not both surfaces gets the view's own
+ * axis instead.** At a silhouette the difference is across the gap between a near surface and a far
+ * one, which is not a gradient of anything; answering the axis there says "seen square on", which
+ * is generous rather than wrong, and the coverage is what actually discounts those pixels.
+ */
+function surfaceNormals(view) {
+    const { width, height, intrinsics } = view.camera;
+    const [fx, fy, cx, cy] = intrinsics;
+    const out = new Float64Array(width * height * 3);
+    const at = (x, y) => {
+        if (x < 0 || x >= width || y < 0 || y >= height)
+            return null;
+        const z = view.depth[y * width + x];
+        if (!(z > 0))
+            return null;
+        return [((x + 0.5 - cx) * z) / fx, ((y + 0.5 - cy) * z) / fy, z];
+    };
+    for (let y = 0; y < height; y += 1) {
+        for (let x = 0; x < width; x += 1) {
+            const pixel = y * width + x;
+            out[pixel * 3 + 2] = -1;
+            const left = at(x - 1, y);
+            const right = at(x + 1, y);
+            const up = at(x, y - 1);
+            const down = at(x, y + 1);
+            if (left === null || right === null || up === null || down === null)
+                continue;
+            const ax = [right[0] - left[0], right[1] - left[1], right[2] - left[2]];
+            const ay = [down[0] - up[0], down[1] - up[1], down[2] - up[2]];
+            const nx = ay[1] * ax[2] - ay[2] * ax[1];
+            const ny = ay[2] * ax[0] - ay[0] * ax[2];
+            const nz = ay[0] * ax[1] - ay[1] * ax[0];
+            const length = Math.sqrt(nx * nx + ny * ny + nz * nz);
+            if (!(length > 0))
+                continue;
+            /* Towards the camera, which is the negative z half of its own frame. */
+            const sign = nz > 0 ? -1 : 1;
+            out[pixel * 3] = (sign * nx) / length;
+            out[pixel * 3 + 1] = (sign * ny) / length;
+            out[pixel * 3 + 2] = (sign * nz) / length;
+        }
+    }
+    return out;
+}