@sssxyd/face-liveness-detector 0.4.0 → 0.4.1-beta.1

package/dist/index.js

@@ -93,7 +93,7 @@
     /**
      * Default configuration for FaceDetectionEngine
      */
-    const DEFAULT_OPTIONS = {
+    const DEFAULT_OPTIONS$1 = {
         // Resource paths
         human_model_path: undefined,
         tensorflow_wasm_path: undefined,
@@ -107,7 +107,6 @@
         detect_video_ideal_height: 720,
         detect_video_mirror: true,
         detect_video_load_timeout: 5000,
-        detect_frame_delay: 120,
         // Collection Settings
         collect_min_collect_count: 3,
         collect_min_face_ratio: 0.5,
@@ -131,8 +130,6 @@
         action_liveness_action_randomize: true,
         action_liveness_verify_timeout: 60000,
         action_liveness_min_mouth_open_percent: 0.2,
-        // Motion Liveness Settings
-        motion_liveness_strict_photo_detection: false,
     };
     /**
      * Merge user configuration with defaults
@@ -142,7 +139,7 @@
      */
     function mergeOptions(userConfig) {
         // Start with deep clone of defaults
-        const merged = structuredClone(DEFAULT_OPTIONS);
+        const merged = structuredClone(DEFAULT_OPTIONS$1);
         if (!userConfig) {
             return merged;
         }
@@ -1564,2872 +1561,1496 @@
     }
 
     /**
-     * 运动和活体检测 - 防止照片攻击
-     * 检测微妙的面部运动和运动模式，以区分真实面孔和高质量照片
+     * 活体检测器 - 微妙运动检测版本 + 照片几何特征检测
+     *
+     * 双重检测策略：
+     * 1. 正向检测：检测生物特征（微妙眨眼、细微张嘴、面部肌肉微动）
+     * 2. 逆向检测：检测照片几何特征（平面约束、透视变换规律、交叉比率）
+     *
+     * ⚠️ 关键理解 ⚠️
+     * MediaPipe 返回的 Z 坐标（深度）是从2D图像【推断】出来的，不是真实的物理深度！
+     * - 对真实人脸：推断出正确的 3D 结构
+     * - 对照片人脸：也可能推断出"假"的 3D 结构（因为照片上的人脸看起来也像 3D 的）
+     *
+     * 因此，检测策略优先级：
+     * 1. 【最可靠】2D 几何约束检测（单应性、交叉比率、透视变换规律）——物理定律，无法欺骗
+     * 2. 【次可靠】生物特征时序检测（眨眼时间、对称性）——行为模式
+     * 3. 【辅助参考】Z 坐标分析——可能被欺骗，仅作辅助
      */
     /**
-     * 运动检测结果
+     * 活体检测结果
      */
     class MotionDetectionResult {
-        // 总体运动评分 (0-1)
-        motionScore;
-        // 人脸区域的光流幅度
-        opticalFlowMagnitude;
-        // 关键点稳定性评分 (0 = 像照片一样稳定, 1 = 自然运动)
-        keypointVariance;
-        // 眼睛区域运动强度
-        eyeMotionScore;
-        // 嘴巴区域运动强度
-        mouthMotionScore;
-        // 检测到的运动类型 ('none' | 'rotation' | 'translation' | 'breathing' | 'micro_expression')
-        motionType;
-        // 基于运动的总体活体性判断
+        // 是否为活体
         isLively;
-        // 详细调试信息
         details;
-        constructor(motionScore, opticalFlowMagnitude, keypointVariance, eyeMotionScore, mouthMotionScore, motionType, isLively, details) {
-            this.motionScore = motionScore;
-            this.opticalFlowMagnitude = opticalFlowMagnitude;
-            this.keypointVariance = keypointVariance;
-            this.eyeMotionScore = eyeMotionScore;
-            this.mouthMotionScore = mouthMotionScore;
-            this.motionType = motionType;
+        constructor(isLively, details) {
             this.isLively = isLively;
             this.details = details;
         }
-        /**
-         * 获取活体检测结果信息
-         * 如果活跃，返回空字符串，否则返回非活体检测的原因
-         */
-        getMessage(minMotionScore, minKeypointVariance) {
-            if (this.isLively) {
-                return '';
-            }
-            const reasons = [];
-            // 检查运动评分
-            if (this.motionScore < minMotionScore) {
-                reasons.push(`检测到的运动不足 (运动评分: ${(this.motionScore * 100).toFixed(1)}%)`);
-            }
-            // 检查关键点方差
-            if (this.keypointVariance < minKeypointVariance) {
-                reasons.push(`关键点方差低 (${(this.keypointVariance * 100).toFixed(1)}%)，表示面孔静止或类似照片`);
-            }
-            // 检查运动类型
-            if (this.motionType === 'none') {
-                reasons.push('未检测到运动，面孔似乎是静止的或来自照片');
-            }
-            // 如果没有找到具体原因但仍然不活跃，提供通用信息
-            if (reasons.length === 0) {
-                reasons.push('Face does not meet liveness requirements');
+        getMessage() {
+            if (this.details.frameCount < 5) {
+                return '数据不足，无法进行活体检测';
             }
-            return reasons.join('; ');
+            if (this.isLively)
+                return '';
+            // 正向检测信息
+            const eyePercent = (this.details.eyeFluctuation * 100).toFixed(0);
+            const mouthPercent = (this.details.mouthFluctuation * 100).toFixed(0);
+            const musclePercent = (this.details.muscleVariation * 100).toFixed(0);
+            const bioFeatures = `未检测到面部微动（眼睛: ${eyePercent}%, 嘴巴: ${mouthPercent}%, 肌肉: ${musclePercent}%）`;
+            // 逆向检测信息
+            if (this.details.isPhoto) {
+                const confidence = ((this.details.photoConfidence || 0) * 100).toFixed(0);
+                const reasons = [];
+                if ((this.details.homographyScore || 0) > 0.5)
+                    reasons.push('单应性约束');
+                if ((this.details.perspectiveScore || 0) > 0.5)
+                    reasons.push('透视规律');
+                if ((this.details.crossRatioScore || 0) > 0.5)
+                    reasons.push('交叉比率');
+                const reasonStr = reasons.length > 0 ? `（${reasons.join('、')}）` : '';
+                return `检测到照片特征${reasonStr}，置信度${confidence}%`;
+            }
+            return bioFeatures;
         }
     }
-    const DEFAULT_MOTION_LIVENESS_DETECTOR_OPTIONS = {
-        minMotionThreshold: 0.15,
-        minKeypointVariance: 0.02,
-        frameBufferSize: 5,
-        eyeAspectRatioThreshold: 0.15,
-        motionConsistencyThreshold: 0.5,
-        minOpticalFlowThreshold: 0.08,
-        strictPhotoDetection: false
+    const DEFAULT_OPTIONS = {
+        frameBufferSize: 15, // 15帧 (0.5秒@30fps)
+        eyeMinFluctuation: 0.008, // 非常低的眨眼阈值（检测微妙变化）
+        mouthMinFluctuation: 0.005, // 非常低的张嘴阈值
+        muscleMinVariation: 0.002, // 非常低的肌肉变化阈值
+        activityThreshold: 0.2 // 只需要有 20% 的活动迹象就判定为活体
     };
     /**
-     * 运动活体检测器
-     * 使用光流、关键点跟踪和面部特征分析
+     * 活体检测器 - 超敏感微动作版本 + 照片几何特征检测
+     *
+     * 双重策略：
+     * 1. 检测生物微动（正向）
+     * 2. 检测照片几何约束（逆向）- 更可靠
      */
     class MotionLivenessDetector {
-        // 配置及默认值
         config;
-        // 状态
-        frameBuffer = []; // 存储灰度帧数据
-        frameWidth = 0;
-        frameHeight = 0;
-        keypointHistory = [];
-        faceAreaHistory = [];
         eyeAspectRatioHistory = [];
         mouthAspectRatioHistory = [];
-        opticalFlowHistory = [];
-        pupilSizeHistory = [];
-        // OpenCV 实例
-        cv = null;
-        constructor(strictPhotoDetection = false) {
-            this.config = {
-                ...DEFAULT_MOTION_LIVENESS_DETECTOR_OPTIONS,
-                strictPhotoDetection
-            };
-        }
-        setCVInstance(cvInstance) {
-            this.cv = cvInstance;
+        faceLandmarksHistory = []; // 原始坐标（用于Z坐标分析）
+        normalizedLandmarksHistory = []; // 【关键】归一化坐标（用于几何约束检测）
+        // 用于检测透视畸变攻击
+        leftEyeEARHistory = [];
+        rightEyeEARHistory = [];
+        frameTimestamps = [];
+        rigidMotionHistory = [];
+        // 【新增】用于照片几何特征检测
+        homographyErrors = []; // 单应性变换误差历史
+        depthConsistencyScores = []; // 深度一致性得分历史
+        planarityScores = []; // 平面性得分历史
+        constructor() {
+            this.config = { ...DEFAULT_OPTIONS };
         }
         getOptions() {
             return this.config;
         }
         isReady() {
-            return this.frameBuffer.length >= this.config.frameBufferSize;
+            return this.eyeAspectRatioHistory.length >= 5; // 只需要5帧就能检测
         }
-        /**
-         * 重置运动检测状态
-         */
         reset() {
-            this.frameBuffer = [];
-            this.frameWidth = 0;
-            this.frameHeight = 0;
-            this.keypointHistory = [];
-            this.faceAreaHistory = [];
             this.eyeAspectRatioHistory = [];
             this.mouthAspectRatioHistory = [];
-            this.opticalFlowHistory = [];
-            this.pupilSizeHistory = [];
+            this.faceLandmarksHistory = [];
+            this.normalizedLandmarksHistory = []; // 【关键】归一化坐标
+            this.leftEyeEARHistory = [];
+            this.rightEyeEARHistory = [];
+            this.frameTimestamps = [];
+            this.rigidMotionHistory = [];
+            this.homographyErrors = [];
+            this.depthConsistencyScores = [];
+            this.planarityScores = [];
         }
-        /**
-         * 从当前帧和历史记录分析运动和活体性
-         */
-        analyzeMotion(grayMat, faceResult, faceBox) {
+        analyzeMotion(faceResult, faceBox) {
             try {
-                // 将当前帧添加到缓冲区
-                this.addFrameToBuffer(grayMat);
-                // 从当前面孔提取关键点
                 const currentKeypoints = this.extractKeypoints(faceResult);
-                this.keypointHistory.push(currentKeypoints);
-                if (this.keypointHistory.length > this.config.frameBufferSize) {
-                    this.keypointHistory.shift();
-                }
-                // 计算人脸区域
-                const faceArea = faceBox[2] * faceBox[3];
-                this.faceAreaHistory.push(faceArea);
-                if (this.faceAreaHistory.length > this.config.frameBufferSize) {
-                    this.faceAreaHistory.shift();
-                }
-                // 计算眼睛和嘴巴的宽高比
-                if (currentKeypoints.leftEye && currentKeypoints.rightEye) {
-                    const leftEAR = this.calculateEyeAspectRatio(currentKeypoints.leftEye);
-                    const rightEAR = this.calculateEyeAspectRatio(currentKeypoints.rightEye);
-                    const avgEAR = (leftEAR + rightEAR) / 2;
-                    this.eyeAspectRatioHistory.push(avgEAR);
-                    if (this.eyeAspectRatioHistory.length > this.config.frameBufferSize) {
-                        this.eyeAspectRatioHistory.shift();
+                // 保存完整网格（原始坐标用于Z坐标分析）
+                if (currentKeypoints.landmarks) {
+                    this.faceLandmarksHistory.push(currentKeypoints.landmarks);
+                    if (this.faceLandmarksHistory.length > this.config.frameBufferSize) {
+                        this.faceLandmarksHistory.shift();
                     }
-                }
-                if (currentKeypoints.mouth) {
-                    const MAR = this.calculateMouthAspectRatio(currentKeypoints.mouth);
-                    this.mouthAspectRatioHistory.push(MAR);
-                    if (this.mouthAspectRatioHistory.length > this.config.frameBufferSize) {
-                        this.mouthAspectRatioHistory.shift();
+                    // 【关键】保存归一化坐标用于几何约束检测
+                    // 归一化到人脸局部坐标系，消除人脸移动的影响
+                    const normalizedLandmarks = this.normalizeLandmarks(currentKeypoints.landmarks, faceBox);
+                    this.normalizedLandmarksHistory.push(normalizedLandmarks);
+                    if (this.normalizedLandmarksHistory.length > this.config.frameBufferSize) {
+                        this.normalizedLandmarksHistory.shift();
                     }
                 }
-                // 需要至少 2 帧进行运动分析
-                if (this.frameBuffer.length < 2) {
-                    return this.createEmptyResult();
-                }
-                // 分析光流
-                const opticalFlowResult = this.analyzeOpticalFlow();
-                this.opticalFlowHistory.push(opticalFlowResult);
-                if (this.opticalFlowHistory.length > this.config.frameBufferSize) {
-                    this.opticalFlowHistory.shift();
-                }
-                // 检测瞳孔反应（简单实现）
-                const pupilResponse = this.detectPupilResponse(currentKeypoints);
-                if (pupilResponse > 0) {
-                    this.pupilSizeHistory.push(pupilResponse);
-                    if (this.pupilSizeHistory.length > this.config.frameBufferSize) {
-                        this.pupilSizeHistory.shift();
-                    }
+                // 数据不足时，继续收集
+                if (this.eyeAspectRatioHistory.length < 5) {
+                    return new MotionDetectionResult(true, {
+                        frameCount: Math.max(this.eyeAspectRatioHistory.length, this.mouthAspectRatioHistory.length)
+                    });
                 }
-                // 分析关键点稳定性
-                const keypointVariance = this.calculateKeypointVariance();
-                // 分析眼睛和嘴巴运动
-                const eyeMotionScore = this.calculateEyeMotionScore();
-                const mouthMotionScore = this.calculateMouthMotionScore();
-                const faceAreaVariance = this.calculateFaceAreaVariance();
-                // 验证运动一致性（防止照片微动攻击）
-                const motionConsistency = this.validateMotionConsistency(opticalFlowResult, keypointVariance);
-                // 检测运动类型
-                const motionType = this.detectMotionType(opticalFlowResult, keypointVariance);
-                // 计算总体运动评分（调整权重以应对照片攻击）
-                const motionScore = this.calculateOverallMotionScore(opticalFlowResult, keypointVariance, eyeMotionScore, mouthMotionScore, motionConsistency);
-                // 计算人脸区域变化率（用于检测呼吸）
-                const faceAreaChangeRate = this.calculateFaceAreaChangeRate();
-                // 确定活体性（加入额外检查）
-                const isLively = this.determineLiveness(keypointVariance, motionType, opticalFlowResult, eyeMotionScore, mouthMotionScore, faceAreaChangeRate);
-                return new MotionDetectionResult(motionScore, opticalFlowResult, keypointVariance, eyeMotionScore, mouthMotionScore, motionType, isLively, {
-                    frameCount: this.frameBuffer.length,
-                    avgKeypointDistance: this.calculateAvgKeypointDistance(),
-                    maxKeypointDistance: this.calculateMaxKeypointDistance(),
-                    faceAreaVariance,
-                    eyeAspectRatioVariance: this.calculateVariance(this.eyeAspectRatioHistory),
-                    mouthAspectRatioVariance: this.calculateVariance(this.mouthAspectRatioHistory)
+                // 【检测1】眼睛微妙波动 - 任何EAR变化都是活体
+                const eyeActivity = this.detectEyeFluctuation(currentKeypoints);
+                // 【检测2】嘴巴微妙波动 - 任何MAR变化都是活体
+                const mouthActivity = this.detectMouthFluctuation(currentKeypoints);
+                // 【检测3】面部肌肉微动 - 任何细微位置变化都是活体
+                const muscleActivity = this.detectMuscleMovement();
+                // 【新增检测4】照片几何特征检测（逆向检测）
+                const photoGeometryResult = this.detectPhotoGeometry();
+                // 综合判定（结合正向和逆向检测）
+                const isLively = this.makeLivenessDecision(eyeActivity, mouthActivity, muscleActivity, photoGeometryResult);
+                return new MotionDetectionResult(isLively, {
+                    frameCount: Math.max(this.eyeAspectRatioHistory.length, this.mouthAspectRatioHistory.length),
+                    // 正向检测结果（生物特征）
+                    eyeAspectRatioStdDev: eyeActivity.stdDev,
+                    mouthAspectRatioStdDev: mouthActivity.stdDev,
+                    eyeFluctuation: eyeActivity.fluctuation,
+                    mouthFluctuation: mouthActivity.fluctuation,
+                    muscleVariation: muscleActivity.variation,
+                    hasEyeMovement: eyeActivity.hasMovement,
+                    hasMouthMovement: mouthActivity.hasMovement,
+                    hasMuscleMovement: muscleActivity.hasMovement,
+                    // 逆向检测结果（照片几何特征）
+                    isPhoto: photoGeometryResult.isPhoto,
+                    photoConfidence: photoGeometryResult.confidence,
+                    homographyScore: photoGeometryResult.details?.homographyScore,
+                    perspectiveScore: photoGeometryResult.details?.perspectiveScore,
+                    crossRatioScore: photoGeometryResult.details?.crossRatioScore,
+                    depthVariation: photoGeometryResult.details?.depthVariation,
+                    crossFramePattern: photoGeometryResult.details?.crossFramePattern
                 });
             }
             catch (error) {
-                console.warn('[MotionLivenessDetector] Error analyzing motion:', error);
+                console.warn('[MotionLivenessDetector]', error);
                 return this.createEmptyResult();
             }
         }
         /**
-         * 将帧添加到循环缓冲区
+         * 检测眼睛的微妙波动（任何变化）
+         * 防护：排除透视畸变、噪声，确保是真实的连续或周期性波动
          */
-        addFrameToBuffer(grayMat) {
-            try {
-                // 存储帧尺寸（首帧时）
-                if (this.frameWidth === 0) {
-                    this.frameWidth = grayMat.cols;
-                    this.frameHeight = grayMat.rows;
-                }
-                // 转换为 Uint8Array 并存储
-                const grayData = new Uint8Array(grayMat.data);
-                this.frameBuffer.push(grayData);
-                // 清理旧的数据
-                if (this.frameBuffer.length > this.config.frameBufferSize) {
-                    this.frameBuffer.shift();
-                }
+        detectEyeFluctuation(keypoints) {
+            if (!keypoints.leftEye || !keypoints.rightEye) {
+                return { score: 0, stdDev: 0, fluctuation: 0, hasMovement: false };
+            }
+            // 计算眼睛宽高比
+            const leftEAR = this.calculateEyeAspectRatio(keypoints.leftEye);
+            const rightEAR = this.calculateEyeAspectRatio(keypoints.rightEye);
+            const avgEAR = (leftEAR + rightEAR) / 2;
+            // 记录时间戳
+            this.frameTimestamps.push(Date.now());
+            if (this.frameTimestamps.length > this.config.frameBufferSize) {
+                this.frameTimestamps.shift();
             }
-            catch (error) {
-                console.warn('[MotionLivenessDetector] Failed to add frame:', error);
+            // 分别记录左右眼EAR（用于一致性检测）
+            this.leftEyeEARHistory.push(leftEAR);
+            this.rightEyeEARHistory.push(rightEAR);
+            if (this.leftEyeEARHistory.length > this.config.frameBufferSize) {
+                this.leftEyeEARHistory.shift();
+                this.rightEyeEARHistory.shift();
             }
-        }
-        /**
-         * 验证运动一致性 - 防止照片微动攻击
-         * 真实面部运动：光流和关键点方差应该都有意义（都不为零）
-         * 照片微动：通常表现为只有光流或只有噪声，或两者都非常低
-         *
-         * 修复：允许不同类型运动的不同比例关系
-         * - 大幅度头部运动（旋转/平移）: 高keypoint variance, 中等optical flow
-         * - 微妙表情运动: 中等optical flow, 低keypoint variance
-         * - 照片微动: 两者都很低，或严重不匹配（一个近零一个不近零）
-         */
-        validateMotionConsistency(opticalFlow, keypointVariance) {
-            // 两个指标都非常低 = 照片或静止
-            if (opticalFlow < 0.01 && keypointVariance < 0.01) {
-                return 0;
+            this.eyeAspectRatioHistory.push(avgEAR);
+            if (this.eyeAspectRatioHistory.length > this.config.frameBufferSize) {
+                this.eyeAspectRatioHistory.shift();
             }
-            // 照片微动的典型特征：其中一个接近零，另一个不为零
-            // 但不是绝对拒绝，因为不同运动类型有不同的光流/关键点比例
-            const minValue = Math.min(opticalFlow, keypointVariance);
-            const maxValue = Math.max(opticalFlow, keypointVariance);
-            // 如果两个都有意义的值（都 > 0.01），认为是真实运动
-            // 即使比例不完全匹配（真实运动类型不同会导致不同的比例）
-            if (minValue >= 0.01) {
-                // 两者都有意义，即使比例不完全匹配也是可以接受的
-                // 允许最大 5:1 的比例（头部大幅旋转可能导致这样的差异）
-                const ratio = minValue / maxValue;
-                // 高宽容度：比例超过 0.2 就认为一致
-                // （之前的阈值 0.265 正好在这个范围内失败）
-                return Math.max(ratio, 0.5); // 如果两者都有意义，至少返回 0.5
-            }
-            // 其中一个接近零
-            // 这可能是照片微动，但也可能是特定运动（比如仅眼睛运动）
-            // 给予较低但非零的分数
-            return minValue / (maxValue + 0.001);
+            if (this.eyeAspectRatioHistory.length < 2) {
+                return { score: 0, stdDev: 0, fluctuation: 0, hasMovement: false };
+            }
+            // 计算EAR的标准差（波动幅度）
+            const stdDev = this.calculateStdDev(this.eyeAspectRatioHistory);
+            // 计算EAR的最大最小差值（波动范围）
+            const maxEAR = Math.max(...this.eyeAspectRatioHistory);
+            const minEAR = Math.min(...this.eyeAspectRatioHistory);
+            const fluctuation = maxEAR - minEAR;
+            // 【防护1】检测是否是透视畸变（往复波动）
+            const isOscillating = this.detectOscillation(this.eyeAspectRatioHistory);
+            // 【防护2】检测是否是连续变化（真实眨眼）还是噪声
+            const hasRealBlink = this.detectRealBlink(this.eyeAspectRatioHistory);
+            // 【防护3】检测最近帧的变化（实时动作）
+            const hasRecentMovement = this.detectRecentMovement(this.eyeAspectRatioHistory);
+            // 【新增防护4】检测左右眼一致性（真实眨眼双眼同步）
+            const eyeSymmetry = this.detectEyeSymmetry();
+            // 【新增防护5】检测眨眼时间模式（真实眨眼非常快，100-400ms）
+            const hasValidBlinkTiming = this.detectBlinkTiming();
+            // 【新增防护6】检测运动-形变相关性（透视畸变特征）
+            const motionDeformCorrelation = this.detectMotionDeformCorrelation();
+            // 【关键】组合多个防护条件
+            // 必须满足：有波动 + (往复或大幅波动) + (真实眨眼或最近有动作)
+            // 并且：左右眼对称 + 时间模式正确 + 非透视畸变
+            const basicMovement = (fluctuation > this.config.eyeMinFluctuation || stdDev > 0.005) &&
+                (isOscillating || fluctuation > 0.02) &&
+                (hasRealBlink || hasRecentMovement);
+            // 透视畸变攻击防护：如果运动和形变高度相关，很可能是照片偏转
+            const isPerspectiveAttack = motionDeformCorrelation > 0.7 && !hasValidBlinkTiming;
+            // 最终判定：基础动作检测通过 + 不是透视攻击 + 左右眼对称
+            const hasMovement = basicMovement && !isPerspectiveAttack && eyeSymmetry > 0.5;
+            // 评分：波动越大评分越高，但透视攻击会降分
+            const baseScore = hasMovement ? Math.min((fluctuation + stdDev) / 0.05, 1) : 0;
+            const score = baseScore * (1 - motionDeformCorrelation * 0.5);
+            console.debug('[Eye]', {
+                EAR: avgEAR.toFixed(4),
+                fluctuation: fluctuation.toFixed(5),
+                stdDev: stdDev.toFixed(5),
+                oscillating: isOscillating,
+                realBlink: hasRealBlink,
+                recentMovement: hasRecentMovement,
+                eyeSymmetry: eyeSymmetry.toFixed(3),
+                blinkTiming: hasValidBlinkTiming,
+                motionDeformCorr: motionDeformCorrelation.toFixed(3),
+                isPerspectiveAttack,
+                score: score.toFixed(3)
+            });
+            return { score, stdDev, fluctuation, hasMovement, isPerspectiveAttack };
         }
         /**
-         * 检测瞳孔反应 - 活体的关键特征
-         * 照片的瞳孔无法反应光线变化
+         * 检测嘴巴的微妙波动（任何变化）
+         * 防护：排除噪声，确保是真实的张嘴/闭嘴动作
          */
-        detectPupilResponse(keypoints) {
-            if (!keypoints.leftEye || !keypoints.rightEye) {
-                return 0;
-            }
-            try {
-                // 计算左眼瞳孔大小（使用眼睛关键点的范围）
-                const leftEyeSize = this.calculateEyeSize(keypoints.leftEye);
-                const rightEyeSize = this.calculateEyeSize(keypoints.rightEye);
-                const avgEyeSize = (leftEyeSize + rightEyeSize) / 2;
-                return avgEyeSize;
+        detectMouthFluctuation(keypoints) {
+            if (!keypoints.mouth) {
+                return { score: 0, stdDev: 0, fluctuation: 0, hasMovement: false };
             }
-            catch (error) {
-                return 0;
+            // 计算嘴巴宽高比
+            const MAR = this.calculateMouthAspectRatio(keypoints.mouth);
+            this.mouthAspectRatioHistory.push(MAR);
+            if (this.mouthAspectRatioHistory.length > this.config.frameBufferSize) {
+                this.mouthAspectRatioHistory.shift();
             }
+            if (this.mouthAspectRatioHistory.length < 2) {
+                return { score: 0, stdDev: 0, fluctuation: 0, hasMovement: false };
+            }
+            // 计算MAR的标准差
+            const stdDev = this.calculateStdDev(this.mouthAspectRatioHistory);
+            // 计算波动范围
+            const maxMAR = Math.max(...this.mouthAspectRatioHistory);
+            const minMAR = Math.min(...this.mouthAspectRatioHistory);
+            const fluctuation = maxMAR - minMAR;
+            // 【防护1】检测真实的张嘴/闭嘴周期
+            const hasRealMouthMovement = this.detectRealMouthMovement(this.mouthAspectRatioHistory);
+            // 【防护2】检测最近是否有嘴巴活动
+            const hasRecentMouthMovement = this.detectRecentMovement(this.mouthAspectRatioHistory);
+            // 【关键】需要真实的嘴巴动作或最近有活动
+            const hasMovement = (fluctuation > this.config.mouthMinFluctuation || stdDev > 0.003) &&
+                (hasRealMouthMovement || hasRecentMouthMovement);
+            // 评分
+            const score = hasMovement ? Math.min((fluctuation + stdDev) / 0.05, 1) : 0;
+            console.debug('[Mouth]', {
+                MAR: MAR.toFixed(4),
+                fluctuation: fluctuation.toFixed(5),
+                stdDev: stdDev.toFixed(5),
+                realMovement: hasRealMouthMovement,
+                recentMovement: hasRecentMouthMovement,
+                score: score.toFixed(3)
+            });
+            return { score, stdDev, fluctuation, hasMovement };
         }
         /**
-         * 计算眼睛大小（用于瞳孔反应检测）
+         * 【关键】检测真实的嘴巴张嘴→闭嘴动作
+         *
+         * 原理类似眨眼，需要检测下降和上升的连续段
          */
-        calculateEyeSize(eyeKeypoints) {
-            if (!eyeKeypoints || eyeKeypoints.length < 4) {
-                return 0;
+        detectRealMouthMovement(values) {
+            if (values.length < 3) {
+                return false;
             }
-            try {
-                // 计算眼睛边界框
-                let minX = Infinity, maxX = -Infinity;
-                let minY = Infinity, maxY = -Infinity;
-                for (const point of eyeKeypoints) {
-                    if (point && point.length >= 2) {
-                        minX = Math.min(minX, point[0]);
-                        maxX = Math.max(maxX, point[0]);
-                        minY = Math.min(minY, point[1]);
-                        maxY = Math.max(maxY, point[1]);
+            // 统计连续段
+            let descendingSegments = 0;
+            let ascendingSegments = 0;
+            let inDescending = false;
+            let inAscending = false;
+            for (let i = 1; i < values.length; i++) {
+                const change = values[i] - values[i - 1];
+                const threshold = 0.008;
+                if (change < -threshold) {
+                    if (!inDescending) {
+                        descendingSegments++;
+                        inDescending = true;
+                        inAscending = false;
+                    }
+                }
+                else if (change > threshold) {
+                    if (!inAscending) {
+                        ascendingSegments++;
+                        inAscending = true;
+                        inDescending = false;
                     }
                 }
-                if (minX === Infinity || minY === Infinity)
-                    return 0;
-                const width = maxX - minX;
-                const height = maxY - minY;
-                return width * height; // 面积
             }
-            catch (error) {
-                return 0;
+            const hasCompletePattern = descendingSegments > 0 && ascendingSegments > 0;
+            // 或检查最近5帧
+            if (values.length >= 5) {
+                const recent5 = values.slice(-5);
+                const recentRange = Math.max(...recent5) - Math.min(...recent5);
+                const hasRecentOpening = recentRange > 0.015;
+                return hasCompletePattern || hasRecentOpening;
             }
+            return hasCompletePattern;
         }
         /**
-         * 从 Human.js 面部检测结果中提取面部关键点
-         * 使用网格标志点（来自 MediaPipe Face Mesh 模型的 468 个点）
-         */
-        extractKeypoints(face) {
-            const keypoints = {};
-            // 提取网格标志点（来自面部网格的 468 个点）
-            if (face.mesh && Array.isArray(face.mesh)) {
-                keypoints.landmarks = face.mesh;
+         * 检测面部肌肉的微动（关键点位置微妙变化）
+         * 关键：允许刚性运动+生物特征（真人摇头），拒绝纯刚性运动（照片旋转）
+         *
+         * 【重要修复】使用归一化坐标进行比较，消除人脸在画面中移动的影响
+         */
+        detectMuscleMovement() {
+            // 【关键】使用归一化坐标历史，而非绝对坐标
+            if (this.normalizedLandmarksHistory.length < 2) {
+                return { score: 0, variation: 0, hasMovement: false };
+            }
+            // 【改进】检测刚性运动，但不直接拒绝
+            // 在综合判定中会结合其他生物特征来判断
+            const rigidityScore = this.detectRigidMotion();
+            // 记录刚性运动历史（用于运动-形变相关性分析）
+            this.rigidMotionHistory.push(rigidityScore);
+            if (this.rigidMotionHistory.length > this.config.frameBufferSize) {
+                this.rigidMotionHistory.shift();
+            }
+            // 选择敏感的肌肉关键点
+            const musclePoints = [
+                61, 291, // 嘴角
+                46, 53, // 左眉
+                276, 283, // 右眉
+                127, 356 // 脸颊
+            ];
+            const distances = [];
+            // 【关键】使用归一化坐标计算位移
+            for (let i = 1; i < this.normalizedLandmarksHistory.length; i++) {
+                const prevFrame = this.normalizedLandmarksHistory[i - 1];
+                const currFrame = this.normalizedLandmarksHistory[i];
+                let totalDist = 0;
+                let validPoints = 0;
+                for (const ptIdx of musclePoints) {
+                    const prev = prevFrame[ptIdx];
+                    const curr = currFrame[ptIdx];
+                    if (prev && curr && prev.length >= 2 && curr.length >= 2) {
+                        // 归一化坐标的距离（相对于人脸尺寸的比例）
+                        const dist = Math.sqrt((curr[0] - prev[0]) ** 2 + (curr[1] - prev[1]) ** 2);
+                        totalDist += dist;
+                        validPoints++;
+                    }
+                }
+                if (validPoints > 0) {
+                    distances.push(totalDist / validPoints);
+                }
             }
-            // 从网格标志点中提取眼睛和嘴巴区域
-            // MediaPipe Face Mesh 标志点索引：
-            // 左眼：362, 385, 387, 390, 25, 55, 154, 133
-            // 右眼：33, 160, 158, 133, 153, 144
-            // 嘴巴：61, 185, 40, 39, 37, 0, 267, 269, 270, 409
-            if (keypoints.landmarks && keypoints.landmarks.length >= 468) {
-                // 左眼关键点
-                keypoints.leftEye = [
-                    keypoints.landmarks[362],
-                    keypoints.landmarks[385],
-                    keypoints.landmarks[387],
-                    keypoints.landmarks[390],
-                    keypoints.landmarks[25],
-                    keypoints.landmarks[55]
-                ].filter(point => point !== undefined);
-                // 右眼关键点
-                keypoints.rightEye = [
-                    keypoints.landmarks[33],
-                    keypoints.landmarks[160],
-                    keypoints.landmarks[158],
-                    keypoints.landmarks[133],
-                    keypoints.landmarks[153],
-                    keypoints.landmarks[144]
-                ].filter(point => point !== undefined);
-                // 嘴巴关键点
-                keypoints.mouth = [
-                    keypoints.landmarks[61],
-                    keypoints.landmarks[185],
-                    keypoints.landmarks[40],
-                    keypoints.landmarks[39],
-                    keypoints.landmarks[37],
-                    keypoints.landmarks[0],
-                    keypoints.landmarks[267],
-                    keypoints.landmarks[269],
-                    keypoints.landmarks[270],
-                    keypoints.landmarks[409]
-                ].filter(point => point !== undefined);
+            if (distances.length === 0) {
+                return { score: 0, variation: 0, hasMovement: false };
             }
-            return keypoints;
+            // 计算肌肉运动的变异性
+            const avgDist = distances.reduce((a, b) => a + b, 0) / distances.length;
+            const variation = this.calculateStdDev(distances);
+            // 【关键】只要有任何细微变化就判定为活动
+            // 注意：阈值需要调整，因为归一化坐标的数值范围是 [0, 1]
+            const hasMovement = variation > 0.001 || avgDist > 0.005;
+            // 评分
+            const score = Math.min((variation + avgDist) / 0.05, 1);
+            console.debug('[Muscle] avgDist:', avgDist.toFixed(4), 'variation:', variation.toFixed(5), 'rigidity:', rigidityScore.toFixed(3), 'score:', score.toFixed(3));
+            return { score: Math.max(score, 0), variation, hasMovement, rigidityScore };
         }
         /**
-         * 计算光流幅度（需要 OpenCV）
-         * 检测帧之间的像素运动
+         * 【防护机制】检测照片透视畸变（倾角拍摄）
+         *
+         * 原理：
+         * - 照片是平面：所有关键点Z坐标（深度）应该相同且恒定
+         * - 当从倾角看平面照片时，虽然会产生2D投影变形，但深度仍然固定在一个平面
+         * - 真实活体：脸部有Z坐标深度，不同区域有深度差异（鼻子、下巴等突出）
          *
-         * 针对5帧短视频优化的参数：
-         * - pyr_scale: 0.8（更陡峭的金字塔，保留细节）
-         * - levels: 2（减少层级数，适合小尺寸视频）
-         * - winsize: 7（更小的窗口，捕捉微小运动）
+         * 返回值：照片平面性得分（0-1，越接近1越可能是平面照片）
          */
-        analyzeOpticalFlow() {
-            if (!this.cv || this.frameBuffer.length < 2 || this.frameWidth === 0 || this.frameHeight === 0) {
-                return 0;
-            }
-            try {
-                // 从 Uint8Array 创建 Mat 对象进行光流计算
-                const prevFrameData = this.frameBuffer[this.frameBuffer.length - 2];
-                const currFrameData = this.frameBuffer[this.frameBuffer.length - 1];
-                // 创建临时 Mat 对象
-                const prevMat = this.cv.matFromArray(this.frameHeight, this.frameWidth, this.cv.CV_8U, prevFrameData);
-                const currMat = this.cv.matFromArray(this.frameHeight, this.frameWidth, this.cv.CV_8U, currFrameData);
-                // 计算光流
-                const flow = new this.cv.Mat();
-                this.cv.calcOpticalFlowFarneback(prevMat, currMat, flow, 0.8, // pyr_scale: 更陡峭的金字塔
-                2, // levels: 减少层级数
-                7, // winsize: 更小的窗口
-                3, // iterations
-                5, // polyN
-                1.2, // polySigma
-                0 // flags
-                );
-                const magnitude = this.calculateFlowMagnitude(flow);
-                // 清理临时对象
-                prevMat.delete();
-                currMat.delete();
-                flow.delete();
-                return magnitude;
-            }
-            catch (error) {
-                console.warn('[MotionLivenessDetector] Optical flow calculation failed:', error);
+        detectPhotoPlanarity() {
+            if (this.faceLandmarksHistory.length < 3) {
                 return 0;
             }
-        }
-        /**
-         * 计算光流的平均幅度
-         * 包含诊断日志用于调试
-         */
-        calculateFlowMagnitude(flowMat) {
-            if (!flowMat || flowMat.empty()) {
-                console.debug('[MotionLivenessDetector] Flow matrix is empty');
+            // 获取最近帧的关键点
+            const latestFrame = this.faceLandmarksHistory[this.faceLandmarksHistory.length - 1];
+            if (!latestFrame || latestFrame.length < 468) {
                 return 0;
             }
-            try {
-                const flowData = new Float32Array(flowMat.data32F);
-                let sumMagnitude = 0;
-                let count = 0;
-                let maxMagnitude = 0;
-                // 处理光流向量（每个像素 2 个值：x 和 y 分量）
-                for (let i = 0; i < flowData.length; i += 2) {
-                    const fx = flowData[i];
-                    const fy = flowData[i + 1];
-                    const mag = Math.sqrt(fx * fx + fy * fy);
-                    sumMagnitude += mag;
-                    maxMagnitude = Math.max(maxMagnitude, mag);
-                    count++;
+            // 采样关键点的Z坐标（深度值）
+            // MediaPipe返回的Z坐标是相对值，表示距离摄像头的深度
+            const samplePoints = [
+                10, // 额头上方
+                152, // 下巴
+                33, // 右眼外角
+                263, // 左眼外角
+                61, // 左嘴角
+                291, // 右嘴角
+                1, // 鼻尖
+                234, // 右脸颊边缘
+                454 // 左脸颊边缘
+            ];
+            const zValues = [];
+            for (const ptIdx of samplePoints) {
+                if (latestFrame[ptIdx] && latestFrame[ptIdx].length >= 3) {
+                    zValues.push(latestFrame[ptIdx][2]);
                 }
-                // 计算平均光流
-                const avgMagnitude = count > 0 ? sumMagnitude / count : 0;
-                // 归一化到 0-1 范围（最大预期光流约为 10 像素/帧，针对5帧优化）
-                const normalizedMagnitude = Math.min(avgMagnitude / 10, 1);
-                // 诊断日志
-                console.debug('[MotionLivenessDetector] Optical flow stats:', {
-                    pixelCount: count,
-                    sumMagnitude: sumMagnitude.toFixed(2),
-                    avgMagnitude: avgMagnitude.toFixed(4),
-                    maxMagnitude: maxMagnitude.toFixed(4),
-                    normalizedResult: normalizedMagnitude.toFixed(4)
-                });
-                return normalizedMagnitude;
             }
-            catch (error) {
-                console.warn('[MotionLivenessDetector] Flow magnitude calculation failed:', error);
+            if (zValues.length < 5) {
                 return 0;
             }
+            // 计算Z坐标的变异系数
+            const zMean = zValues.reduce((a, b) => a + b, 0) / zValues.length;
+            const zStdDev = this.calculateStdDev(zValues);
+            // 照片的Z坐标变异非常小（都在一个平面上）
+            // 活体的Z坐标有较大变异（鼻子比眼睛凸出，下巴和额头深度不同）
+            const zVarianceRatio = zMean > 0 ? zStdDev / zMean : 0;
+            // 平面性评分：如果Z坐标变异很小，说明是平面（照片）
+            // 如果zVarianceRatio < 0.15，认为是平面
+            // 如果zVarianceRatio > 0.3，认为是立体（活体）
+            const planarity = Math.max(0, (0.15 - zVarianceRatio) / 0.15);
+            console.debug('[Planarity]', {
+                zMean: zMean.toFixed(4),
+                zStdDev: zStdDev.toFixed(4),
+                zVarianceRatio: zVarianceRatio.toFixed(4),
+                planarity: planarity.toFixed(3)
+            });
+            return Math.min(planarity, 1);
         }
         /**
-         * 计算关键点位置在帧间的方差
-         * 高方差 = 自然运动（活跃）
-         * 低方差 = 静止如照片
-         */
-        calculateKeypointVariance() {
-            if (this.keypointHistory.length < 2) {
-                return 0;
-            }
-            try {
-                const distances = [];
-                // 比较连续的帧
-                for (let i = 1; i < this.keypointHistory.length; i++) {
-                    const prevKeypoints = this.keypointHistory[i - 1];
-                    const currKeypoints = this.keypointHistory[i];
-                    if (prevKeypoints.landmarks && currKeypoints.landmarks) {
-                        const avgDistance = this.calculateLandmarkDistance(prevKeypoints.landmarks, currKeypoints.landmarks);
-                        distances.push(avgDistance);
+         * 【防护机制】检测刚性运动（照片被拿着旋转/平移）
+         *
+         * 原理：
+         * - 照片所有关键点运动是【刚性的】→ 所有点以相同方向、相似幅度移动
+         * - 活体肌肉运动是【非刚性的】→ 不同部位独立运动（眼睛、嘴、脸颊等）
+         *
+         * 【重要修复】使用归一化坐标进行比较
+         *
+         * 返回值 0-1：值越接近1说明是刚性运动（照片运动）
+         */
+        detectRigidMotion() {
+            // 【关键】使用归一化坐标历史
+            if (this.normalizedLandmarksHistory.length < 2) {
+                return 0; // 数据不足，不判定为刚性运动
+            }
+            // 采样关键点（覆盖全脸，去重）
+            const samplePoints = [
+                33, 263, // 左右眼外角
+                362, 133, // 左右眼内角
+                234, 454, // 左右脸颊边缘
+                10, 152, // 额头、下巴
+                61, 291 // 嘴角
+            ];
+            const motionVectors = [];
+            // 【关键】使用归一化坐标计算运动向量
+            const frame1 = this.normalizedLandmarksHistory[this.normalizedLandmarksHistory.length - 2];
+            const frame2 = this.normalizedLandmarksHistory[this.normalizedLandmarksHistory.length - 1];
+            for (const ptIdx of samplePoints) {
+                if (ptIdx < frame1.length && ptIdx < frame2.length) {
+                    const p1 = frame1[ptIdx];
+                    const p2 = frame2[ptIdx];
+                    if (p1 && p2 && p1.length >= 2 && p2.length >= 2) {
+                        motionVectors.push({
+                            dx: p2[0] - p1[0],
+                            dy: p2[1] - p1[1]
+                        });
                     }
                 }
-                if (distances.length === 0) {
-                    return 0;
-                }
-                // 计算距离的方差
-                const mean = distances.reduce((a, b) => a + b, 0) / distances.length;
-                const variance = distances.reduce((a, d) => a + (d - mean) ** 2, 0) / distances.length;
-                const stdDev = Math.sqrt(variance);
-                // 归一化到 0-1 范围（按预期的自然变化 ~5 像素归一化）
-                return Math.min(stdDev / 5, 1);
             }
-            catch (error) {
-                console.warn('[MotionLivenessDetector] Keypoint variance calculation failed:', error);
+            if (motionVectors.length < 3) {
                 return 0;
             }
+            // 计算所有运动向量的【一致性】
+            // 如果所有向量都指向相同方向（方向角相似），则为刚性运动
+            const angles = motionVectors.map(v => Math.atan2(v.dy, v.dx));
+            const magnitudes = motionVectors.map(v => Math.sqrt(v.dx * v.dx + v.dy * v.dy));
+            // 方向一致性：计算方向的标准差
+            const meanAngle = this.calculateMeanAngle(angles);
+            const angleVariance = angles.reduce((sum, angle) => {
+                const diff = angle - meanAngle;
+                // 处理角度环绕问题
+                const wrappedDiff = Math.abs(diff) > Math.PI ? 2 * Math.PI - Math.abs(diff) : Math.abs(diff);
+                return sum + wrappedDiff * wrappedDiff;
+            }, 0) / angles.length;
+            const angleStdDev = Math.sqrt(angleVariance);
+            // 幅度一致性：计算幅度的变异系数
+            const meanMagnitude = magnitudes.reduce((a, b) => a + b, 0) / magnitudes.length;
+            const magnitudeVariance = magnitudes.reduce((sum, mag) => sum + (mag - meanMagnitude) ** 2, 0) / magnitudes.length;
+            const magnitudeStdDev = Math.sqrt(magnitudeVariance);
+            // 使用更低的阈值避免小运动时误判，当运动幅度很小时使用1避免除零
+            const magnitudeCV = meanMagnitude > 0.001 ? magnitudeStdDev / meanMagnitude : 1;
+            // 综合评分：方向和幅度都一致 → 刚性运动
+            // angleStdDev 越小（接近0）说明方向越一致
+            // magnitudeCV 越小（接近0）说明幅度越一致
+            const rigidityScore = Math.max(0, 1 - angleStdDev / 0.5) * Math.max(0, 1 - magnitudeCV);
+            console.debug('[RigidityCheck]', {
+                samplePointCount: motionVectors.length,
+                angleStdDev: angleStdDev.toFixed(4),
+                magnitudeCV: magnitudeCV.toFixed(4),
+                rigidityScore: rigidityScore.toFixed(3)
+            });
+            return Math.min(rigidityScore, 1);
         }
         /**
-         * 计算两帧中对应标志点之间的平均距离
+         * 计算角度的平均值（考虑循环性）
          */
-        calculateLandmarkDistance(landmarks1, landmarks2) {
-            if (!landmarks1 || !landmarks2 || landmarks1.length !== landmarks2.length) {
-                return 0;
-            }
-            let totalDistance = 0;
-            let count = 0;
-            for (let i = 0; i < Math.min(landmarks1.length, landmarks2.length); i++) {
-                const p1 = landmarks1[i];
-                const p2 = landmarks2[i];
-                if (p1 && p2 && p1.length >= 2 && p2.length >= 2) {
-                    const dx = p1[0] - p2[0];
-                    const dy = p1[1] - p2[1];
-                    const distance = Math.sqrt(dx * dx + dy * dy);
-                    totalDistance += distance;
-                    count++;
-                }
-            }
-            return count > 0 ? totalDistance / count : 0;
+        calculateMeanAngle(angles) {
+            const sinSum = angles.reduce((sum, a) => sum + Math.sin(a), 0);
+            const cosSum = angles.reduce((sum, a) => sum + Math.cos(a), 0);
+            return Math.atan2(sinSum / angles.length, cosSum / angles.length);
         }
         /**
-         * 计算所有帧中的平均关键点距离
+         * 检测序列是否呈现【往复波动】而不是【单向变化】
+         *
+         * 原理：
+         * - 真实眨眼/表情：值会【往复波动】 如 0.4 → 0.3 → 0.4 → 0.5
+         * - 照片透视变形：值会【单向变化】 如 0.4 → 0.3 → 0.25 → 0.2
+         *
+         * 返回值：true = 检测到往复波动（活体特征）
          */
-        calculateAvgKeypointDistance() {
-            if (this.keypointHistory.length < 2) {
-                return 0;
-            }
-            let totalDistance = 0;
-            let comparisons = 0;
-            for (let i = 1; i < this.keypointHistory.length; i++) {
-                const prevKeypoints = this.keypointHistory[i - 1];
-                const currKeypoints = this.keypointHistory[i];
-                if (prevKeypoints.landmarks && currKeypoints.landmarks) {
-                    const avgDistance = this.calculateLandmarkDistance(prevKeypoints.landmarks, currKeypoints.landmarks);
-                    totalDistance += avgDistance;
-                    comparisons++;
-                }
+        detectOscillation(values) {
+            if (values.length < 4) {
+                return false;
             }
-            return comparisons > 0 ? totalDistance / comparisons : 0;
-        }
-        /**
-         * 计算帧间的最大关键点距离
-         */
-        calculateMaxKeypointDistance() {
-            if (this.keypointHistory.length < 2) {
-                return 0;
+            // 计算相邻值的差分
+            const diffs = [];
+            for (let i = 1; i < values.length; i++) {
+                diffs.push(values[i] - values[i - 1]);
             }
-            let maxDistance = 0;
-            for (let i = 1; i < this.keypointHistory.length; i++) {
-                const prevKeypoints = this.keypointHistory[i - 1];
-                const currKeypoints = this.keypointHistory[i];
-                if (prevKeypoints.landmarks && currKeypoints.landmarks) {
-                    const avgDistance = this.calculateLandmarkDistance(prevKeypoints.landmarks, currKeypoints.landmarks);
-                    maxDistance = Math.max(maxDistance, avgDistance);
+            // 统计方向改变次数（从正变负或从负变正）
+            let directionChanges = 0;
+            for (let i = 1; i < diffs.length; i++) {
+                if (diffs[i] * diffs[i - 1] < 0) { // 符号相反
+                    directionChanges++;
                 }
             }
-            return maxDistance;
+            // 往复波动通常有多次方向改变
+            // 单向变化只有0-1次方向改变
+            const isOscillating = directionChanges >= 1;
+            return isOscillating;
         }
         /**
-         * 计算眼睛宽高比 (EAR)
-         * 用于检测眨眼和眼睛开度变化
+         * 【关键】检测真实眨眼（连续的闭眼→睁眼周期）
+         *
+         * 原理：
+         * - 真实眨眼：快速下降（EAR↓ 1-2帧）→ 保持低值（EAR低 2-3帧）→ 快速上升（EAR↑ 1-2帧）
+         * - 噪声或光线变化：孤立的异常值，前后没有连续的变化模式
+         *
+         * 返回值：true = 检测到完整或部分眨眼周期
          */
-        calculateEyeAspectRatio(eyeKeypoints) {
-            if (!eyeKeypoints || eyeKeypoints.length < 6) {
-                return 0;
+        detectRealBlink(values) {
+            if (values.length < 3) {
+                return false;
             }
-            try {
-                // 眼睛关键点：[左角, 上-1, 上-2, 右角, 下-2, 下-1]
-                // 垂直点之间的距离除以水平距离
-                const leftCorner = eyeKeypoints[0];
-                const rightCorner = eyeKeypoints[3];
-                const upperLeft = eyeKeypoints[1];
-                const upperRight = eyeKeypoints[2];
-                const lowerLeft = eyeKeypoints[5];
-                const lowerRight = eyeKeypoints[4];
-                // 欧氏距离
-                const verticalLeft = this.pointDistance(upperLeft, lowerLeft);
-                const verticalRight = this.pointDistance(upperRight, lowerRight);
-                const horizontal = this.pointDistance(leftCorner, rightCorner);
-                if (horizontal === 0)
-                    return 0;
-                // EAR = (||p2 - p6|| + ||p3 - p5||) / (2 * ||p1 - p4||)
-                return (verticalLeft + verticalRight) / (2 * horizontal);
+            // 统计连续下降和上升的段数
+            let descendingSegments = 0;
+            let ascendingSegments = 0;
+            let inDescending = false;
+            let inAscending = false;
+            for (let i = 1; i < values.length; i++) {
+                const change = values[i] - values[i - 1];
+                const threshold = 0.01; // 判定为"变化"的阈值
+                if (change < -threshold) {
+                    if (!inDescending) {
+                        descendingSegments++;
+                        inDescending = true;
+                        inAscending = false;
+                    }
+                }
+                else if (change > threshold) {
+                    if (!inAscending) {
+                        ascendingSegments++;
+                        inAscending = true;
+                        inDescending = false;
+                    }
+                }
+                else ;
             }
-            catch (error) {
-                console.warn('[MotionLivenessDetector] Eye aspect ratio calculation failed:', error);
-                return 0;
+            // 完整眨眼周期：下降→平台→上升，至少要有下降和上升
+            // 或者：最近几帧有明显的下升趋势
+            const hasCompletePattern = descendingSegments > 0 && ascendingSegments > 0;
+            // 或者检查最近5帧是否有明显变化
+            if (values.length >= 5) {
+                const recent5 = values.slice(-5);
+                const recentRange = Math.max(...recent5) - Math.min(...recent5);
+                const hasRecentBlink = recentRange > 0.02;
+                return hasCompletePattern || hasRecentBlink;
             }
+            return hasCompletePattern;
         }
         /**
-         * 计算嘴巴宽高比 (MAR)
-         * 用于检测嘴巴张开的变化
-         */
-        calculateMouthAspectRatio(mouthKeypoints) {
-            if (!mouthKeypoints || mouthKeypoints.length < 6) {
-                return 0;
-            }
-            try {
-                // 简单的嘴巴张开检测
-                // 使用上唇和下唇之间的垂直距离
-                const upperLipY = mouthKeypoints.slice(0, 5).reduce((sum, p) => sum + (p?.[1] || 0), 0) / 5;
-                const lowerLipY = mouthKeypoints.slice(5).reduce((sum, p) => sum + (p?.[1] || 0), 0) / 5;
-                const mouthWidth = this.pointDistance(mouthKeypoints[0], mouthKeypoints[5]);
-                if (mouthWidth === 0)
-                    return 0;
-                const verticalDistance = Math.abs(upperLipY - lowerLipY);
-                return verticalDistance / mouthWidth;
-            }
-            catch (error) {
-                console.warn('[MotionLivenessDetector] Mouth aspect ratio calculation failed:', error);
-                return 0;
-            }
+         * 【新增防护】检测左右眼对称性
+         *
+         * 原理：
+         * - 真实眨眼：左右眼几乎同时闭合和睁开，EAR变化高度同步
+         * - 照片透视畸变：根据偏转方向，一只眼睛可能比另一只变化更大
+         *
+         * 返回值 0-1：越接近1说明左右眼越对称（越像真实眨眼）
+         */
+        detectEyeSymmetry() {
+            if (this.leftEyeEARHistory.length < 3 || this.rightEyeEARHistory.length < 3) {
+                return 1; // 数据不足，默认通过
+            }
+            // 计算左右眼EAR变化的差分
+            const leftDiffs = [];
+            const rightDiffs = [];
+            for (let i = 1; i < this.leftEyeEARHistory.length; i++) {
+                leftDiffs.push(this.leftEyeEARHistory[i] - this.leftEyeEARHistory[i - 1]);
+                rightDiffs.push(this.rightEyeEARHistory[i] - this.rightEyeEARHistory[i - 1]);
+            }
+            // 计算左右眼变化的相关性
+            // 真实眨眼：leftDiffs ≈ rightDiffs（同向同幅度）
+            // 透视畸变：可能一个大一个小，或方向不一致
+            let sumProduct = 0;
+            let sumLeftSq = 0;
+            let sumRightSq = 0;
+            for (let i = 0; i < leftDiffs.length; i++) {
+                sumProduct += leftDiffs[i] * rightDiffs[i];
+                sumLeftSq += leftDiffs[i] * leftDiffs[i];
+                sumRightSq += rightDiffs[i] * rightDiffs[i];
+            }
+            const denominator = Math.sqrt(sumLeftSq * sumRightSq);
+            if (denominator < 0.0001) {
+                return 1; // 几乎没有变化，视为对称
+            }
+            // 皮尔逊相关系数，范围 [-1, 1]
+            const correlation = sumProduct / denominator;
+            // 转换为对称性得分 [0, 1]，相关性越高越对称
+            const symmetry = (correlation + 1) / 2;
+            console.debug('[EyeSymmetry]', {
+                correlation: correlation.toFixed(3),
+                symmetry: symmetry.toFixed(3)
+            });
+            return symmetry;
         }
         /**
-         * 计算面部中心（所有关键点的平均位置）
-         */
-        calculateFaceCenter(landmarks) {
-            if (!landmarks || landmarks.length === 0) {
-                return null;
-            }
-            try {
-                let sumX = 0;
-                let sumY = 0;
-                let validPoints = 0;
-                for (const point of landmarks) {
-                    if (point && point.length >= 2) {
-                        sumX += point[0];
-                        sumY += point[1];
-                        validPoints++;
+         * 【新增防护】检测眨眼时间模式
+         *
+         * 原理：
+         * - 真实眨眼非常快：完整周期 100-400ms（3-12帧@30fps）
+         * - 手动摆动照片：周期通常 500ms-2000ms（15-60帧@30fps）
+         *
+         * 返回值：true = 检测到符合真实眨眼的快速时间模式
+         */
+        detectBlinkTiming() {
+            if (this.eyeAspectRatioHistory.length < 5 || this.frameTimestamps.length < 5) {
+                return true; // 数据不足，默认通过
+            }
+            // 找到EAR的局部最小值（眨眼闭合点）
+            const values = this.eyeAspectRatioHistory;
+            const timestamps = this.frameTimestamps;
+            // 检测下降-上升周期的时间
+            let inDescent = false;
+            let descentStartIdx = -1;
+            let fastBlinkCount = 0;
+            let slowBlinkCount = 0;
+            for (let i = 1; i < values.length; i++) {
+                const change = values[i] - values[i - 1];
+                if (change < -0.01 && !inDescent) {
+                    // 开始下降
+                    inDescent = true;
+                    descentStartIdx = i - 1;
+                }
+                else if (change > 0.01 && inDescent) {
+                    // 开始上升（完成一个眨眼周期）
+                    inDescent = false;
+                    if (descentStartIdx >= 0 && i < timestamps.length) {
+                        const duration = timestamps[i] - timestamps[descentStartIdx];
+                        if (duration > 0 && duration < 500) {
+                            fastBlinkCount++; // 快速眨眼（< 500ms）
+                        }
+                        else if (duration >= 500) {
+                            slowBlinkCount++; // 慢速"眨眼"（可能是照片摆动）
+                        }
                     }
                 }
-                if (validPoints === 0)
-                    return null;
-                return [sumX / validPoints, sumY / validPoints];
-            }
-            catch (error) {
-                return null;
             }
+            // 如果快速眨眼比慢速眨眼多，认为是真实的
+            const hasValidTiming = fastBlinkCount > 0 || slowBlinkCount === 0;
+            console.debug('[BlinkTiming]', {
+                fastBlinks: fastBlinkCount,
+                slowBlinks: slowBlinkCount,
+                hasValidTiming
+            });
+            return hasValidTiming;
         }
         /**
-         * 计算两个点之间的距离
+         * 【新增防护】检测运动-形变相关性
+         *
+         * 原理：
+         * - 照片偏转攻击：刚性运动越大 → EAR/MAR形变越大（高度相关）
+         * - 真实活体：眨眼/张嘴与头部运动无关（低相关或无相关）
+         *
+         * 返回值 0-1：越接近1说明运动和形变越相关（越像照片攻击）
          */
-        pointDistance(p1, p2) {
-            if (!p1 || !p2 || p1.length < 2 || p2.length < 2) {
-                return 0;
+        detectMotionDeformCorrelation() {
+            if (this.rigidMotionHistory.length < 3 || this.eyeAspectRatioHistory.length < 3) {
+                return 0; // 数据不足，默认不是攻击
             }
-            const dx = p1[0] - p2[0];
-            const dy = p1[1] - p2[1];
-            return Math.sqrt(dx * dx + dy * dy);
-        }
-        /**
-         * 基于眼睛宽高比变化计算眼睛运动评分
-         */
-        calculateEyeMotionScore() {
-            if (this.eyeAspectRatioHistory.length < 2) {
-                return 0;
+            // 计算EAR变化幅度
+            const earChanges = [];
+            for (let i = 1; i < this.eyeAspectRatioHistory.length; i++) {
+                earChanges.push(Math.abs(this.eyeAspectRatioHistory[i] - this.eyeAspectRatioHistory[i - 1]));
             }
-            const variance = this.calculateVariance(this.eyeAspectRatioHistory);
-            // 检查方差是否超过眨眼检测的眼睛宽高比阈值
-            if (variance < this.config.eyeAspectRatioThreshold) {
+            // 取最近的刚性运动历史（对齐长度）
+            const motionValues = this.rigidMotionHistory.slice(-(earChanges.length));
+            if (motionValues.length !== earChanges.length || motionValues.length < 3) {
                 return 0;
             }
-            // 归一化：眨眼的预期方差约为 0.05
-            return Math.min(variance / 0.05, 1);
+            // 计算皮尔逊相关系数
+            const n = motionValues.length;
+            const meanMotion = motionValues.reduce((a, b) => a + b, 0) / n;
+            const meanEAR = earChanges.reduce((a, b) => a + b, 0) / n;
+            let numerator = 0;
+            let denomMotion = 0;
+            let denomEAR = 0;
+            for (let i = 0; i < n; i++) {
+                const diffMotion = motionValues[i] - meanMotion;
+                const diffEAR = earChanges[i] - meanEAR;
+                numerator += diffMotion * diffEAR;
+                denomMotion += diffMotion * diffMotion;
+                denomEAR += diffEAR * diffEAR;
+            }
+            const denominator = Math.sqrt(denomMotion * denomEAR);
+            if (denominator < 0.0001) {
+                return 0; // 几乎没有变化
+            }
+            // 相关系数 [-1, 1]，我们关心正相关（运动大→形变大）
+            const correlation = numerator / denominator;
+            // 只有正相关才可疑，负相关或无相关都正常
+            const suspiciousCorrelation = Math.max(0, correlation);
+            console.debug('[MotionDeformCorr]', {
+                correlation: correlation.toFixed(3),
+                suspicious: suspiciousCorrelation.toFixed(3)
+            });
+            return suspiciousCorrelation;
+        }
+        /**
+         * 【关键】检测最近几帧是否有运动
+         *
+         * 防护：某人在检测开始时眨眼，之后就完全静止
+         * 这种情况应该判定为照片，因为照片可以有偶然的反光
+         * 活体应该有【持续的或周期性的】动作
+         *
+         * 返回值：true = 最近3-5帧内有明显变化
+         */
+        detectRecentMovement(values) {
+            if (values.length < 4) {
+                return false; // 数据不足，保守判定
+            }
+            // 检查最近帧的变化幅度
+            // 如果最近帧都相同，说明动作已经停止
+            const recentFrames = values.slice(-5); // 最近5帧
+            const recentRange = Math.max(...recentFrames) - Math.min(...recentFrames);
+            const recentStdDev = this.calculateStdDev(recentFrames);
+            // 最近帧还有变化，说明活体在动
+            const hasRecentChange = recentRange > 0.008 || recentStdDev > 0.003;
+            // 额外检查：不能只是偶然的反光
+            // 如果最后2帧都完全相同或非常接近，说明已经停止
+            const lastTwoChanges = Math.abs(values[values.length - 1] - values[values.length - 2]);
+            const isStabiliziing = lastTwoChanges < 0.002;
+            return hasRecentChange && !isStabiliziing;
+        }
+        /**
+         * 【核心】照片几何特征检测（逆向检测）
+         *
+         * 重要说明：
+         * - MediaPipe的Z坐标是从2D图像【推断】的，不是真实深度
+         * - 对照片也可能推断出"假"的3D结构
+         * - 因此【2D几何约束】比【Z坐标分析】更可靠
+         *
+         * 可靠的检测（基于2D几何，物理定律）：
+         * 1. 单应性变换约束 - 平面必须满足
+         * 2. 特征点相对位置变化 - 照片偏转时遵循透视规律
+         *
+         * 参考性检测（基于推断的Z坐标，可能被欺骗）：
+         * 1. 深度一致性 - 辅助参考
+         * 2. 跨帧深度模式 - 辅助参考
+         */
+        detectPhotoGeometry() {
+            if (this.faceLandmarksHistory.length < 3) {
+                return { isPhoto: false, confidence: 0, details: {} };
+            }
+            // 【核心检测1】平面单应性约束检测（最可靠，纯2D几何）
+            const homographyResult = this.detectHomographyConstraint();
+            // 【核心检测2】特征点相对位置变化模式（照片遵循透视变换规律）
+            const perspectivePattern = this.detectPerspectiveTransformPattern();
+            // 【核心检测3】交叉比率不变性检测（射影几何的核心不变量）
+            const crossRatioResult = this.detectCrossRatioInvariance();
+            // 【辅助检测】深度相关（Z坐标是推断的，权重降低）
+            const depthResult = this.detectDepthConsistency();
+            const crossFrameDepth = this.detectCrossFrameDepthPattern();
+            // 综合判定：2D几何约束权重高，Z坐标权重低
+            const photoScore = homographyResult.planarScore * 0.35 + // 单应性约束（最可靠）
+                perspectivePattern.perspectiveScore * 0.30 + // 透视变换模式（可靠）
+                crossRatioResult.invarianceScore * 0.20 + // 交叉比率不变性（可靠）
+                (1 - depthResult.depthVariation) * 0.10 + // 深度（辅助，低权重）
+                crossFrameDepth.planarPattern * 0.05; // 跨帧深度（辅助，低权重）
+            const isPhoto = photoScore > 0.60; // 阈值
+            const confidence = Math.min(photoScore, 1);
+            // 记录历史
+            this.planarityScores.push(photoScore);
+            if (this.planarityScores.length > this.config.frameBufferSize) {
+                this.planarityScores.shift();
+            }
+            console.debug('[PhotoGeometry]', {
+                homography: homographyResult.planarScore.toFixed(3),
+                perspective: perspectivePattern.perspectiveScore.toFixed(3),
+                crossRatio: crossRatioResult.invarianceScore.toFixed(3),
+                depthVariation: depthResult.depthVariation.toFixed(3),
+                crossFrame: crossFrameDepth.planarPattern.toFixed(3),
+                photoScore: photoScore.toFixed(3),
+                isPhoto
+            });
+            return {
+                isPhoto,
+                confidence,
+                details: {
+                    homographyScore: homographyResult.planarScore,
+                    perspectiveScore: perspectivePattern.perspectiveScore,
+                    crossRatioScore: crossRatioResult.invarianceScore,
+                    depthVariation: depthResult.depthVariation,
+                    crossFramePattern: crossFrameDepth.planarPattern
+                }
+            };
         }
         /**
-         * 基于嘴巴宽高比变化计算嘴巴运动评分
+         * 【新增核心检测】交叉比率不变性检测
+         *
+         * 原理（射影几何的基本定理）：
+         * - 平面上共线4点的【交叉比率】在透视变换下保持不变
+         * - 真实3D人脸旋转时，面部各点不共面，交叉比率会变化
+         * - 照片无论怎么偏转，共线点的交叉比率保持不变
+         *
+         * 这是纯2D几何检测，非常可靠！
          */
-        calculateMouthMotionScore() {
-            if (this.mouthAspectRatioHistory.length < 2) {
-                return 0;
+        /**
+         * 【交叉比率不变性检测】
+         *
+         * 原理（射影几何的基本定理）：
+         * - 平面上共线4点的【交叉比率】在透视变换下保持不变
+         * - 真实3D人脸旋转时，面部各点不共面，交叉比率会变化
+         * - 照片无论怎么偏转，共线点的交叉比率保持不变
+         *
+         * 【注意】交叉比率本身是比率，不依赖绝对坐标
+         * 使用归一化坐标只是为了一致性
+         */
+        detectCrossRatioInvariance() {
+            // 【使用归一化坐标历史，保持一致性】
+            if (this.normalizedLandmarksHistory.length < 3) {
+                return { invarianceScore: 0 };
+            }
+            // 选择面部中线上近似共线的点（额头-鼻梁-鼻尖-嘴-下巴）
+            const midlinePoints = [10, 168, 1, 0, 152]; // 从上到下
+            const crossRatios = [];
+            for (const frame of this.normalizedLandmarksHistory) {
+                if (frame.length < 468)
+                    continue;
+                // 提取中线点的Y坐标（它们大致在一条垂直线上）
+                const yCoords = [];
+                for (const idx of midlinePoints) {
+                    if (frame[idx]) {
+                        yCoords.push(frame[idx][1]);
+                    }
+                }
+                if (yCoords.length >= 4) {
+                    // 计算交叉比率 CR(A,B,C,D) = (AC * BD) / (BC * AD)
+                    const a = yCoords[0], b = yCoords[1], c = yCoords[2], d = yCoords[3];
+                    const ac = Math.abs(c - a);
+                    const bd = Math.abs(d - b);
+                    const bc = Math.abs(c - b);
+                    const ad = Math.abs(d - a);
+                    if (bc > 0.001 && ad > 0.001) {
+                        const cr = (ac * bd) / (bc * ad);
+                        crossRatios.push(cr);
+                    }
+                }
             }
-            const variance = this.calculateVariance(this.mouthAspectRatioHistory);
-            // 归一化：嘴巴运动的预期方差约为 0.02
-            return Math.min(variance / 0.02, 1);
+            if (crossRatios.length < 2) {
+                return { invarianceScore: 0 };
+            }
+            // 计算交叉比率的变异系数
+            // 照片：交叉比率应该几乎不变（变异系数小）
+            // 真人：交叉比率会变化（变异系数大）
+            const mean = crossRatios.reduce((a, b) => a + b, 0) / crossRatios.length;
+            const stdDev = this.calculateStdDev(crossRatios);
+            const cv = mean > 0.001 ? stdDev / mean : 0;
+            // 变异系数越小，越可能是平面（照片）
+            // cv < 0.05 → 非常稳定（照片）
+            // cv > 0.15 → 变化明显（真人）
+            const invarianceScore = Math.max(0, 1 - cv / 0.1);
+            console.debug('[CrossRatio]', {
+                mean: mean.toFixed(4),
+                stdDev: stdDev.toFixed(4),
+                cv: cv.toFixed(4),
+                invarianceScore: invarianceScore.toFixed(3)
+            });
+            return { invarianceScore: Math.min(invarianceScore, 1), cv };
         }
         /**
-         * 计算人脸区域方差
+         * 【关键】检测单应性变换约束
+         *
+         * 原理：
+         * - 平面物体（照片）在不同视角下的投影满足 H * p1 = p2（H是3x3单应性矩阵）
+         * - 3D物体不满足这个约束，会有残差误差
+         *
+         * 方法：用4对点计算H，然后检验其他点是否符合H变换
          */
-        calculateFaceAreaVariance() {
-            return this.calculateVariance(this.faceAreaHistory);
+        /**
+         * 【单应性约束检测】判断多帧特征点是否满足平面约束
+         *
+         * 【重要修复】使用归一化坐标进行比较
+         * 这是纯 2D 几何检测，最可靠！
+         */
+        detectHomographyConstraint() {
+            // 【关键】使用归一化坐标历史
+            if (this.normalizedLandmarksHistory.length < 2) {
+                return { planarScore: 0, error: 0 };
+            }
+            const frame1 = this.normalizedLandmarksHistory[0];
+            const frame2 = this.normalizedLandmarksHistory[this.normalizedLandmarksHistory.length - 1];
+            if (frame1.length < 468 || frame2.length < 468) {
+                return { planarScore: 0, error: 0 };
+            }
+            // 选择用于计算单应性的4个基准点（面部四角）
+            const basePoints = [10, 152, 234, 454]; // 额头、下巴、左脸颊、右脸颊
+            // 选择用于验证的检验点
+            const testPoints = [33, 263, 61, 291, 1, 168]; // 眼角、嘴角、鼻尖、鼻梁
+            // 提取基准点坐标（归一化后的坐标）
+            const srcBase = [];
+            const dstBase = [];
+            for (const idx of basePoints) {
+                if (frame1[idx] && frame2[idx]) {
+                    srcBase.push([frame1[idx][0], frame1[idx][1]]);
+                    dstBase.push([frame2[idx][0], frame2[idx][1]]);
+                }
+            }
+            if (srcBase.length < 4) {
+                return { planarScore: 0, error: 0 };
+            }
+            // 计算简化的仿射变换（近似单应性）
+            // 使用最小二乘法拟合仿射变换 [a, b, c; d, e, f] 
+            const transform = this.estimateAffineTransform(srcBase, dstBase);
+            if (!transform) {
+                return { planarScore: 0, error: 0 };
+            }
+            // 用仿射变换预测检验点位置，计算误差
+            let totalError = 0;
+            let validPoints = 0;
+            for (const idx of testPoints) {
+                if (frame1[idx] && frame2[idx]) {
+                    const predicted = this.applyAffineTransform(transform, frame1[idx][0], frame1[idx][1]);
+                    const actual = [frame2[idx][0], frame2[idx][1]];
+                    // 归一化坐标下的误差（相对于人脸尺寸的比例）
+                    const error = Math.sqrt((predicted[0] - actual[0]) ** 2 + (predicted[1] - actual[1]) ** 2);
+                    totalError += error;
+                    validPoints++;
+                }
+            }
+            if (validPoints === 0) {
+                return { planarScore: 0, error: 0 };
+            }
+            const avgError = totalError / validPoints;
+            // 归一化坐标下，误差已经是相对于人脸尺寸的比例
+            // 不需要再除以脸宽
+            const relativeError = avgError;
+            // 平面得分：误差越小，越可能是平面（照片）
+            // relativeError < 0.02 → 非常可能是平面
+            // relativeError > 0.08 → 不太可能是平面
+            const planarScore = Math.max(0, 1 - relativeError / 0.05);
+            // 记录误差历史
+            this.homographyErrors.push(relativeError);
+            if (this.homographyErrors.length > this.config.frameBufferSize) {
+                this.homographyErrors.shift();
+            }
+            return { planarScore: Math.min(planarScore, 1), error: relativeError };
+        }
+        /**
+         * 估计仿射变换矩阵 (简化的单应性)
+         * 输入：源点和目标点对
+         * 输出：[a, b, c, d, e, f] 表示变换 x' = ax + by + c, y' = dx + ey + f
+         */
+        estimateAffineTransform(src, dst) {
+            if (src.length < 3 || dst.length < 3)
+                return null;
+            const n = Math.min(src.length, dst.length);
+            // 构建方程组 Ax = b (最小二乘)
+            // 对于 x': [x1, y1, 1, 0, 0, 0] * [a,b,c,d,e,f]^T = x1'
+            // 对于 y': [0, 0, 0, x1, y1, 1] * [a,b,c,d,e,f]^T = y1'
+            let sumX = 0, sumY = 0, sumX2 = 0, sumY2 = 0;
+            let sumXpX = 0, sumYpY = 0, sumXp = 0, sumYp = 0;
+            for (let i = 0; i < n; i++) {
+                const x = src[i][0], y = src[i][1];
+                const xp = dst[i][0], yp = dst[i][1];
+                sumX += x;
+                sumY += y;
+                sumX2 += x * x;
+                sumY2 += y * y;
+                sumXpX += xp * x;
+                sumXp += xp;
+                sumYpY += yp * y;
+                sumYp += yp;
+            }
+            // 计算缩放和旋转（简化版本）
+            const det = sumX2 * n - sumX * sumX;
+            if (Math.abs(det) < 0.0001)
+                return null;
+            const a = (sumXpX * n - sumXp * sumX) / (sumX2 * n - sumX * sumX + 0.0001);
+            const b = 0; // 简化，忽略剪切
+            const d = 0;
+            const e = (sumYpY * n - sumYp * sumY) / (sumY2 * n - sumY * sumY + 0.0001);
+            const c = sumXp / n - a * sumX / n;
+            const f = sumYp / n - e * sumY / n;
+            return [a || 1, b, c || 0, d, e || 1, f || 0];
         }
         /**
-         * 计算人脸区域的变化率 - 用于检测呼吸或其他微妙运动
-         * 活体在呼吸或说话时，面部区域会有微小的周期性变化
-         * 照片：变化很小或波动随机
+         * 应用仿射变换
          */
-        calculateFaceAreaChangeRate() {
-            if (this.faceAreaHistory.length < 2) {
-                return 0;
-            }
-            const areas = this.faceAreaHistory;
-            const changes = [];
-            // 计算相邻帧之间的面积变化率
-            for (let i = 1; i < areas.length; i++) {
-                if (areas[i - 1] === 0)
-                    continue;
-                const changeRate = Math.abs((areas[i] - areas[i - 1]) / areas[i - 1]);
-                changes.push(changeRate);
-            }
-            if (changes.length === 0) {
-                return 0;
-            }
-            // 返回平均变化率（转换为百分比形式，范围 0-1）
-            const avgChangeRate = changes.reduce((a, b) => a + b, 0) / changes.length;
-            return Math.min(avgChangeRate * 100, 1);
+        applyAffineTransform(t, x, y) {
+            return [
+                t[0] * x + t[1] * y + t[2],
+                t[3] * x + t[4] * y + t[5]
+            ];
         }
         /**
-         * 计算数字数组的方差
-         */
-        calculateVariance(values) {
-            if (values.length < 2) {
-                return 0;
+         * 【关键】检测深度一致性
+         *
+         * 原理：
+         * - 真实人脸：鼻子Z坐标明显大于眼睛和脸颊（凸出）
+         * - 照片：所有点Z坐标接近相同（平面）
+         */
+        detectDepthConsistency() {
+            const latestFrame = this.faceLandmarksHistory[this.faceLandmarksHistory.length - 1];
+            if (!latestFrame || latestFrame.length < 468) {
+                return { depthVariation: 0.5, isFlat: false };
+            }
+            // 采样不同深度区域的点
+            const nosePoints = [1, 4, 5, 6]; // 鼻子（应该凸出）
+            const eyePoints = [33, 133, 263, 362]; // 眼睛（应该凹陷）
+            const cheekPoints = [234, 454, 50, 280]; // 脸颊（中间深度）
+            const foreheadPoints = [10, 67, 297]; // 额头
+            const getAvgZ = (points) => {
+                let sum = 0, count = 0;
+                for (const idx of points) {
+                    if (latestFrame[idx] && latestFrame[idx].length >= 3) {
+                        sum += latestFrame[idx][2];
+                        count++;
+                    }
+                }
+                return count > 0 ? sum / count : 0;
+            };
+            const noseZ = getAvgZ(nosePoints);
+            const eyeZ = getAvgZ(eyePoints);
+            const cheekZ = getAvgZ(cheekPoints);
+            const foreheadZ = getAvgZ(foreheadPoints);
+            // 计算深度差异
+            const allZ = [noseZ, eyeZ, cheekZ, foreheadZ].filter(z => z !== 0);
+            if (allZ.length < 3) {
+                return { depthVariation: 0.5, isFlat: false };
+            }
+            const zMean = allZ.reduce((a, b) => a + b, 0) / allZ.length;
+            const zStdDev = Math.sqrt(allZ.reduce((sum, z) => sum + (z - zMean) ** 2, 0) / allZ.length);
+            // 深度变异系数
+            const depthVariation = zMean !== 0 ? Math.abs(zStdDev / zMean) : 0;
+            // 检查深度关系是否符合真实人脸
+            // 真实人脸：鼻子应该比眼睛更接近摄像头（Z更小，因为Z表示深度/距离）
+            // 注意：MediaPipe的Z坐标是负值，越接近0表示越近
+            const noseCloser = noseZ > eyeZ; // 鼻子更近
+            // 记录历史
+            this.depthConsistencyScores.push(depthVariation);
+            if (this.depthConsistencyScores.length > this.config.frameBufferSize) {
+                this.depthConsistencyScores.shift();
             }
-            const mean = values.reduce((a, b) => a + b, 0) / values.length;
-            const variance = values.reduce((a, v) => a + (v - mean) ** 2, 0) / values.length;
-            return Math.sqrt(variance);
+            return {
+                depthVariation,
+                isFlat: depthVariation < 0.1, // 深度变异很小 → 平面（照片）
+                noseCloser,
+                details: { noseZ, eyeZ, cheekZ, foreheadZ }
+            };
         }
         /**
-         * 基于分析检测运动类型
-         */
-        detectMotionType(opticalFlow, keypointVariance) {
-            if (keypointVariance < 0.01 && opticalFlow < 0.1) {
-                return 'none';
-            }
-            if (keypointVariance > opticalFlow * 2) {
-                // 关键点运动多于光流表明旋转或表情变化
-                if (this.eyeAspectRatioHistory.length >= 2 &&
-                    this.calculateVariance(this.eyeAspectRatioHistory) > this.config.eyeAspectRatioThreshold) {
-                    return 'micro_expression';
+         * 【关键】检测跨帧深度模式
+         *
+         * 原理：
+         * - 照片旋转时：所有点的深度变化遵循平面投影规律（线性关系）
+         * - 真实人脸旋转时：不同部位的深度变化不成线性关系
+         */
+        detectCrossFrameDepthPattern() {
+            if (this.faceLandmarksHistory.length < 3) {
+                return { planarPattern: 0 };
+            }
+            // 比较多帧的深度变化模式
+            const samplePoints = [1, 33, 263, 61, 291]; // 鼻尖、眼角、嘴角
+            const depthChanges = [];
+            for (let i = 1; i < this.faceLandmarksHistory.length; i++) {
+                const prev = this.faceLandmarksHistory[i - 1];
+                const curr = this.faceLandmarksHistory[i];
+                const changes = [];
+                for (const idx of samplePoints) {
+                    if (prev[idx]?.length >= 3 && curr[idx]?.length >= 3) {
+                        changes.push(curr[idx][2] - prev[idx][2]);
+                    }
+                }
+                if (changes.length >= 3) {
+                    depthChanges.push(changes);
                 }
-                return 'rotation';
             }
-            if (opticalFlow > keypointVariance * 2) {
-                return 'translation';
+            if (depthChanges.length < 2) {
+                return { planarPattern: 0 };
             }
-            // 呼吸运动：一致的小变化
-            if (this.faceAreaHistory.length >= 2 &&
-                this.calculateVariance(this.faceAreaHistory) > 0.001) {
-                return 'breathing';
+            // 检测深度变化的一致性（平面特征：所有点同方向变化）
+            let consistentFrames = 0;
+            for (const changes of depthChanges) {
+                const signs = changes.map(c => Math.sign(c));
+                const allSame = signs.every(s => s === signs[0]) || signs.every(s => Math.abs(changes[signs.indexOf(s)]) < 0.001);
+                if (allSame)
+                    consistentFrames++;
             }
-            return 'micro_expression';
+            const planarPattern = consistentFrames / depthChanges.length;
+            return { planarPattern };
         }
         /**
-         * 从多个来源计算总体运动评分
-         * 针对照片攻击进行优化：提高光流和关键点方差的权重
+         * 【关键】检测透视变换模式
+         *
+         * 原理：
+         * - 照片偏转时，特征点位置变化遵循严格的透视变换规律
+         * - 检测左右脸的相对变化是否符合透视投影
          */
-        calculateOverallMotionScore(opticalFlow, keypointVariance, eyeMotion, mouthMotion, motionConsistency) {
-            // 针对照片防护的优化权重：
-            // - 光流权重提高至 0.45（照片特征是零光流）
-            // - 关键点方差权重保持较高 0.35（照片完全静止）
-            // - 运动一致性权重 0.1（防止微动假正）
-            // - 眼睛和嘴巴运动权重降低 0.05 + 0.05
-            const weights = {
-                opticalFlow: 0.45,
-                keypointVariance: 0.35,
-                motionConsistency: 0.1,
-                eyeMotion: 0.05,
-                mouthMotion: 0.05
-            };
-            // 严格模式：进一步提高光流权重
-            if (this.config.strictPhotoDetection) {
-                weights.opticalFlow = 0.55;
-                weights.keypointVariance = 0.3;
-                weights.motionConsistency = 0.15;
-                weights.eyeMotion = 0;
-                weights.mouthMotion = 0;
-            }
-            return (opticalFlow * weights.opticalFlow +
-                keypointVariance * weights.keypointVariance +
-                motionConsistency * weights.motionConsistency +
-                eyeMotion * weights.eyeMotion +
-                mouthMotion * weights.mouthMotion);
-        }
         /**
-         * 根据运动分析确定面部是否活跃
-         * 【针对5帧场景优化】：改为"多数票"制，使用6个独立指标
+         * 【透视变换模式检测】
          *
-         * 6个检测指标（互相独立）：
-         * 1. 关键点变化 - 照片无法改变关键点位置
-         * 2. 光流幅度 - 照片产生的光流极低
-         * 3. 运动类型 - 照片只能是'none'
-         * 4. 眼睛运动（眨眼）- 照片眼睛无法眨动
-         * 5. 嘴巴运动 - 照片嘴巴完全静止
-         * 6. 面部区域变化 - 照片无法产生呼吸迹象
+         * 【重要修复】使用归一化坐标进行比较
          *
-         * 判决规则：
-         * - 数据充足（>= 5帧）：需要至少2个指标支持才判定为活体
-         * - 数据不足（< 5帧）：需要至少3个指标支持
-         */
-        determineLiveness(keypointVariance, motionType, opticalFlow, eyeMotionScore, mouthMotionScore, faceAreaChangeRate) {
-            // 【改进】：使用"多数票"制而非串联AND逻辑
-            // 这样可以识别不同类型的真实运动
-            // - 头部旋转：关键点变化明显，光流可能不足
-            // - 说话/微笑：嘴巴运动明显，整体光流不足
-            // - 眨眼：眼睛运动明显
-            // - 呼吸：面部区域规律变化
-            // - 眨眼+头动：多个弱指标组合
-            let livelyVotes = 0;
-            const isDataSufficient = this.frameBuffer.length >= this.config.frameBufferSize;
-            const requiredVotes = isDataSufficient ? 2 : 3; // 数据不足时更严格
-            // 指标1：关键点变化 + 光流一致性
-            // 防御：照片旋转也会改变关键点位置，但光流会极低
-            // 真实旋转：关键点变化 + 有意义的光流
-            // 照片旋转：关键点变化 + 极低光流（< 0.02）
-            if (keypointVariance > 0.01 && opticalFlow > 0.02) {
-                // 关键点变化 + 中等光流 = 真实活体运动
-                livelyVotes++;
-            }
-            // 指标2：光流幅度（照片的明显弱点）
-            // 照片几乎无法产生光流
-            if (opticalFlow > 0.03) {
-                livelyVotes++;
-            }
-            // 指标3：运动类型 + 光流双重确认
-            // 防御：照片旋转会被检测为'rotation'，但光流极低
-            // 活体rotation：运动类型是rotation + 有意义的光流
-            // 照片rotation：运动类型是rotation + 极低光流
-            if (motionType !== 'none' && opticalFlow > 0.02) {
-                // 有明确的运动类型 + 足够的光流 = 活体
-                livelyVotes++;
-            }
-            // 指标4：眼睛运动（眨眼）
-            // 照片的眼睛无法眨动，这是活体的明确特征
-            // eyeMotionScore = Math.min(variance / 0.05, 1)
-            // 要检测到眨眼，需要 eyeMotionScore > 0.5
-            if (eyeMotionScore > 0.5) {
-                livelyVotes++;
-            }
-            // 指标5：嘴巴运动
-            // 说话、微笑、张嘴等动作会改变嘴巴宽高比
-            // mouthMotionScore = Math.min(mouthMotionVariance / 0.02, 1)
-            // 要使 mouthMotionVariance > 0.01，需要 mouthMotionScore > 0.5
-            if (mouthMotionScore > 0.5) {
-                livelyVotes++;
-            }
-            // 指标6：面部区域变化
-            // 呼吸或其他微妙运动会导致面部整体面积变化
-            if (faceAreaChangeRate > 0.005) {
-                livelyVotes++;
-            }
-            // 投票结果
-            if (livelyVotes >= requiredVotes) {
-                return true; // 足够多的指标支持，判定为活体
-            }
-            // 投票不足，进行额外严格检查
-            // 如果所有指标都强烈指向照片，则确定判定为非活体
-            if (opticalFlow < 0.02 && motionType === 'none' && keypointVariance < 0.005 && eyeMotionScore < 0.25 && mouthMotionScore < 0.25) {
-                return false; // 绝对确定是照片
-            }
-            // 如果投票数 = 1 但该指标非常强劲，也可以接受
-            if (livelyVotes === 1) {
-                // 关键点变化非常明显 => 活体
-                if (keypointVariance > 0.05) {
-                    return true;
-                }
-                // 眼睛运动非常明显（明显的眨眼） => 活体
-                if (eyeMotionScore > 1.0) {
-                    return true;
-                }
-                // 嘴巴运动非常明显 => 活体
-                if (mouthMotionScore > 1.0) {
-                    return true;
+         * 原理：照片左右偏转时，左右脸宽度比例会平滑变化
+         */
+        detectPerspectiveTransformPattern() {
+            // 【关键】使用归一化坐标历史
+            if (this.normalizedLandmarksHistory.length < 3) {
+                return { perspectiveScore: 0 };
+            }
+            // 比较左右脸的宽度比例变化
+            // 照片左偏时：右脸变窄，左脸变宽（透视效果）
+            // 这种变化应该是平滑且可预测的
+            const widthRatios = [];
+            for (const frame of this.normalizedLandmarksHistory) {
+                if (frame.length >= 468) {
+                    // 使用归一化坐标计算距离比例
+                    const leftWidth = this.pointDist(frame[234], frame[1]); // 左脸到鼻子
+                    const rightWidth = this.pointDist(frame[1], frame[454]); // 鼻子到右脸
+                    if (leftWidth > 0 && rightWidth > 0) {
+                        widthRatios.push(leftWidth / rightWidth);
+                    }
                 }
-                // 光流明显 => 活体
-                if (opticalFlow > 0.08) {
-                    return true;
+            }
+            if (widthRatios.length < 3) {
+                return { perspectiveScore: 0 };
+            }
+            // 照片偏转时，宽度比例变化应该是单调的或周期性的
+            // 计算变化的平滑度
+            let smoothChanges = 0;
+            for (let i = 2; i < widthRatios.length; i++) {
+                const change1 = widthRatios[i - 1] - widthRatios[i - 2];
+                const change2 = widthRatios[i] - widthRatios[i - 1];
+                // 如果变化方向一致或变化很小，则认为是平滑的
+                if (change1 * change2 >= 0 || Math.abs(change1) < 0.02 || Math.abs(change2) < 0.02) {
+                    smoothChanges++;
                 }
             }
-            // 默认判定为非活体
-            return false;
+            const smoothness = smoothChanges / (widthRatios.length - 2);
+            // 平滑的透视变化模式更可能是照片
+            const perspectiveScore = smoothness;
+            return { perspectiveScore };
         }
         /**
-         * 分析失败时创建空结果
-         */
-        createEmptyResult() {
-            return new MotionDetectionResult(0, 0, 0, 0, 0, 'none', true, {
-                frameCount: this.frameBuffer.length,
-                avgKeypointDistance: 0,
-                maxKeypointDistance: 0,
-                faceAreaVariance: 0,
-                eyeAspectRatioVariance: 0,
-                mouthAspectRatioVariance: 0
+         * 综合判定 - 结合正向检测（生物特征）和逆向检测（照片几何）
+         *
+         * 双重策略：
+         * 1. 正向：检测生物微动特征（有 → 活体）
+         * 2. 逆向：检测照片几何约束（满足 → 照片）
+         *
+         * 逆向检测优先级更高，因为照片几何约束是物理定律，无法伪造
+         */
+        makeLivenessDecision(eyeActivity, mouthActivity, muscleActivity, photoGeometry) {
+            if (!this.isReady()) {
+                return true; // 数据不足，默认通过
+            }
+            // ============ 逆向检测（照片几何特征）============
+            // 这是最可靠的检测方式，优先级最高
+            const isPhotoByGeometry = photoGeometry.isPhoto;
+            const photoConfidence = photoGeometry.confidence || 0;
+            // 如果照片几何检测高置信度判定为照片，直接拒绝
+            if (isPhotoByGeometry && photoConfidence > 0.75) {
+                console.debug('[Decision] REJECTED by photo geometry detection', {
+                    photoConfidence: photoConfidence.toFixed(3),
+                    details: photoGeometry.details
+                });
+                return false;
+            }
+            // ============ 正向检测（生物特征）============
+            const hasEyeMovement = eyeActivity.hasMovement;
+            const hasMouthMovement = mouthActivity.hasMovement;
+            const hasMuscleMovement = muscleActivity.hasMovement;
+            const hasBioFeatures = hasEyeMovement || hasMouthMovement || hasMuscleMovement;
+            // 获取其他检测结果
+            const rigidityScore = muscleActivity.rigidityScore || 0;
+            const isPerspectiveAttack = eyeActivity.isPerspectiveAttack || false;
+            const faceShapeStability = this.checkFaceShapeStability();
+            // ============ 综合判定 ============
+            // 
+            // 【决策矩阵】
+            // 
+            // | 照片几何检测 | 生物特征 | 透视攻击 | 判定 |
+            // |-------------|---------|---------|------|
+            // | 是照片(>0.75) | - | - | ❌ 拒绝 |
+            // | 可疑(0.5-0.75) | 有 | 否 | ✅ 通过（生物特征覆盖） |
+            // | 可疑(0.5-0.75) | 无 | - | ❌ 拒绝 |
+            // | 不像照片(<0.5) | 有 | 否 | ✅ 通过 |
+            // | 不像照片(<0.5) | 无 | 是 | ❌ 拒绝 |
+            // | 不像照片(<0.5) | 无 | 否 | ⚠️ 待定（看刚性运动） |
+            let isLively;
+            if (photoConfidence > 0.5) {
+                // 照片可疑度中等以上：需要有明确的生物特征才能通过
+                isLively = hasBioFeatures && !isPerspectiveAttack;
+            }
+            else {
+                // 照片可疑度较低：正常的生物特征检测逻辑
+                const hasRigidMotion = rigidityScore > 0.7;
+                const isPhotoLikely = faceShapeStability > 0.9;
+                isLively =
+                    (hasBioFeatures && !isPerspectiveAttack) ||
+                        (hasRigidMotion && !isPhotoLikely && !isPerspectiveAttack);
+            }
+            console.debug('[Decision]', {
+                // 逆向检测结果
+                photoGeometry: isPhotoByGeometry,
+                photoConfidence: photoConfidence.toFixed(3),
+                // 正向检测结果
+                eye: eyeActivity.score.toFixed(3),
+                mouth: mouthActivity.score.toFixed(3),
+                muscle: muscleActivity.score.toFixed(3),
+                hasBioFeatures,
+                // 其他指标
+                rigidity: rigidityScore.toFixed(3),
+                faceShapeStability: faceShapeStability.toFixed(3),
+                isPerspectiveAttack,
+                // 最终结果
+                isLively
             });
+            return isLively;
         }
         /**
-         * 获取运动检测结果（用于调试）
-         */
-        getStatistics() {
-            return {
-                bufferSize: this.frameBuffer.length,
-                keypointHistorySize: this.keypointHistory.length,
-                faceAreaHistorySize: this.faceAreaHistory.length,
-                eyeAspectRatioHistorySize: this.eyeAspectRatioHistory.length,
-                mouthAspectRatioHistorySize: this.mouthAspectRatioHistory.length,
-                opticalFlowHistorySize: this.opticalFlowHistory.length,
-                pupilSizeHistorySize: this.pupilSizeHistory.length
-            };
-        }
-    }
-
-    /**
-     * 屏幕闪烁检测器
-     *
-     * 核心思路：利用视频帧序列的时间特性
-     * - 屏幕显示内容时有屏幕刷新频率（60/120/144Hz），导致亮度周期性变化
-     * - 真实人脸没有这种周期性闪烁，变化是随机的
-     *
-     * 算法：
-     * 1. 收集N帧视频（15-30帧）
-     * 2. 对每个像素的时间序列计算自相关（autocorrelation）
-     * 3. 如果在某个周期lag发现强自相关 → 存在周期性 → 屏幕闪烁
-     * 4. 统计多少像素检测到周期性，若超过阈值则判定为屏幕
-     */
-    class ScreenFlickerDetector {
-        config;
-        frameCollector;
-        constructor(frameCollector, config) {
-            this.frameCollector = frameCollector;
-            this.config = config;
-            console.log('[ScreenFlicker] Detector initialized with shared FrameCollector');
-        }
-        /**
-         * 获取当前缓冲区中的帧数
-         */
-        getBufferedFrameCount() {
-            return this.frameCollector.getBufferedFrameCount();
-        }
-        /**
-         * 执行闪烁检测分析
-         * 需要至少 maxFlickerPeriodFrames + 1 帧的数据
-         *
-         * 根据实际fps自动调整检测周期范围，以支持不同刷新率的屏幕
-         * 根据分辨率自动调整采样密度和通过率阈值
-         */
-        analyze() {
-            // 获取帧缓冲（从 FrameCollector）
-            const frames = this.frameCollector.getGrayFrames(this.config.bufferSize);
-            // 检查缓冲区是否有足够的帧
-            const minFramesNeeded = this.config.maxFlickerPeriodFrames + 2;
-            if (frames.length < minFramesNeeded) {
-                console.warn(`[ScreenFlicker] Insufficient frames: ${frames.length} < ${minFramesNeeded}`);
-                return {
-                    isScreenCapture: false,
-                    confidence: 0,
-                    passingPixelRatio: 0,
-                    sampledPixelCount: 0,
-                };
-            }
-            const startTime = performance.now();
-            try {
-                // 根据实测fps动态调整检测周期范围
-                const effectiveMaxPeriod = this.getEffectiveMaxPeriod();
-                // 根据分辨率动态调整采样参数
-                const resolutionAdaptation = this.getResolutionAdaptation();
-                // 采样像素位置（使用自适应采样步长）
-                const sampledPixels = this.generateSampledPixels(resolutionAdaptation.effectiveSamplingStride);
-                console.log(`[ScreenFlicker] Analyzing ${sampledPixels.length} sampled pixels`);
-                console.log(`[ScreenFlicker] Resolution: ${this.frameCollector.getFrameWidth()}x${this.frameCollector.getFrameHeight()}, Adaptation: stride=${resolutionAdaptation.effectiveSamplingStride}, passingRatio=${(resolutionAdaptation.effectivePassingRatio * 100).toFixed(0)}%`);
-                console.log(`[ScreenFlicker] Effective period range: 1-${effectiveMaxPeriod} frames (fps: ${this.frameCollector.getAverageFps().toFixed(1)})`);
-                // 对每个采样像素计算自相关
-                const pixelFlickerCounts = new Map(); // lag -> 通过的像素数
-                const correlationValues = [];
-                for (let lag = this.config.minFlickerPeriodFrames; lag <= effectiveMaxPeriod; lag++) {
-                    pixelFlickerCounts.set(lag, 0);
-                }
-                for (const pixelIdx of sampledPixels) {
-                    // 提取该像素在所有帧中的亮度时间序列
-                    const timeSeries = this.extractPixelTimeSeries(pixelIdx, frames);
-                    // 对时间序列计算自相关
-                    const autoCorr = this.computeAutoCorrelation(timeSeries, effectiveMaxPeriod);
-                    // 检查是否在任何周期上有强自相关
-                    for (let lag = this.config.minFlickerPeriodFrames; lag <= effectiveMaxPeriod; lag++) {
-                        if (autoCorr[lag] >= this.config.correlationThreshold) {
-                            const count = pixelFlickerCounts.get(lag) ?? 0;
-                            pixelFlickerCounts.set(lag, count + 1);
-                        }
-                    }
-                }
-                // 找出最强的周期
-                let dominantLag = 0;
-                let maxCount = 0;
-                for (const [lag, count] of pixelFlickerCounts.entries()) {
-                    if (count > maxCount) {
-                        maxCount = count;
-                        dominantLag = lag;
-                    }
-                }
-                const passingPixelRatio = sampledPixels.length > 0 ? maxCount / sampledPixels.length : 0;
-                // 计算置信度
-                const confidence = Math.min(1, passingPixelRatio * 1.5); // 归一化
-                const isScreenCapture = passingPixelRatio >= resolutionAdaptation.effectivePassingRatio;
-                // 根据fps和周期推断屏幕刷新频率
-                let estimatedScreenRefreshRate;
-                if (dominantLag > 0 && this.frameCollector.getAverageFps() > 0) {
-                    // 屏幕刷新频率 = fps / lag
-                    // 例如：60fps视频 + 1帧周期 = 60Hz屏幕
-                    // 例如：60fps视频 + 2帧周期 = 120Hz屏幕
-                    // 例如：30fps视频 + 4帧周期 = 120Hz屏幕
-                    estimatedScreenRefreshRate = this.frameCollector.getAverageFps() / dominantLag;
-                }
-                const analysisTime = performance.now() - startTime;
-                console.log(`[ScreenFlicker] Analysis complete in ${analysisTime.toFixed(1)}ms`);
-                console.log(`[ScreenFlicker] Dominant period: ${dominantLag} frames, Passing pixels: ${(passingPixelRatio * 100).toFixed(1)}%`);
-                if (estimatedScreenRefreshRate) {
-                    console.log(`[ScreenFlicker] Estimated screen refresh rate: ${estimatedScreenRefreshRate.toFixed(0)}Hz`);
-                }
-                console.log(`[ScreenFlicker] Average FPS: ${this.frameCollector.getAverageFps().toFixed(1)}, Confidence: ${confidence.toFixed(3)}, Screen: ${isScreenCapture}`);
-                return {
-                    isScreenCapture,
-                    confidence,
-                    dominantFlickerPeriod: dominantLag > 0 ? dominantLag : undefined,
-                    estimatedScreenRefreshRate: estimatedScreenRefreshRate,
-                    passingPixelRatio,
-                    averageFps: this.frameCollector.getAverageFps() > 0 ? this.frameCollector.getAverageFps() : undefined,
-                    sampledPixelCount: sampledPixels.length,
-                    details: {
-                        correlationValues,
-                        pixelFlickerCounts,
-                    },
-                };
-            }
-            catch (error) {
-                console.error('[ScreenFlicker] Analysis error:', error);
-                return {
-                    isScreenCapture: false,
-                    confidence: 0,
-                    passingPixelRatio: 0,
-                    sampledPixelCount: 0,
-                };
-            }
-        }
-        /**
-         * 重置检测器
-         * 注意：帧缓冲由 FrameCollector 管理
-         */
-        reset() {
-            // 帧缓冲由 FrameCollector 管理，此处无需重置
-            console.log('[ScreenFlicker] Detector state cleared (frames managed by FrameCollector)');
-        }
-        /**
-         * 获取当前平均fps
-         */
-        getAverageFps() {
-            return this.frameCollector.getAverageFps();
-        }
-        /**
-         * 根据实测fps动态调整最大检测周期
-         *
-         * 高fps摄像头 + 高刷屏的周期较短
-         * 低fps摄像头 + 高刷屏的周期较长
-         *
-         * 例如：
-         * - 60fps摄像头：120Hz屏 → 2帧周期 → max=2
-         * - 30fps摄像头：120Hz屏 → 4帧周期 → max=4
-         * - 15fps摄像头：120Hz屏 → 8帧周期 → max=8
-         */
-        getEffectiveMaxPeriod() {
-            // 如果fps尚未稳定，使用配置中的最大值
-            if (this.frameCollector.getAverageFps() < 10) {
-                return this.config.maxFlickerPeriodFrames;
-            }
-            // 根据fps计算合理的最大周期范围
-            let effectiveMax;
-            if (this.frameCollector.getAverageFps() >= 50) {
-                // 高fps摄像头（50+fps）：60Hz屏幕 → 1帧, 120Hz屏幕 → 2-3帧
-                effectiveMax = 3;
-            }
-            else if (this.frameCollector.getAverageFps() >= 30) {
-                // 中等fps摄像头（30-50fps）：60Hz屏幕 → 1-2帧, 120Hz屏幕 → 2-4帧
-                effectiveMax = 4;
-            }
-            else if (this.frameCollector.getAverageFps() >= 15) {
-                // 低fps摄像头（15-30fps）：60Hz屏幕 → 2-4帧, 120Hz屏幕 → 4-8帧
-                effectiveMax = 8;
-            }
-            else {
-                // 极低fps（<15fps）：使用最大值
-                effectiveMax = this.config.maxFlickerPeriodFrames;
-            }
-            // 不超过配置中的上限
-            return Math.min(effectiveMax, this.config.maxFlickerPeriodFrames);
-        }
-        /**
-         * 根据分辨率动态调整采样参数
-         *
-         * 低分辨率时：
-         * - 增加采样密度（减小stride）以获得足够的样本
-         * - 降低通过率阈值以适应噪声影响
-         *
-         * 高分辨率时：
-         * - 可以使用较大的stride来加快处理
-         * - 提高通过率阈值以提高准确性
-         */
-        getResolutionAdaptation() {
-            const totalPixels = this.frameCollector.getFrameWidth() * this.frameCollector.getFrameHeight();
-            const currentStride = this.config.samplingStride;
-            // 估计当前配置下会采样多少像素
-            Math.ceil((this.frameCollector.getFrameWidth() / currentStride) * (this.frameCollector.getFrameHeight() / currentStride));
-            let effectiveStride = currentStride;
-            let effectivePassingRatio = this.config.passingPixelRatio;
-            // 根据像素数调整
-            if (totalPixels < 100000) {
-                // 低分辨率（< 316×316）
-                // 策略：采样所有像素 + 降低通过率阈值
-                effectiveStride = 1;
-                effectivePassingRatio = 0.35; // 从0.40降低到0.35
-                console.log('[ScreenFlicker] Low-res mode: stride=1, passing=35%');
-            }
-            else if (totalPixels < 300000) {
-                // 中低分辨率（316×316 ~ 548×548）
-                // 策略：采样每2个像素 + 略微降低阈值
-                effectiveStride = 2;
-                effectivePassingRatio = 0.38;
-                console.log('[ScreenFlicker] Mid-low-res mode: stride=2, passing=38%');
-            }
-            else if (totalPixels < 900000) {
-                // 中等分辨率（548×548 ~ 949×949）
-                // 策略：标准采样
-                effectiveStride = 2;
-                effectivePassingRatio = 0.40;
-                console.log('[ScreenFlicker] Mid-res mode: stride=2, passing=40%');
-            }
-            else {
-                // 高分辨率（≥949×949，包括1080p）
-                // 策略：降低采样密度 + 提高准确率要求
-                effectiveStride = 3;
-                effectivePassingRatio = 0.42;
-                console.log('[ScreenFlicker] High-res mode: stride=3, passing=42%');
-            }
-            return {
-                effectiveSamplingStride: effectiveStride,
-                effectivePassingRatio: effectivePassingRatio,
-            };
-        }
-        /**
-         * 生成采样像素的索引
-         * @param stride 采样步长（默认使用配置中的值）
-         */
-        generateSampledPixels(stride) {
-            const pixels = [];
-            const effectiveStride = stride ?? this.config.samplingStride;
-            for (let y = 0; y < this.frameCollector.getFrameHeight(); y += effectiveStride) {
-                for (let x = 0; x < this.frameCollector.getFrameWidth(); x += effectiveStride) {
-                    pixels.push(y * this.frameCollector.getFrameWidth() + x);
-                }
-            }
-            console.log(`[ScreenFlicker] Generated ${pixels.length} sampled pixels from ${this.frameCollector.getFrameWidth()}x${this.frameCollector.getFrameHeight()} with stride ${effectiveStride}`);
-            return pixels;
-        }
-        /**
-         * 提取单个像素在所有帧中的亮度时间序列
-         */
-        extractPixelTimeSeries(pixelIdx, frames) {
-            const timeSeries = [];
-            const sourceFrames = frames;
-            for (const frame of sourceFrames) {
-                if (pixelIdx < frame.length) {
-                    timeSeries.push(frame[pixelIdx]);
-                }
-            }
-            return timeSeries;
-        }
-        /**
-         * 计算时间序列的自相关系数
-         * 返回在不同lag值下的相关系数（归一化到0-1）
-         *
-         * @param timeSeries 像素亮度时间序列
-         * @param maxLag 最大检查的lag值
-         */
-        computeAutoCorrelation(timeSeries, maxLag) {
-            const n = timeSeries.length;
-            if (n < 2)
-                return [];
-            // 使用提供的maxLag或者配置中的值
-            const effectiveMaxLag = maxLag ?? this.config.maxFlickerPeriodFrames;
-            // 计算均值
-            let mean = 0;
-            for (const val of timeSeries) {
-                mean += val;
-            }
-            mean /= n;
-            // 计算方差
-            let variance = 0;
-            for (const val of timeSeries) {
-                const diff = val - mean;
-                variance += diff * diff;
-            }
-            variance /= n;
-            if (variance < 1e-6) {
-                // 常数序列，无周期性
-                return [];
-            }
-            // 计算自相关系数
-            const autoCorr = [1.0]; // lag 0 总是1
-            for (let lag = 1; lag <= effectiveMaxLag; lag++) {
-                if (lag >= n)
-                    break;
-                let covariance = 0;
-                for (let i = 0; i < n - lag; i++) {
-                    const diff1 = timeSeries[i] - mean;
-                    const diff2 = timeSeries[i + lag] - mean;
-                    covariance += diff1 * diff2;
-                }
-                covariance /= (n - lag);
-                const correlation = covariance / variance;
-                autoCorr[lag] = Math.max(0, correlation); // 只保留正相关
-            }
-            return autoCorr;
-        }
-    }
-
-    /**
-     * 屏幕响应时间检测器 - 区分墨水屏和LCD/OLED
-     *
-     * 核心原理：
-     * - LCD/OLED: 像素状态变化极快 (<5ms)，直接从0跳到255
-     * - 墨水屏: 像素状态变化缓慢 (200-500ms)，需要多帧逐渐过渡
-     *
-     * 检测方法：
-     * 1. 收集视频帧，跟踪像素值变化
-     * 2. 测量从初始值到最终值需要多少帧
-     * 3. 根据fps计算实际响应时间
-     * 4. 响应时间 > 100ms → 墨水屏
-     */
-    class ScreenResponseTimeDetector {
-        config;
-        frameCollector;
-        constructor(frameCollector, config) {
-            this.frameCollector = frameCollector;
-            this.config = config;
-        }
-        /**
-         * 获取当前缓冲区中的帧数
-         */
-        getBufferedFrameCount() {
-            return this.frameCollector.getBufferedFrameCount();
-        }
-        /**
-         * 执行响应时间检测分析
-         *
-         * 寻找像素值快速变化的情况，测量变化速度
-         * 缓慢变化 → 墨水屏
-         * 快速变化 → LCD/OLED
-         */
-        analyze() {
-            // 获取帧缓冲
-            const frames = this.frameCollector.getGrayFrames(this.config.bufferSize);
-            // 需要足够的帧来测量变化
-            const minFramesNeeded = 10;
-            if (frames.length < minFramesNeeded) {
-                console.warn(`[ResponseTime] Insufficient frames: ${frames.length} < ${minFramesNeeded}`);
-                return {
-                    isScreenCapture: false,
-                    confidence: 0,
-                    passingPixelRatio: 0,
-                    sampledPixelCount: 0,
-                };
-            }
-            const startTime = performance.now();
-            try {
-                // 生成采样像素列表
-                const sampledPixels = this.generateSampledPixels();
-                console.log(`[ResponseTime] Analyzing ${sampledPixels.length} sampled pixels`);
-                console.log(`[ResponseTime] Resolution: ${this.frameCollector.getFrameWidth()}x${this.frameCollector.getFrameHeight()}`);
-                const responseTimes = [];
-                const pixelResponsiveness = new Map();
-                // 对每个采样像素测量响应时间
-                for (const pixelIdx of sampledPixels) {
-                    const responseTime = this.measurePixelResponseTime(pixelIdx, frames);
-                    if (responseTime > 0) {
-                        responseTimes.push(responseTime);
-                        pixelResponsiveness.set(pixelIdx, responseTime);
-                    }
-                }
-                // 统计响应时间
-                if (responseTimes.length === 0) {
-                    console.warn('[ResponseTime] No significant pixel changes detected');
-                    return {
-                        isScreenCapture: false,
-                        confidence: 0,
-                        passingPixelRatio: 0,
-                        sampledPixelCount: sampledPixels.length,
-                    };
-                }
-                // 计算响应时间统计
-                responseTimes.sort((a, b) => a - b);
-                const minResponseTime = responseTimes[0];
-                const maxResponseTime = responseTimes[responseTimes.length - 1];
-                const medianResponseTime = responseTimes[Math.floor(responseTimes.length / 2)];
-                const averageResponseTime = responseTimes.reduce((a, b) => a + b, 0) / responseTimes.length;
-                // 统计缓慢响应的像素比例
-                const slowResponsivePixels = responseTimes.filter(t => t > this.config.einkResponseTimeThreshold).length;
-                const passingPixelRatio = slowResponsivePixels / responseTimes.length;
-                // 判定屏幕类型
-                let estimatedScreenType = 'unknown';
-                let isScreenCapture = false;
-                if (averageResponseTime > this.config.einkResponseTimeThreshold) {
-                    // 响应时间长 → 墨水屏
-                    estimatedScreenType = 'eink';
-                    isScreenCapture = passingPixelRatio >= this.config.passingPixelRatio;
-                }
-                else if (averageResponseTime < 20) {
-                    // 响应时间极短 → LCD/OLED
-                    estimatedScreenType = 'lcd'; // 无法区分LCD和OLED
-                }
-                else {
-                    estimatedScreenType = 'unknown';
-                }
-                // 置信度计算
-                const confidence = Math.min(1, passingPixelRatio * 1.5);
-                const analysisTime = performance.now() - startTime;
-                console.log(`[ResponseTime] Analysis complete in ${analysisTime.toFixed(1)}ms`);
-                console.log(`[ResponseTime] Response times: min=${minResponseTime.toFixed(1)}ms, median=${medianResponseTime.toFixed(1)}ms, max=${maxResponseTime.toFixed(1)}ms, avg=${averageResponseTime.toFixed(1)}ms`);
-                console.log(`[ResponseTime] Slow pixels (>${this.config.einkResponseTimeThreshold}ms): ${(passingPixelRatio * 100).toFixed(1)}%`);
-                console.log(`[ResponseTime] Screen type: ${estimatedScreenType}, Confidence: ${confidence.toFixed(3)}, IsCapture: ${isScreenCapture}`);
-                return {
-                    isScreenCapture,
-                    confidence,
-                    averageResponseTimeMs: averageResponseTime,
-                    maxResponseTimeMs: maxResponseTime,
-                    minResponseTimeMs: minResponseTime,
-                    passingPixelRatio,
-                    sampledPixelCount: responseTimes.length,
-                    estimatedScreenType,
-                    averageFps: this.frameCollector.getAverageFps() > 0 ? this.frameCollector.getAverageFps() : undefined,
-                    details: {
-                        responseTimes,
-                        pixelResponsiveness,
-                    },
-                };
-            }
-            catch (error) {
-                console.error('[ResponseTime] Analysis error:', error);
-                return {
-                    isScreenCapture: false,
-                    confidence: 0,
-                    passingPixelRatio: 0,
-                    sampledPixelCount: 0,
-                };
-            }
-        }
-        /**
-         * 重置检测器
-         * 注意：帧缓冲由 FrameCollector 管理
-         */
-        reset() {
-            // 帧缓冲由 FrameCollector 管理，此处无需重置
-            console.log('[ResponseTime] Detector state cleared (frames managed by FrameCollector)');
-        }
-        /**
-         * 测量单个像素的响应时间
-         *
-         * 跟踪该像素的值变化，找出最大的变化
-         * 计算这个变化需要多少帧（时间）完成
-         */
-        measurePixelResponseTime(pixelIdx, frames) {
-            const sourceFrames = frames;
-            if (sourceFrames.length === 0 || pixelIdx >= sourceFrames[0].length) {
-                return -1;
-            }
-            // 提取像素时间序列
-            const timeSeries = sourceFrames.map((f) => f[pixelIdx]);
-            // 找出最大的像素值变化
-            let maxDelta = 0;
-            let maxDeltaStartFrame = 0;
-            let maxDeltaEndFrame = 0;
-            for (let i = 0; i < timeSeries.length - 1; i++) {
-                const delta = Math.abs(timeSeries[i + 1] - timeSeries[i]);
-                if (delta > maxDelta) {
-                    maxDelta = delta;
-                    maxDeltaStartFrame = i;
-                    maxDeltaEndFrame = i + 1;
-                }
-            }
-            // 如果最大变化太小，忽略
-            if (maxDelta < this.config.minPixelDelta) {
-                return -1;
-            }
-            // 找出完整的变化过程（从开始到结束需要多少帧）
-            const initialValue = timeSeries[maxDeltaStartFrame];
-            const finalValue = timeSeries[maxDeltaEndFrame];
-            const direction = finalValue > initialValue ? 1 : -1;
-            let responseFrameCount = 1;
-            if (direction > 0) {
-                // 上升过程
-                for (let i = maxDeltaStartFrame + 1; i < timeSeries.length; i++) {
-                    if (Math.abs(timeSeries[i] - finalValue) < this.config.minPixelDelta / 2) {
-                        // 到达目标值
-                        responseFrameCount = i - maxDeltaStartFrame;
-                        break;
-                    }
-                }
-            }
-            else {
-                // 下降过程
-                for (let i = maxDeltaStartFrame + 1; i < timeSeries.length; i++) {
-                    if (Math.abs(timeSeries[i] - finalValue) < this.config.minPixelDelta / 2) {
-                        responseFrameCount = i - maxDeltaStartFrame;
-                        break;
-                    }
-                }
-            }
-            // 转换为毫秒
-            const actualFps = this.frameCollector.getAverageFps();
-            const msPerFrame = 1000 / actualFps;
-            const responseTimeMs = responseFrameCount * msPerFrame;
-            return responseTimeMs;
-        }
-        /**
-         * 生成采样像素列表
-         */
-        generateSampledPixels() {
-            const pixels = [];
-            const stride = this.config.samplingStride;
-            for (let y = 0; y < this.frameCollector.getFrameHeight(); y += stride) {
-                for (let x = 0; x < this.frameCollector.getFrameWidth(); x += stride) {
-                    pixels.push(y * this.frameCollector.getFrameWidth() + x);
-                }
-            }
-            console.log(`[ResponseTime] Generated ${pixels.length} sampled pixels from ${this.frameCollector.getFrameWidth()}x${this.frameCollector.getFrameHeight()} with stride ${stride}`);
-            return pixels;
-        }
-    }
-
-    /**
-     * DLP色轮检测器 - 检测DLP投影仪的特有伪影
-     *
-     * 核心原理：
-     * - DLP投影仪使用单色DMD芯片 + RGB色轮
-     * - 色轮以高频率（120-144Hz）轮换RGB颜色
-     * - 摄像头如果不同步捕捉，会看到RGB分离现象
-     *
-     * 特征：
-     * 1. 高对比度边界处出现"彩虹纹"（R左/B右分离）
-     * 2. 快速移动物体边缘有明显的RGB分离
-     * 3. 静止物体通常正常（因为色轮平均后是白色）
-     *
-     * 检测方法：
-     * 1. 找高对比度边界区域
-     * 2. 分析边界处R、G、B通道的位置差异
-     * 3. 如果R领先，B延后 → DLP特征
-     */
-    class DLPColorWheelDetector {
-        config;
-        frameCollector;
-        constructor(frameCollector, config) {
-            this.frameCollector = frameCollector;
-            this.config = config;
-        }
-        /**
-         * 获取当前缓冲区中的帧数
-         */
-        getBufferedFrameCount() {
-            return this.frameCollector.getBufferedFrameCount();
-        }
-        /**
-         * 执行DLP色轮检测分析
-         */
-        analyze() {
-            // 获取BGR帧缓冲（Uint8Array格式）
-            const frames = this.frameCollector.getBgrFrames(this.config.bufferSize).filter((f) => f !== null);
-            const minFramesNeeded = 3; // 至少需要3帧来比较
-            if (frames.length < minFramesNeeded) {
-                console.warn(`[DLPColorWheel] Insufficient frames: ${frames.length} < ${minFramesNeeded}`);
-                return {
-                    isScreenCapture: false,
-                    confidence: 0,
-                    hasColorSeparation: false,
-                    colorSeparationPixels: 0,
-                    sampledEdgePixelCount: 0,
-                };
-            }
-            const startTime = performance.now();
-            try {
-                // 从frameCollector获取帧尺寸
-                const { width: cols, height: rows } = this.frameCollector.getFrameSize();
-                const referenceFrame = frames[0];
-                console.log(`[DLPColorWheel] Analyzing frame size: ${cols}x${rows}`);
-                // 检测高对比度边界
-                const edges = this.detectHighContrastEdges(referenceFrame, rows, cols);
-                console.log(`[DLPColorWheel] Found ${edges.length} edge regions`);
-                if (edges.length === 0) {
-                    console.log('[DLPColorWheel] No significant edges found');
-                    return {
-                        isScreenCapture: false,
-                        confidence: 0,
-                        hasColorSeparation: false,
-                        colorSeparationPixels: 0,
-                        sampledEdgePixelCount: 0,
-                    };
-                }
-                // 分析每条边界的RGB分离
-                const separationDistances = [];
-                let totalRedLead = 0;
-                let totalBlueLag = 0;
-                for (const edge of edges) {
-                    const separation = this.analyzeRGBSeparation(referenceFrame, rows, cols, edge);
-                    if (separation.distance > 0) {
-                        separationDistances.push(separation.distance);
-                        totalRedLead += separation.redLead;
-                        totalBlueLag += separation.blueLag;
-                    }
-                }
-                if (separationDistances.length === 0) {
-                    return {
-                        isScreenCapture: false,
-                        confidence: 0,
-                        hasColorSeparation: false,
-                        colorSeparationPixels: 0,
-                        sampledEdgePixelCount: edges.length,
-                    };
-                }
-                // 计算统计信息
-                const avgSeparation = separationDistances.reduce((a, b) => a + b, 0) / separationDistances.length;
-                const avgRedLead = totalRedLead / separationDistances.length;
-                const avgBlueLag = totalBlueLag / separationDistances.length;
-                // 判定DLP特征
-                const hasRGBSeparation = avgSeparation >= this.config.minChannelSeparationPixels;
-                const hasTypicalDLPPattern = avgRedLead > 1 && avgBlueLag < -1; // R领先，B延后
-                // 置信度计算
-                let confidence = 0;
-                if (hasTypicalDLPPattern) {
-                    // DLP特有特征：R领先 + B延后
-                    confidence = Math.min(1, (Math.abs(avgRedLead) + Math.abs(avgBlueLag)) / 5); // 归一化
-                }
-                else if (hasRGBSeparation) {
-                    // 有RGB分离但不是典型DLP模式
-                    confidence = avgSeparation / 10 * 0.5;
-                }
-                const isScreenCapture = confidence > this.config.separationConfidenceThreshold;
-                // 推断色轮频率（如果有标准的周期）
-                let estimatedFrequency;
-                if (hasTypicalDLPPattern) {
-                    // DLP色轮通常是刷新率的3倍（RGB轮换）
-                    // 60Hz刷新 → 180Hz色轮
-                    // 但我们无法直接测量，这里留作占位符
-                    estimatedFrequency = undefined;
-                }
-                const analysisTime = performance.now() - startTime;
-                console.log(`[DLPColorWheel] Analysis complete in ${analysisTime.toFixed(1)}ms`);
-                console.log(`[DLPColorWheel] RGB Separation: avg=${avgSeparation.toFixed(2)}px, R-lead=${avgRedLead.toFixed(2)}px, B-lag=${avgBlueLag.toFixed(2)}px`);
-                console.log(`[DLPColorWheel] DLP Pattern: ${hasTypicalDLPPattern}, Confidence: ${confidence.toFixed(3)}, IsCapture: ${isScreenCapture}`);
-                return {
-                    isScreenCapture,
-                    confidence,
-                    hasColorSeparation: hasRGBSeparation,
-                    colorSeparationPixels: avgSeparation,
-                    redLeadPixels: avgRedLead,
-                    blueDelayPixels: avgBlueLag,
-                    sampledEdgePixelCount: separationDistances.length,
-                    estimatedColorWheelFrequency: estimatedFrequency,
-                    details: {
-                        edgeLocations: edges,
-                        separationDistances,
-                    },
-                };
-            }
-            catch (error) {
-                console.error('[DLPColorWheel] Analysis error:', error);
-                return {
-                    isScreenCapture: false,
-                    confidence: 0,
-                    hasColorSeparation: false,
-                    colorSeparationPixels: 0,
-                    sampledEdgePixelCount: 0,
-                };
-            }
-        }
-        /**
-         * 重置检测器
-         * 注意：帧缓冲由 FrameCollector 管理
-         */
-        reset() {
-            // 帧缓冲由 FrameCollector 管理，此处无需重置
-            console.log('[DLPColorWheel] Detector state cleared (frames managed by FrameCollector)');
-        }
-        /**
-         * 检测高对比度边界
-         * 返回边界的x坐标位置
-         */
-        detectHighContrastEdges(bgrData, rows, cols) {
-            const edges = [];
-            try {
-                // BGR数据，每像素3个字节
-                const stride = this.config.samplingStride;
-                for (let y = stride; y < rows - stride; y += stride) {
-                    for (let x = stride; x < cols - stride; x += stride) {
-                        // 转换为灰度值进行边界检测
-                        const centerIdx = (y * cols + x) * 3;
-                        const leftIdx = (y * cols + (x - stride)) * 3;
-                        const rightIdx = (y * cols + (x + stride)) * 3;
-                        // 计算灰度值：0.299*R + 0.587*G + 0.114*B
-                        const centerGray = Math.round(0.299 * bgrData[centerIdx + 2] + 0.587 * bgrData[centerIdx + 1] + 0.114 * bgrData[centerIdx]);
-                        const leftGray = Math.round(0.299 * bgrData[leftIdx + 2] + 0.587 * bgrData[leftIdx + 1] + 0.114 * bgrData[leftIdx]);
-                        const rightGray = Math.round(0.299 * bgrData[rightIdx + 2] + 0.587 * bgrData[rightIdx + 1] + 0.114 * bgrData[rightIdx]);
-                        // 检测水平边界
-                        const leftDiff = Math.abs(centerGray - leftGray);
-                        const rightDiff = Math.abs(centerGray - rightGray);
-                        if (leftDiff > this.config.edgeThreshold || rightDiff > this.config.edgeThreshold) {
-                            edges.push(x); // 记录边界x坐标
-                        }
-                    }
-                }
-            }
-            catch (error) {
-                console.error('[DLPColorWheel] Edge detection error:', error);
-            }
-            return edges;
-        }
-        /**
-         * 分析单条边界的RGB分离
-         *
-         * DLP特征：
-         * - R通道的边界比G靠前（向左）
-         * - B通道的边界比G靠后（向右）
-         */
-        analyzeRGBSeparation(bgrData, rows, cols, edgeX) {
-            try {
-                // 提取边界附近的RGB数据
-                const windowSize = 10; // 边界左右各10像素
-                const startX = Math.max(0, edgeX - windowSize);
-                const endX = Math.min(cols, edgeX + windowSize);
-                // 计算各通道的亮度变化（边界处的导数）
-                const rDerivatives = [];
-                const gDerivatives = [];
-                const bDerivatives = [];
-                const centerY = Math.floor(rows / 2); // 使用中间行
-                const rowOffset = centerY * cols * 3; // BGR每像素3个字节
-                for (let x = startX + 1; x < endX; x++) {
-                    const idx0 = rowOffset + (x - 1) * 3;
-                    const idx1 = rowOffset + x * 3;
-                    // BGR顺序
-                    const b0 = bgrData[idx0];
-                    const g0 = bgrData[idx0 + 1];
-                    const r0 = bgrData[idx0 + 2];
-                    const b1 = bgrData[idx1];
-                    const g1 = bgrData[idx1 + 1];
-                    const r1 = bgrData[idx1 + 2];
-                    rDerivatives.push(r1 - r0);
-                    gDerivatives.push(g1 - g0);
-                    bDerivatives.push(b1 - b0);
-                }
-                // 找最大导数位置（边界位置）
-                const rEdge = this.findPeakPosition(rDerivatives);
-                const gEdge = this.findPeakPosition(gDerivatives);
-                const bEdge = this.findPeakPosition(bDerivatives);
-                // 计算相位差
-                const redLead = rEdge - gEdge; // 正值表示R在G之前
-                const blueLag = bEdge - gEdge; // 负值表示B在G之后
-                const totalSeparation = Math.abs(redLead - blueLag);
-                return {
-                    distance: totalSeparation,
-                    redLead,
-                    blueLag,
-                };
-            }
-            catch (error) {
-                console.error('[DLPColorWheel] RGB separation analysis error:', error);
-                return { distance: 0, redLead: 0, blueLag: 0 };
-            }
-        }
-        /**
-         * 找导数数组中的峰值位置
-         */
-        findPeakPosition(derivatives) {
-            if (derivatives.length === 0)
-                return 0;
-            let maxDerivative = -Infinity;
-            let peakPos = 0;
-            for (let i = 0; i < derivatives.length; i++) {
-                const absDeriv = Math.abs(derivatives[i]);
-                if (absDeriv > maxDerivative) {
-                    maxDerivative = absDeriv;
-                    peakPos = i;
-                }
-            }
-            return peakPos;
-        }
-    }
-
-    /**
-     * 光学畸变检测器 - 检测投影仪和其他光学系统的特有伪影
-     *
-     * 核心原理：
-     * - 投影仪通过光学透镜将图像投射到屏幕上
-     * - 光学系统导致多种失真：梯形失真、桶形/枕形失真、模糊
-     * - 真实人脸直接摄像，无这些光学失真
-     *
-     * 检测特征：
-     * 1. 梯形失真（Keystone）- 图像上下边宽度不同
-     * 2. 桶形/枕形失真 - 直线边缘弯曲
-     * 3. 光学模糊 - 边界清晰度在视场中不均匀
-     * 4. 色差（Chromatic Aberration）- RGB通道空间分离
-     * 5. 暗角（Vignetting）- 四角暗化
-     */
-    class OpticalDistortionDetector {
-        config;
-        frameCollector;
-        constructor(frameCollector, config) {
-            this.frameCollector = frameCollector;
-            // 初始化帧尺寸
-            frameCollector.getFrameSize();
-            this.config = config;
-            console.log('[OpticalDistortion] Detector initialized with shared FrameCollector');
-        }
-        /**
-         * 获取当前缓冲区中的帧数
-         */
-        getBufferedFrameCount() {
-            return this.frameCollector.getBufferedFrameCount();
-        }
-        /**
-         * 执行光学畸变检测分析
-         */
-        analyze() {
-            // 获取帧缓冲（从 FrameCollector）
-            const frames = this.frameCollector.getGrayFrames(this.config.bufferSize);
-            const minFramesNeeded = 1;
-            if (frames.length < minFramesNeeded) {
-                console.warn(`[OpticalDistortion] Insufficient frames: ${frames.length}`);
-                return {
-                    isScreenCapture: false,
-                    confidence: 0,
-                    distortionFeatures: {
-                        keystoneDetected: false,
-                        keystoneLevel: 0,
-                        barrelDistortionDetected: false,
-                        barrelDistortionLevel: 0,
-                        chromaticAberrationDetected: false,
-                        chromaticAberrationLevel: 0,
-                        vignetteDetected: false,
-                        vignetteLevel: 0,
-                    },
-                    overallOpticalDistortionScore: 0,
-                };
-            }
-            const startTime = performance.now();
-            try {
-                const referenceFrame = frames[0];
-                console.log(`[OpticalDistortion] Analyzing ${this.frameCollector.getFrameWidth()}x${this.frameCollector.getFrameHeight()}`);
-                // 检测各个光学失真特征
-                const keystoneResult = this.detectKeystone(referenceFrame);
-                const barrelResult = this.detectBarrelDistortion(referenceFrame);
-                const chromaticResult = this.detectChromaticAberration(referenceFrame);
-                const vignetteResult = this.detectVignette(referenceFrame);
-                // 综合评分
-                const compositeScore = keystoneResult.level * this.config.featureWeights.keystone +
-                    barrelResult.level * this.config.featureWeights.barrelDistortion +
-                    chromaticResult.level * this.config.featureWeights.chromaticAberration +
-                    vignetteResult.level * this.config.featureWeights.vignette;
-                const isScreenCapture = compositeScore > 0.35; // 任何明显的光学失真都可能表示投影
-                const analysisTime = performance.now() - startTime;
-                console.log(`[OpticalDistortion] Analysis complete in ${analysisTime.toFixed(1)}ms`);
-                console.log(`[OpticalDistortion] Keystone: ${keystoneResult.level.toFixed(3)}, Barrel: ${barrelResult.level.toFixed(3)}, Chromatic: ${chromaticResult.level.toFixed(3)}, Vignette: ${vignetteResult.level.toFixed(3)}`);
-                console.log(`[OpticalDistortion] Composite score: ${compositeScore.toFixed(3)}, IsCapture: ${isScreenCapture}`);
-                return {
-                    isScreenCapture,
-                    confidence: Math.min(1, compositeScore),
-                    distortionFeatures: {
-                        keystoneDetected: keystoneResult.detected,
-                        keystoneLevel: keystoneResult.level,
-                        barrelDistortionDetected: barrelResult.detected,
-                        barrelDistortionLevel: barrelResult.level,
-                        chromaticAberrationDetected: chromaticResult.detected,
-                        chromaticAberrationLevel: chromaticResult.level,
-                        vignetteDetected: vignetteResult.detected,
-                        vignetteLevel: vignetteResult.level,
-                    },
-                    overallOpticalDistortionScore: compositeScore,
-                    estimatedProjectorType: this.inferProjectorType(keystoneResult, barrelResult, chromaticResult, vignetteResult),
-                };
-            }
-            catch (error) {
-                console.error('[OpticalDistortion] Analysis error:', error);
-                return {
-                    isScreenCapture: false,
-                    confidence: 0,
-                    distortionFeatures: {
-                        keystoneDetected: false,
-                        keystoneLevel: 0,
-                        barrelDistortionDetected: false,
-                        barrelDistortionLevel: 0,
-                        chromaticAberrationDetected: false,
-                        chromaticAberrationLevel: 0,
-                        vignetteDetected: false,
-                        vignetteLevel: 0,
-                    },
-                    overallOpticalDistortionScore: 0,
-                };
-            }
-        }
-        /**
-         * 注意：重置由 FrameCollector 管理
-         * 此检测器不持有任何帧缓冲
-         */
-        reset() {
-            // 帧缓冲由 FrameCollector 管理，此处无需重置
-            console.log('[OpticalDistortion] Detector state cleared (frames managed by FrameCollector)');
-        }
-        /**
-         * 检测梯形失真（Keystone）
-         *
-         * 原理：
-         * - 梯形失真导致图像上下边宽度不同
-         * - 计算上下边的宽度比
-         */
-        detectKeystone(frame) {
-            try {
-                // 检测上边界
-                const topEdgeWidth = this.findHorizontalEdgeWidth(frame, Math.floor(this.frameCollector.getFrameHeight() * 0.1));
-                // 检测下边界
-                const bottomEdgeWidth = this.findHorizontalEdgeWidth(frame, Math.floor(this.frameCollector.getFrameHeight() * 0.9));
-                if (topEdgeWidth === 0 || bottomEdgeWidth === 0) {
-                    return { detected: false, level: 0 };
-                }
-                // 计算宽度变化比
-                const widthRatio = Math.abs(topEdgeWidth - bottomEdgeWidth) / Math.max(topEdgeWidth, bottomEdgeWidth);
-                const detected = widthRatio > this.config.keystoneThreshold;
-                const level = Math.min(1, widthRatio / 0.5); // 归一化
-                console.log(`[OpticalDistortion] Keystone: top=${topEdgeWidth}px, bottom=${bottomEdgeWidth}px, ratio=${widthRatio.toFixed(3)}, level=${level.toFixed(3)}`);
-                return { detected, level };
-            }
-            catch (error) {
-                console.error('[OpticalDistortion] Keystone detection error:', error);
-                return { detected: false, level: 0 };
-            }
-        }
-        /**
-         * 检测桶形/枕形失真
-         *
-         * 原理：
-         * - 提取图像边界
-         * - 拟合边界为曲线，计算曲率
-         * - 高曲率表示失真
-         */
-        detectBarrelDistortion(frame) {
-            try {
-                // 检测左右边界的垂直直线度
-                const leftBoundaryDeviation = this.measureBoundaryDeviation(frame, 'left');
-                const rightBoundaryDeviation = this.measureBoundaryDeviation(frame, 'right');
-                const maxDeviation = Math.max(leftBoundaryDeviation, rightBoundaryDeviation);
-                // 偏差转换为失真水平
-                const distortionLevel = Math.min(1, maxDeviation / (this.frameCollector.getFrameHeight() * 0.1)); // 如果边界弯曲超过高度10%
-                const detected = distortionLevel > this.config.barrelDistortionThreshold;
-                const level = distortionLevel;
-                console.log(`[OpticalDistortion] Barrel: left-dev=${leftBoundaryDeviation.toFixed(1)}px, right-dev=${rightBoundaryDeviation.toFixed(1)}px, level=${level.toFixed(3)}`);
-                return { detected, level };
-            }
-            catch (error) {
-                console.error('[OpticalDistortion] Barrel distortion detection error:', error);
-                return { detected: false, level: 0 };
-            }
-        }
-        /**
-         * 检测色差（RGB通道分离）
-         */
-        detectChromaticAberration(frame) {
-            // 注意：此处输入是灰度图，无法检测RGB分离
-            // 实际使用时应输入BGR彩色图像
-            // 这里为简化，返回低值
-            return {
-                detected: false,
-                level: 0,
-            };
-        }
-        /**
-         * 检测暗角（四角暗化）
-         *
-         * 原理：
-         * - 计算四个角区域的平均亮度
-         * - 与中心区域对比
-         * - 大幅下降表示暗角
-         */
-        detectVignette(frame) {
-            try {
-                // 计算中心区域亮度
-                const centerBrightness = this.getAverageBrightness(frame, Math.floor(this.frameCollector.getFrameWidth() * 0.25), Math.floor(this.frameCollector.getFrameHeight() * 0.25), Math.floor(this.frameCollector.getFrameWidth() * 0.75), Math.floor(this.frameCollector.getFrameHeight() * 0.75));
-                // 计算四个角区域的平均亮度
-                const cornerSize = Math.min(Math.floor(this.frameCollector.getFrameWidth() * 0.1), Math.floor(this.frameCollector.getFrameHeight() * 0.1));
-                const topLeftBrightness = this.getAverageBrightness(frame, 0, 0, cornerSize, cornerSize);
-                const topRightBrightness = this.getAverageBrightness(frame, this.frameCollector.getFrameWidth() - cornerSize, 0, this.frameCollector.getFrameWidth(), cornerSize);
-                const bottomLeftBrightness = this.getAverageBrightness(frame, 0, this.frameCollector.getFrameHeight() - cornerSize, cornerSize, this.frameCollector.getFrameHeight());
-                const bottomRightBrightness = this.getAverageBrightness(frame, this.frameCollector.getFrameWidth() - cornerSize, this.frameCollector.getFrameHeight() - cornerSize, this.frameCollector.getFrameWidth(), this.frameCollector.getFrameHeight());
-                const avgCornerBrightness = (topLeftBrightness + topRightBrightness + bottomLeftBrightness + bottomRightBrightness) / 4;
-                // 计算暗角程度
-                const vignetteLevel = Math.max(0, (centerBrightness - avgCornerBrightness) / centerBrightness);
-                const detected = vignetteLevel > this.config.vignetteThreshold;
-                const level = Math.min(1, vignetteLevel);
-                console.log(`[OpticalDistortion] Vignette: center=${centerBrightness.toFixed(1)}, corners=${avgCornerBrightness.toFixed(1)}, level=${level.toFixed(3)}`);
-                return { detected, level };
-            }
-            catch (error) {
-                console.error('[OpticalDistortion] Vignette detection error:', error);
-                return { detected: false, level: 0 };
-            }
-        }
-        /**
-         * 找水平边界的宽度
-         */
-        findHorizontalEdgeWidth(frame, y) {
-            const stride = this.config.samplingStride;
-            let firstEdge = -1;
-            let lastEdge = -1;
-            const threshold = 50; // 亮度变化阈值
-            for (let x = 0; x < this.frameCollector.getFrameWidth() - stride; x += stride) {
-                const idx1 = y * this.frameCollector.getFrameWidth() + x;
-                const idx2 = y * this.frameCollector.getFrameWidth() + (x + stride);
-                if (idx1 >= frame.length || idx2 >= frame.length)
-                    break;
-                const diff = Math.abs(frame[idx2] - frame[idx1]);
-                if (diff > threshold) {
-                    if (firstEdge === -1) {
-                        firstEdge = x;
-                    }
-                    lastEdge = x;
-                }
-            }
-            if (firstEdge === -1 || lastEdge === -1) {
-                return 0;
-            }
-            return lastEdge - firstEdge;
-        }
-        /**
-         * 测量边界的垂直直线度（曲率）
-         */
-        measureBoundaryDeviation(frame, side) {
-            const stride = this.config.samplingStride;
-            const x = side === 'left' ? Math.floor(this.frameCollector.getFrameWidth() * 0.05) : Math.floor(this.frameCollector.getFrameWidth() * 0.95);
-            // 沿垂直方向跟踪边界位置
-            const positions = [];
-            for (let y = 0; y < this.frameCollector.getFrameHeight(); y += stride) {
-                const edgeX = this.findVerticalEdgeAtY(frame, y, x, side);
-                positions.push(edgeX);
-            }
-            if (positions.length < 2) {
-                return 0;
-            }
-            // 计算位置的标准差作为曲率指标
-            const mean = positions.reduce((a, b) => a + b, 0) / positions.length;
-            const variance = positions.reduce((sum, p) => sum + (p - mean) ** 2, 0) / positions.length;
-            const stdDev = Math.sqrt(variance);
-            return stdDev;
-        }
-        /**
-         * 找在特定y处的垂直边界
-         */
-        findVerticalEdgeAtY(frame, y, startX, side) {
-            const stride = 2;
-            const threshold = 50;
-            if (side === 'left') {
-                // 从左向右找边界
-                for (let x = Math.max(0, startX - 50); x < startX + 50; x += stride) {
-                    const idx1 = y * this.frameCollector.getFrameWidth() + x;
-                    const idx2 = y * this.frameCollector.getFrameWidth() + (x + stride);
-                    if (idx1 >= frame.length || idx2 >= frame.length)
-                        continue;
-                    if (Math.abs(frame[idx2] - frame[idx1]) > threshold) {
-                        return x;
-                    }
-                }
-            }
-            else {
-                // 从右向左找边界
-                for (let x = Math.min(this.frameCollector.getFrameWidth() - 1, startX + 50); x > startX - 50; x -= stride) {
-                    const idx1 = y * this.frameCollector.getFrameWidth() + x;
-                    const idx2 = y * this.frameCollector.getFrameWidth() + (x - stride);
-                    if (idx1 >= frame.length || idx2 >= frame.length)
-                        continue;
-                    if (Math.abs(frame[idx1] - frame[idx2]) > threshold) {
-                        return x;
-                    }
-                }
-            }
-            return startX;
-        }
-        /**
-         * 计算矩形区域的平均亮度
-         */
-        getAverageBrightness(frame, x1, y1, x2, y2) {
-            let sum = 0;
-            let count = 0;
-            const stride = Math.max(1, this.config.samplingStride);
-            for (let y = y1; y < y2; y += stride) {
-                for (let x = x1; x < x2; x += stride) {
-                    const idx = y * this.frameCollector.getFrameWidth() + x;
-                    if (idx >= 0 && idx < frame.length) {
-                        sum += frame[idx];
-                        count++;
-                    }
-                }
-            }
-            return count > 0 ? sum / count : 0;
-        }
-        /**
-         * 推断投影仪类型
-         */
-        inferProjectorType(keystoneResult, barrelResult, chromaticResult, vignetteResult) {
-            // 基于特征组合推断类型
-            // 这是一个简化的启发式方法
-            const totalScore = keystoneResult.level + barrelResult.level + chromaticResult.level + vignetteResult.level;
-            if (totalScore < 0.3) {
-                return 'unknown';
-            }
-            // DLP: 通常有色差
-            if (chromaticResult.level > 0.3) {
-                return 'dlp';
-            }
-            // LCD投影: 通常有明显暗角
-            if (vignetteResult.level > 0.3) {
-                return 'lcd';
-            }
-            // LCoS: 通常有梯形失真
-            if (keystoneResult.level > 0.3) {
-                return 'lcos';
-            }
-            return 'unknown';
-        }
-    }
-
-    /**
-     * 公共帧采集器 - 统一管理多帧图像
-     *
-     * 核心功能：
-     * - 采集灰度和彩色帧
-     * - 计算视频FPS
-     * - 为多个检测器提供帧缓冲
-     * - 支持时间戳记录
-     */
-    /**
-     * 公共帧采集器
-     *
-     * 多个检测器可以共用一个 VideoFrameCollector 实例，减少内存占用和代码重复
-     */
-    class VideoFrameCollector {
-        config;
-        // 帧缓冲区
-        grayFrames = [];
-        bgrFrames = [];
-        frameTimestamps = [];
-        // 帧信息
-        frameWidth = 0;
-        frameHeight = 0;
-        // FPS计算
-        averageFps = 0;
-        fpsHistory = [];
-        constructor(config) {
-            this.config = {
-                bufferSize: config?.bufferSize ?? 60, // 默认60帧（足够大）
-            };
-        }
-        /**
-         * 添加一帧（灰度 + 可选的彩色）
-         *
-         * @param grayMat 灰度图像矩阵（必需）
-         * @param bgrMat 彩色图像矩阵，BGR格式（可选）
-         * @param frameTimestamp 帧时间戳，毫秒（可选，默认使用当前时间）
-         */
-        addFrame(grayMat, bgrMat, frameTimestamp) {
-            if (grayMat.empty?.()) {
-                console.warn('[FrameCollector] Received empty gray frame');
-                return;
-            }
-            const timestamp = frameTimestamp ?? performance.now();
-            // 初始化帧尺寸（首帧时）
-            if (this.frameWidth === 0) {
-                this.frameWidth = grayMat.cols;
-                this.frameHeight = grayMat.rows;
-                console.log(`[FrameCollector] Frame size initialized: ${this.frameWidth}x${this.frameHeight}`);
-            }
-            // 转换灰度帧为字节数组
-            const grayData = new Uint8Array(grayMat.data);
-            this.grayFrames.push(grayData);
-            // 转换彩色帧为字节数组（如果提供）
-            const bgrData = new Uint8Array(bgrMat.data);
-            this.bgrFrames.push(bgrData);
-            this.frameTimestamps.push(timestamp);
-            // 计算瞬时FPS
-            this.updateFpsStats(timestamp);
-            // 维持缓冲区大小
-            if (this.grayFrames.length > this.config.bufferSize) {
-                this.grayFrames.shift();
-                this.bgrFrames.shift();
-                this.frameTimestamps.shift();
-            }
-            const fpsStr = this.averageFps > 0 ? ` (${this.averageFps.toFixed(1)} fps)` : '';
-            console.log(`[FrameCollector] Frame added. Buffer: ${this.grayFrames.length}/${this.config.bufferSize}${fpsStr}`);
-        }
-        /**
-         * 获取灰度帧缓冲区（直接引用，不复制）
-         * @param n 返回最后n个帧，<=0或不提供则返回全部
-         */
-        getGrayFrames(n) {
-            if (n === undefined || n <= 0) {
-                return this.grayFrames;
-            }
-            return this.grayFrames.slice(-n);
-        }
-        /**
-         * 获取彩色帧缓冲区（可能包含null值）
-         * @param n 返回最后n个帧，<=0或不提供则返回全部
-         */
-        getBgrFrames(n) {
-            if (n === undefined || n <= 0) {
-                return this.bgrFrames;
-            }
-            return this.bgrFrames.slice(-n);
-        }
-        /**
-         * 获取指定索引的灰度帧
-         */
-        getGrayFrame(index) {
-            if (index >= 0 && index < this.grayFrames.length) {
-                return this.grayFrames[index];
-            }
-            return null;
-        }
-        /**
-         * 获取指定索引的彩色帧
-         */
-        getBgrFrame(index) {
-            if (index >= 0 && index < this.bgrFrames.length) {
-                return this.bgrFrames[index];
-            }
-            return null;
-        }
-        /**
-         * 获取当前缓冲区中的帧数
-         */
-        getBufferedFrameCount() {
-            return this.grayFrames.length;
-        }
-        /**
-         * 获取帧时间戳
-         */
-        getFrameTimestamp(index) {
-            if (index >= 0 && index < this.frameTimestamps.length) {
-                return this.frameTimestamps[index];
-            }
-            return null;
-        }
-        /**
-         * 获取所有帧的时间戳
-         */
-        getFrameTimestamps() {
-            return this.frameTimestamps;
-        }
-        /**
-         * 获取帧尺寸
-         */
-        getFrameSize() {
-            return {
-                width: this.frameWidth,
-                height: this.frameHeight,
-            };
-        }
-        getFrameWidth() {
-            return this.frameWidth;
-        }
-        getFrameHeight() {
-            return this.frameHeight;
-        }
-        /**
-         * 获取平均FPS
-         */
-        getAverageFps() {
-            return this.averageFps;
-        }
-        /**
-         * 重置收集器，清空所有缓冲区
-         */
-        reset() {
-            this.grayFrames = [];
-            this.bgrFrames = [];
-            this.frameTimestamps = [];
-            this.fpsHistory = [];
-            this.averageFps = 0;
-            console.log('[FrameCollector] Collector reset');
-        }
-        /**
-         * 清空帧缓冲区，但保留配置和FPS统计
-         */
-        clearFrames() {
-            this.grayFrames = [];
-            this.bgrFrames = [];
-            this.frameTimestamps = [];
-            console.log('[FrameCollector] Frames cleared');
-        }
-        /**
-         * 获取统计信息
-         */
-        getStats() {
-            return {
-                bufferedFrames: this.grayFrames.length,
-                bufferSize: this.config.bufferSize,
-                frameWidth: this.frameWidth,
-                frameHeight: this.frameHeight,
-                averageFps: this.averageFps,
-                fpsHistory: [...this.fpsHistory],
-            };
-        }
-        /**
-         * 获取最近N帧（用于批量处理）
-         */
-        getLastNFrames(n) {
-            const startIdx = Math.max(0, this.grayFrames.length - n);
-            return {
-                grayFrames: this.grayFrames.slice(startIdx),
-                bgrFrames: this.bgrFrames.slice(startIdx),
-                timestamps: this.frameTimestamps.slice(startIdx),
-            };
-        }
-        /**
-         * 更新FPS统计
-         */
-        updateFpsStats(currentTimestamp) {
-            if (this.frameTimestamps.length < 2) {
-                return;
-            }
-            const prevTimestamp = this.frameTimestamps[this.frameTimestamps.length - 2];
-            const deltaMs = currentTimestamp - prevTimestamp;
-            if (deltaMs > 0) {
-                const instantFps = 1000 / deltaMs;
-                // 保留FPS历史（用于计算平均值，最多30个）
-                this.fpsHistory.push(instantFps);
-                if (this.fpsHistory.length > 30) {
-                    this.fpsHistory.shift();
-                }
-                // 计算加权平均FPS（更重视最近的值）
-                if (this.fpsHistory.length >= 5) {
-                    let weightedSum = 0;
-                    let weightSum = 0;
-                    for (let i = 0; i < this.fpsHistory.length; i++) {
-                        const weight = (i + 1) / this.fpsHistory.length;
-                        weightedSum += this.fpsHistory[i] * weight;
-                        weightSum += weight;
-                    }
-                    this.averageFps = weightedSum / weightSum;
-                }
-                else if (this.fpsHistory.length > 0) {
-                    // FPS历史不足5个时，计算简单平均
-                    this.averageFps = this.fpsHistory.reduce((a, b) => a + b, 0) / this.fpsHistory.length;
-                }
-            }
-        }
-    }
-
-    /**
-     * 第三版屏幕采集检测器
-     *
-     */
-    /**
-     * 优化版屏幕采集检测结果
-     */
-    class ScreenCaptureDetectionResult {
-        isScreenCapture;
-        confidenceScore;
-        // 实际执行的检测方法结果
-        executedMethods;
-        riskLevel;
-        processingTimeMs;
-        debug;
-        constructor(isScreenCapture, confidenceScore, executedMethods, riskLevel, processingTimeMs, debug) {
-            this.isScreenCapture = isScreenCapture;
-            this.confidenceScore = confidenceScore;
-            this.executedMethods = executedMethods;
-            this.riskLevel = riskLevel;
-            this.processingTimeMs = processingTimeMs;
-            this.debug = debug;
-        }
-        getMessage() {
-            const timeInfo = ` (${this.processingTimeMs}ms)`;
-            if (!this.isScreenCapture) {
-                return `success${timeInfo}`;
-            }
-            const detectedMethods = this.executedMethods
-                .filter(m => m.isScreenCapture)
-                .map(m => `${m.method} (${(m.confidence * 100).toFixed(0)}%)`)
-                .join('; ');
-            return `Screen capture detected: ${detectedMethods}. Risk: ${this.riskLevel.toUpperCase()}${timeInfo}`;
-        }
-    }
-    /**
-     * ScreenCaptureDetectorOptions 的默认值
-     */
-    const DEFAULT_SCREEN_CAPTURE_DETECTOR_OPTIONS = {
-        flickerBufferSize: 15, // 15帧 @ 30fps = 0.5秒，足以检测LCD闪烁
-        flickerMinPeriod: 1,
-        flickerMaxPeriod: 3, // 对应约10Hz的闪烁，覆盖60-120Hz刷新率
-        flickerCorrelationThreshold: 0.65,
-        flickerPassingPixelRatio: 0.40,
-        flickerSamplingStride: 1, // 100%采样以捕捉闪烁周期
-        responseTimeBufferSize: 15, // 15帧 @ 30fps = 0.5秒（墨水屏响应时间200-500ms，0.5秒足够）
-        responseTimeMinPixelDelta: 25, // 像素值变化至少25级（较为宽松，适应各种光照）
-        responseTimeSamplingStride: 2, // 50%采样以加快计算（相邻帧变化缓慢，50%采样足够）
-        responseTimeThreshold: 200, // 200ms阈值（更准确匹配墨水屏响应时间范围200-500ms）
-        responseTimePassingPixelRatio: 0.40, // 40%像素达到要求（略降低，适应真实场景变化）
-        dlpColorWheelBufferSize: 20, // 20帧 @ 30fps = 0.67秒，足以检测DLP色轮干涉
-        dlpEdgeThreshold: 80,
-        dlpChannelSeparationThreshold: 3, // RGB分离至少3像素，减少误报
-        dlpConfidenceThreshold: 0.65,
-        dlpSamplingStride: 1, // 100%采样以捕捉DLP色轮干涉
-        opticalDistortionBufferSize: 3, // 3帧用于验证光学畸变的稳定性
-        opticalKeystoneThreshold: 0.15,
-        opticalBarrelThreshold: 0.10,
-        opticalChromaticThreshold: 3.0,
-        opticalVignetteThreshold: 0.20,
-        opticalSamplingStride: 2, // 50%采样足以覆盖光学畸变特征
-        opticalFeatureKeystone: 0.35, // 梯形失真（最常见投影问题）权重最高
-        opticalFeatureBarrel: 0.30, // 桶形畸变（典型镜头失真）
-        opticalFeatureChromatic: 0.20, // 色差（可能被其他因素影响）
-        opticalFeatureVignette: 0.15, // 晕影（最微妙，易受环境光影响）
-        frameDropRate: 0.03, // 3% 丢帧率（模拟真实摄像头，30fps下约丢1帧/秒）
-        // 检测结果判定阈值
-        flickerConfidenceThreshold: 0.70,
-        responseTimeConfidenceThreshold: 0.65,
-        dlpConfidenceThresholdResult: 0.65,
-        opticalConfidenceThresholdResult: 0.60,
-        compositeConfidenceThresholdScreenCapture: 0.50,
-        compositeConfidenceThresholdHighRisk: 0.70,
-        compositeConfidenceThresholdMediumRisk: 0.50,
-    };
-    function calcOptionsByFPS(fps) {
-        if (fps <= 0) {
-            console.warn('[calcOptionsByFPS] Invalid FPS value, using defaults');
-            return {};
-        }
-        // 基准FPS为30，其他参数按比例调整以保持相同的时间窗口
-        const fpsRatio = fps / 30;
-        return {
-            // 缓冲区大小：按FPS比例调整，保持时间窗口一致
-            flickerBufferSize: Math.max(5, Math.round(15 * fpsRatio)), // 保持约0.5秒时间窗口
-            responseTimeBufferSize: Math.max(8, Math.round(15 * fpsRatio)), // 保持约0.5秒时间窗口（墨水屏响应200-500ms）
-            dlpColorWheelBufferSize: Math.max(8, Math.round(20 * fpsRatio)), // 保持约0.67秒时间窗口
-            opticalDistortionBufferSize: Math.max(1, Math.round(3 * fpsRatio)), // 保持帧数配置
-            frameDropRate: Math.min(0.1, 0.03 * (30 / fps)), // 高FPS时降低丢帧率，保持稳定性
-        };
-    }
-    /**
-     * 优化版屏幕采集检测引擎
-     *
-     * 使用级联检测策略，支持多种模式以平衡速度和精准度
-     */
-    class ScreenCaptureDetector {
-        cv = null;
-        fps;
-        config;
-        frameCollector;
-        flickerDetector;
-        responseTimeDetector;
-        dlpColorWheelDetector;
-        opticalDistortionDetector;
-        droppedFramesCount = 0;
-        constructor(fps) {
-            this.fps = fps ?? 30;
-            // 根据fps动态调整参数
-            const fpsOptions = calcOptionsByFPS(this.fps);
-            // 合并：默认值 → FPS调整值 → 用户选项（后面的覆盖前面的）
-            this.config = {
-                ...DEFAULT_SCREEN_CAPTURE_DETECTOR_OPTIONS,
-                ...fpsOptions
-            };
-            const bufferSize = Math.max(this.config.flickerBufferSize, this.config.responseTimeBufferSize, this.config.dlpColorWheelBufferSize, this.config.opticalDistortionBufferSize);
-            // 创建公共帧采集器
-            this.frameCollector = new VideoFrameCollector({
-                bufferSize: bufferSize
-            });
-            // 初始化视频闪烁检测器 (LCD/OLED)
-            this.flickerDetector = new ScreenFlickerDetector(this.frameCollector, {
-                bufferSize: this.config.flickerBufferSize,
-                minFlickerPeriodFrames: this.config.flickerMinPeriod,
-                maxFlickerPeriodFrames: this.config.flickerMaxPeriod,
-                correlationThreshold: this.config.flickerCorrelationThreshold,
-                passingPixelRatio: this.config.flickerPassingPixelRatio,
-                samplingStride: this.config.flickerSamplingStride,
-            });
-            // 初始化响应时间检测器（墨水屏）
-            this.responseTimeDetector = new ScreenResponseTimeDetector(this.frameCollector, {
-                bufferSize: this.config.responseTimeBufferSize,
-                minPixelDelta: this.config.responseTimeMinPixelDelta,
-                einkResponseTimeThreshold: this.config.responseTimeThreshold,
-                samplingStride: this.config.responseTimeSamplingStride,
-                passingPixelRatio: this.config.responseTimePassingPixelRatio,
-            });
-            // 初始化DLP色轮检测器 (DLP投影仪)
-            this.dlpColorWheelDetector = new DLPColorWheelDetector(this.frameCollector, {
-                bufferSize: this.config.dlpColorWheelBufferSize,
-                edgeThreshold: this.config.dlpEdgeThreshold,
-                minChannelSeparationPixels: this.config.dlpChannelSeparationThreshold,
-                separationConfidenceThreshold: this.config.dlpConfidenceThreshold,
-                samplingStride: this.config.dlpSamplingStride,
-            });
-            // 初始化光学畸变检测器 (其他投影仪)
-            this.opticalDistortionDetector = new OpticalDistortionDetector(this.frameCollector, {
-                bufferSize: this.config.opticalDistortionBufferSize,
-                keystoneThreshold: this.config.opticalKeystoneThreshold,
-                barrelDistortionThreshold: this.config.opticalBarrelThreshold,
-                chromaticAberrationThreshold: this.config.opticalChromaticThreshold,
-                vignetteThreshold: this.config.opticalVignetteThreshold,
-                samplingStride: this.config.opticalSamplingStride,
-                featureWeights: {
-                    keystone: this.config.opticalFeatureKeystone,
-                    barrelDistortion: this.config.opticalFeatureBarrel,
-                    chromaticAberration: this.config.opticalFeatureChromatic,
-                    vignette: this.config.opticalFeatureVignette,
-                }
-            });
-        }
-        setCVInstance(cvInstance) {
-            this.cv = cvInstance;
-        }
-        getFPS() {
-            return this.fps;
-        }
-        /**
-         * 向视频检测器添加一帧（用于实时视频处理）
-         * 建议每收到一帧就调用此方法
-         *
-         * @param grayMat 灰度图像矩阵
-         * @param bgrMat 彩色图像矩阵
-         * @returns 帧是否被接受（true表示被处理，false表示被随机丢弃）
-         */
-        addVideoFrame(grayMat, bgrMat) {
-            // 1. 只保留基础的随机丢帧（模拟真实摄像头）
-            if (this.config.frameDropRate > 0 && Math.random() < this.config.frameDropRate) {
-                this.droppedFramesCount++;
-                return false;
-            }
-            // 2. 添加帧到缓冲区
-            this.frameCollector.addFrame(grayMat, bgrMat);
-            return true;
-        }
-        isReady() {
-            const cachedBufferSize = this.frameCollector.getBufferedFrameCount();
-            return cachedBufferSize >= Math.max(this.config.flickerBufferSize, this.config.responseTimeBufferSize, this.config.dlpColorWheelBufferSize, this.config.opticalDistortionBufferSize);
-        }
-        /**
-         * 获取丢帧统计信息
-         */
-        getFrameDropStats() {
-            return {
-                droppedFramesCount: this.droppedFramesCount,
-                dropRate: this.config.frameDropRate,
-            };
-        }
-        reset() {
-            this.droppedFramesCount = 0;
-            this.frameCollector.reset();
-            this.flickerDetector.reset();
-            this.responseTimeDetector.reset();
-            this.dlpColorWheelDetector.reset();
-            this.opticalDistortionDetector.reset();
-        }
-        /**
-         * 检测屏幕捕捉
-         * 使用三层判定逻辑：
-         * 1. 任意方法能明确判定为屏幕捕捉时，直接返回
-         * 2. 都不能明确判定时，计算加权置信度
-         * 3. 用加权置信度判定最终结果
+         * 【防护机制】检查脸部形状稳定性
          *
-         * @param debugMode - 是否启用调试模式，返回详细日志
-         * @param useVideoAnalysis - 是否使用已积累的视频帧进行闪烁检测
-         * @returns 检测结果
-         */
-        detect(debugMode = false, useVideoAnalysis = false) {
-            return this.detectWithLogic(debugMode, useVideoAnalysis);
-        }
-        /**
-         * 核心检测方法：多屏幕类型级联检测
+         * 原理：
+         * - 真实脸部：眨眼、张嘴等会改变脸部几何形状（EAR/MAR 变化）
+         * - 照片：脸部形状完全固定，不会有任何变化
+         * - 倾角照片：虽然会产生透视变形，但仍然是平面的，Z坐标无深度
          *
-         * 检测顺序（按可靠性排序）：
-         * 1. 视频闪烁（LCD/OLED）- 最可靠的物理特性
-         * 2. 响应时间（墨水屏）- 像素变化速度特征
-         * 3. DLP色轮（DLP投影）- 色轮干涉的独特特征
-         * 4. 光学畸变（其他投影）- 投影光学系统的失真
-         */
-        detectWithLogic(enableDebug = false, useVideoAnalysis = false) {
-            if (!this.cv) {
-                throw new Error('OpenCV instance not initialized. Call setCVInstance() first.');
-            }
-            const startTime = performance.now();
-            const executedMethods = [];
-            const debug = enableDebug ? {
-                startTime,
-                endTime: 0,
-                totalTimeMs: 0,
-                stages: [],
-                finalDecision: {
-                    isScreenCapture: false,
-                    confidenceScore: 0,
-                }
-            } : undefined;
-            try {
-                // ========== Stage 0: 视频闪烁检测 (LCD/OLED) ==========
-                let flickerResult = { isScreenCapture: false,
-                    confidence: 0, passingPixelRatio: 0, sampledPixelCount: 0 };
-                if (useVideoAnalysis && this.flickerDetector.getBufferedFrameCount() >= 5) {
-                    const stage0Start = performance.now();
-                    flickerResult = this.flickerDetector.analyze();
-                    const stage0Time = performance.now() - stage0Start;
-                    executedMethods.push({
-                        method: 'Screen Flicker Detection (LCD/OLED)',
-                        isScreenCapture: flickerResult.isScreenCapture,
-                        confidence: flickerResult.confidence,
-                        details: {
-                            dominantPeriod: flickerResult.dominantFlickerPeriod,
-                            estimatedRefreshRate: flickerResult.estimatedScreenRefreshRate,
-                        },
-                    });
-                    if (debug) {
-                        debug.stages.push({
-                            method: 'Screen Flicker Detection (LCD/OLED)',
-                            completed: true,
-                            timeMs: stage0Time,
-                            result: { ...flickerResult }
-                        });
-                    }
-                    if (flickerResult.isScreenCapture && flickerResult.confidence > this.config.flickerConfidenceThreshold) {
-                        const totalTime = performance.now() - startTime;
-                        if (debug) {
-                            debug.endTime = performance.now();
-                            debug.totalTimeMs = totalTime;
-                            debug.finalDecision = {
-                                isScreenCapture: true,
-                                confidenceScore: flickerResult.confidence,
-                                decisiveMethod: 'Screen Flicker Detection',
-                            };
-                        }
-                        return new ScreenCaptureDetectionResult(true, flickerResult.confidence, executedMethods, 'high', totalTime, debug);
-                    }
-                }
-                // ========== Stage 1: 响应时间检测 (墨水屏) ==========
-                let responseTimeResult = { isScreenCapture: false,
-                    confidence: 0, passingPixelRatio: 0, sampledPixelCount: 0 };
-                if (useVideoAnalysis && this.responseTimeDetector.getBufferedFrameCount() >= 10) {
-                    const stage1Start = performance.now();
-                    responseTimeResult = this.responseTimeDetector.analyze();
-                    const stage1Time = performance.now() - stage1Start;
-                    executedMethods.push({
-                        method: 'Response Time Detection (E-Ink)',
-                        isScreenCapture: responseTimeResult.isScreenCapture,
-                        confidence: responseTimeResult.confidence,
-                        details: {
-                            averageResponseTime: responseTimeResult.averageResponseTimeMs,
-                            estimatedScreenType: responseTimeResult.estimatedScreenType,
-                        },
-                    });
-                    if (debug) {
-                        debug.stages.push({
-                            method: 'Response Time Detection (E-Ink)',
-                            completed: true,
-                            timeMs: stage1Time,
-                            result: { ...responseTimeResult }
-                        });
-                    }
-                    if (responseTimeResult.isScreenCapture && responseTimeResult.confidence > this.config.responseTimeConfidenceThreshold) {
-                        const totalTime = performance.now() - startTime;
-                        if (debug) {
-                            debug.endTime = performance.now();
-                            debug.totalTimeMs = totalTime;
-                            debug.finalDecision = {
-                                isScreenCapture: true,
-                                confidenceScore: responseTimeResult.confidence,
-                                decisiveMethod: 'Response Time Detection (E-Ink)',
-                            };
-                        }
-                        return new ScreenCaptureDetectionResult(true, responseTimeResult.confidence, executedMethods, 'high', totalTime, debug);
-                    }
-                }
-                // ========== Stage 2: DLP色轮检测 (DLP投影) ==========
-                let dlpResult = { isScreenCapture: false,
-                    confidence: 0, hasColorSeparation: false, colorSeparationPixels: 0, sampledEdgePixelCount: 0 };
-                if (useVideoAnalysis && this.dlpColorWheelDetector.getBufferedFrameCount() >= 3) {
-                    const stage2Start = performance.now();
-                    dlpResult = this.dlpColorWheelDetector.analyze();
-                    const stage2Time = performance.now() - stage2Start;
-                    executedMethods.push({
-                        method: 'DLP Color Wheel Detection',
-                        isScreenCapture: dlpResult.isScreenCapture,
-                        confidence: dlpResult.confidence,
-                        details: {
-                            hasColorSeparation: dlpResult.hasColorSeparation,
-                            colorSeparationPixels: dlpResult.colorSeparationPixels,
-                        },
-                    });
-                    if (debug) {
-                        debug.stages.push({
-                            method: 'DLP Color Wheel Detection',
-                            completed: true,
-                            timeMs: stage2Time,
-                            result: { ...dlpResult }
-                        });
-                    }
-                    if (dlpResult.isScreenCapture && dlpResult.confidence > this.config.dlpConfidenceThresholdResult) {
-                        const totalTime = performance.now() - startTime;
-                        if (debug) {
-                            debug.endTime = performance.now();
-                            debug.totalTimeMs = totalTime;
-                            debug.finalDecision = {
-                                isScreenCapture: true,
-                                confidenceScore: dlpResult.confidence,
-                                decisiveMethod: 'DLP Color Wheel Detection',
-                            };
-                        }
-                        return new ScreenCaptureDetectionResult(true, dlpResult.confidence, executedMethods, 'high', totalTime, debug);
-                    }
-                }
-                // ========== Stage 3: 光学畸变检测 (其他投影) ==========
-                let opticalResult = {
-                    isScreenCapture: false, confidence: 0, overallOpticalDistortionScore: 0,
-                    distortionFeatures: {
-                        keystoneDetected: false,
-                        keystoneLevel: 0,
-                        barrelDistortionDetected: false,
-                        barrelDistortionLevel: 0,
-                        chromaticAberrationDetected: false,
-                        chromaticAberrationLevel: 0,
-                        vignetteDetected: false,
-                        vignetteLevel: 0,
-                    }
-                };
-                if (useVideoAnalysis && this.opticalDistortionDetector.getBufferedFrameCount() >= 1) {
-                    const stage3Start = performance.now();
-                    opticalResult = this.opticalDistortionDetector.analyze();
-                    const stage3Time = performance.now() - stage3Start;
-                    executedMethods.push({
-                        method: 'Optical Distortion Detection',
-                        isScreenCapture: opticalResult.isScreenCapture,
-                        confidence: opticalResult.confidence,
-                        details: {
-                            distortionFeatures: opticalResult.distortionFeatures,
-                            estimatedProjectorType: opticalResult.estimatedProjectorType,
-                        },
-                    });
-                    if (debug) {
-                        debug.stages.push({
-                            method: 'Optical Distortion Detection',
-                            completed: true,
-                            timeMs: stage3Time,
-                            result: { ...opticalResult }
-                        });
-                    }
-                    if (opticalResult.isScreenCapture && opticalResult.confidence > this.config.opticalConfidenceThresholdResult) {
-                        const totalTime = performance.now() - startTime;
-                        if (debug) {
-                            debug.endTime = performance.now();
-                            debug.totalTimeMs = totalTime;
-                            debug.finalDecision = {
-                                isScreenCapture: true,
-                                confidenceScore: opticalResult.confidence,
-                                decisiveMethod: 'Optical Distortion Detection',
-                            };
-                        }
-                        return new ScreenCaptureDetectionResult(true, opticalResult.confidence, executedMethods, 'medium', totalTime, debug);
-                    }
-                }
-                // 综合多个视频检测器的结果
-                if (useVideoAnalysis) {
-                    const compositeConfidence = Math.max(flickerResult.confidence, responseTimeResult.confidence, dlpResult.confidence, opticalResult.confidence);
-                    const isScreenCapture = compositeConfidence > this.config.compositeConfidenceThresholdScreenCapture;
-                    const riskLevel = compositeConfidence > this.config.compositeConfidenceThresholdHighRisk ? 'high' : (compositeConfidence > this.config.compositeConfidenceThresholdMediumRisk ? 'medium' : 'low');
-                    const totalTime = performance.now() - startTime;
-                    if (debug) {
-                        debug.endTime = performance.now();
-                        debug.totalTimeMs = totalTime;
-                        debug.finalDecision = {
-                            isScreenCapture,
-                            confidenceScore: compositeConfidence,
-                            decisiveMethod: isScreenCapture ? 'Video Analysis (Composite)' : undefined,
-                        };
-                    }
-                    console.log(`[ScreenCaptureDetector] Video composite: flicker=${flickerResult.confidence?.toFixed(3) ?? '0'}, responseTime=${responseTimeResult.confidence?.toFixed(3) ?? '0'}, dlp=${dlpResult.confidence?.toFixed(3) ?? '0'}, optical=${opticalResult.confidence?.toFixed(3) ?? '0'}, composite=${compositeConfidence.toFixed(3)}`);
-                    return new ScreenCaptureDetectionResult(isScreenCapture, compositeConfidence, executedMethods, riskLevel, totalTime, debug);
-                }
-                // 没有视频分析，返回中立结果
-                const totalTime = performance.now() - startTime;
-                if (debug) {
-                    debug.endTime = performance.now();
-                    debug.totalTimeMs = totalTime;
-                    debug.finalDecision = {
-                        isScreenCapture: false,
-                        confidenceScore: 0,
-                    };
-                }
-                return new ScreenCaptureDetectionResult(false, 0, executedMethods, 'low', totalTime, debug);
-            }
-            catch (error) {
-                console.error('[ScreenCaptureDetector] Detection error:', error);
-                const totalTime = performance.now() - startTime;
-                const avgConfidence = executedMethods.length > 0
-                    ? executedMethods.reduce((sum, m) => sum + m.confidence, 0) / executedMethods.length
-                    : 0;
-                if (debug) {
-                    debug.endTime = performance.now();
-                    debug.totalTimeMs = totalTime;
-                    debug.finalDecision = {
-                        isScreenCapture: false,
-                        confidenceScore: avgConfidence,
-                    };
-                }
-                return new ScreenCaptureDetectionResult(false, avgConfidence, executedMethods, 'low', totalTime, debug);
-            }
-        }
-    }
-
-    /**
-     * 屏幕边角、轮廓检测器
-     * 用于快速判定当前图片是否从屏幕拍摄
-     * 通过检测图片中的屏幕边界轮廓（矩形框）
-     */
-    /**
-     * 默认的屏幕边角、轮廓检测器配置
-     * 优化用于快速检测摄像头拍摄的手机/平板屏幕
-     * 严格模式：仅当非常确定时才判定为屏幕
-     */
-    const DEFAULT_SCREEN_CORNERS_CONTOUR_DETECTOR_OPTIONS = {
-        // Canny 边缘检测参数
-        edgeThreshold1: 35,
-        edgeThreshold2: 110,
-        // 轮廓检测参数（提高面积阈值以排除小轮廓误检）
-        minContourArea: 1200,
-        // 综合判断参数（严格阈值）
-        // screenConfidenceThreshold: 0.75 表示需要 75% 的置信度
-        // screenBoundaryRatioThreshold: 0.25 表示屏幕占比需要 >= 25%
-        screenConfidenceThreshold: 0.75,
-        screenBoundaryRatioThreshold: 0.25
-    };
-    /**
-     * 屏幕边角、轮廓检测器
-     * 用快速边缘和轮廓检测来识别屏幕采集
-     */
-    class ScreenCornersContourDetector {
-        cv = null;
-        config;
-        /**
-         * 构造函数
-         * @param options - 检测器配置选项
+         * 返回值 0-1：值越接近1说明脸部形状越稳定（越可能是照片）
          */
-        constructor(options) {
-            this.config = {
-                ...DEFAULT_SCREEN_CORNERS_CONTOUR_DETECTOR_OPTIONS,
-                ...(options || {})
-            };
-        }
         /**
-         * 设置 OpenCV 实例
-         */
-        setCVInstance(cv) {
-            this.cv = cv;
+         * 检查脸部形状稳定性
+         *
+         * 【重要修复】使用归一化坐标进行比较
+         * 这样即使人脸在画面中移动或缩放，比较仍然有效
+         */
+        checkFaceShapeStability() {
+            // 【关键】使用归一化坐标历史
+            if (this.normalizedLandmarksHistory.length < 5) {
+                return 0.5; // 数据不足
+            }
+            // 【第一层防护】检测照片平面性（Z坐标深度）
+            // 注意：这个方法使用原始坐标的Z值，因为Z是相对深度
+            const planarity = this.detectPhotoPlanarity();
+            if (planarity > 0.7) {
+                // 检测到照片平面特征（Z坐标变异很小）
+                console.debug('[FaceShapeStability] Detected planar face (photo), planarity:', planarity.toFixed(3));
+                return 0.95; // 非常可能是照片
+            }
+            // 【第二层防护】检测脸部形状稳定性
+            // 使用归一化坐标计算距离
+            const faceDistances = [];
+            // 计算以下距离：
+            // 1. 左眼-右眼（眼距）
+            // 2. 上嘴唇-下嘴唇（嘴高）
+            // 3. 左脸颊-右脸颊（脸宽）
+            for (const frame of this.normalizedLandmarksHistory) {
+                if (frame.length >= 468) {
+                    const eyeDist = this.pointDist(frame[33], frame[263]); // 左右眼外角距离
+                    const mouthHeight = Math.abs(frame[13][1] - frame[14][1]); // 上下嘴唇距离
+                    const faceWidth = this.pointDist(frame[234], frame[454]); // 左右脸颊边缘距离
+                    faceDistances.push([eyeDist, mouthHeight, faceWidth]);
+                }
+            }
+            if (faceDistances.length < 3) {
+                return 0.5;
+            }
+            // 计算每个距离的变异系数（越小说明越固定）
+            let totalCV = 0;
+            for (let i = 0; i < 3; i++) {
+                const values = faceDistances.map(d => d[i]);
+                const mean = values.reduce((a, b) => a + b, 0) / values.length;
+                const stdDev = this.calculateStdDev(values);
+                // 归一化坐标下，调整阈值
+                const cv = mean > 0.01 ? stdDev / mean : 0;
+                totalCV += cv;
+            }
+            const avgCV = totalCV / 3;
+            // CV越小，形状越稳定
+            // 如果avgCV < 0.02，说明形状完全不变（可能是照片）
+            // 如果avgCV > 0.1，说明形状在变化（活体）
+            const shapeStability = Math.min(Math.max(0.02 - avgCV, 0) / 0.02, 1);
+            // 综合得分：结合平面性和形状稳定性
+            const combinedStability = Math.max(shapeStability, planarity * 0.5);
+            console.debug('[FaceShapeStability]', {
+                avgCV: avgCV.toFixed(4),
+                planarity: planarity.toFixed(3),
+                shapeStability: shapeStability.toFixed(3),
+                combinedStability: combinedStability.toFixed(3)
+            });
+            return Math.min(combinedStability, 1);
         }
-        /**
-         * 检测图片是否为屏幕采集
-         * @param grayFrame - 灰度图像 Mat
-         * @returns 检测结果
-         */
-        detect(grayFrame) {
-            const startTime = performance.now();
-            if (!this.cv || !grayFrame) {
-                return {
-                    isScreenCapture: false,
-                    confidence: 0,
-                    contourCount: 0,
-                    screenBoundaryRatio: 0,
-                    processingTimeMs: performance.now() - startTime
-                };
-            }
-            try {
-                // 轮廓检测（检测屏幕矩形边界）
-                const contourResult = this.detectContours(grayFrame);
-                const screenLikeContours = contourResult.count;
-                const screenBoundaryRatio = contourResult.boundaryRatio;
-                // 简化的置信度计算：基于轮廓数量和边界占比
-                const confidence = this.calculateScreenConfidence(screenLikeContours, screenBoundaryRatio);
-                const isScreenCapture = confidence >= this.config.screenConfidenceThreshold;
-                return {
-                    isScreenCapture,
-                    confidence,
-                    contourCount: screenLikeContours,
-                    screenBoundaryRatio,
-                    processingTimeMs: performance.now() - startTime
-                };
+        extractKeypoints(face) {
+            const keypoints = {};
+            if (face.mesh && Array.isArray(face.mesh)) {
+                keypoints.landmarks = face.mesh;
             }
-            finally {
-                // 清理资源
+            if (keypoints.landmarks && keypoints.landmarks.length >= 468) {
+                // 左眼关键点 (MediaPipe Face Mesh 标准索引)
+                // 按顺序：外眼角、上眼睑上、上眼睑、内眼角、下眼睑、下眼睑下
+                keypoints.leftEye = [
+                    keypoints.landmarks[362], // 外眼角
+                    keypoints.landmarks[385], // 上眼睑上
+                    keypoints.landmarks[387], // 上眼睑
+                    keypoints.landmarks[263], // 内眼角
+                    keypoints.landmarks[373], // 下眼睑
+                    keypoints.landmarks[380] // 下眼睑下
+                ].filter(p => p !== undefined);
+                // 右眼关键点 (MediaPipe Face Mesh 标准索引)
+                keypoints.rightEye = [
+                    keypoints.landmarks[33], // 外眼角
+                    keypoints.landmarks[160], // 上眼睑上
+                    keypoints.landmarks[158], // 上眼睑
+                    keypoints.landmarks[133], // 内眼角
+                    keypoints.landmarks[153], // 下眼睑
+                    keypoints.landmarks[144] // 下眼睑下
+                ].filter(p => p !== undefined);
+                // 嘴巴关键点
+                keypoints.mouth = [
+                    keypoints.landmarks[61], // 左嘴角
+                    keypoints.landmarks[185], // 上嘴唇左
+                    keypoints.landmarks[40], // 上嘴唇中左
+                    keypoints.landmarks[39], // 上嘴唇中
+                    keypoints.landmarks[37], // 上嘴唇中右
+                    keypoints.landmarks[0], // 上嘴唇右
+                    keypoints.landmarks[267], // 下嘴唇右
+                    keypoints.landmarks[269], // 下嘴唇中右
+                    keypoints.landmarks[270], // 下嘴唇中
+                    keypoints.landmarks[409] // 下嘴唇左
+                ].filter(p => p !== undefined);
             }
+            return keypoints;
         }
-        /**
-         * 轮廓检测 - 检测屏幕矩形边界
-         */
-        detectContours(grayFrame) {
-            const edges = new this.cv.Mat();
-            const contours = new this.cv.MatVector();
+        calculateEyeAspectRatio(eye) {
+            if (!eye || eye.length < 6)
+                return 0;
             try {
-                // 边缘检测
-                this.cv.Canny(grayFrame, edges, this.config.edgeThreshold1, this.config.edgeThreshold2);
-                // 检测轮廓
-                this.cv.findContours(edges, contours, new this.cv.Mat(), this.cv.RETR_TREE, this.cv.CHAIN_APPROX_SIMPLE);
-                let screenLikeContours = 0;
-                let totalScreenBoundaryArea = 0;
-                const imageArea = grayFrame.rows * grayFrame.cols;
-                // 遍历轮廓，找出矩形轮廓（屏幕边界）
-                for (let i = 0; i < contours.size(); i++) {
-                    const contour = contours.get(i);
-                    const area = this.cv.contourArea(contour);
-                    // 忽略过小的轮廓
-                    if (area < this.config.minContourArea) {
-                        contour.delete();
-                        continue;
-                    }
-                    // 使用多边形近似
-                    const approx = new this.cv.Mat();
-                    const arcLength = this.cv.arcLength(contour, true);
-                    this.cv.approxPolyDP(contour, approx, 0.02 * arcLength, true);
-                    // 检查是否是四边形（屏幕边界特征）
-                    if (approx.rows === 4) {
-                        // 检查四边形是否接近矩形
-                        if (this.isRectangleShape(approx)) {
-                            screenLikeContours++;
-                            totalScreenBoundaryArea += area;
-                        }
-                    }
-                    approx.delete();
-                    contour.delete();
-                }
-                const boundaryRatio = imageArea > 0 ? totalScreenBoundaryArea / imageArea : 0;
-                return {
-                    count: screenLikeContours,
-                    boundaryRatio
-                };
+                const v1 = this.pointDist(eye[1], eye[5]);
+                const v2 = this.pointDist(eye[2], eye[4]);
+                const h = this.pointDist(eye[0], eye[3]);
+                return h === 0 ? 0 : (v1 + v2) / (2 * h);
             }
-            finally {
-                edges.delete();
-                contours.delete();
+            catch {
+                return 0;
             }
         }
-        /**
-         * 检查四边形是否接近矩形
-         */
-        isRectangleShape(contour) {
+        calculateMouthAspectRatio(mouth) {
+            if (!mouth || mouth.length < 6)
+                return 0;
             try {
-                const points = [];
-                for (let i = 0; i < contour.rows; i++) {
-                    points.push({
-                        x: contour.data32F[i * 2],
-                        y: contour.data32F[i * 2 + 1]
-                    });
-                }
-                if (points.length !== 4)
-                    return false;
-                // 计算所有边的长度
-                const distances = [];
-                for (let i = 0; i < 4; i++) {
-                    const p1 = points[i];
-                    const p2 = points[(i + 1) % 4];
-                    const dist = Math.sqrt((p2.x - p1.x) ** 2 + (p2.y - p1.y) ** 2);
-                    distances.push(dist);
-                }
-                // 对边长度应该接近（矩形特性）
-                return (Math.abs(distances[0] - distances[2]) < Math.max(distances[0], distances[2]) * 0.2 &&
-                    Math.abs(distances[1] - distances[3]) < Math.max(distances[1], distances[3]) * 0.2);
+                const upperY = mouth.slice(0, 5).reduce((s, p) => s + (p?.[1] || 0), 0) / 5;
+                const lowerY = mouth.slice(5).reduce((s, p) => s + (p?.[1] || 0), 0) / 5;
+                const w = this.pointDist(mouth[0], mouth[5]);
+                return w === 0 ? 0 : Math.abs(upperY - lowerY) / w;
             }
             catch {
-                return false;
+                return 0;
             }
         }
-        /**
-         * 简化的屏幕检测置信度计算
-         */
-        calculateScreenConfidence(contourCount, boundaryRatio) {
-            // 检测到矩形轮廓是主要指标
-            const contourConfidence = Math.min(contourCount, 1.0); // 0-1个轮廓
-            // 屏幕边界占比是辅助指标
-            const boundaryConfidence = Math.min(boundaryRatio / this.config.screenBoundaryRatioThreshold, 1.0);
-            // 综合置信度：主要基于轮廓数量，辅以边界占比
-            return Math.min(contourConfidence * 0.7 + boundaryConfidence * 0.3, 1.0);
+        pointDist(p1, p2) {
+            if (!p1 || !p2 || p1.length < 2 || p2.length < 2)
+                return 0;
+            const dx = p1[0] - p2[0];
+            const dy = p1[1] - p2[1];
+            return Math.sqrt(dx * dx + dy * dy);
+        }
+        calculateStdDev(values) {
+            if (values.length < 2)
+                return 0;
+            const mean = values.reduce((a, b) => a + b, 0) / values.length;
+            const variance = values.reduce((a, v) => a + (v - mean) ** 2, 0) / values.length;
+            return Math.sqrt(variance);
         }
         /**
-         * 获取检测器状态消息
+         * 【关键方法】将关键点坐标归一化到人脸局部坐标系
+         *
+         * 问题：
+         * - MediaPipe 返回的 x,y 坐标是相对于【图像左上角】的像素坐标
+         * - 如果人脸在画面中移动，同一个关键点的绝对坐标会完全不同
+         * - 多帧之间直接比较绝对坐标是错误的！
+         *
+         * 解决：
+         * - 将坐标转换为相对于人脸边界框的归一化坐标
+         * - 归一化坐标 = (点坐标 - 人脸左上角) / 人脸尺寸
+         * - 这样无论人脸在画面中的位置，归一化坐标都一致
+         *
+         * @param landmarks 原始关键点数组
+         * @param faceBox 人脸边界框 [x, y, width, height]
+         * @returns 归一化后的关键点数组
          */
-        getMessage(confidence) {
-            if (confidence < 0.3) {
-                return 'No screen detected';
-            }
-            else if (confidence < 0.6) {
-                return 'Possible screen detected';
+        normalizeLandmarks(landmarks, faceBox) {
+            // faceBox: [x, y, width, height] 或 {x, y, width, height}
+            let boxX, boxY, boxW, boxH;
+            if (Array.isArray(faceBox)) {
+                [boxX, boxY, boxW, boxH] = faceBox;
             }
             else {
-                return 'Screen detected';
+                // 兼容对象格式
+                boxX = faceBox.x || 0;
+                boxY = faceBox.y || 0;
+                boxW = faceBox.width || 1;
+                boxH = faceBox.height || 1;
+            }
+            // 防止除零
+            if (boxW <= 0)
+                boxW = 1;
+            if (boxH <= 0)
+                boxH = 1;
+            const normalized = [];
+            for (const pt of landmarks) {
+                if (pt && pt.length >= 2) {
+                    // 归一化 x, y 到 [0, 1] 相对于人脸框
+                    const nx = (pt[0] - boxX) / boxW;
+                    const ny = (pt[1] - boxY) / boxH;
+                    // Z 坐标保持不变（MediaPipe 的 Z 是相对于人脸中心的）
+                    const nz = pt.length >= 3 ? pt[2] : 0;
+                    normalized.push([nx, ny, nz]);
+                }
+                else {
+                    normalized.push([0, 0, 0]);
+                }
             }
+            return normalized;
+        }
+        createEmptyResult() {
+            return new MotionDetectionResult(true, {
+                frameCount: 0,
+                eyeAspectRatioStdDev: 0,
+                mouthAspectRatioStdDev: 0,
+                eyeFluctuation: 0,
+                mouthFluctuation: 0,
+                muscleVariation: 0,
+                hasEyeMovement: false,
+                hasMouthMovement: false,
+                hasMuscleMovement: false
+            });
+        }
+        getStatistics() {
+            return {
+                eyeHistorySize: this.eyeAspectRatioHistory.length,
+                mouthHistorySize: this.mouthAspectRatioHistory.length,
+                eyeValues: this.eyeAspectRatioHistory.map(v => v.toFixed(4)),
+                mouthValues: this.mouthAspectRatioHistory.map(v => v.toFixed(4))
+            };
         }
     }
 
@@ -4450,32 +3071,15 @@
         lastFrontalScore = 1;
         motionDetector = null;
         liveness = false;
-        realness = false;
-        screenDetector = null;
-        cornersContourDetector = null;
         constructor(options) {
             Object.assign(this, options);
         }
         reset() {
             this.clearActionVerifyTimeout();
             const savedMotionDetector = this.motionDetector;
-            const savedScreenDetector = this.screenDetector;
-            const savedCornersContourDetector = this.cornersContourDetector;
             savedMotionDetector?.reset();
             Object.assign(this, new DetectionState({}));
             this.motionDetector = savedMotionDetector;
-            this.screenDetector = savedScreenDetector;
-            this.cornersContourDetector = savedCornersContourDetector;
-        }
-        updateVideoFPS(fps) {
-            if (this.screenDetector === null) {
-                this.screenDetector = new ScreenCaptureDetector(fps);
-                return;
-            }
-            if (this.screenDetector.getFPS() !== fps) {
-                this.screenDetector.reset();
-                this.screenDetector = new ScreenCaptureDetector(fps);
-            }
         }
         // 默认方法
         needFrontalFace() {
@@ -4484,7 +3088,7 @@
         // 是否准备好进行动作验证
         isReadyToVerify(minCollectCount) {
             if (this.period === exports.DetectionPeriod.COLLECT
-                && this.liveness && this.realness
+                && this.liveness
                 && this.collectCount >= minCollectCount) {
                 return true;
             }
@@ -4506,11 +3110,6 @@
             this.completedActions.add(this.currentAction);
             this.currentAction = null;
         }
-        setCVInstance(cvInstance) {
-            this.motionDetector?.setCVInstance(cvInstance);
-            this.screenDetector?.setCVInstance(cvInstance);
-            this.cornersContourDetector?.setCVInstance(cvInstance);
-        }
         /**
          * Clear action verify timeout
          */
@@ -4522,11 +3121,9 @@
         }
     }
     // <-- Add this import at the top if ResolvedEngineOptions is defined in types.ts
-    function createDetectionState(fps, strictPhotoDetection) {
+    function createDetectionState() {
         const detectionState = new DetectionState({});
-        detectionState.motionDetector = new MotionLivenessDetector(strictPhotoDetection);
-        detectionState.screenDetector = new ScreenCaptureDetector(fps);
-        detectionState.cornersContourDetector = new ScreenCornersContourDetector();
+        detectionState.motionDetector = new MotionLivenessDetector();
         return detectionState;
     }
 
@@ -4564,8 +3161,6 @@
         isDetectingFrameActive = false;
         // Frame-based detection scheduling
         frameIndex = 0;
-        lastDetectionFrameIndex = 0;
-        lastScreenFeatureDetectionFrameIndex = 0;
         // Frame Mat objects created per-frame, cleaned up immediately after use
         detectionState;
         /**
@@ -4575,8 +3170,7 @@
         constructor(options) {
             super();
             this.options = mergeOptions(options);
-            this.adjustDetectFrameDelay();
-            this.detectionState = createDetectionState(this.videoFPS, this.options.motion_liveness_strict_photo_detection);
+            this.detectionState = createDetectionState();
         }
         /**
          * 提取错误信息的辅助方法 - 处理各种错误类型
@@ -4642,9 +3236,7 @@
                 this.stopDetection(false);
             }
             this.options = mergeOptions(options);
-            this.adjustDetectFrameDelay();
-            this.detectionState = createDetectionState(this.videoFPS, this.options.motion_liveness_strict_photo_detection);
-            this.detectionState.setCVInstance(this.cv);
+            this.detectionState = createDetectionState();
             this.emitDebug('config', 'Engine options updated', { wasDetecting }, 'info');
         }
         getEngineState() {
@@ -4725,8 +3317,6 @@
             this.detectionState.reset();
             // Reset frame counters
             this.frameIndex = 0;
-            this.lastDetectionFrameIndex = 0;
-            this.lastScreenFeatureDetectionFrameIndex = 0;
             // Keep Mat pool and canvas (they'll be reused)
             // Don't set isDetectingFrameActive = false here (let finally handle it)
         }
@@ -4745,8 +3335,6 @@
             }
             // Reset frame counters
             this.frameIndex = 0;
-            this.lastDetectionFrameIndex = 0;
-            this.lastScreenFeatureDetectionFrameIndex = 0;
             // Clear frame canvas (releases memory)
             try {
                 this.clearFrameCanvas();
@@ -4793,8 +3381,6 @@
                 const cv_version = getOpenCVVersion();
                 this.emitDebug('initialization', 'OpenCV loaded successfully', { version: cv_version });
                 console.log('[FaceDetectionEngine] OpenCV loaded successfully', { version: cv_version });
-                // Inject OpenCV instance into motion detector and screen detector
-                this.detectionState.setCVInstance(this.cv);
                 // Load Human.js
                 console.log('[FaceDetectionEngine] Loading Human.js models...');
                 this.emitDebug('initialization', 'Loading Human.js...');
@@ -5176,109 +3762,6 @@
                 return;
             console.log(`[FaceDetectionEngine] Video FPS changed: ${this.videoFPS} -> ${fps}`);
             this.videoFPS = fps;
-            this.detectionState.updateVideoFPS(fps);
-            // 当FPS变化时，检查是否需要调整检测延迟以保证最小周期
-            this.adjustDetectFrameDelay();
-        }
-        /**
-         * Adjust detect_frame_delay to ensure main detection interval is at least 3 frames
-         * This is important for proper spacing of corner detection, feature detection, and main detection
-         */
-        adjustDetectFrameDelay() {
-            const minInterval = 3;
-            const currentInterval = this.getDetectionFrameInterval();
-            if (currentInterval < minInterval) {
-                // 计算所需的最小 detect_frame_delay
-                // getDetectionFrameInterval() = Math.round(detect_frame_delay * videoFPS / 1000)
-                // 需要: detect_frame_delay * videoFPS / 1000 >= minInterval
-                // 所以: detect_frame_delay >= minInterval * 1000 / videoFPS
-                const minDetectFrameDelay = Math.ceil(minInterval * 1000 / this.videoFPS);
-                const oldDelay = this.options.detect_frame_delay;
-                this.options.detect_frame_delay = minDetectFrameDelay;
-                this.emitDebug('config', 'Adjusted detect_frame_delay to maintain minimum interval', {
-                    reason: 'main detection interval was less than 3 frames',
-                    oldDelay: oldDelay,
-                    newDelay: minDetectFrameDelay,
-                    oldInterval: currentInterval,
-                    newInterval: this.getDetectionFrameInterval(),
-                    videoFPS: this.videoFPS
-                });
-                console.log(`[FaceDetectionEngine] Adjusted detect_frame_delay: ${oldDelay}ms -> ${minDetectFrameDelay}ms (interval: ${currentInterval} -> ${this.getDetectionFrameInterval()})`);
-            }
-        }
-        /**
-         * Get the frame interval for main face detection based on videoFPS and detect_frame_delay
-         * Uses Math.ceil to ensure actual interval >= configured delay
-         * @returns Number of frames between detections
-         */
-        getDetectionFrameInterval() {
-            // Ceil ensures actual delay never goes below configured detect_frame_delay
-            return Math.max(1, Math.ceil(this.options.detect_frame_delay * this.videoFPS / 1000));
-        }
-        /**
-         * Check if main face detection should be performed this frame
-         * @returns true if enough frames have passed since last detection
-         */
-        shouldPerformMainDetection() {
-            const mainInterval = this.getDetectionFrameInterval();
-            return (this.frameIndex - this.lastDetectionFrameIndex) >= mainInterval;
-        }
-        /**
-         * Check if screen corner detection should be performed this frame
-         * Executes once per main detection interval
-         * Logic:
-         * - If mainInterval <= 2: disabled (insufficient frames)
-         * - If mainInterval > 2: executes at calculated point, unless it's the last frame
-         * @returns true if conditions are met
-         */
-        shouldPerformScreenCornersDetection() {
-            // 未开始采集前，不执行屏幕检测
-            if (this.detectionState.period === exports.DetectionPeriod.DETECT)
-                return false;
-            const mainInterval = this.getDetectionFrameInterval();
-            // 周期太短，无法同时执行主检测、特征检测和边缘检测
-            if (mainInterval <= 2) {
-                return false;
-            }
-            const currentPositionInCycle = this.frameIndex % mainInterval;
-            // 边缘检测在周期的约80%位置
-            let cornersExecutionPoint = Math.floor(mainInterval * 0.8);
-            // 如果计算出的位置是最后一帧，则往前退一位
-            // 这确保边缘检测不会被当作"周期最后一帧的备选特征检测"
-            if (cornersExecutionPoint === mainInterval - 1 && mainInterval > 3) {
-                cornersExecutionPoint = Math.floor(mainInterval * 0.6);
-            }
-            return currentPositionInCycle === cornersExecutionPoint;
-        }
-        /**
-         * Check if screen feature detection (multi-frame) should be performed this frame
-         * Logic:
-         * - Executes at calculated point in the cycle (40% position)
-         * - If missed, can execute at last frame of cycle (fallback)
-         * @returns true if conditions are met
-         */
-        shouldPerformScreenFeatureDetection() {
-            // 未开始采集前，不执行屏幕检测
-            if (this.detectionState.period === exports.DetectionPeriod.DETECT)
-                return false;
-            const mainInterval = this.getDetectionFrameInterval();
-            const currentPositionInCycle = this.frameIndex % mainInterval;
-            // 特征检测在周期的40%位置执行（标准点）
-            const featureExecutionPoint = Math.floor(mainInterval * 0.4);
-            // 在标准执行点执行
-            if (currentPositionInCycle === featureExecutionPoint) {
-                return true;
-            }
-            // 备选方案：如果是周期的最后一帧，且本周期还未执行过特征检测
-            const isLastFrameInCycle = currentPositionInCycle === (mainInterval - 1);
-            if (isLastFrameInCycle) {
-                // 计算当前周期的起始帧（>=0 的最小值）
-                const cycleStartFrame = Math.floor(this.frameIndex / mainInterval) * mainInterval;
-                // 检查此周期是否已执行过特征检测
-                const hasExecutedInThisCycle = this.lastScreenFeatureDetectionFrameIndex >= cycleStartFrame;
-                return !hasExecutedInThisCycle;
-            }
-            return false;
         }
         /**
          * Cancel pending detection frame
@@ -5328,44 +3811,13 @@
             this.frameIndex++;
             this.emitDebug('detection', '进入检测帧循环', {
                 frameIndex: this.frameIndex,
-                frameInterval: this.getDetectionFrameInterval(),
                 period: this.detectionState.period,
                 engineState: this.engineState,
                 videoReadyState: this.videoElement.readyState
             }, 'info');
-            let bgrFrame = null;
-            let grayFrame = null;
             try {
-                // 确定是否需要捕获帧
-                if (!this.shouldCaptureFrame()) {
-                    return;
-                }
-                this.emitDebug('detection', '准备采集帧数据', { frameIndex: this.frameIndex }, 'info');
-                const frameData = this.captureAndPrepareFrames();
-                if (!frameData) {
-                    this.emitDebug('detection', '帧采集失败，无法继续检测', {
-                        frameIndex: this.frameIndex
-                    }, 'warn');
-                    return;
-                }
-                // 帧采集成功日志已移除，减少高频输出
-                bgrFrame = frameData.bgrFrame;
-                grayFrame = frameData.grayFrame;
-                // 添加到屏幕检测器缓冲
-                if (this.detectionState.period !== exports.DetectionPeriod.DETECT) {
-                    this.detectionState.screenDetector?.addVideoFrame(grayFrame, bgrFrame);
-                    // 帧添加日志已移除，减少高频输出
-                }
-                // 执行屏幕检测（边角 + 多帧特征）
-                if (this.performScreenDetection(grayFrame)) {
-                    this.emitDebug('detection', '屏幕检测：检测到屏幕，返回', {
-                        frameIndex: this.frameIndex
-                    }, 'warn');
-                    return;
-                }
-                // 执行主人脸检测
-                await this.performFaceDetection(grayFrame, bgrFrame);
-                // 人脸检测完成日志已移除，减少高频输出
+                // 执行人脸检测
+                await this.performFaceDetection();
             }
             catch (error) {
                 const errorInfo = this.extractErrorInfo(error);
@@ -5377,15 +3829,6 @@
                 }, 'error');
             }
             finally {
-                // 清理非池化的Mat对象（必须执行，即使发生错误也要释放内存）
-                try {
-                    this.cleanupFrames(bgrFrame, grayFrame);
-                }
-                catch (cleanupError) {
-                    this.emitDebug('detection', 'Error in finally cleanup', {
-                        error: cleanupError.message
-                    }, 'error');
-                }
                 // 清除检测帧活跃标志
                 this.isDetectingFrameActive = false;
                 // 调度下一帧的检测（仅当引擎仍在检测状态时）
@@ -5396,15 +3839,6 @@
                 }
             }
         }
-        /**
-         * Check if current frame should be captured based on detection scheduling
-         */
-        shouldCaptureFrame() {
-            return this.shouldPerformMainDetection()
-                || this.shouldPerformScreenCornersDetection()
-                || this.shouldPerformScreenFeatureDetection()
-                || this.detectionState.period !== exports.DetectionPeriod.DETECT;
-        }
         /**
          * Capture video frame and convert to BGR and Grayscale Mat objects
          * @returns {Object | null} Object with bgrFrame and grayFrame, or null if failed
@@ -5455,58 +3889,10 @@
             }
             return { bgrFrame, grayFrame };
         }
-        /**
-         * Perform screen detection (corners and multi-frame features)
-         * @returns true if screen is detected, false otherwise
-         */
-        performScreenDetection(grayFrame) {
-            // 执行屏幕边角检测
-            if (this.shouldPerformScreenCornersDetection()) {
-                try {
-                    const isScreenDetected = this.detectScreenCorners(grayFrame);
-                    if (isScreenDetected) {
-                        this.partialResetDetectionState();
-                        return true;
-                    }
-                }
-                catch (screenDetectError) {
-                    const errorInfo = this.extractErrorInfo(screenDetectError);
-                    this.emitDebug('screen-detection', 'Screen corners detection failed', {
-                        error: errorInfo.message,
-                        stack: errorInfo.stack,
-                        name: errorInfo.name
-                    }, 'error');
-                }
-            }
-            // 执行屏幕多帧特征检测
-            if (this.shouldPerformScreenFeatureDetection()) {
-                this.lastScreenFeatureDetectionFrameIndex = this.frameIndex;
-                try {
-                    const isScreenDetected = this.detectScreenFeatures();
-                    if (isScreenDetected) {
-                        this.partialResetDetectionState();
-                        return true;
-                    }
-                }
-                catch (screenDetectError) {
-                    const errorInfo = this.extractErrorInfo(screenDetectError);
-                    this.emitDebug('screen-detection', 'Screen feature detection failed', {
-                        error: errorInfo.message,
-                        stack: errorInfo.stack,
-                        name: errorInfo.name
-                    }, 'error');
-                }
-            }
-            return false;
-        }
         /**
          * Perform main face detection and handle results
          */
-        async performFaceDetection(grayFrame, bgrFrame) {
-            if (!this.shouldPerformMainDetection()) {
-                return;
-            }
-            this.lastDetectionFrameIndex = this.frameIndex;
+        async performFaceDetection() {
             // Perform face detection
             let result;
             try {
@@ -5533,20 +3919,12 @@
             const faces = result.face || [];
             const gestures = result.gesture || [];
             if (faces.length === 1) {
-                this.handleSingleFace(faces[0], gestures, grayFrame, bgrFrame);
+                this.handleSingleFace(faces[0], gestures);
             }
             else {
                 this.handleMultipleFaces(faces.length);
             }
         }
-        /**
-         * Clean up frame Mat objects
-         * Note: Both BGR and Gray Mats are preallocated and reused
-         * They are only deleted in clearPreallocatedMats()
-         */
-        cleanupFrames(bgrFrame, grayFrame) {
-            // No-op: both Mats are preallocated and cleaned up separately
-        }
         getPerformActionCount() {
             if (this.options.action_liveness_action_count <= 0) {
                 this.emitDebug('config', 'liveness_action_count is 0 or negative', { count: this.options.action_liveness_action_count }, 'info');
@@ -5558,84 +3936,10 @@
             }
             return Math.min(this.options.action_liveness_action_count, actionListLength);
         }
-        /**
-         * Detect screen by corners and contours analysis (fast detection)
-         */
-        detectScreenCorners(grayFrame) {
-            const cornersContourResult = this.detectionState.cornersContourDetector?.detect(grayFrame);
-            if (cornersContourResult?.isScreenCapture) {
-                this.emitDebug('screen-corners-detection', 'Screen boundary detected - possible screen capture', {
-                    confidence: cornersContourResult.confidence,
-                    contourCount: cornersContourResult.contourCount,
-                    screenBoundaryRatio: cornersContourResult.screenBoundaryRatio,
-                    processingTimeMs: cornersContourResult.processingTimeMs,
-                }, 'warn');
-                this.emitDetectorInfo({
-                    code: exports.DetectionCode.FACE_NOT_REAL,
-                    message: 'Screen capture detected by corners/contour analysis',
-                    screenConfidence: cornersContourResult.confidence
-                });
-                return true;
-            }
-            if (cornersContourResult) {
-                this.emitDebug('screen-corners-detection', 'Screen boundary not detected', {
-                    confidence: cornersContourResult.confidence,
-                    contourCount: cornersContourResult.contourCount,
-                    screenBoundaryRatio: cornersContourResult.screenBoundaryRatio,
-                    processingTimeMs: cornersContourResult.processingTimeMs
-                }, 'info');
-            }
-            return false;
-        }
-        /**
-         * Detect screen by multi-frame feature analysis
-         */
-        detectScreenFeatures() {
-            // 屏幕捕获检测（多帧特征检测）
-            const screenResult = this.detectionState.screenDetector?.detect(this.options.debug_mode, true);
-            if (screenResult?.isScreenCapture) {
-                this.emitDebug('screen-detection', 'Screen capture detected - possible video replay attack', {
-                    screenConfidence: screenResult.confidenceScore,
-                    riskLevel: screenResult.riskLevel,
-                    processingTimeMs: screenResult.processingTimeMs,
-                    executedMethodsCount: screenResult.executedMethods?.length || 0,
-                    executedMethodsSummary: screenResult.executedMethods?.map((m) => ({
-                        method: m.method,
-                        isScreenCapture: m.isScreenCapture,
-                        confidence: m.confidence
-                        // details 字段已移除，避免输出超大数据
-                    })),
-                    stageCount: screenResult.debug?.stages?.length || 0,
-                    finalDecision: screenResult.debug?.finalDecision
-                }, 'warn');
-                this.emitDetectorInfo({
-                    code: exports.DetectionCode.FACE_NOT_REAL,
-                    message: screenResult.getMessage(),
-                    screenConfidence: screenResult.confidenceScore
-                });
-                return true;
-            }
-            if (screenResult) {
-                // 只有ready状态的检测器的success结果才可信
-                if (this.detectionState.screenDetector?.isReady() && !screenResult.isScreenCapture) {
-                    this.detectionState.realness = true;
-                    this.emitDebug('screen-detection', 'Screen capture not detected', {
-                        screenConfidence: screenResult.confidenceScore,
-                        riskLevel: screenResult.riskLevel,
-                        processingTimeMs: screenResult.processingTimeMs,
-                        executedMethodsCount: screenResult.executedMethods?.length || 0,
-                        methodsSummary: screenResult.executedMethods?.map((m) => `${m.method}:${m.confidence?.toFixed(2)}`).join(', ') || 'none',
-                        stageCount: screenResult.debug?.stages?.length || 0
-                        // 移除了 executedMethods 和 stageDetails 的完整数据，避免超大输出
-                    }, 'warn');
-                }
-            }
-            return false;
-        }
         /**
          * Handle single face detection
          */
-        handleSingleFace(face, gestures, grayFrame, bgrFrame) {
+        handleSingleFace(face, gestures) {
             const faceBox = face.box || face.boxRaw;
             if (!faceBox) {
                 console.warn('[FaceDetector] Face detected but no box/boxRaw property');
@@ -5652,38 +3956,35 @@
                 this.stopDetection(false);
                 return;
             }
+            let bgrFrame = null;
+            let grayFrame = null;
             try {
-                // 运动检测
-                const motionResult = this.detectionState.motionDetector.analyzeMotion(grayFrame, face, faceBox);
+                const frameData = this.captureAndPrepareFrames();
+                if (!frameData) {
+                    this.emitDebug('detection', '帧采集失败，无法继续检测', {
+                        frameIndex: this.frameIndex
+                    }, 'warn');
+                    return;
+                }
+                bgrFrame = frameData.bgrFrame;
+                grayFrame = frameData.grayFrame;
+                const motionResult = this.detectionState.motionDetector.analyzeMotion(grayFrame, faceBox);
                 // 只有ready状态的检测器的结果才可信
                 if (this.detectionState.motionDetector.isReady()) {
                     if (!motionResult.isLively) {
                         this.emitDebug('motion-detection', 'Motion liveness check failed - possible photo attack', {
-                            motionScore: motionResult.motionScore,
-                            keypointVariance: motionResult.keypointVariance,
-                            opticalFlowMagnitude: motionResult.opticalFlowMagnitude,
-                            eyeMotionScore: motionResult.eyeMotionScore,
-                            mouthMotionScore: motionResult.mouthMotionScore,
-                            motionType: motionResult.motionType,
-                            details: motionResult.details
+                            details: motionResult.details,
+                            message: motionResult.getMessage()
                         }, 'warn');
                         this.emitDetectorInfo({
                             code: exports.DetectionCode.FACE_NOT_LIVE,
-                            message: motionResult.getMessage(this.detectionState.motionDetector.getOptions().minMotionThreshold, this.detectionState.motionDetector.getOptions().minKeypointVariance),
-                            motionScore: motionResult.motionScore,
-                            keypointVariance: motionResult.keypointVariance,
-                            motionType: motionResult.motionType
+                            message: motionResult.getMessage(),
                         });
                         this.partialResetDetectionState();
                         return;
                     }
                     this.emitDebug('motion-detection', 'Motion liveness check passed', {
-                        motionScore: motionResult.motionScore,
-                        keypointVariance: motionResult.keypointVariance,
-                        opticalFlowMagnitude: motionResult.opticalFlowMagnitude,
-                        eyeMotionScore: motionResult.eyeMotionScore,
-                        mouthMotionScore: motionResult.mouthMotionScore,
-                        motionType: motionResult.motionType
+                        details: motionResult.details
                     }, 'warn');
                     this.detectionState.liveness = true;
                 }