@photivra/engine 0.1.0

package/dist/motion/projected-motion.js

@@ -0,0 +1,84 @@
+// SPDX-License-Identifier: Apache-2.0
+import { calculatedResult } from "../core/calculation-result.js";
+import { InvalidScientificInputError, requirePositiveFinite } from "../core/validation.js";
+import { calculateThinLensImageDistance } from "../optics/thin-lens.js";
+function requireFiniteVector3(name, value) {
+    for (const component of ["x", "y", "z"]) {
+        if (!Number.isFinite(value[component])) {
+            throw new InvalidScientificInputError(`${name}.${component} must be finite.`);
+        }
+    }
+}
+/**
+ * Calculates sensor-plane motion during an exposure using ideal rectilinear
+ * projection and constant linear object velocity.
+ *
+ * Without focusDistanceM, nominal focal length is the backwards-compatible
+ * pinhole projection distance. With focusDistanceM, the selected thin-lens
+ * sensor-plane image distance is used.
+ *
+ * The calculation projects the object's shutter-open and shutter-close
+ * positions onto the image plane and measures the displacement between them.
+ * It therefore handles lateral and depth-direction motion without relying on a
+ * generic "subject speed" category.
+ *
+ * @param input Camera, exposure, object-position, and velocity inputs.
+ * @returns Projected sensor-plane displacement.
+ */
+export function calculateProjectedMotionBlur(input) {
+    requirePositiveFinite("focalLengthMm", input.focalLengthMm);
+    requirePositiveFinite("shutterSeconds", input.shutterSeconds);
+    requireFiniteVector3("positionM", input.positionM);
+    requireFiniteVector3("velocityMps", input.velocityMps);
+    if (input.positionM.z <= 0) {
+        throw new InvalidScientificInputError("positionM.z must place the object in front of the camera.");
+    }
+    const endPositionM = {
+        x: input.positionM.x + input.velocityMps.x * input.shutterSeconds,
+        y: input.positionM.y + input.velocityMps.y * input.shutterSeconds,
+        z: input.positionM.z + input.velocityMps.z * input.shutterSeconds
+    };
+    if (endPositionM.z <= 0) {
+        throw new InvalidScientificInputError("Object motion crosses or reaches the camera plane during the exposure.");
+    }
+    const focusProjection = input.focusDistanceM === undefined
+        ? undefined
+        : calculateThinLensImageDistance({
+            focalLengthMm: input.focalLengthMm,
+            objectDistanceM: input.focusDistanceM
+        });
+    const projectionDistanceMm = focusProjection?.value.imageDistanceMm ?? input.focalLengthMm;
+    const startXmm = projectionDistanceMm * (input.positionM.x / input.positionM.z);
+    const startYmm = projectionDistanceMm * (input.positionM.y / input.positionM.z);
+    const endXmm = projectionDistanceMm * (endPositionM.x / endPositionM.z);
+    const endYmm = projectionDistanceMm * (endPositionM.y / endPositionM.z);
+    const deltaXMm = endXmm - startXmm;
+    const deltaYMm = endYmm - startYmm;
+    const distanceMm = Math.hypot(deltaXMm, deltaYMm);
+    let distancePixels;
+    if (input.pixelPitchMicrometers !== undefined) {
+        requirePositiveFinite("pixelPitchMicrometers", input.pixelPitchMicrometers);
+        distancePixels = distanceMm / (input.pixelPitchMicrometers / 1000);
+    }
+    return calculatedResult({
+        deltaXMm,
+        deltaYMm,
+        distanceMm,
+        projectionDistanceMm,
+        ...(distancePixels === undefined ? {} : { distancePixels })
+    }, focusProjection === undefined
+        ? "constant-velocity-pinhole-motion"
+        : "focus-aware-constant-velocity-thin-lens-motion", "1.0.0", focusProjection === undefined
+        ? [
+            "Ideal rectilinear/pinhole projection",
+            "Constant object velocity during the exposure",
+            "Camera motion is not included in this calculation"
+        ]
+        : [
+            "Ideal rectilinear paraxial thin-lens projection to the selected sensor plane",
+            "Constant object velocity during the exposure",
+            "Camera motion is not included in this calculation",
+            "Real-lens focus breathing is not modeled"
+        ]);
+}
+//# sourceMappingURL=projected-motion.js.map

package/dist/motion/projected-motion.js.map

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

package/dist/optics/aperture.d.ts

@@ -0,0 +1,39 @@
+import { type CalculationResult } from "../core/calculation-result.js";
+export interface CalculateIdealApertureInput {
+    /** Number of straight diaphragm blades/sides. Must be from 3 through 1024. */
+    bladeCount: number;
+    /**
+     * Rotation of the first blade edge in degrees, measured counter-clockwise
+     * in image coordinates before the diffraction-normal offset is applied.
+     */
+    firstBladeEdgeAngleDegrees?: number;
+}
+export interface ApertureVertex {
+    x: number;
+    y: number;
+}
+export interface IdealApertureGeometry {
+    bladeCount: number;
+    /** Number of diffraction ray directions for the ideal straight-edged polygon. */
+    sunstarRayCount: number;
+    /**
+     * Diffraction-ray directions in degrees, normalized to [0, 360).
+     *
+     * Each ray is perpendicular to a blade edge. Parallel opposite edges overlap
+     * for even blade counts; odd blade counts therefore produce twice as many
+     * visible ray directions.
+     */
+    sunstarRayAnglesDegrees: readonly number[];
+    /** Unit-circumradius regular-polygon vertices. */
+    normalizedVertices: readonly ApertureVertex[];
+}
+/**
+ * Calculates ideal regular-polygon aperture geometry and the corresponding
+ * straight-edge diffraction-ray directions.
+ *
+ * This models only geometry/symmetry. It does not calculate diffraction
+ * intensity, wavelength-dependent star length, blade curvature, lens
+ * aberrations, coatings, or sensor blooming.
+ */
+export declare function calculateIdealApertureGeometry(input: CalculateIdealApertureInput): CalculationResult<IdealApertureGeometry>;
+//# sourceMappingURL=aperture.d.ts.map

package/dist/optics/aperture.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"aperture.d.ts","sourceRoot":"","sources":["../../src/optics/aperture.ts"],"names":[],"mappings":"AAEA,OAAO,EAEL,KAAK,iBAAiB,EACvB,MAAM,+BAA+B,CAAC;AAQvC,MAAM,WAAW,2BAA2B;IAC1C,8EAA8E;IAC9E,UAAU,EAAE,MAAM,CAAC;IACnB;;;OAGG;IACH,0BAA0B,CAAC,EAAE,MAAM,CAAC;CACrC;AAED,MAAM,WAAW,cAAc;IAC7B,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX;AAED,MAAM,WAAW,qBAAqB;IACpC,UAAU,EAAE,MAAM,CAAC;IACnB,iFAAiF;IACjF,eAAe,EAAE,MAAM,CAAC;IACxB;;;;;;OAMG;IACH,uBAAuB,EAAE,SAAS,MAAM,EAAE,CAAC;IAC3C,kDAAkD;IAClD,kBAAkB,EAAE,SAAS,cAAc,EAAE,CAAC;CAC/C;AAOD;;;;;;;GAOG;AACH,wBAAgB,8BAA8B,CAC5C,KAAK,EAAE,2BAA2B,GACjC,iBAAiB,CAAC,qBAAqB,CAAC,CAoE1C"}

package/dist/optics/aperture.js

@@ -0,0 +1,62 @@
+// SPDX-License-Identifier: Apache-2.0
+import { calculatedResult } from "../core/calculation-result.js";
+import { InvalidScientificInputError, requirePositiveInteger } from "../core/validation.js";
+const MAX_IDEAL_APERTURE_BLADES = 1024;
+function normalizeDegrees(value) {
+    const normalized = value % 360;
+    return normalized < 0 ? normalized + 360 : normalized;
+}
+/**
+ * Calculates ideal regular-polygon aperture geometry and the corresponding
+ * straight-edge diffraction-ray directions.
+ *
+ * This models only geometry/symmetry. It does not calculate diffraction
+ * intensity, wavelength-dependent star length, blade curvature, lens
+ * aberrations, coatings, or sensor blooming.
+ */
+export function calculateIdealApertureGeometry(input) {
+    requirePositiveInteger("bladeCount", input.bladeCount);
+    if (input.bladeCount < 3) {
+        throw new InvalidScientificInputError("bladeCount must be greater than or equal to 3.");
+    }
+    if (input.bladeCount > MAX_IDEAL_APERTURE_BLADES) {
+        throw new InvalidScientificInputError(`bladeCount must be less than or equal to ${MAX_IDEAL_APERTURE_BLADES}.`);
+    }
+    const rawFirstBladeEdgeAngleDegrees = input.firstBladeEdgeAngleDegrees ?? 0;
+    if (!Number.isFinite(rawFirstBladeEdgeAngleDegrees)) {
+        throw new InvalidScientificInputError("firstBladeEdgeAngleDegrees must be finite.");
+    }
+    const firstBladeEdgeAngleDegrees = normalizeDegrees(rawFirstBladeEdgeAngleDegrees);
+    const edgeStepDegrees = 360 / input.bladeCount;
+    const rayAngles = [];
+    for (let index = 0; index < input.bladeCount; index += 1) {
+        const bladeEdgeAngle = firstBladeEdgeAngleDegrees + index * edgeStepDegrees;
+        const rayAngle = normalizeDegrees(bladeEdgeAngle + 90);
+        rayAngles.push(rayAngle);
+        if (input.bladeCount % 2 !== 0) {
+            rayAngles.push(normalizeDegrees(rayAngle + 180));
+        }
+    }
+    rayAngles.sort((left, right) => left - right);
+    const vertexRotationRadians = ((firstBladeEdgeAngleDegrees - 90 + edgeStepDegrees / 2) * Math.PI) / 180;
+    const vertices = Array.from({ length: input.bladeCount }, (_, index) => {
+        const angle = vertexRotationRadians + (index * 2 * Math.PI) / input.bladeCount;
+        return {
+            x: Math.cos(angle),
+            y: Math.sin(angle)
+        };
+    });
+    return calculatedResult({
+        bladeCount: input.bladeCount,
+        sunstarRayCount: rayAngles.length,
+        sunstarRayAnglesDegrees: rayAngles,
+        normalizedVertices: vertices
+    }, "ideal-regular-polygon-aperture", "1.0.0", [
+        "Aperture opening is a regular polygon with straight edges",
+        "Each diffraction ray is perpendicular to a blade edge",
+        "Opposing parallel-edge diffraction overlaps for even blade counts",
+        "Ray intensity/length and blade curvature are not modeled",
+        "Blade count is computationally bounded to 1024"
+    ]);
+}
+//# sourceMappingURL=aperture.js.map

package/dist/optics/aperture.js.map

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

package/dist/optics/circle-of-confusion.d.ts

@@ -0,0 +1,23 @@
+import { type CalculationResult } from "../core/calculation-result.js";
+export interface EstimateEquivalentViewingCircleOfConfusionInput {
+    sensorWidthMm: number;
+    sensorHeightMm: number;
+    referenceSensorWidthMm: number;
+    referenceSensorHeightMm: number;
+    referenceCircleOfConfusionMm: number;
+}
+export interface EquivalentViewingCircleOfConfusion {
+    circleOfConfusionMm: number;
+    sensorDiagonalMm: number;
+    referenceSensorDiagonalMm: number;
+    scaleFactor: number;
+}
+/**
+ * Estimates a circle-of-confusion criterion for equivalent final viewing by
+ * scaling a caller-supplied reference criterion in proportion to sensor
+ * diagonal.
+ *
+ * This is a viewing/acceptability convention, not a physical blur threshold.
+ */
+export declare function estimateEquivalentViewingCircleOfConfusion(input: EstimateEquivalentViewingCircleOfConfusionInput): CalculationResult<EquivalentViewingCircleOfConfusion>;
+//# sourceMappingURL=circle-of-confusion.d.ts.map

package/dist/optics/circle-of-confusion.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"circle-of-confusion.d.ts","sourceRoot":"","sources":["../../src/optics/circle-of-confusion.ts"],"names":[],"mappings":"AAEA,OAAO,EAEL,KAAK,iBAAiB,EACvB,MAAM,+BAA+B,CAAC;AAGvC,MAAM,WAAW,+CAA+C;IAC9D,aAAa,EAAE,MAAM,CAAC;IACtB,cAAc,EAAE,MAAM,CAAC;IACvB,sBAAsB,EAAE,MAAM,CAAC;IAC/B,uBAAuB,EAAE,MAAM,CAAC;IAChC,4BAA4B,EAAE,MAAM,CAAC;CACtC;AAED,MAAM,WAAW,kCAAkC;IACjD,mBAAmB,EAAE,MAAM,CAAC;IAC5B,gBAAgB,EAAE,MAAM,CAAC;IACzB,yBAAyB,EAAE,MAAM,CAAC;IAClC,WAAW,EAAE,MAAM,CAAC;CACrB;AAED;;;;;;GAMG;AACH,wBAAgB,0CAA0C,CACxD,KAAK,EAAE,+CAA+C,GACrD,iBAAiB,CAAC,kCAAkC,CAAC,CA2CvD"}

package/dist/optics/circle-of-confusion.js

@@ -0,0 +1,32 @@
+// SPDX-License-Identifier: Apache-2.0
+import { approximationResult } from "../core/calculation-result.js";
+import { requirePositiveFinite } from "../core/validation.js";
+/**
+ * Estimates a circle-of-confusion criterion for equivalent final viewing by
+ * scaling a caller-supplied reference criterion in proportion to sensor
+ * diagonal.
+ *
+ * This is a viewing/acceptability convention, not a physical blur threshold.
+ */
+export function estimateEquivalentViewingCircleOfConfusion(input) {
+    requirePositiveFinite("sensorWidthMm", input.sensorWidthMm);
+    requirePositiveFinite("sensorHeightMm", input.sensorHeightMm);
+    requirePositiveFinite("referenceSensorWidthMm", input.referenceSensorWidthMm);
+    requirePositiveFinite("referenceSensorHeightMm", input.referenceSensorHeightMm);
+    requirePositiveFinite("referenceCircleOfConfusionMm", input.referenceCircleOfConfusionMm);
+    const sensorDiagonalMm = Math.hypot(input.sensorWidthMm, input.sensorHeightMm);
+    const referenceSensorDiagonalMm = Math.hypot(input.referenceSensorWidthMm, input.referenceSensorHeightMm);
+    const scaleFactor = sensorDiagonalMm / referenceSensorDiagonalMm;
+    return approximationResult({
+        circleOfConfusionMm: input.referenceCircleOfConfusionMm * scaleFactor,
+        sensorDiagonalMm,
+        referenceSensorDiagonalMm,
+        scaleFactor
+    }, "equivalent-viewing-circle-of-confusion", "1.0.0", [
+        "Reference and target images are compared at equivalent final display/print size",
+        "Viewing distance and visual-acuity criterion are treated as equivalent",
+        "Acceptable circle of confusion scales linearly with sensor diagonal",
+        "This is a viewing convention, not a physical lens/sensor blur threshold"
+    ]);
+}
+//# sourceMappingURL=circle-of-confusion.js.map

package/dist/optics/circle-of-confusion.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"circle-of-confusion.js","sourceRoot":"","sources":["../../src/optics/circle-of-confusion.ts"],"names":[],"mappings":"AAAA,sCAAsC;AAEtC,OAAO,EACL,mBAAmB,EAEpB,MAAM,+BAA+B,CAAC;AACvC,OAAO,EAAE,qBAAqB,EAAE,MAAM,uBAAuB,CAAC;AAiB9D;;;;;;GAMG;AACH,MAAM,UAAU,0CAA0C,CACxD,KAAsD;IAEtD,qBAAqB,CAAC,eAAe,EAAE,KAAK,CAAC,aAAa,CAAC,CAAC;IAC5D,qBAAqB,CAAC,gBAAgB,EAAE,KAAK,CAAC,cAAc,CAAC,CAAC;IAC9D,qBAAqB,CACnB,wBAAwB,EACxB,KAAK,CAAC,sBAAsB,CAC7B,CAAC;IACF,qBAAqB,CACnB,yBAAyB,EACzB,KAAK,CAAC,uBAAuB,CAC9B,CAAC;IACF,qBAAqB,CACnB,8BAA8B,EAC9B,KAAK,CAAC,4BAA4B,CACnC,CAAC;IAEF,MAAM,gBAAgB,GAAG,IAAI,CAAC,KAAK,CACjC,KAAK,CAAC,aAAa,EACnB,KAAK,CAAC,cAAc,CACrB,CAAC;IACF,MAAM,yBAAyB,GAAG,IAAI,CAAC,KAAK,CAC1C,KAAK,CAAC,sBAAsB,EAC5B,KAAK,CAAC,uBAAuB,CAC9B,CAAC;IACF,MAAM,WAAW,GAAG,gBAAgB,GAAG,yBAAyB,CAAC;IAEjE,OAAO,mBAAmB,CACxB;QACE,mBAAmB,EACjB,KAAK,CAAC,4BAA4B,GAAG,WAAW;QAClD,gBAAgB;QAChB,yBAAyB;QACzB,WAAW;KACZ,EACD,wCAAwC,EACxC,OAAO,EACP;QACE,iFAAiF;QACjF,wEAAwE;QACxE,qEAAqE;QACrE,yEAAyE;KAC1E,CACF,CAAC;AACJ,CAAC"}

package/dist/optics/depth-of-field.d.ts

@@ -0,0 +1,53 @@
+import { type CalculationResult } from "../core/calculation-result.js";
+export interface CalculateDepthOfFieldInput {
+    /** Lens focal length in millimetres. */
+    focalLengthMm: number;
+    /** F-number. */
+    aperture: number;
+    /** Focus distance from the lens plane in metres. */
+    focusDistanceM: number;
+    /** Acceptable circle of confusion diameter in millimetres. */
+    circleOfConfusionMm: number;
+}
+export interface DepthOfField {
+    hyperfocalDistanceM: number;
+    nearLimitM: number;
+    /** Null represents an infinite far limit. */
+    farLimitM: number | null;
+    /** Null represents infinite total depth of field. */
+    totalDepthOfFieldM: number | null;
+}
+/**
+ * Calculates thin-lens depth-of-field limits using the conventional
+ * hyperfocal-distance formulation.
+ *
+ * The model is geometric and does not include diffraction, aberrations,
+ * focus breathing, pupil magnification, or macro/high-magnification effects.
+ *
+ * @param input Lens, focus, aperture, and acceptable blur-circle inputs.
+ * @returns Hyperfocal, near, and far depth-of-field distances.
+ */
+export declare function calculateDepthOfField(input: CalculateDepthOfFieldInput): CalculationResult<DepthOfField>;
+export interface CalculateDefocusCircleInput {
+    /** Lens focal length in millimetres. */
+    focalLengthMm: number;
+    /** F-number. */
+    aperture: number;
+    /** Focus-plane distance from the lens plane in metres. */
+    focusDistanceM: number;
+    /** Subject-plane distance from the lens plane in metres. */
+    subjectDistanceM: number;
+}
+export interface DefocusCircle {
+    /** Geometric blur-circle diameter at the sensor plane in millimetres. */
+    diameterMm: number;
+}
+/**
+ * Calculates the geometric defocus-circle diameter at the sensor plane for a
+ * subject plane away from the selected focus plane.
+ *
+ * @param input Lens, aperture, focus-plane, and subject-plane distances.
+ * @returns Geometric blur-circle diameter.
+ */
+export declare function calculateDefocusCircle(input: CalculateDefocusCircleInput): CalculationResult<DefocusCircle>;
+//# sourceMappingURL=depth-of-field.d.ts.map

package/dist/optics/depth-of-field.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"depth-of-field.d.ts","sourceRoot":"","sources":["../../src/optics/depth-of-field.ts"],"names":[],"mappings":"AAEA,OAAO,EAEL,KAAK,iBAAiB,EACvB,MAAM,+BAA+B,CAAC;AAOvC,MAAM,WAAW,0BAA0B;IACzC,wCAAwC;IACxC,aAAa,EAAE,MAAM,CAAC;IACtB,gBAAgB;IAChB,QAAQ,EAAE,MAAM,CAAC;IACjB,oDAAoD;IACpD,cAAc,EAAE,MAAM,CAAC;IACvB,8DAA8D;IAC9D,mBAAmB,EAAE,MAAM,CAAC;CAC7B;AAED,MAAM,WAAW,YAAY;IAC3B,mBAAmB,EAAE,MAAM,CAAC;IAC5B,UAAU,EAAE,MAAM,CAAC;IACnB,6CAA6C;IAC7C,SAAS,EAAE,MAAM,GAAG,IAAI,CAAC;IACzB,qDAAqD;IACrD,kBAAkB,EAAE,MAAM,GAAG,IAAI,CAAC;CACnC;AAED;;;;;;;;;GASG;AACH,wBAAgB,qBAAqB,CACnC,KAAK,EAAE,0BAA0B,GAChC,iBAAiB,CAAC,YAAY,CAAC,CA6CjC;AAED,MAAM,WAAW,2BAA2B;IAC1C,wCAAwC;IACxC,aAAa,EAAE,MAAM,CAAC;IACtB,gBAAgB;IAChB,QAAQ,EAAE,MAAM,CAAC;IACjB,0DAA0D;IAC1D,cAAc,EAAE,MAAM,CAAC;IACvB,4DAA4D;IAC5D,gBAAgB,EAAE,MAAM,CAAC;CAC1B;AAED,MAAM,WAAW,aAAa;IAC5B,yEAAyE;IACzE,UAAU,EAAE,MAAM,CAAC;CACpB;AAED;;;;;;GAMG;AACH,wBAAgB,sBAAsB,CACpC,KAAK,EAAE,2BAA2B,GACjC,iBAAiB,CAAC,aAAa,CAAC,CAsClC"}

package/dist/optics/depth-of-field.js

@@ -0,0 +1,81 @@
+// SPDX-License-Identifier: Apache-2.0
+import { calculatedResult } from "../core/calculation-result.js";
+import { InvalidScientificInputError, requirePositiveFinite } from "../core/validation.js";
+import { calculateThinLensImageDistance } from "./thin-lens.js";
+/**
+ * Calculates thin-lens depth-of-field limits using the conventional
+ * hyperfocal-distance formulation.
+ *
+ * The model is geometric and does not include diffraction, aberrations,
+ * focus breathing, pupil magnification, or macro/high-magnification effects.
+ *
+ * @param input Lens, focus, aperture, and acceptable blur-circle inputs.
+ * @returns Hyperfocal, near, and far depth-of-field distances.
+ */
+export function calculateDepthOfField(input) {
+    requirePositiveFinite("focalLengthMm", input.focalLengthMm);
+    requirePositiveFinite("aperture", input.aperture);
+    requirePositiveFinite("focusDistanceM", input.focusDistanceM);
+    requirePositiveFinite("circleOfConfusionMm", input.circleOfConfusionMm);
+    const focusDistanceMm = input.focusDistanceM * 1000;
+    if (focusDistanceMm <= input.focalLengthMm) {
+        throw new InvalidScientificInputError("focusDistanceM must place the focus plane beyond the focal length.");
+    }
+    const hyperfocalDistanceMm = (input.focalLengthMm * input.focalLengthMm) /
+        (input.aperture * input.circleOfConfusionMm) +
+        input.focalLengthMm;
+    const focusOffsetMm = focusDistanceMm - input.focalLengthMm;
+    const nearLimitMm = (hyperfocalDistanceMm * focusDistanceMm) /
+        (hyperfocalDistanceMm + focusOffsetMm);
+    const farDenominator = hyperfocalDistanceMm - focusOffsetMm;
+    const farLimitMm = farDenominator <= 0
+        ? null
+        : (hyperfocalDistanceMm * focusDistanceMm) / farDenominator;
+    return calculatedResult({
+        hyperfocalDistanceM: hyperfocalDistanceMm / 1000,
+        nearLimitM: nearLimitMm / 1000,
+        farLimitM: farLimitMm === null ? null : farLimitMm / 1000,
+        totalDepthOfFieldM: farLimitMm === null ? null : (farLimitMm - nearLimitMm) / 1000
+    }, "thin-lens-depth-of-field", "1.0.0", [
+        "Geometric thin-lens model",
+        "Circle of confusion is supplied by the caller",
+        "Macro/high-magnification effects are not modeled"
+    ]);
+}
+/**
+ * Calculates the geometric defocus-circle diameter at the sensor plane for a
+ * subject plane away from the selected focus plane.
+ *
+ * @param input Lens, aperture, focus-plane, and subject-plane distances.
+ * @returns Geometric blur-circle diameter.
+ */
+export function calculateDefocusCircle(input) {
+    requirePositiveFinite("focalLengthMm", input.focalLengthMm);
+    requirePositiveFinite("aperture", input.aperture);
+    requirePositiveFinite("focusDistanceM", input.focusDistanceM);
+    requirePositiveFinite("subjectDistanceM", input.subjectDistanceM);
+    let focusImageDistanceMm;
+    let subjectImageDistanceMm;
+    try {
+        focusImageDistanceMm = calculateThinLensImageDistance({
+            focalLengthMm: input.focalLengthMm,
+            objectDistanceM: input.focusDistanceM
+        }).value.imageDistanceMm;
+        subjectImageDistanceMm = calculateThinLensImageDistance({
+            focalLengthMm: input.focalLengthMm,
+            objectDistanceM: input.subjectDistanceM
+        }).value.imageDistanceMm;
+    }
+    catch (error) {
+        if (error instanceof InvalidScientificInputError) {
+            throw new InvalidScientificInputError("focusDistanceM and subjectDistanceM must be beyond the focal length.");
+        }
+        throw error;
+    }
+    const apertureDiameterMm = input.focalLengthMm / input.aperture;
+    const diameterMm = apertureDiameterMm *
+        (Math.abs(subjectImageDistanceMm - focusImageDistanceMm) /
+            subjectImageDistanceMm);
+    return calculatedResult({ diameterMm }, "thin-lens-defocus-circle", "1.0.0", ["Geometric thin-lens model", "Ideal circular entrance pupil"]);
+}
+//# sourceMappingURL=depth-of-field.js.map

package/dist/optics/depth-of-field.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"depth-of-field.js","sourceRoot":"","sources":["../../src/optics/depth-of-field.ts"],"names":[],"mappings":"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"}

package/dist/optics/diffraction.d.ts

@@ -0,0 +1,26 @@
+import { type CalculationResult } from "../core/calculation-result.js";
+export interface CalculateAiryDiskInput {
+    /** F-number. */
+    aperture: number;
+    /** Wavelength in nanometres. Defaults are intentionally left to callers. */
+    wavelengthNm: number;
+}
+export interface AiryDisk {
+    /**
+     * Diameter from the center of the diffraction pattern to the first dark-ring
+     * diameter, in micrometres: 2.44 * wavelength * f-number.
+     */
+    firstZeroDiameterMicrometers: number;
+}
+/**
+ * Calculates the first-zero Airy-disk diameter for an ideal circular aperture.
+ *
+ * This uses the established diffraction relation d = 2.44 * lambda * N.
+ * It is an independent implementation of the mathematical relation and does
+ * not model lens aberrations or non-circular pupil geometry.
+ *
+ * @param input F-number and wavelength.
+ * @returns Diffraction diameter at the image plane.
+ */
+export declare function calculateAiryDisk(input: CalculateAiryDiskInput): CalculationResult<AiryDisk>;
+//# sourceMappingURL=diffraction.d.ts.map

package/dist/optics/diffraction.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"diffraction.d.ts","sourceRoot":"","sources":["../../src/optics/diffraction.ts"],"names":[],"mappings":"AAEA,OAAO,EAEL,KAAK,iBAAiB,EACvB,MAAM,+BAA+B,CAAC;AAGvC,MAAM,WAAW,sBAAsB;IACrC,gBAAgB;IAChB,QAAQ,EAAE,MAAM,CAAC;IACjB,4EAA4E;IAC5E,YAAY,EAAE,MAAM,CAAC;CACtB;AAED,MAAM,WAAW,QAAQ;IACvB;;;OAGG;IACH,4BAA4B,EAAE,MAAM,CAAC;CACtC;AAED;;;;;;;;;GASG;AACH,wBAAgB,iBAAiB,CAC/B,KAAK,EAAE,sBAAsB,GAC5B,iBAAiB,CAAC,QAAQ,CAAC,CAa7B"}

package/dist/optics/diffraction.js

@@ -0,0 +1,21 @@
+// SPDX-License-Identifier: Apache-2.0
+import { calculatedResult } from "../core/calculation-result.js";
+import { requirePositiveFinite } from "../core/validation.js";
+/**
+ * Calculates the first-zero Airy-disk diameter for an ideal circular aperture.
+ *
+ * This uses the established diffraction relation d = 2.44 * lambda * N.
+ * It is an independent implementation of the mathematical relation and does
+ * not model lens aberrations or non-circular pupil geometry.
+ *
+ * @param input F-number and wavelength.
+ * @returns Diffraction diameter at the image plane.
+ */
+export function calculateAiryDisk(input) {
+    requirePositiveFinite("aperture", input.aperture);
+    requirePositiveFinite("wavelengthNm", input.wavelengthNm);
+    return calculatedResult({
+        firstZeroDiameterMicrometers: 2.44 * (input.wavelengthNm / 1000) * input.aperture
+    }, "ideal-circular-aperture-airy-disk", "1.0.0", ["Ideal circular aperture", "Monochromatic wavelength"]);
+}
+//# sourceMappingURL=diffraction.js.map

package/dist/optics/diffraction.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"diffraction.js","sourceRoot":"","sources":["../../src/optics/diffraction.ts"],"names":[],"mappings":"AAAA,sCAAsC;AAEtC,OAAO,EACL,gBAAgB,EAEjB,MAAM,+BAA+B,CAAC;AACvC,OAAO,EAAE,qBAAqB,EAAE,MAAM,uBAAuB,CAAC;AAiB9D;;;;;;;;;GASG;AACH,MAAM,UAAU,iBAAiB,CAC/B,KAA6B;IAE7B,qBAAqB,CAAC,UAAU,EAAE,KAAK,CAAC,QAAQ,CAAC,CAAC;IAClD,qBAAqB,CAAC,cAAc,EAAE,KAAK,CAAC,YAAY,CAAC,CAAC;IAE1D,OAAO,gBAAgB,CACrB;QACE,4BAA4B,EAC1B,IAAI,GAAG,CAAC,KAAK,CAAC,YAAY,GAAG,IAAI,CAAC,GAAG,KAAK,CAAC,QAAQ;KACtD,EACD,mCAAmC,EACnC,OAAO,EACP,CAAC,yBAAyB,EAAE,0BAA0B,CAAC,CACxD,CAAC;AACJ,CAAC"}

package/dist/optics/thin-lens.d.ts

@@ -0,0 +1,30 @@
+import { type CalculationResult } from "../core/calculation-result.js";
+export interface CalculateThinLensImageDistanceInput {
+    /** Lens focal length in millimetres. */
+    focalLengthMm: number;
+    /** Object/focus-plane distance from the lens principal plane in metres. */
+    objectDistanceM: number;
+}
+export interface ThinLensImageDistance {
+    /** Image/sensor-plane distance from the lens principal plane in millimetres. */
+    imageDistanceMm: number;
+    /** Absolute paraxial magnification at the supplied object distance. */
+    magnification: number;
+    /**
+     * Image-distance scale relative to the infinity-focus approximation f.
+     * Values approach 1 as object distance becomes large.
+     */
+    infinityProjectionScale: number;
+}
+/**
+ * Calculates Gaussian thin-lens image distance:
+ *
+ * 1/f = 1/s + 1/v
+ *
+ * where f is focal length, s is object distance, and v is image distance.
+ *
+ * This is a paraxial ideal-lens model. It does not model real-lens focus
+ * breathing, pupil magnification, principal-plane movement, or aberrations.
+ */
+export declare function calculateThinLensImageDistance(input: CalculateThinLensImageDistanceInput): CalculationResult<ThinLensImageDistance>;
+//# sourceMappingURL=thin-lens.d.ts.map

package/dist/optics/thin-lens.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"thin-lens.d.ts","sourceRoot":"","sources":["../../src/optics/thin-lens.ts"],"names":[],"mappings":"AAEA,OAAO,EAEL,KAAK,iBAAiB,EACvB,MAAM,+BAA+B,CAAC;AAMvC,MAAM,WAAW,mCAAmC;IAClD,wCAAwC;IACxC,aAAa,EAAE,MAAM,CAAC;IACtB,2EAA2E;IAC3E,eAAe,EAAE,MAAM,CAAC;CACzB;AAED,MAAM,WAAW,qBAAqB;IACpC,gFAAgF;IAChF,eAAe,EAAE,MAAM,CAAC;IACxB,uEAAuE;IACvE,aAAa,EAAE,MAAM,CAAC;IACtB;;;OAGG;IACH,uBAAuB,EAAE,MAAM,CAAC;CACjC;AAED;;;;;;;;;GASG;AACH,wBAAgB,8BAA8B,CAC5C,KAAK,EAAE,mCAAmC,GACzC,iBAAiB,CAAC,qBAAqB,CAAC,CA6B1C"}

package/dist/optics/thin-lens.js

@@ -0,0 +1,33 @@
+// SPDX-License-Identifier: Apache-2.0
+import { calculatedResult } from "../core/calculation-result.js";
+import { InvalidScientificInputError, requirePositiveFinite } from "../core/validation.js";
+/**
+ * Calculates Gaussian thin-lens image distance:
+ *
+ * 1/f = 1/s + 1/v
+ *
+ * where f is focal length, s is object distance, and v is image distance.
+ *
+ * This is a paraxial ideal-lens model. It does not model real-lens focus
+ * breathing, pupil magnification, principal-plane movement, or aberrations.
+ */
+export function calculateThinLensImageDistance(input) {
+    requirePositiveFinite("focalLengthMm", input.focalLengthMm);
+    requirePositiveFinite("objectDistanceM", input.objectDistanceM);
+    const objectDistanceMm = input.objectDistanceM * 1000;
+    if (objectDistanceMm <= input.focalLengthMm) {
+        throw new InvalidScientificInputError("objectDistanceM must place the object plane beyond the focal length.");
+    }
+    const imageDistanceMm = (input.focalLengthMm * objectDistanceMm) /
+        (objectDistanceMm - input.focalLengthMm);
+    return calculatedResult({
+        imageDistanceMm,
+        magnification: imageDistanceMm / objectDistanceMm,
+        infinityProjectionScale: imageDistanceMm / input.focalLengthMm
+    }, "gaussian-thin-lens-image-distance", "1.0.0", [
+        "Paraxial Gaussian thin-lens model",
+        "Distances are measured from ideal principal planes",
+        "Real-lens focus breathing and pupil magnification are not modeled"
+    ]);
+}
+//# sourceMappingURL=thin-lens.js.map

package/dist/optics/thin-lens.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"thin-lens.js","sourceRoot":"","sources":["../../src/optics/thin-lens.ts"],"names":[],"mappings":"AAAA,sCAAsC;AAEtC,OAAO,EACL,gBAAgB,EAEjB,MAAM,+BAA+B,CAAC;AACvC,OAAO,EACL,2BAA2B,EAC3B,qBAAqB,EACtB,MAAM,uBAAuB,CAAC;AAqB/B;;;;;;;;;GASG;AACH,MAAM,UAAU,8BAA8B,CAC5C,KAA0C;IAE1C,qBAAqB,CAAC,eAAe,EAAE,KAAK,CAAC,aAAa,CAAC,CAAC;IAC5D,qBAAqB,CAAC,iBAAiB,EAAE,KAAK,CAAC,eAAe,CAAC,CAAC;IAEhE,MAAM,gBAAgB,GAAG,KAAK,CAAC,eAAe,GAAG,IAAI,CAAC;IACtD,IAAI,gBAAgB,IAAI,KAAK,CAAC,aAAa,EAAE,CAAC;QAC5C,MAAM,IAAI,2BAA2B,CACnC,sEAAsE,CACvE,CAAC;IACJ,CAAC;IAED,MAAM,eAAe,GACnB,CAAC,KAAK,CAAC,aAAa,GAAG,gBAAgB,CAAC;QACxC,CAAC,gBAAgB,GAAG,KAAK,CAAC,aAAa,CAAC,CAAC;IAE3C,OAAO,gBAAgB,CACrB;QACE,eAAe;QACf,aAAa,EAAE,eAAe,GAAG,gBAAgB;QACjD,uBAAuB,EAAE,eAAe,GAAG,KAAK,CAAC,aAAa;KAC/D,EACD,mCAAmC,EACnC,OAAO,EACP;QACE,mCAAmC;QACnC,oDAAoD;QACpD,mEAAmE;KACpE,CACF,CAAC;AACJ,CAAC"}

package/dist/output/crop.d.ts

@@ -0,0 +1,27 @@
+import { type CalculationResult } from "../core/calculation-result.js";
+export interface CalculateCenteredCropInput {
+    /** Original image width in pixels. */
+    pixelWidth: number;
+    /** Original image height in pixels. */
+    pixelHeight: number;
+    /**
+     * Linear crop factor. 1 means no crop; 1.5 retains 1 / 1.5 of each
+     * dimension while preserving aspect ratio.
+     */
+    cropFactor: number;
+}
+export interface CenteredCrop {
+    pixelWidth: number;
+    pixelHeight: number;
+    megapixels: number;
+    /** Fraction of original pixel area retained, from 0 to 1. */
+    retainedAreaFraction: number;
+}
+/**
+ * Calculates dimensions remaining after a centered, same-aspect-ratio crop.
+ *
+ * @param input Original dimensions and linear crop factor.
+ * @returns Remaining pixel dimensions and area fraction.
+ */
+export declare function calculateCenteredCrop(input: CalculateCenteredCropInput): CalculationResult<CenteredCrop>;
+//# sourceMappingURL=crop.d.ts.map

package/dist/output/crop.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"crop.d.ts","sourceRoot":"","sources":["../../src/output/crop.ts"],"names":[],"mappings":"AAEA,OAAO,EAEL,KAAK,iBAAiB,EACvB,MAAM,+BAA+B,CAAC;AAOvC,MAAM,WAAW,0BAA0B;IACzC,sCAAsC;IACtC,UAAU,EAAE,MAAM,CAAC;IACnB,uCAAuC;IACvC,WAAW,EAAE,MAAM,CAAC;IACpB;;;OAGG;IACH,UAAU,EAAE,MAAM,CAAC;CACpB;AAED,MAAM,WAAW,YAAY;IAC3B,UAAU,EAAE,MAAM,CAAC;IACnB,WAAW,EAAE,MAAM,CAAC;IACpB,UAAU,EAAE,MAAM,CAAC;IACnB,6DAA6D;IAC7D,oBAAoB,EAAE,MAAM,CAAC;CAC9B;AAED;;;;;GAKG;AACH,wBAAgB,qBAAqB,CACnC,KAAK,EAAE,0BAA0B,GAChC,iBAAiB,CAAC,YAAY,CAAC,CA6BjC"}

package/dist/output/crop.js

@@ -0,0 +1,26 @@
+// SPDX-License-Identifier: Apache-2.0
+import { calculatedResult } from "../core/calculation-result.js";
+import { InvalidScientificInputError, requirePositiveFinite, requirePositiveInteger } from "../core/validation.js";
+/**
+ * Calculates dimensions remaining after a centered, same-aspect-ratio crop.
+ *
+ * @param input Original dimensions and linear crop factor.
+ * @returns Remaining pixel dimensions and area fraction.
+ */
+export function calculateCenteredCrop(input) {
+    requirePositiveInteger("pixelWidth", input.pixelWidth);
+    requirePositiveInteger("pixelHeight", input.pixelHeight);
+    requirePositiveFinite("cropFactor", input.cropFactor);
+    if (input.cropFactor < 1) {
+        throw new InvalidScientificInputError("cropFactor must be greater than or equal to 1.");
+    }
+    const pixelWidth = Math.max(1, Math.floor(input.pixelWidth / input.cropFactor));
+    const pixelHeight = Math.max(1, Math.floor(input.pixelHeight / input.cropFactor));
+    return calculatedResult({
+        pixelWidth,
+        pixelHeight,
+        megapixels: (pixelWidth * pixelHeight) / 1_000_000,
+        retainedAreaFraction: (pixelWidth * pixelHeight) / (input.pixelWidth * input.pixelHeight)
+    }, "centered-same-aspect-crop", "1.0.0", ["Centered crop", "Original aspect ratio is preserved"]);
+}
+//# sourceMappingURL=crop.js.map

package/dist/output/crop.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"crop.js","sourceRoot":"","sources":["../../src/output/crop.ts"],"names":[],"mappings":"AAAA,sCAAsC;AAEtC,OAAO,EACL,gBAAgB,EAEjB,MAAM,+BAA+B,CAAC;AACvC,OAAO,EACL,2BAA2B,EAC3B,qBAAqB,EACrB,sBAAsB,EACvB,MAAM,uBAAuB,CAAC;AAsB/B;;;;;GAKG;AACH,MAAM,UAAU,qBAAqB,CACnC,KAAiC;IAEjC,sBAAsB,CAAC,YAAY,EAAE,KAAK,CAAC,UAAU,CAAC,CAAC;IACvD,sBAAsB,CAAC,aAAa,EAAE,KAAK,CAAC,WAAW,CAAC,CAAC;IACzD,qBAAqB,CAAC,YAAY,EAAE,KAAK,CAAC,UAAU,CAAC,CAAC;IAEtD,IAAI,KAAK,CAAC,UAAU,GAAG,CAAC,EAAE,CAAC;QACzB,MAAM,IAAI,2BAA2B,CACnC,gDAAgD,CACjD,CAAC;IACJ,CAAC;IAED,MAAM,UAAU,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,UAAU,GAAG,KAAK,CAAC,UAAU,CAAC,CAAC,CAAC;IAChF,MAAM,WAAW,GAAG,IAAI,CAAC,GAAG,CAC1B,CAAC,EACD,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,WAAW,GAAG,KAAK,CAAC,UAAU,CAAC,CACjD,CAAC;IAEF,OAAO,gBAAgB,CACrB;QACE,UAAU;QACV,WAAW;QACX,UAAU,EAAE,CAAC,UAAU,GAAG,WAAW,CAAC,GAAG,SAAS;QAClD,oBAAoB,EAClB,CAAC,UAAU,GAAG,WAAW,CAAC,GAAG,CAAC,KAAK,CAAC,UAAU,GAAG,KAAK,CAAC,WAAW,CAAC;KACtE,EACD,2BAA2B,EAC3B,OAAO,EACP,CAAC,eAAe,EAAE,oCAAoC,CAAC,CACxD,CAAC;AACJ,CAAC"}