@bubo-squared/gyroview 0.4.2 → 0.6.0

package/dist/packages/core/src/domain/motion/mounting/Mounting.js

@@ -0,0 +1,117 @@
+import { HALF_TURN, QUARTER_TURN, degrees, degreesToRadians, radians } from "../../../shared/units/angle.js";
+import { ZERO_VECTOR3, addVectors, dotProduct, magnitudeOf } from "../../../shared/math/Vector3.js";
+import { multiplyMatrices, rotationAboutX, rotationAboutY, rotationAboutZ, transformVector, transposeMatrix } from "../../../shared/math/Matrix3.js";
+import { toBodyFrame } from "../imu/ImuFrame.js";
+import { indexOfLeast } from "../../../shared/math/minimum.js";
+import { measuredGravity } from "../orientation/gravity.js";
+//#region ../../packages/core/src/domain/motion/mounting/Mounting.ts
+var QUARTER_TURN_ANGLE = degreesToRadians(QUARTER_TURN);
+var MINUS_QUARTER_TURN_ANGLE = degreesToRadians(degrees(-QUARTER_TURN));
+var HALF_TURN_ANGLE = degreesToRadians(HALF_TURN);
+/**
+* Also how a recording stands whose gravity cannot be read: one without a gyro record, or whose
+* IMU frame is a guess.
+*/
+var UPRIGHT_MOUNTING = {
+	name: "upright",
+	toBody: lensLevel(radians(0))
+};
+var DOWN = [
+	0,
+	1,
+	0
+];
+var LENS_AXIS = [
+	0,
+	0,
+	1
+];
+/**
+* The four ways a camera can stand with its lens axis level, one for each body axis across it
+* that gravity can lie along.
+*/
+var LENS_LEVEL_MOUNTINGS = [
+	UPRIGHT_MOUNTING,
+	{
+		name: "upside down",
+		toBody: lensLevel(HALF_TURN_ANGLE)
+	},
+	{
+		name: "on its right side",
+		toBody: lensLevel(MINUS_QUARTER_TURN_ANGLE)
+	},
+	{
+		name: "on its left side",
+		toBody: lensLevel(QUARTER_TURN_ANGLE)
+	}
+];
+/**
+* The two ways a camera can stand with its lens axis the vertical.
+*/
+var LENS_VERTICAL_MOUNTINGS = [{
+	name: "with lens 0 up",
+	toBody: lensVertical(MINUS_QUARTER_TURN_ANGLE)
+}, {
+	name: "with lens 0 down",
+	toBody: lensVertical(QUARTER_TURN_ANGLE)
+}];
+var LENS_VERTICAL_CONE_COSINE = Math.cos(degreesToRadians(degrees(30)));
+/**
+* A half turn about the vertical faces the upright frame away from lens 0, then a turn about the
+* lens axis stands the body as it stood.
+*/
+function lensLevel(roll) {
+	return multiplyMatrices(rotationAboutZ(roll), rotationAboutY(HALF_TURN_ANGLE));
+}
+/**
+* A quarter turn about the vertical faces the upright frame along the body's minus x, then a
+* quarter turn about the lateral axis stands lens 0's axis up or down.
+*/
+function lensVertical(tilt) {
+	return multiplyMatrices(rotationAboutX(tilt), rotationAboutY(MINUS_QUARTER_TURN_ANGLE));
+}
+/**
+* The mounting whose down lies nearest the gravity the accelerometer measured whenever the camera
+* rested, read through the IMU frame: lens-vertical within its cone of the lens axis, lens-level
+* outside it. Quarter turns only, so the picture keeps every tilt the camera really took.
+* Upright for a camera that never rests, and for one whose IMU frame is a guess: read through a
+* wrong frame, gravity would stand the picture on its side or on its head.
+*/
+function mountingOf(gyro, frame) {
+	if (!frame.isVerified) return UPRIGHT_MOUNTING;
+	const gravity = restingGravitySumOf(gyro, frame);
+	const mountings = isNearLensAxis(gravity) ? LENS_VERTICAL_MOUNTINGS : LENS_LEVEL_MOUNTINGS;
+	const misalignments = mountings.map((mounting) => -dotProduct(transformVector(mounting.toBody, DOWN), gravity));
+	return mountings[indexOfLeast(misalignments)] ?? UPRIGHT_MOUNTING;
+}
+function isNearLensAxis(gravity) {
+	return Math.abs(dotProduct(gravity, LENS_AXIS)) > LENS_VERTICAL_CONE_COSINE * magnitudeOf(gravity);
+}
+/**
+* The IMU frame as it lies in the mounting's upright frame: what the camera's orientation is
+* integrated in, so that levelling and heading start from the camera as it stood. Its `toBody`
+* reads into the upright frame, which stands for the body throughout the integration.
+*/
+function uprightImuFrame(frame, mounting) {
+	return {
+		...frame,
+		toBody: multiplyMatrices(transposeMatrix(mounting.toBody), frame.toBody)
+	};
+}
+/**
+* A rotation into the mounting's upright frame, such as a stabilizer's, carried on into the body
+* the lenses are posed in.
+*/
+function rotationIntoBody(mounting, uprightRotation) {
+	return multiplyMatrices(mounting.toBody, uprightRotation);
+}
+function restingGravitySumOf(gyro, frame) {
+	let sum = ZERO_VECTOR3;
+	for (let index = 0; index < gyro.length; index += 1) {
+		const gravity = measuredGravity(toBodyFrame(frame, gyro.sampleAt(index).acceleration));
+		if (gravity) sum = addVectors(sum, gravity);
+	}
+	return sum;
+}
+//#endregion
+export { UPRIGHT_MOUNTING, mountingOf, rotationIntoBody, uprightImuFrame };

package/dist/packages/core/src/domain/motion/orientation/OrientationTrack.js

@@ -24,8 +24,10 @@ var QUATERNION_COMPONENTS = 4;
 */
 var MAX_STEP_SECONDS = .05;
 /**
-* The camera's orientation over the whole recording, body frame to world frame, one quaternion
-* per gyro sample. World: y down along gravity, z along the body's forward axis at the start.
+* The camera's orientation over the whole recording, from the frame its IMU frame reads into (the
+* body, or the upright frame of its mounting, as the player integrates it) to the world, one
+* quaternion per gyro sample. World: y down along gravity, z along that frame's forward axis at
+* the start.
 */
 var OrientationTrack = class OrientationTrack {
 	videoTimes;

package/dist/packages/core/src/domain/motion/orientation/gravity.js

@@ -94,4 +94,4 @@ function anyPerpendicular(v) {
 	];
 }
 //#endregion
-export { WORLD_DOWN, gravityCorrection, initialOrientation };
+export { WORLD_DOWN, gravityCorrection, initialOrientation, measuredGravity };

package/dist/packages/core/src/domain/view/Framing.js

@@ -1,4 +1,4 @@
-import { DEFAULT_VIEW, isSameView } from "./ViewState.js";
+import { DEFAULT_VIEW, clampView, isSameView } from "./ViewState.js";
 import { FITTED, isSameMagnification } from "./magnification.js";
 //#region ../../packages/core/src/domain/view/Framing.ts
 var DEFAULT_FRAMING = {
@@ -19,6 +19,12 @@ function withView(framing, view) {
 	};
 }
 /**
+* The framing with a page's view taken as it is given, within the sphere.
+*/
+function withPlacedView(framing, view) {
+	return withView(framing, clampView(view));
+}
+/**
 * The framing with the lens tiles' magnification replaced, the other parts kept.
 */
 function withLenses(framing, lenses) {
@@ -28,4 +34,4 @@ function withLenses(framing, lenses) {
 	};
 }
 //#endregion
-export { DEFAULT_FRAMING, isSameFraming, withLenses, withView };
+export { DEFAULT_FRAMING, isSameFraming, withLenses, withPlacedView, withView };

package/dist/packages/core/src/domain/view/ViewState.js

@@ -1,7 +1,7 @@
 import { degrees, degreesToRadians, wrapHalfTurn } from "../../shared/units/angle.js";
 import { ensureInvariant } from "../../shared/errors/GyroViewError.js";
 import { clamp } from "../../shared/math/clamp.js";
-import { multiplyMatrices, rotationAboutX, rotationAboutY } from "../../shared/math/Matrix3.js";
+import { multiplyMatrices, rotationAboutX, rotationAboutY, rotationAboutZ } from "../../shared/math/Matrix3.js";
 //#region ../../packages/core/src/domain/view/ViewState.ts
 /**
 * From a short telephoto to a wide angle: past 120 degrees a rectilinear view stretches its
@@ -14,35 +14,40 @@ var MAX_PITCH_DEGREES = 90;
 var DEFAULT_VIEW = {
 	yaw: degrees(0),
 	pitch: degrees(0),
+	roll: degrees(0),
 	fieldOfView: degrees(DEFAULT_FIELD_OF_VIEW_DEGREES)
 };
 /**
-* Keeps the view inside the sphere: yaw wrapped to (-180, 180], pitch within the poles, field
-* of view within its bounds. Non-finite angles are a programming error.
+* Keeps the view inside the sphere: yaw and roll wrapped to (-180, 180], pitch within the poles,
+* field of view within its bounds. Non-finite angles are a programming error.
 */
 function clampView(view) {
 	ensureInvariant([
 		view.yaw,
 		view.pitch,
+		view.roll,
 		view.fieldOfView
 	].every((angle) => Number.isFinite(angle)), "view angles must be finite");
 	return {
 		...view,
 		yaw: wrapHalfTurn(view.yaw),
+		roll: wrapHalfTurn(view.roll),
 		pitch: degrees(clamp(view.pitch, -90, MAX_PITCH_DEGREES)),
 		fieldOfView: degrees(clamp(view.fieldOfView, NARROWEST_DEGREES, WIDEST_DEGREES))
 	};
 }
 function isSameView(a, b) {
-	return a.yaw === b.yaw && a.pitch === b.pitch && a.fieldOfView === b.fieldOfView;
+	return a.yaw === b.yaw && a.pitch === b.pitch && a.roll === b.roll && a.fieldOfView === b.fieldOfView;
 }
 /**
-* Turns view-space directions (z forward) into camera body directions: pitch about the body's
-* lateral axis first, then yaw about its vertical axis. Body y points down, so a positive
-* rotation about x tilts the forward direction upwards.
+* Turns view-space directions (x right, y down, z forward) into camera body directions: roll
+* about the line of sight first, then pitch about the body's lateral axis, then yaw about its
+* vertical axis. Body y points down, so a positive rotation about x tilts the forward direction
+* upwards, and one about z turns the screen's right toward its bottom: clockwise.
 */
 function viewRotation(view) {
-	return multiplyMatrices(rotationAboutY(degreesToRadians(view.yaw)), rotationAboutX(degreesToRadians(view.pitch)));
+	const pointed = multiplyMatrices(rotationAboutY(degreesToRadians(view.yaw)), rotationAboutX(degreesToRadians(view.pitch)));
+	return multiplyMatrices(pointed, rotationAboutZ(degreesToRadians(view.roll)));
 }
 //#endregion
 export { DEFAULT_VIEW, clampView, isSameView, viewRotation };

package/dist/packages/core/src/domain/view/lensTilesView.js

@@ -1,6 +1,6 @@
 import { aspectOf, boundsOf, lensTiles, shiftOf } from "./screenLayout.js";
 import { FITTED, clampMagnification, magnifiedArea, magnifyAt, panMagnification } from "./magnification.js";
-import { withLenses } from "./Framing.js";
+import { withLenses, withPlacedView } from "./Framing.js";
 //#region ../../packages/core/src/domain/view/lensTilesView.ts
 /**
 * An arrow's angle moves zoomed tiles as a drag across the viewport would move them, a 90-degree
@@ -54,6 +54,7 @@ var LENS_TILES_VIEW = {
 	turn: turnLenses,
 	zoom: (framing, zoom, context) => withLenses(framing, magnifyAt(fittedTiles(context).bounds, framing.lenses, zoom)),
 	reset: (framing) => withLenses(framing, FITTED),
+	place: withPlacedView,
 	picture: (framing, context) => ({
 		kind: "lens-tiles",
 		tiles: magnifiedTiles(framing, context)

package/dist/packages/core/src/domain/view/motionLookView.js

@@ -0,0 +1,103 @@
+import { degrees, degreesToRadians, wrapHalfTurn } from "../../shared/units/angle.js";
+import { milliseconds } from "../../shared/units/time.js";
+import { angleBetweenRotations } from "../../shared/math/Matrix3.js";
+import { DEFAULT_VIEW, clampView, viewRotation } from "./ViewState.js";
+import { SCREEN_CENTRE, aspectOf } from "./screenLayout.js";
+import { lookAt, panView, zoomViewAt } from "./viewGestures.js";
+import { withView } from "./Framing.js";
+import { rectilinearPicture } from "./normalView.js";
+//#region ../../packages/core/src/domain/view/motionLookView.ts
+var READING_GAP = milliseconds(500);
+var UNSEEN_TURN = degreesToRadians(degrees(.01));
+/**
+* Where a reading turns a view the device holds. The yaw only turns by as much as the device
+* turned since the reading it continues, so a drag, Reset view or a page's yaw move the heading
+* and the device carries on from there; after a gap, and at the first reading, the yaw stays.
+* The pitch and roll are the device's, level with the real horizon. A turn too small to see
+* leaves the view as it is and keeps counting from the look last shown, at the new reading's
+* time: a phone at rest draws nothing, and a slow drift lands in full once it shows.
+*/
+function followReading(view, previous, reading) {
+	const { pitch, roll } = reading.look;
+	if (!isOneMovement(previous, reading)) return {
+		view: clampView({
+			...view,
+			pitch,
+			roll
+		}),
+		reading
+	};
+	const yaw = degrees(view.yaw + wrapHalfTurn(degrees(reading.look.yaw - previous.look.yaw)));
+	const turned = clampView({
+		...view,
+		yaw,
+		pitch,
+		roll
+	});
+	return isUnseenTurn(view, turned) ? {
+		view,
+		reading: {
+			look: previous.look,
+			at: reading.at
+		}
+	} : {
+		view: turned,
+		reading
+	};
+}
+function isOneMovement(previous, reading) {
+	return previous !== void 0 && reading.at - previous.at <= READING_GAP;
+}
+function isUnseenTurn(view, turned) {
+	return angleBetweenRotations(viewRotation(view), viewRotation(turned)) < UNSEEN_TURN;
+}
+/**
+* The view once the device lets go of it: level, looking where it looked.
+*/
+function withoutRoll(view) {
+	return {
+		...view,
+		roll: degrees(0)
+	};
+}
+/**
+* The normal view while the device holds it (ADR 0040): the device gives the pitch and the roll,
+* so drags and the arrows turn the heading alone, a zoom narrows about the centre, and a page's
+* view sets the heading and the zoom.
+*/
+var MOTION_LOOK_VIEW = {
+	isStabilized: true,
+	canPan: () => true,
+	pan: (framing, delta, { viewport }) => withView(framing, panView(framing.view, {
+		x: delta.x,
+		y: 0
+	}, viewport.width)),
+	turn: (framing, turn) => {
+		const { view } = framing;
+		return withView(framing, lookAt(view, degrees(view.yaw + turn.yaw), view.pitch));
+	},
+	zoom: (framing, zoom, { viewport }) => withView(framing, zoomViewAt(framing.view, {
+		steps: zoom.steps,
+		focus: SCREEN_CENTRE
+	}, aspectOf(viewport))),
+	reset: (framing) => withHeading(framing, {
+		...framing.view,
+		yaw: degrees(0),
+		fieldOfView: DEFAULT_VIEW.fieldOfView
+	}),
+	place: withHeading,
+	picture: rectilinearPicture
+};
+/**
+* The held view with the yaw and field of view of `view`, the device's pitch and roll kept.
+*/
+function withHeading(framing, view) {
+	const { yaw, fieldOfView } = view;
+	return withView(framing, clampView({
+		...framing.view,
+		yaw,
+		fieldOfView
+	}));
+}
+//#endregion
+export { MOTION_LOOK_VIEW, followReading, withoutRoll };

package/dist/packages/core/src/domain/view/normalView.js

@@ -2,7 +2,7 @@ import { degrees } from "../../shared/units/angle.js";
 import { DEFAULT_VIEW, viewRotation } from "./ViewState.js";
 import { WHOLE_SCREEN, aspectOf } from "./screenLayout.js";
 import { lookAt, panView, zoomViewAt } from "./viewGestures.js";
-import { withView } from "./Framing.js";
+import { withPlacedView, withView } from "./Framing.js";
 //#region ../../packages/core/src/domain/view/normalView.ts
 /**
 * A rectilinear window into the stitched sphere over the whole viewport, turned by drags and
@@ -18,12 +18,19 @@ var NORMAL_VIEW = {
 	},
 	zoom: (framing, zoom, { viewport }) => withView(framing, zoomViewAt(framing.view, zoom, aspectOf(viewport))),
 	reset: (framing) => withView(framing, DEFAULT_VIEW),
-	picture: ({ view }) => ({
+	place: withPlacedView,
+	picture: rectilinearPicture
+};
+/**
+* The view's rectilinear picture over the whole viewport, turned by its whole rotation.
+*/
+function rectilinearPicture({ view }) {
+	return {
 		kind: "rectilinear",
 		rotation: viewRotation(view),
 		fieldOfView: view.fieldOfView,
 		area: WHOLE_SCREEN
-	})
-};
+	};
+}
 //#endregion
-export { NORMAL_VIEW };
+export { NORMAL_VIEW, rectilinearPicture };

package/dist/packages/core/src/domain/view/panoramaView.js

@@ -3,7 +3,7 @@ import { rotationAboutY } from "../../shared/math/Matrix3.js";
 import { HALF, aspectOf, fittedRectangle, pictureAt, shiftOf } from "./screenLayout.js";
 import { lookAt } from "./viewGestures.js";
 import { FITTED, clampMagnification, magnifiedArea, magnifyAt, panMagnification, pictureShiftOf } from "./magnification.js";
-import { withView } from "./Framing.js";
+import { withPlacedView, withView } from "./Framing.js";
 //#region ../../packages/core/src/domain/view/panoramaView.ts
 /**
 * An equirectangular picture spans a full turn across for a half turn from top to bottom.
@@ -86,6 +86,7 @@ var PANORAMA_VIEW = {
 		...withView(framing, lookAt(framing.view, degrees(0), framing.view.pitch)),
 		panorama: FITTED
 	}),
+	place: withPlacedView,
 	picture: (framing, context) => {
 		const { fitted, panorama } = shownPanorama(framing, context);
 		return {

package/dist/packages/core/src/domain/view/screenLook.js

@@ -0,0 +1,74 @@
+import { degrees, degreesToRadians, radians, radiansToDegrees } from "../../shared/units/angle.js";
+import { clamp } from "../../shared/math/clamp.js";
+import { multiplyMatrices, rotationAboutX, rotationAboutY, rotationAboutZ } from "../../shared/math/Matrix3.js";
+//#region ../../packages/core/src/domain/view/screenLook.ts
+/**
+* View space (x right, y down, z into the screen) into the screen's frame (x right, y up, z out
+* of the screen): the viewer looks through the screen, out of its back.
+*/
+var VIEW_TO_SCREEN = [
+	1,
+	0,
+	0,
+	0,
+	-1,
+	0,
+	0,
+	0,
+	-1
+];
+/**
+* The browser's world (x east, y north, z up) into the view's (x right, y down, z forward), north
+* standing for forward: the yaw only counts changes, so any horizontal direction would do.
+*/
+var WORLD_TO_VIEW = [
+	1,
+	0,
+	0,
+	0,
+	0,
+	-1,
+	0,
+	1,
+	0
+];
+/**
+* Below this cosine of the pitch the screen looks straight up or down, where only the sum or the
+* difference of yaw and roll is defined, and each one alone would be read from rounding noise:
+* the look then takes the turn as yaw alone, within a millionth of a radian of the screen.
+*/
+var POLE_COSINE = 1e-6;
+/**
+* The rotation that turns view-space directions into the view's world for a device held this
+* way, as `viewRotation` turns them for a view.
+*/
+function screenRotationOf(attitude) {
+	const device = multiplyMatrices(multiplyMatrices(rotationAbout(rotationAboutZ, attitude.alpha), rotationAbout(rotationAboutX, attitude.beta)), rotationAbout(rotationAboutY, attitude.gamma));
+	const screen = multiplyMatrices(rotationAbout(rotationAboutZ, degrees(-attitude.screenAngle)), VIEW_TO_SCREEN);
+	return multiplyMatrices(multiplyMatrices(WORLD_TO_VIEW, device), screen);
+}
+/**
+* The yaw, pitch and roll whose `viewRotation` is the screen's rotation: the rotation
+* `Ry(yaw) Rx(pitch) Rz(roll)` read back from its entries.
+*/
+function screenLookOf(attitude) {
+	const [m00, , m02, m10, m11, m12, m20, , m22] = screenRotationOf(attitude);
+	const pitch = angleOf(Math.asin(-clamp(m12, -1, 1)));
+	return Math.hypot(m10, m11) < POLE_COSINE ? {
+		yaw: angleOf(Math.atan2(-m20, m00)),
+		pitch,
+		roll: degrees(0)
+	} : {
+		yaw: angleOf(Math.atan2(m02, m22)),
+		pitch,
+		roll: angleOf(Math.atan2(m10, m11))
+	};
+}
+function rotationAbout(rotation, angle) {
+	return rotation(degreesToRadians(angle));
+}
+function angleOf(value) {
+	return radiansToDegrees(radians(value));
+}
+//#endregion
+export { screenLookOf, screenRotationOf };

package/dist/packages/core/src/domain/view/viewModes.js

@@ -1,5 +1,6 @@
 import { LENS_TILES_VIEW } from "./lensTilesView.js";
 import { NORMAL_VIEW } from "./normalView.js";
+import { MOTION_LOOK_VIEW } from "./motionLookView.js";
 import { PANORAMA_VIEW } from "./panoramaView.js";
 //#region ../../packages/core/src/domain/view/viewModes.ts
 var RULES = {
@@ -10,5 +11,21 @@ var RULES = {
 function viewModeRulesFor(mode) {
 	return RULES[mode];
 }
+/**
+* Motion look turns the normal view alone: the flat pictures show the whole sphere or the raw
+* lenses, which a phone held up as a window has nothing to turn.
+*/
+var MOTION_LOOK_RULES = {
+	normal: MOTION_LOOK_VIEW,
+	equirectangular: void 0,
+	"raw-lenses": void 0
+};
+/**
+* The rules of a mode while the device holds the view, or none for a mode the device does not
+* turn.
+*/
+function motionLookRulesFor(mode) {
+	return MOTION_LOOK_RULES[mode];
+}
 //#endregion
-export { viewModeRulesFor };
+export { motionLookRulesFor, viewModeRulesFor };

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

@@ -15,7 +15,9 @@ import { clamp } from "./shared/math/clamp.js";
 import "./domain/motion/timing/FrameTimes.js";
 import { IDENTITY_MATRIX3 } from "./shared/math/Matrix3.js";
 import "./domain/motion/imu/ImuFrame.js";
+import "./shared/math/minimum.js";
 import "./shared/math/Quaternion.js";
+import { UPRIGHT_MOUNTING } from "./domain/motion/mounting/Mounting.js";
 import "./domain/motion/orientation/OrientationTrack.js";
 import { timeRecording } from "./application/recording/timeRecording.js";
 import "./domain/format/naming/RecordingFileName.js";
@@ -26,11 +28,12 @@ import "./domain/container/TrackSampleTable.js";
 import { readSampleTable } from "./application/recording/readSampleTable.js";
 import "./domain/stitching/LensLayout.js";
 import { detectLensLayout } from "./domain/format/layout/detectLensLayout.js";
+import { hevcCodecStringOf } from "./domain/format/mp4/hevcCodecString.js";
 import { DEFAULT_STABILIZATION_MODE, STABILIZATION_MODES } from "./domain/motion/stabilization/Stabilizer.js";
 import { stabilizerFor } from "./domain/motion/stabilization/stabilizers.js";
 import "./domain/optics/lensPose.js";
 import "./domain/optics/gainMatch.js";
-import { clampView, isSameView } from "./domain/view/ViewState.js";
+import "./domain/view/ViewState.js";
 import { DEFAULT_PICTURE_QUALITY, PICTURE_QUALITIES, pixelRatioCapOf } from "./domain/view/PictureQuality.js";
 import { DEFAULT_VIEW_MODE, VIEW_MODES } from "./domain/view/ViewMode.js";
 import { SCREEN_CENTRE, aspectOf } from "./domain/view/screenLayout.js";
@@ -38,7 +41,9 @@ import { aspectOfArea, planeHalfExtentOf } from "./domain/view/rectilinear.js";
 import { lookAt, zoomStepsForPinch } from "./domain/view/viewGestures.js";
 import "./domain/view/magnification.js";
 import { DEFAULT_FRAMING, isSameFraming } from "./domain/view/Framing.js";
-import { viewModeRulesFor } from "./domain/view/viewModes.js";
+import { followReading, withoutRoll } from "./domain/view/motionLookView.js";
+import { motionLookRulesFor, viewModeRulesFor } from "./domain/view/viewModes.js";
+import { screenLookOf } from "./domain/view/screenLook.js";
 import "./domain/stitching/seamRing.js";
 import { buildStitchingSetup, lensFrameOrder } from "./domain/stitching/StitchingSetup.js";
 import { StabilizingFrameSink } from "./application/stabilization/StabilizingFrameSink.js";
@@ -68,4 +73,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 { 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 };
+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, UPRIGHT_MOUNTING, VIEW_MODES, WallClock, asGyroViewError, aspectOf, aspectOfArea, buildStitchingSetup, clamp, degrees, detectLensLayout, displayConversionsOf, downloadPolicyFor, ensureIndexInRange, ensureInvariant, fileNameOfUrl, followReading, hasErrorCode, hevcCodecStringOf, inspectRecording, isAbortError, isFlowing, isGyroViewErrorCode, isSameFraming, keysOf, lazy, lensFrameOrder, locateOtherLensFile, lookAt, matrixCorrectionOf, messageOf, microseconds, microsecondsToSeconds, milliseconds, motionLookRulesFor, namedOrUnspecified, pixelRatioCapOf, planeHalfExtentOf, probeDecoding, readRecording, readSampleTable, screenLookOf, seconds, secondsToMicroseconds, stabilizerFor, startFileDownload, timeRecording, viewModeRulesFor, withoutRoll, zoomStepsForPinch };

package/dist/packages/core/src/shared/binary/ByteReader.js

@@ -41,6 +41,10 @@ var ByteReader = class {
 		this.ensureAvailable(offset, UINT32_SIZE);
 		return this.view.getUint32(offset, IS_LITTLE_ENDIAN);
 	}
+	uint16BeAt(offset) {
+		this.ensureAvailable(offset, UINT16_SIZE);
+		return this.view.getUint16(offset, IS_BIG_ENDIAN);
+	}
 	uint32BeAt(offset) {
 		this.ensureAvailable(offset, UINT32_SIZE);
 		return this.view.getUint32(offset, IS_BIG_ENDIAN);

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

@@ -5,6 +5,7 @@ import { microseconds, microsecondsToSeconds, milliseconds, seconds, secondsToMi
 import "./math/Vector3.js";
 import { clamp } from "./math/clamp.js";
 import { IDENTITY_MATRIX3 } from "./math/Matrix3.js";
+import "./math/minimum.js";
 import "./math/Quaternion.js";
 import { keysOf } from "./keysOf.js";
 import { Outbox } from "./events/Outbox.js";

package/dist/packages/core/src/shared/math/Matrix3.js

@@ -1,3 +1,5 @@
+import { radians } from "../units/angle.js";
+import { clamp } from "./clamp.js";
 //#region ../../packages/core/src/shared/math/Matrix3.ts
 var IDENTITY_MATRIX3 = [
 	1,
@@ -73,6 +75,23 @@ function multiplyMatrices(a, b) {
 		a20 * b02 + a21 * b12 + a22 * b22
 	];
 }
+/**
+* The transpose, which for a rotation is its inverse.
+*/
+function transposeMatrix(m) {
+	const [m00, m01, m02, m10, m11, m12, m20, m21, m22] = m;
+	return [
+		m00,
+		m10,
+		m20,
+		m01,
+		m11,
+		m21,
+		m02,
+		m12,
+		m22
+	];
+}
 function transformVector(m, v) {
 	const [m00, m01, m02, m10, m11, m12, m20, m21, m22] = m;
 	const [x, y, z] = v;
@@ -89,5 +108,14 @@ function determinantOf(m) {
 	const [m00, m01, m02, m10, m11, m12, m20, m21, m22] = m;
 	return m00 * (m11 * m22 - m12 * m21) - m01 * (m10 * m22 - m12 * m20) + m02 * (m10 * m21 - m11 * m20);
 }
+/**
+* How far rotation `b` turns from rotation `a`: the angle of `aᵀ b`, from its trace
+* (`1 + 2 cos θ`), which is the sum of the two matrices' entrywise products; clamped against
+* rounding.
+*/
+function angleBetweenRotations(a, b) {
+	const trace = a.reduce((sum, entry, index) => sum + entry * (b[index] ?? 0), 0);
+	return radians(Math.acos(clamp((trace - 1) / 2, -1, 1)));
+}
 //#endregion
-export { IDENTITY_MATRIX3, determinantOf, multiplyMatrices, rotationAboutX, rotationAboutY, rotationAboutZ, transformVector };
+export { IDENTITY_MATRIX3, angleBetweenRotations, determinantOf, multiplyMatrices, rotationAboutX, rotationAboutY, rotationAboutZ, transformVector, transposeMatrix };

package/dist/packages/core/src/shared/math/minimum.js

@@ -0,0 +1,17 @@
+//#region ../../packages/core/src/shared/math/minimum.ts
+/**
+* The index of the least of the values, the first on a tie; values that are not finite never
+* win, so a list of them all gives index 0.
+*/
+function indexOfLeast(values) {
+	let best = 0;
+	let least = Infinity;
+	for (const [index, value] of values.entries()) {
+		if (!Number.isFinite(value) || !(value < least)) continue;
+		best = index;
+		least = value;
+	}
+	return best;
+}
+//#endregion
+export { indexOfLeast };

package/dist/packages/player/src/browserPlayer.js

@@ -1,17 +1,19 @@
+import { BrowserAttitudeSensor } from "./composition/BrowserAttitudeSensor.js";
 import { browserPorts } from "./composition/browserPorts.js";
 import { buildPipeline } from "./composition/buildPipeline.js";
 import { Player } from "./player/Player.js";
 //#region ../../packages/player/src/browserPlayer.ts
 /**
-* A player composed for a browser: HTTP, blob and WebCodecs ports and the GPU pipeline, drawing
-* on the host's canvas and sounding through its audio element. What `<gyro-view>` plays with,
-* and where a page that wants the player without the element starts.
+* A player composed for a browser: HTTP, blob and WebCodecs ports, the GPU pipeline and the
+* device's attitude, drawing on the host's canvas and sounding through its audio element. What
+* `<gyro-view>` plays with, and where a page that wants the player without the element starts.
 */
 function createBrowserPlayer(host, options) {
 	return new Player({
 		host,
 		ports: browserPorts(options),
-		pipelines: buildPipeline
+		pipelines: buildPipeline,
+		attitude: new BrowserAttitudeSensor()
 	});
 }
 //#endregion