scax-engine 0.2.0-beta.1 → 0.2.0-beta.2

package/dist/scax-engine.cjs

@@ -7013,119 +7013,6 @@ class Ray {
     }
 }
 
-/**
- * 2D affine 왜곡 추정 전용 클래스입니다.
- * [x'; y'] = [[a b c], [d e f]] * [x y 1]^T 형태를 최소자승으로 적합합니다.
- */
-class Affine {
-    constructor() {
-        this.lastResult = null;
-        this.lastPairs = [];
-    }
-    estimate(pairs) {
-        const inputPairs = Array.isArray(pairs) ? pairs : [];
-        this.lastPairs = inputPairs;
-        const affine = this.fitAffine2D(inputPairs);
-        if (!affine) {
-            this.lastResult = null;
-            return null;
-        }
-        let residualSumPct = 0;
-        let residualCount = 0;
-        let residualMaxPct = 0;
-        const residuals = [];
-        for (const pair of inputPairs) {
-            const px = affine.a * pair.sx + affine.b * pair.sy + affine.c;
-            const py = affine.d * pair.sx + affine.e * pair.sy + affine.f;
-            const rx = pair.tx - px;
-            const ry = pair.ty - py;
-            const magnitude = Math.hypot(rx, ry);
-            if (magnitude < 1e-4)
-                continue;
-            const radiusRef = Math.hypot(px, py);
-            const pct = (magnitude / Math.max(0.2, radiusRef)) * 100;
-            residualSumPct += pct;
-            residualCount += 1;
-            residualMaxPct = Math.max(residualMaxPct, pct);
-            residuals.push({ sx: pair.sx, sy: pair.sy, px, py, rx, ry, magnitude, pct });
-        }
-        const result = {
-            ...affine,
-            count: inputPairs.length,
-            residualAvgPct: residualCount ? residualSumPct / residualCount : 0,
-            residualMaxPct,
-            residuals,
-        };
-        this.lastResult = result;
-        return result;
-    }
-    /**
-     * 마지막 affine 추정 결과를 반환합니다.
-     */
-    getLastResult() {
-        return this.lastResult;
-    }
-    /**
-     * 마지막 affine 추정에 사용된 입력쌍을 반환합니다.
-     */
-    getLastPairs() {
-        return [...this.lastPairs];
-    }
-    fitAffine2D(pairs) {
-        if (!Array.isArray(pairs) || pairs.length < 4)
-            return null;
-        const ata = Array.from({ length: 6 }, () => Array(6).fill(0));
-        const atb = Array(6).fill(0);
-        const accumulate = (row, rhs) => {
-            for (let i = 0; i < 6; i += 1) {
-                atb[i] += row[i] * rhs;
-                for (let j = 0; j < 6; j += 1)
-                    ata[i][j] += row[i] * row[j];
-            }
-        };
-        for (const pair of pairs) {
-            accumulate([pair.sx, pair.sy, 1, 0, 0, 0], pair.tx);
-            accumulate([0, 0, 0, pair.sx, pair.sy, 1], pair.ty);
-        }
-        const n = 6;
-        const aug = ata.map((row, index) => [...row, atb[index]]);
-        for (let col = 0; col < n; col += 1) {
-            let pivot = col;
-            for (let row = col + 1; row < n; row += 1) {
-                if (Math.abs(aug[row][col]) > Math.abs(aug[pivot][col]))
-                    pivot = row;
-            }
-            if (Math.abs(aug[pivot][col]) < 1e-10)
-                return null;
-            if (pivot !== col) {
-                const temp = aug[col];
-                aug[col] = aug[pivot];
-                aug[pivot] = temp;
-            }
-            const divider = aug[col][col];
-            for (let j = col; j <= n; j += 1)
-                aug[col][j] /= divider;
-            for (let row = 0; row < n; row += 1) {
-                if (row === col)
-                    continue;
-                const factor = aug[row][col];
-                if (Math.abs(factor) < 1e-12)
-                    continue;
-                for (let j = col; j <= n; j += 1)
-                    aug[row][j] -= factor * aug[col][j];
-            }
-        }
-        return {
-            a: aug[0][n],
-            b: aug[1][n],
-            c: aug[2][n],
-            d: aug[3][n],
-            e: aug[4][n],
-            f: aug[5][n],
-        };
-    }
-}
-
 class LightSource {
     constructor() {
         this.rays = [];
@@ -7337,6 +7224,156 @@ class RadialLightSource extends LightSource {
     }
 }
 
+class Surface {
+    constructor(props) {
+        this.type = "";
+        this.name = "";
+        this.position = new Vector3(0, 0, 0);
+        this.tilt = new Vector2(0, 0);
+        this.meridians = [];
+        const { type, name, position, tilt } = props;
+        this.type = type;
+        this.name = name;
+        this.position = new Vector3(position.x, position.y, position.z);
+        this.tilt = new Vector2(tilt.x, tilt.y);
+        this.incidentRays = [];
+        this.refractedRays = [];
+    }
+    clearTraceHistory() {
+        this.incidentRays = [];
+        this.refractedRays = [];
+    }
+    getWorldPosition() {
+        return this.position.clone();
+    }
+    setPositionAndTilt(position, tiltXDeg, tiltYDeg) {
+        this.position.copy(position);
+        this.tilt.set(tiltXDeg, tiltYDeg);
+    }
+    /**
+     * 안질 tilt가 0인 표면을 전제로, pivot 기준 강체 회전 후 동일 Euler(XYZ) tilt를 부여합니다.
+     */
+    applyRigidRotationAboutPivot(pivot, rotation) {
+        const p1 = pivot.clone().add(new Vector3().subVectors(this.position, pivot).applyQuaternion(rotation));
+        const euler = new Euler().setFromQuaternion(rotation, "XYZ");
+        this.position.copy(p1);
+        this.tilt.set((euler.x * 180) / Math.PI, (euler.y * 180) / Math.PI);
+    }
+}
+
+/**
+ * 2D affine 왜곡 추정 전용 클래스입니다.
+ * [x'; y'] = [[a b c], [d e f]] * [x y 1]^T 형태를 최소자승으로 적합합니다.
+ */
+class Affine {
+    constructor() {
+        this.lastResult = null;
+        this.lastPairs = [];
+    }
+    estimate(pairs) {
+        const inputPairs = Array.isArray(pairs) ? pairs : [];
+        this.lastPairs = inputPairs;
+        const affine = this.fitAffine2D(inputPairs);
+        if (!affine) {
+            this.lastResult = null;
+            return null;
+        }
+        let residualSumPct = 0;
+        let residualCount = 0;
+        let residualMaxPct = 0;
+        const residuals = [];
+        for (const pair of inputPairs) {
+            const px = affine.a * pair.sx + affine.b * pair.sy + affine.c;
+            const py = affine.d * pair.sx + affine.e * pair.sy + affine.f;
+            const rx = pair.tx - px;
+            const ry = pair.ty - py;
+            const magnitude = Math.hypot(rx, ry);
+            if (magnitude < 1e-4)
+                continue;
+            const radiusRef = Math.hypot(px, py);
+            const pct = (magnitude / Math.max(0.2, radiusRef)) * 100;
+            residualSumPct += pct;
+            residualCount += 1;
+            residualMaxPct = Math.max(residualMaxPct, pct);
+            residuals.push({ sx: pair.sx, sy: pair.sy, px, py, rx, ry, magnitude, pct });
+        }
+        const result = {
+            ...affine,
+            count: inputPairs.length,
+            residualAvgPct: residualCount ? residualSumPct / residualCount : 0,
+            residualMaxPct,
+            residuals,
+        };
+        this.lastResult = result;
+        return result;
+    }
+    /**
+     * 마지막 affine 추정 결과를 반환합니다.
+     */
+    getLastResult() {
+        return this.lastResult;
+    }
+    /**
+     * 마지막 affine 추정에 사용된 입력쌍을 반환합니다.
+     */
+    getLastPairs() {
+        return [...this.lastPairs];
+    }
+    fitAffine2D(pairs) {
+        if (!Array.isArray(pairs) || pairs.length < 4)
+            return null;
+        const ata = Array.from({ length: 6 }, () => Array(6).fill(0));
+        const atb = Array(6).fill(0);
+        const accumulate = (row, rhs) => {
+            for (let i = 0; i < 6; i += 1) {
+                atb[i] += row[i] * rhs;
+                for (let j = 0; j < 6; j += 1)
+                    ata[i][j] += row[i] * row[j];
+            }
+        };
+        for (const pair of pairs) {
+            accumulate([pair.sx, pair.sy, 1, 0, 0, 0], pair.tx);
+            accumulate([0, 0, 0, pair.sx, pair.sy, 1], pair.ty);
+        }
+        const n = 6;
+        const aug = ata.map((row, index) => [...row, atb[index]]);
+        for (let col = 0; col < n; col += 1) {
+            let pivot = col;
+            for (let row = col + 1; row < n; row += 1) {
+                if (Math.abs(aug[row][col]) > Math.abs(aug[pivot][col]))
+                    pivot = row;
+            }
+            if (Math.abs(aug[pivot][col]) < 1e-10)
+                return null;
+            if (pivot !== col) {
+                const temp = aug[col];
+                aug[col] = aug[pivot];
+                aug[pivot] = temp;
+            }
+            const divider = aug[col][col];
+            for (let j = col; j <= n; j += 1)
+                aug[col][j] /= divider;
+            for (let row = 0; row < n; row += 1) {
+                if (row === col)
+                    continue;
+                const factor = aug[row][col];
+                if (Math.abs(factor) < 1e-12)
+                    continue;
+                for (let j = col; j <= n; j += 1)
+                    aug[row][j] -= factor * aug[col][j];
+            }
+        }
+        return {
+            a: aug[0][n],
+            b: aug[1][n],
+            c: aug[2][n],
+            d: aug[3][n],
+            e: aug[4][n],
+            f: aug[5][n],
+        };
+    }
+}
+
 /** 각막 기준 안구 회전점 z(mm). `SCAXEngineCore`와 동일. */
 const EYE_ROTATION_PIVOT_FROM_CORNEA_MM = 13;
 function normalizePrismAmount$2(value) {
@@ -7409,43 +7446,6 @@ function applyRigidEyePoseToSurfaces(surfaces, pivot, rotation) {
     }
 }
 
-class Surface {
-    constructor(props) {
-        this.type = "";
-        this.name = "";
-        this.position = new Vector3(0, 0, 0);
-        this.tilt = new Vector2(0, 0);
-        this.meridians = [];
-        const { type, name, position, tilt } = props;
-        this.type = type;
-        this.name = name;
-        this.position = new Vector3(position.x, position.y, position.z);
-        this.tilt = new Vector2(tilt.x, tilt.y);
-        this.incidentRays = [];
-        this.refractedRays = [];
-    }
-    clearTraceHistory() {
-        this.incidentRays = [];
-        this.refractedRays = [];
-    }
-    getWorldPosition() {
-        return this.position.clone();
-    }
-    setPositionAndTilt(position, tiltXDeg, tiltYDeg) {
-        this.position.copy(position);
-        this.tilt.set(tiltXDeg, tiltYDeg);
-    }
-    /**
-     * 안질 tilt가 0인 표면을 전제로, pivot 기준 강체 회전 후 동일 Euler(XYZ) tilt를 부여합니다.
-     */
-    applyRigidRotationAboutPivot(pivot, rotation) {
-        const p1 = pivot.clone().add(new Vector3().subVectors(this.position, pivot).applyQuaternion(rotation));
-        const euler = new Euler().setFromQuaternion(rotation, "XYZ");
-        this.position.copy(p1);
-        this.tilt.set((euler.x * 180) / Math.PI, (euler.y * 180) / Math.PI);
-    }
-}
-
 class ApertureStopSurface extends Surface {
     constructor(props) {
         super({
@@ -9641,7 +9641,9 @@ class SCAXEngine {
     }
 }
 
+exports.LightSource = LightSource;
 exports.Ray = Ray;
 exports.SCAXEngine = SCAXEngine;
 exports.SCAXEngineCore = SCAXEngineCore;
+exports.Surface = Surface;
 //# sourceMappingURL=scax-engine.cjs.map

package/dist/scax-engine.js

@@ -7011,119 +7011,6 @@ class Ray {
     }
 }
 
-/**
- * 2D affine 왜곡 추정 전용 클래스입니다.
- * [x'; y'] = [[a b c], [d e f]] * [x y 1]^T 형태를 최소자승으로 적합합니다.
- */
-class Affine {
-    constructor() {
-        this.lastResult = null;
-        this.lastPairs = [];
-    }
-    estimate(pairs) {
-        const inputPairs = Array.isArray(pairs) ? pairs : [];
-        this.lastPairs = inputPairs;
-        const affine = this.fitAffine2D(inputPairs);
-        if (!affine) {
-            this.lastResult = null;
-            return null;
-        }
-        let residualSumPct = 0;
-        let residualCount = 0;
-        let residualMaxPct = 0;
-        const residuals = [];
-        for (const pair of inputPairs) {
-            const px = affine.a * pair.sx + affine.b * pair.sy + affine.c;
-            const py = affine.d * pair.sx + affine.e * pair.sy + affine.f;
-            const rx = pair.tx - px;
-            const ry = pair.ty - py;
-            const magnitude = Math.hypot(rx, ry);
-            if (magnitude < 1e-4)
-                continue;
-            const radiusRef = Math.hypot(px, py);
-            const pct = (magnitude / Math.max(0.2, radiusRef)) * 100;
-            residualSumPct += pct;
-            residualCount += 1;
-            residualMaxPct = Math.max(residualMaxPct, pct);
-            residuals.push({ sx: pair.sx, sy: pair.sy, px, py, rx, ry, magnitude, pct });
-        }
-        const result = {
-            ...affine,
-            count: inputPairs.length,
-            residualAvgPct: residualCount ? residualSumPct / residualCount : 0,
-            residualMaxPct,
-            residuals,
-        };
-        this.lastResult = result;
-        return result;
-    }
-    /**
-     * 마지막 affine 추정 결과를 반환합니다.
-     */
-    getLastResult() {
-        return this.lastResult;
-    }
-    /**
-     * 마지막 affine 추정에 사용된 입력쌍을 반환합니다.
-     */
-    getLastPairs() {
-        return [...this.lastPairs];
-    }
-    fitAffine2D(pairs) {
-        if (!Array.isArray(pairs) || pairs.length < 4)
-            return null;
-        const ata = Array.from({ length: 6 }, () => Array(6).fill(0));
-        const atb = Array(6).fill(0);
-        const accumulate = (row, rhs) => {
-            for (let i = 0; i < 6; i += 1) {
-                atb[i] += row[i] * rhs;
-                for (let j = 0; j < 6; j += 1)
-                    ata[i][j] += row[i] * row[j];
-            }
-        };
-        for (const pair of pairs) {
-            accumulate([pair.sx, pair.sy, 1, 0, 0, 0], pair.tx);
-            accumulate([0, 0, 0, pair.sx, pair.sy, 1], pair.ty);
-        }
-        const n = 6;
-        const aug = ata.map((row, index) => [...row, atb[index]]);
-        for (let col = 0; col < n; col += 1) {
-            let pivot = col;
-            for (let row = col + 1; row < n; row += 1) {
-                if (Math.abs(aug[row][col]) > Math.abs(aug[pivot][col]))
-                    pivot = row;
-            }
-            if (Math.abs(aug[pivot][col]) < 1e-10)
-                return null;
-            if (pivot !== col) {
-                const temp = aug[col];
-                aug[col] = aug[pivot];
-                aug[pivot] = temp;
-            }
-            const divider = aug[col][col];
-            for (let j = col; j <= n; j += 1)
-                aug[col][j] /= divider;
-            for (let row = 0; row < n; row += 1) {
-                if (row === col)
-                    continue;
-                const factor = aug[row][col];
-                if (Math.abs(factor) < 1e-12)
-                    continue;
-                for (let j = col; j <= n; j += 1)
-                    aug[row][j] -= factor * aug[col][j];
-            }
-        }
-        return {
-            a: aug[0][n],
-            b: aug[1][n],
-            c: aug[2][n],
-            d: aug[3][n],
-            e: aug[4][n],
-            f: aug[5][n],
-        };
-    }
-}
-
 class LightSource {
     constructor() {
         this.rays = [];
@@ -7335,6 +7222,156 @@ class RadialLightSource extends LightSource {
     }
 }
 
+class Surface {
+    constructor(props) {
+        this.type = "";
+        this.name = "";
+        this.position = new Vector3(0, 0, 0);
+        this.tilt = new Vector2(0, 0);
+        this.meridians = [];
+        const { type, name, position, tilt } = props;
+        this.type = type;
+        this.name = name;
+        this.position = new Vector3(position.x, position.y, position.z);
+        this.tilt = new Vector2(tilt.x, tilt.y);
+        this.incidentRays = [];
+        this.refractedRays = [];
+    }
+    clearTraceHistory() {
+        this.incidentRays = [];
+        this.refractedRays = [];
+    }
+    getWorldPosition() {
+        return this.position.clone();
+    }
+    setPositionAndTilt(position, tiltXDeg, tiltYDeg) {
+        this.position.copy(position);
+        this.tilt.set(tiltXDeg, tiltYDeg);
+    }
+    /**
+     * 안질 tilt가 0인 표면을 전제로, pivot 기준 강체 회전 후 동일 Euler(XYZ) tilt를 부여합니다.
+     */
+    applyRigidRotationAboutPivot(pivot, rotation) {
+        const p1 = pivot.clone().add(new Vector3().subVectors(this.position, pivot).applyQuaternion(rotation));
+        const euler = new Euler().setFromQuaternion(rotation, "XYZ");
+        this.position.copy(p1);
+        this.tilt.set((euler.x * 180) / Math.PI, (euler.y * 180) / Math.PI);
+    }
+}
+
+/**
+ * 2D affine 왜곡 추정 전용 클래스입니다.
+ * [x'; y'] = [[a b c], [d e f]] * [x y 1]^T 형태를 최소자승으로 적합합니다.
+ */
+class Affine {
+    constructor() {
+        this.lastResult = null;
+        this.lastPairs = [];
+    }
+    estimate(pairs) {
+        const inputPairs = Array.isArray(pairs) ? pairs : [];
+        this.lastPairs = inputPairs;
+        const affine = this.fitAffine2D(inputPairs);
+        if (!affine) {
+            this.lastResult = null;
+            return null;
+        }
+        let residualSumPct = 0;
+        let residualCount = 0;
+        let residualMaxPct = 0;
+        const residuals = [];
+        for (const pair of inputPairs) {
+            const px = affine.a * pair.sx + affine.b * pair.sy + affine.c;
+            const py = affine.d * pair.sx + affine.e * pair.sy + affine.f;
+            const rx = pair.tx - px;
+            const ry = pair.ty - py;
+            const magnitude = Math.hypot(rx, ry);
+            if (magnitude < 1e-4)
+                continue;
+            const radiusRef = Math.hypot(px, py);
+            const pct = (magnitude / Math.max(0.2, radiusRef)) * 100;
+            residualSumPct += pct;
+            residualCount += 1;
+            residualMaxPct = Math.max(residualMaxPct, pct);
+            residuals.push({ sx: pair.sx, sy: pair.sy, px, py, rx, ry, magnitude, pct });
+        }
+        const result = {
+            ...affine,
+            count: inputPairs.length,
+            residualAvgPct: residualCount ? residualSumPct / residualCount : 0,
+            residualMaxPct,
+            residuals,
+        };
+        this.lastResult = result;
+        return result;
+    }
+    /**
+     * 마지막 affine 추정 결과를 반환합니다.
+     */
+    getLastResult() {
+        return this.lastResult;
+    }
+    /**
+     * 마지막 affine 추정에 사용된 입력쌍을 반환합니다.
+     */
+    getLastPairs() {
+        return [...this.lastPairs];
+    }
+    fitAffine2D(pairs) {
+        if (!Array.isArray(pairs) || pairs.length < 4)
+            return null;
+        const ata = Array.from({ length: 6 }, () => Array(6).fill(0));
+        const atb = Array(6).fill(0);
+        const accumulate = (row, rhs) => {
+            for (let i = 0; i < 6; i += 1) {
+                atb[i] += row[i] * rhs;
+                for (let j = 0; j < 6; j += 1)
+                    ata[i][j] += row[i] * row[j];
+            }
+        };
+        for (const pair of pairs) {
+            accumulate([pair.sx, pair.sy, 1, 0, 0, 0], pair.tx);
+            accumulate([0, 0, 0, pair.sx, pair.sy, 1], pair.ty);
+        }
+        const n = 6;
+        const aug = ata.map((row, index) => [...row, atb[index]]);
+        for (let col = 0; col < n; col += 1) {
+            let pivot = col;
+            for (let row = col + 1; row < n; row += 1) {
+                if (Math.abs(aug[row][col]) > Math.abs(aug[pivot][col]))
+                    pivot = row;
+            }
+            if (Math.abs(aug[pivot][col]) < 1e-10)
+                return null;
+            if (pivot !== col) {
+                const temp = aug[col];
+                aug[col] = aug[pivot];
+                aug[pivot] = temp;
+            }
+            const divider = aug[col][col];
+            for (let j = col; j <= n; j += 1)
+                aug[col][j] /= divider;
+            for (let row = 0; row < n; row += 1) {
+                if (row === col)
+                    continue;
+                const factor = aug[row][col];
+                if (Math.abs(factor) < 1e-12)
+                    continue;
+                for (let j = col; j <= n; j += 1)
+                    aug[row][j] -= factor * aug[col][j];
+            }
+        }
+        return {
+            a: aug[0][n],
+            b: aug[1][n],
+            c: aug[2][n],
+            d: aug[3][n],
+            e: aug[4][n],
+            f: aug[5][n],
+        };
+    }
+}
+
 /** 각막 기준 안구 회전점 z(mm). `SCAXEngineCore`와 동일. */
 const EYE_ROTATION_PIVOT_FROM_CORNEA_MM = 13;
 function normalizePrismAmount$2(value) {
@@ -7407,43 +7444,6 @@ function applyRigidEyePoseToSurfaces(surfaces, pivot, rotation) {
     }
 }
 
-class Surface {
-    constructor(props) {
-        this.type = "";
-        this.name = "";
-        this.position = new Vector3(0, 0, 0);
-        this.tilt = new Vector2(0, 0);
-        this.meridians = [];
-        const { type, name, position, tilt } = props;
-        this.type = type;
-        this.name = name;
-        this.position = new Vector3(position.x, position.y, position.z);
-        this.tilt = new Vector2(tilt.x, tilt.y);
-        this.incidentRays = [];
-        this.refractedRays = [];
-    }
-    clearTraceHistory() {
-        this.incidentRays = [];
-        this.refractedRays = [];
-    }
-    getWorldPosition() {
-        return this.position.clone();
-    }
-    setPositionAndTilt(position, tiltXDeg, tiltYDeg) {
-        this.position.copy(position);
-        this.tilt.set(tiltXDeg, tiltYDeg);
-    }
-    /**
-     * 안질 tilt가 0인 표면을 전제로, pivot 기준 강체 회전 후 동일 Euler(XYZ) tilt를 부여합니다.
-     */
-    applyRigidRotationAboutPivot(pivot, rotation) {
-        const p1 = pivot.clone().add(new Vector3().subVectors(this.position, pivot).applyQuaternion(rotation));
-        const euler = new Euler().setFromQuaternion(rotation, "XYZ");
-        this.position.copy(p1);
-        this.tilt.set((euler.x * 180) / Math.PI, (euler.y * 180) / Math.PI);
-    }
-}
-
 class ApertureStopSurface extends Surface {
     constructor(props) {
         super({
@@ -9639,5 +9639,5 @@ class SCAXEngine {
     }
 }
 
-export { Ray, SCAXEngine, SCAXEngineCore };
+export { LightSource, Ray, SCAXEngine, SCAXEngineCore, Surface };
 //# sourceMappingURL=scax-engine.js.map

package/dist/scax-engine.umd.js

@@ -7017,119 +7017,6 @@
 	    }
 	}
 
-	/**
-	 * 2D affine 왜곡 추정 전용 클래스입니다.
-	 * [x'; y'] = [[a b c], [d e f]] * [x y 1]^T 형태를 최소자승으로 적합합니다.
-	 */
-	class Affine {
-	    constructor() {
-	        this.lastResult = null;
-	        this.lastPairs = [];
-	    }
-	    estimate(pairs) {
-	        const inputPairs = Array.isArray(pairs) ? pairs : [];
-	        this.lastPairs = inputPairs;
-	        const affine = this.fitAffine2D(inputPairs);
-	        if (!affine) {
-	            this.lastResult = null;
-	            return null;
-	        }
-	        let residualSumPct = 0;
-	        let residualCount = 0;
-	        let residualMaxPct = 0;
-	        const residuals = [];
-	        for (const pair of inputPairs) {
-	            const px = affine.a * pair.sx + affine.b * pair.sy + affine.c;
-	            const py = affine.d * pair.sx + affine.e * pair.sy + affine.f;
-	            const rx = pair.tx - px;
-	            const ry = pair.ty - py;
-	            const magnitude = Math.hypot(rx, ry);
-	            if (magnitude < 1e-4)
-	                continue;
-	            const radiusRef = Math.hypot(px, py);
-	            const pct = (magnitude / Math.max(0.2, radiusRef)) * 100;
-	            residualSumPct += pct;
-	            residualCount += 1;
-	            residualMaxPct = Math.max(residualMaxPct, pct);
-	            residuals.push({ sx: pair.sx, sy: pair.sy, px, py, rx, ry, magnitude, pct });
-	        }
-	        const result = {
-	            ...affine,
-	            count: inputPairs.length,
-	            residualAvgPct: residualCount ? residualSumPct / residualCount : 0,
-	            residualMaxPct,
-	            residuals,
-	        };
-	        this.lastResult = result;
-	        return result;
-	    }
-	    /**
-	     * 마지막 affine 추정 결과를 반환합니다.
-	     */
-	    getLastResult() {
-	        return this.lastResult;
-	    }
-	    /**
-	     * 마지막 affine 추정에 사용된 입력쌍을 반환합니다.
-	     */
-	    getLastPairs() {
-	        return [...this.lastPairs];
-	    }
-	    fitAffine2D(pairs) {
-	        if (!Array.isArray(pairs) || pairs.length < 4)
-	            return null;
-	        const ata = Array.from({ length: 6 }, () => Array(6).fill(0));
-	        const atb = Array(6).fill(0);
-	        const accumulate = (row, rhs) => {
-	            for (let i = 0; i < 6; i += 1) {
-	                atb[i] += row[i] * rhs;
-	                for (let j = 0; j < 6; j += 1)
-	                    ata[i][j] += row[i] * row[j];
-	            }
-	        };
-	        for (const pair of pairs) {
-	            accumulate([pair.sx, pair.sy, 1, 0, 0, 0], pair.tx);
-	            accumulate([0, 0, 0, pair.sx, pair.sy, 1], pair.ty);
-	        }
-	        const n = 6;
-	        const aug = ata.map((row, index) => [...row, atb[index]]);
-	        for (let col = 0; col < n; col += 1) {
-	            let pivot = col;
-	            for (let row = col + 1; row < n; row += 1) {
-	                if (Math.abs(aug[row][col]) > Math.abs(aug[pivot][col]))
-	                    pivot = row;
-	            }
-	            if (Math.abs(aug[pivot][col]) < 1e-10)
-	                return null;
-	            if (pivot !== col) {
-	                const temp = aug[col];
-	                aug[col] = aug[pivot];
-	                aug[pivot] = temp;
-	            }
-	            const divider = aug[col][col];
-	            for (let j = col; j <= n; j += 1)
-	                aug[col][j] /= divider;
-	            for (let row = 0; row < n; row += 1) {
-	                if (row === col)
-	                    continue;
-	                const factor = aug[row][col];
-	                if (Math.abs(factor) < 1e-12)
-	                    continue;
-	                for (let j = col; j <= n; j += 1)
-	                    aug[row][j] -= factor * aug[col][j];
-	            }
-	        }
-	        return {
-	            a: aug[0][n],
-	            b: aug[1][n],
-	            c: aug[2][n],
-	            d: aug[3][n],
-	            e: aug[4][n],
-	            f: aug[5][n],
-	        };
-	    }
-	}
-
 	class LightSource {
 	    constructor() {
 	        this.rays = [];
@@ -7341,6 +7228,156 @@
 	    }
 	}
 
+	class Surface {
+	    constructor(props) {
+	        this.type = "";
+	        this.name = "";
+	        this.position = new Vector3(0, 0, 0);
+	        this.tilt = new Vector2(0, 0);
+	        this.meridians = [];
+	        const { type, name, position, tilt } = props;
+	        this.type = type;
+	        this.name = name;
+	        this.position = new Vector3(position.x, position.y, position.z);
+	        this.tilt = new Vector2(tilt.x, tilt.y);
+	        this.incidentRays = [];
+	        this.refractedRays = [];
+	    }
+	    clearTraceHistory() {
+	        this.incidentRays = [];
+	        this.refractedRays = [];
+	    }
+	    getWorldPosition() {
+	        return this.position.clone();
+	    }
+	    setPositionAndTilt(position, tiltXDeg, tiltYDeg) {
+	        this.position.copy(position);
+	        this.tilt.set(tiltXDeg, tiltYDeg);
+	    }
+	    /**
+	     * 안질 tilt가 0인 표면을 전제로, pivot 기준 강체 회전 후 동일 Euler(XYZ) tilt를 부여합니다.
+	     */
+	    applyRigidRotationAboutPivot(pivot, rotation) {
+	        const p1 = pivot.clone().add(new Vector3().subVectors(this.position, pivot).applyQuaternion(rotation));
+	        const euler = new Euler().setFromQuaternion(rotation, "XYZ");
+	        this.position.copy(p1);
+	        this.tilt.set((euler.x * 180) / Math.PI, (euler.y * 180) / Math.PI);
+	    }
+	}
+
+	/**
+	 * 2D affine 왜곡 추정 전용 클래스입니다.
+	 * [x'; y'] = [[a b c], [d e f]] * [x y 1]^T 형태를 최소자승으로 적합합니다.
+	 */
+	class Affine {
+	    constructor() {
+	        this.lastResult = null;
+	        this.lastPairs = [];
+	    }
+	    estimate(pairs) {
+	        const inputPairs = Array.isArray(pairs) ? pairs : [];
+	        this.lastPairs = inputPairs;
+	        const affine = this.fitAffine2D(inputPairs);
+	        if (!affine) {
+	            this.lastResult = null;
+	            return null;
+	        }
+	        let residualSumPct = 0;
+	        let residualCount = 0;
+	        let residualMaxPct = 0;
+	        const residuals = [];
+	        for (const pair of inputPairs) {
+	            const px = affine.a * pair.sx + affine.b * pair.sy + affine.c;
+	            const py = affine.d * pair.sx + affine.e * pair.sy + affine.f;
+	            const rx = pair.tx - px;
+	            const ry = pair.ty - py;
+	            const magnitude = Math.hypot(rx, ry);
+	            if (magnitude < 1e-4)
+	                continue;
+	            const radiusRef = Math.hypot(px, py);
+	            const pct = (magnitude / Math.max(0.2, radiusRef)) * 100;
+	            residualSumPct += pct;
+	            residualCount += 1;
+	            residualMaxPct = Math.max(residualMaxPct, pct);
+	            residuals.push({ sx: pair.sx, sy: pair.sy, px, py, rx, ry, magnitude, pct });
+	        }
+	        const result = {
+	            ...affine,
+	            count: inputPairs.length,
+	            residualAvgPct: residualCount ? residualSumPct / residualCount : 0,
+	            residualMaxPct,
+	            residuals,
+	        };
+	        this.lastResult = result;
+	        return result;
+	    }
+	    /**
+	     * 마지막 affine 추정 결과를 반환합니다.
+	     */
+	    getLastResult() {
+	        return this.lastResult;
+	    }
+	    /**
+	     * 마지막 affine 추정에 사용된 입력쌍을 반환합니다.
+	     */
+	    getLastPairs() {
+	        return [...this.lastPairs];
+	    }
+	    fitAffine2D(pairs) {
+	        if (!Array.isArray(pairs) || pairs.length < 4)
+	            return null;
+	        const ata = Array.from({ length: 6 }, () => Array(6).fill(0));
+	        const atb = Array(6).fill(0);
+	        const accumulate = (row, rhs) => {
+	            for (let i = 0; i < 6; i += 1) {
+	                atb[i] += row[i] * rhs;
+	                for (let j = 0; j < 6; j += 1)
+	                    ata[i][j] += row[i] * row[j];
+	            }
+	        };
+	        for (const pair of pairs) {
+	            accumulate([pair.sx, pair.sy, 1, 0, 0, 0], pair.tx);
+	            accumulate([0, 0, 0, pair.sx, pair.sy, 1], pair.ty);
+	        }
+	        const n = 6;
+	        const aug = ata.map((row, index) => [...row, atb[index]]);
+	        for (let col = 0; col < n; col += 1) {
+	            let pivot = col;
+	            for (let row = col + 1; row < n; row += 1) {
+	                if (Math.abs(aug[row][col]) > Math.abs(aug[pivot][col]))
+	                    pivot = row;
+	            }
+	            if (Math.abs(aug[pivot][col]) < 1e-10)
+	                return null;
+	            if (pivot !== col) {
+	                const temp = aug[col];
+	                aug[col] = aug[pivot];
+	                aug[pivot] = temp;
+	            }
+	            const divider = aug[col][col];
+	            for (let j = col; j <= n; j += 1)
+	                aug[col][j] /= divider;
+	            for (let row = 0; row < n; row += 1) {
+	                if (row === col)
+	                    continue;
+	                const factor = aug[row][col];
+	                if (Math.abs(factor) < 1e-12)
+	                    continue;
+	                for (let j = col; j <= n; j += 1)
+	                    aug[row][j] -= factor * aug[col][j];
+	            }
+	        }
+	        return {
+	            a: aug[0][n],
+	            b: aug[1][n],
+	            c: aug[2][n],
+	            d: aug[3][n],
+	            e: aug[4][n],
+	            f: aug[5][n],
+	        };
+	    }
+	}
+
 	/** 각막 기준 안구 회전점 z(mm). `SCAXEngineCore`와 동일. */
 	const EYE_ROTATION_PIVOT_FROM_CORNEA_MM = 13;
 	function normalizePrismAmount$2(value) {
@@ -7413,43 +7450,6 @@
 	    }
 	}
 
-	class Surface {
-	    constructor(props) {
-	        this.type = "";
-	        this.name = "";
-	        this.position = new Vector3(0, 0, 0);
-	        this.tilt = new Vector2(0, 0);
-	        this.meridians = [];
-	        const { type, name, position, tilt } = props;
-	        this.type = type;
-	        this.name = name;
-	        this.position = new Vector3(position.x, position.y, position.z);
-	        this.tilt = new Vector2(tilt.x, tilt.y);
-	        this.incidentRays = [];
-	        this.refractedRays = [];
-	    }
-	    clearTraceHistory() {
-	        this.incidentRays = [];
-	        this.refractedRays = [];
-	    }
-	    getWorldPosition() {
-	        return this.position.clone();
-	    }
-	    setPositionAndTilt(position, tiltXDeg, tiltYDeg) {
-	        this.position.copy(position);
-	        this.tilt.set(tiltXDeg, tiltYDeg);
-	    }
-	    /**
-	     * 안질 tilt가 0인 표면을 전제로, pivot 기준 강체 회전 후 동일 Euler(XYZ) tilt를 부여합니다.
-	     */
-	    applyRigidRotationAboutPivot(pivot, rotation) {
-	        const p1 = pivot.clone().add(new Vector3().subVectors(this.position, pivot).applyQuaternion(rotation));
-	        const euler = new Euler().setFromQuaternion(rotation, "XYZ");
-	        this.position.copy(p1);
-	        this.tilt.set((euler.x * 180) / Math.PI, (euler.y * 180) / Math.PI);
-	    }
-	}
-
 	class ApertureStopSurface extends Surface {
 	    constructor(props) {
 	        super({
@@ -9645,9 +9645,11 @@
 	    }
 	}
 
+	exports.LightSource = LightSource;
 	exports.Ray = Ray;
 	exports.SCAXEngine = SCAXEngine;
 	exports.SCAXEngineCore = SCAXEngineCore;
+	exports.Surface = Surface;
 
 }));
 //# sourceMappingURL=scax-engine.umd.js.map

package/dist/types/index.d.ts

@@ -1,4 +1,6 @@
 export { default as Ray } from "./ray/ray";
+export { LightSource } from "./light-sources/light-source";
+export { default as Surface } from "./surfaces/surface";
 export { default as SCAXEngine, SCAXEngineCore } from "./scax-engine";
-export type { MeridianInfo, PrismPower, SCAXEngineProps, SCAXPower, SimulateResult, } from "./scax-engine";
+export type { MeridianInfo, PrismPower, SCAXEngineProps, SCAXPower, SimulateResult, SturmResult } from "./scax-engine";
 //# sourceMappingURL=index.d.ts.map

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

@@ -2,6 +2,7 @@ import Affine from "./affine/affine";
 import { GridLightSourceProps, GridRGLightSourceProps, LightSource, RadialLightSourceProps } from "./light-sources/light-source";
 import { EyeModelParameter } from "./parameters/eye/eyemodel-parameter";
 import Ray from "./ray/ray";
+import Sturm from "./sturm/sturm";
 import Surface from "./surfaces/surface";
 export type EyeModel = "gullstrand" | "navarro";
 export type PupilType = "constricted" | "neutral" | "dilated" | "none";
@@ -95,6 +96,8 @@ export type MeridianInfo = {
     tabo: number;
     d: number;
 }[];
+/** `Sturm#calculate()` / `SCAXEngine#sturmCalculation()` 반환 구조 */
+export type SturmResult = ReturnType<Sturm["calculate"]>;
 export type AffineAnalysisResult = ReturnType<Affine["estimate"]>;
 /**
  * legacy simulator.js를 TypeScript로 옮긴 핵심 시뮬레이터입니다.
@@ -143,117 +146,7 @@ export declare class SCAXEngineCore {
      * 2) Sturm calculation 전용 함수
      * traced ray 집합에서 z-scan 기반 Sturm 슬라이스/근사 중심을 계산합니다.
      */
-    sturmCalculation(rays?: Ray[]): {
-        slices_info: {
-            count: number;
-            slices: {
-                z: number;
-                depth: number;
-                ratio: number;
-                size: number;
-                profile: {
-                    at: {
-                        x: number;
-                        y: number;
-                        z: number;
-                    };
-                    wMajor: number;
-                    wMinor: number;
-                    angleMajorDeg: number;
-                    j0: number;
-                    j45: number;
-                    angleMinorDeg: number;
-                    majorDirection: {
-                        x: number;
-                        y: number;
-                        z: number;
-                    };
-                    minorDirection: {
-                        x: number;
-                        y: number;
-                        z: number;
-                    };
-                };
-            }[];
-        };
-        sturm_info: {
-            has_astigmatism: boolean;
-            method: string;
-            anterior: {
-                z: number;
-                depth: number;
-                ratio: number;
-                size: number;
-                profile: {
-                    at: {
-                        x: number;
-                        y: number;
-                        z: number;
-                    };
-                    wMajor: number;
-                    wMinor: number;
-                    angleMajorDeg: number;
-                    j0: number;
-                    j45: number;
-                    angleMinorDeg: number;
-                    majorDirection: {
-                        x: number;
-                        y: number;
-                        z: number;
-                    };
-                    minorDirection: {
-                        x: number;
-                        y: number;
-                        z: number;
-                    };
-                };
-            };
-            posterior: {
-                z: number;
-                depth: number;
-                ratio: number;
-                size: number;
-                profile: {
-                    at: {
-                        x: number;
-                        y: number;
-                        z: number;
-                    };
-                    wMajor: number;
-                    wMinor: number;
-                    angleMajorDeg: number;
-                    j0: number;
-                    j45: number;
-                    angleMinorDeg: number;
-                    majorDirection: {
-                        x: number;
-                        y: number;
-                        z: number;
-                    };
-                    minorDirection: {
-                        x: number;
-                        y: number;
-                        z: number;
-                    };
-                };
-            } | null;
-            approx_center: {
-                x: number;
-                y: number;
-                z: number;
-                mode: string;
-            } | null;
-            line: "g" | "F" | "e" | "d" | "C" | "r";
-            wavelength_nm: number;
-            color: number | null;
-            ray_count: number;
-            analysis_axis: {
-                x: number;
-                y: number;
-                z: number;
-            };
-        }[];
-    };
+    sturmCalculation(rays?: Ray[]): SturmResult;
     getAffineAnalysis(): AffineAnalysisResult;
     private surfaceOrderZ;
     private readSurfacePosition;
@@ -279,117 +172,7 @@ export default class SCAXEngine {
     dispose(): void;
     simulate(): SimulateResult;
     rayTracing(): Ray[];
-    sturmCalculation(rays?: Ray[]): {
-        slices_info: {
-            count: number;
-            slices: {
-                z: number;
-                depth: number;
-                ratio: number;
-                size: number;
-                profile: {
-                    at: {
-                        x: number;
-                        y: number;
-                        z: number;
-                    };
-                    wMajor: number;
-                    wMinor: number;
-                    angleMajorDeg: number;
-                    j0: number;
-                    j45: number;
-                    angleMinorDeg: number;
-                    majorDirection: {
-                        x: number;
-                        y: number;
-                        z: number;
-                    };
-                    minorDirection: {
-                        x: number;
-                        y: number;
-                        z: number;
-                    };
-                };
-            }[];
-        };
-        sturm_info: {
-            has_astigmatism: boolean;
-            method: string;
-            anterior: {
-                z: number;
-                depth: number;
-                ratio: number;
-                size: number;
-                profile: {
-                    at: {
-                        x: number;
-                        y: number;
-                        z: number;
-                    };
-                    wMajor: number;
-                    wMinor: number;
-                    angleMajorDeg: number;
-                    j0: number;
-                    j45: number;
-                    angleMinorDeg: number;
-                    majorDirection: {
-                        x: number;
-                        y: number;
-                        z: number;
-                    };
-                    minorDirection: {
-                        x: number;
-                        y: number;
-                        z: number;
-                    };
-                };
-            };
-            posterior: {
-                z: number;
-                depth: number;
-                ratio: number;
-                size: number;
-                profile: {
-                    at: {
-                        x: number;
-                        y: number;
-                        z: number;
-                    };
-                    wMajor: number;
-                    wMinor: number;
-                    angleMajorDeg: number;
-                    j0: number;
-                    j45: number;
-                    angleMinorDeg: number;
-                    majorDirection: {
-                        x: number;
-                        y: number;
-                        z: number;
-                    };
-                    minorDirection: {
-                        x: number;
-                        y: number;
-                        z: number;
-                    };
-                };
-            } | null;
-            approx_center: {
-                x: number;
-                y: number;
-                z: number;
-                mode: string;
-            } | null;
-            line: "g" | "F" | "e" | "d" | "C" | "r";
-            wavelength_nm: number;
-            color: number | null;
-            ray_count: number;
-            analysis_axis: {
-                x: number;
-                y: number;
-                z: number;
-            };
-        }[];
-    };
+    sturmCalculation(rays?: Ray[]): SturmResult;
     calculateMeridians(scaxPowers: SCAXPower[]): MeridianInfo;
     calculateEyeRotationByPrism(prism: PrismPower): {
         x: number;

package/package.json

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