@sssxyd/face-liveness-detector 0.4.2-alpha.3 → 0.4.3-alpha.10

package/dist/index.esm.js

@@ -41,11 +41,11 @@ 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_LIVE"] = "FACE_NOT_LIVE";
     DetectionCode["FACE_LOW_QUALITY"] = "FACE_LOW_QUALITY";
     DetectionCode["FACE_CHECK_PASS"] = "FACE_CHECK_PASS";
-    DetectionCode["PLEASE_MOVING_FACE"] = "PLEASE_MOVING_FACE";
+    DetectionCode["FACE_NOT_MOVING"] = "FACE_NOT_MOVING";
     DetectionCode["PHOTO_ATTACK_DETECTED"] = "PHOTO_ATTACK_DETECTED";
+    DetectionCode["SCREEN_ATTACK_DETECTED"] = "SCREEN_ATTACK_DETECTED";
 })(DetectionCode || (DetectionCode = {}));
 /**
  * Error code enumeration
@@ -84,6 +84,9 @@ const DEFAULT_OPTIONS$2 = {
     debug_log_level: 'info',
     debug_log_stages: undefined, // undefined 表示所有阶段
     debug_log_throttle: 100, // 默认 100ms 节流，防止过于频繁
+    enable_face_moving_detection: true,
+    enable_photo_attack_detection: true,
+    enable_screen_attack_detection: true,
     // Detection Settings
     detect_video_ideal_width: 1280,
     detect_video_ideal_height: 720,
@@ -1110,12 +1113,13 @@ async function _initializeOpenCV(timeout) {
         const canSetCallback = cvModule && Object.isExtensible(cvModule);
         if (canSetCallback) {
             try {
-                const originalOnRuntimeInitialized = cvModule.onRuntimeInitialized(cvModule).onRuntimeInitialized = () => {
+                const originalCallback = cvModule.onRuntimeInitialized;
+                const newCallback = () => {
                     console.log('[FaceDetectionEngine] onRuntimeInitialized callback triggered');
                     // 调用原始回调（如果存在）
-                    if (originalOnRuntimeInitialized && typeof originalOnRuntimeInitialized === 'function') {
+                    if (originalCallback && typeof originalCallback === 'function') {
                         try {
-                            originalOnRuntimeInitialized();
+                            originalCallback();
                         }
                         catch (e) {
                             console.warn('[FaceDetectionEngine] Original onRuntimeInitialized callback failed:', e);
@@ -1123,6 +1127,7 @@ async function _initializeOpenCV(timeout) {
                     }
                     resolveOnce('callback');
                 };
+                cvModule.onRuntimeInitialized = newCallback;
                 console.log('[FaceDetectionEngine] onRuntimeInitialized callback set successfully');
             }
             catch (e) {
@@ -1562,11 +1567,13 @@ function matToBase64Jpeg(cv, mat, quality = 0.9) {
 class FaceMovingDetectionResult {
     isMoving;
     details;
-    debug;
-    constructor(isMoving, details, debug = {}) {
+    available = false;
+    trusted = false;
+    constructor(isMoving, details, available = false) {
         this.isMoving = isMoving;
         this.details = details;
-        this.debug = debug;
+        this.available = available;
+        this.trusted = available;
     }
     getMessage() {
         if (this.details.frameCount < 2) {
@@ -1682,7 +1689,7 @@ class FaceMovingDetector {
         details.lastCentroidShift = this.calculateCentroidShift(lastFrame.result);
         // 计算中心化坐标的变化速率（基于实际时间）
         details.centroidShiftRate = this.calculateCentroidShiftRate();
-        return new FaceMovingDetectionResult(details.isMoving, details);
+        return new FaceMovingDetectionResult(details.isMoving, details, true);
     }
     /**
      * 计算两帧之间的运动强度
@@ -1840,17 +1847,6 @@ class FaceMovingDetector {
         const variance = squaredDiffs.reduce((a, b) => a + b) / values.length;
         return Math.sqrt(variance);
     }
-    /**
-     * 检查当前实例是否可用
-     *
-     * @description 通过检查帧缓冲区长度来判断实例是否处于可用状态
-     *              当帧缓冲区长度大于等于2时，认为实例可用
-     *
-     * @returns {boolean} 如果实例可用返回true，否则返回false
-     */
-    isAvailable() {
-        return this.frameBuffer.length >= 2;
-    }
     /**
      * 重置检测器
      */
@@ -1880,22 +1876,12 @@ class FaceMovingDetector {
 }
 
 /**
- * 照片攻击检测器 - 双重方案实现
- *
- * 方案一：MediaPipe 3D 关键点深度方差分析
- * - 完全不依赖背景
- * - 对白墙、黑墙、任意纯色背景均有效
- * - 只需人脸本身具有 3D 结构（真实人脸有，照片没有）
+ * 照片攻击检测器
  *
- * 方案二：关键点运动透视一致性检验
+ * 关键点运动透视一致性检验
  * - 比较鼻尖、脸颊、耳朵等在多帧中的 2D 位移比例
  * - 真实人脸因透视效应，近处点移动幅度 > 远处点
  * - 照片上所有点按同一仿射变换移动 → 运动向量高度一致
- *
- * ⚠️ 关键理解 ⚠️
- * MediaPipe 返回的 Z 坐标（深度）是从 2D 图像【推断】出来的，不是真实的物理深度！
- * - 对真实人脸：推断出正确的 3D 结构 → Z 坐标有方差
- * - 对照片人脸：推断深度值可能平坦 → Z 坐标方差极小
  */
 /**
  * 照片攻击检测结果
@@ -1903,17 +1889,13 @@ class FaceMovingDetector {
 class PhotoAttackDetectionResult {
     isPhoto;
     details;
-    debug;
-    constructor(isPhoto, details, debug = {}) {
+    available = false;
+    trusted = false;
+    constructor(isPhoto, details, available = false, trusted = false) {
         this.isPhoto = isPhoto;
         this.details = details;
-        this.debug = debug;
-    }
-    isAvailable() {
-        return this.details.frameCount >= 3;
-    }
-    isTrusted() {
-        return this.details.frameCount >= 15;
+        this.available = available;
+        this.trusted = trusted;
     }
     getMessage() {
         if (this.details.frameCount < 3) {
@@ -1923,14 +1905,10 @@ class PhotoAttackDetectionResult {
             return '';
         const confidence = (this.details.photoConfidence * 100).toFixed(0);
         const reasons = [];
-        if (this.details.depthVarianceScore > 0.5) {
-            const depthVar = (this.details.depthVariance * 1000).toFixed(1);
-            reasons.push(`深度方差极小(${depthVar})`);
-        }
         if (this.details.perspectiveScore > 0.5) {
-            this.details.motionDisplacementVariance.toFixed(3);
+            const motionVar = this.details.motionDisplacementVariance.toFixed(3);
             const consistency = (this.details.motionDirectionConsistency * 100).toFixed(0);
-            reasons.push(`运动一致性过高(${consistency}%)`);
+            reasons.push(`运动一致性过高(${consistency}%)，位移方差(${motionVar})`);
         }
         const reasonStr = reasons.length > 0 ? `（${reasons.join('、')}）` : '';
         return `检测到照片攻击${reasonStr}，置信度 ${confidence}%`;
@@ -1938,17 +1916,15 @@ class PhotoAttackDetectionResult {
 }
 const DEFAULT_OPTIONS = {
     frameBufferSize: 15, // 15帧 (0.5秒@30fps)
-    depthVarianceThreshold: 0.001, // 深度方差阈值：真实人脸 > 0.005，照片 < 0.001
-    motionVarianceThreshold: 0.01, // 运动方差阈值：真实人脸 > 0.02，照片 < 0.01
-    perspectiveRatioThreshold: 0.85, // 透视比率阈值：真实人脸 > 0.95，照片 < 0.85
+    requiredFrameCount: 15, // 可信赖所需的最小帧数
+    motionVarianceThreshold: 0.005, // 运动方差阈值：真实人脸 > 0.02，照片 < 0.01
+    perspectiveRatioThreshold: 1, // 透视比率阈值：真实人脸 > 1，照片 < 1
     motionConsistencyThreshold: 0.8, // 运动一致性阈值：真实人脸 < 0.5，照片 > 0.8
 };
 /**
  * 照片攻击检测器
  *
- * 两种检测方案：
- * 1. 3D 深度方差分析（依赖 MediaPipe Z 坐标）
- * 2. 运动透视一致性检验（纯 2D 几何分析）
+ * 运动透视一致性检验（纯 2D 几何分析）
  */
 class PhotoAttackDetector {
     config;
@@ -1984,11 +1960,6 @@ class PhotoAttackDetector {
     detect() {
         const details = {
             frameCount: this.frameBuffer.length,
-            depthVariance: 0,
-            keyPointDepthVariance: 0,
-            depthRange: 0,
-            isFlatDepth: false,
-            depthVarianceScore: 0,
             motionDisplacementVariance: 0,
             perspectiveRatio: 0,
             motionDirectionConsistency: 0,
@@ -1996,127 +1967,24 @@ class PhotoAttackDetector {
             perspectiveScore: 0,
             isPhoto: false,
             photoConfidence: 0,
-            dominantFeature: 'combined'
         };
         // 帧数不足，无法检测
         if (this.frameBuffer.length < 3) {
             return new PhotoAttackDetectionResult(false, details);
         }
-        // ============ 方案一：3D 深度方差分析 ============
-        const depthAnalysis = this.analyzeDepthVariance();
-        details.depthVariance = depthAnalysis.depthVariance;
-        details.keyPointDepthVariance = depthAnalysis.keyPointDepthVariance;
-        details.depthRange = depthAnalysis.depthRange;
-        details.isFlatDepth = depthAnalysis.isFlatDepth;
-        details.depthVarianceScore = depthAnalysis.score;
-        // ============ 方案二：运动透视一致性检验 ============
+        // ============ 运动透视一致性检验 ============
         const perspectiveAnalysis = this.analyzePerspectiveConsistency();
         details.motionDisplacementVariance = perspectiveAnalysis.motionDisplacementVariance;
         details.perspectiveRatio = perspectiveAnalysis.perspectiveRatio;
         details.motionDirectionConsistency = perspectiveAnalysis.motionDirectionConsistency;
         details.affineTransformPatternMatch = perspectiveAnalysis.affineTransformPatternMatch;
         details.perspectiveScore = perspectiveAnalysis.score;
-        // ============ 综合判定 ============
-        const isPhotoByDepth = depthAnalysis.score > 0.6;
-        const isPhotoByPerspective = perspectiveAnalysis.score > 0.6;
-        // 只要有一个方案高置信度检测到照片，就判定为照片
-        details.isPhoto = isPhotoByDepth || isPhotoByPerspective;
-        // 置信度：两个方案的最大值（最强的证据）
-        details.photoConfidence = Math.max(depthAnalysis.score, perspectiveAnalysis.score);
-        // 确定最强特征
-        if (Math.abs(depthAnalysis.score - perspectiveAnalysis.score) < 0.1) {
-            details.dominantFeature = 'combined';
-        }
-        else if (depthAnalysis.score > perspectiveAnalysis.score) {
-            details.dominantFeature = 'depth';
-        }
-        else {
-            details.dominantFeature = 'perspective';
-        }
-        return new PhotoAttackDetectionResult(details.isPhoto, details);
-    }
-    /**
-     * 方案一：3D 深度方差分析
-     *
-     * 原理：
-     * - 真实人脸具有真实的 3D 结构，Z 坐标（深度）跨越较大范围
-     * - 照片是 2D 的，所有点深度基本相同，Z 坐标方差极小
-     * - MediaPipe 可以从 2D 图像推断出深度，但：
-     *   - 真实人脸：推断正确，Z 坐标有明显差异（鼻尖 > 脸颊 > 耳朵）
-     *   - 照片：推断平坦，Z 坐标基本相同
-     */
-    analyzeDepthVariance() {
-        let allDepths = [];
-        let keyPointDepths = [];
-        // 提取所有帧的深度值
-        for (const result of this.frameBuffer) {
-            // 方案一：使用 rotation 字段中的深度信息
-            if (!result.meshRaw)
-                continue;
-            // 提取所有关键点的 Z 坐标
-            for (const point of result.meshRaw) {
-                if (point.length >= 3 && typeof point[2] === 'number') {
-                    allDepths.push(point[2]);
-                }
-            }
-            // 提取关键特征点的深度（鼻子、脸颊、耳朵）
-            const annotations = result.annotations;
-            if (annotations) {
-                const nose = annotations.nose || [];
-                const leftCheek = annotations.leftCheek || [];
-                const rightCheek = annotations.rightCheek || [];
-                const leftEar = annotations.leftEar || [];
-                const rightEar = annotations.rightEar || [];
-                const allKeypoints = [
-                    ...nose,
-                    ...leftCheek,
-                    ...rightCheek,
-                    ...leftEar,
-                    ...rightEar
-                ];
-                for (const point of allKeypoints) {
-                    if (point.length >= 3 && typeof point[2] === 'number') {
-                        keyPointDepths.push(point[2]);
-                    }
-                }
-            }
-        }
-        if (allDepths.length === 0) {
-            return {
-                depthVariance: 0,
-                keyPointDepthVariance: 0,
-                depthRange: 0,
-                isFlatDepth: true,
-                score: 0
-            };
-        }
-        // 计算深度方差
-        const depthVariance = this.calculateVariance(allDepths);
-        const depthRange = Math.max(...allDepths) - Math.min(...allDepths);
-        // 关键点深度方差
-        const keyPointDepthVariance = keyPointDepths.length > 0
-            ? this.calculateVariance(keyPointDepths)
-            : 0;
-        // 判定是否为平坦深度
-        const isFlatDepth = depthVariance < this.config.depthVarianceThreshold;
-        // 计算置信度分数
-        // 深度方差越小，越可能是照片；深度方差越大，越可能是真实人脸
-        // 使用反向逻辑：照片得分高，真实人脸得分低
-        const variance_score = Math.max(0, (this.config.depthVarianceThreshold - depthVariance) / this.config.depthVarianceThreshold);
-        // 关键点深度方差也应该很小
-        const keypoint_score = Math.max(0, (this.config.depthVarianceThreshold - keyPointDepthVariance) / this.config.depthVarianceThreshold);
-        // 综合分数
-        const score = Math.min(1, (variance_score + keypoint_score) / 2);
-        return {
-            depthVariance,
-            keyPointDepthVariance,
-            depthRange,
-            isFlatDepth,
-            score
-        };
+        details.isPhoto = perspectiveAnalysis.score > 0.5;
+        details.photoConfidence = perspectiveAnalysis.score;
+        return new PhotoAttackDetectionResult(details.isPhoto, details, true, this.frameBuffer.length >= this.config.requiredFrameCount);
     }
     /**
-     * 方案二：运动透视一致性检验
+     * 运动透视一致性检验
      *
      * 原理：
      * - 真实人脸运动：由于透视效应，近处点移动幅度大，远处点移动幅度小
@@ -2165,7 +2033,40 @@ class PhotoAttackDetector {
         // - 方向一致性越高 -> 照片特征 -> score高
         // - 仿射变换匹配度越高 -> 照片特征 -> score高
         const variance_indicator = Math.max(0, 1 - (motionDisplacementVariance / this.config.motionVarianceThreshold));
-        const ratio_indicator = Math.max(0, 1 - Math.abs(perspectiveRatio - 1) / (1 - this.config.perspectiveRatioThreshold));
+        // 修改透视比率计算逻辑以支持阈值大于等于1的情况
+        let ratio_indicator = 0;
+        if (this.config.perspectiveRatioThreshold === 1) {
+            // 特殊情况：阈值等于1时
+            // perspectiveRatio < 1: 近处点移动 < 远处点，明显照片特征 → 高分
+            // perspectiveRatio >= 1: 近处点移动 >= 远处点，符合透视效应 → 低分
+            if (perspectiveRatio < 1) {
+                // 使用非线性放大，让 0.90 ~ 1 的 范围得到更高分数
+                const deviation = 1 - perspectiveRatio;
+                ratio_indicator = Math.min(1, deviation * 10);
+            }
+            else {
+                // 大于等于1，符合透视效应，降低照片分数
+                ratio_indicator = 0;
+            }
+        }
+        else if (this.config.perspectiveRatioThreshold < 1) {
+            // 阈值小于1时的逻辑
+            const denominator = 1 - this.config.perspectiveRatioThreshold;
+            ratio_indicator = Math.max(0, 1 - Math.abs(perspectiveRatio - 1) / denominator);
+        }
+        else {
+            // 阈值大于1时，真实人脸应有更高比率
+            // 如果透视比率大于阈值，则更可能是真实人脸，返回低分（非照片）
+            // 如果透视比率小于等于阈值，则可能是照片，返回高分
+            if (perspectiveRatio < this.config.perspectiveRatioThreshold) {
+                // 透视比率小于阈值，更像照片
+                ratio_indicator = Math.max(0, 1 - (this.config.perspectiveRatioThreshold - perspectiveRatio) / this.config.perspectiveRatioThreshold);
+            }
+            else {
+                // 透视比率大于阈值，更像真实人脸
+                ratio_indicator = 0; // 真实人脸，返回低分
+            }
+        }
         const consistency_indicator = Math.min(1, motionDirectionConsistency / this.config.motionConsistencyThreshold);
         const affine_indicator = affineTransformPatternMatch;
         // 综合分数：四个指标的平均值
@@ -2356,11 +2257,385 @@ class PhotoAttackDetector {
     reset() {
         this.frameBuffer = [];
     }
+}
+
+/**
+ * 屏幕攻击检测结果
+ */
+class ScreenAttackDetectionResult {
+    isScreenAttack;
+    details;
+    available = false;
+    trusted = false;
+    constructor(isScreenAttack, details, available = false, trusted = false) {
+        this.isScreenAttack = isScreenAttack;
+        this.details = details;
+        this.available = available;
+        this.trusted = trusted;
+    }
+    getMessage() {
+        if (this.details.frameCount < 1) {
+            return '未获得足够数据，无法进行屏幕攻击检测';
+        }
+        if (!this.isScreenAttack)
+            return '';
+        const confidence = (this.details.screenAttackConfidence * 100).toFixed(2);
+        const reasons = [];
+        if (this.details.moireConfidence > 0.6) {
+            const moireScore = (this.details.moireScore * 100).toFixed(2);
+            reasons.push(`摩尔纹特征明显(${moireScore})`);
+        }
+        const reasonStr = reasons.length > 0 ? `（${reasons.join('、')}）` : '';
+        return `检测到屏幕攻击${reasonStr}，置信度 ${confidence}%`;
+    }
+}
+const DEFAULT_SCREEN_OPTIONS = {
+    moireThreshold: 0.65,
+    pixelGridSensitivity: 0.75,
+    requiredFrameCount: 12,
+    earlyDetectionThreshold: 0.8
+};
+/**
+ * 屏幕攻击检测器
+ *
+ * 检测方案：
+ * 摩尔纹/像素网格分析（检测屏幕特有的周期性图案）
+ */
+class ScreenAttackDetector {
+    config;
+    opencv = null;
+    frameCount = 0;
+    emitDebug = () => { }; // 默认空实现
+    constructor(options) {
+        this.config = { ...DEFAULT_SCREEN_OPTIONS, ...options };
+    }
     /**
-     * 获取当前缓冲区中的帧数
+     * 设置 OpenCV 实例
+     * @param opencv - TechStark opencv.js 实例
      */
-    getFrameCount() {
-        return this.frameBuffer.length;
+    setOpencv(opencv) {
+        this.opencv = opencv;
+    }
+    /**
+     * 设置 emitDebug 方法（依赖注入）
+     * @param emitDebugFn - 来自 FaceDetectionEngine 的 emitDebug 方法
+     */
+    setEmitDebug(emitDebugFn) {
+        this.emitDebug = emitDebugFn;
+    }
+    /**
+     * 检测屏幕攻击
+     * @param faceBox - 人脸区域框
+     * @param colorMat - 彩色图像矩阵
+     * @param grayMat - 灰度图像矩阵
+     * @returns 检测结果
+     */
+    detect(colorMat, grayMat) {
+        this.frameCount += 1;
+        const details = {
+            frameCount: this.frameCount,
+            moireScore: 0,
+            pixelGridStrength: 0,
+            moireConfidence: 0,
+            isScreenAttack: false,
+            screenAttackConfidence: 0,
+            feature: 'moire',
+            debugInfo: {}
+        };
+        // 检查OpenCV是否已设置
+        if (!this.opencv) {
+            this.emitDebug('screen-attack', 'OpenCV未初始化', {}, 'warn');
+            return new ScreenAttackDetectionResult(false, details);
+        }
+        try {
+            // ============ 摩尔纹/像素网格分析 ============
+            const moireAnalysis = this.analyzeMoirePattern(grayMat);
+            details.moireScore = moireAnalysis.score;
+            details.pixelGridStrength = moireAnalysis.pixelGridStrength;
+            details.moireConfidence = moireAnalysis.confidence;
+            details.debugInfo.moireAnalysis = moireAnalysis.debug;
+            // 早期检测：如果摩尔纹分数过高，直接判定为屏幕攻击
+            if (details.moireScore > this.config.earlyDetectionThreshold) {
+                details.isScreenAttack = true;
+                details.screenAttackConfidence = details.moireScore;
+                details.feature = 'moire';
+                this.emitDebug('screen-attack', '摩尔纹分析早期检测触发', {
+                    moireScore: details.moireScore,
+                    earlyThreshold: this.config.earlyDetectionThreshold
+                });
+                return new ScreenAttackDetectionResult(true, details, true, true);
+            }
+            // 基于摩尔纹置信度的判定
+            details.isScreenAttack = details.moireConfidence > this.config.moireThreshold;
+            details.screenAttackConfidence = details.moireScore;
+            this.emitDebug('screen-attack', '摩尔纹分析完成', {
+                moireScore: details.moireScore,
+                isScreenAttack: details.isScreenAttack
+            });
+            return new ScreenAttackDetectionResult(details.isScreenAttack, details, true, this.frameCount >= this.config.requiredFrameCount);
+        }
+        catch (error) {
+            this.emitDebug('screen-attack', `检测过程中发生错误: ${error}`, {}, 'error');
+            return new ScreenAttackDetectionResult(false, details, false, false);
+        }
+    }
+    /**
+     * 摩尔纹/像素网格分析
+     *
+     * 原理：
+     * - 真实人脸：纹理在频域中分布较为随机
+     * - 屏幕显示：像素阵列在频域中产生特有的摩尔纹和周期性图案
+     * - 摄像头采样与屏幕像素网格的频率混叠效应
+     */
+    analyzeMoirePattern(grayMat) {
+        const cv = this.opencv;
+        let debugInfo = {};
+        try {
+            // 分析整个图像，而不是特定区域
+            const analysisMat = grayMat;
+            // 确保图像是浮点类型用于FFT
+            const floatMat = new cv.Mat();
+            analysisMat.convertTo(floatMat, cv.CV_32F);
+            // 创建复数矩阵用于FFT
+            const planes = new cv.MatVector();
+            const zeros = cv.Mat.zeros(floatMat.rows, floatMat.cols, cv.CV_32F);
+            planes.push_back(floatMat);
+            planes.push_back(zeros);
+            // 执行2D FFT
+            const complexI = new cv.Mat();
+            cv.merge(planes, complexI);
+            cv.dft(complexI, complexI, cv.DFT_COMPLEX_OUTPUT);
+            // 计算幅度谱
+            const mag = new cv.Mat();
+            const planesVec = new cv.MatVector();
+            cv.split(complexI, planesVec);
+            const real = planesVec.get(0);
+            const imag = planesVec.get(1);
+            // 计算幅度: sqrt(real^2 + imag^2)
+            cv.magnitude(real, imag, mag);
+            // 转换为对数尺度以便可视化
+            const matShift = new cv.Mat();
+            mag.convertTo(matShift, cv.CV_32F);
+            // 对数变换
+            cv.add(cv.Mat.ones(mag.rows, mag.cols, cv.CV_32F), matShift, matShift);
+            cv.log(matShift, matShift);
+            // 重新排列四象限，使零频率分量位于中心
+            const cx = Math.floor(matShift.cols / 2);
+            const cy = Math.floor(matShift.rows / 2);
+            const q0 = matShift.roi(new cv.Rect(0, 0, cx, cy));
+            const q1 = matShift.roi(new cv.Rect(cx, 0, cx, cy));
+            const q2 = matShift.roi(new cv.Rect(0, cy, cx, cy));
+            const q3 = matShift.roi(new cv.Rect(cx, cy, cx, cy));
+            const tmp = new cv.Mat();
+            q0.copyTo(tmp);
+            q3.copyTo(q0);
+            tmp.copyTo(q3);
+            q1.copyTo(tmp);
+            q2.copyTo(q1);
+            tmp.copyTo(q2);
+            // 专门检测摩尔纹特征
+            // 屏幕像素网格在频域中产生同心圆状的规律性模式
+            const moireScore = this.analyzeMoireCharacteristics(matShift);
+            const pixelGridStrength = this.calculatePixelGridStrength(matShift);
+            // 综合分析摩尔纹特征
+            let finalScore = 0;
+            let patternStrength = 0;
+            // 基于同心圆模式的分析
+            if (moireScore > 0.3) {
+                finalScore += moireScore * 0.6;
+            }
+            // 基于像素网格强度的分析
+            if (pixelGridStrength > 0.4) {
+                finalScore += pixelGridStrength * 0.4;
+            }
+            // 检查是否有清晰的周期性峰值
+            const peaks = this.findMoirePeaks(matShift);
+            const peakCount = peaks.length;
+            if (peakCount > 15) { // 高峰值数量表明存在明显的摩尔纹
+                finalScore += Math.min(0.3, peakCount / 100);
+            }
+            patternStrength = Math.max(moireScore, pixelGridStrength);
+            // 限制分数范围
+            finalScore = Math.min(1, Math.max(0, finalScore));
+            // 计算置信度
+            const confidence = finalScore * this.config.pixelGridSensitivity;
+            debugInfo = {
+                moireScore,
+                pixelGridStrength,
+                peakCount,
+                patternStrength,
+                rawScore: finalScore
+            };
+            // 释放内存
+            floatMat.delete();
+            complexI.delete();
+            mag.delete();
+            matShift.delete();
+            planes.delete();
+            zeros.delete();
+            planesVec.delete();
+            real.delete();
+            imag.delete();
+            tmp.delete();
+            return {
+                score: finalScore,
+                pixelGridStrength,
+                confidence,
+                debug: debugInfo
+            };
+        }
+        catch (error) {
+            this.emitDebug('screen-attack-moire', `摩尔纹分析出错: ${error}`, {}, 'error');
+            return { score: 0, pixelGridStrength: 0, confidence: 0, debug: {} };
+        }
+    }
+    /**
+     * 分析频域中的摩尔纹特征
+     */
+    analyzeMoireCharacteristics(spectrum) {
+        this.opencv;
+        const centerX = Math.floor(spectrum.cols / 2);
+        const centerY = Math.floor(spectrum.rows / 2);
+        // 计算径向剖面图以检测同心圆模式
+        const radialProfile = this.computeRadialProfile(spectrum, centerX, centerY);
+        // 检查径向剖面的规律性（同心圆特征）
+        let regularityScore = 0;
+        Math.max(1, Math.floor(radialProfile.length / 10));
+        // 计算径向剖面的自相关性来检测规律性
+        const autoCorrelation = this.calculateAutoCorrelation(radialProfile);
+        // 寻找主要的周期性模式
+        let maxPeak = 0;
+        for (let i = 1; i < autoCorrelation.length / 4; i++) {
+            if (autoCorrelation[i] > maxPeak) {
+                maxPeak = autoCorrelation[i];
+            }
+        }
+        // 根据最大峰值确定摩尔纹特征强度
+        regularityScore = Math.min(1, maxPeak / 10.0); // 归一化
+        return regularityScore;
+    }
+    /**
+     * 计算像素网格强度
+     */
+    calculatePixelGridStrength(spectrum) {
+        const cv = this.opencv;
+        // 创建用于存储均值和标准差的标量
+        const mean = new cv.Mat();
+        const stddev = new cv.Mat();
+        // 计算频谱的均值和标准差
+        cv.meanStdDev(spectrum, mean, stddev);
+        // 获取标准差的值
+        let spectrumStdDev = 0;
+        if (stddev.data64F && stddev.data64F.length > 0) {
+            spectrumStdDev = stddev.data64F[0];
+        }
+        else if (stddev.data32F && stddev.data32F.length > 0) {
+            spectrumStdDev = stddev.data32F[0];
+        }
+        else {
+            // 如果无法获取数据，则手动计算
+            let sum = 0;
+            let sumSq = 0;
+            const data = spectrum.data32F || spectrum.data64F;
+            if (data) {
+                for (let i = 0; i < data.length; i++) {
+                    sum += data[i];
+                    sumSq += data[i] * data[i];
+                }
+                const meanVal = sum / data.length;
+                const variance = (sumSq / data.length) - (meanVal * meanVal);
+                spectrumStdDev = Math.sqrt(variance);
+            }
+        }
+        // 释放内存
+        mean.delete();
+        stddev.delete();
+        // 归一化标准差到0-1范围
+        const normalizedStdDev = Math.min(1, spectrumStdDev / 5.0);
+        return normalizedStdDev;
+    }
+    /**
+     * 查找频域中的摩尔纹峰值
+     */
+    findMoirePeaks(spectrum) {
+        const cv = this.opencv;
+        const peaks = [];
+        // 使用局部最大值检测
+        const kernel = cv.Mat.ones(3, 3, cv.CV_8UC1);
+        // 膨胀操作以找到局部最大值
+        const dilated = new cv.Mat();
+        cv.dilate(spectrum, dilated, kernel);
+        // 比较原图和膨胀后的图，相等的位置即为局部最大值
+        const localMaxMask = new cv.Mat();
+        cv.compare(spectrum, dilated, localMaxMask, cv.CMP_EQ);
+        // 查找非零点（即峰值位置）
+        for (let y = 1; y < spectrum.rows - 1; y++) {
+            for (let x = 1; x < spectrum.cols - 1; x++) {
+                const maskIndex = y * localMaxMask.cols + x;
+                // 使用正确的数组访问方式
+                if (localMaxMask.data[maskIndex] !== 0) {
+                    const spectrumIndex = y * spectrum.cols + x;
+                    const val = spectrum.data32F ? spectrum.data32F[spectrumIndex] : 0;
+                    // 只保留显著的峰值
+                    if (val > 3.0) { // 阈值可根据实际调试调整
+                        peaks.push({ x, y, value: val });
+                    }
+                }
+            }
+        }
+        // 释放内存
+        kernel.delete();
+        dilated.delete();
+        localMaxMask.delete();
+        return peaks;
+    }
+    /**
+     * 计算径向剖面图
+     */
+    computeRadialProfile(spectrum, centerX, centerY) {
+        this.opencv;
+        const profile = [];
+        const maxRadius = Math.min(centerX, centerY);
+        for (let r = 0; r < maxRadius; r++) {
+            let sum = 0;
+            let count = 0;
+            for (let angle = 0; angle < 360; angle += 5) { // 每5度采样一次
+                const rad = angle * Math.PI / 180;
+                const x = Math.round(centerX + r * Math.cos(rad));
+                const y = Math.round(centerY + r * Math.sin(rad));
+                if (x >= 0 && x < spectrum.cols && y >= 0 && y < spectrum.rows) {
+                    const index = y * spectrum.cols + x;
+                    if (spectrum.data32F && index < spectrum.data32F.length) {
+                        const value = spectrum.data32F[index];
+                        sum += value;
+                        count++;
+                    }
+                }
+            }
+            profile.push(count > 0 ? sum / count : 0);
+        }
+        return profile;
+    }
+    /**
+     * 计算数组的自相关
+     */
+    calculateAutoCorrelation(data) {
+        const n = data.length;
+        const result = new Array(n).fill(0);
+        for (let lag = 0; lag < n; lag++) {
+            let sum = 0;
+            for (let i = 0; i < n - lag; i++) {
+                sum += data[i] * data[i + lag];
+            }
+            result[lag] = sum / (n - lag);
+        }
+        return result;
+    }
+    /**
+     * 重置检测器
+     */
+    reset() {
+        this.frameCount = 0;
     }
 }
 
@@ -2380,7 +2655,9 @@ class DetectionState {
     lastFrontalScore = 1;
     faceMovingDetector = null;
     photoAttackDetector = null;
+    screenAttachDetector = null;
     liveness = false;
+    realness = false;
     constructor(options) {
         Object.assign(this, options);
     }
@@ -2388,11 +2665,17 @@ class DetectionState {
         this.clearActionVerifyTimeout();
         const savedFaceMovingDetector = this.faceMovingDetector;
         const savedPhotoAttackDetector = this.photoAttackDetector;
+        const savedScreenAttackDetector = this.screenAttachDetector;
         savedFaceMovingDetector?.reset();
         savedPhotoAttackDetector?.reset();
+        savedScreenAttackDetector?.reset();
         Object.assign(this, new DetectionState({}));
         this.faceMovingDetector = savedFaceMovingDetector;
         this.photoAttackDetector = savedPhotoAttackDetector;
+        this.screenAttachDetector = savedScreenAttackDetector;
+    }
+    setOpenCv(opencv) {
+        this.screenAttachDetector?.setOpencv(opencv);
     }
     // 默认方法
     needFrontalFace() {
@@ -2401,7 +2684,7 @@ class DetectionState {
     // 是否准备好进行动作验证
     isReadyToVerify(minCollectCount) {
         if (this.period === DetectionPeriod.COLLECT
-            && this.liveness
+            && this.liveness && this.realness
             && this.collectCount >= minCollectCount) {
             return true;
         }
@@ -2437,8 +2720,11 @@ function createDetectionState(engine) {
     const detectionState = new DetectionState({});
     detectionState.faceMovingDetector = new FaceMovingDetector();
     detectionState.faceMovingDetector.setEmitDebug(engine.emitDebug.bind(engine));
+    // 禁用深度分析，实测深度分析不准确
     detectionState.photoAttackDetector = new PhotoAttackDetector();
     detectionState.photoAttackDetector.setEmitDebug(engine.emitDebug.bind(engine));
+    detectionState.screenAttachDetector = new ScreenAttackDetector();
+    detectionState.screenAttachDetector.setEmitDebug(engine.emitDebug.bind(engine));
     return detectionState;
 }
 
@@ -2950,6 +3236,7 @@ class FaceDetectionEngine extends SimpleEventEmitter {
             if (!this.transitionEngineState(EngineState.DETECTING, 'startDetection() video ready')) {
                 throw new Error('Failed to transition to DETECTING state');
             }
+            this.detectionState.setOpenCv(this.cv);
             this.cancelPendingDetection();
             this.animationFrameId = requestAnimationFrame(() => {
                 this.detect();
@@ -3282,6 +3569,16 @@ class FaceDetectionEngine extends SimpleEventEmitter {
             this.stopDetection(false);
             return;
         }
+        if (!this.detectionState.screenAttachDetector) {
+            this.emit('detector-error', {
+                code: ErrorCode.INTERNAL_ERROR,
+                message: 'Screen attack detector is not initialized'
+            });
+            // Clear the detecting flag before stopping to avoid deadlock
+            this.isDetectingFrameActive = false;
+            this.stopDetection(false);
+            return;
+        }
         try {
             // 动作活体检测阶段处理
             if (this.detectionState.period === DetectionPeriod.VERIFY) {
@@ -3302,55 +3599,51 @@ class FaceDetectionEngine extends SimpleEventEmitter {
                 this.emitDebug('detection', 'Face is too large', { ratio: faceRatio.toFixed(4), minRatio: this.options.collect_min_face_ratio, maxRatio: this.options.collect_max_face_ratio }, 'info');
                 return;
             }
-            this.detectionState.faceMovingDetector.addFrame(face, timestamp);
-            if (!this.detectionState.faceMovingDetector.isAvailable()) {
-                // 面部移动数据尚不可用，等待更多帧
-                this.emitDebug('motion-detection', 'Face moving data not yet available - collecting more frames', {
-                    collectedFrames: this.detectionState.faceMovingDetector.getFrameCount()
-                }, 'info');
-                return;
-            }
-            // const faceMovingResult = this.detectionState.faceMovingDetector.detect()
-            // if(!faceMovingResult.isMoving){
-            //   // 面部移动检测失败，可能为照片攻击
-            //   this.emitDebug('motion-detection', 'Face moving detection failed - possible photo attack', {
-            //     details: faceMovingResult.details,
-            //     debug: faceMovingResult.debug
-            //   }, 'warn')
-            //   this.emitDetectorInfo({
-            //     code: DetectionCode.PLEASE_MOVING_FACE,
-            //     message: '请动一动您的脸部',
-            //   })
-            //   this.partialResetDetectionState()
-            //   return
-            // }
-            this.detectionState.photoAttackDetector.addFrame(face);
-            const photoAttackResult = this.detectionState.photoAttackDetector.detect();
-            if (photoAttackResult.isAvailable()) {
-                // 照片攻击检测可用（仅当判定为照片攻击时)
-                if (photoAttackResult.isPhoto) {
-                    this.emitDetectorInfo({
-                        code: DetectionCode.PHOTO_ATTACK_DETECTED,
-                        message: photoAttackResult.getMessage(),
-                    });
-                    this.emitDebug('motion-detection', 'Photo attack detected', {
-                        details: photoAttackResult.details,
-                        debug: photoAttackResult.debug,
-                    }, 'warn');
-                    this.partialResetDetectionState();
-                    return;
+            // 开启面部移动检测
+            if (this.options.enable_face_moving_detection) {
+                this.detectionState.faceMovingDetector.addFrame(face, timestamp);
+                const faceMovingResult = this.detectionState.faceMovingDetector.detect();
+                if (faceMovingResult.available) {
+                    if (!faceMovingResult.isMoving) {
+                        // 面部移动检测失败，可能为照片攻击
+                        this.emitDebug('motion-detection', 'Face moving detection failed - possible photo attack', faceMovingResult.details, 'warn');
+                        this.emitDetectorInfo({
+                            code: DetectionCode.FACE_NOT_MOVING,
+                            message: faceMovingResult.getMessage(),
+                        });
+                        this.partialResetDetectionState();
+                        return;
+                    }
                 }
-                else {
-                    if (photoAttackResult.isTrusted()) {
-                        // 仅当采集到足够帧，且判定为非照片攻击时，才采信
-                        this.detectionState.liveness = true;
-                        this.emitDebug('motion-detection', 'Photo attack detection passed - face is live', {
-                            debug: photoAttackResult.debug,
-                            details: photoAttackResult.details,
-                        }, 'warn');
+            }
+            // 开启照片攻击检测
+            if (this.options.enable_photo_attack_detection) {
+                this.detectionState.photoAttackDetector.addFrame(face);
+                const photoAttackResult = this.detectionState.photoAttackDetector.detect();
+                if (photoAttackResult.available) {
+                    // 照片攻击检测可用（仅当判定为照片攻击时)
+                    if (photoAttackResult.isPhoto) {
+                        this.emitDetectorInfo({
+                            code: DetectionCode.PHOTO_ATTACK_DETECTED,
+                            message: photoAttackResult.getMessage(),
+                        });
+                        this.emitDebug('motion-detection', 'Photo attack detected', photoAttackResult.details, 'warn');
+                        this.partialResetDetectionState();
+                        return;
+                    }
+                    else {
+                        if (photoAttackResult.trusted) {
+                            // 仅当采集到足够帧，且判定为非照片攻击时，才采信
+                            this.detectionState.liveness = true;
+                            this.emitDebug('motion-detection', 'Photo attack detection passed - face is live', photoAttackResult.details, 'warn');
+                        }
                     }
                 }
             }
+            else {
+                // 未启用照片攻击检测，默认活体为活体
+                this.detectionState.liveness = true;
+            }
             // 捕获并准备帧数据
             const frameData = this.captureAndPrepareFrames();
             if (!frameData) {
@@ -3361,6 +3654,31 @@ class FaceDetectionEngine extends SimpleEventEmitter {
             }
             const bgrFrame = frameData.bgrFrame;
             const grayFrame = frameData.grayFrame;
+            if (this.options.enable_screen_attack_detection) {
+                const screenAttackResult = this.detectionState.screenAttachDetector.detect(bgrFrame, grayFrame);
+                if (screenAttackResult.available) {
+                    if (screenAttackResult.isScreenAttack) {
+                        this.emitDetectorInfo({
+                            code: DetectionCode.SCREEN_ATTACK_DETECTED,
+                            message: screenAttackResult.getMessage(),
+                        });
+                        this.emitDebug('motion-detection', 'Screen attack detected', screenAttackResult.details, 'warn');
+                        this.partialResetDetectionState();
+                        return;
+                    }
+                    else {
+                        if (screenAttackResult.trusted) {
+                            // 仅当采集到足够帧，且判定为非屏幕攻击时，才采信
+                            this.detectionState.realness = true;
+                            this.emitDebug('motion-detection', 'Screen attack detection passed - face is real', screenAttackResult.details, 'warn');
+                        }
+                    }
+                }
+            }
+            else {
+                // 未启用屏幕攻击检测，默认真实性为真实
+                this.detectionState.realness = true;
+            }
             let frontal = 1;
             // 计算面部正对度，不达标则跳过当前帧
             if (this.detectionState.needFrontalFace()) {