@bubo-squared/gyroview 0.3.0 → 0.4.0

package/dist/packages/core/src/domain/format/calibration/layouts/MeiCalibrationLayout.js

@@ -1,45 +1,119 @@
-import { V3Token } from "../offsetTokens.js";
+import { MeiToken, V3Token, V6Token } from "../offsetTokens.js";
 import { canvasOfFirstBlock, eulerDegrees, versionWordMismatch } from "./CalibrationStringLayout.js";
 import { CalibrationVersion } from "../CalibrationVersion.js";
 import { MeiModel } from "../../../optics/MeiModel.js";
+import { RADIAL_AND_FIRST_PAIR } from "../v6TermReading.js";
 //#region ../../packages/core/src/domain/format/calibration/layouts/MeiCalibrationLayout.ts
 /**
-* `offset_v3`: `xi fx fy cx cy yaw pitch roll tx ty tz k1 k2 k3 p1 p2 width height type` per
-* lens, then a version word with 3 in its high 16 bits.
+* The layout of a Mei string version, a version word after its lens blocks.
 */
-var MEI_CALIBRATION_LAYOUT = {
+function meiLayout(format) {
+	return {
+		version: format.version,
+		lensTokens: format.lensTokens,
+		trailingTokens: 1,
+		radialScale: format.radialScale,
+		versionWordProblem: (versionWord) => versionWordMismatch(versionWord, format.version),
+		parseLens: (block, lensIndex) => meiLensOf(block, lensIndex, format),
+		canvasOf: (_numbers, blocks) => canvasOfFirstBlock(blocks, format.canvasTokens.width, format.canvasTokens.height)
+	};
+}
+function meiLensOf(block, lensIndex, format) {
+	return {
+		lensIndex,
+		model: new MeiModel({
+			xi: block(MeiToken.Xi),
+			focal: [block(MeiToken.FocalX), block(MeiToken.FocalY)],
+			principalPoint: {
+				x: block(MeiToken.CenterX),
+				y: block(MeiToken.CenterY)
+			},
+			distortion: format.distortionOf(block)
+		}),
+		orientation: eulerDegrees(block(MeiToken.Yaw), block(MeiToken.Pitch), block(MeiToken.Roll)),
+		translation: [
+			block(MeiToken.TranslationX),
+			block(MeiToken.TranslationY),
+			block(MeiToken.TranslationZ)
+		]
+	};
+}
+/**
+* `offset_v3`: the Mei tokens, then `k1 k2 k3 p1 p2 width height type` per lens, and a version
+* word with 3 in its high 16 bits. Drawn as read: the X5, the only camera seen to write it,
+* stitches through its legacy string (ADR 0023).
+*/
+var MEI_CALIBRATION_LAYOUT = meiLayout({
 	version: CalibrationVersion.Mei,
 	lensTokens: 19,
-	trailingTokens: 1,
-	versionWordProblem: (versionWord) => versionWordMismatch(versionWord, CalibrationVersion.Mei),
-	parseLens(block, lensIndex) {
-		return {
-			lensIndex,
-			model: new MeiModel({
-				xi: block(V3Token.Xi),
-				focal: [block(V3Token.FocalX), block(V3Token.FocalY)],
-				principalPoint: {
-					x: block(V3Token.CenterX),
-					y: block(V3Token.CenterY)
-				},
-				radial: [
-					block(V3Token.K1),
-					block(V3Token.K2),
-					block(V3Token.K3)
-				],
-				tangential: [block(V3Token.P1), block(V3Token.P2)]
-			}),
-			orientation: eulerDegrees(block(V3Token.Yaw), block(V3Token.Pitch), block(V3Token.Roll)),
-			translation: [
-				block(V3Token.TranslationX),
-				block(V3Token.TranslationY),
-				block(V3Token.TranslationZ)
-			]
-		};
+	canvasTokens: {
+		width: V3Token.CanvasWidth,
+		height: V3Token.CanvasHeight
 	},
-	canvasOf(_numbers, blocks) {
-		return canvasOfFirstBlock(blocks, V3Token.CanvasWidth, V3Token.CanvasHeight);
-	}
-};
+	distortionOf: (block) => ({
+		radial: [
+			block(V3Token.K1),
+			block(V3Token.K2),
+			block(V3Token.K3)
+		],
+		tangential: [{
+			p1: block(V3Token.P1),
+			p2: block(V3Token.P2)
+		}],
+		thinPrism: []
+	}),
+	radialScale: 1
+});
+/**
+* The radial scale a v6 reading is drawn at, measured on the X6, the one camera seen to stitch
+* through it: Insta360 Studio's far field and the seam's far bins agree on it to 0.3 percent
+* (ADR 0023). Provisional, from one unit; the X5's own v6 strings would want 1.02 to 1.04, but
+* the X5 stitches through its legacy string.
+*/
+var V6_RADIAL_SCALE = 1.008;
+/**
+* `offset_v6`: the Mei tokens, then `k1..k5 p1..p4 s1..s4 width height type` per lens, and a
+* version word with 6 in its high 16 bits; its distortion tokens read by `reading` (ADR 0032).
+*/
+function extendedMeiLayout(reading) {
+	return meiLayout({
+		version: CalibrationVersion.ExtendedMei,
+		lensTokens: 27,
+		canvasTokens: {
+			width: V6Token.CanvasWidth,
+			height: V6Token.CanvasHeight
+		},
+		distortionOf: (block) => reading(v6DistortionTokensOf(block)),
+		radialScale: V6_RADIAL_SCALE
+	});
+}
+/**
+* `offset_v6` as the player reads it: its radial terms and first tangential pair (ADR 0032,
+* provisional).
+*/
+var EXTENDED_MEI_CALIBRATION_LAYOUT = extendedMeiLayout(RADIAL_AND_FIRST_PAIR);
+function v6DistortionTokensOf(block) {
+	return {
+		radial: [
+			block(V6Token.K1),
+			block(V6Token.K2),
+			block(V6Token.K3),
+			block(V6Token.K4),
+			block(V6Token.K5)
+		],
+		tangential: [
+			block(V6Token.P1),
+			block(V6Token.P2),
+			block(V6Token.P3),
+			block(V6Token.P4)
+		],
+		thinPrism: [
+			block(V6Token.S1),
+			block(V6Token.S2),
+			block(V6Token.S3),
+			block(V6Token.S4)
+		]
+	};
+}
 //#endregion
-export { MEI_CALIBRATION_LAYOUT };
+export { EXTENDED_MEI_CALIBRATION_LAYOUT, MEI_CALIBRATION_LAYOUT, extendedMeiLayout, meiLayout };

package/dist/packages/core/src/domain/format/calibration/layouts/PolynomialCalibrationLayout.js

@@ -11,6 +11,7 @@ var POLYNOMIAL_CALIBRATION_LAYOUT = {
 	version: CalibrationVersion.Polynomial,
 	lensTokens: 16,
 	trailingTokens: 1,
+	radialScale: 1,
 	versionWordProblem: (versionWord) => versionWordMismatch(versionWord, CalibrationVersion.Polynomial),
 	parseLens(block, lensIndex) {
 		return {

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

@@ -31,7 +31,10 @@ var V2Token = {
 	CanvasHeight: 14,
 	LensType: 15
 };
-var V3Token = {
+/**
+* The tokens every Mei string (v3, v6) starts its lens block with; each version's own follow.
+*/
+var MeiToken = {
 	Xi: 0,
 	FocalX: 1,
 	FocalY: 2,
@@ -42,7 +45,9 @@ var V3Token = {
 	Roll: 7,
 	TranslationX: 8,
 	TranslationY: 9,
-	TranslationZ: 10,
+	TranslationZ: 10
+};
+var V3Token = {
 	K1: 11,
 	K2: 12,
 	K3: 13,
@@ -53,8 +58,32 @@ var V3Token = {
 	LensType: 18
 };
 /**
+* `offset_v6` after the Mei tokens: five radial terms, four tangential and four thin-prism
+* tokens, then the canvas and the lens type. The order is insta360-rs's (`docs/INSV_FORMAT.md`),
+* confirmed on the X5, whose v6 and v3 strings agree on the Mei tokens, the canvas and the lens
+* type (ADR 0032).
+*/
+var V6Token = {
+	K1: 11,
+	K2: 12,
+	K3: 13,
+	K4: 14,
+	K5: 15,
+	P1: 16,
+	P2: 17,
+	P3: 18,
+	P4: 19,
+	S1: 20,
+	S2: 21,
+	S3: 22,
+	S4: 23,
+	CanvasWidth: 24,
+	CanvasHeight: 25,
+	LensType: 26
+};
+/**
 * Tokens after the lens blocks. v1 ends with canvas width, canvas height and a version word;
-* v2 and v3 end with the version word only.
+* v2, v3 and v6 end with the version word only.
 */
 var V1Trailing = {
 	CanvasWidth: 0,
@@ -62,4 +91,4 @@ var V1Trailing = {
 	VersionWord: 2
 };
 //#endregion
-export { V1Token, V1Trailing, V2Token, V3Token };
+export { MeiToken, V1Token, V1Trailing, V2Token, V3Token, V6Token };

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,25 @@ 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);
 /**
 * Until a recording proves otherwise, the IMU is assumed aligned with the body.
 */
@@ -100,7 +109,7 @@ var ALIGNED_IMU_FRAME = assumedImuFrame("aligned (unverified)", [
 	"y",
 	"z"
 ]);
-var IMU_FRAMES_BY_MODEL = [["Insta360 X5", X5_IMU_FRAME]];
+var IMU_FRAMES_BY_MODEL = [["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.
@@ -109,4 +118,4 @@ function imuFrameFor(hints) {
 	return IMU_FRAMES_BY_MODEL.find(([prefix]) => hints.model?.startsWith(prefix))?.[1] ?? ALIGNED_IMU_FRAME;
 }
 //#endregion
-export { ALIGNED_IMU_FRAME, X5_IMU_FRAME, assumedImuFrame, imuFrameFor, isProperRotation, toBodyFrame };
+export { ALIGNED_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 };