@sssxyd/face-liveness-detector 0.4.1-beta.6 → 0.4.1-beta.8

package/dist/index.esm.js

@@ -41,7 +41,6 @@ var DetectionCode;
     DetectionCode["FACE_TOO_SMALL"] = "FACE_TOO_SMALL";
     DetectionCode["FACE_TOO_LARGE"] = "FACE_TOO_LARGE";
     DetectionCode["FACE_NOT_FRONTAL"] = "FACE_NOT_FRONTAL";
-    DetectionCode["FACE_NOT_REAL"] = "FACE_NOT_REAL";
     DetectionCode["FACE_NOT_LIVE"] = "FACE_NOT_LIVE";
     DetectionCode["FACE_LOW_QUALITY"] = "FACE_LOW_QUALITY";
     DetectionCode["FACE_CHECK_PASS"] = "FACE_CHECK_PASS";
@@ -109,7 +108,7 @@ const DEFAULT_OPTIONS$1 = {
     action_liveness_action_list: [LivenessAction.BLINK, LivenessAction.MOUTH_OPEN, LivenessAction.NOD_DOWN, LivenessAction.NOD_UP],
     action_liveness_action_count: 1,
     action_liveness_action_randomize: true,
-    action_liveness_verify_timeout: 60000,
+    action_liveness_verify_timeout: 15000,
     action_liveness_min_mouth_open_percent: 0.2,
 };
 /**
@@ -1634,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 = [];
@@ -1683,7 +1685,7 @@ class MotionLivenessDetector {
                 });
             }
             // 数据不足时，继续收集
-            if (!this.isReady()) {
+            if (!this.collectedMinFrames()) {
                 return this.createEmptyResult({
                     reason: '数据收集中，帧数不足',
                     collectedFrames: this.normalizedLandmarksHistory.length
@@ -1700,7 +1702,7 @@ class MotionLivenessDetector {
             // 综合判定（结合正向和逆向检测）
             const isLively = this.makeLivenessDecision(eyeActivity, mouthActivity, muscleActivity, photoGeometryResult);
             return new MotionDetectionResult(isLively, {
-                frameCount: Math.max(this.eyeAspectRatioHistory.length, this.mouthAspectRatioHistory.length),
+                frameCount: Math.max(this.eyeAspectRatioHistory.length, this.mouthAspectRatioHistory.length, this.faceLandmarksHistory.length, this.normalizedLandmarksHistory.length),
                 // 正向检测结果（生物特征）
                 eyeAspectRatioStdDev: eyeActivity.stdDev,
                 mouthAspectRatioStdDev: mouthActivity.stdDev,
@@ -1893,10 +1895,13 @@ class MotionLivenessDetector {
      * 检测面部肌肉的微动（关键点位置微妙变化）
      * 关键：允许刚性运动+生物特征（真人摇头），拒绝纯刚性运动（照片旋转）
      *
-     * 【重要修复】使用归一化坐标进行比较，消除人脸在画面中移动的影响
+     * 【合理使用归一化坐标】这里使用归一化坐标是有意义的，因为：
+     * - 目的是检测肌肉的【相对运动幅度】，与人脸尺寸无关
+     * - 消除人脸在画面中位置变化的影响
+     * - 用相对于人脸的比例运动来判断肌肉活动
      */
     detectMuscleMovement() {
-        // 【关键】使用归一化坐标历史，而非绝对坐标
+        // 使用归一化坐标历史，消除人脸位置和尺寸影响
         if (this.normalizedLandmarksHistory.length < 2) {
             return { score: 0, variation: 0, hasMovement: false };
         }
@@ -1916,7 +1921,7 @@ class MotionLivenessDetector {
             127, 356 // 脸颊
         ];
         const distances = [];
-        // 【关键】使用归一化坐标计算位移
+        // 使用归一化坐标计算相对位移
         for (let i = 1; i < this.normalizedLandmarksHistory.length; i++) {
             const prevFrame = this.normalizedLandmarksHistory[i - 1];
             const currFrame = this.normalizedLandmarksHistory[i];
@@ -2017,12 +2022,14 @@ class MotionLivenessDetector {
      * - 照片所有关键点运动是【刚性的】→ 所有点以相同方向、相似幅度移动
      * - 活体肌肉运动是【非刚性的】→ 不同部位独立运动（眼睛、嘴、脸颊等）
      *
-     * 【重要修复】使用归一化坐标进行比较
+     * 【合理使用归一化坐标】这里使用归一化坐标是有意义的，因为：
+     * - 消除人脸在画面中的平移，只关注人脸内部的相对运动模式
+     * - 检测的是运动向量的方向一致性，不依赖绝对坐标
      *
      * 返回值 0-1：值越接近1说明是刚性运动（照片运动）
      */
     detectRigidMotion() {
-        // 【关键】使用归一化坐标历史
+        // 使用归一化坐标历史，消除平移影响
         if (this.normalizedLandmarksHistory.length < 2) {
             return 0; // 数据不足，不判定为刚性运动
         }
@@ -2035,7 +2042,7 @@ class MotionLivenessDetector {
             61, 291 // 嘴角
         ];
         const motionVectors = [];
-        // 【关键】使用归一化坐标计算运动向量
+        // 使用最近两帧计算运动向量
         const frame1 = this.normalizedLandmarksHistory[this.normalizedLandmarksHistory.length - 2];
         const frame2 = this.normalizedLandmarksHistory[this.normalizedLandmarksHistory.length - 1];
         for (const ptIdx of samplePoints) {
@@ -2361,7 +2368,7 @@ class MotionLivenessDetector {
      * 2. 跨帧深度模式 - 辅助参考
      */
     detectPhotoGeometry() {
-        if (this.faceLandmarksHistory.length < 3) {
+        if (this.normalizedLandmarksHistory.length < 3) {
             return { isPhoto: false, confidence: 0, details: {} };
         }
         // 【核心检测1】平面单应性约束检测（最可靠，纯2D几何）
@@ -2374,12 +2381,13 @@ class MotionLivenessDetector {
         const depthResult = this.detectDepthConsistency();
         const crossFrameDepth = this.detectCrossFrameDepthPattern();
         // 综合判定：2D几何约束权重高，Z坐标权重低
-        const photoScore = homographyResult.planarScore * 0.35 + // 单应性约束（最可靠）
-            perspectivePattern.perspectiveScore * 0.30 + // 透视变换模式（可靠）
-            crossRatioResult.invarianceScore * 0.20 + // 交叉比率不变性（可靠）
-            (1 - depthResult.depthVariation) * 0.10 + // 深度（辅助，低权重）
+        // 【改进】提高perspectiveScore的权重，因为完美的平滑变换是照片的强特征
+        const photoScore = homographyResult.planarScore * 0.30 + // 单应性约束（最可靠）
+            perspectivePattern.perspectiveScore * 0.40 + // 透视变换模式（可靠且权重提高）
+            crossRatioResult.invarianceScore * 0.15 + // 交叉比率不变性（可靠）
+            (1 - Math.min(depthResult.depthVariation, 1)) * 0.10 + // 深度（辅助，低权重）
             crossFrameDepth.planarPattern * 0.05; // 跨帧深度（辅助，低权重）
-        const isPhoto = photoScore > 0.60; // 阈值
+        const isPhoto = photoScore > 0.50; // 【改进】降低阈值到0.50（从0.60）
         const confidence = Math.min(photoScore, 1);
         // 记录历史
         this.planarityScores.push(photoScore);
@@ -2425,18 +2433,19 @@ class MotionLivenessDetector {
      * - 真实3D人脸旋转时，面部各点不共面，交叉比率会变化
      * - 照片无论怎么偏转，共线点的交叉比率保持不变
      *
-     * 【注意】交叉比率本身是比率，不依赖绝对坐标
-     * 使用归一化坐标只是为了一致性
+     * 虽然交叉比率是射影不变量（用任何坐标系都可以），
+     * 但使用原始坐标以保持一致性和物理意义的清晰性
      */
     detectCrossRatioInvariance() {
-        // 【使用归一化坐标历史，保持一致性】
-        if (this.normalizedLandmarksHistory.length < 3) {
+        // 【使用原始坐标历史】虽然交叉比率是射影不变量，
+        // 但原始坐标保持物理清晰性
+        if (this.faceLandmarksHistory.length < 3) {
             return { invarianceScore: 0 };
         }
         // 选择面部中线上近似共线的点（额头-鼻梁-鼻尖-嘴-下巴）
         const midlinePoints = [10, 168, 1, 0, 152]; // 从上到下
         const crossRatios = [];
-        for (const frame of this.normalizedLandmarksHistory) {
+        for (const frame of this.faceLandmarksHistory) {
             if (frame.length < 468)
                 continue;
             // 提取中线点的Y坐标（它们大致在一条垂直线上）
@@ -2492,118 +2501,541 @@ class MotionLivenessDetector {
     /**
      * 【单应性约束检测】判断多帧特征点是否满足平面约束
      *
-     * 【重要修复】使用归一化坐标进行比较
+     * 【关键改进】：
+     * 1. 使用DLT算法计算完整的3x3单应性矩阵（8参数）
+     * 2. 使用相邻帧而不是首尾帧（减少变化幅度）
+     * 3. 检查单应性矩阵的性质（秩、行列式等）
+     * 4. 计算多帧的平均误差（更稳定）
+     * 5. 对所有帧对的H矩阵一致性进行验证
+     *
      * 这是纯 2D 几何检测，最可靠！
      */
     detectHomographyConstraint() {
-        // 【关键】使用归一化坐标历史
-        if (this.normalizedLandmarksHistory.length < 2) {
+        // 【关键】使用原始坐标历史，而不是归一化坐标
+        // 原因：单应性矩阵在原始图像坐标中定义
+        // 归一化坐标虽然消除平移影响，但破坏了H矩阵的定义
+        if (this.faceLandmarksHistory.length < 2) {
             return { planarScore: 0 };
         }
-        const frame1 = this.normalizedLandmarksHistory[0];
-        const frame2 = this.normalizedLandmarksHistory[this.normalizedLandmarksHistory.length - 1];
-        if (frame1.length < 468 || frame2.length < 468) {
-            return { planarScore: 0, error: 0 };
-        }
-        // 选择用于计算单应性的4个基准点（面部四角）
-        const basePoints = [10, 152, 234, 454]; // 额头、下巴、左脸颊、右脸颊
-        // 选择用于验证的检验点
-        const testPoints = [33, 263, 61, 291, 1, 168]; // 眼角、嘴角、鼻尖、鼻梁
-        // 提取基准点坐标（归一化后的坐标）
-        const srcBase = [];
-        const dstBase = [];
-        for (const idx of basePoints) {
-            if (frame1[idx] && frame2[idx]) {
-                srcBase.push([frame1[idx][0], frame1[idx][1]]);
-                dstBase.push([frame2[idx][0], frame2[idx][1]]);
+        // 【改进】使用所有面部关键点（468个点）而不是采样点
+        // 更多的点对会给出更准确的单应性矩阵估计
+        const errors = [];
+        const homographyMatrices = [];
+        let lastSrcPoints = []; // 保存最后一组点对，用于计算特征尺度
+        // 【策略改进】优先使用最近的帧对（尽早检测）
+        // 照片的几何约束是瞬间的，2帧就足够；多帧用来验证一致性
+        const recentFrameCount = Math.min(5, this.faceLandmarksHistory.length);
+        // 计算最近帧对的变换误差（重点在最近的帧）
+        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 < 100 || frame2.length < 100)
+                continue; // 至少100个有效点
+            // 【改进】收集所有有效的点对（而不是只采样10个点）
+            // 这给出更好的H矩阵估计
+            const srcPoints = [];
+            const dstPoints = [];
+            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) {
+                    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 < 10)
+                continue; // 至少10个匹配点对（DLT最少需要4个）
+            // 保存这一组点对（用于后面计算特征尺度）
+            lastSrcPoints = srcPoints;
+            // 【新增】使用DLT算法计算完整的3x3单应性矩阵
+            const H = this.estimateHomographyDLT(srcPoints, dstPoints);
+            if (!H)
+                continue;
+            homographyMatrices.push(H);
+            // 【改进】使用单应性矩阵计算误差（而不是仿射变换）
+            let frameError = 0;
+            let validCount = 0;
+            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++;
+            }
+            if (validCount > 0) {
+                errors.push(frameError / validCount);
             }
         }
-        if (srcBase.length < 4) {
+        if (errors.length === 0) {
             return { planarScore: 0, error: 0 };
         }
-        // 计算简化的仿射变换（近似单应性）
-        // 使用最小二乘法拟合仿射变换 [a, b, c; d, e, f] 
-        const transform = this.estimateAffineTransform(srcBase, dstBase);
-        if (!transform) {
-            return { planarScore: 0, error: 0 };
+        // 计算所有帧的平均误差
+        const avgError = errors.reduce((a, b) => a + b, 0) / errors.length;
+        // 【新增】检查H矩阵的一致性
+        // 照片的H矩阵在不同帧对中应该保持相对稳定
+        let matrixConsistency = 1.0;
+        if (homographyMatrices.length > 1) {
+            matrixConsistency = this.checkHomographyConsistency(homographyMatrices);
+        }
+        // 【改进】使用相对误差而不是绝对误差
+        // 相对误差 = 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]', {
+            recentFrameCount,
+            frameCount: errors.length,
+            avgError: avgError.toFixed(4),
+            errorScore: errorScore.toFixed(3),
+            matrixConsistency: matrixConsistency.toFixed(3),
+            planarScore: planarScore.toFixed(3),
+            homographyMatrixCount: homographyMatrices.length
+        });
+        return { planarScore: Math.min(planarScore, 1), error: avgError };
+    }
+    /**
+     * 使用DLT算法估计单应性矩阵（Homography Estimation using DLT）
+     *
+     * DLT (Direct Linear Transform) 是估计射影变换的标准算法
+     *
+     * 输入：
+     * - 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)
+            return null;
+        const n = src.length;
+        // 【关键】对点进行归一化，提高数值稳定性
+        const srcNorm = this.normalizePoints(src);
+        const dstNorm = this.normalizePoints(dst);
+        if (!srcNorm || !dstNorm)
+            return null;
+        // 构建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];
+            // 第一行：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]);
+        }
+        // 使用最小二乘法求解 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;
+    }
+    /**
+     * 点集归一化（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)
+            return null;
+        // 计算重心
+        let cx = 0, cy = 0;
+        for (const p of points) {
+            cx += p[0];
+            cy += p[1];
+        }
+        cx /= points.length;
+        cy /= points.length;
+        // 计算平均距离
+        let avgDist = 0;
+        for (const p of points) {
+            const dx = p[0] - cx;
+            const dy = p[1] - cy;
+            avgDist += Math.sqrt(dx * dx + dy * dy);
+        }
+        avgDist /= points.length;
+        // 缩放因子
+        const scale = avgDist > 0.001 ? Math.sqrt(2) / avgDist : 1;
+        // 应用归一化变换
+        const normalized = [];
+        for (const p of points) {
+            normalized.push([
+                (p[0] - cx) * scale,
+                (p[1] - cy) * scale
+            ]);
+        }
+        // 归一化矩阵 T
+        const T = [
+            [scale, 0, -cx * scale],
+            [0, scale, -cy * scale],
+            [0, 0, 1]
+        ];
+        return { points: normalized, T };
+    }
+    /**
+     * 最小二乘法求解齐次线性方程 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) {
+        if (A.length < 8)
+            return null;
+        // 构造 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++) {
+                for (let k = 0; k < A.length; k++) {
+                    ATA[i][j] += A[k][i] * A[k][j];
+                }
+            }
         }
-        // 用仿射变换预测检验点位置，计算误差
-        let totalError = 0;
-        let validPoints = 0;
-        for (const idx of testPoints) {
-            if (frame1[idx] && frame2[idx]) {
-                const predicted = this.applyAffineTransform(transform, frame1[idx][0], frame1[idx][1]);
-                const actual = [frame2[idx][0], frame2[idx][1]];
-                // 归一化坐标下的误差（相对于人脸尺寸的比例）
-                const error = Math.sqrt((predicted[0] - actual[0]) ** 2 + (predicted[1] - actual[1]) ** 2);
-                totalError += error;
-                validPoints++;
+        // 求 A^T*A 的最小特征向量
+        // 最小特征向量对应最小特征值，使 ||Ah|| 最小
+        const eigenVec = this.getSmallestEigenvector(ATA);
+        return eigenVec;
+    }
+    /**
+     * 求9x9对称矩阵(A^T*A)的最小特征向量
+     * 使用改进的迭代方法
+     *
+     * 原理：
+     * - A^T*A 是对称半正定矩阵
+     * - 最小特征值对应的特征向量是最小二乘解
+     * - 使用迭代幂法（Power Iteration）的变种求最小特征向量
+     */
+    getSmallestEigenvector(mat) {
+        if (mat.length !== 9)
+            return null;
+        // 初始随机向量
+        let v = [1, 0, 0, 0, 1, 0, 0, 0, 1]; // 初始值更稳定
+        let prevEigenvalue = Infinity;
+        // 迭代求解最小特征值对应的特征向量
+        for (let iter = 0; iter < 50; iter++) {
+            // 计算 A*v
+            const Av = [0, 0, 0, 0, 0, 0, 0, 0, 0];
+            for (let i = 0; i < 9; i++) {
+                for (let j = 0; j < 9; j++) {
+                    Av[i] += mat[i][j] * v[j];
+                }
+            }
+            // 计算 Rayleigh 商（特征值估计）
+            let vTAv = 0;
+            let vTv = 0;
+            for (let i = 0; i < 9; i++) {
+                vTAv += v[i] * Av[i];
+                vTv += v[i] * v[i];
+            }
+            const eigenvalue = vTv > 1e-10 ? vTAv / vTv : 0;
+            // 标准化 Av
+            const AvNorm = Math.sqrt(Av.reduce((a, b) => a + b * b, 0));
+            if (AvNorm < 1e-10) {
+                break;
             }
+            // 更新 v
+            for (let i = 0; i < 9; i++) {
+                v[i] = Av[i] / AvNorm;
+            }
+            // 收敛判断：特征值变化很小
+            if (Math.abs(eigenvalue - prevEigenvalue) < 1e-8) {
+                break;
+            }
+            prevEigenvalue = eigenvalue;
         }
-        if (validPoints === 0) {
-            return { planarScore: 0, error: 0 };
+        // 最后做一次归一化
+        const norm = Math.sqrt(v.reduce((a, b) => a + b * b, 0));
+        if (norm > 1e-10) {
+            for (let i = 0; i < 9; i++) {
+                v[i] = v[i] / norm;
+            }
         }
-        const avgError = totalError / validPoints;
-        // 归一化坐标下，误差已经是相对于人脸尺寸的比例
-        // 不需要再除以脸宽
-        const relativeError = avgError;
-        // 平面得分：误差越小，越可能是平面（照片）
-        // relativeError < 0.02 → 非常可能是平面
-        // relativeError > 0.08 → 不太可能是平面
-        const planarScore = Math.max(0, 1 - relativeError / 0.05);
-        // 记录误差历史
-        this.homographyErrors.push(relativeError);
-        if (this.homographyErrors.length > this.config.frameBufferSize) {
-            this.homographyErrors.shift();
-        }
-        return { planarScore: Math.min(planarScore, 1), error: relativeError };
+        return v;
     }
     /**
-     * 估计仿射变换矩阵 (简化的单应性)
-     * 输入：源点和目标点对
-     * 输出：[a, b, c, d, e, f] 表示变换 x' = ax + by + c, y' = dx + ey + f
+     * 反演应化矩阵 - 从归一化坐标回到原始图像坐标
+     *
+     * 原理：
+     * - 在归一化坐标系中估算的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
      */
-    estimateAffineTransform(src, dst) {
-        if (src.length < 3 || dst.length < 3)
-            return null;
-        const n = Math.min(src.length, dst.length);
-        // 构建方程组 Ax = b (最小二乘)
-        // 对于 x': [x1, y1, 1, 0, 0, 0] * [a,b,c,d,e,f]^T = x1'
-        // 对于 y': [0, 0, 0, x1, y1, 1] * [a,b,c,d,e,f]^T = y1'
-        let sumX = 0, sumY = 0, sumX2 = 0, sumY2 = 0;
-        let sumXpX = 0, sumYpY = 0, sumXp = 0, sumYp = 0;
-        for (let i = 0; i < n; i++) {
-            const x = src[i][0], y = src[i][1];
-            const xp = dst[i][0], yp = dst[i][1];
-            sumX += x;
-            sumY += y;
-            sumX2 += x * x;
-            sumY2 += y * y;
-            sumXpX += xp * x;
-            sumXp += xp;
-            sumYpY += yp * y;
-            sumYp += yp;
-        }
-        // 计算缩放和旋转（简化版本）
-        const det = sumX2 * n - sumX * sumX;
+    denormalizeHomography(h, srcNorm, dstNorm) {
+        // 将向量h转换为3x3矩阵
+        const H_norm = [
+            [h[0], h[1], h[2]],
+            [h[3], h[4], h[5]],
+            [h[6], h[7], h[8]]
+        ];
+        // H = T_dst^-1 * H_norm * T_src
+        const T_src = srcNorm.T;
+        const T_dst = dstNorm.T;
+        const T_dst_inv = this.invertMatrix3x3(T_dst);
+        if (!T_dst_inv)
+            return H_norm;
+        // 矩阵乘法：(3x3) * (3x3) * (3x3)
+        const temp = this.multiplyMatrix3x3(T_dst_inv, H_norm);
+        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矩阵求逆
+     */
+    invertMatrix3x3(m) {
+        const [m00, m01, m02] = m[0];
+        const [m10, m11, m12] = m[1];
+        const [m20, m21, m22] = m[2];
+        const det = m00 * (m11 * m22 - m12 * m21) -
+            m01 * (m10 * m22 - m12 * m20) +
+            m02 * (m10 * m21 - m11 * m20);
         if (Math.abs(det) < 0.0001)
             return null;
-        const a = (sumXpX * n - sumXp * sumX) / (sumX2 * n - sumX * sumX + 0.0001);
-        const b = 0; // 简化，忽略剪切
-        const d = 0;
-        const e = (sumYpY * n - sumYp * sumY) / (sumY2 * n - sumY * sumY + 0.0001);
-        const c = sumXp / n - a * sumX / n;
-        const f = sumYp / n - e * sumY / n;
-        return [a || 1, b, c || 0, d, e || 1, f || 0];
+        const inv = [
+            [
+                (m11 * m22 - m12 * m21) / det,
+                (m02 * m21 - m01 * m22) / det,
+                (m01 * m12 - m02 * m11) / det
+            ],
+            [
+                (m12 * m20 - m10 * m22) / det,
+                (m00 * m22 - m02 * m20) / det,
+                (m02 * m10 - m00 * m12) / det
+            ],
+            [
+                (m10 * m21 - m11 * m20) / det,
+                (m01 * m20 - m00 * m21) / det,
+                (m00 * m11 - m01 * m10) / det
+            ]
+        ];
+        return inv;
+    }
+    /**
+     * 3x3矩阵乘法
+     */
+    multiplyMatrix3x3(A, B) {
+        const result = Array(3).fill(0).map(() => Array(3).fill(0));
+        for (let i = 0; i < 3; i++) {
+            for (let j = 0; j < 3; j++) {
+                for (let k = 0; k < 3; k++) {
+                    result[i][j] += A[i][k] * B[k][j];
+                }
+            }
+        }
+        return result;
     }
     /**
-     * 应用仿射变换
+     * 应用单应性变换 - 齐次坐标变换与反齐次化
+     *
+     * 操作步骤：
+     * 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，点被投影到无穷远（退化情况）
      */
-    applyAffineTransform(t, x, y) {
-        return [
-            t[0] * x + t[1] * y + t[2],
-            t[3] * x + t[4] * y + t[5]
+    applyHomography(H, x, y) {
+        // 齐次坐标表示
+        const p = [x, y, 1];
+        // 矩阵乘法：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[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;
+    }
+    /**
+     * 【新增】检查单应性矩阵的一致性
+     *
+     * 原理：
+     * - 照片旋转时，每对相邻帧的H矩阵应该相近（因为是持续旋转）
+     * - 真实人脸做随机动作时，H矩阵会变化很大
+     */
+    checkHomographyConsistency(matrices) {
+        if (matrices.length < 2)
+            return 1;
+        // 计算矩阵间的相似度
+        let totalSimilarity = 0;
+        let pairCount = 0;
+        for (let i = 1; i < matrices.length; i++) {
+            const M1 = matrices[i - 1];
+            const M2 = matrices[i];
+            // Frobenius范数相似度
+            let sumDiff = 0;
+            for (let r = 0; r < 3; r++) {
+                for (let c = 0; c < 3; c++) {
+                    const diff = M1[r][c] - M2[r][c];
+                    sumDiff += diff * diff;
+                }
+            }
+            const frobeniusDist = Math.sqrt(sumDiff);
+            // 标准化距离（除以矩阵范数）
+            let normM1 = 0, normM2 = 0;
+            for (let r = 0; r < 3; r++) {
+                for (let c = 0; c < 3; c++) {
+                    normM1 += M1[r][c] * M1[r][c];
+                    normM2 += M2[r][c] * M2[r][c];
+                }
+            }
+            normM1 = Math.sqrt(normM1);
+            normM2 = Math.sqrt(normM2);
+            const avgNorm = (normM1 + normM2) / 2;
+            const normalizedDist = avgNorm > 0.1 ? Math.min(frobeniusDist / avgNorm, 2) : 2;
+            // 将距离转换为相似度 (0-1)
+            // 距离越小，相似度越高
+            const similarity = Math.max(0, 1 - normalizedDist / 2);
+            totalSimilarity += similarity;
+            pairCount++;
+        }
+        return pairCount > 0 ? totalSimilarity / pairCount : 1;
     }
     /**
      * 【关键】检测深度一致性
@@ -2705,32 +3137,28 @@ class MotionLivenessDetector {
         const planarPattern = consistentFrames / depthChanges.length;
         return { planarPattern };
     }
-    /**
-     * 【关键】检测透视变换模式
-     *
-     * 原理：
-     * - 照片偏转时，特征点位置变化遵循严格的透视变换规律
-     * - 检测左右脸的相对变化是否符合透视投影
-     */
     /**
      * 【透视变换模式检测】
      *
-     * 【重要修复】使用归一化坐标进行比较
+     * 【改进】使用原始坐标而不是归一化坐标
      *
      * 原理：照片左右偏转时，左右脸宽度比例会平滑变化
+     * 这种比例变化遵循严格的透视投影规律
      */
     detectPerspectiveTransformPattern() {
-        // 【关键】使用归一化坐标历史
-        if (this.normalizedLandmarksHistory.length < 3) {
+        // 【关键】使用原始坐标历史，而不是归一化坐标
+        // 透视变换的宽度比例变化在原始图像坐标中更准确
+        if (this.faceLandmarksHistory.length < 3) {
             return { perspectiveScore: 0 };
         }
         // 比较左右脸的宽度比例变化
         // 照片左偏时：右脸变窄，左脸变宽（透视效果）
         // 这种变化应该是平滑且可预测的
         const widthRatios = [];
-        for (const frame of this.normalizedLandmarksHistory) {
+        for (const frame of this.faceLandmarksHistory) {
             if (frame.length >= 468) {
-                // 使用归一化坐标计算距离比例
+                // 使用原始坐标计算距离比例
+                // 234: 左脸颊边缘，1: 鼻尖，454: 右脸颊边缘
                 const leftWidth = this.pointDist(frame[234], frame[1]); // 左脸到鼻子
                 const rightWidth = this.pointDist(frame[1], frame[454]); // 鼻子到右脸
                 if (leftWidth > 0 && rightWidth > 0) {
@@ -2767,17 +3195,35 @@ class MotionLivenessDetector {
      * 逆向检测优先级更高，因为照片几何约束是物理定律，无法伪造
      */
     makeLivenessDecision(eyeActivity, mouthActivity, muscleActivity, photoGeometry) {
-        if (!this.isReady()) {
+        if (!this.collectedMinFrames()) {
             return true; // 数据不足，默认通过
         }
         // ============ 逆向检测（照片几何特征）============
         // 这是最可靠的检测方式，优先级最高
         const isPhotoByGeometry = photoGeometry.isPhoto;
         const photoConfidence = photoGeometry.confidence || 0;
+        const frameCount = Math.max(this.eyeAspectRatioHistory.length, this.mouthAspectRatioHistory.length, this.faceLandmarksHistory.length, this.normalizedLandmarksHistory.length);
+        // 【改进】根据帧数调整照片检测的敏感度
+        // 少帧情况下，照片特征更容易误判，但如果几何约束强，仍应拒绝
+        let photoConfidenceThreshold = 0.55;
+        if (frameCount < 8) {
+            // 少于8帧时，提高拒绝阈值，但只对超强照片特征有效
+            // perspectiveScore=1.0 是超强信号，不应该放过
+            if ((photoGeometry.details?.perspectiveScore || 0) > 0.95) {
+                photoConfidenceThreshold = 0.45; // 降低阈值
+            }
+            else {
+                photoConfidenceThreshold = 0.65; // 提高阈值
+            }
+        }
         // 如果照片几何检测高置信度判定为照片，直接拒绝
-        if (isPhotoByGeometry && photoConfidence > 0.75) {
+        // 【改进】根据帧数和具体特征调整阈值
+        if (isPhotoByGeometry && photoConfidence > photoConfidenceThreshold) {
             console.debug('[Decision] REJECTED by photo geometry detection', {
                 photoConfidence: photoConfidence.toFixed(3),
+                photoConfidenceThreshold: photoConfidenceThreshold.toFixed(3),
+                perspectiveScore: (photoGeometry.details?.perspectiveScore || 0).toFixed(3),
+                frameCount,
                 details: photoGeometry.details
             });
             return false;
@@ -2847,11 +3293,13 @@ class MotionLivenessDetector {
     /**
      * 检查脸部形状稳定性
      *
-     * 【重要修复】使用归一化坐标进行比较
-     * 这样即使人脸在画面中移动或缩放，比较仍然有效
+     * 【合理使用归一化坐标】这里使用归一化坐标是有意义的，因为：
+     * - 目的是检测【脸部形状的变化】（眼睛距离、嘴巴高度等）
+     * - 与人脸在画面中的位置和尺寸无关
+     * - 消除平移和缩放影响，专注于形状的变化
      */
     checkFaceShapeStability() {
-        // 【关键】使用归一化坐标历史
+        // 使用归一化坐标历史，消除平移和缩放影响
         if (this.normalizedLandmarksHistory.length < 5) {
             return 0.5; // 数据不足
         }
@@ -2864,7 +3312,7 @@ class MotionLivenessDetector {
             return 0.95; // 非常可能是照片
         }
         // 【第二层防护】检测脸部形状稳定性
-        // 使用归一化坐标计算距离
+        // 使用归一化坐标计算相对距离，检测形状变化
         const faceDistances = [];
         // 计算以下距离：
         // 1. 左眼-右眼（眼距）
@@ -3976,8 +4424,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,
@@ -3991,17 +4439,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) {