scax-engine 0.1.2 → 0.1.4

package/README.md

@@ -1,6 +1,6 @@
 # scax-engine
 
-눈 모델(Gullstrand / Navarro)에 대한 광선 추적, Sturm 간격 분석, 아핀 왜곡 추정, 유발 난시·프리즘 편위 계산을 제공하는 TypeScript 안경광학 시뮬레이션(단안 기준, OD) 라이브러리입니다. ESM, CJS, UMD 빌드를 지원합니다.
+눈 모델(Gullstrand / Navarro)에 대한 광선 추적, Sturm 간격 분석, 유발 난시·프리즘 편위 계산을 제공하는 TypeScript 안경광학 시뮬레이션(단안 기준, OD) 라이브러리입니다. ESM, CJS, UMD 빌드를 지원합니다.
 
 
 English documentation: [README-en.md](README-en.md)
@@ -69,7 +69,7 @@ const next = engine.simulate();
 
 ### `new SCAXEngine(props?)`
 
-시뮬레이션 엔진 인스턴스를 생성합니다. 내부 `Sturm`, `Affine` 헬퍼는 인스턴스당 한 번만 생성됩니다.
+시뮬레이션 엔진 인스턴스를 생성합니다. 내부 `Sturm` 헬퍼는 인스턴스당 한 번만 생성됩니다.
 
 #### `props`
 
@@ -103,13 +103,13 @@ const next = engine.simulate();
 
 생성자와 동일한 설정 경로를 다시 실행합니다. `props`를 기준으로 eye / lens / 표면 / 광원을 재구성하며, 생략된 키에는 위 기본값이 적용됩니다.
 
-- `Sturm`, `Affine` 인스턴스는 재생성되지 않지만, `update` 직후에는 Sturm·affine 분석 캐시가 비워지며 `simulate` 등으로 다시 채워집니다.
+- `Sturm` 인스턴스는 재생성되지 않지만, `update` 직후에는 Sturm 분석 캐시가 비워지며 `simulate` 등으로 다시 채워집니다.
 
 ### `engine.dispose()`
 
 엔진 인스턴스가 잡고 있던 추적/분석 캐시와 표면 trace history를 정리합니다.
 
-- 해제 대상: traced rays, Sturm/affine 캐시, surface incident/refracted history
+- 해제 대상: traced rays, Sturm 캐시, surface incident/refracted history
 - UI에서 엔진을 자주 새로 만들 때(예: 프레임별/슬라이더 연속 갱신) 이전 인스턴스에 `dispose()`를 호출하면 메모리 사용량을 안정적으로 유지할 수 있습니다.
 
 ### 인스턴스 메서드
@@ -152,7 +152,6 @@ const next = engine.simulate();
 
 - `sturmCalculation(rays?)` — 추적 광선(인자 생략 시 마지막 `rayTracing`/`simulate` 결과)으로 Sturm 슬라이스·스펙트럼선별 분석 객체를 계산해 반환합니다. `simulate()` 호출 시 내부에서 Sturm도 갱신됩니다.
 
-- `getAffineAnalysis()` — 현재 설정으로 망막 대응점 쌍을 만들어 아핀 적합을 수행(또는 캐시 재사용)합니다. 유효한 쌍이 부족하면 `null`이 될 수 있습니다.
 
 ## UMD
 

package/dist/scax-engine.cjs

@@ -7029,6 +7029,19 @@ const DEFAULT_STURM_TOP2_MIN_GAP_MM = 0.0;
  * 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 근사 중심으로 우선 사용
  */
@@ -7037,6 +7050,11 @@ const DEFAULT_EFFECTIVE_CYLINDER_THRESHOLD_D = 0.125;
  * 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) {
@@ -8008,7 +8026,7 @@ class Sturm {
         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);
@@ -8017,7 +8035,7 @@ class Sturm {
             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,
@@ -8151,6 +8169,9 @@ class Sturm {
         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();
@@ -8160,6 +8181,8 @@ class Sturm {
             wMajor: Math.sqrt(lambdaMajor),
             wMinor: Math.sqrt(lambdaMinor),
             angleMajorDeg,
+            j0,
+            j45,
             angleMinorDeg: (angleMajorDeg + 90) % 180,
             majorDirection: {
                 x: majorDirection.x,
@@ -8197,6 +8220,84 @@ class Sturm {
         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;
@@ -8221,6 +8322,19 @@ class Sturm {
         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) {
@@ -8241,21 +8355,17 @@ class Sturm {
         }
         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;
         }
@@ -8822,7 +8932,7 @@ const TABOToDeg = (TABOAngle) => {
  * legacy simulator.js를 TypeScript로 옮긴 핵심 시뮬레이터입니다.
  * - 광원 광선을 생성하고
  * - 표면들을 순서대로 통과시키며 굴절을 계산한 뒤
- * - 망막 대응쌍, Sturm 분석, 왜곡(affine) 분석까지 제공합니다.
+ * - Sturm 분석까지 제공합니다.
  */
 class SCAXEngineCore {
     constructor(props = {}) {
@@ -8879,8 +8989,10 @@ class SCAXEngineCore {
         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);
@@ -9042,10 +9154,22 @@ class SCAXEngineCore {
      * - 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,
@@ -9105,35 +9229,54 @@ class SCAXEngineCore {
         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;
     }
-    /**
-     * 3) Affine 왜곡 추정 전용 함수
-     * 광선 대응쌍(sx,sy)->(tx,ty)에 대해 최소자승 2D affine을 적합합니다.
-     */
-    estimateAffineDistortion(pairs) {
-        const inputPairs = Array.isArray(pairs) ? pairs : [];
-        this.lastAffineAnalysis = this.affine.estimate(inputPairs);
-        return this.lastAffineAnalysis;
-    }
-    /**
-     * 현재 eye+lens 설정 기준 affine 왜곡 결과를 반환합니다.
-     * traced ray/affine 결과는 기존 계산값을 우선 재사용합니다.
-     */
     getAffineAnalysis() {
+        /*
         if (!this.tracedRays.length) {
-            this.simulate();
+          this.simulate();
         }
         if (!this.lastAffineAnalysis) {
-            this.lastAffineAnalysis = this.estimateAffineDistortion(this.createAffinePairs(this.tracedRays));
+          this.lastAffineAnalysis = this.estimateAffineDistortion(this.createAffinePairs(this.tracedRays));
         }
         return this.lastAffineAnalysis;
+        */
+        // Affine analysis is intentionally disabled for now.
+        return null;
     }
     surfaceOrderZ(surface) {
         const z = Number(this.readSurfacePosition(surface)?.z);
@@ -9385,6 +9528,13 @@ class SCAXEngineCore {
         }
         return 2 * Math.hypot(j0, j45);
     }
+    // Kept for later review/release.
+    estimateAffineDistortion(pairs) {
+        const inputPairs = Array.isArray(pairs) ? pairs : [];
+        this.lastAffineAnalysis = this.affine.estimate(inputPairs);
+        return this.lastAffineAnalysis;
+    }
+    // Kept for later review/release.
     createAffinePairs(rays) {
         return (Array.isArray(rays) ? rays : [])
             .map((ray) => {

package/dist/scax-engine.js

@@ -7027,6 +7027,19 @@ const DEFAULT_STURM_TOP2_MIN_GAP_MM = 0.0;
  * 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 근사 중심으로 우선 사용
  */
@@ -7035,6 +7048,11 @@ const DEFAULT_EFFECTIVE_CYLINDER_THRESHOLD_D = 0.125;
  * 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) {
@@ -8006,7 +8024,7 @@ class Sturm {
         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);
@@ -8015,7 +8033,7 @@ class Sturm {
             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,
@@ -8149,6 +8167,9 @@ class Sturm {
         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();
@@ -8158,6 +8179,8 @@ class Sturm {
             wMajor: Math.sqrt(lambdaMajor),
             wMinor: Math.sqrt(lambdaMinor),
             angleMajorDeg,
+            j0,
+            j45,
             angleMinorDeg: (angleMajorDeg + 90) % 180,
             majorDirection: {
                 x: majorDirection.x,
@@ -8195,6 +8218,84 @@ class Sturm {
         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;
@@ -8219,6 +8320,19 @@ class Sturm {
         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) {
@@ -8239,21 +8353,17 @@ class Sturm {
         }
         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;
         }
@@ -8820,7 +8930,7 @@ const TABOToDeg = (TABOAngle) => {
  * legacy simulator.js를 TypeScript로 옮긴 핵심 시뮬레이터입니다.
  * - 광원 광선을 생성하고
  * - 표면들을 순서대로 통과시키며 굴절을 계산한 뒤
- * - 망막 대응쌍, Sturm 분석, 왜곡(affine) 분석까지 제공합니다.
+ * - Sturm 분석까지 제공합니다.
  */
 class SCAXEngineCore {
     constructor(props = {}) {
@@ -8877,8 +8987,10 @@ class SCAXEngineCore {
         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);
@@ -9040,10 +9152,22 @@ class SCAXEngineCore {
      * - 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,
@@ -9103,35 +9227,54 @@ class SCAXEngineCore {
         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;
     }
-    /**
-     * 3) Affine 왜곡 추정 전용 함수
-     * 광선 대응쌍(sx,sy)->(tx,ty)에 대해 최소자승 2D affine을 적합합니다.
-     */
-    estimateAffineDistortion(pairs) {
-        const inputPairs = Array.isArray(pairs) ? pairs : [];
-        this.lastAffineAnalysis = this.affine.estimate(inputPairs);
-        return this.lastAffineAnalysis;
-    }
-    /**
-     * 현재 eye+lens 설정 기준 affine 왜곡 결과를 반환합니다.
-     * traced ray/affine 결과는 기존 계산값을 우선 재사용합니다.
-     */
     getAffineAnalysis() {
+        /*
         if (!this.tracedRays.length) {
-            this.simulate();
+          this.simulate();
         }
         if (!this.lastAffineAnalysis) {
-            this.lastAffineAnalysis = this.estimateAffineDistortion(this.createAffinePairs(this.tracedRays));
+          this.lastAffineAnalysis = this.estimateAffineDistortion(this.createAffinePairs(this.tracedRays));
         }
         return this.lastAffineAnalysis;
+        */
+        // Affine analysis is intentionally disabled for now.
+        return null;
     }
     surfaceOrderZ(surface) {
         const z = Number(this.readSurfacePosition(surface)?.z);
@@ -9383,6 +9526,13 @@ class SCAXEngineCore {
         }
         return 2 * Math.hypot(j0, j45);
     }
+    // Kept for later review/release.
+    estimateAffineDistortion(pairs) {
+        const inputPairs = Array.isArray(pairs) ? pairs : [];
+        this.lastAffineAnalysis = this.affine.estimate(inputPairs);
+        return this.lastAffineAnalysis;
+    }
+    // Kept for later review/release.
     createAffinePairs(rays) {
         return (Array.isArray(rays) ? rays : [])
             .map((ray) => {

package/dist/scax-engine.umd.js

@@ -7033,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 근사 중심으로 우선 사용
 	 */
@@ -7041,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) {
@@ -8012,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);
@@ -8021,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,
@@ -8155,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();
@@ -8164,6 +8185,8 @@
 	            wMajor: Math.sqrt(lambdaMajor),
 	            wMinor: Math.sqrt(lambdaMinor),
 	            angleMajorDeg,
+	            j0,
+	            j45,
 	            angleMinorDeg: (angleMajorDeg + 90) % 180,
 	            majorDirection: {
 	                x: majorDirection.x,
@@ -8201,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;
@@ -8225,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) {
@@ -8245,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;
 	        }
@@ -8826,7 +8936,7 @@
 	 * legacy simulator.js를 TypeScript로 옮긴 핵심 시뮬레이터입니다.
 	 * - 광원 광선을 생성하고
 	 * - 표면들을 순서대로 통과시키며 굴절을 계산한 뒤
-	 * - 망막 대응쌍, Sturm 분석, 왜곡(affine) 분석까지 제공합니다.
+	 * - Sturm 분석까지 제공합니다.
 	 */
 	class SCAXEngineCore {
 	    constructor(props = {}) {
@@ -8883,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);
@@ -9046,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,
@@ -9109,35 +9233,54 @@
 	        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;
 	    }
-	    /**
-	     * 3) Affine 왜곡 추정 전용 함수
-	     * 광선 대응쌍(sx,sy)->(tx,ty)에 대해 최소자승 2D affine을 적합합니다.
-	     */
-	    estimateAffineDistortion(pairs) {
-	        const inputPairs = Array.isArray(pairs) ? pairs : [];
-	        this.lastAffineAnalysis = this.affine.estimate(inputPairs);
-	        return this.lastAffineAnalysis;
-	    }
-	    /**
-	     * 현재 eye+lens 설정 기준 affine 왜곡 결과를 반환합니다.
-	     * traced ray/affine 결과는 기존 계산값을 우선 재사용합니다.
-	     */
 	    getAffineAnalysis() {
+	        /*
 	        if (!this.tracedRays.length) {
-	            this.simulate();
+	          this.simulate();
 	        }
 	        if (!this.lastAffineAnalysis) {
-	            this.lastAffineAnalysis = this.estimateAffineDistortion(this.createAffinePairs(this.tracedRays));
+	          this.lastAffineAnalysis = this.estimateAffineDistortion(this.createAffinePairs(this.tracedRays));
 	        }
 	        return this.lastAffineAnalysis;
+	        */
+	        // Affine analysis is intentionally disabled for now.
+	        return null;
 	    }
 	    surfaceOrderZ(surface) {
 	        const z = Number(this.readSurfacePosition(surface)?.z);
@@ -9389,6 +9532,13 @@
 	        }
 	        return 2 * Math.hypot(j0, j45);
 	    }
+	    // Kept for later review/release.
+	    estimateAffineDistortion(pairs) {
+	        const inputPairs = Array.isArray(pairs) ? pairs : [];
+	        this.lastAffineAnalysis = this.affine.estimate(inputPairs);
+	        return this.lastAffineAnalysis;
+	    }
+	    // Kept for later review/release.
 	    createAffinePairs(rays) {
 	        return (Array.isArray(rays) ? rays : [])
 	            .map((ray) => {

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

@@ -189,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 근사 중심으로 우선 사용
  */
@@ -197,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/scax-engine.d.ts

@@ -112,7 +112,7 @@ export type AffineAnalysisResult = ReturnType<Affine["estimate"]>;
  * legacy simulator.js를 TypeScript로 옮긴 핵심 시뮬레이터입니다.
  * - 광원 광선을 생성하고
  * - 표면들을 순서대로 통과시키며 굴절을 계산한 뒤
- * - 망막 대응쌍, Sturm 분석, 왜곡(affine) 분석까지 제공합니다.
+ * - Sturm 분석까지 제공합니다.
  */
 export declare class SCAXEngineCore {
     private static readonly EYE_ROTATION_PIVOT_FROM_CORNEA_MM;
@@ -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;
@@ -278,15 +289,6 @@ export declare class SCAXEngineCore {
             };
         }[];
     };
-    /**
-     * 3) Affine 왜곡 추정 전용 함수
-     * 광선 대응쌍(sx,sy)->(tx,ty)에 대해 최소자승 2D affine을 적합합니다.
-     */
-    private estimateAffineDistortion;
-    /**
-     * 현재 eye+lens 설정 기준 affine 왜곡 결과를 반환합니다.
-     * traced ray/affine 결과는 기존 계산값을 우선 재사용합니다.
-     */
     getAffineAnalysis(): AffineAnalysisResult;
     private surfaceOrderZ;
     private readSurfacePosition;
@@ -316,6 +318,7 @@ export declare class SCAXEngineCore {
     private applyLightSourceTransformToRay;
     private calculateLightDeviation;
     private effectiveCylinderFromOpticSurfaces;
+    private estimateAffineDistortion;
     private createAffinePairs;
 }
 /**
@@ -350,6 +353,8 @@ export default class SCAXEngine {
                     wMajor: number;
                     wMinor: number;
                     angleMajorDeg: number;
+                    j0: number;
+                    j45: number;
                     angleMinorDeg: number;
                     majorDirection: {
                         x: number;
@@ -381,6 +386,8 @@ export default class SCAXEngine {
                     wMajor: number;
                     wMinor: number;
                     angleMajorDeg: number;
+                    j0: number;
+                    j45: number;
                     angleMinorDeg: number;
                     majorDirection: {
                         x: number;
@@ -408,6 +415,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.2",
+  "version": "0.1.4",
   "description": "Optical calculation engine for an eye model, with ESM, CJS, and UMD builds.",
   "main": "./dist/scax-engine.cjs",
   "module": "./dist/scax-engine.js",