@sssxyd/face-liveness-detector 0.2.25 → 0.2.28

package/dist/index.esm.js

@@ -289,7 +289,6 @@ if (cvModuleImport && cvModuleImport.default) {
 }
 let webglAvailableCache = null;
 let opencvInitPromise = null;
-let opencvInitialized = false; // 标记是否已初始化完成
 function _isWebGLAvailable() {
     if (webglAvailableCache !== null) {
         return webglAvailableCache;
@@ -324,11 +323,6 @@ function _detectOptimalBackend() {
  * @param timeout - Maximum wait time in milliseconds (default: 30000)
  */
 async function preloadOpenCV(timeout = 30000) {
-    // 如果已经初始化完成，直接返回
-    if (opencvInitialized) {
-        console.log('[OpenCV] Already initialized, skipping preload');
-        return;
-    }
     // 如果已经在初始化中，返回现有的 Promise
     if (opencvInitPromise) {
         console.log('[OpenCV] Already initializing, reusing existing promise');
@@ -338,15 +332,13 @@ async function preloadOpenCV(timeout = 30000) {
     // 复用 loadOpenCV 的初始化逻辑
     opencvInitPromise = _initializeOpenCV(timeout);
     try {
-        const initTime = await opencvInitPromise;
-        console.log('[OpenCV] Preload completed successfully ', {
-            initTime: `${initTime.toFixed(2)}ms`,
-            version: getOpenCVVersion()
-        });
+        await opencvInitPromise;
+        console.log('[OpenCV] Preload completed successfully');
     }
     catch (error) {
         console.error('[OpenCV] Preload failed:', error);
-        opencvInitPromise = null; // 失败时清除 Promise，允许重试
+        // 失败后清除 Promise，允许重试
+        opencvInitPromise = null;
         throw error;
     }
 }
@@ -356,16 +348,16 @@ async function preloadOpenCV(timeout = 30000) {
  */
 async function _initializeOpenCV(timeout) {
     const initStartTime = performance.now();
-    console.log('Waiting for OpenCV WASM initialization...');
+    console.log('[FaceDetectionEngine] Waiting for OpenCV WASM initialization...');
     // 快速路径：检查是否已经初始化
     if (cvModule.Mat) {
         const initTime = performance.now() - initStartTime;
-        console.log(`OpenCV.js already initialized, took ${initTime.toFixed(2)}ms`);
+        console.log(`[FaceDetectionEngine] OpenCV.js already initialized, took ${initTime.toFixed(2)}ms`);
         return cvModule;
     }
     if (typeof globalThis !== 'undefined' && globalThis.cv && globalThis.cv.Mat) {
         const initTime = performance.now() - initStartTime;
-        console.log(`OpenCV.js already initialized (from global), took ${initTime.toFixed(2)}ms`);
+        console.log(`[FaceDetectionEngine] OpenCV.js already initialized (from global), took ${initTime.toFixed(2)}ms`);
         cvModule = globalThis.cv;
         return cvModule;
     }
@@ -373,84 +365,63 @@ async function _initializeOpenCV(timeout) {
     if (typeof globalThis !== 'undefined' && !globalThis.cv) {
         if (cvModule && Object.isExtensible(cvModule)) {
             globalThis.cv = cvModule;
-            console.log('cvModule assigned to globalThis.cv');
+            console.log('[FaceDetectionEngine] cvModule assigned to globalThis.cv');
         }
         else {
-            console.log('cvModule is not extensible or globalThis already has cv');
+            console.log('[FaceDetectionEngine] cvModule is not extensible or globalThis already has cv');
         }
     }
     return new Promise((resolve, reject) => {
-        // 轮询检查OpenCV初始化状态的标记
-        let pollInterval = null;
-        // 防止多次调用 resolve/reject
-        let finished = false;
         const timeoutId = setTimeout(() => {
-            console.error('OpenCV.js initialization timeout after ' + timeout + 'ms');
-            finished = true;
-            if (pollInterval) {
-                clearInterval(pollInterval);
-            }
+            console.error('[FaceDetectionEngine] OpenCV.js initialization timeout after ' + timeout + 'ms');
             reject(new Error('OpenCV.js initialization timeout'));
         }, timeout);
+        let resolved = false;
         const resolveOnce = (source) => {
-            if (finished) {
-                console.log('[resolveOnce] Already finished, ignoring call from:', source);
+            if (resolved)
                 return;
-            }
-            finished = true;
-            console.log('[resolveOnce] Marking as finished');
-            // 立即停止所有定时器和轮询
+            resolved = true;
             clearTimeout(timeoutId);
-            if (pollInterval !== null) {
-                clearInterval(pollInterval);
-                pollInterval = null;
-                console.log('[resolveOnce] Poll interval cleared');
-            }
+            clearInterval(pollInterval);
             const initTime = performance.now() - initStartTime;
-            console.log(`OpenCV.js initialized (${source}), took ${initTime.toFixed(2)}ms`);
-            // 标记初始化完成
-            opencvInitialized = true;
-            // 返回简单的标记，实际的 cv 对象已经在 globalThis.cv 上了
-            resolve(initTime);
+            console.log(`[FaceDetectionEngine] OpenCV.js initialized (${source}), took ${initTime.toFixed(2)}ms`);
+            resolve(cvModule);
         };
         // 尝试设置回调（只有在 cvModule 可扩展时才尝试）
         const canSetCallback = cvModule && Object.isExtensible(cvModule);
         if (canSetCallback) {
             try {
                 const originalOnRuntimeInitialized = cvModule.onRuntimeInitialized(cvModule).onRuntimeInitialized = () => {
-                    console.log('[onRuntimeInitialized] callback triggered');
+                    console.log('[FaceDetectionEngine] onRuntimeInitialized callback triggered');
                     // 调用原始回调（如果存在）
                     if (originalOnRuntimeInitialized && typeof originalOnRuntimeInitialized === 'function') {
                         try {
                             originalOnRuntimeInitialized();
                         }
                         catch (e) {
-                            console.warn('[onRuntimeInitialized] callback failed:', e);
+                            console.warn('[FaceDetectionEngine] Original onRuntimeInitialized callback failed:', e);
                         }
                     }
                     resolveOnce('callback');
                 };
-                console.log('[onRuntimeInitialized] callback set successfully');
+                console.log('[FaceDetectionEngine] onRuntimeInitialized callback set successfully');
             }
             catch (e) {
-                console.warn('[onRuntimeInitialized] Failed to set callback, will use polling:', e);
+                console.warn('[FaceDetectionEngine] Failed to set onRuntimeInitialized callback, will use polling:', e);
             }
         }
         else {
-            console.log('[polling] cvModule is not extensible, using polling mode');
+            console.log('[FaceDetectionEngine] cvModule is not extensible, using polling mode');
         }
         // 启动轮询作为备用方案或主要方案
-        pollInterval = setInterval(() => {
-            console.log('[polling] Checking for Mat class...');
+        const pollInterval = setInterval(() => {
             // 优先检查 cvModule 中是否有 Mat
             if (cvModule.Mat) {
-                console.log('[polling] Found Mat in cvModule');
                 resolveOnce('cvModule polling');
                 return;
             }
             // 其次检查 globalThis.cv 中是否有 Mat
             if (typeof globalThis !== 'undefined' && globalThis.cv && globalThis.cv.Mat) {
-                console.log('[polling] Found Mat in globalThis.cv');
                 cvModule = globalThis.cv;
                 resolveOnce('globalThis.cv polling');
                 return;
@@ -464,38 +435,52 @@ async function _initializeOpenCV(timeout) {
  * @returns Promise that resolves with cv module
  */
 async function loadOpenCV(timeout = 30000) {
+    let cv;
+    console.log('[FaceDetectionEngine] Loading OpenCV.js...');
     try {
-        // 快速检查是否已经初始化完成
-        if (opencvInitialized) {
-            console.log('[loadOpenCV] Already initialized, returning immediately');
-            const cv = getCvSync();
-            if (cv) {
-                return { cv };
-            }
+        // 如果已经在初始化中，复用现有的 Promise
+        if (opencvInitPromise) {
+            console.log('[FaceDetectionEngine] OpenCV initialization in progress, waiting...');
+            cv = await opencvInitPromise;
+        }
+        else if (cvModule.Mat) {
+            // 检查 cvModule 是否已经初始化
+            console.log('[FaceDetectionEngine] OpenCV.js already initialized');
+            cv = cvModule;
+        }
+        else if (typeof globalThis !== 'undefined' && globalThis.cv && globalThis.cv.Mat) {
+            // 检查全局 cv 是否已经初始化
+            console.log('[FaceDetectionEngine] OpenCV.js already initialized (global)');
+            cvModule = globalThis.cv;
+            cv = cvModule;
         }
-        // 等待初始化
-        console.log('[loadOpenCV] Waiting for initialization...');
-        if (!opencvInitPromise) {
-            console.log('[loadOpenCV] Starting new initialization');
+        else {
+            // 开始新的初始化
+            console.log('[FaceDetectionEngine] Starting OpenCV initialization...');
             opencvInitPromise = _initializeOpenCV(timeout);
+            try {
+                cv = await opencvInitPromise;
+            }
+            catch (error) {
+                // 失败后清除 Promise，允许重试
+                opencvInitPromise = null;
+                throw error;
+            }
         }
-        console.log('[loadOpenCV] Awaiting opencvInitPromise');
-        const initTime = await opencvInitPromise;
-        // 获取初始化后的 cv 对象
-        const cv = getCvSync();
-        if (!cv) {
-            console.error('[loadOpenCV] getCvSync returned null');
-            throw new Error('OpenCV module is invalid');
+        // 最终验证
+        if (!cv || !cv.Mat) {
+            console.error('[FaceDetectionEngine] OpenCV module is invalid:', {
+                hasMat: cv && cv.Mat,
+                type: typeof cv,
+                keys: cv ? Object.keys(cv).slice(0, 10) : 'N/A'
+            });
+            throw new Error('OpenCV.js loaded but module is invalid (no Mat class found)');
         }
-        console.log('[loadOpenCV] OpenCV.js load successfully', {
-            initTime: `${initTime.toFixed(2)}ms`,
-            version: getOpenCVVersion()
-        });
-        return cv;
+        console.log('[FaceDetectionEngine] OpenCV.js loaded successfully');
+        return { cv };
     }
     catch (error) {
-        console.error('[loadOpenCV] OpenCV.js load failed', error);
-        opencvInitPromise = null; // 失败时清除 Promise，允许重试
+        console.error('[FaceDetectionEngine] Failed to load OpenCV.js:', error);
         throw error;
     }
 }
@@ -514,35 +499,6 @@ function getCvSync() {
     }
     return null;
 }
-/**
- * Extract OpenCV version from getBuildInformation
- * @returns version string like "4.12.0"
- */
-function getOpenCVVersion() {
-    try {
-        const cv = getCvSync();
-        if (!cv || !cv.getBuildInformation) {
-            return 'unknown';
-        }
-        const buildInfo = cv.getBuildInformation();
-        // 查找 "Version control:" 或 "OpenCV" 开头的行
-        // 格式: "Version control:               4.12.0"
-        const versionMatch = buildInfo.match(/Version\s+control:\s+(\d+\.\d+\.\d+)/i);
-        if (versionMatch && versionMatch[1]) {
-            return versionMatch[1];
-        }
-        // 备用方案：查找 "OpenCV X.X.X" 格式
-        const opencvMatch = buildInfo.match(/OpenCV\s+(\d+\.\d+\.\d+)/i);
-        if (opencvMatch && opencvMatch[1]) {
-            return opencvMatch[1];
-        }
-        return 'unknown';
-    }
-    catch (error) {
-        console.error('[getOpenCVVersion] Failed to get version:', error);
-        return 'unknown';
-    }
-}
 /**
  * Load Human.js
  * @param modelPath - Path to model files (optional)
@@ -550,7 +506,6 @@ function getOpenCVVersion() {
  * @returns Promise that resolves with Human instance
  */
 async function loadHuman(modelPath, wasmPath) {
-    const initStartTime = performance.now();
     const config = {
         backend: _detectOptimalBackend(),
         face: {
@@ -573,16 +528,24 @@ async function loadHuman(modelPath, wasmPath) {
     if (wasmPath) {
         config.wasmPath = wasmPath;
     }
-    console.log('[loadHuman] Config:', {
+    console.log('[FaceDetectionEngine] Human.js config:', {
         backend: config.backend,
         modelBasePath: config.modelBasePath || '(using default)',
         wasmPath: config.wasmPath || '(using default)'
     });
+    const initStartTime = performance.now();
+    console.log('[FaceDetectionEngine] Creating Human instance...');
     const human = new Human(config);
+    const instanceCreateTime = performance.now() - initStartTime;
+    console.log(`[FaceDetectionEngine] Human instance created, took ${instanceCreateTime.toFixed(2)}ms`);
+    console.log('[FaceDetectionEngine] Loading Human.js models...');
+    const modelLoadStartTime = performance.now();
     try {
         await human.load();
+        const loadTime = performance.now() - modelLoadStartTime;
         const totalTime = performance.now() - initStartTime;
-        console.log('[loadHuman] Loaded successfully', {
+        console.log('[FaceDetectionEngine] Human.js loaded successfully', {
+            modelLoadTime: `${loadTime.toFixed(2)}ms`,
             totalInitTime: `${totalTime.toFixed(2)}ms`,
             version: human.version
         });
@@ -590,40 +553,37 @@ async function loadHuman(modelPath, wasmPath) {
     }
     catch (error) {
         const errorMsg = error instanceof Error ? error.message : 'Unknown error';
-        console.error('[loadHuman] Load failed:', errorMsg);
+        console.error('[FaceDetectionEngine] Human.js load failed:', errorMsg);
         throw error;
     }
 }
-async function loadLibraries(modelPath, wasmPath, timeout) {
-    console.log('[loadLibraries] Starting parallel load of OpenCV and Human...');
-    const startTime = performance.now();
-    if (timeout == undefined) {
-        timeout = 30000;
-    }
+/**
+ * Extract OpenCV version from getBuildInformation
+ * @returns version string like "4.12.0"
+ */
+function getOpenCVVersion() {
     try {
-        const cv = await loadOpenCV(timeout);
-        if (!cv) {
-            throw new Error('Failed to load OpenCV');
+        const cv = getCvSync();
+        if (!cv || !cv.getBuildInformation) {
+            return 'unknown';
         }
-        const human = await loadHuman(modelPath, wasmPath);
-        if (!human) {
-            throw new Error('Failed to load Human');
+        const buildInfo = cv.getBuildInformation();
+        // 查找 "Version control:" 或 "OpenCV" 开头的行
+        // 格式: "Version control:               4.12.0"
+        const versionMatch = buildInfo.match(/Version\s+control:\s+(\d+\.\d+\.\d+)/i);
+        if (versionMatch && versionMatch[1]) {
+            return versionMatch[1];
         }
-        const totalTime = performance.now() - startTime;
-        console.log('[loadLibraries] libraries loaded successfully', {
-            totalInitTime: `${totalTime.toFixed(2)}ms`,
-            opencvVersion: getOpenCVVersion(),
-            humanVersion: human.version
-        });
-        return {
-            cv,
-            human
-        };
+        // 备用方案：查找 "OpenCV X.X.X" 格式
+        const opencvMatch = buildInfo.match(/OpenCV\s+(\d+\.\d+\.\d+)/i);
+        if (opencvMatch && opencvMatch[1]) {
+            return opencvMatch[1];
+        }
+        return 'unknown';
     }
     catch (error) {
-        const errorMsg = error instanceof Error ? error.message : 'Unknown error';
-        console.error('[loadLibraries] Failed to load libraries:', errorMsg);
-        throw error;
+        console.error('[getOpenCVVersion] Failed to get version:', error);
+        return 'unknown';
     }
 }
 
@@ -1604,17 +1564,66 @@ class FaceDetectionEngine extends SimpleEventEmitter {
         this.isInitializing = true;
         this.emitDebug('initialization', 'Starting to load detection libraries...');
         try {
-            // Load Libraries
-            this.emitDebug('initialization', 'Loading Libraries...');
-            const { human } = await loadLibraries(this.config.human_model_path, this.config.tensorflow_wasm_path, 30000);
-            // Store human instance
-            this.human = human;
+            // Load OpenCV
+            this.emitDebug('initialization', 'Loading OpenCV...');
+            const { cv } = await loadOpenCV(60000); // 1 minute timeout
+            if (!cv || !cv.Mat) {
+                console.log('[FaceDetectionEngine] Failed to load OpenCV.js: module is null or invalid');
+                this.emit('detector-error', {
+                    success: false,
+                    error: 'Failed to load OpenCV.js: module is null or invalid'
+                });
+                this.emit('detector-error', {
+                    code: ErrorCode.DETECTOR_NOT_INITIALIZED,
+                    message: 'Failed to load OpenCV.js: module is null or invalid'
+                });
+                return;
+            }
+            const cv_version = getOpenCVVersion();
+            this.emitDebug('initialization', 'OpenCV loaded successfully', {
+                version: cv_version
+            });
+            console.log('[FaceDetectionEngine] OpenCV loaded successfully', {
+                version: cv_version
+            });
+            // Load Human.js
+            console.log('[FaceDetectionEngine] Loading Human.js models...');
+            this.emitDebug('initialization', 'Loading Human.js...');
+            const humanStartTime = performance.now();
+            this.human = await loadHuman(this.config.human_model_path, this.config.tensorflow_wasm_path);
+            const humanLoadTime = performance.now() - humanStartTime;
+            if (!this.human) {
+                const errorMsg = 'Failed to load Human.js: instance is null';
+                console.log('[FaceDetectionEngine] ' + errorMsg);
+                this.emitDebug('initialization', errorMsg, { loadTime: humanLoadTime }, 'error');
+                this.emit('detector-loaded', {
+                    success: false,
+                    error: errorMsg
+                });
+                this.emit('detector-error', {
+                    code: ErrorCode.DETECTOR_NOT_INITIALIZED,
+                    message: errorMsg
+                });
+                return;
+            }
+            this.emitDebug('initialization', 'Human.js loaded successfully', {
+                loadTime: `${humanLoadTime.toFixed(2)}ms`,
+                version: this.human.version
+            });
+            console.log('[FaceDetectionEngine] Human.js loaded successfully', {
+                loadTime: `${humanLoadTime.toFixed(2)}ms`,
+                version: this.human.version
+            });
             this.isReady = true;
             const loadedData = {
                 success: true,
-                opencv_version: getOpenCVVersion(),
+                opencv_version: cv_version,
                 human_version: this.human.version
             };
+            console.log('[FaceDetectionEngine] Engine initialized and ready', {
+                opencv_version: loadedData.opencv_version,
+                human_version: loadedData.human_version
+            });
             this.emit('detector-loaded', loadedData);
             this.emitDebug('initialization', 'Engine initialized and ready', loadedData);
         }