id-scanner-lib 1.0.0 → 1.1.1

package/dist/id-scanner-ocr.esm.js

@@ -0,0 +1,914 @@
+import { createWorker } from 'tesseract.js';
+
+/**
+ * @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;
+    }
+}
+
+/**
+ * @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.camera = new Camera();
+        if (typeof options === 'function') {
+            // 兼容旧的构造函数方式
+            this.onDetected = options;
+        }
+        else if (options) {
+            // 使用新的选项对象方式
+            this.onDetected = options.onDetection;
+        }
+    }
+    /**
+     * 启动身份证检测
+     *
+     * 初始化相机并开始连续检测视频帧中的身份证
+     *
+     * @param {HTMLVideoElement} videoElement - 用于显示相机画面的video元素
+     * @returns {Promise<void>} 启动完成的Promise
+     */
+    async start(videoElement) {
+        await this.camera.initialize(videoElement);
+        this.detecting = true;
+        this.detect();
+    }
+    /**
+     * 执行一次身份证检测
+     *
+     * 内部方法，捕获当前视频帧并尝试检测其中的身份证
+     *
+     * @private
+     */
+    async detect() {
+        if (!this.detecting)
+            return;
+        const imageData = this.camera.captureFrame();
+        if (imageData) {
+            try {
+                // 简单实现，因为没有完整的OpenCV.js
+                // 实际项目中应该使用OpenCV.js做更精确的边缘检测
+                const result = await this.detectIDCard(imageData);
+                if (this.onDetected) {
+                    this.onDetected(result);
+                }
+            }
+            catch (error) {
+                console.error('身份证检测错误:', error);
+            }
+        }
+        this.detectTimer = window.setTimeout(() => this.detect(), 200);
+    }
+    /**
+     * 身份证检测核心算法
+     *
+     * 通过图像处理技术检测和提取图像中的身份证区域
+     *
+     * @private
+     * @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 } // 左下
+            ];
+            // 模拟裁剪图像（实际项目中应该做透视变换）
+            const canvas = document.createElement('canvas');
+            canvas.width = cardWidth;
+            canvas.height = cardHeight;
+            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
+                };
+            }
+        }
+        return { success: false };
+    }
+    /**
+     * 停止身份证检测
+     *
+     * 停止检测循环并释放相机资源
+     */
+    stop() {
+        this.detecting = false;
+        if (this.detectTimer) {
+            clearTimeout(this.detectTimer);
+            this.detectTimer = null;
+        }
+        this.camera.release();
+    }
+}
+
+/**
+ * @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 {
+    constructor() {
+        this.worker = null;
+    }
+    /**
+     * 初始化OCR引擎
+     *
+     * 加载Tesseract OCR引擎和中文简体语言包，并设置适合身份证识别的参数
+     *
+     * @returns {Promise<void>} 初始化完成的Promise
+     */
+    async initialize() {
+        this.worker = 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民族汉族满族回族维吾尔族藏族苗族彝族壮族朝鲜族侗族瑶族白族土家族哈尼族哈萨克族傣族黎族傈僳族佤族高山族拉祜族水族东乡族钠西族景颇族柯尔克孜族士族达斡尔族仫佬族羌族布朗族撒拉族毛南族仡佬族锡伯族阿昌族普米族塔吉克族怒族乌孜别克族俄罗斯族鄂温克族德昂族保安族裕固族京族塔塔尔族独龙族鄂伦春族赫哲族门巴族珞巴族基诺族男女性别住址出生公民身份号码签发机关有效期'
+        });
+    }
+    /**
+     * 处理身份证图像并提取信息
+     * @param imageData 要处理的身份证图像数据
+     * @returns 提取的身份证信息
+     */
+    async processIDCard(imageData) {
+        if (!this.worker) {
+            await this.initialize();
+        }
+        // 图像预处理，提高OCR识别率
+        const enhancedImage = ImageProcessor.adjustBrightnessContrast(imageData, 15, 25);
+        // 转换ImageData为Canvas
+        const canvas = ImageProcessor.imageDataToCanvas(enhancedImage);
+        // OCR识别
+        try {
+            const { data } = await this.worker.recognize(canvas);
+            // 解析身份证信息
+            return this.parseIDCardText(data.text);
+        }
+        catch (error) {
+            console.error('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;
+    }
+    /**
+     * 终止OCR引擎并释放资源
+     *
+     * @returns {Promise<void>} 终止完成的Promise
+     */
+    async terminate() {
+        if (this.worker) {
+            await this.worker.terminate();
+            this.worker = null;
+        }
+    }
+}
+
+/**
+ * @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();
+    }
+}
+
+export { DataExtractor, IDCardDetector, OCRModule, OCRProcessor };
+//# sourceMappingURL=id-scanner-ocr.esm.js.map