scax-engine 0.1.1 → 0.1.3

package/dist/scax-engine.js

@@ -6930,6 +6930,13 @@ const FRAUNHOFER_REFRACTIVE_INDICES = {
         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,
@@ -7020,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 근사 중심으로 우선 사용
  */
@@ -7028,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) {
@@ -7883,48 +7908,48 @@ GullstrandParameter.parameter = {
             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",
@@ -7950,8 +7975,8 @@ NavarroParameter.parameter = {
             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",
@@ -7959,8 +7984,8 @@ NavarroParameter.parameter = {
             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",
@@ -7968,8 +7993,8 @@ NavarroParameter.parameter = {
             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",
@@ -7977,8 +8002,8 @@ NavarroParameter.parameter = {
             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",
@@ -7999,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);
@@ -8008,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,
@@ -8142,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();
@@ -8151,6 +8179,8 @@ class Sturm {
             wMajor: Math.sqrt(lambdaMajor),
             wMinor: Math.sqrt(lambdaMinor),
             angleMajorDeg,
+            j0,
+            j45,
             angleMinorDeg: (angleMajorDeg + 90) % 180,
             majorDirection: {
                 x: majorDirection.x,
@@ -8188,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;
@@ -8212,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) {
@@ -8232,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;
         }
@@ -8870,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);
@@ -9033,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,
@@ -9096,12 +9227,40 @@ 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;
     }
     /**