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

package/dist/index.esm.js

@@ -2752,36 +2752,39 @@ function calculateCorrelation(mat1, mat2) {
  * 计算综合屏幕拍摄置信度
  * 基于各项特征指标的加权平均
  *
- * 权重说明：
- * - 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,
 };
@@ -2874,6 +2877,16 @@ function detectMoirePattern(cv, gray, config) {
         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 频域分析（优先方案）
@@ -2883,19 +2896,25 @@ function detectMoirePattern(cv, gray, config) {
             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,
         };
@@ -3446,6 +3465,10 @@ function analyzeEdgeDirection(cv, edges) {
 
 /**
  * RGB 发光模式检测的默认配置
+ *
+ * 针对完整高分辨率图像（1920×1080+）优化：
+ * - 足够的频域采样，RGB子像素周期信号清晰
+ * - 使用更严格的置信度阈值
  */
 const DEFAULT_RGB_EMISSION_CONFIG = {
     // 频率带分析参数
@@ -3797,7 +3820,8 @@ class ScreenCaptureDetector {
                 });
             }
             // 明确判定为屏幕捕捉时，直接返回
-            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) {
@@ -3833,7 +3857,8 @@ class ScreenCaptureDetector {
                 });
             }
             // 明确判定为屏幕捕捉时，直接返回
-            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) {
@@ -3874,7 +3899,8 @@ class ScreenCaptureDetector {
                     });
                 }
                 // 明确判定为屏幕捕捉时，直接返回
-                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) {
@@ -3890,9 +3916,10 @@ class ScreenCaptureDetector {
                 }
             }
             // 都不能明确判定，计算加权置信度
-            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;
             // 根据加权置信度判断风险等级
@@ -4626,8 +4653,6 @@ class FaceDetectionEngine extends SimpleEventEmitter {
         // 所有需要删除的 Mat 对象
         let bgrFrame = null;
         let grayFrame = null;
-        let bgrFace = null;
-        let grayFace = null;
         try {
             // 当前帧图片
             bgrFrame = drawCanvasToMat(this.cv, frameCanvas, false);
@@ -4643,14 +4668,6 @@ class FaceDetectionEngine extends SimpleEventEmitter {
                 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: ErrorCode.INTERNAL_ERROR,
@@ -4668,7 +4685,7 @@ class FaceDetectionEngine extends SimpleEventEmitter {
                 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 提取各检测器的置信度
@@ -4835,10 +4852,6 @@ class FaceDetectionEngine extends SimpleEventEmitter {
                 grayFrame.delete();
             if (bgrFrame)
                 bgrFrame.delete();
-            if (bgrFace)
-                bgrFace.delete();
-            if (grayFace)
-                grayFace.delete();
         }
     }
     /**