scax-engine 0.1.1 → 0.1.3

package/dist/scax-engine.umd.js

@@ -6936,6 +6936,13 @@
 	        d: 1.406,
 	        C: 1.405318,
 	    },
+	    // Navarro 수정체 중심 굴절률(d=1.42)용 분산 스펙
+	    lens_navarro: {
+	        F: 1.421585,
+	        e: 1.420542,
+	        d: 1.420,
+	        C: 1.419318,
+	    },
 	    lens_anterior: {
 	        F: 1.387507,
 	        e: 1.386516,
@@ -7026,6 +7033,19 @@
 	 * Sturm 분석에서 Top2 선택 시 허용하는 최소 축 각도 차(도)
 	 */
 	const DEFAULT_STURM_TOP2_MIN_ANGLE_GAP_DEG = 45;
+	/**
+	 * Sturm Top2 이각(J0,J45) phasor 내적 상한: cos(Δ₂θ) 이 이 값 이하일 때
+	 * 두 주경선을 직교(선초점 쌍)로 취급한다. -1에 가까울수록 엄격.
+	 */
+	const DEFAULT_STURM_TOP2_PHASOR_OPPOSITION_MAX_DOT = -0.86;
+	/**
+	 * phasor 직교 판정 실패 시 완화 단계에서 쓰는 내적 상한
+	 */
+	const DEFAULT_STURM_TOP2_PHASOR_FALLBACK_MAX_DOT = -0.55;
+	/**
+	 * 축 각·phasor 폴백 후에도 후보가 없을 때 허용하는 최소 각도 차(도)
+	 */
+	const DEFAULT_STURM_TOP2_AXIS_LAST_RESORT_MIN_GAP_DEG = 22;
 	/**
 	 * 실효 난시량이 이 값(D) 이상이면 U/V 중간점을 CLC 근사 중심으로 우선 사용
 	 */
@@ -7034,6 +7054,11 @@
 	 * Sturm z-scan 간격(mm)
 	 */
 	const DEFAULT_STURM_STEP_MM = 0.01;
+	/**
+	 * Sturm 분석 슬라이스의 profile.at.z를 각막(앞)~망막+이 값(mm) 구간으로 한정할 때
+	 * 망막 표면 z보다 진행 방향 +z로 허용하는 여유.
+	 */
+	const DEFAULT_STURM_PROFILE_WORLD_Z_PAST_RETINA_MM = 4;
 
 	const DEFAULT_DIR = new Vector3(0, 0, 1);
 	function isFiniteVector3(v) {
@@ -7889,48 +7914,48 @@
 	            name: "cornea_anterior",
 	            z: 0.0,
 	            radius: 7.7,
-	            n_before: 1.0,
-	            n_after: 1.376,
+	            n_before: FRAUNHOFER_REFRACTIVE_INDICES.air,
+	            n_after: FRAUNHOFER_REFRACTIVE_INDICES.cornea,
 	        },
 	        {
 	            type: "spherical",
 	            name: "cornea_posterior",
 	            z: 0.5,
 	            radius: 6.8,
-	            n_before: 1.376,
-	            n_after: 1.336,
+	            n_before: FRAUNHOFER_REFRACTIVE_INDICES.cornea,
+	            n_after: FRAUNHOFER_REFRACTIVE_INDICES.aqueous,
 	        },
 	        {
 	            type: "spherical",
 	            name: "lens_anterior",
 	            z: 3.6,
 	            radius: 10.0,
-	            n_before: 1.336,
-	            n_after: 1.386,
+	            n_before: FRAUNHOFER_REFRACTIVE_INDICES.aqueous,
+	            n_after: FRAUNHOFER_REFRACTIVE_INDICES.lens_anterior,
 	        },
 	        {
 	            type: "spherical",
 	            name: "lens_nucleus_anterior",
 	            z: 4.146,
 	            radius: 7.911,
-	            n_before: 1.386,
-	            n_after: 1.406,
+	            n_before: FRAUNHOFER_REFRACTIVE_INDICES.lens_anterior,
+	            n_after: FRAUNHOFER_REFRACTIVE_INDICES.lens_nucleus_anterior,
 	        },
 	        {
 	            type: "spherical",
 	            name: "lens_nucleus_posterior",
 	            z: 6.565,
 	            radius: -5.76,
-	            n_before: 1.406,
-	            n_after: 1.386,
+	            n_before: FRAUNHOFER_REFRACTIVE_INDICES.lens_nucleus_anterior,
+	            n_after: FRAUNHOFER_REFRACTIVE_INDICES.lens_nucleus_posterior,
 	        },
 	        {
 	            type: "spherical",
 	            name: "lens_posterior",
 	            z: 7.2,
 	            radius: -6,
-	            n_before: 1.386,
-	            n_after: 1.336,
+	            n_before: FRAUNHOFER_REFRACTIVE_INDICES.lens_nucleus_posterior,
+	            n_after: FRAUNHOFER_REFRACTIVE_INDICES.vitreous,
 	        },
 	        {
 	            type: "spherical-image",
@@ -7956,8 +7981,8 @@
 	            z: 0.0,
 	            radius: 7.72,
 	            conic: -0.26,
-	            n_before: 1.0,
-	            n_after: 1.376,
+	            n_before: FRAUNHOFER_REFRACTIVE_INDICES.air,
+	            n_after: FRAUNHOFER_REFRACTIVE_INDICES.cornea,
 	        },
 	        {
 	            type: "aspherical",
@@ -7965,8 +7990,8 @@
 	            z: 0.55,
 	            radius: 6.5,
 	            conic: 0.0,
-	            n_before: 1.376,
-	            n_after: 1.336,
+	            n_before: FRAUNHOFER_REFRACTIVE_INDICES.cornea,
+	            n_after: FRAUNHOFER_REFRACTIVE_INDICES.aqueous,
 	        },
 	        {
 	            type: "aspherical",
@@ -7974,8 +7999,8 @@
 	            z: 0.55 + 3.05,
 	            radius: 10.2,
 	            conic: -3.13,
-	            n_before: 1.336,
-	            n_after: 1.42,
+	            n_before: FRAUNHOFER_REFRACTIVE_INDICES.aqueous,
+	            n_after: FRAUNHOFER_REFRACTIVE_INDICES.lens_navarro,
 	        },
 	        {
 	            type: "aspherical",
@@ -7983,8 +8008,8 @@
 	            z: 0.55 + 3.05 + 4.0,
 	            radius: -6,
 	            conic: -1,
-	            n_before: 1.42,
-	            n_after: 1.336,
+	            n_before: FRAUNHOFER_REFRACTIVE_INDICES.lens_navarro,
+	            n_after: FRAUNHOFER_REFRACTIVE_INDICES.vitreous,
 	        },
 	        {
 	            type: "spherical-image",
@@ -8005,7 +8030,7 @@
 	        this.lastResult = null;
 	        this.lineOrder = ["g", "F", "e", "d", "C", "r"];
 	    }
-	    calculate(rays, effectiveCylinderD, axisReferenceRays) {
+	    calculate(rays, effectiveCylinderD, axisReferenceRays, profileWorldZBounds) {
 	        const frame = this.analysisFrameFromRays(axisReferenceRays?.length ? axisReferenceRays : rays);
 	        const depthRange = this.depthRangeFromRays(rays, frame);
 	        const sturmSlices = this.collectSturmSlices(rays, frame, depthRange, DEFAULT_STURM_STEP_MM);
@@ -8014,7 +8039,7 @@
 	            const groupFrame = this.analysisFrameFromRays(group.rays, frame);
 	            const groupDepthRange = this.depthRangeFromRays(group.rays, groupFrame);
 	            const slices = this.collectSturmSlices(group.rays, groupFrame, groupDepthRange, DEFAULT_STURM_STEP_MM);
-	            const analysis = this.analyzeSturmSlices(slices, effectiveCylinderD);
+	            const analysis = this.analyzeSturmSlices(slices, effectiveCylinderD, profileWorldZBounds);
 	            return {
 	                line: group.line,
 	                wavelength_nm: group.wavelength_nm,
@@ -8148,6 +8173,9 @@
 	        const lambdaMinor = Math.max(0, trace / 2 - root);
 	        const thetaRad = 0.5 * Math.atan2(2 * sxy, sxx - syy);
 	        const angleMajorDeg = ((thetaRad * 180) / Math.PI + 360) % 180;
+	        const twoThetaRad = 2 * thetaRad;
+	        const j0 = Math.cos(twoThetaRad);
+	        const j45 = Math.sin(twoThetaRad);
 	        const majorDirection = frame.u.clone().multiplyScalar(Math.cos(thetaRad))
 	            .add(frame.v.clone().multiplyScalar(Math.sin(thetaRad)))
 	            .normalize();
@@ -8157,6 +8185,8 @@
 	            wMajor: Math.sqrt(lambdaMajor),
 	            wMinor: Math.sqrt(lambdaMinor),
 	            angleMajorDeg,
+	            j0,
+	            j45,
 	            angleMinorDeg: (angleMajorDeg + 90) % 180,
 	            majorDirection: {
 	                x: majorDirection.x,
@@ -8194,6 +8224,84 @@
 	        const d = Math.abs((((a - b) % 180) + 180) % 180);
 	        return Math.min(d, 180 - d);
 	    }
+	    phasorDot(p, q) {
+	        return p.j0 * q.j0 + p.j45 * q.j45;
+	    }
+	    /**
+	     * 평탄도 순으로 정렬된 슬라이스에서 선초점 쌍(직교 주경선)에 해당하는 Top2를 고른다.
+	     * 주경선 각 대신 이각 phasor (cos 2θ, sin 2θ)로 직교를 판정하고, 실패 시 각도·전역 검색·깊이 폴백을 사용한다.
+	     */
+	    pickFlattestSturmPair(sortedByFlatness, top2MinGapMm, allSlices) {
+	        if (sortedByFlatness.length === 0)
+	            return [];
+	        const first = sortedByFlatness[0];
+	        const top2MinAngleGapDeg = DEFAULT_STURM_TOP2_MIN_ANGLE_GAP_DEG;
+	        const phasorStrict = DEFAULT_STURM_TOP2_PHASOR_OPPOSITION_MAX_DOT;
+	        const phasorLoose = DEFAULT_STURM_TOP2_PHASOR_FALLBACK_MAX_DOT;
+	        const lastResortMinDeg = DEFAULT_STURM_TOP2_AXIS_LAST_RESORT_MIN_GAP_DEG;
+	        const depthOk = (c) => Math.abs(c.depth - first.depth) >= top2MinGapMm;
+	        const byPhasor = (pool, maxDot) => pool.find((c) => (c !== first
+	            && depthOk(c)
+	            && this.phasorDot(first.profile, c.profile) <= maxDot));
+	        let second = byPhasor(sortedByFlatness, phasorStrict)
+	            ?? byPhasor(sortedByFlatness, phasorLoose);
+	        if (!second) {
+	            second = sortedByFlatness.find((c) => (c !== first
+	                && depthOk(c)
+	                && this.axisDiffDeg(c.profile.angleMajorDeg, first.profile.angleMajorDeg) >= top2MinAngleGapDeg));
+	        }
+	        if (!second) {
+	            let best = null;
+	            let bestAxDiff = -1;
+	            for (const c of sortedByFlatness) {
+	                if (c === first || !depthOk(c))
+	                    continue;
+	                const axd = this.axisDiffDeg(c.profile.angleMajorDeg, first.profile.angleMajorDeg);
+	                if (axd > bestAxDiff) {
+	                    bestAxDiff = axd;
+	                    best = c;
+	                }
+	            }
+	            if (best && bestAxDiff >= lastResortMinDeg)
+	                second = best;
+	        }
+	        // 평탄도 정렬 풀만으로는 같은 phasor만 연속으로 나오는 경우가 있어, 전 스캔에서 가장 반대인 phasor를 고른다.
+	        if (!second) {
+	            let best = null;
+	            let bestDot = 1;
+	            for (const c of allSlices) {
+	                if (c === first || !depthOk(c))
+	                    continue;
+	                const d = this.phasorDot(first.profile, c.profile);
+	                if (d < bestDot) {
+	                    bestDot = d;
+	                    best = c;
+	                }
+	            }
+	            if (best && bestDot < -0.08)
+	                second = best;
+	        }
+	        // 마지막: 가장 납작한 슬라이스와 깊이 차가 가장 큰 “비교적 납작한” 슬라이스 (선초점이 z로 분리될 때)
+	        if (!second) {
+	            const flatThreshold = first.ratio * 1.5 + 1e-6;
+	            let best = null;
+	            let bestDepthSpan = -1;
+	            for (const c of allSlices) {
+	                if (c === first || !depthOk(c))
+	                    continue;
+	                if (c.ratio > flatThreshold)
+	                    continue;
+	                const span = Math.abs(c.depth - first.depth);
+	                if (span > bestDepthSpan) {
+	                    bestDepthSpan = span;
+	                    best = c;
+	                }
+	            }
+	            if (best)
+	                second = best;
+	        }
+	        return second ? [first, second] : [first];
+	    }
 	    buildApproxCenter(flattestTop2, smallestEllipse, preferTop2Mid) {
 	        if (flattestTop2.length <= 0)
 	            return null;
@@ -8218,6 +8326,19 @@
 	        const first = flattestTop2[0];
 	        return { x: first.profile.at.x, y: first.profile.at.y, z: first.z, mode: "top1-flat" };
 	    }
+	    slicesForSturmAnalysis(sturmSlices, bounds) {
+	        if (!bounds)
+	            return sturmSlices;
+	        const zMin = bounds.zMin;
+	        const zMax = bounds.zMax;
+	        if (!Number.isFinite(zMin) || !Number.isFinite(zMax) || zMax < zMin)
+	            return sturmSlices;
+	        const bounded = sturmSlices.filter((s) => {
+	            const z = s.profile?.at?.z;
+	            return Number.isFinite(z) && z >= zMin && z <= zMax;
+	        });
+	        return bounded.length >= 2 ? bounded : sturmSlices;
+	    }
 	    groupByFraunhoferLine(rays) {
 	        const groups = new Map();
 	        for (const ray of rays) {
@@ -8238,21 +8359,17 @@
 	        }
 	        return [...groups.values()].sort((a, b) => this.lineOrder.indexOf(a.line) - this.lineOrder.indexOf(b.line));
 	    }
-	    analyzeSturmSlices(sturmSlices, effectiveCylinderD) {
+	    analyzeSturmSlices(sturmSlices, effectiveCylinderD, profileWorldZBounds) {
 	        const top2MinGapMm = DEFAULT_STURM_TOP2_MIN_GAP_MM;
-	        const top2MinAngleGapDeg = DEFAULT_STURM_TOP2_MIN_ANGLE_GAP_DEG;
 	        const effectiveCylinderThresholdD = DEFAULT_EFFECTIVE_CYLINDER_THRESHOLD_D;
 	        const preferTop2Mid = effectiveCylinderD >= effectiveCylinderThresholdD;
-	        const sortedByFlatness = [...sturmSlices].sort((a, b) => a.ratio - b.ratio);
-	        let flattestTop2 = [];
-	        if (sortedByFlatness.length > 0) {
-	            const first = sortedByFlatness[0];
-	            const second = sortedByFlatness.find((candidate) => (Math.abs(candidate.depth - first.depth) >= top2MinGapMm
-	                && this.axisDiffDeg(candidate.profile.angleMajorDeg, first.profile.angleMajorDeg) >= top2MinAngleGapDeg));
-	            flattestTop2 = second ? [first, second] : [first];
-	        }
+	        const slicesForAnalysis = this.slicesForSturmAnalysis(sturmSlices, profileWorldZBounds ?? null);
+	        const sortedByFlatness = [...slicesForAnalysis].sort((a, b) => a.ratio - b.ratio);
+	        const flattestTop2 = sortedByFlatness.length > 0
+	            ? this.pickFlattestSturmPair(sortedByFlatness, top2MinGapMm, slicesForAnalysis)
+	            : [];
 	        let smallestEllipse = null;
-	        for (const slice of sturmSlices) {
+	        for (const slice of slicesForAnalysis) {
 	            if (!smallestEllipse || slice.size < smallestEllipse.size)
 	                smallestEllipse = slice;
 	        }
@@ -8876,8 +8993,10 @@
 	        const eyeRotXDeg = this.prismComponentToAngleDeg(this.eyePrismEffectVector.x);
 	        const eyeRotYDeg = this.prismComponentToAngleDeg(this.eyePrismEffectVector.y);
 	        this.eyeTiltDeg = this.normalizeEyeTilt(eye?.tilt);
-	        const eyeEulerXDeg = (-eyeRotYDeg) + this.eyeTiltDeg.x;
-	        const eyeEulerYDeg = eyeRotXDeg + this.eyeTiltDeg.y;
+	        // Apply eye deviation in the opposite direction so a lens with the same
+	        // prism/base prescription can optically compensate the eye deviation.
+	        const eyeEulerXDeg = eyeRotYDeg + this.eyeTiltDeg.x;
+	        const eyeEulerYDeg = (-eyeRotXDeg) + this.eyeTiltDeg.y;
 	        this.eyeRotationQuaternion = new Quaternion().setFromEuler(new Euler((eyeEulerXDeg * Math.PI) / 180, (eyeEulerYDeg * Math.PI) / 180, 0, "XYZ"));
 	        this.eyeRotationQuaternionInverse = this.eyeRotationQuaternion.clone().invert();
 	        this.eyeRotationPivot = new Vector3(0, 0, SCAXEngineCore.EYE_ROTATION_PIVOT_FROM_CORNEA_MM);
@@ -9039,10 +9158,22 @@
 	     * - x_deg/y_deg는 프리즘 회전량에 eye.tilt를 합산한 최종 렌더 회전량입니다.
 	     */
 	    getEyeRotation() {
-	        const rx = this.prismVectorFromBase(this.eyePrismPrescription.p, this.eyePrismPrescription.p_ax);
-	        const eyeEffect = this.vectorToPrismInfo(rx.x, rx.y);
-	        const xDeg = this.prismComponentToAngleDeg(eyeEffect.x) + this.eyeTiltDeg.y;
-	        const yDeg = this.prismComponentToAngleDeg(eyeEffect.y) + this.eyeTiltDeg.x;
+	        // Keep render rotation strictly aligned with the internal eye rotation used in ray tracing.
+	        // Internal eye-space Euler:
+	        //   eyeEulerXDeg = eyeRotYDeg + tilt.x
+	        //   eyeEulerYDeg = (-eyeRotXDeg) + tilt.y
+	        // UI mapping (applyEyeRenderRotation):
+	        //   object.rotation.x = -y_deg
+	        //   object.rotation.y =  x_deg
+	        // so we expose:
+	        //   x_deg = eyeEulerYDeg
+	        //   y_deg = -eyeEulerXDeg
+	        const eyeRotXDeg = this.prismComponentToAngleDeg(this.eyePrismEffectVector.x);
+	        const eyeRotYDeg = this.prismComponentToAngleDeg(this.eyePrismEffectVector.y);
+	        const eyeEulerXDeg = eyeRotYDeg + this.eyeTiltDeg.x;
+	        const eyeEulerYDeg = (-eyeRotXDeg) + this.eyeTiltDeg.y;
+	        const xDeg = eyeEulerYDeg;
+	        const yDeg = -eyeEulerXDeg;
 	        return {
 	            x_deg: xDeg,
 	            y_deg: yDeg,
@@ -9102,12 +9233,40 @@
 	        this.tracedRays = traced;
 	        return traced;
 	    }
+	    /**
+	     * Sturm 선초/근사중심에 사용할 슬라이스 centroid(world z) 구간:
+	     * 각막 전면(cornea_anterior) 이상 ~ 망막(retina) + 여유 이하.
+	     */
+	    sturmEyeProfileWorldZBounds() {
+	        let corneaAnteriorZ = Number.POSITIVE_INFINITY;
+	        let retinaZ = Number.NEGATIVE_INFINITY;
+	        for (const surface of this.surfaces) {
+	            const name = String(surface.name || "").toLowerCase();
+	            const z = Number(this.readSurfacePosition(surface)?.z);
+	            if (!Number.isFinite(z))
+	                continue;
+	            if (name.includes("cornea") && name.includes("anterior")) {
+	                corneaAnteriorZ = Math.min(corneaAnteriorZ, z);
+	            }
+	            if (name === "retina") {
+	                retinaZ = Math.max(retinaZ, z);
+	            }
+	        }
+	        if (!Number.isFinite(corneaAnteriorZ) || !Number.isFinite(retinaZ))
+	            return undefined;
+	        if (retinaZ + 1e-9 < corneaAnteriorZ)
+	            return undefined;
+	        return {
+	            zMin: corneaAnteriorZ,
+	            zMax: retinaZ + DEFAULT_STURM_PROFILE_WORLD_Z_PAST_RETINA_MM,
+	        };
+	    }
 	    /**
 	     * 2) Sturm calculation 전용 함수
 	     * traced ray 집합에서 z-scan 기반 Sturm 슬라이스/근사 중심을 계산합니다.
 	     */
 	    sturmCalculation(rays = this.tracedRays) {
-	        this.lastSturmGapAnalysis = this.sturm.calculate(rays, this.effectiveCylinderFromOpticSurfaces(), this.lastSourceRaysForSturm);
+	        this.lastSturmGapAnalysis = this.sturm.calculate(rays, this.effectiveCylinderFromOpticSurfaces(), this.lastSourceRaysForSturm, this.sturmEyeProfileWorldZBounds() ?? null);
 	        return this.lastSturmGapAnalysis;
 	    }
 	    /**

package/dist/types/index.d.ts

@@ -1,5 +1,6 @@
 export { default as SCAXEngine } from "./scax-engine";
 export { SCAXEngineCore } from "./scax-engine";
+export type { SturmProfileWorldZBounds } from "./sturm/sturm";
 export { default as Ray } from "./ray/ray";
 export type { RayProps } from "./ray/ray";
 export type { AffinePair } from "./affine/affine";

package/dist/types/parameters/constants.d.ts

@@ -93,6 +93,12 @@ export declare const FRAUNHOFER_REFRACTIVE_INDICES: {
         d: number;
         C: number;
     };
+    lens_navarro: {
+        F: number;
+        e: number;
+        d: number;
+        C: number;
+    };
     lens_anterior: {
         F: number;
         e: number;
@@ -183,6 +189,19 @@ export declare const DEFAULT_STURM_TOP2_MIN_GAP_MM = 0;
  * Sturm 분석에서 Top2 선택 시 허용하는 최소 축 각도 차(도)
  */
 export declare const DEFAULT_STURM_TOP2_MIN_ANGLE_GAP_DEG = 45;
+/**
+ * Sturm Top2 이각(J0,J45) phasor 내적 상한: cos(Δ₂θ) 이 이 값 이하일 때
+ * 두 주경선을 직교(선초점 쌍)로 취급한다. -1에 가까울수록 엄격.
+ */
+export declare const DEFAULT_STURM_TOP2_PHASOR_OPPOSITION_MAX_DOT = -0.86;
+/**
+ * phasor 직교 판정 실패 시 완화 단계에서 쓰는 내적 상한
+ */
+export declare const DEFAULT_STURM_TOP2_PHASOR_FALLBACK_MAX_DOT = -0.55;
+/**
+ * 축 각·phasor 폴백 후에도 후보가 없을 때 허용하는 최소 각도 차(도)
+ */
+export declare const DEFAULT_STURM_TOP2_AXIS_LAST_RESORT_MIN_GAP_DEG = 22;
 /**
  * 실효 난시량이 이 값(D) 이상이면 U/V 중간점을 CLC 근사 중심으로 우선 사용
  */
@@ -191,4 +210,9 @@ export declare const DEFAULT_EFFECTIVE_CYLINDER_THRESHOLD_D = 0.125;
  * Sturm z-scan 간격(mm)
  */
 export declare const DEFAULT_STURM_STEP_MM = 0.01;
+/**
+ * Sturm 분석 슬라이스의 profile.at.z를 각막(앞)~망막+이 값(mm) 구간으로 한정할 때
+ * 망막 표면 z보다 진행 방향 +z로 허용하는 여유.
+ */
+export declare const DEFAULT_STURM_PROFILE_WORLD_Z_PAST_RETINA_MM = 4;
 //# sourceMappingURL=constants.d.ts.map

package/dist/types/parameters/eye/eyemodel-parameter.d.ts

@@ -1,3 +1,4 @@
+import { RefractiveIndexSpec } from "../../optics/refractive-index";
 import Surface from "../../surfaces/surface";
 interface BaseEyeSurfaceParameter {
     name: string;
@@ -6,15 +7,15 @@ interface BaseEyeSurfaceParameter {
 interface SphericalEyeSurfaceParameter extends BaseEyeSurfaceParameter {
     type: "spherical";
     radius: number;
-    n_before: number;
-    n_after: number;
+    n_before: RefractiveIndexSpec;
+    n_after: RefractiveIndexSpec;
 }
 interface AsphericalEyeSurfaceParameter extends BaseEyeSurfaceParameter {
     type: "aspherical";
     radius: number;
     conic: number;
-    n_before: number;
-    n_after: number;
+    n_before: RefractiveIndexSpec;
+    n_after: RefractiveIndexSpec;
 }
 interface SphericalImageEyeSurfaceParameter extends BaseEyeSurfaceParameter {
     type: "spherical-image";

package/dist/types/scax-engine.d.ts

@@ -169,6 +169,11 @@ export declare class SCAXEngineCore {
      * 광원에서 시작한 광선을 표면 순서대로 굴절시켜 최종 광선 집합을 반환합니다.
      */
     rayTracing(): Ray[];
+    /**
+     * Sturm 선초/근사중심에 사용할 슬라이스 centroid(world z) 구간:
+     * 각막 전면(cornea_anterior) 이상 ~ 망막(retina) + 여유 이하.
+     */
+    private sturmEyeProfileWorldZBounds;
     /**
      * 2) Sturm calculation 전용 함수
      * traced ray 집합에서 z-scan 기반 Sturm 슬라이스/근사 중심을 계산합니다.
@@ -190,6 +195,8 @@ export declare class SCAXEngineCore {
                     wMajor: number;
                     wMinor: number;
                     angleMajorDeg: number;
+                    j0: number;
+                    j45: number;
                     angleMinorDeg: number;
                     majorDirection: {
                         x: number;
@@ -221,6 +228,8 @@ export declare class SCAXEngineCore {
                     wMajor: number;
                     wMinor: number;
                     angleMajorDeg: number;
+                    j0: number;
+                    j45: number;
                     angleMinorDeg: number;
                     majorDirection: {
                         x: number;
@@ -248,6 +257,8 @@ export declare class SCAXEngineCore {
                     wMajor: number;
                     wMinor: number;
                     angleMajorDeg: number;
+                    j0: number;
+                    j45: number;
                     angleMinorDeg: number;
                     majorDirection: {
                         x: number;
@@ -350,6 +361,8 @@ export default class SCAXEngine {
                     wMajor: number;
                     wMinor: number;
                     angleMajorDeg: number;
+                    j0: number;
+                    j45: number;
                     angleMinorDeg: number;
                     majorDirection: {
                         x: number;
@@ -381,6 +394,8 @@ export default class SCAXEngine {
                     wMajor: number;
                     wMinor: number;
                     angleMajorDeg: number;
+                    j0: number;
+                    j45: number;
                     angleMinorDeg: number;
                     majorDirection: {
                         x: number;
@@ -408,6 +423,8 @@ export default class SCAXEngine {
                     wMajor: number;
                     wMinor: number;
                     angleMajorDeg: number;
+                    j0: number;
+                    j45: number;
                     angleMinorDeg: number;
                     majorDirection: {
                         x: number;

package/dist/types/sturm/sturm.d.ts

@@ -1,4 +1,9 @@
 import Ray from "../ray/ray";
+/** Sturm 선초 분석에 사용할 슬라이스 centroid(world) z 구간 [zMin, zMax] (mm) */
+export type SturmProfileWorldZBounds = {
+    zMin: number;
+    zMax: number;
+};
 type FraunhoferLine = "g" | "F" | "e" | "d" | "C" | "r";
 type SturmSlice = {
     z: number;
@@ -14,6 +19,9 @@ type SturmSlice = {
         wMajor: number;
         wMinor: number;
         angleMajorDeg: number;
+        /** 이각 공간 난시 phasor: (cos 2θ, sin 2θ), θ = 주경선 각(rad) */
+        j0: number;
+        j45: number;
         angleMinorDeg: number;
         majorDirection: {
             x: number;
@@ -34,7 +42,7 @@ type SturmSlice = {
  */
 export default class Sturm {
     private lastResult;
-    calculate(rays: Ray[], effectiveCylinderD: number, axisReferenceRays?: Ray[]): {
+    calculate(rays: Ray[], effectiveCylinderD: number, axisReferenceRays?: Ray[], profileWorldZBounds?: SturmProfileWorldZBounds | null): {
         slices_info: {
             count: number;
             slices: SturmSlice[];
@@ -73,7 +81,14 @@ export default class Sturm {
     private secondMomentProfileAtDepth;
     private collectSturmSlices;
     private axisDiffDeg;
+    private phasorDot;
+    /**
+     * 평탄도 순으로 정렬된 슬라이스에서 선초점 쌍(직교 주경선)에 해당하는 Top2를 고른다.
+     * 주경선 각 대신 이각 phasor (cos 2θ, sin 2θ)로 직교를 판정하고, 실패 시 각도·전역 검색·깊이 폴백을 사용한다.
+     */
+    private pickFlattestSturmPair;
     private buildApproxCenter;
+    private slicesForSturmAnalysis;
     private groupByFraunhoferLine;
     private analyzeSturmSlices;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "scax-engine",
-  "version": "0.1.1",
+  "version": "0.1.3",
   "description": "Optical calculation engine for an eye model, with ESM, CJS, and UMD builds.",
   "main": "./dist/scax-engine.cjs",
   "module": "./dist/scax-engine.js",