@sssxyd/face-liveness-detector 0.4.2-alpha.2 → 0.4.3-alpha.1

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,
@@ -1562,11 +1565,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 = true, trusted = false) {
         this.isMoving = isMoving;
         this.details = details;
-        this.debug = debug;
+        this.available = available;
+        this.trusted = trusted;
     }
     getMessage() {
         if (this.details.frameCount < 2) {
@@ -1682,7 +1687,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, true);
     }
     /**
      * 计算两帧之间的运动强度
@@ -1840,17 +1845,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;
-    }
     /**
      * 重置检测器
      */
@@ -1903,17 +1897,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) {
@@ -1928,9 +1918,9 @@ class PhotoAttackDetectionResult {
             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,8 +1928,9 @@ 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
+    requiredFrameCount: 15, // 可信赖所需的最小帧数
+    depthVarianceThreshold: 0.003, // 深度方差阈值：真实人脸 > 0.005，照片 < 0.001
+    motionVarianceThreshold: 0.015, // 运动方差阈值：真实人脸 > 0.02，照片 < 0.01
     perspectiveRatioThreshold: 0.85, // 透视比率阈值：真实人脸 > 0.95，照片 < 0.85
     motionConsistencyThreshold: 0.8, // 运动一致性阈值：真实人脸 < 0.5，照片 > 0.8
 };
@@ -2033,7 +2024,7 @@ class PhotoAttackDetector {
         else {
             details.dominantFeature = 'perspective';
         }
-        return new PhotoAttackDetectionResult(details.isPhoto, details);
+        return new PhotoAttackDetectionResult(details.isPhoto, details, true, this.frameBuffer.length >= this.config.requiredFrameCount);
     }
     /**
      * 方案一：3D 深度方差分析
@@ -2356,11 +2347,382 @@ 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.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 meanStddev = { mean: new cv.Scalar(), stddev: new cv.Scalar() };
+        cv.meanStdDev(spectrum, meanStddev.mean, meanStddev.stddev);
+        const spectrumStdDev = meanStddev.stddev.data64F[0];
+        // 归一化标准差到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++) {
+                if (localMaxMask.ucharPtr(y, x)[0] !== 0) {
+                    try {
+                        // 使用floatPtr访问浮点值
+                        const ptrValue = spectrum.floatPtr(y, x);
+                        if (ptrValue && ptrValue.length > 0) {
+                            const val = ptrValue[0];
+                            // 只保留显著的峰值
+                            if (val > 3.0) { // 阈值可根据实际调试调整
+                                peaks.push({ x, y, value: val });
+                            }
+                        }
+                    }
+                    catch (e) {
+                        // fallback to other method
+                        try {
+                            const val = spectrum.data32F[y * spectrum.cols + x];
+                            if (val > 3.0) {
+                                peaks.push({ x, y, value: val });
+                            }
+                        }
+                        catch (e2) {
+                            console.warn("Could not access pixel value at", x, y);
+                        }
+                    }
+                }
+            }
+        }
+        // 释放内存
+        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) {
+                    try {
+                        const value = spectrum.floatPtr(y, x)[0];
+                        sum += value;
+                        count++;
+                    }
+                    catch (e) {
+                        try {
+                            const value = spectrum.data32F[y * spectrum.cols + x];
+                            sum += value;
+                            count++;
+                        }
+                        catch (e2) {
+                            // 忽略错误
+                        }
+                    }
+                }
+            }
+            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 +2742,9 @@ class DetectionState {
     lastFrontalScore = 1;
     faceMovingDetector = null;
     photoAttackDetector = null;
+    screenAttachDetector = null;
     liveness = false;
+    realness = false;
     constructor(options) {
         Object.assign(this, options);
     }
@@ -2388,11 +2752,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 +2771,7 @@ class DetectionState {
     // 是否准备好进行动作验证
     isReadyToVerify(minCollectCount) {
         if (this.period === DetectionPeriod.COLLECT
-            && this.liveness
+            && this.liveness && this.realness
             && this.collectCount >= minCollectCount) {
             return true;
         }
@@ -2439,6 +2809,9 @@ function createDetectionState(engine) {
     detectionState.faceMovingDetector.setEmitDebug(engine.emitDebug.bind(engine));
     detectionState.photoAttackDetector = new PhotoAttackDetector();
     detectionState.photoAttackDetector.setEmitDebug(engine.emitDebug.bind(engine));
+    detectionState.screenAttachDetector = new ScreenAttackDetector();
+    detectionState.screenAttachDetector.setOpencv(cv);
+    detectionState.screenAttachDetector.setEmitDebug(engine.emitDebug.bind(engine));
     return detectionState;
 }
 
@@ -2552,6 +2925,7 @@ class FaceDetectionEngine extends SimpleEventEmitter {
         }
         this.options = mergeOptions(options);
         this.detectionState = createDetectionState(this);
+        this.detectionState.setOpenCv(this.cv);
         this.emitDebug('config', 'Engine options updated', { wasDetecting }, 'info');
     }
     getEngineState() {
@@ -2790,6 +3164,7 @@ class FaceDetectionEngine extends SimpleEventEmitter {
             if (!this.transitionEngineState(EngineState.READY, 'initialize() success')) {
                 throw new Error('Failed to transition to READY state');
             }
+            this.detectionState.setOpenCv(this.cv);
             const loadedData = {
                 success: true,
                 opencv_version: getOpenCVVersion(),
@@ -3282,6 +3657,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 +3687,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 +3742,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()) {