@sssxyd/face-liveness-detector 0.4.0-alpha.10 → 0.4.0-alpha.11

package/dist/index.js

@@ -2774,36 +2774,39 @@
      * 计算综合屏幕拍摄置信度
      * 基于各项特征指标的加权平均
      *
-     * 权重说明：
-     * - RGB相关性 (42%)：最强屏幕特征，完全独立于分辨率，是核心判断指标
-     * - 饱和度 (36%)：次强屏幕特征，屏幕图像去饱和特征明显
-     * - 像素熵 (22%)：辅助特征，屏幕像素分布规则性
-     *
-     * 删除梯度特征原因：
-     * - 梯度特征对分辨率敏感，是主要噪声源
-     * - 权重仅 17%，且可靠性最低（⭐⭐⭐）
-     * - 删除后准确率反而提升 1-3%（去掉噪声）
-     * - 代码简化 40%，性能提升 40%（少 80ms 计算）
-     * - RGB相关性 + 饱和度 已足以识别屏幕特性
+     * 针对完整高分辨率图像（1920×1080+）优化：
+     * - 足够的屏幕像素采样，所有特征都清晰
+     * - RGB相关性权重提升（屏幕同质性强）
+     * - 饱和度权重平衡（屏幕特征明显）
+     * - 像素熵权重保持
      */
     function calculateScreenConfidence(saturation, rgbCorrelation, entropy) {
-        // 加权平均：各特征的贡献度
-        // 权重自动归一化：35/83 : 30/83 : 18/83
         const weights = {
-            rgbCorrelation: 0.42, // RGB相关性：42% (from 35/83)
-            saturation: 0.36, // 饱和度：36% (from 30/83)
-            entropy: 0.22, // 像素熵：22% (from 18/83)
+            rgbCorrelation: 0.42, // RGB相关性：42% (完整图像中最强屏幕特征)
+            saturation: 0.36, // 饱和度：36%
+            entropy: 0.22, // 像素熵：22%
         };
-        const confidence = rgbCorrelation.score * weights.rgbCorrelation +
-            saturation.score * weights.saturation +
-            entropy.score * weights.entropy;
+        // 为每个特征计算连续得分（而不是二元的 0 或 1）
+        // 这样即使特征未达到硬阈值，仍然可以贡献部分置信度
+        // RGB 相关性：0.75-1.0 范围评分（屏幕通常 > 0.85）
+        const rgbScore = Math.max(0, (rgbCorrelation.value - 0.7) / (1.0 - 0.7));
+        // 饱和度：0-40 范围评分（屏幕通常 < 40）
+        const satScore = Math.max(0, 1 - (saturation.value / 40));
+        // 像素熵：4-8 范围评分（屏幕通常 < 6.5）
+        const entScore = Math.max(0, 1 - (entropy.value / 8));
+        const confidence = rgbScore * weights.rgbCorrelation +
+            satScore * weights.saturation +
+            entScore * weights.entropy;
         return Math.min(1, Math.max(0, confidence));
     }
 
     // ==================== 类型定义 ====================
     // ==================== 默认配置 ====================
     const DEFAULT_CONFIG = {
-        moire_threshold: 0.65,
+        // 针对完整高分辨率图像（1920×1080+）优化：
+        // - 完整采样提供充足的屏幕像素网格
+        // - 莫尔纹信号清晰，使用更严格的阈值
+        moire_threshold: 0.55,
         enable_dct: true,
         enable_edge_detection: true,
     };
@@ -2896,6 +2899,16 @@
             const finalConfig = { ...DEFAULT_CONFIG, ...config };
             if (!cv)
                 throw new Error('OpenCV instance not initialized');
+            // 验证灰度图像是否有效
+            if (!gray || gray.rows === 0 || gray.cols === 0) {
+                console.warn('[MoirePattern] Invalid gray image');
+                return {
+                    isScreenCapture: false,
+                    confidence: 0.0,
+                    moireStrength: 0.0,
+                    dominantFrequencies: [],
+                };
+            }
             let moireStrength = 0;
             let dominantFrequencies = [];
             // 使用 DCT 频域分析（优先方案）
@@ -2905,19 +2918,25 @@
                 dominantFrequencies = dctResult.dominantFrequencies;
             }
             // 辅助：Canny 边缘检测方案用于增强检测
-            if (finalConfig.enable_edge_detection) {
-                const edges = new cv.Mat();
-                cv.Canny(gray, edges, 50, 150);
-                const periodicity = detectPeriodicity(cv, edges);
-                const directionConsistency = analyzeEdgeDirection(cv, edges);
-                edges.delete();
-                // 融合两种方法的结果
-                moireStrength += (periodicity + directionConsistency) * 0.5 * 0.4;
+            if (finalConfig.enable_edge_detection && moireStrength < 0.5) {
+                try {
+                    const edges = new cv.Mat();
+                    cv.Canny(gray, edges, 50, 150);
+                    const periodicity = detectPeriodicity(cv, edges);
+                    const directionConsistency = analyzeEdgeDirection(cv, edges);
+                    edges.delete();
+                    // 融合两种方法的结果
+                    moireStrength += (periodicity + directionConsistency) * 0.5 * 0.4;
+                }
+                catch (edgeError) {
+                    console.warn('[MoirePattern] Edge detection failed, skipping:', edgeError);
+                    // 继续使用 DCT 结果
+                }
             }
             const isScreenCapture = moireStrength > finalConfig.moire_threshold;
             return {
                 isScreenCapture,
-                confidence: Math.min(Math.abs(moireStrength - finalConfig.moire_threshold) / 0.35, 1.0),
+                confidence: Math.min(Math.max(0, moireStrength), 1.0),
                 moireStrength,
                 dominantFrequencies,
             };
@@ -3468,6 +3487,10 @@
 
     /**
      * RGB 发光模式检测的默认配置
+     *
+     * 针对完整高分辨率图像（1920×1080+）优化：
+     * - 足够的频域采样，RGB子像素周期信号清晰
+     * - 使用更严格的置信度阈值
      */
     const DEFAULT_RGB_EMISSION_CONFIG = {
         // 频率带分析参数
@@ -3819,7 +3842,8 @@
                     });
                 }
                 // 明确判定为屏幕捕捉时，直接返回
-                const rgbCanDetermine = rgbEmissionResult.isScreenCapture && rgbEmissionResult.confidence > 0.75;
+                // 完整高分辨率图像：RGB信号应该很强
+                const rgbCanDetermine = rgbEmissionResult.isScreenCapture && rgbEmissionResult.confidence > 0.65;
                 if (rgbCanDetermine) {
                     const totalTime = performance.now() - startTime;
                     if (debug) {
@@ -3855,7 +3879,8 @@
                     });
                 }
                 // 明确判定为屏幕捕捉时，直接返回
-                const colorCanDetermine = colorResult.isScreenCapture && colorResult.confidence > 0.75;
+                // 完整高分辨率图像：色彩特征应该清晰
+                const colorCanDetermine = colorResult.isScreenCapture && colorResult.confidence > 0.65;
                 if (colorCanDetermine) {
                     const totalTime = performance.now() - startTime;
                     if (debug) {
@@ -3896,7 +3921,8 @@
                         });
                     }
                     // 明确判定为屏幕捕捉时，直接返回
-                    const moireCanDetermine = moireResult.isScreenCapture && moireResult.confidence > 0.75;
+                    // 完整高分辨率图像：莫尔纹应该很清晰
+                    const moireCanDetermine = moireResult.isScreenCapture && moireResult.confidence > 0.65;
                     if (moireCanDetermine) {
                         const totalTime = performance.now() - startTime;
                         if (debug) {
@@ -3912,9 +3938,10 @@
                     }
                 }
                 // 都不能明确判定，计算加权置信度
-                const weightedConfidence = rgbEmissionResult.confidence * 0.5 + // RGB权重 50%
-                    colorResult.confidence * 0.3 + // Color权重 30%
-                    moireResult.confidence * 0.2; // Moiré权重 20%
+                // 优化权重比例：针对完整高分辨率图像（1920×1080+）
+                const weightedConfidence = rgbEmissionResult.confidence * 0.50 + // RGB权重 50%
+                    colorResult.confidence * 0.25 + // Color权重 25%
+                    moireResult.confidence * 0.25; // Moiré权重 25% (提升，完整图像中莫尔纹清晰)
                 // 第 3 层：用加权置信度判定最终结果
                 const isScreenCapture = weightedConfidence > this.confidenceThreshold;
                 // 根据加权置信度判断风险等级
@@ -4648,8 +4675,6 @@
             // 所有需要删除的 Mat 对象
             let bgrFrame = null;
             let grayFrame = null;
-            let bgrFace = null;
-            let grayFace = null;
             try {
                 // 当前帧图片
                 bgrFrame = drawCanvasToMat(this.cv, frameCanvas, false);
@@ -4665,14 +4690,6 @@
                     this.scheduleNextDetection(this.options.detect_error_retry_delay);
                     return;
                 }
-                // 提取人脸区域图片及灰度图片
-                bgrFace = bgrFrame.roi(new this.cv.Rect(faceBox[0], faceBox[1], faceBox[2], faceBox[3]));
-                grayFace = matToGray(this.cv, bgrFace);
-                if (!grayFace) {
-                    this.emitDebug('detection', 'Failed to convert face Mat to grayscale', {}, 'warn');
-                    this.scheduleNextDetection(this.options.detect_error_retry_delay);
-                    return;
-                }
                 if (!this.detectionState.screenDetector) {
                     this.emit('detector-error', {
                         code: exports.ErrorCode.INTERNAL_ERROR,
@@ -4690,7 +4707,7 @@
                     return;
                 }
                 // 屏幕捕获检测, 只关心脸部区域
-                const screenResult = this.detectionState.screenDetector.detect(bgrFace, grayFace, this.options.debug_mode);
+                const screenResult = this.detectionState.screenDetector.detect(bgrFrame, grayFrame, this.options.debug_mode);
                 // 屏幕捕获检测器已经准备就绪，其验证结果可信
                 if (screenResult.isScreenCapture) {
                     // 从 executedMethods 提取各检测器的置信度
@@ -4857,10 +4874,6 @@
                     grayFrame.delete();
                 if (bgrFrame)
                     bgrFrame.delete();
-                if (bgrFace)
-                    bgrFace.delete();
-                if (grayFace)
-                    grayFace.delete();
             }
         }
         /**