@photivra/engine 0.5.1 → 0.6.0

package/dist/motion/capture-rotation-inverse-mapping.js

@@ -0,0 +1,171 @@
+// SPDX-License-Identifier: Apache-2.0
+import { approximationResult } from "../core/calculation-result.js";
+import { InvalidScientificInputError, requirePositiveFinite } from "../core/validation.js";
+import { mapOrientedPhysicalUvToImagePlanePoint, resolveCaptureGeometry, transformNativeRasterVectorToOriented } from "../output/capture-geometry.js";
+import { calculateCaptureExposureWindows } from "../sensor/exposure-window.js";
+import { calculateSensorGeometryMetrics } from "../sensor/sensor-geometry.js";
+import { calculateInverseCameraRotationImageMapping } from "./camera-rotation.js";
+function requireExposurePhase(value) {
+    if (!Number.isFinite(value) || value < 0 || value > 1) {
+        throw new InvalidScientificInputError("localExposurePhase must be finite and within [0, 1].");
+    }
+}
+function requireNonEmptySamples(value) {
+    if (!Array.isArray(value) || value.length === 0) {
+        throw new InvalidScientificInputError("samplePointsNative must be a non-empty array.");
+    }
+}
+function nativePointToImagePlane(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 captureTimeAtPhase(exposure, phase) {
+    return (exposure.startOffsetSecondsFromOpeningReference +
+        phase * exposure.localExposureDurationSeconds);
+}
+/**
+ * Calculates an instantaneous inverse capture-scan mapping for stationary
+ * world rays under pure camera rotation.
+ *
+ * The destination native sensor location is authoritative for local exposure
+ * timing. At an explicit phase within that local window, the captured
+ * image-plane ray is analytically mapped back to the reference image plane at
+ * the first opening-boundary phase.
+ *
+ * No fixed-point/iterative solve is used because pure rotation under the
+ * existing constant-axis model has an analytic inverse once destination
+ * location and local capture time are known.
+ *
+ * This function is not a finite-exposure renderer and does not integrate blur.
+ * Sensor data-readout timing is deliberately absent; exposure boundaries are
+ * the only timing source.
+ */
+export function calculateCaptureRotationInverseMappings(input) {
+    requirePositiveFinite("imagingArea.widthMm", input.imagingArea.widthMm);
+    requirePositiveFinite("imagingArea.heightMm", input.imagingArea.heightMm);
+    requirePositiveFinite("focalLengthMm", input.focalLengthMm);
+    requireExposurePhase(input.localExposurePhase);
+    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: input.orientation,
+        activeCaptureRect: exposureWindows.value.activeCaptureRect
+    }).value;
+    const sensorGeometry = calculateSensorGeometryMetrics({
+        imagingArea: input.imagingArea,
+        nativeRaster: input.nativeRaster
+    });
+    const pitchXmm = sensorGeometry.value.sampling.pitchXMicrometers / 1000;
+    const pitchYmm = sensorGeometry.value.sampling.pitchYMicrometers / 1000;
+    let inverseRotationProvenance;
+    const samples = input.samplePointsNative.map((point, index) => {
+        const exposure = exposureWindows.value.samples[index];
+        if (exposure === undefined) {
+            throw new InvalidScientificInputError("Exposure-window sample alignment failed.");
+        }
+        const destinationImagePointMm = nativePointToImagePlane(point, geometry.activeCapture.nativeRect, geometry.activeCapture.physicalBoundsFromOpticalAxisMm);
+        const captureTimeSecondsFromReference = captureTimeAtPhase(exposure, input.localExposurePhase);
+        const inverse = calculateInverseCameraRotationImageMapping({
+            focalLengthMm: input.focalLengthMm,
+            imagePointMm: destinationImagePointMm,
+            timeSecondsFromExposureStart: captureTimeSecondsFromReference,
+            angularVelocityRadPerSec: input.angularVelocityRadPerSec,
+            ...(input.focusDistanceM === undefined
+                ? {}
+                : { focusDistanceM: input.focusDistanceM }),
+            samplingPitchMicrometers: {
+                x: sensorGeometry.value.sampling.pitchXMicrometers,
+                y: sensorGeometry.value.sampling.pitchYMicrometers
+            }
+        });
+        inverseRotationProvenance ??= inverse.provenance;
+        const nativeX = inverse.value.deltaMm.x / pitchXmm;
+        const nativeY = -inverse.value.deltaMm.y / pitchYmm;
+        const inverseDisplacementNativeSamples = {
+            x: nativeX,
+            y: nativeY,
+            distance: Math.hypot(nativeX, nativeY)
+        };
+        const orientedVector = transformNativeRasterVectorToOriented({
+            vector: {
+                x: inverseDisplacementNativeSamples.x,
+                y: inverseDisplacementNativeSamples.y
+            },
+            orientation: input.orientation
+        });
+        const inverseDisplacementOrientedSamples = {
+            ...orientedVector,
+            distance: Math.hypot(orientedVector.x, orientedVector.y)
+        };
+        return {
+            destinationPointNative: { ...point },
+            destinationImagePointMm,
+            localExposureWindow: {
+                startSecondsFromCaptureReference: exposure.startOffsetSecondsFromOpeningReference,
+                endSecondsFromCaptureReference: exposure.endOffsetSecondsFromOpeningReference,
+                durationSeconds: exposure.localExposureDurationSeconds
+            },
+            localExposurePhase: input.localExposurePhase,
+            captureTimeSecondsFromReference,
+            referenceImagePointMm: {
+                ...inverse.value.referenceImagePointMm
+            },
+            inverseDisplacementImagePlaneMm: {
+                ...inverse.value.deltaMm
+            },
+            inverseDisplacementNativeSamples,
+            inverseDisplacementOrientedSamples
+        };
+    });
+    if (inverseRotationProvenance === undefined) {
+        throw new InvalidScientificInputError("At least one inverse rotation mapping sample is required.");
+    }
+    return approximationResult({
+        timeReference: "first-opening-boundary-phase",
+        referenceTimeSecondsFromCaptureReference: 0,
+        mappingMeaning: "instantaneous-destination-to-exposure-start-reference-ray",
+        orientation: input.orientation,
+        localExposurePhase: input.localExposurePhase,
+        imagingArea: { ...input.imagingArea },
+        activeCaptureRect: {
+            ...exposureWindows.value.activeCaptureRect
+        },
+        samples,
+        componentProvenance: {
+            exposureWindows: exposureWindows.provenance,
+            sensorGeometry: sensorGeometry.provenance,
+            inverseCameraRotation: inverseRotationProvenance
+        }
+    }, "capture-rotation-instantaneous-inverse-mapping", "1.0.0", [
+        "Destination native capture location determines the local exposure window.",
+        "The caller explicitly selects one phase within each local exposure interval; no midpoint or other phase is inferred.",
+        "The first opening-boundary phase is the reference image time and is bound to t=0 of the camera-rotation model for this composition.",
+        "Pure rotation is inverted analytically after local capture time is known; no iterative or fixed-point solver is used.",
+        "Sensor data-readout timing is not an input and is not assumed to equal any exposure boundary.",
+        "Reference image-plane coordinates are not clamped to the active capture and may fall outside it under motion.",
+        "Native geometric sample displacement uses the full physical imaging-area/native-raster pitch and is not output-resolution dependent.",
+        "Physical capture orientation rotates reported native displacement only; it does not alter native exposure timing.",
+        "The mapping lives in the ideal pre-lens image plane and does not compose radial distortion, chromatic aberration, PSF, or output resampling.",
+        "This is an instantaneous mapping, not finite-exposure integration or a blur kernel.",
+        "Camera translation, depth parallax, subject motion, deformation, occlusion changes, flash/flicker and shutter shock are excluded.",
+        "The model does not claim the global rolling/capture-scan picture-taking map is one-to-one for arbitrary motion."
+    ]);
+}
+//# sourceMappingURL=capture-rotation-inverse-mapping.js.map

package/dist/motion/capture-rotation-inverse-mapping.js.map

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

package/dist/motion/capture-rotation-temporal-quadrature.d.ts

@@ -0,0 +1,89 @@
+import { type CalculationProvenance, type CalculationResult } from "../core/calculation-result.js";
+import type { RasterPoint, RasterVector } from "../output/capture-geometry.js";
+import type { ImagePlanePointMm } from "./camera-rotation.js";
+import { type CalculateCaptureRotationInverseMappingsInput } from "./capture-rotation-inverse-mapping.js";
+export interface CalculateCaptureRotationTemporalQuadratureInput extends Omit<CalculateCaptureRotationInverseMappingsInput, "localExposurePhase"> {
+    /**
+     * Number of deterministic temporal quadrature nodes per local exposure
+     * interval. Nodes use the uniform midpoint rule.
+     */
+    temporalSampleCount: number;
+}
+export interface CaptureRotationTemporalQuadratureNode {
+    temporalSampleIndex: number;
+    /**
+     * Normalized phase in the local exposure interval, strictly inside (0, 1).
+     */
+    localExposurePhase: number;
+    captureTimeSecondsFromReference: number;
+    /**
+     * Dimensionless weight for approximating the time-average of a downstream
+     * quantity under a uniform temporal-response assumption.
+     */
+    normalizedTimeWeight: number;
+    /**
+     * Seconds-valued quadrature measure for approximating a time integral.
+     *
+     * This is temporal measure only. It is not shutter transmission, radiometric
+     * throughput, photon count, sensor response, or scene radiance.
+     */
+    timeMeasureSeconds: number;
+    referenceImagePointMm: ImagePlanePointMm;
+    inverseDisplacementImagePlaneMm: {
+        x: number;
+        y: number;
+        distance: number;
+    };
+    inverseDisplacementNativeSamples: RasterVector & {
+        distance: number;
+    };
+    inverseDisplacementOrientedSamples: RasterVector & {
+        distance: number;
+    };
+}
+export interface CaptureRotationTemporalQuadraturePoint {
+    destinationPointNative: RasterPoint;
+    destinationImagePointMm: ImagePlanePointMm;
+    localExposureWindow: {
+        startSecondsFromCaptureReference: number;
+        endSecondsFromCaptureReference: number;
+        durationSeconds: number;
+    };
+    nodes: readonly CaptureRotationTemporalQuadratureNode[];
+}
+export interface CaptureRotationTemporalQuadrature {
+    timeReference: "first-opening-boundary-phase";
+    quadratureScheme: "uniform-midpoint";
+    temporalResponseModel: "uniform-over-local-exposure";
+    temporalSampleCount: number;
+    /**
+     * The quadrature returns geometry and temporal measure only. It does not
+     * integrate radiance or produce a blur kernel.
+     */
+    outputMeaning: "temporal-geometry-quadrature-nodes";
+    points: readonly CaptureRotationTemporalQuadraturePoint[];
+    componentProvenance: {
+        instantaneousInverseMapping: CalculationProvenance;
+    };
+}
+/**
+ * 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 declare function calculateCaptureRotationTemporalQuadrature(input: CalculateCaptureRotationTemporalQuadratureInput): CalculationResult<CaptureRotationTemporalQuadrature>;
+//# sourceMappingURL=capture-rotation-temporal-quadrature.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"capture-rotation-temporal-quadrature.d.ts","sourceRoot":"","sources":["../../src/motion/capture-rotation-temporal-quadrature.ts"],"names":[],"mappings":"AAEA,OAAO,EAEL,KAAK,qBAAqB,EAC1B,KAAK,iBAAiB,EACvB,MAAM,+BAA+B,CAAC;AAKvC,OAAO,KAAK,EAAE,WAAW,EAAE,YAAY,EAAE,MAAM,+BAA+B,CAAC;AAC/E,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,sBAAsB,CAAC;AAC9D,OAAO,EAEL,KAAK,4CAA4C,EAClD,MAAM,uCAAuC,CAAC;AAE/C,MAAM,WAAW,+CACf,SAAQ,IAAI,CACV,4CAA4C,EAC5C,oBAAoB,CACrB;IACD;;;OAGG;IACH,mBAAmB,EAAE,MAAM,CAAC;CAC7B;AAED,MAAM,WAAW,qCAAqC;IACpD,mBAAmB,EAAE,MAAM,CAAC;IAC5B;;OAEG;IACH,kBAAkB,EAAE,MAAM,CAAC;IAC3B,+BAA+B,EAAE,MAAM,CAAC;IACxC;;;OAGG;IACH,oBAAoB,EAAE,MAAM,CAAC;IAC7B;;;;;OAKG;IACH,kBAAkB,EAAE,MAAM,CAAC;IAC3B,qBAAqB,EAAE,iBAAiB,CAAC;IACzC,+BAA+B,EAAE;QAC/B,CAAC,EAAE,MAAM,CAAC;QACV,CAAC,EAAE,MAAM,CAAC;QACV,QAAQ,EAAE,MAAM,CAAC;KAClB,CAAC;IACF,gCAAgC,EAAE,YAAY,GAAG;QAC/C,QAAQ,EAAE,MAAM,CAAC;KAClB,CAAC;IACF,kCAAkC,EAAE,YAAY,GAAG;QACjD,QAAQ,EAAE,MAAM,CAAC;KAClB,CAAC;CACH;AAED,MAAM,WAAW,sCAAsC;IACrD,sBAAsB,EAAE,WAAW,CAAC;IACpC,uBAAuB,EAAE,iBAAiB,CAAC;IAC3C,mBAAmB,EAAE;QACnB,gCAAgC,EAAE,MAAM,CAAC;QACzC,8BAA8B,EAAE,MAAM,CAAC;QACvC,eAAe,EAAE,MAAM,CAAC;KACzB,CAAC;IACF,KAAK,EAAE,SAAS,qCAAqC,EAAE,CAAC;CACzD;AAED,MAAM,WAAW,iCAAiC;IAChD,aAAa,EAAE,8BAA8B,CAAC;IAC9C,gBAAgB,EAAE,kBAAkB,CAAC;IACrC,qBAAqB,EAAE,6BAA6B,CAAC;IACrD,mBAAmB,EAAE,MAAM,CAAC;IAC5B;;;OAGG;IACH,aAAa,EAAE,oCAAoC,CAAC;IACpD,MAAM,EAAE,SAAS,sCAAsC,EAAE,CAAC;IAC1D,mBAAmB,EAAE;QACnB,2BAA2B,EAAE,qBAAqB,CAAC;KACpD,CAAC;CACH;AAMD;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,0CAA0C,CACxD,KAAK,EAAE,+CAA+C,GACrD,iBAAiB,CAAC,iCAAiC,CAAC,CA2ItD"}

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

@@ -0,0 +1,116 @@
+// SPDX-License-Identifier: Apache-2.0
+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":"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"}

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

@@ -0,0 +1,98 @@
+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,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,153 @@
+// SPDX-License-Identifier: Apache-2.0
+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