@sssxyd/face-liveness-detector 0.2.27 → 0.2.29

package/dist/index.js

@@ -311,7 +311,6 @@
     }
     let webglAvailableCache = null;
     let opencvInitPromise = null;
-    let opencvInitialized = false; // 标记是否已初始化完成
     function _isWebGLAvailable() {
         if (webglAvailableCache !== null) {
             return webglAvailableCache;
@@ -346,11 +345,6 @@
      * @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');
@@ -360,15 +354,13 @@
         // 复用 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;
         }
     }
@@ -378,16 +370,16 @@
      */
     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`);
-            return cvModule;
+            console.log(`[FaceDetectionEngine] OpenCV.js already initialized, took ${initTime.toFixed(2)}ms`);
+            return true;
         }
         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;
         }
@@ -395,84 +387,69 @@
         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;
+                console.error('[FaceDetectionEngine] OpenCV.js initialization timeout after ' + timeout + 'ms');
                 if (pollInterval) {
                     clearInterval(pollInterval);
                 }
                 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) {
+                if (pollInterval) {
                     clearInterval(pollInterval);
-                    pollInterval = null;
-                    console.log('[resolveOnce] Poll interval cleared');
                 }
                 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(true);
             };
             // 尝试设置回调（只有在 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...');
                 // 优先检查 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;
@@ -486,35 +463,59 @@
      * @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');
-                return getCvSync();
-            }
-            // 等待初始化
-            console.log('[loadOpenCV] Waiting for initialization...');
-            if (!opencvInitPromise) {
-                console.log('[loadOpenCV] Starting new initialization');
-                opencvInitPromise = _initializeOpenCV(timeout);
+            // 如果已经在初始化中，复用现有的 Promise
+            if (opencvInitPromise) {
+                console.log('[FaceDetectionEngine] OpenCV initialization in progress, waiting...');
+                try {
+                    await opencvInitPromise;
+                    cv = getCvSync();
+                    if (cv && cv.Mat) {
+                        console.log('[FaceDetectionEngine] OpenCV.js loaded successfully');
+                        return { cv };
+                    }
+                }
+                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');
+            else {
+                cv = getCvSync();
+                if (cv && cv.Mat) {
+                    console.log('[FaceDetectionEngine] OpenCV.js already initialized');
+                    return { cv };
+                }
+                // 开始新的初始化
+                console.log('[FaceDetectionEngine] Starting OpenCV initialization...');
+                opencvInitPromise = _initializeOpenCV(timeout);
+                try {
+                    await opencvInitPromise;
+                    cv = getCvSync();
+                    if (cv && cv.Mat) {
+                        console.log('[FaceDetectionEngine] OpenCV.js loaded successfully');
+                        return { cv };
+                    }
+                }
+                catch (error) {
+                    // 失败后清除 Promise，允许重试
+                    opencvInitPromise = null;
+                    throw error;
+                }
             }
-            console.log('[loadOpenCV] OpenCV.js load successfully', {
-                initTime: `${initTime.toFixed(2)}ms`,
-                version: getOpenCVVersion()
+            // 如果到这里还没有返回，说明加载失败
+            console.error('[FaceDetectionEngine] OpenCV module is invalid:', {
+                hasMat: cv && cv.Mat,
+                type: typeof cv,
+                keys: cv ? Object.keys(cv).slice(0, 10) : 'N/A'
             });
-            return cv;
+            throw new Error('OpenCV.js loaded but module is invalid (no Mat class found)');
         }
         catch (error) {
-            console.error('[loadOpenCV] OpenCV.js load failed', error);
-            opencvInitPromise = null; // 失败时清除 Promise，允许重试
+            console.error('[FaceDetectionEngine] Failed to load OpenCV.js:', error);
             throw error;
         }
     }
@@ -533,35 +534,6 @@
         }
         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)
@@ -569,8 +541,6 @@
      * @returns Promise that resolves with Human instance
      */
     async function loadHuman(modelPath, wasmPath) {
-        console.log('[loadHuman] START - creating config');
-        const initStartTime = performance.now();
         const config = {
             backend: _detectOptimalBackend(),
             face: {
@@ -593,20 +563,24 @@
         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)'
         });
-        console.log('[loadHuman] Creating Human instance...');
+        const initStartTime = performance.now();
+        console.log('[FaceDetectionEngine] Creating Human instance...');
         const human = new Human(config);
-        console.log('[loadHuman] Human instance created, starting load...');
+        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 {
-            console.log('[loadHuman] Calling human.load()...');
             await human.load();
-            console.log('[loadHuman] human.load() completed');
+            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
             });
@@ -614,33 +588,37 @@
         }
         catch (error) {
             const errorMsg = error instanceof Error ? error.message : 'Unknown error';
-            console.error('[loadHuman] Load failed:', errorMsg);
-            console.error('[loadHuman] Error stack:', error instanceof Error ? error.stack : 'N/A');
+            console.error('[FaceDetectionEngine] Human.js load failed:', errorMsg);
             throw error;
         }
     }
-    async function loadLibraries(modelPath, wasmPath, timeout = 30000) {
-        console.log('[loadLibraries] Starting parallel load of OpenCV and Human...');
-        const startTime = performance.now();
+    /**
+     * Extract OpenCV version from getBuildInformation
+     * @returns version string like "4.12.0"
+     */
+    function getOpenCVVersion() {
         try {
-            console.log('[loadLibraries] Launching Promise.all with OpenCV and Human...');
-            const [cv, human] = await Promise.all([
-                loadOpenCV(timeout),
-                loadHuman(modelPath, wasmPath)
-            ]);
-            console.log('[loadLibraries] Both promises resolved');
-            const totalTime = performance.now() - startTime;
-            console.log('[loadLibraries] libraries loaded successfully', {
-                totalInitTime: `${totalTime.toFixed(2)}ms`,
-                opencvVersion: getOpenCVVersion(),
-                humanVersion: human.version
-            });
-            return { cv, human };
+            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) {
-            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';
         }
     }
 
@@ -1621,13 +1599,12 @@
             this.isInitializing = true;
             this.emitDebug('initialization', 'Starting to load detection libraries...');
             try {
-                // Load Libraries
-                this.emitDebug('initialization', 'Loading Libraries...');
-                const startLoadTime = performance.now();
-                const { cv, human } = await loadLibraries(this.config.human_model_path, this.config.tensorflow_wasm_path, 30000);
+                // 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-loaded', {
+                    this.emit('detector-error', {
                         success: false,
                         error: 'Failed to load OpenCV.js: module is null or invalid'
                     });
@@ -1637,9 +1614,23 @@
                     });
                     return;
                 }
-                if (!human) {
+                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
@@ -1650,16 +1641,21 @@
                     });
                     return;
                 }
-                // Store human instance
-                this.human = human;
+                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', {
-                    initCostTime: (performance.now() - startLoadTime).toFixed(2),
                     opencv_version: loadedData.opencv_version,
                     human_version: loadedData.human_version
                 });