@bubo-squared/gyroview 0.3.1 → 0.4.1

package/dist/packages/core/src/domain/format/calibration/parseOffsetString.js

@@ -1,40 +1,45 @@
 import "./layouts/CalibrationStringLayout.js";
 import { LEGACY_CALIBRATION_LAYOUT } from "./layouts/LegacyCalibrationLayout.js";
-import { MEI_CALIBRATION_LAYOUT } from "./layouts/MeiCalibrationLayout.js";
-import { POLYNOMIAL_CALIBRATION_LAYOUT } from "./layouts/PolynomialCalibrationLayout.js";
 import { GyroViewError } from "../../../shared/errors/GyroViewError.js";
+import { EXTENDED_MEI_CALIBRATION_LAYOUT, MEI_CALIBRATION_LAYOUT } from "./layouts/MeiCalibrationLayout.js";
+import { POLYNOMIAL_CALIBRATION_LAYOUT } from "./layouts/PolynomialCalibrationLayout.js";
 //#region ../../packages/core/src/domain/format/calibration/parseOffsetString.ts
 var TOKEN_SEPARATOR = "_";
-var LAYOUTS = [
+/**
+* Every calibration string version the player reads; their token counts never coincide for a
+* lens count.
+*/
+var CALIBRATION_LAYOUTS = [
 	LEGACY_CALIBRATION_LAYOUT,
 	POLYNOMIAL_CALIBRATION_LAYOUT,
-	MEI_CALIBRATION_LAYOUT
+	MEI_CALIBRATION_LAYOUT,
+	EXTENDED_MEI_CALIBRATION_LAYOUT
 ];
 /**
-* Parses `offset`, `offset_v2` and `offset_v3` strings into a calibration set with its version. The
-* layout is detected from the token count; the v6 layout (13 distortion coefficients per lens) is
-* recognised and rejected explicitly.
+* Parses a calibration string of any version into a calibration set with its version, the layout
+* detected from the token count among `layouts`: the player's, or a measurement's own readings.
 */
-function parseOffsetString(text) {
-	const numbers = text.split(TOKEN_SEPARATOR).map((token) => parseNumber(token, text));
+function parseOffsetString(text, layouts = CALIBRATION_LAYOUTS) {
+	const numbers = text.split(TOKEN_SEPARATOR).map((token) => parseNumber(token));
 	const lensCount = numbers[0] ?? 0;
-	const layout = detectLayout(numbers.length, lensCount, text);
+	const layout = detectLayout(layouts, numbers);
 	ensureVersionWordFits(layout, numbers.at(-1) ?? 0);
 	const blocks = Array.from({ length: lensCount }, (_unused, lensIndex) => lensBlock(numbers, 1 + lensIndex * layout.lensTokens));
 	return {
 		version: layout.version,
 		canvas: layout.canvasOf(numbers, blocks),
-		lenses: blocks.map((block, lensIndex) => layout.parseLens(block, lensIndex))
+		lenses: blocks.map((block, lensIndex) => layout.parseLens(block, lensIndex)),
+		radialScale: layout.radialScale
 	};
 }
 function tokenCountFor(lensCount, lensTokens, trailingTokens) {
 	return 1 + lensCount * lensTokens + trailingTokens;
 }
-function detectLayout(tokenCount, lensCount, text) {
-	const layout = LAYOUTS.find((candidate) => tokenCount === tokenCountFor(lensCount, candidate.lensTokens, candidate.trailingTokens));
+function detectLayout(layouts, numbers) {
+	const lensCount = numbers[0] ?? 0;
+	const layout = layouts.find((candidate) => numbers.length === tokenCountFor(lensCount, candidate.lensTokens, candidate.trailingTokens));
 	if (layout) return layout;
-	if (tokenCount === tokenCountFor(lensCount, 27, 1)) throw new GyroViewError("unsupported-calibration", "calibration string uses the v6 layout (13 distortion coefficients), which is not supported yet");
-	throw new GyroViewError("invalid-calibration", `calibration string has ${tokenCount} tokens for ${lensCount} lenses, matching no known layout: ${text}`);
+	throw new GyroViewError("invalid-calibration", `calibration string has ${numbers.length} tokens for ${lensCount} lenses, matching no known layout`);
 }
 function ensureVersionWordFits(layout, versionWord) {
 	const problem = layout.versionWordProblem?.(versionWord);
@@ -43,9 +48,9 @@ function ensureVersionWordFits(layout, versionWord) {
 function lensBlock(numbers, start) {
 	return (token) => numbers[start + token] ?? NaN;
 }
-function parseNumber(token, text) {
+function parseNumber(token) {
 	const value = Number(token);
-	if (token.trim() === "" || !Number.isFinite(value)) throw new GyroViewError("invalid-calibration", `calibration token "${token}" is not a finite number in: ${text}`);
+	if (token.trim() === "" || !Number.isFinite(value)) throw new GyroViewError("invalid-calibration", `calibration token "${token}" is not a finite number`);
 	return value;
 }
 //#endregion

package/dist/packages/core/src/domain/format/calibration/selectCalibration.js

@@ -1,5 +1,6 @@
 import { GyroViewError } from "../../../shared/errors/GyroViewError.js";
 import { parseOffsetString } from "./parseOffsetString.js";
+import { CALIBRATION_SOURCES } from "../info/calibrationSources.js";
 //#region ../../packages/core/src/domain/format/calibration/selectCalibration.ts
 /**
 * Only these failures mean "this string is unusable, try the next one"; anything else is a bug
@@ -7,22 +8,25 @@ import { parseOffsetString } from "./parseOffsetString.js";
 */
 var SKIPPABLE = /* @__PURE__ */ new Set(["invalid-calibration", "unsupported-calibration"]);
 /**
-* Picks the calibration a recording is stitched through: the legacy string first, whose
-* equidistant reading is the one Insta360's own stitch agrees with on the far field
-* (ADR 0023), then the Mei (v3) and polynomial (v2) strings for a recording without it. Strings
-* that cannot be used are reported, not silently dropped; having none is reported as absence,
-* not as a failure.
+* The order the calibration strings are tried in: the legacy string first, whose equidistant
+* reading is the one Insta360's own stitch agrees with on the far field (ADR 0023), then, for a
+* recording without it, the Mei strings, the newer fit (v6) before the older (v3), and the
+* polynomial (v2) last.
+*/
+var CALIBRATION_PREFERENCE = [
+	"offset",
+	"offsetV6",
+	"offsetV3",
+	"offsetV2"
+];
+/**
+* Picks the calibration a recording is stitched through, the first usable string in
+* {@link CALIBRATION_PREFERENCE}. Strings that cannot be used are reported, not silently
+* dropped; having none is reported as absence, not as a failure.
 */
 function selectCalibration(strings) {
-	const candidates = [
-		["offset", strings.offset],
-		["offset_v3", strings.offsetV3],
-		["offset_v2", strings.offsetV2]
-	];
 	const warnings = [];
-	for (const [name, text] of candidates) {
-		if (text === void 0) continue;
-		const attempt = tryParse(name, text);
+	for (const attempt of attemptsOf(strings)) {
 		if ("calibration" in attempt) return {
 			calibration: attempt.calibration,
 			warnings
@@ -34,7 +38,16 @@ function selectCalibration(strings) {
 		warnings
 	};
 }
-function tryParse(name, text) {
+/**
+* The strings the recording carries, each parsed when asked for, in preference order.
+*/
+function* attemptsOf(strings) {
+	for (const key of CALIBRATION_PREFERENCE) {
+		const text = strings[key];
+		if (text !== void 0) yield tryParse(CALIBRATION_SOURCES[key], text);
+	}
+}
+function tryParse({ name }, text) {
 	try {
 		return { calibration: parseOffsetString(text) };
 	} catch (error) {
@@ -43,4 +56,4 @@ function tryParse(name, text) {
 	}
 }
 //#endregion
-export { selectCalibration };
+export { CALIBRATION_PREFERENCE, selectCalibration };

package/dist/packages/core/src/domain/format/calibration/v6TermReading.js

@@ -0,0 +1,20 @@
+//#region ../../packages/core/src/domain/format/calibration/v6TermReading.ts
+/**
+* The five radial terms and the first tangential pair, the terms v3 carries too and reads the
+* same way: on the X5, whose v3 and v6 strings describe the same lenses, this reading draws
+* v3's image to about two canvas pixels. `p3`, `p4` and `s1` to `s4` are left out until real
+* footage says how Insta360's stitch reads them.
+*/
+var RADIAL_AND_FIRST_PAIR = ({ radial, tangential }) => {
+	const [p1, p2] = tangential;
+	return {
+		radial,
+		tangential: [{
+			p1,
+			p2
+		}],
+		thinPrism: []
+	};
+};
+//#endregion
+export { RADIAL_AND_FIRST_PAIR };

package/dist/packages/core/src/domain/format/info/calibrationSources.js

@@ -0,0 +1,27 @@
+import { InfoField } from "./infoFields.js";
+//#region ../../packages/core/src/domain/format/info/calibrationSources.ts
+/**
+* Every calibration string the player reads, declared once: the parser reads the strings by it,
+* and the calibration's selection names them by it. The record's type makes the compiler refuse
+* a string of {@link CalibrationStrings} without a source.
+*/
+var CALIBRATION_SOURCES = {
+	offset: {
+		field: InfoField.Offset,
+		name: "offset"
+	},
+	offsetV2: {
+		field: InfoField.OffsetV2,
+		name: "offset_v2"
+	},
+	offsetV3: {
+		field: InfoField.OffsetV3,
+		name: "offset_v3"
+	},
+	offsetV6: {
+		field: InfoField.OffsetV6,
+		name: "offset_v6"
+	}
+};
+//#endregion
+export { CALIBRATION_SOURCES };

package/dist/packages/core/src/domain/format/info/infoFields.js

@@ -45,7 +45,7 @@ var InfoField = {
 	*/
 	OffsetV2: 53,
 	/**
-	Unified (MEI) camera model calibration string (v3, or v6 with more coefficients).
+	Unified (MEI) camera model calibration string (v3).
 	*/
 	OffsetV3: 54,
 	IsRawGyro: 62,
@@ -64,7 +64,13 @@ var InfoField = {
 	/**
 	Observed (insta360-rs): 1 = track 0 is stream 10, 2 = track 0 is stream 00.
 	*/
-	TrackOrder: 80
+	TrackOrder: 80,
+	/**
+	Unified (MEI) camera model calibration string with more distortion terms (v6, 27 tokens a
+	lens). Named "current V6 calibration" by insta360-rs; observed beside v1 to v3 on the X5, and
+	as the only calibration string of the X6.
+	*/
+	OffsetV6: 111
 };
 var DimensionField = {
 	Width: 1,

package/dist/packages/core/src/domain/format/info/parseInfoRecord.js

@@ -1,7 +1,9 @@
 import { GyroViewError } from "../../../shared/errors/GyroViewError.js";
 import { DimensionField, FileLayoutValue, GyroConfigField, InfoField, PtsType, TrackOrderValue, WindowCropField } from "./infoFields.js";
+import { CALIBRATION_SOURCES } from "./calibrationSources.js";
 import { InfoRecordFormat } from "../constants.js";
 import { ProtobufMessage } from "../../../shared/protobuf/ProtobufMessage.js";
+import { mapRecord } from "../../../shared/mapRecord.js";
 import { milliseconds, millisecondsToSeconds } from "../../../shared/units/time.js";
 //#region ../../packages/core/src/domain/format/info/parseInfoRecord.ts
 /**
@@ -22,7 +24,7 @@ function parseInfoRecord(payload, format) {
 		firstFrameTimestamp: message.varint(InfoField.FirstFrameTimestamp),
 		readoutTime: secondsFromMilliseconds(message.double(InfoField.RollingShutterTimeMs)),
 		windowCrop: windowCropOf(message.message(InfoField.WindowCropInfo)),
-		gyroOffset: optionalMilliseconds(message.double(InfoField.GyroTimestampMs)),
+		gyroOffset: gyroOffsetOf(message),
 		gyroType: message.varint(InfoField.GyroType),
 		isRawGyro: message.boolean(InfoField.IsRawGyro),
 		preferredFrameTimeSource: frameTimeSourceOf(message.varint(InfoField.PtsType)),
@@ -34,6 +36,13 @@ function parseInfoRecord(payload, format) {
 function secondsFromMilliseconds(value) {
 	return value === void 0 ? void 0 : millisecondsToSeconds(milliseconds(value));
 }
+/**
+* The gyro's offset from the frames, only where the camera says it measured one (field 29), as
+* telemetry-parser reads it: a value in field 28 without that is not one.
+*/
+function gyroOffsetOf(message) {
+	return message.boolean(InfoField.HasGyroTimestamp) === true ? optionalMilliseconds(message.double(InfoField.GyroTimestampMs)) : void 0;
+}
 function optionalMilliseconds(value) {
 	return value === void 0 ? void 0 : milliseconds(value);
 }
@@ -56,11 +65,7 @@ function trackOrderOf(value) {
 	return value === TrackOrderValue.Stream00First ? "stream-00-first" : void 0;
 }
 function calibrationStringsOf(message) {
-	return {
-		offset: message.string(InfoField.Offset),
-		offsetV2: message.string(InfoField.OffsetV2),
-		offsetV3: message.string(InfoField.OffsetV3)
-	};
+	return mapRecord(CALIBRATION_SOURCES, (source) => message.string(source.field));
 }
 function dimensionOf(message) {
 	const width = message?.varint(DimensionField.Width);

package/dist/packages/core/src/domain/motion/imu/ImuFrame.js

@@ -82,16 +82,30 @@ function toBodyFrame(frame, imuVector) {
 	return transformVector(frame.toBody, imuVector);
 }
 /**
-* Measured on two X5 recordings (firmware 1.7 and 1.11, ADR 0009): the IMU sits rotated a quarter
-* turn about the camera's lateral axis, so the body's down is the IMU's z and the body's forward
-* is the IMU's minus y. Chosen by the world-stillness ranking in
-* `tools/integration/src/measure/imuFrameRanking.test.ts`, which every other arrangement loses.
+* The IMU rotated a quarter turn about the camera's lateral axis: the body's down is the IMU's z
+* and the body's forward is the IMU's minus y.
 */
-var X5_IMU_FRAME = measuredImuFrame("X5", [
+var QUARTER_TURN_ABOUT_LATERAL = [
 	"x",
 	"z",
 	"-y"
-]);
+];
+/**
+* Measured on two X5 recordings (firmware 1.7 and 1.11, ADR 0009), chosen by the world-stillness
+* ranking in `tools/integration/src/measure/imuFrameRanking.test.ts`, which every other
+* arrangement loses.
+*/
+var X5_IMU_FRAME = measuredImuFrame("X5", QUARTER_TURN_ABOUT_LATERAL);
+/**
+* Measured on one X6 recording (ADR 0009): the X5's arrangement, which the same ranking puts
+* first by half the unstabilized movement, the runner-up close to none.
+*/
+var X6_IMU_FRAME = measuredImuFrame("X6", QUARTER_TURN_ABOUT_LATERAL);
+/**
+* Measured on one X4 Air recording (ADR 0009): the X5's arrangement again, which the ranking puts
+* first, the aligned frame third.
+*/
+var X4_AIR_IMU_FRAME = measuredImuFrame("X4 Air", QUARTER_TURN_ABOUT_LATERAL);
 /**
 * Until a recording proves otherwise, the IMU is assumed aligned with the body.
 */
@@ -100,13 +114,21 @@ var ALIGNED_IMU_FRAME = assumedImuFrame("aligned (unverified)", [
 	"y",
 	"z"
 ]);
-var IMU_FRAMES_BY_MODEL = [["Insta360 X5", X5_IMU_FRAME]];
+/**
+* Keyed by the whole model name: a name that extends a measured one ("X4 Air" of "X4", an "X5
+* Pro") is another camera, unmeasured until a recording of it is ranked.
+*/
+var IMU_FRAMES_BY_MODEL = /* @__PURE__ */ new Map([
+	["Insta360 X4 Air", X4_AIR_IMU_FRAME],
+	["Insta360 X5", X5_IMU_FRAME],
+	["Insta360 X6", X6_IMU_FRAME]
+]);
 /**
 * The IMU frame for a recording, chosen from the camera model the file names. A starting point
 * the recording's own data can be checked against with the ranking test, never the last word.
 */
 function imuFrameFor(hints) {
-	return IMU_FRAMES_BY_MODEL.find(([prefix]) => hints.model?.startsWith(prefix))?.[1] ?? ALIGNED_IMU_FRAME;
+	return IMU_FRAMES_BY_MODEL.get(hints.model?.trim() ?? "") ?? ALIGNED_IMU_FRAME;
 }
 //#endregion
-export { ALIGNED_IMU_FRAME, X5_IMU_FRAME, assumedImuFrame, imuFrameFor, isProperRotation, toBodyFrame };
+export { ALIGNED_IMU_FRAME, X4_AIR_IMU_FRAME, X5_IMU_FRAME, X6_IMU_FRAME, assumedImuFrame, imuFrameFor, isProperRotation, toBodyFrame };

package/dist/packages/core/src/domain/motion/timing/FrameTimes.js

@@ -11,7 +11,6 @@ var GRID_TOLERANCE_FRAMES = .01;
 * Capture timing of every encoded frame, in frame order.
 */
 var FrameTimes = class FrameTimes {
-	readoutTime;
 	clock;
 	captureTimes;
 	shutterTimes;
@@ -21,7 +20,6 @@ var FrameTimes = class FrameTimes {
 		this.clock = parts.clock;
 		this.captureTimes = parts.captureTimes;
 		this.shutterTimes = parts.shutterTimes;
-		this.readoutTime = parts.readoutTime ?? seconds(0);
 		this.frameDuration = parts.frameDuration;
 	}
 	/**
@@ -47,7 +45,7 @@ var FrameTimes = class FrameTimes {
 			captureTime,
 			videoTime,
 			shutterTime,
-			midExposureVideoTime: seconds(videoTime + (shutterTime ?? 0) / 2 + this.readoutTime / 2)
+			midExposureVideoTime: seconds(videoTime + (shutterTime ?? 0) / 2)
 		};
 	}
 	/**

package/dist/packages/core/src/domain/motion/timing/frameTimeSources.js

@@ -15,7 +15,6 @@ function fromExposureRecord(context) {
 		clock,
 		captureTimes: Float64Array.from(frames.captureTimes),
 		shutterTimes: Float64Array.from(frames.shutterTimes),
-		readoutTime: context.readoutTime,
 		frameDuration: context.frameDuration
 	});
 }
@@ -30,7 +29,6 @@ function fromTrackTimestamps(context) {
 	return FrameTimes.withoutShutterTimes({
 		clock,
 		captureTimes,
-		readoutTime: context.readoutTime,
 		frameDuration: context.frameDuration
 	});
 }
@@ -45,7 +43,6 @@ function fromNominalRate(context) {
 	return FrameTimes.withoutShutterTimes({
 		clock,
 		captureTimes,
-		readoutTime: context.readoutTime,
 		frameDuration: context.frameDuration
 	});
 }

package/dist/packages/core/src/domain/optics/MeiDistortion.js

@@ -0,0 +1,43 @@
+import { ensureInvariant } from "../../shared/errors/GyroViewError.js";
+//#region ../../packages/core/src/domain/optics/MeiDistortion.ts
+/**
+* The most terms of each family a calibration string carries (`offset_v6`: five radial terms,
+* two tangential pairs, two thin-prism orders): what a renderer must hold room for.
+*/
+var MEI_TERM_CAPACITY = {
+	radial: 5,
+	tangential: 2,
+	thinPrism: 2
+};
+/**
+* Refuses a distortion with more terms of a family than {@link MEI_TERM_CAPACITY} holds: a
+* defect of the reading that made it, found where the string is read rather than when a
+* renderer packs it.
+*/
+function ensureWithinTermCapacity(distortion) {
+	ensureFamilyFits("radial", distortion.radial.length);
+	ensureFamilyFits("tangential", distortion.tangential.length);
+	ensureFamilyFits("thinPrism", distortion.thinPrism.length);
+}
+function ensureFamilyFits(family, count) {
+	const capacity = MEI_TERM_CAPACITY[family];
+	ensureInvariant(count <= capacity, `a Mei distortion has ${count} ${family} terms, more than the ${capacity} a string carries`);
+}
+function distortMei(distortion, point) {
+	const [x, y] = point;
+	const r2 = x * x + y * y;
+	const radial = 1 + r2 * seriesIn(r2, distortion.radial, (k) => k);
+	const p1 = seriesIn(r2, distortion.tangential, (pair) => pair.p1);
+	const p2 = seriesIn(r2, distortion.tangential, (pair) => pair.p2);
+	const prismX = r2 * seriesIn(r2, distortion.thinPrism, (term) => term.x);
+	const prismY = r2 * seriesIn(r2, distortion.thinPrism, (term) => term.y);
+	return [radial * x + 2 * p1 * x * y + p2 * (r2 + 2 * x * x) + prismX, radial * y + p1 * (r2 + 2 * y * y) + 2 * p2 * x * y + prismY];
+}
+/**
+* `c0 + c1 r² + c2 r⁴ + ...` of the terms' coefficients, by Horner's rule.
+*/
+function seriesIn(r2, terms, coefficientOf) {
+	return terms.reduceRight((sum, term) => sum * r2 + coefficientOf(term), 0);
+}
+//#endregion
+export { MEI_TERM_CAPACITY, distortMei, ensureWithinTermCapacity };

package/dist/packages/core/src/domain/optics/MeiModel.js

@@ -1,9 +1,10 @@
 import { HALF_FIELD_OF_VIEW } from "./opticsConstants.js";
+import { distortMei, ensureWithinTermCapacity } from "./MeiDistortion.js";
 //#region ../../packages/core/src/domain/optics/MeiModel.ts
 /**
-* Unified (Mei) omnidirectional camera model with radial-tangential distortion, as stored in
-* `offset_v3`. A direction is projected onto the unit sphere, then from a point `xi` behind the
-* sphere centre onto the normalised image plane, then distorted and scaled.
+* Unified (Mei) omnidirectional camera model with radial, tangential and thin-prism distortion,
+* as stored in `offset_v3` and `offset_v6`. A direction is projected onto the unit sphere, then from a point
+* `xi` behind the sphere centre onto the normalised image plane, then distorted and scaled.
 */
 var MeiModel = class {
 	parameters;
@@ -12,6 +13,7 @@ var MeiModel = class {
 	principalPoint;
 	constructor(parameters) {
 		this.parameters = parameters;
+		ensureWithinTermCapacity(parameters.distortion);
 		this.principalPoint = parameters.principalPoint;
 	}
 	get projection() {
@@ -24,22 +26,12 @@ var MeiModel = class {
 		const [x, y, z] = direction;
 		const depth = z + this.parameters.xi;
 		if (depth <= 0 || Math.atan2(Math.hypot(x, y), z) > this.halfFieldOfView) return void 0;
-		const normalised = [x / depth, y / depth];
-		const [distortedX, distortedY] = this.distort(normalised);
+		const [distortedX, distortedY] = distortMei(this.parameters.distortion, [x / depth, y / depth]);
 		return {
 			x: this.parameters.focal[0] * distortedX + this.principalPoint.x,
 			y: this.parameters.focal[1] * distortedY + this.principalPoint.y
 		};
 	}
-	distort([mx, my]) {
-		const [k1, k2, k3] = this.parameters.radial;
-		const [p1, p2] = this.parameters.tangential;
-		const r2 = mx * mx + my * my;
-		const radial = 1 + k1 * r2 + k2 * r2 * r2 + k3 * r2 * r2 * r2;
-		const tangentialX = 2 * p1 * mx * my + p2 * (r2 + 2 * mx * mx);
-		const tangentialY = p1 * (r2 + 2 * my * my) + 2 * p2 * mx * my;
-		return [radial * mx + tangentialX, radial * my + tangentialY];
-	}
 };
 //#endregion
 export { MeiModel };

package/dist/packages/core/src/domain/optics/scaledProjection.js

@@ -0,0 +1,30 @@
+//#region ../../packages/core/src/domain/optics/scaledProjection.ts
+/**
+* The projection with every image radius multiplied by `scale` about the principal point: the
+* Mei model's focal lengths, or the radial polynomial's coefficients. Exact at a scale of 1.
+*/
+function scaledProjection(projection, scale) {
+	switch (projection.kind) {
+		case "mei": {
+			const [fx, fy] = projection.focal;
+			return {
+				...projection,
+				focal: [fx * scale, fy * scale]
+			};
+		}
+		case "radial-polynomial": {
+			const [c1, c2, c3, c4] = projection.coefficients;
+			return {
+				...projection,
+				coefficients: [
+					c1 * scale,
+					c2 * scale,
+					c3 * scale,
+					c4 * scale
+				]
+			};
+		}
+	}
+}
+//#endregion
+export { scaledProjection };

package/dist/packages/core/src/domain/stitching/StitchingSetup.js

@@ -1,7 +1,8 @@
 import { degrees, degreesToRadians } from "../../shared/units/angle.js";
-import { GyroViewError } from "../../shared/errors/GyroViewError.js";
+import { GyroViewError, ensureInvariant } from "../../shared/errors/GyroViewError.js";
 import { lensRotation } from "../optics/lensPose.js";
 import { SEAM_RING_ANGLE } from "./seamRing.js";
+import { scaledProjection } from "../optics/scaledProjection.js";
 //#region ../../packages/core/src/domain/stitching/StitchingSetup.ts
 /**
 * Two 200-degree lenses overlap between 80 and 100 degrees from their axes; the blend spans 5
@@ -33,23 +34,31 @@ function buildStitchingSetup(inputs) {
 	const { calibration, layout } = inputs;
 	if (calibration.lenses.length !== layout.sources.length) throw new GyroViewError("unsupported-layout", `the calibration describes ${calibration.lenses.length} lenses but the layout has ${layout.sources.length}`);
 	const frames = lensFrameOrder(layout);
+	ensureInvariant(inputs.displayConversions.length === frames.length, `${inputs.displayConversions.length} display conversions for ${frames.length} frame sources`);
 	return {
 		lenses: layout.sources.map((source) => {
 			const lens = lensOf(calibration, source.lensIndex);
+			const frameSlot = frames.findIndex((key) => isSameSource(key, source));
 			return {
 				lensIndex: source.lensIndex,
-				frameSlot: frames.findIndex((key) => isSameSource(key, source)),
+				frameSlot,
 				region: source.region,
 				window: canvasWindowOf(calibration, lens),
 				rotation: lensRotation(lens),
-				projection: lens.model.projection,
-				halfFieldOfView: lens.model.halfFieldOfView
+				projection: scaledProjection(lens.model.projection, calibration.radialScale),
+				halfFieldOfView: lens.model.halfFieldOfView,
+				displayConversion: conversionAt(inputs.displayConversions, frameSlot)
 			};
 		}),
 		frameSlotCount: frames.length,
 		feather: DEFAULT_FEATHER
 	};
 }
+function conversionAt(conversions, frameSlot) {
+	const conversion = conversions[frameSlot];
+	ensureInvariant(conversion !== void 0, `no display conversion for frame slot ${frameSlot}`);
+	return conversion;
+}
 function isSameSource(key, source) {
 	return key.inputIndex === source.inputIndex && key.trackIndex === source.trackIndex;
 }

package/dist/packages/core/src/index.js

@@ -1,7 +1,7 @@
 import { degrees } from "./shared/units/angle.js";
-import "./domain/optics/EquidistantModel.js";
 import "./domain/format/calibration/CalibrationVersion.js";
 import { GYRO_VIEW_ERROR_CATEGORIES, GYRO_VIEW_ERROR_CODES, GyroViewError, asGyroViewError, ensureIndexInRange, ensureInvariant, hasErrorCode, isAbortError, isGyroViewErrorCode, messageOf } from "./shared/errors/GyroViewError.js";
+import { MEI_TERM_CAPACITY } from "./domain/optics/MeiDistortion.js";
 import { lazy } from "./shared/lazy.js";
 import { microseconds, microsecondsToSeconds, milliseconds, seconds, secondsToMicroseconds } from "./shared/units/time.js";
 import "./domain/motion/exposure/ExposureRecord.js";
@@ -48,8 +48,12 @@ import "./domain/stitching/seamMismatch.js";
 import "./domain/stitching/seamDisparity.js";
 import "./domain/stitching/seamDisparityField.js";
 import "./domain/stitching/seamJoin.js";
+import { COLOUR_PRIMARIES, MATRIX_COEFFICIENTS, TRANSFER_CHARACTERISTICS, namedOrUnspecified } from "./domain/colour/TrackColour.js";
+import { BT709_LUMINANCE, HLG_OETF, displayConversionsOf } from "./domain/colour/DisplayConversion.js";
+import { matrixCorrectionOf } from "./domain/colour/matrixCorrection.js";
 import { keysOf } from "./shared/keysOf.js";
 import { Outbox } from "./shared/events/Outbox.js";
+import "./shared/index.js";
 import { Ending, ITERATION_END } from "./shared/async/iteration.js";
 import { SourceByteStream } from "./application/download/SourceByteStream.js";
 import { startFileDownload } from "./application/download/startFileDownload.js";
@@ -64,4 +68,4 @@ import { WallClock } from "./application/playback/WallClock.js";
 import { isFlowing } from "./domain/playback/PlayerState.js";
 import { TypedEmitter } from "./shared/events/TypedEmitter.js";
 import { PlaybackSession } from "./application/playback/PlaybackSession.js";
-export { ByteRange, DEFAULT_FRAMING, DEFAULT_PICTURE_QUALITY, DEFAULT_STABILIZATION_MODE, DEFAULT_VIEW_MODE, Deferred, Ending, GYRO_VIEW_ERROR_CATEGORIES, GYRO_VIEW_ERROR_CODES, GainMatchingFrameSink, GyroViewError, IDENTITY_MATRIX3, ITERATION_END, Outbox, PICTURE_QUALITIES, PlaybackSession, RecordingBuffer, RunStop, SCREEN_CENTRE, STABILIZATION_MODES, STOPPED, SourceByteStream, StabilizingFrameSink, TypedEmitter, VIEW_MODES, WallClock, asGyroViewError, aspectOf, aspectOfArea, buildStitchingSetup, clamp, clampView, degrees, detectLensLayout, downloadPolicyFor, ensureIndexInRange, ensureInvariant, fileNameOfUrl, hasErrorCode, inspectRecording, isAbortError, isFlowing, isGyroViewErrorCode, isSameFraming, isSameView, keysOf, lazy, lensFrameOrder, locateOtherLensFile, lookAt, messageOf, microseconds, microsecondsToSeconds, milliseconds, pixelRatioCapOf, planeHalfExtentOf, probeDecoding, readRecording, readSampleTable, seconds, secondsToMicroseconds, stabilizerFor, startFileDownload, timeRecording, viewModeRulesFor, zoomStepsForPinch };
+export { BT709_LUMINANCE, ByteRange, COLOUR_PRIMARIES, DEFAULT_FRAMING, DEFAULT_PICTURE_QUALITY, DEFAULT_STABILIZATION_MODE, DEFAULT_VIEW_MODE, Deferred, Ending, GYRO_VIEW_ERROR_CATEGORIES, GYRO_VIEW_ERROR_CODES, GainMatchingFrameSink, GyroViewError, HLG_OETF, IDENTITY_MATRIX3, ITERATION_END, MATRIX_COEFFICIENTS, MEI_TERM_CAPACITY, Outbox, PICTURE_QUALITIES, PlaybackSession, RecordingBuffer, RunStop, SCREEN_CENTRE, STABILIZATION_MODES, STOPPED, SourceByteStream, StabilizingFrameSink, TRANSFER_CHARACTERISTICS, TypedEmitter, VIEW_MODES, WallClock, asGyroViewError, aspectOf, aspectOfArea, buildStitchingSetup, clamp, clampView, degrees, detectLensLayout, displayConversionsOf, downloadPolicyFor, ensureIndexInRange, ensureInvariant, fileNameOfUrl, hasErrorCode, inspectRecording, isAbortError, isFlowing, isGyroViewErrorCode, isSameFraming, isSameView, keysOf, lazy, lensFrameOrder, locateOtherLensFile, lookAt, matrixCorrectionOf, messageOf, microseconds, microsecondsToSeconds, milliseconds, namedOrUnspecified, pixelRatioCapOf, planeHalfExtentOf, probeDecoding, readRecording, readSampleTable, seconds, secondsToMicroseconds, stabilizerFor, startFileDownload, timeRecording, viewModeRulesFor, zoomStepsForPinch };

package/dist/packages/core/src/shared/index.js

@@ -0,0 +1,11 @@
+import { degrees } from "./units/angle.js";
+import { GYRO_VIEW_ERROR_CATEGORIES, GYRO_VIEW_ERROR_CODES, GyroViewError, asGyroViewError, ensureIndexInRange, ensureInvariant, hasErrorCode, isAbortError, isGyroViewErrorCode, messageOf } from "./errors/GyroViewError.js";
+import { lazy } from "./lazy.js";
+import { microseconds, microsecondsToSeconds, milliseconds, seconds, secondsToMicroseconds } from "./units/time.js";
+import "./math/Vector3.js";
+import { clamp } from "./math/clamp.js";
+import { IDENTITY_MATRIX3 } from "./math/Matrix3.js";
+import "./math/Quaternion.js";
+import { keysOf } from "./keysOf.js";
+import { Outbox } from "./events/Outbox.js";
+export { GYRO_VIEW_ERROR_CATEGORIES, GYRO_VIEW_ERROR_CODES, GyroViewError, IDENTITY_MATRIX3, Outbox, asGyroViewError, clamp, degrees, ensureIndexInRange, ensureInvariant, hasErrorCode, isAbortError, isGyroViewErrorCode, keysOf, lazy, messageOf, microseconds, microsecondsToSeconds, milliseconds, seconds, secondsToMicroseconds };

package/dist/packages/core/src/shared/mapRecord.js

@@ -0,0 +1,11 @@
+//#region ../../packages/core/src/shared/mapRecord.ts
+/**
+* A record with each value of `every` turned by `map`, under the same keys: a table declared once
+* becomes a record of what it describes, and the record's type keeps every key of the table.
+*/
+function mapRecord(every, map) {
+	const entries = Object.entries(every).map(([key, value]) => [key, map(value, key)]);
+	return Object.fromEntries(entries);
+}
+//#endregion
+export { mapRecord };