id-scanner-lib 1.0.0 → 1.2.0

package/dist/id-scanner-ocr.js

@@ -0,0 +1,1634 @@
+(function (global, factory) {
+    typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('tesseract.js')) :
+    typeof define === 'function' && define.amd ? define(['exports', 'tesseract.js'], factory) :
+    (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.IDScannerOCR = {}, global.Tesseract));
+})(this, (function (exports, tesseract_js) { 'use strict';
+
+    /**
+     * @file 相机工具类
+     * @description 提供访问和控制设备摄像头的功能
+     * @module Camera
+     */
+    /**
+     * 相机工具类
+     *
+     * 提供访问设备摄像头、获取视频流以及捕获图像帧的功能
+     *
+     * @example
+     * ```typescript
+     * // 创建相机实例
+     * const camera = new Camera({
+     *   width: 1280,
+     *   height: 720,
+     *   facingMode: 'environment' // 使用后置摄像头
+     * });
+     *
+     * // 初始化相机
+     * const videoElement = document.getElementById('video') as HTMLVideoElement;
+     * await camera.start(videoElement);
+     *
+     * // 捕获当前视频帧
+     * const imageData = camera.captureFrame();
+     *
+     * // 使用结束后释放资源
+     * camera.stop();
+     * ```
+     */
+    class Camera {
+        /**
+         * 创建相机实例
+         * @param {CameraOptions} [options] - 相机配置选项
+         */
+        constructor(options = {}) {
+            this.options = options;
+            this.stream = null;
+            this.videoElement = null;
+            this.options = {
+                width: 640,
+                height: 480,
+                facingMode: 'environment',
+                ...options
+            };
+        }
+        /**
+         * 启动摄像头并将视频流绑定到视频元素
+         * @param videoElement HTML视频元素
+         * @returns Promise<void>
+         */
+        async start(videoElement) {
+            return this.initialize(videoElement);
+        }
+        /**
+         * 停止摄像头并释放资源
+         */
+        stop() {
+            this.release();
+        }
+        /**
+         * 初始化相机，获取视频流并绑定到视频元素
+         *
+         * @param {HTMLVideoElement} videoElement - 用于显示视频流的视频元素
+         * @returns {Promise<void>} 初始化完成的Promise
+         * @throws 如果无法访问摄像头，将抛出错误
+         */
+        async initialize(videoElement) {
+            this.videoElement = videoElement;
+            try {
+                // 构建媒体约束
+                const constraints = {
+                    video: {
+                        width: { ideal: this.options.width },
+                        height: { ideal: this.options.height },
+                        facingMode: this.options.facingMode
+                    }
+                };
+                // 获取视频流
+                this.stream = await navigator.mediaDevices.getUserMedia(constraints);
+                // 绑定到视频元素
+                if (this.videoElement) {
+                    this.videoElement.srcObject = this.stream;
+                    await new Promise((resolve) => {
+                        if (this.videoElement) {
+                            this.videoElement.onloadedmetadata = () => {
+                                if (this.videoElement) {
+                                    this.videoElement.play().then(() => resolve());
+                                }
+                            };
+                        }
+                    });
+                }
+            }
+            catch (error) {
+                console.error('无法访问摄像头:', error);
+                throw new Error('无法访问摄像头。请确保已授予摄像头访问权限，并且摄像头未被其他应用程序占用。');
+            }
+        }
+        /**
+         * 捕获当前视频帧
+         *
+         * @returns {ImageData|null} 视频帧的ImageData对象，如果未初始化则返回null
+         */
+        captureFrame() {
+            if (!this.videoElement) {
+                return null;
+            }
+            // 创建Canvas元素用于捕获视频帧
+            const canvas = document.createElement('canvas');
+            canvas.width = this.videoElement.videoWidth;
+            canvas.height = this.videoElement.videoHeight;
+            const context = canvas.getContext('2d');
+            if (!context) {
+                return null;
+            }
+            // 将视频内容绘制到Canvas中
+            context.drawImage(this.videoElement, 0, 0, canvas.width, canvas.height);
+            // 获取ImageData对象
+            return context.getImageData(0, 0, canvas.width, canvas.height);
+        }
+        /**
+         * 释放摄像头资源
+         */
+        release() {
+            // 停止视频流的所有轨道
+            if (this.stream) {
+                this.stream.getTracks().forEach(track => track.stop());
+                this.stream = null;
+            }
+            // 清除视频元素绑定
+            if (this.videoElement) {
+                this.videoElement.srcObject = null;
+                this.videoElement = null;
+            }
+        }
+    }
+
+    /**
+     * @file 图像处理工具类
+     * @description 提供图像处理相关的辅助功能
+     * @module ImageProcessor
+     */
+    /**
+     * 图像处理工具类
+     *
+     * 提供常用的图像处理功能，如亮度和对比度调整、灰度转换、图像大小调整等。
+     * 这些功能可用于增强图像质量，提高OCR和扫描的识别率。
+     *
+     * @example
+     * ```typescript
+     * // 使用图像处理功能增强图像
+     * const enhancedImage = ImageProcessor.adjustBrightnessContrast(
+     *   originalImageData,
+     *   15,  // 增加亮度
+     *   25   // 增加对比度
+     * );
+     *
+     * // 转换为灰度图像
+     * const grayImage = ImageProcessor.toGrayscale(originalImageData);
+     * ```
+     */
+    class ImageProcessor {
+        /**
+         * 将ImageData转换为Canvas元素
+         *
+         * @param {ImageData} imageData - 要转换的图像数据
+         * @returns {HTMLCanvasElement} 包含图像的Canvas元素
+         */
+        static imageDataToCanvas(imageData) {
+            const canvas = document.createElement('canvas');
+            canvas.width = imageData.width;
+            canvas.height = imageData.height;
+            const ctx = canvas.getContext('2d');
+            if (ctx) {
+                ctx.putImageData(imageData, 0, 0);
+            }
+            return canvas;
+        }
+        /**
+         * 将Canvas转换为ImageData
+         *
+         * @param {HTMLCanvasElement} canvas - 要转换的Canvas元素
+         * @returns {ImageData|null} Canvas的图像数据，如果获取失败则返回null
+         */
+        static canvasToImageData(canvas) {
+            const ctx = canvas.getContext('2d');
+            return ctx ? ctx.getImageData(0, 0, canvas.width, canvas.height) : null;
+        }
+        /**
+         * 调整图像亮度和对比度
+         *
+         * @param {ImageData} imageData - 要处理的图像数据
+         * @param {number} [brightness=0] - 亮度调整值，正值增加亮度，负值降低亮度，范围建议为-100到100
+         * @param {number} [contrast=0] - 对比度调整值，正值增加对比度，负值降低对比度，范围建议为-100到100
+         * @returns {ImageData} 处理后的图像数据
+         */
+        static adjustBrightnessContrast(imageData, brightness = 0, contrast = 0) {
+            const canvas = this.imageDataToCanvas(imageData);
+            const ctx = canvas.getContext('2d');
+            if (ctx) {
+                const imgData = ctx.getImageData(0, 0, canvas.width, canvas.height);
+                const data = imgData.data;
+                // 调整对比度算法
+                const factor = (259 * (contrast + 255)) / (255 * (259 - contrast));
+                for (let i = 0; i < data.length; i += 4) {
+                    // 红色
+                    data[i] = this.truncate(factor * (data[i] - 128) + 128 + brightness);
+                    // 绿色
+                    data[i + 1] = this.truncate(factor * (data[i + 1] - 128) + 128 + brightness);
+                    // 蓝色
+                    data[i + 2] = this.truncate(factor * (data[i + 2] - 128) + 128 + brightness);
+                    // Alpha不变
+                }
+                ctx.putImageData(imgData, 0, 0);
+                return imgData;
+            }
+            return imageData;
+        }
+        /**
+         * 确保值在0-255范围内
+         *
+         * @private
+         * @param {number} value - 要截断的值
+         * @returns {number} 截断后的值，范围为0-255
+         */
+        static truncate(value) {
+            return Math.min(255, Math.max(0, value));
+        }
+        /**
+         * 将彩色图像转换为灰度图像
+         *
+         * 灰度转换可以简化图像，提高OCR和条形码识别的准确率
+         *
+         * @param {ImageData} imageData - 要转换的彩色图像
+         * @returns {ImageData} 转换后的灰度图像
+         */
+        static toGrayscale(imageData) {
+            const canvas = this.imageDataToCanvas(imageData);
+            const ctx = canvas.getContext('2d');
+            if (ctx) {
+                const imgData = ctx.getImageData(0, 0, canvas.width, canvas.height);
+                const data = imgData.data;
+                for (let i = 0; i < data.length; i += 4) {
+                    const avg = (data[i] + data[i + 1] + data[i + 2]) / 3;
+                    data[i] = avg; // 红色
+                    data[i + 1] = avg; // 绿色
+                    data[i + 2] = avg; // 蓝色
+                    // Alpha不变
+                }
+                ctx.putImageData(imgData, 0, 0);
+                return imgData;
+            }
+            return imageData;
+        }
+        /**
+         * 调整图像大小
+         *
+         * @param {ImageData} imageData - 原图像数据
+         * @param {number} newWidth - 新宽度
+         * @param {number} newHeight - 新高度
+         * @returns {ImageData} 调整大小后的图像数据
+         */
+        static resize(imageData, newWidth, newHeight) {
+            const canvas = document.createElement('canvas');
+            canvas.width = newWidth;
+            canvas.height = newHeight;
+            const ctx = canvas.getContext('2d');
+            if (ctx) {
+                const tempCanvas = this.imageDataToCanvas(imageData);
+                ctx.drawImage(tempCanvas, 0, 0, imageData.width, imageData.height, 0, 0, newWidth, newHeight);
+                return ctx.getImageData(0, 0, newWidth, newHeight);
+            }
+            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;
+    }
+
+    /**
+     * @file 身份证检测模块
+     * @description 提供自动检测和定位图像中的身份证功能
+     * @module IDCardDetector
+     */
+    /**
+     * 身份证检测器类
+     *
+     * 通过图像处理和计算机视觉技术，实时检测视频流中的身份证，并提取身份证区域
+     * 注意：当前实现是简化版，实际项目中建议使用OpenCV.js进行更精确的检测
+     *
+     * @example
+     * ```typescript
+     * // 创建身份证检测器
+     * const detector = new IDCardDetector((result) => {
+     *   if (result.success && result.croppedImage) {
+     *     console.log('检测到身份证!');
+     *     // 对裁剪出的身份证图像进行处理
+     *     processIDCardImage(result.croppedImage);
+     *   }
+     * });
+     *
+     * // 启动检测
+     * const videoElement = document.getElementById('video') as HTMLVideoElement;
+     * await detector.start(videoElement);
+     *
+     * // 停止检测
+     * detector.stop();
+     * ```
+     */
+    class IDCardDetector {
+        /**
+         * 创建身份证检测器实例
+         *
+         * @param options 身份证检测器配置选项，或者检测回调函数
+         */
+        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);
+        }
+        /**
+         * 启动身份证检测
+         *
+         * 初始化相机并开始连续检测视频帧中的身份证
+         *
+         * @param {HTMLVideoElement} videoElement - 用于显示相机画面的video元素
+         * @returns {Promise<void>} 启动完成的Promise
+         */
+        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
+         */
+        detect() {
+            if (!this.detecting)
+                return;
+            this.detectTimer = requestAnimationFrame(() => {
+                try {
+                    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);
+                }
+            }
+        }
+        /**
+         * 检测图像中的身份证
+         *
+         * @private
+         * @param {ImageData} imageData - 要分析的图像数据
+         * @returns {Promise<DetectionResult>} 检测结果
+         */
+        async detectIDCard(imageData) {
+            // 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 = rectWidth;
+                canvas.height = rectHeight;
+                const ctx = canvas.getContext('2d');
+                if (ctx) {
+                    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 detectionResult;
+        }
+        /**
+         * 清除检测结果缓存
+         */
+        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 提供身份证文字识别和信息提取功能
+     * @module OCRProcessor
+     */
+    /**
+     * OCR处理器类
+     *
+     * 使用Tesseract.js实现对身份证图像的OCR文字识别和信息提取功能
+     *
+     * @example
+     * ```typescript
+     * // 创建OCR处理器
+     * const ocrProcessor = new OCRProcessor();
+     *
+     * // 初始化OCR引擎
+     * await ocrProcessor.initialize();
+     *
+     * // 处理身份证图像
+     * const idInfo = await ocrProcessor.processIDCard(idCardImageData);
+     * console.log('识别到的身份证信息:', idInfo);
+     *
+     * // 使用结束后释放资源
+     * await ocrProcessor.terminate();
+     * ```
+     */
+    class OCRProcessor {
+        /**
+         * 创建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引擎
+         *
+         * 加载Tesseract OCR引擎和中文简体语言包，并设置适合身份证识别的参数
+         *
+         * @returns {Promise<void>} 初始化完成的Promise
+         */
+        async initialize() {
+            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引擎初始化完成');
+            }
+        }
+        /**
+         * 处理身份证图像并提取信息
+         * @param imageData 要处理的身份证图像数据
+         * @returns 提取的身份证信息
+         */
+        async processIDCard(imageData) {
+            if (!this.initialized) {
+                await this.initialize();
+            }
+            // 计算图像指纹，用于缓存查找
+            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 {
+                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) {
+                this.options.logger?.(`OCR识别错误: ${error}`);
+                return {};
+            }
+        }
+        /**
+         * 解析身份证文本信息
+         *
+         * 从OCR识别到的文本中提取结构化的身份证信息
+         *
+         * @private
+         * @param {string} text - OCR识别到的文本
+         * @returns {IDCardInfo} 提取到的身份证信息对象
+         */
+        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;
+        }
+        /**
+         * 清除结果缓存
+         */
+        clearCache() {
+            this.resultCache.clear();
+            this.options.logger?.('OCR结果缓存已清除');
+        }
+        /**
+         * 终止OCR引擎并释放资源
+         *
+         * @returns {Promise<void>} 终止完成的Promise
+         */
+        async terminate() {
+            if (this.worker) {
+                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();
+        }
+    }
+
+    /**
+     * @file 数据提取工具类
+     * @description 提供身份证信息的验证和格式化功能
+     * @module DataExtractor
+     */
+    /**
+     * 数据提取工具类
+     *
+     * 提供身份证信息的验证、提取和增强功能，可以从身份证号码中提取出生日期、性别等信息，
+     * 并对OCR识别结果进行补充和验证
+     *
+     * @example
+     * ```typescript
+     * // 验证身份证号码
+     * const isValid = DataExtractor.validateIDNumber('110101199001011234');
+     *
+     * // 从身份证号码提取出生日期
+     * const birthDate = DataExtractor.extractBirthDateFromID('110101199001011234');
+     * // 结果: '1990-01-01'
+     *
+     * // 增强OCR识别结果
+     * const enhancedInfo = DataExtractor.enhanceIDCardInfo({
+     *   name: '张三',
+     *   idNumber: '110101199001011234'
+     * });
+     * // 结果会自动补充性别和出生日期
+     * ```
+     */
+    class DataExtractor {
+        /**
+         * 验证身份证号码格式
+         *
+         * 检查身份证号码的长度、格式和出生日期部分是否有效
+         *
+         * @param {string} idNumber - 要验证的身份证号码
+         * @returns {boolean} 是否是有效的身份证号码
+         */
+        static validateIDNumber(idNumber) {
+            // 简单校验长度
+            if (!idNumber || idNumber.length !== 18) {
+                return false;
+            }
+            // 校验格式 (前17位必须是数字，最后一位可以是数字或X)
+            const pattern = /^\d{17}[\dX]$/;
+            if (!pattern.test(idNumber)) {
+                return false;
+            }
+            // 校验出生日期
+            const year = parseInt(idNumber.substr(6, 4));
+            const month = parseInt(idNumber.substr(10, 2));
+            const day = parseInt(idNumber.substr(12, 2));
+            const date = new Date(year, month - 1, day);
+            if (date.getFullYear() !== year ||
+                date.getMonth() + 1 !== month ||
+                date.getDate() !== day) {
+                return false;
+            }
+            // 简单的校验规则，实际项目中可以加入更完善的验证
+            return true;
+        }
+        /**
+         * 从身份证号码提取出生日期
+         *
+         * @param {string} idNumber - 身份证号码
+         * @returns {string|null} 格式化的出生日期（YYYY-MM-DD），如果身份证号码无效则返回null
+         */
+        static extractBirthDateFromID(idNumber) {
+            if (!this.validateIDNumber(idNumber)) {
+                return null;
+            }
+            const year = idNumber.substr(6, 4);
+            const month = idNumber.substr(10, 2);
+            const day = idNumber.substr(12, 2);
+            return `${year}-${month}-${day}`;
+        }
+        /**
+         * 从身份证号码提取性别
+         *
+         * 根据身份证号码第17位判断性别，奇数为男，偶数为女
+         *
+         * @param {string} idNumber - 身份证号码
+         * @returns {string|null} '男'或'女'，如果身份证号码无效则返回null
+         */
+        static extractGenderFromID(idNumber) {
+            if (!this.validateIDNumber(idNumber)) {
+                return null;
+            }
+            // 第17位，奇数为男，偶数为女
+            const genderCode = parseInt(idNumber.charAt(16));
+            return genderCode % 2 === 1 ? '男' : '女';
+        }
+        /**
+         * 从身份证号码提取地区编码
+         *
+         * @param {string} idNumber - 身份证号码
+         * @returns {string|null} 地区编码（前6位），如果身份证号码无效则返回null
+         */
+        static extractRegionFromID(idNumber) {
+            if (!this.validateIDNumber(idNumber)) {
+                return null;
+            }
+            return idNumber.substr(0, 6);
+        }
+        /**
+         * 合并并优化身份证信息
+         *
+         * 使用多个来源的数据进行交叉验证和补充，如果OCR识别结果缺少某些信息，
+         * 但有身份证号码，则可以从号码中提取出生日期和性别等信息
+         *
+         * @param {IDCardInfo} ocrInfo - OCR识别到的身份证信息
+         * @param {string} [idNumber] - 可选的外部提供的身份证号码，优先级高于OCR识别结果
+         * @returns {IDCardInfo} 增强后的身份证信息
+         */
+        static enhanceIDCardInfo(ocrInfo, idNumber) {
+            const result = { ...ocrInfo };
+            // 如果OCR识别出身份证号，但没有识别出生日期或性别，则从身份证号码提取
+            if (result.idNumber && this.validateIDNumber(result.idNumber)) {
+                // 从身份证号提取出生日期
+                if (!result.birthDate) {
+                    result.birthDate = this.extractBirthDateFromID(result.idNumber) || undefined;
+                }
+                // 从身份证号提取性别
+                if (!result.gender) {
+                    result.gender = this.extractGenderFromID(result.idNumber) || undefined;
+                }
+            }
+            // 如果外部传入了身份证号，则优先使用它并提取信息
+            if (idNumber && this.validateIDNumber(idNumber)) {
+                result.idNumber = idNumber;
+                // 使用身份证号码再次验证或补充信息
+                const birthDate = this.extractBirthDateFromID(idNumber);
+                if (birthDate) {
+                    result.birthDate = birthDate;
+                }
+                const gender = this.extractGenderFromID(idNumber);
+                if (gender) {
+                    result.gender = gender;
+                }
+            }
+            return result;
+        }
+        /**
+         * 提取并验证身份证信息
+         *
+         * @param idCardInfo 初步提取的身份证信息
+         * @returns 验证和增强后的身份证信息
+         */
+        extractAndValidate(idCardInfo) {
+            const enhancedInfo = { ...idCardInfo };
+            // 验证和规范化身份证号
+            if (enhancedInfo.idNumber) {
+                enhancedInfo.idNumber = this.normalizeIDNumber(enhancedInfo.idNumber);
+                // 如果身份证号有效，推断出生日期
+                if (this.validateIDNumber(enhancedInfo.idNumber)) {
+                    if (!enhancedInfo.birthDate) {
+                        enhancedInfo.birthDate = this.extractBirthDateFromID(enhancedInfo.idNumber);
+                    }
+                    // 推断性别
+                    if (!enhancedInfo.gender) {
+                        enhancedInfo.gender = this.extractGenderFromID(enhancedInfo.idNumber);
+                    }
+                }
+            }
+            // 规范化日期格式
+            if (enhancedInfo.birthDate) {
+                enhancedInfo.birthDate = this.normalizeDate(enhancedInfo.birthDate);
+            }
+            // 规范化地址信息
+            if (enhancedInfo.address) {
+                enhancedInfo.address = this.normalizeAddress(enhancedInfo.address);
+            }
+            return enhancedInfo;
+        }
+        /**
+         * 规范化身份证号码
+         */
+        normalizeIDNumber(idNumber) {
+            // 移除空格和特殊字符
+            return idNumber.replace(/[\s\-]/g, '').toUpperCase();
+        }
+        /**
+         * 验证身份证号码是否有效
+         */
+        validateIDNumber(idNumber) {
+            // 简单验证身份证号码长度和格式
+            const idRegex = /(^\d{15}$)|(^\d{17}([0-9]|X)$)/;
+            return idRegex.test(idNumber);
+        }
+        /**
+         * 从身份证号中提取出生日期
+         */
+        extractBirthDateFromID(idNumber) {
+            if (idNumber.length === 18) {
+                return `${idNumber.substring(6, 10)}-${idNumber.substring(10, 12)}-${idNumber.substring(12, 14)}`;
+            }
+            else if (idNumber.length === 15) {
+                return `19${idNumber.substring(6, 8)}-${idNumber.substring(8, 10)}-${idNumber.substring(10, 12)}`;
+            }
+            return '';
+        }
+        /**
+         * 从身份证号中提取性别信息
+         */
+        extractGenderFromID(idNumber) {
+            let sexCode;
+            if (idNumber.length === 18) {
+                sexCode = parseInt(idNumber.charAt(16));
+            }
+            else {
+                sexCode = parseInt(idNumber.charAt(14));
+            }
+            return sexCode % 2 === 1 ? '男' : '女';
+        }
+        /**
+         * 规范化日期格式
+         */
+        normalizeDate(date) {
+            // 简单的日期格式化逻辑
+            return date.replace(/(\d{4})(\d{2})(\d{2})/, '$1-$2-$3');
+        }
+        /**
+         * 规范化地址信息
+         */
+        normalizeAddress(address) {
+            // 地址格式化逻辑
+            return address.trim();
+        }
+    }
+
+    /**
+     * @file OCR模块入口文件
+     * @description 包含身份证OCR识别相关功能
+     * @module IDScannerOCR
+     * @version 1.0.0
+     * @license MIT
+     */
+    /**
+     * OCR模块类
+     *
+     * 提供身份证检测和OCR文字识别功能
+     */
+    class OCRModule {
+        /**
+         * 构造函数
+         * @param options 配置选项
+         */
+        constructor(options = {}) {
+            this.options = options;
+            this.isRunning = false;
+            this.videoElement = null;
+            this.camera = new Camera(options.cameraOptions);
+            this.idDetector = new IDCardDetector({
+                onDetection: this.handleIDDetection.bind(this),
+                onError: this.handleError.bind(this)
+            });
+            this.ocrProcessor = new OCRProcessor();
+            this.dataExtractor = new DataExtractor();
+        }
+        /**
+         * 初始化OCR引擎
+         *
+         * @returns Promise<void>
+         */
+        async initialize() {
+            try {
+                await this.ocrProcessor.initialize();
+                console.log('OCR engine initialized');
+            }
+            catch (error) {
+                this.handleError(error);
+                throw error;
+            }
+        }
+        /**
+         * 启动身份证扫描
+         * @param videoElement HTML视频元素
+         */
+        async startIDCardScanner(videoElement) {
+            if (!this.ocrProcessor) {
+                throw new Error('OCR engine not initialized. Call initialize() first.');
+            }
+            this.videoElement = videoElement;
+            this.isRunning = true;
+            await this.camera.start(videoElement);
+            this.idDetector.start(videoElement);
+        }
+        /**
+         * 停止扫描
+         */
+        stop() {
+            this.isRunning = false;
+            this.idDetector.stop();
+            this.camera.stop();
+        }
+        /**
+         * 处理身份证检测结果
+         */
+        async handleIDDetection(result) {
+            if (!this.isRunning)
+                return;
+            try {
+                // 检查 imageData 是否存在
+                if (!result.imageData) {
+                    this.handleError(new Error('无效的图像数据'));
+                    return;
+                }
+                const idCardInfo = await this.ocrProcessor.processIDCard(result.imageData);
+                const extractedInfo = this.dataExtractor.extractAndValidate(idCardInfo);
+                if (this.options.onIDCardScanned) {
+                    this.options.onIDCardScanned(extractedInfo);
+                }
+            }
+            catch (error) {
+                this.handleError(error);
+            }
+        }
+        /**
+         * 处理错误
+         */
+        handleError(error) {
+            if (this.options.onError) {
+                this.options.onError(error);
+            }
+            else {
+                console.error('OCRModule error:', error);
+            }
+        }
+        /**
+         * 释放资源
+         */
+        async terminate() {
+            this.stop();
+            await this.ocrProcessor.terminate();
+        }
+    }
+
+    exports.DataExtractor = DataExtractor;
+    exports.IDCardDetector = IDCardDetector;
+    exports.OCRModule = OCRModule;
+    exports.OCRProcessor = OCRProcessor;
+
+}));
+//# sourceMappingURL=id-scanner-ocr.js.map