@driftengine/capture 4.0.0

package/dist/testScene.js

@@ -0,0 +1,214 @@
+/**
+ * Analytic scenes rendered on the CPU, so a capture's stages can be held to geometry that is known
+ * before anything runs.
+ *
+ * **It ships rather than sitting in a test**, as `@driftengine/nav`'s test field does: a consumer
+ * porting this, or checking a device against the reference, needs the same scenes the engine's own
+ * tests use, and a fixture that exists only under `*.test.ts` cannot be imported.
+ *
+ * **A ray cast rather than a rasteriser.** Every pixel's answer is the distance along its own ray,
+ * so the depth written beside the colour is the truth rather than an interpolation — which is what
+ * makes it a fixture for depth, for triangulation and for the pose that comes out of them. The
+ * shapes are boxes and planes, which intersect in closed form, and the surfaces are a procedural
+ * checker with a seeded value noise on top: **a corner detector needs something to find**, and a
+ * flat colour would make every later test pass for the wrong reason.
+ *
+ * **What it gives up**: no shadows, no reflections, one directional light. Nothing in a capture
+ * cares — what is measured is where things are, not how they look.
+ */
+/** Where the light comes from, normalised, and how much of the surface is lit without it. */
+const LIGHT = [0.4, 0.8, -0.45];
+const AMBIENT = 0.35;
+/**
+ * A world-to-camera for an eye looking at a target, with the world's up.
+ *
+ * **The camera's axes are the ones an image has**: x to the right, **y downward** and z forward, so
+ * row zero of a frame is the top of it. Taking y upward instead renders every scene upside down,
+ * which a test of a corner's position finds and a test of a colour does not.
+ */
+export function lookAt(eye, target, up = [0, 1, 0]) {
+    const forward = normalise([target[0] - eye[0], target[1] - eye[1], target[2] - eye[2]]);
+    const sideways = cross(up, forward);
+    /*
+     * **A camera looking straight along its own up vector is refused rather than answered.** The
+     * cross product is zero there and `normalise` would hand back a zero row, so the pose comes out
+     * rank-deficient: every point in the world projects to the middle of the frame and the depth map
+     * behind it is nonsense that looks like a picture. Found by a fusion whose two vertical views
+     * quietly agreed the sphere was somewhere else.
+     */
+    const span = Math.sqrt(sideways[0] * sideways[0] + sideways[1] * sideways[1] + sideways[2] * sideways[2]);
+    if (!(span > 1e-9)) {
+        throw new RangeError('capture: a camera cannot look along its own up vector — pass an up it is not parallel to');
+    }
+    const right = normalise(sideways);
+    const down = cross(right, forward);
+    const out = new Float64Array(12);
+    const rows = [right, down, forward];
+    for (let r = 0; r < 3; r += 1) {
+        const row = rows[r];
+        out[r * 4] = row[0];
+        out[r * 4 + 1] = row[1];
+        out[r * 4 + 2] = row[2];
+        out[r * 4 + 3] = -(row[0] * eye[0] + row[1] * eye[1] + row[2] * eye[2]);
+    }
+    return out;
+}
+function cross(a, b) {
+    return [a[1] * b[2] - a[2] * b[1], a[2] * b[0] - a[0] * b[2], a[0] * b[1] - a[1] * b[0]];
+}
+function normalise(v) {
+    /* `Math.hypot` is one of the twenty-two the determinism gate refuses; a root of a sum is not. */
+    const length = Math.sqrt(v[0] * v[0] + v[1] * v[1] + v[2] * v[2]) || 1;
+    return [v[0] / length, v[1] / length, v[2] / length];
+}
+/*
+ * A value noise over the surface, from an integer hash rather than a sine: `Math.sin` is one of the
+ * twenty-two functions no two engines are obliged to agree on, and this package is inside the
+ * determinism gate — a fixture that renders differently elsewhere is not a fixture.
+ */
+function noise(x, y, z, seed) {
+    let h = (Math.imul(x | 0, 0x27d4eb2d) ^
+        Math.imul(y | 0, 0x165667b1) ^
+        Math.imul(z | 0, 0x9e3779b1) ^
+        seed) >>>
+        0;
+    h = Math.imul(h ^ (h >>> 15), 0x2c1b3c6d) >>> 0;
+    h = Math.imul(h ^ (h >>> 12), 0x297a2d39) >>> 0;
+    return ((h ^ (h >>> 15)) >>> 0) / 4294967296;
+}
+/** The colour of a point on a surface: a checker, a seeded speckle, and the light on it. */
+function shade(point, normal, seed, out, at) {
+    const checker = (Math.floor(point[0] * 2) + Math.floor(point[1] * 2) + Math.floor(point[2] * 2)) % 2 === 0
+        ? 0.75
+        : 0.35;
+    const speckle = noise(Math.floor(point[0] * 8), Math.floor(point[1] * 8), Math.floor(point[2] * 8), seed);
+    const lambert = Math.max(0, normal[0] * LIGHT[0] + normal[1] * LIGHT[1] + normal[2] * LIGHT[2]);
+    const light = AMBIENT + (1 - AMBIENT) * lambert;
+    const tone = (checker * 0.7 + speckle * 0.3) * light;
+    const tint = [1, 0.92, 0.86];
+    for (let c = 0; c < 3; c += 1) {
+        out[at + c] = Math.max(0, Math.min(255, Math.round(tone * 255 * tint[c])));
+    }
+    out[at + 3] = 255;
+}
+/** The nearest hit along a ray, or null: `[distance, normal]`. */
+function hitBox(origin, direction, box) {
+    let near = -Infinity;
+    let far = Infinity;
+    let axis = 0;
+    let sign = 1;
+    for (let a = 0; a < 3; a += 1) {
+        const d = direction[a];
+        const o = origin[a];
+        const low = box.min[a];
+        const high = box.max[a];
+        if (Math.abs(d) < 1e-12) {
+            if (o < low || o > high)
+                return null;
+            continue;
+        }
+        let first = (low - o) / d;
+        let second = (high - o) / d;
+        let towards = -1;
+        if (first > second) {
+            [first, second] = [second, first];
+            towards = 1;
+        }
+        if (first > near) {
+            near = first;
+            axis = a;
+            sign = towards;
+        }
+        far = Math.min(far, second);
+        if (near > far)
+            return null;
+    }
+    if (near <= 1e-6 || near === -Infinity)
+        return null;
+    const normal = [0, 0, 0];
+    normal[axis] = sign;
+    return { distance: near, normal };
+}
+/**
+ * `scene` through `camera` into `out`, RGBA, and the distance along the camera's own axis into
+ * `depth` where one
+ * is given — zero where the ray met nothing.
+ */
+export function renderTestScene(scene, camera, out, depth) {
+    const { width, height } = camera;
+    const [fx, fy, cx, cy] = camera.intrinsics;
+    const m = camera.worldToCamera;
+    /* The eye and the camera's axes in the world: the rotation is orthonormal, so its inverse is its transpose. */
+    const eye = [0, 0, 0];
+    for (let r = 0; r < 3; r += 1) {
+        for (let c = 0; c < 3; c += 1) {
+            eye[c] -= m[r * 4 + c] * m[r * 4 + 3];
+        }
+    }
+    const point = [0, 0, 0];
+    const direction = [0, 0, 0];
+    for (let y = 0; y < height; y += 1) {
+        for (let x = 0; x < width; x += 1) {
+            const a = (x + 0.5 - cx) / fx;
+            const b = (y + 0.5 - cy) / fy;
+            for (let c = 0; c < 3; c += 1) {
+                direction[c] = a * m[c] + b * m[4 + c] + m[8 + c];
+            }
+            const length = Math.sqrt(direction[0] * direction[0] + direction[1] * direction[1] + direction[2] * direction[2]);
+            for (let c = 0; c < 3; c += 1)
+                direction[c] = direction[c] / length;
+            let nearest = Infinity;
+            let normal = null;
+            let seed = 0;
+            for (const box of scene.boxes) {
+                const hit = hitBox(eye, direction, box);
+                if (hit !== null && hit.distance < nearest) {
+                    nearest = hit.distance;
+                    normal = hit.normal;
+                    seed = box.seed;
+                }
+            }
+            for (const plane of scene.planes) {
+                const denominator = plane.normal[0] * direction[0] +
+                    plane.normal[1] * direction[1] +
+                    plane.normal[2] * direction[2];
+                if (Math.abs(denominator) < 1e-12)
+                    continue;
+                const distance = (plane.offset -
+                    (plane.normal[0] * eye[0] +
+                        plane.normal[1] * eye[1] +
+                        plane.normal[2] * eye[2])) /
+                    denominator;
+                if (distance > 1e-6 && distance < nearest) {
+                    nearest = distance;
+                    normal = [
+                        denominator > 0 ? -plane.normal[0] : plane.normal[0],
+                        denominator > 0 ? -plane.normal[1] : plane.normal[1],
+                        denominator > 0 ? -plane.normal[2] : plane.normal[2],
+                    ];
+                    seed = plane.seed;
+                }
+            }
+            const at = (y * width + x) * 4;
+            if (normal === null) {
+                out[at] = 0;
+                out[at + 1] = 0;
+                out[at + 2] = 0;
+                out[at + 3] = 0;
+                if (depth !== undefined)
+                    depth[y * width + x] = 0;
+                continue;
+            }
+            for (let c = 0; c < 3; c += 1)
+                point[c] = eye[c] + nearest * direction[c];
+            shade(point, normal, seed, out, at);
+            /* The depth a camera means is along its axis, not along the ray. */
+            if (depth !== undefined) {
+                const along = (point[0] - eye[0]) * m[8] +
+                    (point[1] - eye[1]) * m[9] +
+                    (point[2] - eye[2]) * m[10];
+                depth[y * width + x] = along;
+            }
+        }
+    }
+}

package/dist/twoView.d.ts

@@ -0,0 +1,22 @@
+export interface RelativePoseOut {
+    /** 3 × 3 row-major: the second camera's rotation relative to the first. */
+    readonly rotation: Float64Array;
+    /** A unit direction, or zeros where the pair has no parallax to fix one. */
+    readonly translation: Float64Array;
+}
+export interface RelativePoseResult {
+    readonly inliers: number;
+    readonly model: 'essential' | 'homography';
+    /** The median angle between a point's two rays, in degrees. */
+    readonly parallax: number;
+}
+/**
+ * The points behind `count` correspondences, in the first camera's frame, into `out` (3 each), and
+ * how many landed in front of both cameras. A point that did not is left at zero.
+ */
+export declare function triangulate(a: Float64Array, b: Float64Array, count: number, intrinsics: readonly [number, number, number, number], rotation: Float64Array, translation: Float64Array, out: Float64Array): number;
+/**
+ * The pose of the second view relative to the first, from `count` correspondences in pixels.
+ * `random` is the caller's seeded generator: a capture answers the same twice.
+ */
+export declare function relativePose(a: Float64Array, b: Float64Array, count: number, intrinsics: readonly [number, number, number, number], random: () => number, out: RelativePoseOut): RelativePoseResult;

package/dist/twoView.js

@@ -0,0 +1,435 @@
+/**
+ * The pose between two views, and the points it puts in front of them.
+ *
+ * **Two models are fitted, not one.** An essential matrix explains a pair that moved; a homography
+ * explains a pair that turned, or one looking at a plane. Both are fitted by RANSAC and scored the
+ * same way, and the homography wins where it explains what the essential explains — because a
+ * camera that only turned can be fitted with a translation that reproduces both pictures exactly
+ * and means nothing. **That is the failure this exists to prevent**: the translation would go into
+ * the reconstruction as a baseline, every triangulated point would take its scale from it, and
+ * nothing downstream could tell.
+ *
+ * **So parallax is measured and reported**, as the median angle between the two rays to a point.
+ * Below a threshold the pair is a turn: the rotation is answered, the translation is zeroed, and
+ * the caller is told which model spoke.
+ *
+ * **RANSAC takes its randomness as an argument.** A capture must give the same answer twice, so the
+ * caller passes the generator — a seeded one — rather than this reaching for `Math.random`.
+ */
+import { exactAcos } from '@driftengine/core';
+import { cholesky, choleskySolve, svd3, svdN } from './math/dense.js';
+/** How many samples RANSAC draws, and how far a point may sit from its epipolar line. */
+const TRIALS = 200;
+const THRESHOLD = 1.5;
+/** A pair with less parallax than this, in degrees, is a turn rather than a move. */
+const TURNED = 1;
+/** The homography wins when it explains at least this share of what both models explain. */
+const PLANAR = 0.45;
+/** The last right-singular vector of `rows × cols`: the least-squares null direction. */
+function nullVector(rows, count, cols) {
+    const u = new Float64Array(count * cols);
+    const s = new Float64Array(cols);
+    const v = new Float64Array(cols * cols);
+    svdN(rows, count, cols, u, s, v);
+    const out = new Float64Array(cols);
+    for (let r = 0; r < cols; r += 1)
+        out[r] = v[r * cols + cols - 1];
+    return out;
+}
+/** An essential matrix from eight or more normalised correspondences. */
+function essentialFrom(a, b, picks) {
+    const rows = new Float64Array(Math.max(9, picks.length) * 9);
+    picks.forEach((at, row) => {
+        const [x1, y1] = [a[at * 2], a[at * 2 + 1]];
+        const [x2, y2] = [b[at * 2], b[at * 2 + 1]];
+        const terms = [x2 * x1, x2 * y1, x2, y2 * x1, y2 * y1, y2, x1, y1, 1];
+        for (let c = 0; c < 9; c += 1)
+            rows[row * 9 + c] = terms[c];
+    });
+    const flat = nullVector(rows, Math.max(9, picks.length), 9);
+    /* An essential matrix has two equal singular values and a third of zero: make it one. */
+    const u = new Float64Array(9);
+    const s = new Float64Array(3);
+    const v = new Float64Array(9);
+    svd3(flat, u, s, v);
+    const scale = (s[0] + s[1]) / 2;
+    const out = new Float64Array(9);
+    for (let r = 0; r < 3; r += 1) {
+        for (let c = 0; c < 3; c += 1) {
+            out[r * 3 + c] =
+                scale *
+                    (u[r * 3] * v[c * 3] +
+                        u[r * 3 + 1] * v[c * 3 + 1]);
+        }
+    }
+    return out;
+}
+/** A homography from four or more normalised correspondences. */
+function homographyFrom(a, b, picks) {
+    const count = Math.max(9, picks.length * 2);
+    const rows = new Float64Array(count * 9);
+    picks.forEach((at, pick) => {
+        const [x1, y1] = [a[at * 2], a[at * 2 + 1]];
+        const [x2, y2] = [b[at * 2], b[at * 2 + 1]];
+        const first = [-x1, -y1, -1, 0, 0, 0, x2 * x1, x2 * y1, x2];
+        const second = [0, 0, 0, -x1, -y1, -1, y2 * x1, y2 * y1, y2];
+        for (let c = 0; c < 9; c += 1) {
+            rows[pick * 2 * 9 + c] = first[c];
+            rows[(pick * 2 + 1) * 9 + c] = second[c];
+        }
+    });
+    return nullVector(rows, count, 9);
+}
+/** Sampson's distance from an essential matrix, in pixels of the first camera. */
+function essentialError(e, a, b, at, focal) {
+    const x1 = [a[at * 2], a[at * 2 + 1], 1];
+    const x2 = [b[at * 2], b[at * 2 + 1], 1];
+    const ex1 = [0, 0, 0];
+    const etx2 = [0, 0, 0];
+    for (let r = 0; r < 3; r += 1) {
+        for (let c = 0; c < 3; c += 1) {
+            ex1[r] = ex1[r] + e[r * 3 + c] * x1[c];
+            etx2[c] = etx2[c] + e[r * 3 + c] * x2[r];
+        }
+    }
+    const numerator = x2[0] * ex1[0] +
+        x2[1] * ex1[1] +
+        x2[2] * ex1[2];
+    const denominator = ex1[0] * ex1[0] +
+        ex1[1] * ex1[1] +
+        etx2[0] * etx2[0] +
+        etx2[1] * etx2[1];
+    if (denominator === 0)
+        return Infinity;
+    return (Math.abs(numerator) / Math.sqrt(denominator)) * focal;
+}
+/** The symmetric transfer error of a homography, in pixels. */
+function homographyError(h, a, b, at, focal) {
+    const apply = (m, x, y) => {
+        const u = m[0] * x + m[1] * y + m[2];
+        const v = m[3] * x + m[4] * y + m[5];
+        const w = m[6] * x + m[7] * y + m[8];
+        return w === 0 ? null : [u / w, v / w];
+    };
+    const inverse = invert3(h);
+    if (inverse === null)
+        return Infinity;
+    const forward = apply(h, a[at * 2], a[at * 2 + 1]);
+    const backward = apply(inverse, b[at * 2], b[at * 2 + 1]);
+    if (forward === null || backward === null)
+        return Infinity;
+    /* A root of a sum, not `Math.hypot`, which the determinism gate refuses. */
+    const forwardX = forward[0] - b[at * 2];
+    const forwardY = forward[1] - b[at * 2 + 1];
+    const backwardX = backward[0] - a[at * 2];
+    const backwardY = backward[1] - a[at * 2 + 1];
+    const first = Math.sqrt(forwardX * forwardX + forwardY * forwardY);
+    const second = Math.sqrt(backwardX * backwardX + backwardY * backwardY);
+    return ((first + second) / 2) * focal;
+}
+function invert3(m) {
+    const a = m[0];
+    const b = m[1];
+    const c = m[2];
+    const d = m[3];
+    const e = m[4];
+    const f = m[5];
+    const g = m[6];
+    const h = m[7];
+    const i = m[8];
+    const determinant = a * (e * i - f * h) - b * (d * i - f * g) + c * (d * h - e * g);
+    if (Math.abs(determinant) < 1e-14)
+        return null;
+    const out = new Float64Array(9);
+    out[0] = (e * i - f * h) / determinant;
+    out[1] = (c * h - b * i) / determinant;
+    out[2] = (b * f - c * e) / determinant;
+    out[3] = (f * g - d * i) / determinant;
+    out[4] = (a * i - c * g) / determinant;
+    out[5] = (c * d - a * f) / determinant;
+    out[6] = (d * h - e * g) / determinant;
+    out[7] = (b * g - a * h) / determinant;
+    out[8] = (a * e - b * d) / determinant;
+    return out;
+}
+/** One point from a pair of rays, by the linear method, into `out` at `at`. */
+function triangulatePoint(ax, ay, bx, by, rotation, translation, out, at) {
+    /* Four rows of `x × (P · X) = 0`, two from each camera, solved by their normal equations. */
+    const rows = [
+        [-1, 0, ax, 0],
+        [0, -1, ay, 0],
+        [
+            rotation[0] - bx * rotation[6],
+            rotation[1] - bx * rotation[7],
+            rotation[2] - bx * rotation[8],
+            translation[0] - bx * translation[2],
+        ],
+        [
+            rotation[3] - by * rotation[6],
+            rotation[4] - by * rotation[7],
+            rotation[5] - by * rotation[8],
+            translation[1] - by * translation[2],
+        ],
+    ];
+    const normals = new Float64Array(9);
+    const right = new Float64Array(3);
+    for (const row of rows) {
+        for (let r = 0; r < 3; r += 1) {
+            right[r] = right[r] - row[r] * row[3];
+            for (let c = 0; c < 3; c += 1) {
+                normals[r * 3 + c] =
+                    normals[r * 3 + c] + row[r] * row[c];
+            }
+        }
+    }
+    const factor = new Float64Array(9);
+    if (!cholesky(normals, 3, factor))
+        return false;
+    const point = Float64Array.from(right);
+    choleskySolve(factor, 3, point);
+    out[at * 3] = point[0];
+    out[at * 3 + 1] = point[1];
+    out[at * 3 + 2] = point[2];
+    return true;
+}
+/**
+ * The points behind `count` correspondences, in the first camera's frame, into `out` (3 each), and
+ * how many landed in front of both cameras. A point that did not is left at zero.
+ */
+export function triangulate(a, b, count, intrinsics, rotation, translation, out) {
+    const [fx, fy, cx, cy] = intrinsics;
+    let ahead = 0;
+    for (let at = 0; at < count; at += 1) {
+        const ax = (a[at * 2] - cx) / fx;
+        const ay = (a[at * 2 + 1] - cy) / fy;
+        const bx = (b[at * 2] - cx) / fx;
+        const by = (b[at * 2 + 1] - cy) / fy;
+        out[at * 3] = 0;
+        out[at * 3 + 1] = 0;
+        out[at * 3 + 2] = 0;
+        if (!triangulatePoint(ax, ay, bx, by, rotation, translation, out, at))
+            continue;
+        const z = out[at * 3 + 2];
+        if (!(z > 0)) {
+            out[at * 3] = 0;
+            out[at * 3 + 1] = 0;
+            out[at * 3 + 2] = 0;
+            continue;
+        }
+        /* And in front of the second camera too, which is what a wrong decomposition fails. */
+        let second = translation[2];
+        for (let k = 0; k < 3; k += 1) {
+            second += rotation[6 + k] * out[at * 3 + k];
+        }
+        if (second > 0)
+            ahead += 1;
+        else {
+            out[at * 3] = 0;
+            out[at * 3 + 1] = 0;
+            out[at * 3 + 2] = 0;
+        }
+    }
+    return ahead;
+}
+/** The four poses an essential matrix allows, and the one its points stand in front of. */
+function decompose(e, a, b, picks, out) {
+    const u = new Float64Array(9);
+    const s = new Float64Array(3);
+    const v = new Float64Array(9);
+    svd3(e, u, s, v);
+    const w = Float64Array.from([0, -1, 0, 1, 0, 0, 0, 0, 1]);
+    const build = (turned) => {
+        /* U · W · Vᵀ, or U · Wᵀ · Vᵀ: the two rotations an essential matrix allows. */
+        const out2 = new Float64Array(9);
+        const uw = 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 +=
+                        u[r * 3 + k] *
+                            (turned ? w[c * 3 + k] : w[k * 3 + c]);
+                }
+                uw[r * 3 + c] = sum;
+            }
+        }
+        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 += uw[r * 3 + k] * v[c * 3 + k];
+                out2[r * 3 + c] = sum;
+            }
+        }
+        /* A rotation has determinant one; the other sign is a reflection. */
+        const determinant = out2[0] *
+            (out2[4] * out2[8] - out2[5] * out2[7]) -
+            out2[1] *
+                (out2[3] * out2[8] - out2[5] * out2[6]) +
+            out2[2] *
+                (out2[3] * out2[7] - out2[4] * out2[6]);
+        if (determinant < 0)
+            for (let i = 0; i < 9; i += 1)
+                out2[i] = -out2[i];
+        return out2;
+    };
+    const direction = Float64Array.from([u[2], u[5], u[8]]);
+    const scratch = new Float64Array(picks.length * 3);
+    const subA = new Float64Array(picks.length * 2);
+    const subB = new Float64Array(picks.length * 2);
+    picks.forEach((at, i) => {
+        subA[i * 2] = a[at * 2];
+        subA[i * 2 + 1] = a[at * 2 + 1];
+        subB[i * 2] = b[at * 2];
+        subB[i * 2 + 1] = b[at * 2 + 1];
+    });
+    let best = -1;
+    for (const turned of [false, true]) {
+        const rotation = build(turned);
+        for (const sign of [1, -1]) {
+            const translation = Float64Array.from([
+                sign * direction[0],
+                sign * direction[1],
+                sign * direction[2],
+            ]);
+            const ahead = triangulate(subA, subB, picks.length, [1, 1, 0, 0], rotation, translation, scratch);
+            if (ahead > best) {
+                best = ahead;
+                out.rotation.set(rotation);
+                out.translation.set(translation);
+            }
+        }
+    }
+    return best;
+}
+/** The median angle between the two rays to each point, in degrees. */
+function parallaxOf(a, b, picks, rotation, translation) {
+    const angles = [];
+    const point = new Float64Array(3);
+    const centre = [0, 0, 0];
+    for (let k = 0; k < 3; k += 1) {
+        /* The second camera's centre in the first's frame: −Rᵀ · t. */
+        centre[k] = -(rotation[k] * translation[0] +
+            rotation[3 + k] * translation[1] +
+            rotation[6 + k] * translation[2]);
+    }
+    for (const at of picks) {
+        if (!triangulatePoint(a[at * 2], a[at * 2 + 1], b[at * 2], b[at * 2 + 1], rotation, translation, point, 0)) {
+            continue;
+        }
+        const first = [point[0], point[1], point[2]];
+        const second = [
+            first[0] - centre[0],
+            first[1] - centre[1],
+            first[2] - centre[2],
+        ];
+        const dot = first[0] * second[0] + first[1] * second[1] + first[2] * second[2];
+        const lengths = Math.sqrt(first[0] * first[0] + first[1] * first[1] + first[2] * first[2]) *
+            Math.sqrt(second[0] * second[0] + second[1] * second[1] + second[2] * second[2]);
+        if (lengths === 0)
+            continue;
+        angles.push((exactAcos(Math.min(1, Math.max(-1, dot / lengths))) * 180) / Math.PI);
+    }
+    if (angles.length === 0)
+        return 0;
+    angles.sort((p, q) => p - q);
+    return angles[Math.floor(angles.length / 2)];
+}
+/**
+ * The pose of the second view relative to the first, from `count` correspondences in pixels.
+ * `random` is the caller's seeded generator: a capture answers the same twice.
+ */
+export function relativePose(a, b, count, intrinsics, random, out) {
+    const [fx, fy, cx, cy] = intrinsics;
+    const focal = (fx + fy) / 2;
+    const normalA = new Float64Array(count * 2);
+    const normalB = new Float64Array(count * 2);
+    for (let at = 0; at < count; at += 1) {
+        normalA[at * 2] = (a[at * 2] - cx) / fx;
+        normalA[at * 2 + 1] = (a[at * 2 + 1] - cy) / fy;
+        normalB[at * 2] = (b[at * 2] - cx) / fx;
+        normalB[at * 2 + 1] = (b[at * 2 + 1] - cy) / fy;
+    }
+    const sample = (size) => {
+        const picks = [];
+        while (picks.length < size) {
+            const at = Math.min(count - 1, Math.floor(random() * count));
+            if (!picks.includes(at))
+                picks.push(at);
+        }
+        return picks;
+    };
+    const score = (fit, error, size) => {
+        let best = null;
+        let bestInliers = [];
+        let bestScore = -1;
+        for (let trial = 0; trial < TRIALS; trial += 1) {
+            const model = fit(sample(size));
+            let sum = 0;
+            const inliers = [];
+            for (let at = 0; at < count; at += 1) {
+                const off = error(model, at);
+                if (off < THRESHOLD) {
+                    inliers.push(at);
+                    /* A score that rewards a close fit rather than counting alone. */
+                    sum += THRESHOLD - off;
+                }
+            }
+            if (sum > bestScore) {
+                bestScore = sum;
+                best = model;
+                bestInliers = inliers;
+            }
+        }
+        return { model: best, inliers: bestInliers, score: bestScore };
+    };
+    const essential = score((picks) => essentialFrom(normalA, normalB, picks), (model, at) => essentialError(model, normalA, normalB, at, focal), 8);
+    const homography = score((picks) => homographyFrom(normalA, normalB, picks), (model, at) => homographyError(model, normalA, normalB, at, focal), 4);
+    const total = essential.score + homography.score;
+    const planar = total > 0 && homography.score / total > PLANAR;
+    out.rotation.set([1, 0, 0, 0, 1, 0, 0, 0, 1]);
+    out.translation.set([0, 0, 0]);
+    if (!planar && essential.model !== null && essential.inliers.length >= 8) {
+        const refined = essentialFrom(normalA, normalB, essential.inliers);
+        decompose(refined, normalA, normalB, essential.inliers, out);
+        const parallax = parallaxOf(normalA, normalB, essential.inliers, out.rotation, out.translation);
+        if (parallax >= TURNED) {
+            return { inliers: essential.inliers.length, model: 'essential', parallax };
+        }
+        /* It moved too little to say where: answer the turn and claim no baseline. */
+        out.translation.set([0, 0, 0]);
+        return { inliers: essential.inliers.length, model: 'homography', parallax };
+    }
+    if (homography.model !== null) {
+        /* A turn's homography is `R` itself once the intrinsics are out of it; scale it to a rotation. */
+        const h = homography.model;
+        const u = new Float64Array(9);
+        const s = new Float64Array(3);
+        const v = new Float64Array(9);
+        svd3(h, u, s, v);
+        const rotation = 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 += u[r * 3 + k] * v[c * 3 + k];
+                rotation[r * 3 + c] = sum;
+            }
+        }
+        const determinant = rotation[0] *
+            (rotation[4] * rotation[8] -
+                rotation[5] * rotation[7]) -
+            rotation[1] *
+                (rotation[3] * rotation[8] -
+                    rotation[5] * rotation[6]) +
+            rotation[2] *
+                (rotation[3] * rotation[7] -
+                    rotation[4] * rotation[6]);
+        if (determinant < 0)
+            for (let i = 0; i < 9; i += 1)
+                rotation[i] = -rotation[i];
+        out.rotation.set(rotation);
+        return { inliers: homography.inliers.length, model: 'homography', parallax: 0 };
+    }
+    return { inliers: 0, model: 'homography', parallax: 0 };
+}