@sssxyd/face-liveness-detector 0.4.0-alpha.1 → 0.4.0-alpha.3

package/dist/index.esm.js

@@ -1632,6 +1632,46 @@ function getOpenCVVersion() {
     }
 }
 
+/**
+ * 将绘制图片的canvas转换为mat
+ * @param {any} cv OpenCV实例
+ * @param {HTMLCanvasElement} canvas canvas元素
+ * @param {boolean} gray 是否转换为灰度图像
+ * @returns {any | null} - 转换后的Mat对象，如果转换失败则返回null
+ */
+function drawCanvasToMat(cv, canvas, gray) {
+    try {
+        if (!cv || !canvas) {
+            return null;
+        }
+        // Convert canvas directly to cv.Mat
+        const mat = cv.imread(canvas);
+        if (!mat || mat.empty()) {
+            return null;
+        }
+        if (gray) {
+            cv.cvtColor(mat, mat, cv.COLOR_BGR2GRAY);
+        }
+        return mat;
+    }
+    catch (e) {
+        return null;
+    }
+}
+function matToGray(cv, mat) {
+    try {
+        if (!cv || !mat || mat.empty()) {
+            return null;
+        }
+        const grayMat = new cv.Mat();
+        cv.cvtColor(mat, grayMat, cv.COLOR_BGR2GRAY);
+        return grayMat;
+    }
+    catch (e) {
+        return null;
+    }
+}
+
 /**
  * 运动和活体检测 - 防止照片攻击
  * 检测微妙的面部运动和运动模式，以区分真实面孔和高质量照片
@@ -2380,46 +2420,6 @@ class MotionLivenessDetector {
     }
 }
 
-/**
- * 将绘制图片的canvas转换为mat
- * @param {any} cv OpenCV实例
- * @param {HTMLCanvasElement} canvas canvas元素
- * @param {boolean} gray 是否转换为灰度图像
- * @returns {any | null} - 转换后的Mat对象，如果转换失败则返回null
- */
-function drawCanvasToMat(cv, canvas, gray) {
-    try {
-        if (!cv || !canvas) {
-            return null;
-        }
-        // Convert canvas directly to cv.Mat
-        const mat = cv.imread(canvas);
-        if (!mat || mat.empty()) {
-            return null;
-        }
-        if (gray) {
-            cv.cvtColor(mat, mat, cv.COLOR_BGR2GRAY);
-        }
-        return mat;
-    }
-    catch (e) {
-        return null;
-    }
-}
-function matToGray(cv, mat) {
-    try {
-        if (!cv || !mat || mat.empty()) {
-            return null;
-        }
-        const grayMat = new cv.Mat();
-        cv.cvtColor(mat, grayMat, cv.COLOR_BGR2GRAY);
-        return grayMat;
-    }
-    catch (e) {
-        return null;
-    }
-}
-
 /**
  * 屏幕色彩特征检测模块
  *
@@ -3991,10 +3991,6 @@ class ScreenCaptureDetector {
     }
 }
 
-/**
- * Face Detection Engine - Core Detection Engine
- * Framework-agnostic face liveness detection engine
- */
 /**
  * Internal detection state interface
  */
@@ -4017,6 +4013,7 @@ class DetectionState {
         Object.assign(this, options);
     }
     reset() {
+        this.clearActionVerifyTimeout();
         const savedMotionDetector = this.motionDetector;
         const savedScreenDetector = this.screenDetector;
         savedMotionDetector?.reset();
@@ -4037,7 +4034,71 @@ class DetectionState {
         }
         return false;
     }
+    onActionStarted(nextAction, timeoutMills, timeoutCallback) {
+        if (nextAction === null) {
+            return;
+        }
+        this.currentAction = nextAction;
+        this.clearActionVerifyTimeout();
+        this.actionVerifyTimeout = setTimeout(timeoutCallback, timeoutMills);
+    }
+    onActionCompleted() {
+        if (this.currentAction === null) {
+            return;
+        }
+        this.clearActionVerifyTimeout();
+        this.completedActions.add(this.currentAction);
+        this.currentAction = null;
+    }
+    setCVInstance(cvInstance) {
+        this.motionDetector?.setCVInstance(cvInstance);
+        this.screenDetector?.setCVInstance(cvInstance);
+    }
+    /**
+     * Clear action verify timeout
+     */
+    clearActionVerifyTimeout() {
+        if (this.actionVerifyTimeout !== null) {
+            clearTimeout(this.actionVerifyTimeout);
+            this.actionVerifyTimeout = null;
+        }
+    }
 }
+// <-- Add this import at the top if ResolvedEngineOptions is defined in types.ts
+function createDetectionState(options) {
+    const detectionState = new DetectionState({});
+    detectionState.motionDetector = new MotionLivenessDetector({
+        minMotionThreshold: options.motion_liveness_min_motion_score,
+        minKeypointVariance: options.motion_liveness_min_keypoint_variance,
+        frameBufferSize: options.motion_liveness_frame_buffer_size,
+        eyeAspectRatioThreshold: options.motion_liveness_eye_aspect_ratio_threshold
+    });
+    detectionState.screenDetector = new ScreenCaptureDetector({
+        confidenceThreshold: options.screen_capture_confidence_threshold,
+        detectionStrategy: stringToDetectionStrategy(options.screen_capture_detection_strategy),
+        moireThreshold: options.screen_moire_pattern_threshold,
+        moireEnableDCT: options.screen_moire_pattern_enable_dct,
+        moireEnableEdgeDetection: options.screen_moire_pattern_enable_edge_detection,
+        colorSaturationThreshold: options.screen_color_saturation_threshold,
+        colorRgbCorrelationThreshold: options.screen_color_rgb_correlation_threshold,
+        colorPixelEntropyThreshold: options.screen_color_pixel_entropy_threshold,
+        colorConfidenceThreshold: options.screen_color_confidence_threshold,
+        rgbLowFreqStartPercent: options.screen_rgb_low_freq_start_percent,
+        rgbLowFreqEndPercent: options.screen_rgb_low_freq_end_percent,
+        rgbEnergyRatioNormalizationFactor: options.screen_rgb_energy_ratio_normalization_factor,
+        rgbChannelDifferenceNormalizationFactor: options.screen_rgb_channel_difference_normalization_factor,
+        rgbEnergyScoreWeight: options.screen_rgb_energy_score_weight,
+        rgbAsymmetryScoreWeight: options.screen_rgb_asymmetry_score_weight,
+        rgbDifferenceFactorWeight: options.screen_rgb_difference_factor_weight,
+        rgbConfidenceThreshold: options.screen_rgb_confidence_threshold
+    });
+    return detectionState;
+}
+
+/**
+ * Face Detection Engine - Core Detection Engine
+ * Framework-agnostic face liveness detection engine
+ */
 /**
  * Framework-agnostic face liveness detection engine
  * Provides core detection logic without UI dependencies
@@ -4064,32 +4125,15 @@ class FaceDetectionEngine extends SimpleEventEmitter {
         this.actualVideoWidth = 0;
         this.actualVideoHeight = 0;
         this.options = mergeOptions(options);
-        this.detectionState = new DetectionState({});
-        this.detectionState.motionDetector = new MotionLivenessDetector({
-            minMotionThreshold: this.options.motion_liveness_min_motion_score,
-            minKeypointVariance: this.options.motion_liveness_min_keypoint_variance,
-            frameBufferSize: this.options.motion_liveness_frame_buffer_size,
-            eyeAspectRatioThreshold: this.options.motion_liveness_eye_aspect_ratio_threshold
-        });
-        this.detectionState.screenDetector = new ScreenCaptureDetector({
-            confidenceThreshold: this.options.screen_capture_confidence_threshold,
-            detectionStrategy: stringToDetectionStrategy(this.options.screen_capture_detection_strategy),
-            moireThreshold: this.options.screen_moire_pattern_threshold,
-            moireEnableDCT: this.options.screen_moire_pattern_enable_dct,
-            moireEnableEdgeDetection: this.options.screen_moire_pattern_enable_edge_detection,
-            colorSaturationThreshold: this.options.screen_color_saturation_threshold,
-            colorRgbCorrelationThreshold: this.options.screen_color_rgb_correlation_threshold,
-            colorPixelEntropyThreshold: this.options.screen_color_pixel_entropy_threshold,
-            colorConfidenceThreshold: this.options.screen_color_confidence_threshold,
-            rgbLowFreqStartPercent: this.options.screen_rgb_low_freq_start_percent,
-            rgbLowFreqEndPercent: this.options.screen_rgb_low_freq_end_percent,
-            rgbEnergyRatioNormalizationFactor: this.options.screen_rgb_energy_ratio_normalization_factor,
-            rgbChannelDifferenceNormalizationFactor: this.options.screen_rgb_channel_difference_normalization_factor,
-            rgbEnergyScoreWeight: this.options.screen_rgb_energy_score_weight,
-            rgbAsymmetryScoreWeight: this.options.screen_rgb_asymmetry_score_weight,
-            rgbDifferenceFactorWeight: this.options.screen_rgb_difference_factor_weight,
-            rgbConfidenceThreshold: this.options.screen_rgb_confidence_threshold
-        });
+        this.detectionState = createDetectionState(this.options);
+    }
+    updateOptions(options) {
+        if (this.engineState == EngineState.DETECTING) {
+            this.stopDetection(false);
+        }
+        this.options = mergeOptions(options);
+        this.detectionState = createDetectionState(this.options);
+        this.detectionState.setCVInstance(this.cv);
     }
     getEngineState() {
         return this.engineState;
@@ -4128,10 +4172,8 @@ class FaceDetectionEngine extends SimpleEventEmitter {
             console.log('[FaceDetectionEngine] OpenCV loaded successfully', {
                 version: cv_version
             });
-            // Inject OpenCV instance into motion detector
-            if (this.detectionState.motionDetector) {
-                this.detectionState.motionDetector.cv = cv;
-            }
+            // 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...');
@@ -4749,7 +4791,14 @@ class FaceDetectionEngine extends SimpleEventEmitter {
     handleVerifyPhase(gestures) {
         // No action set yet, will continue after setting
         if (!this.detectionState.currentAction) {
-            this.selectNextAction();
+            if (!this.selectNextAction()) {
+                this.emit('detector-error', {
+                    code: ErrorCode.INTERNAL_ERROR,
+                    message: 'No available actions to perform for liveness verification'
+                });
+                this.stopDetection(false);
+                return;
+            }
             this.scheduleNextDetection(this.options.detect_frame_delay * 3);
             return;
         }
@@ -4766,16 +4815,21 @@ class FaceDetectionEngine extends SimpleEventEmitter {
         // Action completed
         this.emit('detector-action', actionComplete);
         this.emitDebug('liveness', 'Action detected', { action: this.detectionState.currentAction });
-        this.clearActionVerifyTimeout();
-        this.detectionState.completedActions.add(this.detectionState.currentAction);
-        this.detectionState.currentAction = null;
+        this.detectionState.onActionCompleted();
         // Check if all required actions completed
         if (this.detectionState.completedActions.size >= this.getPerformActionCount()) {
             this.stopDetection(true);
             return;
         }
         // Select next action
-        this.selectNextAction();
+        if (!this.selectNextAction()) {
+            this.emit('detector-error', {
+                code: ErrorCode.INTERNAL_ERROR,
+                message: 'No available actions to perform for liveness verification'
+            });
+            this.stopDetection(false);
+            return;
+        }
         this.scheduleNextDetection();
     }
     /**
@@ -4844,7 +4898,7 @@ class FaceDetectionEngine extends SimpleEventEmitter {
         const availableActions = (this.options.action_liveness_action_list ?? []).filter(action => !this.detectionState.completedActions.has(action));
         if (availableActions.length === 0) {
             this.emitDebug('liveness', 'No available actions to perform', { completedActions: Array.from(this.detectionState.completedActions), totalActions: this.options.action_liveness_action_list?.length ?? 0 }, 'warn');
-            return;
+            return false;
         }
         let nextAction = availableActions[0];
         if (this.options.action_liveness_action_randomize) {
@@ -4852,38 +4906,24 @@ class FaceDetectionEngine extends SimpleEventEmitter {
             const randomIndex = Math.floor(Math.random() * availableActions.length);
             nextAction = availableActions[randomIndex];
         }
-        this.detectionState.currentAction = nextAction;
         const actionStart = {
             action: nextAction,
             status: LivenessActionStatus.STARTED
         };
         this.emit('detector-action', actionStart);
         this.emitDebug('liveness', 'Action selected', { action: this.detectionState.currentAction });
-        // Start action verification timeout timer
-        this.clearActionVerifyTimeout();
-        this.detectionState.actionVerifyTimeout = setTimeout(() => {
-            if (nextAction) {
-                this.emitDebug('liveness', 'Action verify timeout', {
-                    action: nextAction,
-                    timeout: this.options.action_liveness_verify_timeout
-                }, 'warn');
-                this.emit('detector-action', {
-                    action: nextAction,
-                    status: LivenessActionStatus.TIMEOUT
-                });
-                this.resetDetectionState();
-            }
-        }, this.options.action_liveness_verify_timeout);
-        return;
-    }
-    /**
-     * Clear action verify timeout
-     */
-    clearActionVerifyTimeout() {
-        if (this.detectionState.actionVerifyTimeout !== null) {
-            clearTimeout(this.detectionState.actionVerifyTimeout);
-            this.detectionState.actionVerifyTimeout = null;
-        }
+        this.detectionState.onActionStarted(nextAction, this.options.action_liveness_verify_timeout, () => {
+            this.emitDebug('liveness', 'Action verify timeout', {
+                action: nextAction,
+                timeout: this.options.action_liveness_verify_timeout
+            }, 'warn');
+            this.emit('detector-action', {
+                action: nextAction,
+                status: LivenessActionStatus.TIMEOUT
+            });
+            this.resetDetectionState();
+        });
+        return true;
     }
     /**
      * Detect specific action