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

package/dist/index.esm.js

@@ -2525,12 +2525,23 @@ class MotionLivenessDetector {
         // 【策略改进】优先使用最近的帧对（尽早检测）
         // 照片的几何约束是瞬间的，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 < 100 || frame2.length < 100)
+            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 = [];
@@ -2551,30 +2562,61 @@ class MotionLivenessDetector {
                     }
                 }
             }
-            if (srcPoints.length < 10)
+            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 };
         }
         // 计算所有帧的平均误差
@@ -2595,10 +2637,12 @@ class MotionLivenessDetector {
         // 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),
@@ -2632,14 +2676,23 @@ class MotionLivenessDetector {
      * 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;
+        }
+        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形式推导：
@@ -2780,59 +2833,113 @@ class MotionLivenessDetector {
     }
     /**
      * 求9x9对称矩阵(A^T*A)的最小特征向量
-     * 使用改进的迭代方法
      *
-     * 原理：
-     * - A^T*A 是对称半正定矩阵
-     * - 最小特征值对应的特征向量是最小二乘解
-     * - 使用迭代幂法（Power Iteration）的变种求最小特征向量
+     * 【关键】使用 Jacobi 特征值分解而不是幂法
+     *
+     * 问题分析：
+     * - 迭代幂法（Power Iteration）求的是**最大**特征值的特征向量
+     * - 我们需要**最小**特征值的特征向量
+     * - 之前的幂法实现虽然标记为最小，但实际求的是最大 → 算法失败！
+     *
+     * 解决方案：
+     * 1. 使用 QR 算法或 Jacobi 方法求完整的特征值分解
+     * 2. 选择最小特征值对应的特征向量
+     *
+     * 此处实现简化的 Jacobi 迭代：
+     * - 对称矩阵对角化
+     * - 提取最小特征值的特征向量
      */
     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];
+        // 复制矩阵，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++) {
-                    Av[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;
+                    }
                 }
             }
-            // 计算 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) {
+            // 收敛判断
+            if (maxOffDiag < 1e-10) {
                 break;
             }
-            // 更新 v
+            // 计算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] = Av[i] / AvNorm;
+                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];
+                }
             }
-            // 收敛判断：特征值变化很小
-            if (Math.abs(eigenvalue - prevEigenvalue) < 1e-8) {
-                break;
+            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;
             }
-            prevEigenvalue = eigenvalue;
         }
-        // 最后做一次归一化
-        const norm = Math.sqrt(v.reduce((a, b) => a + b * b, 0));
+        // 找到最小特征值的位置
+        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++) {
-                v[i] = v[i] / norm;
+                eigenvector[i] = eigenvector[i] / norm;
             }
         }
-        return v;
+        return eigenvector;
     }
     /**
      * 反演应化矩阵 - 从归一化坐标回到原始图像坐标