id-scanner-lib 1.1.1 → 1.2.0

package/dist/id-scanner-ocr.js

@@ -279,6 +279,323 @@
             }
             return imageData;
         }
+        /**
+         * 降低图像分辨率以提高处理速度
+         *
+         * 对于OCR和图像分析，降低分辨率可以在保持识别率的同时大幅提升处理速度
+         *
+         * @param {ImageData} imageData - 原图像数据
+         * @param {number} [maxDimension=1000] - 目标最大尺寸（宽或高）
+         * @returns {ImageData} 处理后的图像数据
+         */
+        static downsampleForProcessing(imageData, maxDimension = 1000) {
+            const { width, height } = imageData;
+            // 如果图像尺寸已经小于或等于目标尺寸，则无需处理
+            if (width <= maxDimension && height <= maxDimension) {
+                return imageData;
+            }
+            // 计算缩放比例，保持宽高比
+            const scale = maxDimension / Math.max(width, height);
+            const newWidth = Math.round(width * scale);
+            const newHeight = Math.round(height * scale);
+            // 调整图像大小
+            return this.resize(imageData, newWidth, newHeight);
+        }
+        /**
+         * 转换图像为Base64格式，方便在Worker线程中传递
+         *
+         * @param {ImageData} imageData - 原图像数据
+         * @returns {string} base64编码的图像数据
+         */
+        static imageDataToBase64(imageData) {
+            const canvas = this.imageDataToCanvas(imageData);
+            return canvas.toDataURL('image/jpeg', 0.7); // 使用较低质量的JPEG格式减少数据量
+        }
+        /**
+         * 从Base64字符串还原图像数据
+         *
+         * @param {string} base64 - base64编码的图像数据
+         * @returns {Promise<ImageData>} 还原的图像数据
+         */
+        static async base64ToImageData(base64) {
+            return new Promise((resolve, reject) => {
+                const img = new Image();
+                img.onload = () => {
+                    const canvas = document.createElement('canvas');
+                    canvas.width = img.width;
+                    canvas.height = img.height;
+                    const ctx = canvas.getContext('2d');
+                    if (!ctx) {
+                        reject(new Error('无法创建Canvas上下文'));
+                        return;
+                    }
+                    ctx.drawImage(img, 0, 0);
+                    const imageData = ctx.getImageData(0, 0, canvas.width, canvas.height);
+                    resolve(imageData);
+                };
+                img.onerror = () => {
+                    reject(new Error('图像加载失败'));
+                };
+                img.src = base64;
+            });
+        }
+        /**
+         * 使用Web Worker并行处理图像
+         * 此方法将图像分割为多个部分，并行处理以提高性能
+         *
+         * @param {ImageData} imageData - 原图像数据
+         * @param {Function} processingFunction - 处理函数，接收ImageData返回ImageData
+         * @param {number} [chunks=4] - 分割的块数
+         * @returns {Promise<ImageData>} 处理后的图像数据
+         */
+        static async processImageInParallel(imageData, processingFunction, chunks = 4) {
+            // 如果不支持Worker或图像太小，直接处理
+            if (typeof Worker === 'undefined' || imageData.width * imageData.height < 100000) {
+                return processingFunction(imageData);
+            }
+            // 创建结果canvas
+            const resultCanvas = document.createElement('canvas');
+            resultCanvas.width = imageData.width;
+            resultCanvas.height = imageData.height;
+            const resultCtx = resultCanvas.getContext('2d');
+            if (!resultCtx) {
+                throw new Error('无法创建Canvas上下文');
+            }
+            // 根据图像特性确定分割方向和每块大小
+            const isWide = imageData.width > imageData.height;
+            const chunkSize = Math.floor((isWide ? imageData.width : imageData.height) / chunks);
+            // 创建Worker处理每个块
+            const promises = [];
+            for (let i = 0; i < chunks; i++) {
+                const chunkCanvas = document.createElement('canvas');
+                const chunkCtx = chunkCanvas.getContext('2d');
+                if (!chunkCtx)
+                    continue;
+                let chunkImageData;
+                if (isWide) {
+                    // 水平分割
+                    const startX = i * chunkSize;
+                    const width = (i === chunks - 1) ? imageData.width - startX : chunkSize;
+                    chunkCanvas.width = width;
+                    chunkCanvas.height = imageData.height;
+                    // 复制原图像数据到分块
+                    const tempCanvas = this.imageDataToCanvas(imageData);
+                    chunkCtx.drawImage(tempCanvas, startX, 0, width, imageData.height, 0, 0, width, imageData.height);
+                    chunkImageData = chunkCtx.getImageData(0, 0, width, imageData.height);
+                }
+                else {
+                    // 垂直分割
+                    const startY = i * chunkSize;
+                    const height = (i === chunks - 1) ? imageData.height - startY : chunkSize;
+                    chunkCanvas.width = imageData.width;
+                    chunkCanvas.height = height;
+                    // 复制原图像数据到分块
+                    const tempCanvas = this.imageDataToCanvas(imageData);
+                    chunkCtx.drawImage(tempCanvas, 0, startY, imageData.width, height, 0, 0, imageData.width, height);
+                    chunkImageData = chunkCtx.getImageData(0, 0, imageData.width, height);
+                }
+                // 使用Worker处理
+                const workerCode = `
+        self.onmessage = function(e) {
+          const imageData = e.data.imageData;
+          const processingFunction = ${processingFunction.toString()};
+          const result = processingFunction(imageData);
+          self.postMessage({ result, index: e.data.index }, [result.data.buffer]);
+        }
+      `;
+                const blob = new Blob([workerCode], { type: 'application/javascript' });
+                const workerUrl = URL.createObjectURL(blob);
+                const worker = new Worker(workerUrl);
+                const promise = new Promise((resolve) => {
+                    worker.onmessage = function (e) {
+                        resolve(e.data);
+                        worker.terminate();
+                        URL.revokeObjectURL(workerUrl);
+                    };
+                    // 传输数据
+                    worker.postMessage({
+                        imageData: chunkImageData,
+                        index: i
+                    }, [chunkImageData.data.buffer]);
+                });
+                promises.push(promise);
+            }
+            // 等待所有Worker完成并组合结果
+            const results = await Promise.all(promises);
+            // 按索引排序结果
+            results.sort((a, b) => a.index - b.index);
+            // 将处理后的块绘制到结果canvas
+            for (let i = 0; i < results.length; i++) {
+                const { result } = results[i];
+                const tempCanvas = this.imageDataToCanvas(result);
+                if (isWide) {
+                    const startX = i * chunkSize;
+                    resultCtx.drawImage(tempCanvas, startX, 0);
+                }
+                else {
+                    const startY = i * chunkSize;
+                    resultCtx.drawImage(tempCanvas, 0, startY);
+                }
+            }
+            return resultCtx.getImageData(0, 0, imageData.width, imageData.height);
+        }
+    }
+
+    /**
+     * @file 性能优化工具类
+     * @description 提供节流、防抖、缓存等性能优化功能
+     * @module PerformanceUtils
+     */
+    /**
+     * 节流函数：限制函数在一定时间内只能执行一次
+     *
+     * @param fn 需要节流的函数
+     * @param delay 延迟时间（毫秒）
+     * @returns 节流处理后的函数
+     */
+    function throttle(fn, delay) {
+        let lastCall = 0;
+        let timeoutId = null;
+        return function (...args) {
+            const now = Date.now();
+            const remaining = delay - (now - lastCall);
+            if (remaining <= 0) {
+                if (timeoutId) {
+                    clearTimeout(timeoutId);
+                    timeoutId = null;
+                }
+                lastCall = now;
+                fn.apply(this, args);
+            }
+            else if (!timeoutId) {
+                timeoutId = window.setTimeout(() => {
+                    lastCall = Date.now();
+                    timeoutId = null;
+                    fn.apply(this, args);
+                }, remaining);
+            }
+        };
+    }
+    /**
+     * LRU缓存类 - 使用最近最少使用策略的缓存实现
+     */
+    class LRUCache {
+        /**
+         * 构造LRU缓存
+         * @param maxSize 缓存最大容量
+         */
+        constructor(maxSize = 100) {
+            this.maxSize = maxSize;
+            this.cache = new Map();
+        }
+        /**
+         * 获取缓存项
+         * @param key 缓存键
+         * @returns 缓存值或undefined
+         */
+        get(key) {
+            if (!this.cache.has(key)) {
+                return undefined;
+            }
+            // 获取值
+            const value = this.cache.get(key);
+            // 将项移至最新位置（删除后重新添加）
+            this.cache.delete(key);
+            this.cache.set(key, value);
+            return value;
+        }
+        /**
+         * 设置缓存项
+         * @param key 缓存键
+         * @param value 缓存值
+         */
+        set(key, value) {
+            // 如果键已存在，需要先删除
+            if (this.cache.has(key)) {
+                this.cache.delete(key);
+            }
+            // 如果缓存已满，移除最老的项
+            if (this.cache.size >= this.maxSize) {
+                const oldestKey = this.cache.keys().next().value;
+                this.cache.delete(oldestKey);
+            }
+            // 添加新项
+            this.cache.set(key, value);
+        }
+        /**
+         * 删除缓存项
+         * @param key 缓存键
+         * @returns 是否成功删除
+         */
+        delete(key) {
+            return this.cache.delete(key);
+        }
+        /**
+         * 清空缓存
+         */
+        clear() {
+            this.cache.clear();
+        }
+        /**
+         * 获取当前缓存大小
+         */
+        get size() {
+            return this.cache.size;
+        }
+        /**
+         * 检查键是否存在
+         * @param key 缓存键
+         */
+        has(key) {
+            return this.cache.has(key);
+        }
+    }
+    /**
+     * 图像指纹计算函数 - 用于检测相同或相似图像
+     *
+     * @param imageData 图像数据
+     * @param size 指纹尺寸（默认8x8）
+     * @returns 图像指纹字符串
+     */
+    function calculateImageFingerprint(imageData, size = 8) {
+        // 1. 缩小图像到指定尺寸
+        const canvas = document.createElement('canvas');
+        canvas.width = size;
+        canvas.height = size;
+        const ctx = canvas.getContext('2d');
+        if (!ctx) {
+            return '';
+        }
+        // 创建一个临时canvas来绘制原始imageData
+        const tempCanvas = document.createElement('canvas');
+        tempCanvas.width = imageData.width;
+        tempCanvas.height = imageData.height;
+        const tempCtx = tempCanvas.getContext('2d');
+        if (!tempCtx) {
+            return '';
+        }
+        tempCtx.putImageData(imageData, 0, 0);
+        // 缩小到目标尺寸
+        ctx.drawImage(tempCanvas, 0, 0, imageData.width, imageData.height, 0, 0, size, size);
+        // 2. 转换为灰度
+        const smallImgData = ctx.getImageData(0, 0, size, size);
+        const grayValues = [];
+        for (let i = 0; i < smallImgData.data.length; i += 4) {
+            const r = smallImgData.data[i];
+            const g = smallImgData.data[i + 1];
+            const b = smallImgData.data[i + 2];
+            // 转为灰度: 0.299r + 0.587g + 0.114b
+            const gray = Math.round(0.299 * r + 0.587 * g + 0.114 * b);
+            grayValues.push(gray);
+        }
+        // 3. 计算平均值
+        const avg = grayValues.reduce((sum, val) => sum + val, 0) / grayValues.length;
+        // 4. 比较每个像素与平均值，生成二进制指纹
+        let fingerprint = '';
+        for (const gray of grayValues) {
+            fingerprint += gray >= avg ? '1' : '0';
+        }
+        return fingerprint;
     }
 
     /**
@@ -320,15 +637,48 @@
         constructor(options) {
             this.detecting = false;
             this.detectTimer = null;
+            this.frameCount = 0;
+            this.lastDetectionTime = 0;
             this.camera = new Camera();
             if (typeof options === 'function') {
                 // 兼容旧的构造函数方式
                 this.onDetected = options;
+                this.options = {
+                    detectionInterval: 200,
+                    maxImageDimension: 800,
+                    enableCache: true,
+                    cacheSize: 20,
+                    logger: console.log
+                };
             }
             else if (options) {
                 // 使用新的选项对象方式
+                this.options = {
+                    detectionInterval: 200,
+                    maxImageDimension: 800,
+                    enableCache: true,
+                    cacheSize: 20,
+                    logger: console.log,
+                    ...options
+                };
                 this.onDetected = options.onDetection;
+                this.onError = options.onError;
             }
+            else {
+                this.options = {
+                    detectionInterval: 200,
+                    maxImageDimension: 800,
+                    enableCache: true,
+                    cacheSize: 20,
+                    logger: console.log
+                };
+            }
+            this.detectionInterval = this.options.detectionInterval;
+            this.maxImageDimension = this.options.maxImageDimension;
+            // 初始化结果缓存
+            this.resultCache = new LRUCache(this.options.cacheSize);
+            // 创建节流版本的检测函数
+            this.throttledDetect = throttle(this.performDetection.bind(this), this.detectionInterval);
         }
         /**
          * 启动身份证检测
@@ -341,98 +691,374 @@
         async start(videoElement) {
             await this.camera.initialize(videoElement);
             this.detecting = true;
+            this.frameCount = 0;
+            this.lastDetectionTime = 0;
             this.detect();
         }
         /**
-         * 执行一次身份证检测
-         *
-         * 内部方法，捕获当前视频帧并尝试检测其中的身份证
+         * 停止身份证检测
+         */
+        stop() {
+            this.detecting = false;
+            if (this.detectTimer !== null) {
+                cancelAnimationFrame(this.detectTimer);
+                this.detectTimer = null;
+            }
+        }
+        /**
+         * 持续检测视频帧
          *
          * @private
          */
-        async detect() {
+        detect() {
             if (!this.detecting)
                 return;
-            const imageData = this.camera.captureFrame();
-            if (imageData) {
+            this.detectTimer = requestAnimationFrame(() => {
                 try {
-                    // 简单实现，因为没有完整的OpenCV.js
-                    // 实际项目中应该使用OpenCV.js做更精确的边缘检测
-                    const result = await this.detectIDCard(imageData);
-                    if (this.onDetected) {
-                        this.onDetected(result);
+                    this.frameCount++;
+                    const now = performance.now();
+                    // 帧率控制 - 只有满足时间间隔的帧才进行检测
+                    // 这样可以显著减少CPU使用率，同时保持良好的用户体验
+                    if (this.frameCount % 3 === 0 || now - this.lastDetectionTime >= this.detectionInterval) {
+                        this.throttledDetect();
+                        this.lastDetectionTime = now;
                     }
+                    // 继续下一帧检测
+                    this.detect();
                 }
                 catch (error) {
+                    if (this.onError) {
+                        this.onError(error);
+                    }
+                    else {
+                        console.error('身份证检测错误:', error);
+                    }
+                    // 出错后延迟重试
+                    setTimeout(() => {
+                        if (this.detecting) {
+                            this.detect();
+                        }
+                    }, 1000);
+                }
+            });
+        }
+        /**
+         * 执行单帧检测
+         *
+         * @private
+         */
+        async performDetection() {
+            if (!this.detecting || !this.camera)
+                return;
+            // 获取当前视频帧
+            const frame = this.camera.captureFrame();
+            if (!frame)
+                return;
+            // 检查缓存
+            if (this.options.enableCache) {
+                const fingerprint = calculateImageFingerprint(frame, 16); // 使用更大的尺寸提高特征区分度
+                const cachedResult = this.resultCache.get(fingerprint);
+                if (cachedResult) {
+                    this.options.logger?.('使用缓存的检测结果');
+                    // 使用缓存结果，但更新图像数据以确保最新
+                    const updatedResult = {
+                        ...cachedResult,
+                        imageData: frame
+                    };
+                    if (this.onDetected) {
+                        this.onDetected(updatedResult);
+                    }
+                    return;
+                }
+            }
+            // 降低分辨率以提高性能
+            const downsampledFrame = ImageProcessor.downsampleForProcessing(frame, this.maxImageDimension);
+            try {
+                // 检测身份证
+                const result = await this.detectIDCard(downsampledFrame);
+                // 如果检测成功，将原始图像添加到结果中
+                if (result.success) {
+                    result.imageData = frame;
+                    // 缓存结果
+                    if (this.options.enableCache) {
+                        const fingerprint = calculateImageFingerprint(frame, 16);
+                        this.resultCache.set(fingerprint, result);
+                    }
+                }
+                // 处理检测结果
+                if (this.onDetected) {
+                    this.onDetected(result);
+                }
+            }
+            catch (error) {
+                if (this.onError) {
+                    this.onError(error);
+                }
+                else {
                     console.error('身份证检测错误:', error);
                 }
             }
-            this.detectTimer = window.setTimeout(() => this.detect(), 200);
         }
         /**
-         * 身份证检测核心算法
-         *
-         * 通过图像处理技术检测和提取图像中的身份证区域
+         * 检测图像中的身份证
          *
          * @private
-         * @param {ImageData} imageData - 需要检测身份证的图像数据
-         * @returns {Promise<DetectionResult>} 检测结果，包含成功标志和裁剪后的身份证图像
+         * @param {ImageData} imageData - 要分析的图像数据
+         * @returns {Promise<DetectionResult>} 检测结果
          */
         async detectIDCard(imageData) {
-            // 图像预处理
-            const grayscale = ImageProcessor.toGrayscale(imageData);
-            ImageProcessor.adjustBrightnessContrast(grayscale, 10, 30);
-            // 简化的身份证检测算法
-            // 在真实项目中，这里应该使用OpenCV.js进行轮廓检测和矩形检测
-            // 模拟检测过程
-            const success = Math.random() > 0.7; // 模拟70%的概率检测成功
-            if (success) {
-                // 模拟一个身份证区域，实际项目中应该是根据检测结果
-                const cardWidth = Math.floor(imageData.width * 0.8);
-                const cardHeight = Math.floor(cardWidth * 0.63); // 身份证比例大约是8:5
-                const x = Math.floor((imageData.width - cardWidth) / 2);
-                const y = Math.floor((imageData.height - cardHeight) / 2);
-                // 模拟四个角点
-                const corners = [
-                    { x, y }, // 左上
-                    { x: x + cardWidth, y }, // 右上
-                    { x: x + cardWidth, y: y + cardHeight }, // 右下
-                    { x, y: y + cardHeight } // 左下
+            // 1. 图像预处理
+            ImageProcessor.toGrayscale(imageData);
+            // 2. 检测矩形和边缘（简化版实现）
+            // 注意：实际应用中应使用OpenCV.js或其他计算机视觉库进行更精确的检测
+            // 此处仅作为概念性实现，使用基本矩形检测逻辑
+            // 模拟检测过程，随机判断是否找到身份证
+            // 在实际应用中，此处应当实现实际的计算机视觉算法
+            const detectionResult = {
+                success: Math.random() > 0.3, // 70%的概率成功检测到
+                message: '身份证检测完成'
+            };
+            if (detectionResult.success) {
+                // 模拟一个身份证矩形区域
+                const width = imageData.width;
+                const height = imageData.height;
+                // 大致的身份证区域（按比例）
+                const rectWidth = Math.round(width * 0.7);
+                const rectHeight = Math.round(rectWidth * 0.618); // 身份证是黄金比例
+                const rectX = Math.round((width - rectWidth) / 2);
+                const rectY = Math.round((height - rectHeight) / 2);
+                // 添加四个角点
+                detectionResult.corners = [
+                    { x: rectX, y: rectY },
+                    { x: rectX + rectWidth, y: rectY },
+                    { x: rectX + rectWidth, y: rectY + rectHeight },
+                    { x: rectX, y: rectY + rectHeight }
                 ];
-                // 模拟裁剪图像（实际项目中应该做透视变换）
+                // 添加边界框
+                detectionResult.boundingBox = {
+                    x: rectX,
+                    y: rectY,
+                    width: rectWidth,
+                    height: rectHeight
+                };
+                // 裁剪身份证图像
                 const canvas = document.createElement('canvas');
-                canvas.width = cardWidth;
-                canvas.height = cardHeight;
+                canvas.width = rectWidth;
+                canvas.height = rectHeight;
                 const ctx = canvas.getContext('2d');
                 if (ctx) {
-                    // 从原图中裁剪身份证区域
-                    const sourceCanvas = ImageProcessor.imageDataToCanvas(imageData);
-                    ctx.drawImage(sourceCanvas, x, y, cardWidth, cardHeight, 0, 0, cardWidth, cardHeight);
-                    const croppedImage = ctx.getImageData(0, 0, cardWidth, cardHeight);
-                    return {
-                        success: true,
-                        corners,
-                        croppedImage
-                    };
+                    const tempCanvas = ImageProcessor.imageDataToCanvas(imageData);
+                    ctx.drawImage(tempCanvas, rectX, rectY, rectWidth, rectHeight, 0, 0, rectWidth, rectHeight);
+                    detectionResult.croppedImage = ctx.getImageData(0, 0, rectWidth, rectHeight);
                 }
+                // 设置置信度
+                detectionResult.confidence = 0.7 + Math.random() * 0.3;
             }
-            return { success: false };
+            return detectionResult;
         }
         /**
-         * 停止身份证检测
-         *
-         * 停止检测循环并释放相机资源
+         * 清除检测结果缓存
          */
-        stop() {
-            this.detecting = false;
-            if (this.detectTimer) {
-                clearTimeout(this.detectTimer);
-                this.detectTimer = null;
-            }
+        clearCache() {
+            this.resultCache.clear();
+            this.options.logger?.('检测结果缓存已清除');
+        }
+        /**
+         * 释放资源
+         */
+        dispose() {
+            this.stop();
             this.camera.release();
+            this.resultCache.clear();
         }
     }
 
+    /**
+     * @file Web Worker辅助工具类
+     * @description 提供Worker线程管理功能，用于将计算密集型任务移至后台线程
+     * @module WorkerUtils
+     */
+    /**
+     * 创建Worker线程并处理消息通信
+     *
+     * @param workerFunction 要在Worker中执行的函数
+     * @returns 返回包含发送消息方法的Worker控制对象
+     */
+    function createWorker(workerFunction) {
+        // 将函数转换为字符串，然后创建一个Blob URL
+        const workerCode = `
+    self.onmessage = async function(e) {
+      try {
+        const result = await (${workerFunction.toString()})(e.data);
+        self.postMessage({ success: true, result });
+      } catch (error) {
+        self.postMessage({ 
+          success: false, 
+          error: { message: error.message, stack: error.stack }
+        });
+      }
+    }
+  `;
+        const blob = new Blob([workerCode], { type: 'application/javascript' });
+        const workerUrl = URL.createObjectURL(blob);
+        const worker = new Worker(workerUrl);
+        // 创建一个映射来存储待解析的Promise
+        const promiseMap = new Map();
+        let messageCounter = 0;
+        worker.onmessage = (e) => {
+            // 释放Blob URL
+            if (promiseMap.size === 0) {
+                URL.revokeObjectURL(workerUrl);
+            }
+            const { id, success, result, error } = e.data;
+            const promiseHandlers = promiseMap.get(id);
+            if (promiseHandlers) {
+                promiseMap.delete(id);
+                if (success) {
+                    promiseHandlers.resolve(result);
+                }
+                else {
+                    const workerError = new Error(error.message);
+                    workerError.stack = error.stack;
+                    promiseHandlers.reject(workerError);
+                }
+            }
+        };
+        return {
+            postMessage: (data) => {
+                return new Promise((resolve, reject) => {
+                    const id = messageCounter++;
+                    promiseMap.set(id, { resolve, reject });
+                    worker.postMessage({ id, data });
+                });
+            },
+            terminate: () => {
+                worker.terminate();
+                promiseMap.clear();
+                URL.revokeObjectURL(workerUrl);
+            }
+        };
+    }
+    /**
+     * 判断浏览器是否支持Web Workers
+     *
+     * @returns 是否支持Web Workers
+     */
+    function isWorkerSupported() {
+        return typeof Worker !== 'undefined';
+    }
+
+    /**
+     * @file OCR Worker处理模块
+     * @description 用于在Web Worker中执行OCR处理
+     * @module OCRWorker
+     */
+    /**
+     * 在Web Worker中执行OCR处理的函数
+     *
+     * 该函数用于在使用 createWorker 创建的 Worker 中执行
+     *
+     * @param input OCR处理输入数据
+     * @returns OCR处理结果
+     */
+    async function processOCRInWorker(input) {
+        // 计时开始
+        const startTime = performance.now();
+        // 加载Tesseract.js (Worker 环境下动态导入)
+        const { createWorker } = await import('tesseract.js');
+        // 创建OCR Worker
+        const worker = createWorker(input.tessWorkerOptions || {
+            logger: (m) => console.log(m)
+        });
+        try {
+            // 初始化OCR引擎
+            await worker.load();
+            await worker.loadLanguage('chi_sim');
+            await worker.initialize('chi_sim');
+            await worker.setParameters({
+                tessedit_char_whitelist: '0123456789X-年月日一二三四五六七八九十零壹贰叁肆伍陆柒捌玖拾ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz民族汉族满族回族维吾尔族藏族苗族彝族壮族朝鲜族侗族瑶族白族土家族哈尼族哈萨克族傣族黎族傈僳族佤族高山族拉祜族水族东乡族钠西族景颇族柯尔克孜族士族达斡尔族仫佬族羌族布朗族撒拉族毛南族仡佬族锡伯族阿昌族普米族塔吉克族怒族乌孜别克族俄罗斯族鄂温克族德昂族保安族裕固族京族塔塔尔族独龙族鄂伦春族赫哲族门巴族珞巴族基诺族男女性别住址出生公民身份号码签发机关有效期'
+            });
+            // 识别图像
+            const { data } = await worker.recognize(input.imageBase64);
+            // 解析识别结果
+            const idCardInfo = parseIDCardText(data.text);
+            // 处理完成后终止worker
+            await worker.terminate();
+            // 计算处理时间
+            const processingTime = performance.now() - startTime;
+            // 返回处理结果
+            return {
+                idCardInfo,
+                processingTime
+            };
+        }
+        catch (error) {
+            // 确保资源被释放
+            await worker.terminate();
+            throw error;
+        }
+    }
+    /**
+     * 解析身份证文本信息
+     *
+     * 从OCR识别到的文本中提取结构化的身份证信息
+     *
+     * @private
+     * @param {string} text - OCR识别到的文本
+     * @returns {IDCardInfo} 提取到的身份证信息对象
+     */
+    function parseIDCardText(text) {
+        const info = {};
+        // 拆分为行
+        const lines = text.split('\n').filter(line => line.trim());
+        // 解析身份证号码（最容易识别的部分）
+        const idNumberRegex = /(\d{17}[\dX])/;
+        const idNumberMatch = text.match(idNumberRegex);
+        if (idNumberMatch) {
+            info.idNumber = idNumberMatch[1];
+        }
+        // 解析姓名
+        for (const line of lines) {
+            if (line.includes('姓名') || line.length < 10 && line.length > 1 && !/\d/.test(line)) {
+                info.name = line.replace('姓名', '').trim();
+                break;
+            }
+        }
+        // 解析性别和民族
+        const genderNationalityRegex = /(男|女).*(族)/;
+        const genderMatch = text.match(genderNationalityRegex);
+        if (genderMatch) {
+            info.gender = genderMatch[1];
+            const nationalityText = genderMatch[0];
+            info.nationality = nationalityText.substring(nationalityText.indexOf(genderMatch[1]) + 1).trim();
+        }
+        // 解析出生日期
+        const birthDateRegex = /(\d{4})年(\d{1,2})月(\d{1,2})日/;
+        const birthDateMatch = text.match(birthDateRegex);
+        if (birthDateMatch) {
+            info.birthDate = `${birthDateMatch[1]}-${birthDateMatch[2]}-${birthDateMatch[3]}`;
+        }
+        // 解析地址
+        const addressRegex = /住址([\s\S]*?)公民身份号码/;
+        const addressMatch = text.match(addressRegex);
+        if (addressMatch) {
+            info.address = addressMatch[1].replace(/\n/g, '').trim();
+        }
+        // 解析签发机关
+        const authorityRegex = /签发机关([\s\S]*?)有效期/;
+        const authorityMatch = text.match(authorityRegex);
+        if (authorityMatch) {
+            info.issuingAuthority = authorityMatch[1].replace(/\n/g, '').trim();
+        }
+        // 解析有效期限
+        const validPeriodRegex = /有效期限([\s\S]*?)(-|至)/;
+        const validPeriodMatch = text.match(validPeriodRegex);
+        if (validPeriodMatch) {
+            info.validPeriod = validPeriodMatch[0].replace('有效期限', '').trim();
+        }
+        return info;
+    }
+
     /**
      * @file OCR处理模块
      * @description 提供身份证文字识别和信息提取功能
@@ -460,8 +1086,25 @@
      * ```
      */
     class OCRProcessor {
-        constructor() {
+        /**
+         * 创建OCR处理器实例
+         *
+         * @param options OCR处理器选项
+         */
+        constructor(options = {}) {
             this.worker = null;
+            this.ocrWorker = null;
+            this.initialized = false;
+            this.options = {
+                useWorker: isWorkerSupported(),
+                enableCache: true,
+                cacheSize: 50,
+                maxImageDimension: 1000,
+                logger: console.log,
+                ...options
+            };
+            // 初始化缓存
+            this.resultCache = new LRUCache(this.options.cacheSize);
         }
         /**
          * 初始化OCR引擎
@@ -471,15 +1114,28 @@
          * @returns {Promise<void>} 初始化完成的Promise
          */
         async initialize() {
-            this.worker = tesseract_js.createWorker({
-                logger: (m) => console.log(m)
-            });
-            await this.worker.load();
-            await this.worker.loadLanguage('chi_sim');
-            await this.worker.initialize('chi_sim');
-            await this.worker.setParameters({
-                tessedit_char_whitelist: '0123456789X-年月日一二三四五六七八九十零壹贰叁肆伍陆柒捌玖拾ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz民族汉族满族回族维吾尔族藏族苗族彝族壮族朝鲜族侗族瑶族白族土家族哈尼族哈萨克族傣族黎族傈僳族佤族高山族拉祜族水族东乡族钠西族景颇族柯尔克孜族士族达斡尔族仫佬族羌族布朗族撒拉族毛南族仡佬族锡伯族阿昌族普米族塔吉克族怒族乌孜别克族俄罗斯族鄂温克族德昂族保安族裕固族京族塔塔尔族独龙族鄂伦春族赫哲族门巴族珞巴族基诺族男女性别住址出生公民身份号码签发机关有效期'
-            });
+            if (this.initialized)
+                return;
+            if (this.options.useWorker) {
+                // 使用自定义Worker线程处理OCR
+                this.ocrWorker = createWorker(processOCRInWorker);
+                this.initialized = true;
+                this.options.logger?.('OCR Worker 初始化完成');
+            }
+            else {
+                // 使用主线程处理OCR
+                this.worker = tesseract_js.createWorker({
+                    logger: this.options.logger
+                });
+                await this.worker.load();
+                await this.worker.loadLanguage('chi_sim');
+                await this.worker.initialize('chi_sim');
+                await this.worker.setParameters({
+                    tessedit_char_whitelist: '0123456789X-年月日一二三四五六七八九十零壹贰叁肆伍陆柒捌玖拾ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz民族汉族满族回族维吾尔族藏族苗族彝族壮族朝鲜族侗族瑶族白族土家族哈尼族哈萨克族傣族黎族傈僳族佤族高山族拉祜族水族东乡族钠西族景颇族柯尔克孜族士族达斡尔族仫佬族羌族布朗族撒拉族毛南族仡佬族锡伯族阿昌族普米族塔吉克族怒族乌孜别克族俄罗斯族鄂温克族德昂族保安族裕固族京族塔塔尔族独龙族鄂伦春族赫哲族门巴族珞巴族基诺族男女性别住址出生公民身份号码签发机关有效期'
+                });
+                this.initialized = true;
+                this.options.logger?.('OCR引擎初始化完成');
+            }
         }
         /**
          * 处理身份证图像并提取信息
@@ -487,21 +1143,57 @@
          * @returns 提取的身份证信息
          */
         async processIDCard(imageData) {
-            if (!this.worker) {
+            if (!this.initialized) {
                 await this.initialize();
             }
-            // 图像预处理，提高OCR识别率
-            const enhancedImage = ImageProcessor.adjustBrightnessContrast(imageData, 15, 25);
-            // 转换ImageData为Canvas
-            const canvas = ImageProcessor.imageDataToCanvas(enhancedImage);
+            // 计算图像指纹，用于缓存查找
+            if (this.options.enableCache) {
+                const fingerprint = calculateImageFingerprint(imageData);
+                // 检查缓存中是否有结果
+                const cachedResult = this.resultCache.get(fingerprint);
+                if (cachedResult) {
+                    this.options.logger?.('使用缓存的OCR结果');
+                    return cachedResult;
+                }
+            }
+            // 图像预处理：降低分辨率和增强对比度
+            const downsampledImage = ImageProcessor.downsampleForProcessing(imageData, this.options.maxImageDimension);
+            const enhancedImage = ImageProcessor.adjustBrightnessContrast(downsampledImage, 15, 25);
             // OCR识别
             try {
-                const { data } = await this.worker.recognize(canvas);
-                // 解析身份证信息
-                return this.parseIDCardText(data.text);
+                let idCardInfo;
+                if (this.options.useWorker && this.ocrWorker) {
+                    // 使用Worker线程处理
+                    const base64Image = ImageProcessor.imageDataToBase64(enhancedImage);
+                    const result = await this.ocrWorker.postMessage({
+                        imageBase64: base64Image,
+                        tessWorkerOptions: {
+                            logger: this.options.logger
+                        }
+                    });
+                    idCardInfo = result.idCardInfo;
+                    this.options.logger?.(`OCR处理完成，用时: ${result.processingTime.toFixed(2)}ms`);
+                }
+                else {
+                    // 使用主线程处理
+                    const startTime = performance.now();
+                    // 转换ImageData为Canvas
+                    const canvas = ImageProcessor.imageDataToCanvas(enhancedImage);
+                    const { data } = await this.worker.recognize(canvas);
+                    // 解析身份证信息
+                    idCardInfo = this.parseIDCardText(data.text);
+                    const processingTime = performance.now() - startTime;
+                    this.options.logger?.(`OCR处理完成，用时: ${processingTime.toFixed(2)}ms`);
+                }
+                // 缓存结果
+                if (this.options.enableCache) {
+                    const fingerprint = calculateImageFingerprint(imageData);
+                    this.resultCache.set(fingerprint, idCardInfo);
+                }
+                return idCardInfo;
             }
             catch (error) {
-                console.error('OCR识别错误:', error);
+                this.options.logger?.(`OCR识别错误: ${error}`);
                 return {};
             }
         }
@@ -565,6 +1257,13 @@
             }
             return info;
         }
+        /**
+         * 清除结果缓存
+         */
+        clearCache() {
+            this.resultCache.clear();
+            this.options.logger?.('OCR结果缓存已清除');
+        }
         /**
          * 终止OCR引擎并释放资源
          *
@@ -575,6 +1274,18 @@
                 await this.worker.terminate();
                 this.worker = null;
             }
+            if (this.ocrWorker) {
+                this.ocrWorker.terminate();
+                this.ocrWorker = null;
+            }
+            this.initialized = false;
+            this.options.logger?.('OCR引擎已终止');
+        }
+        /**
+         * 释放资源
+         */
+        dispose() {
+            return this.terminate();
         }
     }