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

package/dist/index.esm.js

@@ -71,7 +71,7 @@ var EngineState;
 /**
  * Default configuration for FaceDetectionEngine
  */
-const DEFAULT_OPTIONS = {
+const DEFAULT_OPTIONS$1 = {
     // Resource paths
     human_model_path: undefined,
     tensorflow_wasm_path: undefined,
@@ -85,7 +85,6 @@ const DEFAULT_OPTIONS = {
     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,
@@ -109,8 +108,6 @@ const DEFAULT_OPTIONS = {
     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
@@ -120,7 +117,7 @@ const DEFAULT_OPTIONS = {
  */
 function mergeOptions(userConfig) {
     // Start with deep clone of defaults
-    const merged = structuredClone(DEFAULT_OPTIONS);
+    const merged = structuredClone(DEFAULT_OPTIONS$1);
     if (!userConfig) {
         return merged;
     }
@@ -1542,2872 +1539,1496 @@ function matToBase64Jpeg(cv, mat, quality = 0.9) {
 }
 
 /**
- * 运动和活体检测 - 防止照片攻击
- * 检测微妙的面部运动和运动模式，以区分真实面孔和高质量照片
+ * 活体检测器 - 微妙运动检测版本 + 照片几何特征检测
+ *
+ * 双重检测策略：
+ * 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.normalizedLandmarksHistory.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.isReady()) {
+                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))
+        };
     }
 }
 
@@ -4428,32 +3049,15 @@ class DetectionState {
     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() {
@@ -4462,7 +3066,7 @@ class DetectionState {
     // 是否准备好进行动作验证
     isReadyToVerify(minCollectCount) {
         if (this.period === DetectionPeriod.COLLECT
-            && this.liveness && this.realness
+            && this.liveness
             && this.collectCount >= minCollectCount) {
             return true;
         }
@@ -4484,11 +3088,6 @@ class DetectionState {
         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
      */
@@ -4500,11 +3099,9 @@ class DetectionState {
     }
 }
 // <-- 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;
 }
 
@@ -4542,8 +3139,6 @@ class FaceDetectionEngine extends SimpleEventEmitter {
     isDetectingFrameActive = false;
     // Frame-based detection scheduling
     frameIndex = 0;
-    lastDetectionFrameIndex = 0;
-    lastScreenFeatureDetectionFrameIndex = 0;
     // Frame Mat objects created per-frame, cleaned up immediately after use
     detectionState;
     /**
@@ -4553,8 +3148,7 @@ class FaceDetectionEngine extends SimpleEventEmitter {
     constructor(options) {
         super();
         this.options = mergeOptions(options);
-        this.adjustDetectFrameDelay();
-        this.detectionState = createDetectionState(this.videoFPS, this.options.motion_liveness_strict_photo_detection);
+        this.detectionState = createDetectionState();
     }
     /**
      * 提取错误信息的辅助方法 - 处理各种错误类型
@@ -4620,9 +3214,7 @@ class FaceDetectionEngine extends SimpleEventEmitter {
             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() {
@@ -4703,8 +3295,6 @@ class FaceDetectionEngine extends SimpleEventEmitter {
         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)
     }
@@ -4723,8 +3313,6 @@ class FaceDetectionEngine extends SimpleEventEmitter {
         }
         // Reset frame counters
         this.frameIndex = 0;
-        this.lastDetectionFrameIndex = 0;
-        this.lastScreenFeatureDetectionFrameIndex = 0;
         // Clear frame canvas (releases memory)
         try {
             this.clearFrameCanvas();
@@ -4771,8 +3359,6 @@ class FaceDetectionEngine extends SimpleEventEmitter {
             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...');
@@ -5154,109 +3740,6 @@ class FaceDetectionEngine extends SimpleEventEmitter {
             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 === 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 === 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
@@ -5306,44 +3789,13 @@ class FaceDetectionEngine extends SimpleEventEmitter {
         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 !== 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);
@@ -5355,15 +3807,6 @@ class FaceDetectionEngine extends SimpleEventEmitter {
             }, 'error');
         }
         finally {
-            // 清理非池化的Mat对象（必须执行，即使发生错误也要释放内存）
-            try {
-                this.cleanupFrames(bgrFrame, grayFrame);
-            }
-            catch (cleanupError) {
-                this.emitDebug('detection', 'Error in finally cleanup', {
-                    error: cleanupError.message
-                }, 'error');
-            }
             // 清除检测帧活跃标志
             this.isDetectingFrameActive = false;
             // 调度下一帧的检测（仅当引擎仍在检测状态时）
@@ -5374,15 +3817,6 @@ class FaceDetectionEngine extends SimpleEventEmitter {
             }
         }
     }
-    /**
-     * Check if current frame should be captured based on detection scheduling
-     */
-    shouldCaptureFrame() {
-        return this.shouldPerformMainDetection()
-            || this.shouldPerformScreenCornersDetection()
-            || this.shouldPerformScreenFeatureDetection()
-            || this.detectionState.period !== 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
@@ -5433,58 +3867,10 @@ class FaceDetectionEngine extends SimpleEventEmitter {
         }
         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 {
@@ -5511,20 +3897,12 @@ class FaceDetectionEngine extends SimpleEventEmitter {
         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');
@@ -5536,84 +3914,10 @@ class FaceDetectionEngine extends SimpleEventEmitter {
         }
         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: 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: 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');
@@ -5630,38 +3934,35 @@ class FaceDetectionEngine extends SimpleEventEmitter {
             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: 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;
             }