@driftengine/capture 4.0.0

package/src/gaussians/gradients.ts

@@ -0,0 +1,285 @@
+/**
+ * What a Gaussian would have to change to make the picture right: the derivatives of the rendered
+ * frame with respect to every parameter of every Gaussian.
+ *
+ * **Analytic, and checked against a central difference.** Every term below is a chain rule through
+ * the same projection `rasterise.ts` draws with — the view transform, the perspective Jacobian, the
+ * screen covariance, its inverse, the exponent, the alpha, and the compositing — and
+ * `gradients.test.ts` compares each against the rasteriser it differentiates, nudged. A gradient
+ * that is subtly wrong does not fail: it trains to a slightly wrong cloud, which is why the
+ * comparison is the test rather than a measure of how well it fits.
+ *
+ * **The compositing is walked twice.** Forward, nearest first, to know what each Gaussian
+ * contributed and what light was left after it; then backward, furthest first, carrying the colour
+ * accumulated behind — because what a Gaussian's alpha is worth depends on everything in front of
+ * it and everything behind it at once.
+ */
+import { exactExp } from '@driftengine/core';
+
+import {
+  cameraCentre,
+  sh1Basis,
+  sh1DirectionGradient,
+  splatColour,
+  SH1_COEFFICIENTS,
+  viewDirection,
+} from './harmonics.ts';
+import {
+  visibleGaussians,
+  type GaussianSet,
+  type Projected,
+  type RasterCamera,
+} from './project.ts';
+import { screenToParameters } from './projectGradient.ts';
+import type { Frame } from './rasterise.ts';
+
+/** Where the gradients go: one entry per parameter of every Gaussian. */
+export interface GaussianGradients {
+  /** Three per Gaussian. */
+  readonly positions: Float64Array;
+  readonly scales: Float64Array;
+  /** Four per Gaussian, xyzw. */
+  readonly rotations: Float64Array;
+  readonly colors: Float64Array;
+  /** Nine per Gaussian, and left at zero for a cloud with no band to fit. */
+  readonly sh1: Float64Array;
+  /**
+   * The gradients **as the screen sees them**, nine per Gaussian: the two of its centre in pixels,
+   * the three of its screen covariance, its opacity, and its resolved colour.
+   *
+   * Everything else here is a chain rule away from these. They are kept because the tiled device
+   * rasteriser computes exactly this much and nothing further — the projection and the band are
+   * per-splat work that is not worth a dispatch — so this is the surface
+   * `scripts/gpu-parity.mjs` holds the two rasterisers to.
+   */
+  readonly screen: Float64Array;
+  /** One per Gaussian. */
+  readonly opacities: Float64Array;
+}
+
+export function createGradients(count: number): GaussianGradients {
+  return {
+    positions: new Float64Array(count * 3),
+    scales: new Float64Array(count * 3),
+    rotations: new Float64Array(count * 4),
+    colors: new Float64Array(count * 3),
+    sh1: new Float64Array(count * SH1_COEFFICIENTS),
+    screen: new Float64Array(count * SCREEN_GRADIENTS),
+    opacities: new Float64Array(count),
+  };
+}
+
+const FAINT = 1 / 255 / 4;
+
+/** Numbers a Gaussian's screen-space gradient occupies: mean, covariance, opacity, colour. */
+export const SCREEN_GRADIENTS = 9;
+
+/** The squared difference between a render and a frame, and the render's own gradient. */
+export function imageLoss(rendered: Frame, target: Frame, gradient: Float64Array): number {
+  let sum = 0;
+  for (let at = 0; at < gradient.length; at += 1) {
+    const off = (rendered[at] as number) - (target[at] as number);
+    sum += off * off;
+    gradient[at] = 2 * off;
+  }
+  return sum;
+}
+
+/**
+ * The gradients of a render against `dPixels` — the loss's derivative by each rendered channel,
+ * four a pixel — added into `out`. The render is repeated here rather than taken as an argument,
+ * because the backward walk needs what each Gaussian contributed on the way.
+ */
+export function accumulateGradients(
+  set: GaussianSet,
+  camera: RasterCamera,
+  dPixels: Float64Array,
+  out: GaussianGradients,
+): void {
+  const { width, height } = camera;
+  const { order, projected } = visibleGaussians(set, camera);
+  const pixels = width * height;
+
+  /* Forward: the light left at each pixel after every Gaussian in front of it. */
+  const transmittance = new Float64Array(pixels).fill(1);
+  for (const at of order) {
+    const one = projected[at] as Projected;
+    const determinant = one.a * one.d - one.b * one.b;
+    const inverse = [one.d / determinant, -one.b / determinant, one.a / determinant];
+    const box = boxOf(one, width, height);
+    for (let y = box.top; y <= box.bottom; y += 1) {
+      for (let x = box.left; x <= box.right; x += 1) {
+        const dx = x + 0.5 - one.x;
+        const dy = y + 0.5 - one.y;
+        const power =
+          -0.5 *
+          ((inverse[0] as number) * dx * dx +
+            2 * (inverse[1] as number) * dx * dy +
+            (inverse[2] as number) * dy * dy);
+        const alpha = (set.opacities[at] as number) * exactExp(power);
+        if (alpha < FAINT) continue;
+        const pixel = y * width + x;
+        transmittance[pixel] = (transmittance[pixel] as number) * (1 - alpha);
+      }
+    }
+  }
+
+  /* Backward: furthest first, carrying what stands behind each Gaussian. */
+  const behind = new Float64Array(pixels * 3);
+  const behindAlpha = new Float64Array(pixels);
+  const light = Float64Array.from(transmittance);
+  const eye = new Float64Array(3);
+  cameraCentre(camera.worldToCamera, eye);
+  const direction = new Float64Array(3);
+  const basis = new Float64Array(3);
+  const colour = new Float64Array(3);
+  const dColour = new Float64Array(3);
+  const dDirection = new Float64Array(3);
+  for (let index = order.length - 1; index >= 0; index -= 1) {
+    const at = order[index] as number;
+    const one = projected[at] as Projected;
+    const determinant = one.a * one.d - one.b * one.b;
+    const inverse = [one.d / determinant, -one.b / determinant, one.a / determinant];
+    const box = boxOf(one, width, height);
+    const opacity = set.opacities[at] as number;
+    const distance = viewDirection(set.positions, at, eye, direction);
+    sh1Basis(direction, basis);
+    splatColour(set.colors, set.sh1, at, basis, colour);
+    dColour.fill(0);
+    /* The screen-space gradients this Gaussian gathers over its own pixels. */
+    let dMeanX = 0;
+    let dMeanY = 0;
+    let dA = 0;
+    let dB = 0;
+    let dD = 0;
+    let dOpacity = 0;
+    for (let y = box.top; y <= box.bottom; y += 1) {
+      for (let x = box.left; x <= box.right; x += 1) {
+        const dx = x + 0.5 - one.x;
+        const dy = y + 0.5 - one.y;
+        const power =
+          -0.5 *
+          ((inverse[0] as number) * dx * dx +
+            2 * (inverse[1] as number) * dx * dy +
+            (inverse[2] as number) * dy * dy);
+        const weight = exactExp(power);
+        const alpha = opacity * weight;
+        if (alpha < FAINT) continue;
+        const pixel = y * width + x;
+        /* Undo this Gaussian's own share to recover the light that reached it. */
+        const after = light[pixel] as number;
+        const before = alpha === 1 ? after : after / (1 - alpha);
+        let dAlpha = 0;
+        for (let c = 0; c < 3; c += 1) {
+          const grad = dPixels[pixel * 4 + c] as number;
+          /* What this Gaussian puts on the pixel, and what its alpha takes from behind it. */
+          dColour[c] = (dColour[c] as number) + grad * alpha * before;
+          dAlpha += grad * before * ((colour[c] as number) - (behind[pixel * 3 + c] as number));
+        }
+        const gradAlpha = dPixels[pixel * 4 + 3] as number;
+        dAlpha += gradAlpha * before * (1 - (behindAlpha[pixel] as number));
+        dOpacity += dAlpha * weight;
+        /* Through the exponent to the mean and the covariance. */
+        const dPower = dAlpha * opacity * weight;
+        const gx = (inverse[0] as number) * dx + (inverse[1] as number) * dy;
+        const gy = (inverse[1] as number) * dx + (inverse[2] as number) * dy;
+        dMeanX += dPower * gx;
+        dMeanY += dPower * gy;
+        /*
+         * The exponent by the inverse covariance, **entry by entry rather than by three numbers**:
+         * the off-diagonal is one of a symmetric pair, so it takes half of what a single shared
+         * parameter would, and `dB` below is what puts the two halves back together. Written the
+         * other way it is a factor of two on every cross term, which is a wrong gradient that
+         * still points roughly the right way — so it fits, slightly wrongly, rather than failing.
+         */
+        const dInverseA = -0.5 * dPower * dx * dx;
+        const dInverseB = -0.5 * dPower * dx * dy;
+        const dInverseD = -0.5 * dPower * dy * dy;
+        /* d(Σ⁻¹)/dΣ for a symmetric 2 × 2, written out. */
+        const ia = inverse[0] as number;
+        const ib = inverse[1] as number;
+        const id = inverse[2] as number;
+        dA += -(
+          ia * dInverseA * ia +
+          ib * dInverseB * ia +
+          ia * dInverseB * ib +
+          ib * dInverseD * ib
+        );
+        dB +=
+          -(ia * dInverseA * ib + ib * dInverseB * ib + ia * dInverseB * id + ib * dInverseD * id) *
+          2;
+        dD += -(
+          ib * dInverseA * ib +
+          id * dInverseB * ib +
+          ib * dInverseB * id +
+          id * dInverseD * id
+        );
+        /* And carry this Gaussian into what stands behind the next one. */
+        for (let c = 0; c < 3; c += 1) {
+          behind[pixel * 3 + c] =
+            alpha * (colour[c] as number) + (1 - alpha) * (behind[pixel * 3 + c] as number);
+        }
+        behindAlpha[pixel] = alpha + (1 - alpha) * (behindAlpha[pixel] as number);
+        light[pixel] = before;
+      }
+    }
+    out.opacities[at] = (out.opacities[at] as number) + dOpacity;
+    /* What a device's tiled pass answers, before any of the chain rules below it. */
+    const screen = at * SCREEN_GRADIENTS;
+    out.screen[screen] = (out.screen[screen] as number) + dMeanX;
+    out.screen[screen + 1] = (out.screen[screen + 1] as number) + dMeanY;
+    out.screen[screen + 2] = (out.screen[screen + 2] as number) + dA;
+    out.screen[screen + 3] = (out.screen[screen + 3] as number) + dB;
+    out.screen[screen + 4] = (out.screen[screen + 4] as number) + dD;
+    out.screen[screen + 5] = (out.screen[screen + 5] as number) + dOpacity;
+    for (let c = 0; c < 3; c += 1) {
+      out.screen[screen + 6 + c] = (out.screen[screen + 6 + c] as number) + (dColour[c] as number);
+    }
+    /*
+     * The colour this Gaussian showed, back to the terms it was made of. **A channel the shader
+     * clamped at zero took no gradient**: it is flat there, so a constant term already below zero
+     * is not pushed further down by a frame that wanted it darker still.
+     */
+    for (let c = 0; c < 3; c += 1) {
+      if (!((colour[c] as number) > 0)) continue;
+      out.colors[at * 3 + c] = (out.colors[at * 3 + c] as number) + (dColour[c] as number);
+      if (set.sh1 === undefined) continue;
+      for (let band = 0; band < 3; band += 1) {
+        const slot = at * SH1_COEFFICIENTS + band * 3 + c;
+        out.sh1[slot] =
+          (out.sh1[slot] as number) + (dColour[c] as number) * (basis[band] as number);
+      }
+    }
+    /*
+     * And the band is a **second way a position changes the picture**: moving a Gaussian turns the
+     * direction it is seen from, which reshades it. Small next to the term that moves it across the
+     * frame, and the difference finds it all the same.
+     */
+    if (set.sh1 !== undefined && distance > 0) {
+      sh1DirectionGradient(set.sh1, at, colour, dColour, dDirection);
+      let along = 0;
+      for (let axis = 0; axis < 3; axis += 1)
+        along += (dDirection[axis] as number) * (direction[axis] as number);
+      for (let axis = 0; axis < 3; axis += 1) {
+        out.positions[at * 3 + axis] =
+          (out.positions[at * 3 + axis] as number) +
+          ((dDirection[axis] as number) - along * (direction[axis] as number)) / distance;
+      }
+    }
+    /* Through the projection to the Gaussian's own parameters. */
+    screenToParameters(set, at, camera, dMeanX, dMeanY, dA, dB, dD, out);
+  }
+}
+
+function boxOf(
+  one: Projected,
+  width: number,
+  height: number,
+): { left: number; right: number; top: number; bottom: number } {
+  return {
+    left: Math.max(0, Math.floor(one.x - one.radius)),
+    right: Math.min(width - 1, Math.ceil(one.x + one.radius)),
+    top: Math.max(0, Math.floor(one.y - one.radius)),
+    bottom: Math.min(height - 1, Math.ceil(one.y + one.radius)),
+  };
+}

package/src/gaussians/harmonics.ts

@@ -0,0 +1,122 @@
+/**
+ * The colour a Gaussian shows from a direction: its constant term plus the degree-1 band.
+ *
+ * **This is the splat shader's line, in JavaScript.** A capture fitted here is drawn by
+ * `@driftengine/splats`, so the two evaluations have to agree down to the sign of each basis —
+ * `SH_C1 * (-direction.y * c0 + direction.z * c1 - direction.x * c2)`, clamped at zero, shaded by
+ * the direction from the camera to the Gaussian in the capture's own world. A band evaluated with
+ * a different order here fits coefficients that look right in the fitter and wrong in the game,
+ * where it reads as a shader fault rather than as a capture that was never right.
+ *
+ * **Degree 1 and no further**, because that is what a record carries: nine coefficients and a
+ * scale in one more texel, and `SPLAT_WORDS_SH1` is what decided it.
+ */
+
+/** The l=1 basis constant, as the shader's `SH_C1`. */
+export const SH_C1 = 0.4886025119029199;
+
+/** Nine coefficients a Gaussian, interleaved by basis and then by channel. */
+export const SH1_COEFFICIENTS = 9;
+
+/** The three degree-1 basis values for a direction, the band constant folded in, into `out`. */
+export function sh1Basis(direction: ArrayLike<number>, out: Float64Array): void {
+  out[0] = -SH_C1 * (direction[1] as number);
+  out[1] = SH_C1 * (direction[2] as number);
+  out[2] = -SH_C1 * (direction[0] as number);
+}
+
+/** Where a camera stands in the world, from a 3 × 4 world-to-camera: −Rᵀ · t. */
+export function cameraCentre(worldToCamera: ArrayLike<number>, out: Float64Array): void {
+  out[0] = 0;
+  out[1] = 0;
+  out[2] = 0;
+  for (let r = 0; r < 3; r += 1) {
+    for (let c = 0; c < 3; c += 1) {
+      out[c] =
+        (out[c] as number) -
+        (worldToCamera[r * 4 + c] as number) * (worldToCamera[r * 4 + 3] as number);
+    }
+  }
+}
+
+/**
+ * The direction the band is shaded by: from `centre` to the Gaussian at `at`, normalised.
+ *
+ * A Gaussian standing exactly where the camera does has no direction to give. It answers with the
+ * camera's own forward axis rather than a division by zero — which costs nothing, because a
+ * Gaussian at the camera is behind the near plane and is not drawn.
+ *
+ * Answers the distance as well, because the gradient below divides by it: a direction is a
+ * normalisation, and how much a step moves it depends on how far away the thing is.
+ */
+export function viewDirection(
+  positions: ArrayLike<number>,
+  at: number,
+  centre: ArrayLike<number>,
+  out: Float64Array,
+): number {
+  const x = (positions[at * 3] as number) - (centre[0] as number);
+  const y = (positions[at * 3 + 1] as number) - (centre[1] as number);
+  const z = (positions[at * 3 + 2] as number) - (centre[2] as number);
+  const length = Math.sqrt(x * x + y * y + z * z);
+  if (!(length > 0)) {
+    out[0] = 0;
+    out[1] = 0;
+    out[2] = 1;
+    return 0;
+  }
+  out[0] = x / length;
+  out[1] = y / length;
+  out[2] = z / length;
+  return length;
+}
+
+/** A Gaussian's colour from a direction whose basis is already resolved, clamped at zero. */
+export function splatColour(
+  colors: ArrayLike<number>,
+  sh1: ArrayLike<number> | undefined,
+  at: number,
+  basis: ArrayLike<number>,
+  out: Float64Array,
+): void {
+  for (let c = 0; c < 3; c += 1) {
+    let value = colors[at * 3 + c] as number;
+    if (sh1 !== undefined) {
+      for (let band = 0; band < 3; band += 1) {
+        value += (basis[band] as number) * (sh1[at * SH1_COEFFICIENTS + band * 3 + c] as number);
+      }
+    }
+    out[c] = value > 0 ? value : 0;
+  }
+}
+
+/**
+ * The band's own gradient by the **direction** it was shaded from, into `out`.
+ *
+ * The colour is `−C·u_y·c₀ + C·u_z·c₁ − C·u_x·c₂` a channel, so each axis of the direction gathers
+ * one basis's coefficients. A channel the clamp flattened contributes nothing, exactly as it
+ * contributes nothing to the constant term.
+ *
+ * What the caller still owes is the step from a direction to a position: a direction is a
+ * normalisation, so only the part of a move across the line of sight turns it, and the amount it
+ * turns by falls off with distance.
+ */
+export function sh1DirectionGradient(
+  sh1: ArrayLike<number>,
+  at: number,
+  colour: ArrayLike<number>,
+  dColour: ArrayLike<number>,
+  out: Float64Array,
+): void {
+  out[0] = 0;
+  out[1] = 0;
+  out[2] = 0;
+  for (let c = 0; c < 3; c += 1) {
+    if (!((colour[c] as number) > 0)) continue;
+    const weight = (dColour[c] as number) * SH_C1;
+    const base = at * SH1_COEFFICIENTS;
+    out[0] = (out[0] as number) - weight * (sh1[base + 6 + c] as number);
+    out[1] = (out[1] as number) - weight * (sh1[base + c] as number);
+    out[2] = (out[2] as number) + weight * (sh1[base + 3 + c] as number);
+  }
+}

package/src/gaussians/optimise.ts

@@ -0,0 +1,191 @@
+/**
+ * A cloud of Gaussians fitted to a clip's frames, from a camera path and a sparse start.
+ *
+ * **The engine already knows how to draw the answer.** What comes out is `@driftengine/splats`'
+ * `SplatSource` — the same shape its `.ply` and `.sog` readers produce — so a fitted capture goes
+ * through `packSplats` and into a `.drft` beside anything else, and is drawn by the shader this
+ * package's rasteriser was written to match.
+ *
+ * **Two parameters are fitted through a transform, and it is what keeps the fit standing.** A
+ * scale is optimised as its logarithm and an opacity as its logit, so neither can be stepped past
+ * the end of its own range: a negative standard deviation is a covariance that is not a covariance,
+ * and an opacity above one is light arriving from a Gaussian that was never there. The gradients
+ * this receives are with respect to the real quantities, and the chain rule back to the transformed
+ * ones is one multiplication each.
+ *
+ * **The frames are linear and carry their own coverage.** A synthetic frame comes out of the
+ * rasteriser with both; a photograph has to be decoded from its display transform and given an
+ * alpha of one by whoever read it, because a photograph *is* fully covered and saying so is the
+ * caller's statement about their clip rather than this module's guess. A masked capture says
+ * something narrower with the same field, and the fit needs no further telling.
+ */
+import type { SplatSource } from '@driftengine/splats';
+
+import { adamStep, createAdamState } from './adam.ts';
+import { accumulateGradients, createGradients, imageLoss } from './gradients.ts';
+import {
+  chain,
+  clear,
+  createCloud,
+  harvest,
+  materialise,
+  start,
+  viewOf,
+  SPLIT_FRACTION,
+} from './parameters.ts';
+import type { RasterCamera } from './project.ts';
+import { rasteriseGaussians, type Frame } from './rasterise.ts';
+import { refineCloud } from './refine.ts';
+
+export interface OptimiseOptions {
+  /** `fx`, `fy`, `cx`, `cy`, shared by every frame, as the path was solved with. */
+  readonly intrinsics: readonly [number, number, number, number];
+  readonly width: number;
+  readonly height: number;
+  /** Three per point: where the fit starts, usually the path's own sparse reconstruction. */
+  readonly seeds: Float64Array;
+  /** The most Gaussians the answer may carry. */
+  readonly budget: number;
+  readonly iterations: number;
+  /** The engine's seeded generator: the same one twice gives the same capture. */
+  readonly random: () => number;
+  /**
+   * The standard deviation every Gaussian starts at, in metres.
+   *
+   * Left out, it is the distance from each seed to its nearest neighbour — the spacing of the
+   * cloud, which is the size at which the seeds tile what they were sampled from. **A cloud of one
+   * seed has no spacing**, and is refused rather than given a number out of the air.
+   */
+  readonly initialScale?: number;
+  /** Fit the degree-1 band as well as the constant term. */
+  readonly viewDependent?: boolean;
+  /** How often the cloud is grown and pruned. */
+  readonly refineEvery?: number;
+}
+
+/** How often the cloud is grown and pruned, where the caller does not say. */
+const DEFAULT_REFINE_EVERY = 50;
+
+/** A clip fitted to Gaussians. Nothing here is the caller's array; everything is freshly cut. */
+export function optimiseGaussians(
+  targets: readonly Frame[],
+  poses: readonly Float64Array[],
+  options: OptimiseOptions,
+): SplatSource {
+  const { intrinsics, width, height, seeds, budget, iterations, random } = options;
+  if (targets.length === 0 || targets.length !== poses.length) {
+    throw new RangeError(
+      `capture: ${targets.length} frames against ${poses.length} poses, and a fit needs one of each`,
+    );
+  }
+  const seeded = Math.floor(seeds.length / 3);
+  if (seeded === 0) throw new RangeError('capture: a fit needs at least one seed to start from');
+  if (seeded > budget) {
+    throw new RangeError(`capture: ${seeded} seeds do not fit a budget of ${budget} Gaussians`);
+  }
+  const cameras: RasterCamera[] = poses.map((worldToCamera) => ({
+    width,
+    height,
+    intrinsics,
+    worldToCamera,
+  }));
+  const extent = sceneExtent(seeds, seeded, cameras);
+  const scale = options.initialScale ?? seedSpacing(seeds, seeded);
+
+  const cloud = createCloud(budget, extent, options.viewDependent === true);
+  start(cloud, seeds, seeded, scale);
+
+  const pixels = width * height * 4;
+  const rendered = new Float64Array(pixels);
+  const dPixels = new Float64Array(pixels);
+  const gradients = createGradients(budget);
+  const adam = createAdamState();
+  const refineEvery = options.refineEvery ?? DEFAULT_REFINE_EVERY;
+  const set = viewOf(cloud, budget);
+
+  for (let iteration = 0; iteration < iterations; iteration += 1) {
+    materialise(cloud);
+    set.count = cloud.count;
+    const view = iteration % targets.length;
+    rasteriseGaussians(set, cameras[view] as RasterCamera, rendered);
+    imageLoss(rendered, targets[view] as Frame, dPixels);
+    clear(gradients, cloud.count);
+    accumulateGradients(set, cameras[view] as RasterCamera, dPixels, gradients);
+    chain(cloud, gradients);
+    adamStep(cloud.families, cloud.count, adam);
+    /*
+     * Grown and pruned between steps, never on the last one: a refinement leaves fresh Gaussians
+     * that have taken no step, and a cloud handed back in that state is one the caller is drawing
+     * before the fit has looked at it.
+     */
+    if (iteration + 1 < iterations && (iteration + 1) % refineEvery === 0) {
+      materialise(cloud);
+      refineCloud(cloud, { budget, splitAbove: SPLIT_FRACTION * extent, random });
+    }
+  }
+  materialise(cloud);
+  return harvest(cloud);
+}
+
+/**
+ * How big the capture is: the radius of the sphere holding the seeds and the cameras.
+ *
+ * **The cameras are in it deliberately.** A position's step is in metres, so it has to be a
+ * fraction of something real, and a seed cloud can be a single point — which has no size of its own
+ * and is still a scene, because the cameras looking at it are a distance away.
+ */
+function sceneExtent(seeds: Float64Array, count: number, cameras: readonly RasterCamera[]): number {
+  const points: number[][] = [];
+  for (let at = 0; at < count; at += 1) {
+    points.push([
+      seeds[at * 3] as number,
+      seeds[at * 3 + 1] as number,
+      seeds[at * 3 + 2] as number,
+    ]);
+  }
+  for (const camera of cameras) {
+    const m = camera.worldToCamera;
+    const centre = [0, 0, 0];
+    for (let r = 0; r < 3; r += 1) {
+      for (let c = 0; c < 3; c += 1) {
+        centre[c] = (centre[c] as number) - (m[r * 4 + c] as number) * (m[r * 4 + 3] as number);
+      }
+    }
+    points.push(centre);
+  }
+  const middle = [0, 0, 0];
+  for (const point of points) {
+    for (let c = 0; c < 3; c += 1) middle[c] = (middle[c] as number) + (point[c] as number);
+  }
+  for (let c = 0; c < 3; c += 1) middle[c] = (middle[c] as number) / points.length;
+  let furthest = 0;
+  for (const point of points) {
+    let square = 0;
+    for (let c = 0; c < 3; c += 1) {
+      const off = (point[c] as number) - (middle[c] as number);
+      square += off * off;
+    }
+    furthest = square > furthest ? square : furthest;
+  }
+  return Math.sqrt(furthest);
+}
+
+/** The mean distance from a seed to its nearest neighbour: the spacing the cloud was sampled at. */
+function seedSpacing(seeds: Float64Array, count: number): number {
+  if (count < 2) return 0;
+  let total = 0;
+  for (let at = 0; at < count; at += 1) {
+    let nearest = Infinity;
+    for (let other = 0; other < count; other += 1) {
+      if (other === at) continue;
+      let square = 0;
+      for (let c = 0; c < 3; c += 1) {
+        const off = (seeds[at * 3 + c] as number) - (seeds[other * 3 + c] as number);
+        square += off * off;
+      }
+      if (square < nearest) nearest = square;
+    }
+    total += Math.sqrt(nearest);
+  }
+  return total / count;
+}