@photivra/engine 0.5.1 → 1.0.0

package/dist/motion/capture-rotation-temporal-quadrature.js

@@ -0,0 +1,131 @@
+// SPDX-License-Identifier: Apache-2.0
+/**
+ * Module boundary and integration notes.
+ * Builds deterministic temporal quadrature nodes for pure-camera-rotation capture geometry over each
+ * destination point's local exposure interval. The first model uses an equal-width midpoint rule.
+ * Every node reuses calculateCaptureRotationInverseMappings(), so the instantaneous geometry has one
+ * authoritative implementation. No radiance is evaluated here. normalizedTimeWeight is suitable for a
+ * downstream time-average under a uniform temporal-response assumption, while timeMeasureSeconds is
+ * the local dt measure for a downstream time integral. Neither weight includes shutter transmission,
+ * scene flicker, sensor response, radiometric calibration or any other throughput term. The function
+ * intentionally reports no numerical integration error estimate: geometry alone cannot determine the
+ * error in a scene-radiance integral. Downstream renderers may compare increasing temporal sample
+ * counts in their own radiance domain when convergence evidence is required.
+ * @see docs/MOTION_AND_SIGNAL.md for equations, coordinate/unit conventions, blockers and support
+ * limits.
+ */
+import { approximationResult } from "../core/calculation-result.js";
+import { InvalidScientificInputError, requirePositiveInteger } from "../core/validation.js";
+import { calculateCaptureRotationInverseMappings } from "./capture-rotation-inverse-mapping.js";
+function midpointPhase(index, sampleCount) {
+    return (index + 0.5) / sampleCount;
+}
+/**
+ * Builds deterministic temporal quadrature nodes for pure-camera-rotation
+ * capture geometry over each destination point's local exposure interval.
+ *
+ * The first model uses an equal-width midpoint rule. Every node reuses
+ * calculateCaptureRotationInverseMappings(), so the instantaneous geometry has
+ * one authoritative implementation.
+ *
+ * No radiance is evaluated here. normalizedTimeWeight is suitable for a
+ * downstream time-average under a uniform temporal-response assumption, while
+ * timeMeasureSeconds is the local dt measure for a downstream time integral.
+ * Neither weight includes shutter transmission, scene flicker, sensor
+ * response, radiometric calibration or any other throughput term.
+ *
+ * The function intentionally reports no numerical integration error estimate:
+ * geometry alone cannot determine the error in a scene-radiance integral.
+ * Downstream renderers may compare increasing temporal sample counts in their
+ * own radiance domain when convergence evidence is required.
+ */
+export function calculateCaptureRotationTemporalQuadrature(input) {
+    requirePositiveInteger("temporalSampleCount", input.temporalSampleCount);
+    if (!Array.isArray(input.samplePointsNative) ||
+        input.samplePointsNative.length === 0) {
+        throw new InvalidScientificInputError("samplePointsNative must be a non-empty array.");
+    }
+    const totalNodeCount = input.temporalSampleCount * input.samplePointsNative.length;
+    if (!Number.isSafeInteger(totalNodeCount)) {
+        throw new InvalidScientificInputError("temporalSampleCount × samplePointsNative.length must be a safe integer.");
+    }
+    const { temporalSampleCount, ...instantaneousInput } = input;
+    const phaseResults = Array.from({ length: temporalSampleCount }, (_, temporalSampleIndex) => {
+        const localExposurePhase = midpointPhase(temporalSampleIndex, temporalSampleCount);
+        return calculateCaptureRotationInverseMappings({
+            ...instantaneousInput,
+            localExposurePhase
+        });
+    });
+    const firstResult = phaseResults[0];
+    if (firstResult === undefined) {
+        throw new InvalidScientificInputError("At least one temporal quadrature node is required.");
+    }
+    const normalizedTimeWeight = 1 / temporalSampleCount;
+    const points = firstResult.value.samples.map((firstSample, pointIndex) => {
+        const durationSeconds = firstSample.localExposureWindow.durationSeconds;
+        const timeMeasureSeconds = durationSeconds / temporalSampleCount;
+        const nodes = phaseResults.map((phaseResult, temporalSampleIndex) => {
+            const sample = phaseResult.value.samples[pointIndex];
+            if (sample === undefined) {
+                throw new InvalidScientificInputError("Instantaneous inverse-mapping sample alignment failed.");
+            }
+            const localExposurePhase = midpointPhase(temporalSampleIndex, temporalSampleCount);
+            return {
+                temporalSampleIndex,
+                localExposurePhase,
+                captureTimeSecondsFromReference: sample.captureTimeSecondsFromReference,
+                normalizedTimeWeight,
+                timeMeasureSeconds,
+                referenceImagePointMm: {
+                    ...sample.referenceImagePointMm
+                },
+                inverseDisplacementImagePlaneMm: {
+                    ...sample.inverseDisplacementImagePlaneMm
+                },
+                inverseDisplacementNativeSamples: {
+                    ...sample.inverseDisplacementNativeSamples
+                },
+                inverseDisplacementOrientedSamples: {
+                    ...sample.inverseDisplacementOrientedSamples
+                }
+            };
+        });
+        return {
+            destinationPointNative: {
+                ...firstSample.destinationPointNative
+            },
+            destinationImagePointMm: {
+                ...firstSample.destinationImagePointMm
+            },
+            localExposureWindow: {
+                ...firstSample.localExposureWindow
+            },
+            nodes
+        };
+    });
+    return approximationResult({
+        timeReference: "first-opening-boundary-phase",
+        quadratureScheme: "uniform-midpoint",
+        temporalResponseModel: "uniform-over-local-exposure",
+        temporalSampleCount,
+        outputMeaning: "temporal-geometry-quadrature-nodes",
+        points,
+        componentProvenance: {
+            instantaneousInverseMapping: firstResult.provenance
+        }
+    }, "capture-rotation-temporal-quadrature", "1.0.0", [
+        "Each destination native point retains its own validated local exposure interval.",
+        "Temporal nodes use a deterministic equal-width midpoint rule with phases (i + 0.5) / N and therefore do not sample the exact opening/closing boundaries.",
+        "Normalized temporal weights sum approximately to one and represent a uniform time-average measure only.",
+        "Seconds-valued temporal measures sum approximately to the local exposure duration and represent dt only.",
+        "Uniform temporal response is an explicit approximation; shutter transmission ramps, scene flicker, sensor response and radiometric throughput are not included.",
+        "Every node delegates instantaneous geometry to calculateCaptureRotationInverseMappings(); no second camera-motion equation is introduced.",
+        "Sensor data-readout timing and readout/exposure linkage metadata do not alter the exposure integral unless a future explicit image-formation model consumes them.",
+        "Reference rays may leave the active source frame under motion and are not clamped.",
+        "No radiance, photon count, blur kernel, PSF, source resampling or output pixel value is calculated.",
+        "No geometry-only convergence/error estimate is reported because temporal integration error depends on the downstream radiance/visibility function as well as motion.",
+        "Camera translation, scene-depth parallax, subject motion/deformation, occlusion changes, flash/flicker, shutter shock and non-uniform temporal response remain separate future work."
+    ]);
+}
+//# sourceMappingURL=capture-rotation-temporal-quadrature.js.map

package/dist/motion/capture-rotation-temporal-quadrature.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"capture-rotation-temporal-quadrature.js","sourceRoot":"","sources":["../../src/motion/capture-rotation-temporal-quadrature.ts"],"names":[],"mappings":"AAAA,sCAAsC;AAEtC;;;;;;;;;;;;;;GAcG;AAEH,OAAO,EACL,mBAAmB,EAGpB,MAAM,+BAA+B,CAAC;AACvC,OAAO,EACL,2BAA2B,EAC3B,sBAAsB,EACvB,MAAM,uBAAuB,CAAC;AAG/B,OAAO,EACL,uCAAuC,EAExC,MAAM,uCAAuC,CAAC;AA0E/C,SAAS,aAAa,CAAC,KAAa,EAAE,WAAmB;IACvD,OAAO,CAAC,KAAK,GAAG,GAAG,CAAC,GAAG,WAAW,CAAC;AACrC,CAAC;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,MAAM,UAAU,0CAA0C,CACxD,KAAsD;IAEtD,sBAAsB,CACpB,qBAAqB,EACrB,KAAK,CAAC,mBAAmB,CAC1B,CAAC;IAEF,IACE,CAAC,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,kBAAkB,CAAC;QACxC,KAAK,CAAC,kBAAkB,CAAC,MAAM,KAAK,CAAC,EACrC,CAAC;QACD,MAAM,IAAI,2BAA2B,CACnC,+CAA+C,CAChD,CAAC;IACJ,CAAC;IAED,MAAM,cAAc,GAClB,KAAK,CAAC,mBAAmB,GAAG,KAAK,CAAC,kBAAkB,CAAC,MAAM,CAAC;IAC9D,IAAI,CAAC,MAAM,CAAC,aAAa,CAAC,cAAc,CAAC,EAAE,CAAC;QAC1C,MAAM,IAAI,2BAA2B,CACnC,yEAAyE,CAC1E,CAAC;IACJ,CAAC;IAED,MAAM,EACJ,mBAAmB,EACnB,GAAG,kBAAkB,EACtB,GAAG,KAAK,CAAC;IAEV,MAAM,YAAY,GAAG,KAAK,CAAC,IAAI,CAC7B,EAAE,MAAM,EAAE,mBAAmB,EAAE,EAC/B,CAAC,CAAC,EAAE,mBAAmB,EAAE,EAAE;QACzB,MAAM,kBAAkB,GAAG,aAAa,CACtC,mBAAmB,EACnB,mBAAmB,CACpB,CAAC;QAEF,OAAO,uCAAuC,CAAC;YAC7C,GAAG,kBAAkB;YACrB,kBAAkB;SACnB,CAAC,CAAC;IACL,CAAC,CACF,CAAC;IAEF,MAAM,WAAW,GAAG,YAAY,CAAC,CAAC,CAAC,CAAC;IACpC,IAAI,WAAW,KAAK,SAAS,EAAE,CAAC;QAC9B,MAAM,IAAI,2BAA2B,CACnC,oDAAoD,CACrD,CAAC;IACJ,CAAC;IAED,MAAM,oBAAoB,GAAG,CAAC,GAAG,mBAAmB,CAAC;IAErD,MAAM,MAAM,GAAG,WAAW,CAAC,KAAK,CAAC,OAAO,CAAC,GAAG,CAC1C,CAAC,WAAW,EAAE,UAAU,EAAE,EAAE;QAC1B,MAAM,eAAe,GACnB,WAAW,CAAC,mBAAmB,CAAC,eAAe,CAAC;QAClD,MAAM,kBAAkB,GACtB,eAAe,GAAG,mBAAmB,CAAC;QAExC,MAAM,KAAK,GAAG,YAAY,CAAC,GAAG,CAC5B,CAAC,WAAW,EAAE,mBAAmB,EAAE,EAAE;YACnC,MAAM,MAAM,GAAG,WAAW,CAAC,KAAK,CAAC,OAAO,CAAC,UAAU,CAAC,CAAC;YACrD,IAAI,MAAM,KAAK,SAAS,EAAE,CAAC;gBACzB,MAAM,IAAI,2BAA2B,CACnC,wDAAwD,CACzD,CAAC;YACJ,CAAC;YAED,MAAM,kBAAkB,GAAG,aAAa,CACtC,mBAAmB,EACnB,mBAAmB,CACpB,CAAC;YAEF,OAAO;gBACL,mBAAmB;gBACnB,kBAAkB;gBAClB,+BAA+B,EAC7B,MAAM,CAAC,+BAA+B;gBACxC,oBAAoB;gBACpB,kBAAkB;gBAClB,qBAAqB,EAAE;oBACrB,GAAG,MAAM,CAAC,qBAAqB;iBAChC;gBACD,+BAA+B,EAAE;oBAC/B,GAAG,MAAM,CAAC,+BAA+B;iBAC1C;gBACD,gCAAgC,EAAE;oBAChC,GAAG,MAAM,CAAC,gCAAgC;iBAC3C;gBACD,kCAAkC,EAAE;oBAClC,GAAG,MAAM,CAAC,kCAAkC;iBAC7C;aACF,CAAC;QACJ,CAAC,CACF,CAAC;QAEF,OAAO;YACL,sBAAsB,EAAE;gBACtB,GAAG,WAAW,CAAC,sBAAsB;aACtC;YACD,uBAAuB,EAAE;gBACvB,GAAG,WAAW,CAAC,uBAAuB;aACvC;YACD,mBAAmB,EAAE;gBACnB,GAAG,WAAW,CAAC,mBAAmB;aACnC;YACD,KAAK;SACN,CAAC;IACJ,CAAC,CACF,CAAC;IAEF,OAAO,mBAAmB,CACxB;QACE,aAAa,EAAE,8BAA8B;QAC7C,gBAAgB,EAAE,kBAAkB;QACpC,qBAAqB,EAAE,6BAA6B;QACpD,mBAAmB;QACnB,aAAa,EAAE,oCAAoC;QACnD,MAAM;QACN,mBAAmB,EAAE;YACnB,2BAA2B,EAAE,WAAW,CAAC,UAAU;SACpD;KACF,EACD,sCAAsC,EACtC,OAAO,EACP;QACE,kFAAkF;QAClF,0JAA0J;QAC1J,yGAAyG;QACzG,0GAA0G;QAC1G,iKAAiK;QACjK,2IAA2I;QAC3I,mKAAmK;QACnK,oFAAoF;QACpF,qGAAqG;QACrG,sKAAsK;QACtK,sLAAsL;KACvL,CACF,CAAC;AACJ,CAAC"}

package/dist/motion/capture-rotation-trajectory.d.ts

@@ -0,0 +1,113 @@
+/**
+ * Module boundary and integration notes.
+ * Evaluates pure-camera-rotation trajectories for stationary reference rays over each point's local
+ * exposure window. This is a temporal-geometry bridge, not a finished rolling-shutter image mapping.
+ * The native sample point defines where a stationary world ray would land in the reference
+ * global-shutter image at the first opening-boundary phase. The existing camera-rotation model is then
+ * evaluated at that point's local exposure start and end. Sensor data-readout timing is intentionally
+ * absent. A camera/mode-specific relationship between sensor readout and exposure boundaries requires
+ * a separate explicit contract; this function never assumes one. A later renderer-facing
+ * rolling-shutter warp must solve the image mapping consistently with capture-location-dependent time
+ * and integrate over the local exposure interval. The endpoint chord returned here must not be treated
+ * as a blur kernel or as an inverse destination-to-source sampling map.
+ * @see docs/MOTION_AND_SIGNAL.md for equations, coordinate/unit conventions, blockers and support
+ * limits.
+ */
+import { type CalculationProvenance, type CalculationResult } from "../core/calculation-result.js";
+import { type RasterPoint } from "../output/capture-geometry.js";
+import { type CalculateCaptureExposureWindowsInput } from "../sensor/exposure-window.js";
+import type { SensorImagingArea } from "../sensor/sensor-geometry.js";
+import { type CameraAngularVelocityRadPerSec, type ImagePlanePointMm } from "./camera-rotation.js";
+export interface CalculateCaptureRotationTrajectoriesInput extends CalculateCaptureExposureWindowsInput {
+    /**
+     * Physical photosensitive imaging area associated with nativeRaster.
+     */
+    imagingArea: SensorImagingArea;
+    /** Physical focal length in millimetres. */
+    focalLengthMm: number;
+    /** Optional focus distance in metres for focus-aware projection distance. */
+    focusDistanceM?: number;
+    /**
+     * Constant physical camera angular velocity resolved in camera axes at the
+     * first opening-boundary phase.
+     */
+    angularVelocityRadPerSec: CameraAngularVelocityRadPerSec;
+    /**
+     * Native points whose stationary-reference-ray trajectories should be
+     * evaluated. Required and non-empty for this trajectory API.
+     */
+    samplePointsNative: readonly RasterPoint[];
+}
+export interface CaptureRotationTrajectoryEndpoint {
+    timeSecondsFromCaptureReference: number;
+    mappedImagePointMm: ImagePlanePointMm;
+    deltaFromReferenceMm: {
+        x: number;
+        y: number;
+        distance: number;
+    };
+}
+export interface CaptureRotationTrajectorySample {
+    pointNative: RasterPoint;
+    /**
+     * Image-plane position of the stationary world ray at the capture reference
+     * time (the first opening-boundary phase).
+     */
+    referenceImagePointMm: ImagePlanePointMm;
+    localExposureWindow: {
+        startSecondsFromCaptureReference: number;
+        endSecondsFromCaptureReference: number;
+        durationSeconds: number;
+        openingNormalizedScanPosition: number | null;
+        closingNormalizedScanPosition: number | null;
+    };
+    atLocalExposureStart: CaptureRotationTrajectoryEndpoint;
+    atLocalExposureEnd: CaptureRotationTrajectoryEndpoint;
+    /**
+     * Chord between the two trajectory endpoints.
+     *
+     * This is not a blur kernel, integrated exposure, or rolling-shutter warp.
+     */
+    localExposureTrajectoryEndpointDeltaMm: {
+        x: number;
+        y: number;
+        distance: number;
+    };
+}
+export interface CaptureRotationTrajectories {
+    timeReference: "first-opening-boundary-phase";
+    trajectoryMeaning: "forward-stationary-reference-ray";
+    imagingArea: SensorImagingArea;
+    activeCaptureRect: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    };
+    samples: readonly CaptureRotationTrajectorySample[];
+    componentProvenance: {
+        exposureWindows: CalculationProvenance;
+        cameraRotation: CalculationProvenance;
+    };
+}
+/**
+ * Evaluates pure-camera-rotation trajectories for stationary reference rays
+ * over each point's local exposure window.
+ *
+ * This is a temporal-geometry bridge, not a finished rolling-shutter image
+ * mapping. The native sample point defines where a stationary world ray would
+ * land in the reference global-shutter image at the first opening-boundary
+ * phase. The existing camera-rotation model is then evaluated at that point's
+ * local exposure start and end.
+ *
+ * Sensor data-readout timing is intentionally absent. A camera/mode-specific
+ * relationship between sensor readout and exposure boundaries requires a
+ * separate explicit contract; this function never assumes one.
+ *
+ * A later renderer-facing rolling-shutter warp must solve the image mapping
+ * consistently with capture-location-dependent time and integrate over the
+ * local exposure interval. The endpoint chord returned here must not be treated
+ * as a blur kernel or as an inverse destination-to-source sampling map.
+ */
+export declare function calculateCaptureRotationTrajectories(input: CalculateCaptureRotationTrajectoriesInput): CalculationResult<CaptureRotationTrajectories>;
+//# sourceMappingURL=capture-rotation-trajectory.d.ts.map

package/dist/motion/capture-rotation-trajectory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"capture-rotation-trajectory.d.ts","sourceRoot":"","sources":["../../src/motion/capture-rotation-trajectory.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,EAEL,KAAK,qBAAqB,EAC1B,KAAK,iBAAiB,EACvB,MAAM,+BAA+B,CAAC;AAKvC,OAAO,EAGL,KAAK,WAAW,EACjB,MAAM,+BAA+B,CAAC;AACvC,OAAO,EAEL,KAAK,oCAAoC,EAE1C,MAAM,8BAA8B,CAAC;AACtC,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,8BAA8B,CAAC;AACtE,OAAO,EAEL,KAAK,8BAA8B,EAEnC,KAAK,iBAAiB,EACvB,MAAM,sBAAsB,CAAC;AAE9B,MAAM,WAAW,yCACf,SAAQ,oCAAoC;IAC5C;;OAEG;IACH,WAAW,EAAE,iBAAiB,CAAC;IAC/B,4CAA4C;IAC5C,aAAa,EAAE,MAAM,CAAC;IACtB,6EAA6E;IAC7E,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB;;;OAGG;IACH,wBAAwB,EAAE,8BAA8B,CAAC;IACzD;;;OAGG;IACH,kBAAkB,EAAE,SAAS,WAAW,EAAE,CAAC;CAC5C;AAED,MAAM,WAAW,iCAAiC;IAChD,+BAA+B,EAAE,MAAM,CAAC;IACxC,kBAAkB,EAAE,iBAAiB,CAAC;IACtC,oBAAoB,EAAE;QACpB,CAAC,EAAE,MAAM,CAAC;QACV,CAAC,EAAE,MAAM,CAAC;QACV,QAAQ,EAAE,MAAM,CAAC;KAClB,CAAC;CACH;AAED,MAAM,WAAW,+BAA+B;IAC9C,WAAW,EAAE,WAAW,CAAC;IACzB;;;OAGG;IACH,qBAAqB,EAAE,iBAAiB,CAAC;IACzC,mBAAmB,EAAE;QACnB,gCAAgC,EAAE,MAAM,CAAC;QACzC,8BAA8B,EAAE,MAAM,CAAC;QACvC,eAAe,EAAE,MAAM,CAAC;QACxB,6BAA6B,EAAE,MAAM,GAAG,IAAI,CAAC;QAC7C,6BAA6B,EAAE,MAAM,GAAG,IAAI,CAAC;KAC9C,CAAC;IACF,oBAAoB,EAAE,iCAAiC,CAAC;IACxD,kBAAkB,EAAE,iCAAiC,CAAC;IACtD;;;;OAIG;IACH,sCAAsC,EAAE;QACtC,CAAC,EAAE,MAAM,CAAC;QACV,CAAC,EAAE,MAAM,CAAC;QACV,QAAQ,EAAE,MAAM,CAAC;KAClB,CAAC;CACH;AAED,MAAM,WAAW,2BAA2B;IAC1C,aAAa,EAAE,8BAA8B,CAAC;IAC9C,iBAAiB,EAAE,kCAAkC,CAAC;IACtD,WAAW,EAAE,iBAAiB,CAAC;IAC/B,iBAAiB,EAAE;QACjB,CAAC,EAAE,MAAM,CAAC;QACV,CAAC,EAAE,MAAM,CAAC;QACV,KAAK,EAAE,MAAM,CAAC;QACd,MAAM,EAAE,MAAM,CAAC;KAChB,CAAC;IACF,OAAO,EAAE,SAAS,+BAA+B,EAAE,CAAC;IACpD,mBAAmB,EAAE;QACnB,eAAe,EAAE,qBAAqB,CAAC;QACvC,cAAc,EAAE,qBAAqB,CAAC;KACvC,CAAC;CACH;AAgHD;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,oCAAoC,CAClD,KAAK,EAAE,yCAAyC,GAC/C,iBAAiB,CAAC,2BAA2B,CAAC,CAyFhD"}

package/dist/motion/capture-rotation-trajectory.js

@@ -0,0 +1,168 @@
+// SPDX-License-Identifier: Apache-2.0
+/**
+ * Module boundary and integration notes.
+ * Evaluates pure-camera-rotation trajectories for stationary reference rays over each point's local
+ * exposure window. This is a temporal-geometry bridge, not a finished rolling-shutter image mapping.
+ * The native sample point defines where a stationary world ray would land in the reference
+ * global-shutter image at the first opening-boundary phase. The existing camera-rotation model is then
+ * evaluated at that point's local exposure start and end. Sensor data-readout timing is intentionally
+ * absent. A camera/mode-specific relationship between sensor readout and exposure boundaries requires
+ * a separate explicit contract; this function never assumes one. A later renderer-facing
+ * rolling-shutter warp must solve the image mapping consistently with capture-location-dependent time
+ * and integrate over the local exposure interval. The endpoint chord returned here must not be treated
+ * as a blur kernel or as an inverse destination-to-source sampling map.
+ * @see docs/MOTION_AND_SIGNAL.md for equations, coordinate/unit conventions, blockers and support
+ * limits.
+ */
+import { approximationResult } from "../core/calculation-result.js";
+import { InvalidScientificInputError, requirePositiveFinite } from "../core/validation.js";
+import { mapOrientedPhysicalUvToImagePlanePoint, resolveCaptureGeometry } from "../output/capture-geometry.js";
+import { calculateCaptureExposureWindows } from "../sensor/exposure-window.js";
+import { calculateCameraRotationImageMapping } from "./camera-rotation.js";
+function requireNonEmptySamples(samplePointsNative) {
+    if (!Array.isArray(samplePointsNative) || samplePointsNative.length === 0) {
+        throw new InvalidScientificInputError("samplePointsNative must be a non-empty array.");
+    }
+}
+function nativePointToReferenceImagePlane(point, activeCaptureRect, activePhysicalBoundsFromOpticalAxisMm) {
+    const u = (point.x - activeCaptureRect.x) / activeCaptureRect.width;
+    const v = (point.y - activeCaptureRect.y) / activeCaptureRect.height;
+    return mapOrientedPhysicalUvToImagePlanePoint({
+        uv: { u, v },
+        orientedPhysicalBoundsFromOpticalAxisMm: activePhysicalBoundsFromOpticalAxisMm,
+        orientation: "landscape"
+    });
+}
+function endpointFromMapping(mapping) {
+    return {
+        timeSecondsFromCaptureReference: mapping.timeSecondsFromExposureStart,
+        mappedImagePointMm: { ...mapping.mappedImagePointMm },
+        deltaFromReferenceMm: { ...mapping.deltaMm }
+    };
+}
+function trajectorySample(point, exposure, referenceImagePointMm, input) {
+    const common = {
+        focalLengthMm: input.focalLengthMm,
+        imagePointMm: referenceImagePointMm,
+        angularVelocityRadPerSec: input.angularVelocityRadPerSec,
+        ...(input.focusDistanceM === undefined
+            ? {}
+            : { focusDistanceM: input.focusDistanceM })
+    };
+    const start = calculateCameraRotationImageMapping({
+        ...common,
+        timeSecondsFromExposureStart: exposure.startOffsetSecondsFromOpeningReference
+    });
+    const end = calculateCameraRotationImageMapping({
+        ...common,
+        timeSecondsFromExposureStart: exposure.endOffsetSecondsFromOpeningReference
+    });
+    const endpointDeltaX = end.value.mappedImagePointMm.x -
+        start.value.mappedImagePointMm.x;
+    const endpointDeltaY = end.value.mappedImagePointMm.y -
+        start.value.mappedImagePointMm.y;
+    return {
+        sample: {
+            pointNative: { ...point },
+            referenceImagePointMm: { ...referenceImagePointMm },
+            localExposureWindow: {
+                startSecondsFromCaptureReference: exposure.startOffsetSecondsFromOpeningReference,
+                endSecondsFromCaptureReference: exposure.endOffsetSecondsFromOpeningReference,
+                durationSeconds: exposure.localExposureDurationSeconds,
+                openingNormalizedScanPosition: exposure.openingNormalizedScanPosition,
+                closingNormalizedScanPosition: exposure.closingNormalizedScanPosition
+            },
+            atLocalExposureStart: endpointFromMapping(start.value),
+            atLocalExposureEnd: endpointFromMapping(end.value),
+            localExposureTrajectoryEndpointDeltaMm: {
+                x: endpointDeltaX,
+                y: endpointDeltaY,
+                distance: Math.hypot(endpointDeltaX, endpointDeltaY)
+            }
+        },
+        rotationProvenance: start.provenance
+    };
+}
+/**
+ * Evaluates pure-camera-rotation trajectories for stationary reference rays
+ * over each point's local exposure window.
+ *
+ * This is a temporal-geometry bridge, not a finished rolling-shutter image
+ * mapping. The native sample point defines where a stationary world ray would
+ * land in the reference global-shutter image at the first opening-boundary
+ * phase. The existing camera-rotation model is then evaluated at that point's
+ * local exposure start and end.
+ *
+ * Sensor data-readout timing is intentionally absent. A camera/mode-specific
+ * relationship between sensor readout and exposure boundaries requires a
+ * separate explicit contract; this function never assumes one.
+ *
+ * A later renderer-facing rolling-shutter warp must solve the image mapping
+ * consistently with capture-location-dependent time and integrate over the
+ * local exposure interval. The endpoint chord returned here must not be treated
+ * as a blur kernel or as an inverse destination-to-source sampling map.
+ */
+export function calculateCaptureRotationTrajectories(input) {
+    requirePositiveFinite("imagingArea.widthMm", input.imagingArea.widthMm);
+    requirePositiveFinite("imagingArea.heightMm", input.imagingArea.heightMm);
+    requirePositiveFinite("focalLengthMm", input.focalLengthMm);
+    requireNonEmptySamples(input.samplePointsNative);
+    const exposureWindows = calculateCaptureExposureWindows({
+        nativeRaster: input.nativeRaster,
+        ...(input.activeCaptureRect === undefined
+            ? {}
+            : { activeCaptureRect: input.activeCaptureRect }),
+        shutterMechanism: input.shutterMechanism,
+        nominalExposureDurationSeconds: input.nominalExposureDurationSeconds,
+        opening: input.opening,
+        closing: input.closing,
+        samplePointsNative: input.samplePointsNative
+    });
+    const geometry = resolveCaptureGeometry({
+        imagingArea: input.imagingArea,
+        nativeRaster: input.nativeRaster,
+        orientation: "landscape",
+        activeCaptureRect: exposureWindows.value.activeCaptureRect
+    }).value;
+    const exposureByPoint = exposureWindows.value.samples;
+    const samples = [];
+    let rotationProvenance;
+    input.samplePointsNative.forEach((point, index) => {
+        const exposure = exposureByPoint[index];
+        if (exposure === undefined) {
+            throw new InvalidScientificInputError("Exposure-window sample alignment failed.");
+        }
+        const referenceImagePointMm = nativePointToReferenceImagePlane(point, geometry.activeCapture.nativeRect, geometry.activeCapture.physicalBoundsFromOpticalAxisMm);
+        const resolved = trajectorySample(point, exposure, referenceImagePointMm, input);
+        samples.push(resolved.sample);
+        rotationProvenance ??= resolved.rotationProvenance;
+    });
+    if (rotationProvenance === undefined) {
+        throw new InvalidScientificInputError("At least one rotation trajectory sample is required.");
+    }
+    return approximationResult({
+        timeReference: "first-opening-boundary-phase",
+        trajectoryMeaning: "forward-stationary-reference-ray",
+        imagingArea: { ...input.imagingArea },
+        activeCaptureRect: {
+            ...exposureWindows.value.activeCaptureRect
+        },
+        samples,
+        componentProvenance: {
+            exposureWindows: exposureWindows.provenance,
+            cameraRotation: rotationProvenance
+        }
+    }, "capture-rotation-exposure-trajectory", "1.0.0", [
+        "The first opening-boundary phase is explicitly bound to t=0 of the low-level camera-rotation model for this composition only.",
+        "Each native point identifies a stationary world ray by its reference image-plane location at the capture reference time.",
+        "Local exposure start/end times come only from the capture exposure-window contract.",
+        "Sensor data-readout timing does not participate and is never assumed to equal an exposure boundary.",
+        "Camera angular velocity is constant and resolved in camera axes at the first opening-boundary phase.",
+        "Only pure camera rotation is modeled; camera translation, scene depth parallax, subject motion, deformation and occlusion changes are excluded.",
+        "The returned start/end mappings are a forward stationary-ray trajectory, not a rolling-shutter image warp.",
+        "The trajectory endpoint chord is not an integrated blur kernel and may not represent the curved path between endpoints.",
+        "A later inverse renderer warp must solve capture-location-dependent timing consistently rather than evaluating one forward displacement at the destination coordinate.",
+        "Exposure integration over the full local interval remains future work."
+    ]);
+}
+//# sourceMappingURL=capture-rotation-trajectory.js.map

package/dist/motion/capture-rotation-trajectory.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"capture-rotation-trajectory.js","sourceRoot":"","sources":["../../src/motion/capture-rotation-trajectory.ts"],"names":[],"mappings":"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"}

package/dist/motion/capture-translation-parallax-temporal-quadrature.d.ts

@@ -0,0 +1,119 @@
+/**
+ * Module boundary and integration notes.
+ * Evaluates depth-dependent translational parallax at deterministic midpoint nodes over each scene
+ * point's authoritative local exposure window. The model is deliberately per point. Camera translation
+ * and optional subject translation coexist through relative linear motion; neither is redefined as the
+ * other. Camera rotation and visibility/occlusion remain separate models.
+ * @see docs/MOTION_AND_SIGNAL.md for equations, coordinate/unit conventions, blockers and support
+ * limits.
+ */
+import { type CalculationResult } from "../core/calculation-result.js";
+import { type CaptureOrientation, type RasterPoint } from "../output/capture-geometry.js";
+import type { Vector3 } from "../schema/scene.js";
+import type { ResolvedCaptureModeTiming } from "../sensor/capture-mode-timing.js";
+import type { SensorImagingArea } from "../sensor/sensor-geometry.js";
+export interface CaptureTranslationParallaxSceneSample {
+    sampleId: string;
+    /**
+     * Native destination point whose authoritative local exposure window applies
+     * to this scene sample.
+     */
+    destinationPointNative: RasterPoint;
+    /**
+     * Metric point position in the camera axes at the first-opening-boundary
+     * phase. +X right, +Y up, +Z forward/away from the camera.
+     */
+    positionCameraM: Vector3;
+    /**
+     * Optional constant subject/world-point velocity in the same initial camera
+     * axes. Omitted means stationary world point.
+     */
+    subjectVelocityMps?: Vector3;
+}
+export interface CalculateCaptureTranslationParallaxTemporalQuadratureInput {
+    timing: ResolvedCaptureModeTiming;
+    imagingArea: SensorImagingArea;
+    focalLengthMm: number;
+    focusDistanceM?: number;
+    orientation: CaptureOrientation;
+    /**
+     * Constant physical camera-center translation in camera axes at the capture
+     * reference phase. Rotation is intentionally separate.
+     */
+    cameraTranslationVelocityMps: Vector3;
+    temporalSampleCount: number;
+    sceneSamples: readonly CaptureTranslationParallaxSceneSample[];
+}
+export interface CaptureTranslationParallaxTemporalNode {
+    temporalSampleIndex: number;
+    localExposurePhase: number;
+    captureTimeSecondsFromReference: number;
+    normalizedTimeWeight: number;
+    timeMeasureSeconds: number;
+    relativePositionCameraM: Vector3;
+    mappedImagePointMm: {
+        x: number;
+        y: number;
+    };
+    deltaFromReferenceImagePlaneMm: {
+        x: number;
+        y: number;
+        distance: number;
+    };
+    deltaNativeSamples: {
+        x: number;
+        y: number;
+        distance: number;
+    };
+    deltaOrientedSamples: {
+        x: number;
+        y: number;
+        distance: number;
+    };
+}
+export interface CaptureTranslationParallaxTemporalSample {
+    sampleId: string;
+    destinationPointNative: RasterPoint;
+    referencePositionCameraM: Vector3;
+    subjectVelocityMps: Vector3;
+    localExposureWindow: {
+        startSecondsFromCaptureReference: number;
+        endSecondsFromCaptureReference: number;
+        durationSeconds: number;
+    };
+    referenceImagePointMm: {
+        x: number;
+        y: number;
+    };
+    nodes: readonly CaptureTranslationParallaxTemporalNode[];
+}
+export interface CaptureTranslationParallaxTemporalQuadrature {
+    timeReference: "first-opening-boundary-phase";
+    timingProfileIdentity: {
+        profileId: string;
+        profileVersion: string;
+        captureModeId: string;
+    };
+    orientation: CaptureOrientation;
+    projectionDistanceMm: number;
+    temporalSampleCount: number;
+    cameraTranslationVelocityMps: Vector3;
+    samples: readonly CaptureTranslationParallaxTemporalSample[];
+    geometryModel: "metric-depth-dependent-constant-linear-translation";
+    relativeMotionComposition: "subject-minus-camera-translation";
+    metricSceneDepthRequired: true;
+    oneGlobalHomographyAuthorized: false;
+    cameraRotationComposed: false;
+    visibilityOcclusionModeled: false;
+    sensorReadoutTimingUsedAsExposureTiming: false;
+}
+/**
+ * Evaluates depth-dependent translational parallax at deterministic midpoint
+ * nodes over each scene point's authoritative local exposure window.
+ *
+ * The model is deliberately per point. Camera translation and optional subject
+ * translation coexist through relative linear motion; neither is redefined as
+ * the other. Camera rotation and visibility/occlusion remain separate models.
+ */
+export declare function calculateCaptureTranslationParallaxTemporalQuadrature(input: CalculateCaptureTranslationParallaxTemporalQuadratureInput): CalculationResult<CaptureTranslationParallaxTemporalQuadrature>;
+//# sourceMappingURL=capture-translation-parallax-temporal-quadrature.d.ts.map

package/dist/motion/capture-translation-parallax-temporal-quadrature.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"capture-translation-parallax-temporal-quadrature.d.ts","sourceRoot":"","sources":["../../src/motion/capture-translation-parallax-temporal-quadrature.ts"],"names":[],"mappings":"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"}