@sssxyd/face-liveness-detector 0.4.1-beta.7 → 0.4.1-beta.9

package/dist/index.esm.js

@@ -1633,8 +1633,11 @@ class MotionLivenessDetector {
     getOptions() {
         return this.config;
     }
-    isReady() {
-        return this.normalizedLandmarksHistory.length >= 5; // 只需要5帧就能检测
+    collectedMinFrames() {
+        return this.normalizedLandmarksHistory.length >= 5;
+    }
+    collectedFullFrames() {
+        return this.normalizedLandmarksHistory.length >= this.config.frameBufferSize;
     }
     reset() {
         this.eyeAspectRatioHistory = [];
@@ -1682,7 +1685,7 @@ class MotionLivenessDetector {
                 });
             }
             // 数据不足时，继续收集
-            if (!this.isReady()) {
+            if (!this.collectedMinFrames()) {
                 return this.createEmptyResult({
                     reason: '数据收集中，帧数不足',
                     collectedFrames: this.normalizedLandmarksHistory.length
@@ -2518,46 +2521,102 @@ class MotionLivenessDetector {
         // 更多的点对会给出更准确的单应性矩阵估计
         const errors = [];
         const homographyMatrices = [];
-        // 计算相邻帧的变换误差
-        for (let i = 1; i < this.faceLandmarksHistory.length; i++) {
+        let lastSrcPoints = []; // 保存最后一组点对，用于计算特征尺度
+        // 【策略改进】优先使用最近的帧对（尽早检测）
+        // 照片的几何约束是瞬间的，2帧就足够；多帧用来验证一致性
+        const recentFrameCount = Math.min(5, this.faceLandmarksHistory.length);
+        console.debug('[HomographyConstraint] Starting analysis', {
+            totalFrames: this.faceLandmarksHistory.length,
+            recentFrameCount,
+            startIndex: Math.max(1, this.faceLandmarksHistory.length - recentFrameCount)
+        });
+        // 计算最近帧对的变换误差（重点在最近的帧）
+        for (let i = Math.max(1, this.faceLandmarksHistory.length - recentFrameCount); i < this.faceLandmarksHistory.length; i++) {
             const frame1 = this.faceLandmarksHistory[i - 1];
             const frame2 = this.faceLandmarksHistory[i];
-            if (frame1.length < 468 || frame2.length < 468)
-                continue;
+            console.debug(`[HomographyConstraint] Processing frame pair [${i - 1}, ${i}]`, {
+                frame1Length: frame1.length,
+                frame2Length: frame2.length
+            });
+            if (frame1.length < 100 || frame2.length < 100) {
+                console.debug(`[HomographyConstraint] Frame pair skipped (insufficient points)`);
+                continue; // 至少100个有效点
+            }
             // 【改进】收集所有有效的点对（而不是只采样10个点）
             // 这给出更好的H矩阵估计
             const srcPoints = [];
             const dstPoints = [];
-            for (let ptIdx = 0; ptIdx < frame1.length; ptIdx++) {
+            for (let ptIdx = 0; ptIdx < Math.min(frame1.length, frame2.length); ptIdx++) {
                 if (frame1[ptIdx] && frame2[ptIdx] &&
                     frame1[ptIdx].length >= 2 && frame2[ptIdx].length >= 2) {
-                    // 使用x, y原始坐标
-                    srcPoints.push([frame1[ptIdx][0], frame1[ptIdx][1]]);
-                    dstPoints.push([frame2[ptIdx][0], frame2[ptIdx][1]]);
+                    const x1 = frame1[ptIdx][0];
+                    const y1 = frame1[ptIdx][1];
+                    const x2 = frame2[ptIdx][0];
+                    const y2 = frame2[ptIdx][1];
+                    // 【修复】只排除明显的异常值（移动过大），保留所有其他点
+                    // 包括静止的点和微妙移动的点，DLT需要全局点分布
+                    const displacement = Math.sqrt((x2 - x1) ** 2 + (y2 - y1) ** 2);
+                    if (displacement < 200) { // 仅排除极端异常
+                        srcPoints.push([x1, y1]);
+                        dstPoints.push([x2, y2]);
+                    }
                 }
             }
-            if (srcPoints.length < 4)
-                continue;
+            console.debug(`[HomographyConstraint] Collected points`, {
+                srcPointsCount: srcPoints.length,
+                dstPointsCount: dstPoints.length
+            });
+            if (srcPoints.length < 10) {
+                console.debug(`[HomographyConstraint] Point pair skipped (only ${srcPoints.length} < 10 points)`);
+                continue; // 至少10个匹配点对（DLT最少需要4个）
+            }
+            // 保存这一组点对（用于后面计算特征尺度）
+            lastSrcPoints = srcPoints;
             // 【新增】使用DLT算法计算完整的3x3单应性矩阵
             const H = this.estimateHomographyDLT(srcPoints, dstPoints);
-            if (!H)
+            if (!H) {
+                console.debug(`[HomographyConstraint] DLT failed to estimate homography`);
                 continue;
+            }
+            console.debug(`[HomographyConstraint] H matrix estimated:`, {
+                h00: H[0][0].toFixed(4),
+                h11: H[1][1].toFixed(4),
+                h22: H[2][2].toFixed(4),
+                det: (H[0][0] * H[1][1] * H[2][2] + H[0][1] * H[1][2] * H[2][0] + H[0][2] * H[1][0] * H[2][1]
+                    - H[0][2] * H[1][1] * H[2][0] - H[0][0] * H[1][2] * H[2][1] - H[0][1] * H[1][0] * H[2][2]).toFixed(4)
+            });
             homographyMatrices.push(H);
             // 【改进】使用单应性矩阵计算误差（而不是仿射变换）
             let frameError = 0;
             let validCount = 0;
+            const sampleErrors = [];
             for (let j = 0; j < srcPoints.length; j++) {
                 const transformed = this.applyHomography(H, srcPoints[j][0], srcPoints[j][1]);
                 const actual = dstPoints[j];
                 const error = Math.sqrt((transformed[0] - actual[0]) ** 2 + (transformed[1] - actual[1]) ** 2);
                 frameError += error;
                 validCount++;
+                // 记录前5个误差用于调试
+                if (j < 5) {
+                    sampleErrors.push(error);
+                }
             }
             if (validCount > 0) {
-                errors.push(frameError / validCount);
+                const avgFrameError = frameError / validCount;
+                errors.push(avgFrameError);
+                console.debug(`[HomographyConstraint] Frame error computed`, {
+                    pointCount: validCount,
+                    avgFrameError: avgFrameError.toFixed(4),
+                    sampleErrors: sampleErrors.map(e => e.toFixed(4)).join(', ')
+                });
             }
         }
+        console.debug(`[HomographyConstraint] Error collection complete`, {
+            totalErrors: errors.length,
+            matrixCount: homographyMatrices.length
+        });
         if (errors.length === 0) {
+            console.debug(`[HomographyConstraint] No errors computed, returning 0`);
             return { planarScore: 0, error: 0 };
         }
         // 计算所有帧的平均误差
@@ -2568,75 +2627,138 @@ class MotionLivenessDetector {
         if (homographyMatrices.length > 1) {
             matrixConsistency = this.checkHomographyConsistency(homographyMatrices);
         }
-        // 平面得分 = 误差低 且 H矩阵一致
-        // avgError < 0.01 → 非常可能是平面
-        // avgError > 0.05 → 可能是立体（活体）
-        const errorScore = Math.max(0, 1 - avgError / 0.03);
+        // 【改进】使用相对误差而不是绝对误差
+        // 相对误差 = avgError / 点集特征尺度
+        // 这样对不同分辨率和点集大小更鲁棒
+        const characteristicScale = lastSrcPoints.length > 0 ? this.computeCharacteristicScale(lastSrcPoints) : 1;
+        const relativeError = characteristicScale > 0.1 ? avgError / characteristicScale : avgError;
+        // 平面性判决：
+        // relativeError < 0.05 → 很可能是平面（照片）
+        // relativeError > 0.1  → 很可能是立体（活体）
+        const errorScore = Math.max(0, 1 - relativeError / 0.1);
         const planarScore = errorScore * matrixConsistency;
-        console.debug('[HomographyConstraint]', {
+        console.debug('[HomographyConstraint] FINAL RESULT', {
+            recentFrameCount,
             frameCount: errors.length,
             avgError: avgError.toFixed(4),
+            characteristicScale: characteristicScale.toFixed(4),
+            relativeError: relativeError.toFixed(4),
             errorScore: errorScore.toFixed(3),
             matrixConsistency: matrixConsistency.toFixed(3),
-            planarScore: planarScore.toFixed(3)
+            planarScore: planarScore.toFixed(3),
+            homographyMatrixCount: homographyMatrices.length
         });
         return { planarScore: Math.min(planarScore, 1), error: avgError };
     }
     /**
-     * 估计仿射变换矩阵
-     * 【改进】使用完整的6参数仿射变换（包含剪切分量）
-     *
-     * 变换形式: x' = ax + by + c, y' = dx + ey + f
-     * 其中 [a, b] 和 [d, e] 可以包含旋转、缩放、剪切分量
-    /**
-     * 【新增】使用DLT算法估计单应性矩阵
+     * 使用DLT算法估计单应性矩阵（Homography Estimation using DLT）
      *
      * DLT (Direct Linear Transform) 是估计射影变换的标准算法
-     * 输入：源点和目标点对 (至少4对)
-     * 输出：3x3单应性矩阵H，使得 p' = H * p (齐次坐标)
      *
-     * 相比仿射变换：
-     * - 仿射：6参数，处理旋转+缩放+平移+剪切
-     * - 单应性：8参数，处理完整的射影变换（包括透视）
+     * 输入：
+     * - src: 源点坐标数组 (至少4对)
+     * - dst: 目标点坐标数组
      *
-     * 照片倾斜拍摄时，需要完整的单应性矩阵！
+     * 输出：
+     * - 3x3单应性矩阵H，使得 p' = H * p (齐次坐标表示)
+     *
+     * 关键特性：
+     * - 与仿射变换的区别：
+     *   * 仿射：6参数，处理旋转+缩放+平移+剪切
+     *   * 单应性：8参数，处理完整的射影变换（包括透视失真）
+     * - 适用场景：照片倾斜拍摄、相机透视变换
+     * - 数值稳定性：使用点集归一化提高数值精度
+     *
+     * 算法步骤：
+     * 1. 归一化源点和目标点（改进数值稳定性）
+     * 2. 构建 2n×9 的 A 矩阵（n为点对数）
+     * 3. 使用最小二乘法求解 Ah = 0
+     * 4. 反演应化矩阵到原始坐标系
      */
     estimateHomographyDLT(src, dst) {
-        if (src.length < 4 || dst.length < 4 || src.length !== dst.length)
+        if (src.length < 4 || dst.length < 4 || src.length !== dst.length) {
+            console.debug('[DLT] Invalid input', { srcLen: src.length, dstLen: dst.length });
             return null;
+        }
         const n = src.length;
         // 【关键】对点进行归一化，提高数值稳定性
         const srcNorm = this.normalizePoints(src);
         const dstNorm = this.normalizePoints(dst);
-        if (!srcNorm || !dstNorm)
+        if (!srcNorm || !dstNorm) {
+            console.debug('[DLT] Point normalization failed');
             return null;
-        // 构建DLT方程矩阵 A (2n x 9)
-        // 对每对点，构建2行方程：
-        // [-x, -y, -1, 0, 0, 0, x*x', y*x', x']
-        // [0, 0, 0, -x, -y, -1, x*y', y*y', y']
+        }
+        console.debug('[DLT] Normalization success', {
+            pointCount: n,
+            srcScale: srcNorm.T[0][0].toFixed(4),
+            dstScale: dstNorm.T[0][0].toFixed(4)
+        });
+        // 构建DLT方程矩阵 A (2n × 9)
+        // 
+        // 标准DLT形式推导：
+        // 已知齐次坐标关系：p' = H * p
+        // 即：[x', y', 1]^T = H * [x, y, 1]^T / w
+        // 其中：w = h7*x + h8*y + h9 (齐次化分母)
+        // 
+        // 展开得到：
+        // x' = (h1*x + h2*y + h3) / (h7*x + h8*y + h9)
+        // y' = (h4*x + h5*y + h6) / (h7*x + h8*y + h9)
+        // 
+        // 交叉相乘消去分母：
+        // x'*(h7*x + h8*y + h9) = h1*x + h2*y + h3
+        // y'*(h7*x + h8*y + h9) = h4*x + h5*y + h6
+        // 
+        // 整理为齐次线性方程 Ah = 0：
+        // h1*x + h2*y + h3 - xp*h7*x - xp*h8*y - xp*h9 = 0
+        // h4*x + h5*y + h6 - yp*h7*x - yp*h8*y - yp*h9 = 0
+        // 
+        // 矩阵形式（每对点产生2行方程）：
+        // [x,  y,  1,  0,  0,  0, -xp*x, -xp*y, -xp]   [h1]
+        // [0,  0,  0,  x,  y,  1, -yp*x, -yp*y, -yp] * [h2] = 0
+        //                                               [...]
+        //                                               [h9]
         const A = [];
         for (let i = 0; i < n; i++) {
             const x = srcNorm.points[i][0];
             const y = srcNorm.points[i][1];
             const xp = dstNorm.points[i][0];
             const yp = dstNorm.points[i][1];
-            // 第一行
-            A.push([-x, -y, -1, 0, 0, 0, x * xp, y * xp, xp]);
-            // 第二行
-            A.push([0, 0, 0, -x, -y, -1, x * yp, y * yp, yp]);
+            // 第一行：h1*x + h2*y + h3 - xp*h7*x - xp*h8*y - xp*h9 = 0
+            A.push([x, y, 1, 0, 0, 0, -xp * x, -xp * y, -xp]);
+            // 第二行：h4*x + h5*y + h6 - yp*h7*x - yp*h8*y - yp*h9 = 0
+            A.push([0, 0, 0, x, y, 1, -yp * x, -yp * y, -yp]);
         }
-        // 使用SVD求解 Ah = 0
-        // h 是最小奇异值对应的右奇异向量
+        // 使用最小二乘法求解 Ah = 0
+        // h 是 A^T*A 最小特征值对应的特征向量
         const h = this.solveHomographyLSQ(A);
         if (!h)
             return null;
-        // 反演应化矩阵（从归一化坐标回到原始坐标）
+        // 反演应化：从归一化坐标回到原始图像坐标
+        // H_orig = T_dst^(-1) * H_norm * T_src
         const H = this.denormalizeHomography(h, srcNorm, dstNorm);
         return H;
     }
     /**
-     * 点集归一化（提高数值稳定性）
-     * 变换点使得重心在原点，平均距离为sqrt(2)
+     * 点集归一化（Hartley标准化）- 提高DLT数值稳定性
+     *
+     * 目的：
+     * - DLT算法对坐标尺度敏感，归一化可显著改善数值稳定性
+     * - 避免矩阵条件数过大，减少数值误差
+     *
+     * 方法：
+     * 1. 计算点集的重心 (cx, cy)
+     * 2. 计算点到重心的平均距离
+     * 3. 缩放使得平均距离为 √2
+     *
+     * 变换：T = [s, 0, -s*cx; 0, s, -s*cy; 0, 0, 1]
+     * 其中 s = √2 / avgDistance
+     *
+     * 好处：
+     * - 点集的重心在原点
+     * - 点到原点的平均距离为 √2（标准化）
+     * - A^T*A 矩阵条件数接近最优
+     *
+     * 逆操作：在得到矩阵后需要反归一化回原始坐标
      */
     normalizePoints(points) {
         if (points.length === 0)
@@ -2676,15 +2798,26 @@ class MotionLivenessDetector {
         return { points: normalized, T };
     }
     /**
-     * 最小二乘法求解 Ah = 0
-     * 其中 h 是3x3矩阵的向量化形式
+     * 最小二乘法求解齐次线性方程 Ah = 0
+     *
+     * 问题：找到使 ||Ah|| 最小的单位向量 h
+     *
+     * 标准解法：
+     * - 完整SVD：对 A 进行 SVD 分解，h 是最小奇异值的右奇异向量
+     * - 特征向量法（此处使用）：
+     *   1. 计算 A^T * A（9×9对称矩阵）
+     *   2. 求 A^T*A 的最小特征值对应的特征向量
+     *   3. 该特征向量即为所求的 h
+     *
+     * 说明：
+     * - h 是 3×3 单应性矩阵 H 的向量化形式
+     * - 返回的特征向量已归一化
      */
     solveHomographyLSQ(A) {
-        // 简化的SVD求解：找使 ||Ah|| 最小的 h
-        // 为了简化，使用迭代最小二乘法或对称矩阵的特征向量
         if (A.length < 8)
             return null;
-        // A^T * A 矩阵 (9x9)
+        // 构造 A^T * A 矩阵 (9×9)
+        // 这是一个对称半正定矩阵
         const ATA = Array(9).fill(0).map(() => Array(9).fill(0));
         for (let i = 0; i < 9; i++) {
             for (let j = 0; j < 9; j++) {
@@ -2693,44 +2826,136 @@ class MotionLivenessDetector {
                 }
             }
         }
-        // 求ATA的最小特征向量（对应最小特征值）
+        // 求 A^T*A 的最小特征向量
+        // 最小特征向量对应最小特征值，使 ||Ah|| 最小
         const eigenVec = this.getSmallestEigenvector(ATA);
         return eigenVec;
     }
     /**
-     * 求3x3对称矩阵的最小特征向量（简化版本）
-     * 使用幂迭代法或直接求解
+     * 求9x9对称矩阵(A^T*A)的最小特征向量
+     *
+     * 【关键】使用 Jacobi 特征值分解而不是幂法
+     *
+     * 问题分析：
+     * - 迭代幂法（Power Iteration）求的是**最大**特征值的特征向量
+     * - 我们需要**最小**特征值的特征向量
+     * - 之前的幂法实现虽然标记为最小，但实际求的是最大 → 算法失败！
+     *
+     * 解决方案：
+     * 1. 使用 QR 算法或 Jacobi 方法求完整的特征值分解
+     * 2. 选择最小特征值对应的特征向量
+     *
+     * 此处实现简化的 Jacobi 迭代：
+     * - 对称矩阵对角化
+     * - 提取最小特征值的特征向量
      */
     getSmallestEigenvector(mat) {
         if (mat.length !== 9)
             return null;
-        // 为了简化，使用初步估计：取行和最小的方向
-        // 或者使用固定迭代次数的幂法
-        // 简化：返回一个初步猜测的向量
-        // 实际应用应该使用完整的SVD或特征值分解库
-        // 这里使用Power Iteration的反向版本（找最小特征值）
-        let v = [1, 1, 1, 1, 1, 1, 1, 1, 1];
-        for (let iter = 0; iter < 10; iter++) {
-            // v_new = A * v
-            const v_new = [0, 0, 0, 0, 0, 0, 0, 0, 0];
+        // 复制矩阵，Jacobi方法会修改原矩阵
+        const A = mat.map(row => [...row]);
+        const V = Array(9).fill(0).map((_, i) => {
+            const row = Array(9).fill(0);
+            row[i] = 1;
+            return row;
+        }); // 9×9 单位矩阵，用于存储特征向量
+        // Jacobi迭代（简化版）
+        // 目标：将 A 对角化为 D = V^T * A * V
+        for (let iteration = 0; iteration < 20; iteration++) {
+            let maxOffDiag = 0;
+            let p = 0, q = 1;
+            // 找非对角元素中绝对值最大的
             for (let i = 0; i < 9; i++) {
-                for (let j = 0; j < 9; j++) {
-                    v_new[i] += mat[i][j] * v[j];
+                for (let j = i + 1; j < 9; j++) {
+                    if (Math.abs(A[i][j]) > maxOffDiag) {
+                        maxOffDiag = Math.abs(A[i][j]);
+                        p = i;
+                        q = j;
+                    }
                 }
             }
-            // 归一化
-            const norm = Math.sqrt(v_new.reduce((a, b) => a + b * b, 0));
-            if (norm < 0.0001)
+            // 收敛判断
+            if (maxOffDiag < 1e-10) {
                 break;
+            }
+            // 计算Givens旋转角
+            const Aqq = A[q][q];
+            const App = A[p][p];
+            const Apq = A[p][q];
+            let theta = 0;
+            if (Math.abs(Aqq - App) < 1e-10) {
+                theta = Math.PI / 4;
+            }
+            else {
+                theta = 0.5 * Math.atan2(2 * Apq, Aqq - App);
+            }
+            const c = Math.cos(theta);
+            const s = Math.sin(theta);
+            // 更新矩阵 A（2×2 子块旋转）
+            const App_new = c * c * App - 2 * s * c * Apq + s * s * Aqq;
+            const Aqq_new = s * s * App + 2 * s * c * Apq + c * c * Aqq;
+            const Apq_new = 0; // 旋转后的非对角元素为0
+            // 更新第p行第q列的其他元素
             for (let i = 0; i < 9; i++) {
-                v[i] = v_new[i] / norm;
+                if (i !== p && i !== q) {
+                    const Aip = A[i][p];
+                    const Aiq = A[i][q];
+                    A[i][p] = c * Aip - s * Aiq;
+                    A[p][i] = A[i][p];
+                    A[i][q] = s * Aip + c * Aiq;
+                    A[q][i] = A[i][q];
+                }
+            }
+            A[p][p] = App_new;
+            A[q][q] = Aqq_new;
+            A[p][q] = Apq_new;
+            A[q][p] = Apq_new;
+            // 更新特征向量矩阵 V
+            for (let i = 0; i < 9; i++) {
+                const Vip = V[i][p];
+                const Viq = V[i][q];
+                V[i][p] = c * Vip - s * Viq;
+                V[i][q] = s * Vip + c * Viq;
             }
         }
-        return v;
+        // 找到最小特征值的位置
+        let minIdx = 0;
+        let minEigenvalue = A[0][0];
+        for (let i = 1; i < 9; i++) {
+            if (A[i][i] < minEigenvalue) {
+                minEigenvalue = A[i][i];
+                minIdx = i;
+            }
+        }
+        // 提取对应的特征向量（V的第 minIdx 列）
+        const eigenvector = Array(9);
+        for (let i = 0; i < 9; i++) {
+            eigenvector[i] = V[i][minIdx];
+        }
+        // 归一化
+        const norm = Math.sqrt(eigenvector.reduce((a, b) => a + b * b, 0));
+        if (norm > 1e-10) {
+            for (let i = 0; i < 9; i++) {
+                eigenvector[i] = eigenvector[i] / norm;
+            }
+        }
+        return eigenvector;
     }
     /**
-     * 反演应化矩阵
-     * H_orig = T_dst^-1 * H_norm * T_src
+     * 反演应化矩阵 - 从归一化坐标回到原始图像坐标
+     *
+     * 原理：
+     * - 在归一化坐标系中估算的H矩阵需要转换回原始坐标
+     *
+     * 公式：H_orig = T_dst^(-1) * H_norm * T_src
+     *
+     * 说明：
+     * - T_src：源点的归一化变换矩阵
+     * - T_dst：目标点的归一化变换矩阵
+     * - H_norm：在归一化坐标中计算得到的3×3矩阵
+     * - H_orig：最终的单应性矩阵（用于原始图像坐标）
+     *
+     * 验证：p'_orig = H_orig * p_src_orig
      */
     denormalizeHomography(h, srcNorm, dstNorm) {
         // 将向量h转换为3x3矩阵
@@ -2750,6 +2975,30 @@ class MotionLivenessDetector {
         const H = this.multiplyMatrix3x3(temp, T_src);
         return H;
     }
+    /**
+     * 检查点集的分布范围（防止点集集中在小区域）
+     * 返回值：0-1，值越大说明分布越分散
+     */
+    checkPointSpread(points) {
+        if (points.length < 2)
+            return 0;
+        let minX = Infinity, maxX = -Infinity;
+        let minY = Infinity, maxY = -Infinity;
+        for (const p of points) {
+            minX = Math.min(minX, p[0]);
+            maxX = Math.max(maxX, p[0]);
+            minY = Math.min(minY, p[1]);
+            maxY = Math.max(maxY, p[1]);
+        }
+        const rangeX = maxX - minX;
+        const rangeY = maxY - minY;
+        const area = rangeX * rangeY;
+        // 点集的相对面积（相对于整个图像，假设1920x1080）
+        // 面积越大，点的分布越分散
+        const imageArea = 1920 * 1080;
+        const relativeArea = Math.min(area / imageArea, 1);
+        return relativeArea;
+    }
     /**
      * 3x3矩阵求逆
      */
@@ -2796,23 +3045,59 @@ class MotionLivenessDetector {
         return result;
     }
     /**
-     * 应用单应性变换（齐次坐标）
-     * p' = H * p / (H * p 的 Z 分量)
+     * 应用单应性变换 - 齐次坐标变换与反齐次化
+     *
+     * 操作步骤：
+     * 1. 输入：(x, y) → 齐次坐标 [x, y, 1]
+     * 2. 矩阵乘法：H * p 得到齐次结果 [x'w, y'w, w]
+     * 3. 反齐次化：[x'w/w, y'w/w] = [x', y']
+     *
+     * 公式：
+     * [x']     [h11 h12 h13] [x]
+     * [y'  ] = [h21 h22 h23] [y]
+     * [w']     [h31 h32 h33] [1]
+     *
+     * 最后：x' = x'w / w, y' = y'w / w
+     *
+     * 注意：如果 w' ≈ 0，点被投影到无穷远（退化情况）
      */
     applyHomography(H, x, y) {
-        // 齐次坐标
+        // 齐次坐标表示
         const p = [x, y, 1];
-        // H * p
+        // 矩阵乘法：H * p
         const Hp = [
             H[0][0] * p[0] + H[0][1] * p[1] + H[0][2] * p[2],
             H[1][0] * p[0] + H[1][1] * p[1] + H[1][2] * p[2],
             H[2][0] * p[0] + H[2][1] * p[1] + H[2][2] * p[2]
         ];
-        // 反齐次化
+        // 反齐次化：除以齐次坐标的 Z 分量
+        // 如果 w ≈ 0，则点在无穷远，返回齐次结果
         if (Math.abs(Hp[2]) < 0.0001) {
-            return [Hp[0], Hp[1]];
+            return [Hp[0], Hp[1]]; // 异常情况：接近无穷
         }
-        return [Hp[0] / Hp[2], Hp[1] / Hp[2]];
+        return [Hp[0] / Hp[2], Hp[1] / Hp[2]]; // 正常情况：反齐次化
+    }
+    /**
+     * 【新增】计算点集的特征尺度（点间的平均距离）
+     *
+     * 用于相对误差计算，使算法对不同分辨率和点集大小更鲁棒
+     */
+    computeCharacteristicScale(points) {
+        if (points.length < 2)
+            return 1;
+        let totalDist = 0;
+        let count = 0;
+        // 采样计算点间距离，避免 O(n²) 复杂度
+        const sampleSize = Math.min(points.length, 30);
+        for (let i = 0; i < sampleSize; i++) {
+            for (let j = i + 1; j < sampleSize; j++) {
+                const dx = points[i][0] - points[j][0];
+                const dy = points[i][1] - points[j][1];
+                totalDist += Math.sqrt(dx * dx + dy * dy);
+                count++;
+            }
+        }
+        return count > 0 ? totalDist / count : 1;
     }
     /**
      * 【新增】检查单应性矩阵的一致性
@@ -3017,7 +3302,7 @@ class MotionLivenessDetector {
      * 逆向检测优先级更高，因为照片几何约束是物理定律，无法伪造
      */
     makeLivenessDecision(eyeActivity, mouthActivity, muscleActivity, photoGeometry) {
-        if (!this.isReady()) {
+        if (!this.collectedMinFrames()) {
             return true; // 数据不足，默认通过
         }
         // ============ 逆向检测（照片几何特征）============
@@ -4246,8 +4531,8 @@ class FaceDetectionEngine extends SimpleEventEmitter {
             }
             // 静默活体检测
             const motionResult = this.detectionState.motionDetector.analyzeMotion(face, faceBox);
-            // 只有ready状态的检测器的结果才可信
-            if (this.detectionState.motionDetector.isReady()) {
+            if (this.detectionState.motionDetector.collectedMinFrames()) {
+                // 采集到最小帧数后，否定性判定才可信
                 if (!motionResult.isLively) {
                     this.emitDebug('motion-detection', 'Motion liveness check failed - possible photo attack', {
                         details: motionResult.details,
@@ -4261,17 +4546,20 @@ class FaceDetectionEngine extends SimpleEventEmitter {
                     this.partialResetDetectionState();
                     return;
                 }
-                this.emitDebug('motion-detection', 'Motion liveness check passed', {
-                    debug: motionResult.debug,
-                    details: motionResult.details,
-                }, 'warn');
-                this.detectionState.liveness = true;
-            }
-            else {
-                this.emitDebug('motion-detection', 'Motion liveness detector not ready yet', {
-                    debug: motionResult.debug,
-                    details: motionResult.details,
-                }, 'warn');
+                // 采集到足够帧数后，肯定性判定才可信
+                if (this.detectionState.motionDetector.collectedFullFrames()) {
+                    this.emitDebug('motion-detection', 'Motion liveness check passed', {
+                        debug: motionResult.debug,
+                        details: motionResult.details,
+                    }, 'warn');
+                    this.detectionState.liveness = true;
+                }
+                else {
+                    this.emitDebug('motion-detection', 'Motion liveness check ongoing - collecting more frames', {
+                        debug: motionResult.debug,
+                        details: motionResult.details,
+                    }, 'warn');
+                }
             }
             // 动作活体检测阶段处理
             if (this.detectionState.period === DetectionPeriod.VERIFY) {