id-scanner-lib 1.3.0 → 1.3.3

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

@@ -151,6 +151,7 @@ function _mergeNamespaces(e,t){return t.forEach((function(t){t&&"string"!=typeof
  * @file 图像处理工具类
  * @description 提供图像预处理功能，用于提高OCR识别率
  * @module ImageProcessor
+ * @version 1.3.2
  */
 /**
  * 图像处理工具类
@@ -550,6 +551,278 @@ class ImageProcessor {
         // 获取新的ImageData
         return ctx.getImageData(0, 0, newWidth, newHeight);
     }
+    /**
+     * 边缘检测算法，用于识别图像中的边缘
+     * 基于Sobel算子实现
+     *
+     * @param imageData 原始图像数据，应已转为灰度图
+     * @param threshold 边缘阈值，默认为30
+     * @returns 检测到边缘的图像数据
+     */
+    static detectEdges(imageData, threshold = 30) {
+        // 确保输入图像是灰度图
+        const grayscaleImage = this.toGrayscale(new ImageData(new Uint8ClampedArray(imageData.data), imageData.width, imageData.height));
+        const width = grayscaleImage.width;
+        const height = grayscaleImage.height;
+        const inputData = grayscaleImage.data;
+        const outputData = new Uint8ClampedArray(inputData.length);
+        // Sobel算子 - 水平和垂直方向
+        const sobelX = [-1, 0, 1, -2, 0, 2, -1, 0, 1];
+        const sobelY = [-1, -2, -1, 0, 0, 0, 1, 2, 1];
+        // 对每个像素应用Sobel算子
+        for (let y = 1; y < height - 1; y++) {
+            for (let x = 1; x < width - 1; x++) {
+                let gx = 0;
+                let gy = 0;
+                // 应用卷积
+                for (let ky = -1; ky <= 1; ky++) {
+                    for (let kx = -1; kx <= 1; kx++) {
+                        const pixelPos = ((y + ky) * width + (x + kx)) * 4;
+                        const pixelVal = inputData[pixelPos]; // 灰度值
+                        const kernelIdx = (ky + 1) * 3 + (kx + 1);
+                        gx += pixelVal * sobelX[kernelIdx];
+                        gy += pixelVal * sobelY[kernelIdx];
+                    }
+                }
+                // 计算梯度强度
+                let magnitude = Math.sqrt(gx * gx + gy * gy);
+                // 应用阈值
+                magnitude = magnitude > threshold ? 255 : 0;
+                // 设置输出像素
+                const pos = (y * width + x) * 4;
+                outputData[pos] = outputData[pos + 1] = outputData[pos + 2] = magnitude;
+                outputData[pos + 3] = 255; // 透明度保持完全不透明
+            }
+        }
+        // 处理边缘像素
+        for (let i = 0; i < width * 4; i++) {
+            // 顶部和底部行
+            outputData[i] = 0;
+            outputData[(height - 1) * width * 4 + i] = 0;
+        }
+        for (let i = 0; i < height; i++) {
+            // 左右两侧列
+            const leftPos = i * width * 4;
+            const rightPos = (i * width + width - 1) * 4;
+            for (let j = 0; j < 4; j++) {
+                outputData[leftPos + j] = 0;
+                outputData[rightPos + j] = 0;
+            }
+        }
+        return new ImageData(outputData, width, height);
+    }
+    /**
+     * 卡尼-德里奇边缘检测
+     * 相比Sobel更精确的边缘检测算法
+     *
+     * @param imageData 灰度图像数据
+     * @param lowThreshold 低阈值
+     * @param highThreshold 高阈值
+     * @returns 边缘检测结果
+     */
+    static cannyEdgeDetection(imageData, lowThreshold = 20, highThreshold = 50) {
+        const grayscaleImage = this.toGrayscale(new ImageData(new Uint8ClampedArray(imageData.data), imageData.width, imageData.height));
+        // 1. 高斯模糊
+        const blurredImage = this.gaussianBlur(grayscaleImage, 1.5);
+        // 2. 使用Sobel算子计算梯度
+        const { gradientMagnitude, gradientDirection } = this.computeGradients(blurredImage);
+        // 3. 非极大值抛弃
+        const nonMaxSuppressed = this.nonMaxSuppression(gradientMagnitude, gradientDirection, blurredImage.width, blurredImage.height);
+        // 4. 双阈值处理
+        const thresholdResult = this.hysteresisThresholding(nonMaxSuppressed, blurredImage.width, blurredImage.height, lowThreshold, highThreshold);
+        // 创建输出图像
+        const outputData = new Uint8ClampedArray(imageData.data.length);
+        // 将结果转换为ImageData
+        for (let i = 0; i < thresholdResult.length; i++) {
+            const pos = i * 4;
+            const value = thresholdResult[i] ? 255 : 0;
+            outputData[pos] = outputData[pos + 1] = outputData[pos + 2] = value;
+            outputData[pos + 3] = 255;
+        }
+        return new ImageData(outputData, blurredImage.width, blurredImage.height);
+    }
+    /**
+     * 高斯模糊
+     */
+    static gaussianBlur(imageData, sigma = 1.5) {
+        const width = imageData.width;
+        const height = imageData.height;
+        const inputData = imageData.data;
+        const outputData = new Uint8ClampedArray(inputData.length);
+        // 生成高斯核
+        const kernelSize = Math.max(3, Math.floor(sigma * 3) * 2 + 1);
+        const halfKernel = Math.floor(kernelSize / 2);
+        const kernel = this.generateGaussianKernel(kernelSize, sigma);
+        // 应用高斯核
+        for (let y = 0; y < height; y++) {
+            for (let x = 0; x < width; x++) {
+                let sum = 0;
+                let weightSum = 0;
+                for (let ky = -halfKernel; ky <= halfKernel; ky++) {
+                    for (let kx = -halfKernel; kx <= halfKernel; kx++) {
+                        const pixelY = Math.min(Math.max(y + ky, 0), height - 1);
+                        const pixelX = Math.min(Math.max(x + kx, 0), width - 1);
+                        const pixelPos = (pixelY * width + pixelX) * 4;
+                        const kernelY = ky + halfKernel;
+                        const kernelX = kx + halfKernel;
+                        const weight = kernel[kernelY * kernelSize + kernelX];
+                        sum += inputData[pixelPos] * weight;
+                        weightSum += weight;
+                    }
+                }
+                const pos = (y * width + x) * 4;
+                const value = Math.round(sum / weightSum);
+                outputData[pos] = outputData[pos + 1] = outputData[pos + 2] = value;
+                outputData[pos + 3] = 255;
+            }
+        }
+        return new ImageData(outputData, width, height);
+    }
+    /**
+     * 生成高斯核
+     */
+    static generateGaussianKernel(size, sigma) {
+        const kernel = new Array(size * size);
+        const center = Math.floor(size / 2);
+        let sum = 0;
+        for (let y = 0; y < size; y++) {
+            for (let x = 0; x < size; x++) {
+                const distance = Math.sqrt((x - center) ** 2 + (y - center) ** 2);
+                const value = Math.exp(-(distance ** 2) / (2 * sigma ** 2));
+                kernel[y * size + x] = value;
+                sum += value;
+            }
+        }
+        // 归一化
+        for (let i = 0; i < kernel.length; i++) {
+            kernel[i] /= sum;
+        }
+        return kernel;
+    }
+    /**
+     * 计算梯度强度和方向
+     */
+    static computeGradients(imageData) {
+        const width = imageData.width;
+        const height = imageData.height;
+        const inputData = imageData.data;
+        const gradientMagnitude = new Array(width * height);
+        const gradientDirection = new Array(width * height);
+        // Sobel算子
+        const sobelX = [-1, 0, 1, -2, 0, 2, -1, 0, 1];
+        const sobelY = [-1, -2, -1, 0, 0, 0, 1, 2, 1];
+        for (let y = 1; y < height - 1; y++) {
+            for (let x = 1; x < width - 1; x++) {
+                let gx = 0;
+                let gy = 0;
+                for (let ky = -1; ky <= 1; ky++) {
+                    for (let kx = -1; kx <= 1; kx++) {
+                        const pixelPos = ((y + ky) * width + (x + kx)) * 4;
+                        const pixelVal = inputData[pixelPos];
+                        const kernelIdx = (ky + 1) * 3 + (kx + 1);
+                        gx += pixelVal * sobelX[kernelIdx];
+                        gy += pixelVal * sobelY[kernelIdx];
+                    }
+                }
+                const idx = y * width + x;
+                gradientMagnitude[idx] = Math.sqrt(gx * gx + gy * gy);
+                gradientDirection[idx] = Math.atan2(gy, gx);
+            }
+        }
+        // 处理边界
+        for (let y = 0; y < height; y++) {
+            for (let x = 0; x < width; x++) {
+                if (y === 0 || y === height - 1 || x === 0 || x === width - 1) {
+                    const idx = y * width + x;
+                    gradientMagnitude[idx] = 0;
+                    gradientDirection[idx] = 0;
+                }
+            }
+        }
+        return { gradientMagnitude, gradientDirection };
+    }
+    /**
+     * 非极大值抛弃
+     */
+    static nonMaxSuppression(gradientMagnitude, gradientDirection, width, height) {
+        const result = new Array(width * height).fill(0);
+        for (let y = 1; y < height - 1; y++) {
+            for (let x = 1; x < width - 1; x++) {
+                const idx = y * width + x;
+                const magnitude = gradientMagnitude[idx];
+                const direction = gradientDirection[idx];
+                // 将方向转化为角度
+                const degrees = (direction * 180 / Math.PI + 180) % 180;
+                // 获取相邻像素索引
+                let neighbor1Idx, neighbor2Idx;
+                // 将方向量化为四个方向: 0°, 45°, 90°, 135°
+                if ((degrees >= 0 && degrees < 22.5) || (degrees >= 157.5 && degrees <= 180)) {
+                    // 水平方向
+                    neighbor1Idx = idx - 1;
+                    neighbor2Idx = idx + 1;
+                }
+                else if (degrees >= 22.5 && degrees < 67.5) {
+                    // 45度方向
+                    neighbor1Idx = (y - 1) * width + (x + 1);
+                    neighbor2Idx = (y + 1) * width + (x - 1);
+                }
+                else if (degrees >= 67.5 && degrees < 112.5) {
+                    // 垂直方向
+                    neighbor1Idx = (y - 1) * width + x;
+                    neighbor2Idx = (y + 1) * width + x;
+                }
+                else {
+                    // 135度方向
+                    neighbor1Idx = (y - 1) * width + (x - 1);
+                    neighbor2Idx = (y + 1) * width + (x + 1);
+                }
+                // 检查当前像素是否是最大值
+                if (magnitude >= gradientMagnitude[neighbor1Idx] &&
+                    magnitude >= gradientMagnitude[neighbor2Idx]) {
+                    result[idx] = magnitude;
+                }
+            }
+        }
+        return result;
+    }
+    /**
+     * 双阈值处理
+     */
+    static hysteresisThresholding(nonMaxSuppressed, width, height, lowThreshold, highThreshold) {
+        const result = new Array(width * height).fill(false);
+        const visited = new Array(width * height).fill(false);
+        const stack = [];
+        // 标记强边缘点
+        for (let i = 0; i < nonMaxSuppressed.length; i++) {
+            if (nonMaxSuppressed[i] >= highThreshold) {
+                result[i] = true;
+                stack.push(i);
+                visited[i] = true;
+            }
+        }
+        // 使用深度优先搜索连接弱边缘
+        const dx = [-1, 0, 1, -1, 1, -1, 0, 1];
+        const dy = [-1, -1, -1, 0, 0, 1, 1, 1];
+        while (stack.length > 0) {
+            const currentIdx = stack.pop();
+            const currentX = currentIdx % width;
+            const currentY = Math.floor(currentIdx / width);
+            // 检查88个相邻方向
+            for (let i = 0; i < 8; i++) {
+                const newX = currentX + dx[i];
+                const newY = currentY + dy[i];
+                if (newX >= 0 && newX < width && newY >= 0 && newY < height) {
+                    const newIdx = newY * width + newX;
+                    if (!visited[newIdx] && nonMaxSuppressed[newIdx] >= lowThreshold) {
+                        result[newIdx] = true;
+                        stack.push(newIdx);
+                        visited[newIdx] = true;
+                    }
+                }
+            }
+        }
+        return result;
+    }
 }
 
 /**
@@ -715,6 +988,7 @@ function calculateImageFingerprint(imageData, size = 8) {
  * @file 身份证检测模块
  * @description 提供自动检测和定位图像中的身份证功能
  * @module IDCardDetector
+ * @version 1.3.2
  */
 /**
  * 身份证检测器类
@@ -922,25 +1196,24 @@ class IDCardDetector {
      */
     async detectIDCard(imageData) {
         // 1. 图像预处理
-        ImageProcessor.toGrayscale(imageData);
-        // 2. 检测矩形和边缘（简化版实现）
-        // 注意：实际应用中应使用OpenCV.js或其他计算机视觉库进行更精确的检测
-        // 此处仅作为概念性实现，使用基本矩形检测逻辑
-        // 模拟检测过程，随机判断是否找到身份证
-        // 在实际应用中，此处应当实现实际的计算机视觉算法
+        const grayscale = ImageProcessor.toGrayscale(imageData);
+        // 2. 使用Sobel边缘检测算法检测边缘
+        const edgeData = ImageProcessor.detectEdges(grayscale);
+        // 3. 检测矩形和边缘
+        // 使用基于边缘的矩形检测
+        const rectangles = this.detectRectangles(edgeData);
+        // 4. 评估检测结果 - 检查是否找到了合适的矩形
+        const idCardRect = this.findIdCardRectangle(rectangles, imageData.width, imageData.height);
         const detectionResult = {
-            success: Math.random() > 0.3, // 70%的概率成功检测到
-            message: "身份证检测完成",
+            success: idCardRect !== null,
+            message: idCardRect ? "身份证检测成功" : "未检测到身份证",
         };
-        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);
+        if (detectionResult.success && idCardRect) {
+            // 使用实际检测到的身份证区域
+            const rectWidth = idCardRect.width;
+            const rectHeight = idCardRect.height;
+            const rectX = idCardRect.x;
+            const rectY = idCardRect.y;
             // 添加四个角点
             detectionResult.corners = [
                 { x: rectX, y: rectY },
@@ -965,8 +1238,8 @@ class IDCardDetector {
                 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;
+            // 设置置信度 - 基于边缘强度和矩形形状评分
+            detectionResult.confidence = this.calculateConfidence(idCardRect, edgeData);
         }
         return detectionResult;
     }
@@ -985,7 +1258,123 @@ class IDCardDetector {
         this.camera.release();
         this.resultCache.clear();
     }
+    /**
+     * 从边缘图像中检测矩形
+     * @param edgeData 边缘检测后的图像数据
+     * @returns 检测到的矩形数组
+     */
+    detectRectangles(edgeData) {
+        const width = edgeData.width;
+        const height = edgeData.height;
+        const minSize = Math.min(width, height) * 0.2; // 最小矩形尺寸
+        const rectangles = [];
+        // 使用积分图像加速边缘密度计算
+        const integralImg = new Uint32Array(width * height);
+        // 计算积分图像
+        for (let y = 0; y < height; y++) {
+            for (let x = 0; x < width; x++) {
+                const idx = y * width + x;
+                const pixel = (edgeData.data[idx * 4] > 128) ? 1 : 0; // 边缘为白色
+                // 计算积分图
+                const above = y > 0 ? integralImg[(y - 1) * width + x] : 0;
+                const left = x > 0 ? integralImg[y * width + (x - 1)] : 0;
+                const diagonal = (x > 0 && y > 0) ? integralImg[(y - 1) * width + (x - 1)] : 0;
+                integralImg[idx] = pixel + above + left - diagonal;
+            }
+        }
+        // 滑动窗口检测矩形
+        for (let h = minSize; h < height * 0.9; h += Math.max(2, Math.floor(h * 0.05))) {
+            // 计算当前高度下,按照标准身份证比例的宽度
+            const w = Math.round(h * IDCardDetector.ID_CARD_ASPECT_RATIO);
+            if (w > width * 0.9)
+                continue;
+            for (let y = 0; y < height - h; y += Math.max(2, Math.floor(h * 0.1))) {
+                for (let x = 0; x < width - w; x += Math.max(2, Math.floor(w * 0.1))) {
+                    // 计算矩形区域内的边缘密度
+                    const edgeCount = this.calculateRectSum(integralImg, x, y, w, h, width);
+                    const avgEdgeDensity = edgeCount / (w * h);
+                    // 计算矩形边界的边缘密度
+                    const perimeterEdgeCount = this.calculateRectPerimeter(integralImg, x, y, w, h, width);
+                    const perimeterLength = 2 * (w + h);
+                    const perimeterDensity = perimeterEdgeCount / perimeterLength;
+                    // 矩形得分 - 边界边缘密度高且内部适中
+                    const rectScore = perimeterDensity * 0.7 + (0.3 - Math.abs(0.15 - avgEdgeDensity)) * 0.3;
+                    if (rectScore > 0.4) { // 阈值可根据实际项目调整
+                        rectangles.push({
+                            x,
+                            y,
+                            width: w,
+                            height: h,
+                            confidence: rectScore
+                        });
+                    }
+                }
+            }
+        }
+        // 按得分排序
+        return rectangles.sort((a, b) => b.confidence - a.confidence);
+    }
+    /**
+     * 使用积分图计算矩形区域内的总和
+     */
+    calculateRectSum(integral, x, y, w, h, stride) {
+        const x2 = Math.min(x + w - 1, stride - 1);
+        const y2 = Math.min(y + h - 1, integral.length / stride - 1);
+        const topLeft = (x > 0 && y > 0) ? integral[(y - 1) * stride + (x - 1)] : 0;
+        const topRight = y > 0 ? integral[(y - 1) * stride + x2] : 0;
+        const bottomLeft = x > 0 ? integral[y2 * stride + (x - 1)] : 0;
+        const bottomRight = integral[y2 * stride + x2];
+        return bottomRight - topRight - bottomLeft + topLeft;
+    }
+    /**
+     * 计算矩形周长上的边缘点数量
+     */
+    calculateRectPerimeter(integral, x, y, w, h, stride) {
+        // 上边缘
+        const topEdgeSum = this.calculateRectSum(integral, x, y, w, 1, stride);
+        // 下边缘
+        const bottomEdgeSum = this.calculateRectSum(integral, x, y + h - 1, w, 1, stride);
+        // 左边缘
+        const leftEdgeSum = this.calculateRectSum(integral, x, y, 1, h, stride);
+        // 右边缘
+        const rightEdgeSum = this.calculateRectSum(integral, x + w - 1, y, 1, h, stride);
+        return topEdgeSum + bottomEdgeSum + leftEdgeSum + rightEdgeSum;
+    }
+    /**
+     * 从检测到的矩形中找出最可能是身份证的矩形
+     */
+    findIdCardRectangle(rectangles, imageWidth, imageHeight) {
+        if (rectangles.length === 0)
+            return null;
+        // 筛选符合身份证宽高比的矩形
+        const filteredRects = rectangles.filter(rect => {
+            const aspectRatio = rect.width / rect.height;
+            return Math.abs(aspectRatio - IDCardDetector.ID_CARD_ASPECT_RATIO) < 0.2; // 允许20%的误差
+        });
+        if (filteredRects.length === 0)
+            return null;
+        // 返回得分最高的矩形
+        return filteredRects[0];
+    }
+    /**
+     * 计算身份证检测的置信度
+     */
+    calculateConfidence(rect, edgeData) {
+        if (!rect)
+            return 0;
+        // 基本得分来自矩形检测
+        let score = rect.confidence;
+        // 额外因素：矩形大小相对于图像
+        const relativeSize = (rect.width * rect.height) / (edgeData.width * edgeData.height);
+        if (relativeSize > 0.1 && relativeSize < 0.7) {
+            score += 0.1; // 身份证通常占据图像的合理比例
+        }
+        // 范围限制在0-1之间
+        return Math.min(Math.max(score, 0), 1);
+    }
 }
+// 身份证标准宽高比（近似黄金比例）
+IDCardDetector.ID_CARD_ASPECT_RATIO = 1.58; // 标准身份证宽高比
 
 /**
  * @file Web Worker辅助工具类
@@ -1081,16 +1470,16 @@ async function processOCRInWorker(input) {
     // 加载Tesseract.js (Worker 环境下动态导入)
     const { createWorker } = await import('tesseract.js');
     // 创建OCR Worker
-    const worker = await createWorker(input.tessWorkerOptions || {
-        logger: (m) => console.log(m)
-    }); // 添加类型断言，避免TypeScript错误
+    const worker = (await createWorker(input.tessWorkerOptions || {
+        logger: (m) => console.log(m),
+    })); // 添加类型断言，避免TypeScript错误
     try {
         // 初始化OCR引擎
         await worker.load();
-        await worker.loadLanguage('chi_sim');
-        await worker.initialize('chi_sim');
+        await worker.loadLanguage("chi_sim");
+        await worker.initialize("chi_sim");
         await worker.setParameters({
-            tessedit_char_whitelist: '0123456789X-年月日一二三四五六七八九十零壹贰叁肆伍陆柒捌玖拾ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz民族汉族满族回族维吾尔族藏族苗族彝族壮族朝鲜族侗族瑶族白族土家族哈尼族哈萨克族傣族黎族傈僳族佤族高山族拉祜族水族东乡族钠西族景颇族柯尔克孜族士族达斡尔族仫佬族羌族布朗族撒拉族毛南族仡佬族锡伯族阿昌族普米族塔吉克族怒族乌孜别克族俄罗斯族鄂温克族德昂族保安族裕固族京族塔塔尔族独龙族鄂伦春族赫哲族门巴族珞巴族基诺族男女性别住址出生公民身份号码签发机关有效期'
+            tessedit_char_whitelist: "0123456789X-年月日一二三四五六七八九十零壹贰叁肆伍陆柒捌玖拾ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz民族汉族满族回族维吾尔族藏族苗族彝族壮族朝鲜族侗族瑶族白族土家族哈尼族哈萨克族傣族黎族傈僳族佤族高山族拉祜族水族东乡族钠西族景颇族柯尔克孜族士族达斡尔族仫佬族羌族布朗族撒拉族毛南族仡佬族锡伯族阿昌族普米族塔吉克族怒族乌孜别克族俄罗斯族鄂温克族德昂族保安族裕固族京族塔塔尔族独龙族鄂伦春族赫哲族门巴族珞巴族基诺族男女性别住址出生公民身份号码签发机关有效期",
         });
         // 识别图像
         const { data } = await worker.recognize(input.imageBase64);
@@ -1103,7 +1492,7 @@ async function processOCRInWorker(input) {
         // 返回处理结果
         return {
             idCardInfo,
-            processingTime
+            processingTime,
         };
     }
     catch (error) {
@@ -1124,7 +1513,7 @@ async function processOCRInWorker(input) {
 function parseIDCardText(text) {
     const info = {};
     // 拆分为行
-    const lines = text.split('\n').filter(line => line.trim());
+    const lines = text.split("\n").filter((line) => line.trim());
     // 解析身份证号码（最容易识别的部分）
     const idNumberRegex = /(\d{17}[\dX])/;
     const idNumberMatch = text.match(idNumberRegex);
@@ -1133,8 +1522,9 @@ function parseIDCardText(text) {
     }
     // 解析姓名
     for (const line of lines) {
-        if (line.includes('姓名') || line.length < 10 && line.length > 1 && !/\d/.test(line)) {
-            info.name = line.replace('姓名', '').trim();
+        if (line.includes("姓名") ||
+            (line.length < 10 && line.length > 1 && !/\d/.test(line))) {
+            info.name = line.replace("姓名", "").trim();
             break;
         }
     }
@@ -1144,7 +1534,9 @@ function parseIDCardText(text) {
     if (genderMatch) {
         info.gender = genderMatch[1];
         const nationalityText = genderMatch[0];
-        info.nationality = nationalityText.substring(nationalityText.indexOf(genderMatch[1]) + 1).trim();
+        info.nationality = nationalityText
+            .substring(nationalityText.indexOf(genderMatch[1]) + 1)
+            .trim();
     }
     // 解析出生日期
     const birthDateRegex = /(\d{4})年(\d{1,2})月(\d{1,2})日/;
@@ -1156,19 +1548,19 @@ function parseIDCardText(text) {
     const addressRegex = /住址([\s\S]*?)公民身份号码/;
     const addressMatch = text.match(addressRegex);
     if (addressMatch) {
-        info.address = addressMatch[1].replace(/\n/g, '').trim();
+        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();
+        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();
+        info.validPeriod = validPeriodMatch[0].replace("有效期限", "").trim();
     }
     return info;
 }
@@ -1177,6 +1569,7 @@ function parseIDCardText(text) {
  * @file OCR处理模块
  * @description 提供身份证文字识别和信息提取功能
  * @module OCRProcessor
+ * @version 1.3.2
  */
 /**
  * OCR处理器类
@@ -1338,57 +1731,184 @@ class OCRProcessor {
      * @param {string} text - OCR识别到的文本
      * @returns {IDCardInfo} 提取到的身份证信息对象
      */
+    /**
+     * 格式化日期字符串为标准格式 (YYYY-MM-DD)
+     * @param dateStr 原始日期字符串
+     * @returns 格式化后的日期字符串
+     */
+    formatDateString(dateStr) {
+        // 先尝试提取年月日
+        const dateMatch = dateStr.match(/(\d{4})[-\.\u5e74\s]*(\d{1,2})[-\.\u6708\s]*(\d{1,2})[日]*/);
+        if (dateMatch) {
+            const year = dateMatch[1];
+            const month = dateMatch[2].padStart(2, '0');
+            const day = dateMatch[3].padStart(2, '0');
+            return `${year}-${month}-${day}`;
+        }
+        // 如果是纯数字格式如 20220101
+        if (/^\d{8}$/.test(dateStr)) {
+            const year = dateStr.substring(0, 4);
+            const month = dateStr.substring(4, 6);
+            const day = dateStr.substring(6, 8);
+            return `${year}-${month}-${day}`;
+        }
+        // 如果无法格式化，返回原始字符串
+        return dateStr;
+    }
+    /**
+     * 验证身份证号是否符合规则
+     * @param idNumber 身份证号
+     * @returns 是否有效
+     */
+    validateIDNumber(idNumber) {
+        // 基本验证，校验位有效性和长度
+        if (!idNumber || idNumber.length !== 18) {
+            return false;
+        }
+        // 检查格式，前17位必须为数字，最后一位可以是数字或'X'
+        const pattern = /^\d{17}[\dX]$/;
+        if (!pattern.test(idNumber)) {
+            return false;
+        }
+        // 检查日期部分
+        parseInt(idNumber.substr(6, 4));
+        const month = parseInt(idNumber.substr(10, 2));
+        const day = parseInt(idNumber.substr(12, 2));
+        if (month < 1 || month > 12 || day < 1 || day > 31) {
+            return false;
+        }
+        // 更详细的检查可以添加校验位的验证等逻辑...
+        return true;
+    }
     parseIDCardText(text) {
         const info = {};
-        // 拆分为行
-        const lines = text.split("\n").filter((line) => line.trim());
-        // 解析身份证号码（最容易识别的部分）
+        // 预处理文本，清除多余空白
+        const processedText = text.replace(/\s+/g, " ").trim();
+        // 拆分为行，并过滤空行
+        const lines = processedText.split("\n").filter((line) => line.trim());
+        // 解析身份证号码 - 多种模式匹配
+        // 1. 普通18位身份证号模式
         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;
+        // 2. 带前缀的模式
+        const idNumberWithPrefixRegex = /公民身份号码[\s\:]*(\d{17}[\dX])/;
+        // 尝试所有模式
+        let idNumber = null;
+        const basicMatch = processedText.match(idNumberRegex);
+        const prefixMatch = processedText.match(idNumberWithPrefixRegex);
+        if (prefixMatch && prefixMatch[1]) {
+            idNumber = prefixMatch[1]; // 首选带前缀的匹配，因为最可靠
+        }
+        else if (basicMatch && basicMatch[1]) {
+            idNumber = basicMatch[1]; // 其次是常规匹配
+        }
+        if (idNumber) {
+            info.idNumber = idNumber;
+        }
+        // 解析姓名 - 使用多种策略
+        // 1. 直接匹配姓名标签近的内容
+        const nameWithLabelRegex = /姓名[\s\:]*([一-龥]{2,4})/;
+        const nameMatch = processedText.match(nameWithLabelRegex);
+        // 2. 分析行文本寻找姓名
+        if (nameMatch && nameMatch[1]) {
+            info.name = nameMatch[1].trim();
+        }
+        else {
+            // 备用方案：查找短行且内容全是汉字
+            for (const line of lines) {
+                if (line.length >= 2 && line.length <= 5 && /^[一-龥]+$/.test(line) && !/性别|民族|住址|公民|签发|有效/.test(line)) {
+                    info.name = line.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();
+        // 解析性别和民族 - 多种模式匹配
+        // 1. 标准格式匹配
+        const genderAndNationalityRegex = /性别[\s\:]*([男女])[\s ]*民族[\s\:]*([一-龥]+族)/;
+        const genderNationalityMatch = processedText.match(genderAndNationalityRegex);
+        // 2. 只匹配性别
+        const genderOnlyRegex = /性别[\s\:]*([男女])/;
+        const genderOnlyMatch = processedText.match(genderOnlyRegex);
+        // 3. 只匹配民族
+        const nationalityOnlyRegex = /民族[\s\:]*([一-龥]+族)/;
+        const nationalityOnlyMatch = processedText.match(nationalityOnlyRegex);
+        if (genderNationalityMatch) {
+            info.gender = genderNationalityMatch[1];
+            info.nationality = genderNationalityMatch[2];
+        }
+        else {
+            // 分开获取
+            if (genderOnlyMatch)
+                info.gender = genderOnlyMatch[1];
+            if (nationalityOnlyMatch)
+                info.nationality = nationalityOnlyMatch[1];
+        }
+        // 解析出生日期 - 支持多种格式
+        // 1. 标准格式：YYYY年MM月DD日
+        const birthDateRegex1 = /出生[\s\:]*(\d{4})年(\d{1,2})月(\d{1,2})[日号]/;
+        // 2. 美式日期格式：YYYY-MM-DD或YYYY/MM/DD
+        const birthDateRegex2 = /出生[\s\:]*(\d{4})[-\/\.](\d{1,2})[-\/\.](\d{1,2})/;
+        // 3. 带前缀的格式
+        const birthDateRegex3 = /出生日期[\s\:]*(\d{4})[-\/\.\u5e74](\d{1,2})[-\/\.\u6708](\d{1,2})[日号]?/;
+        let birthDateMatch = processedText.match(birthDateRegex1) ||
+            processedText.match(birthDateRegex2) ||
+            processedText.match(birthDateRegex3);
+        // 4. 从身份证号码中提取出生日期（如果上述方法失败）
+        if (!birthDateMatch && info.idNumber && info.idNumber.length === 18) {
+            const year = info.idNumber.substring(6, 10);
+            const month = info.idNumber.substring(10, 12);
+            const day = info.idNumber.substring(12, 14);
+            info.birthDate = `${year}-${month}-${day}`;
+        }
+        else if (birthDateMatch) {
+            // 确保月份和日期是两位数
+            const year = birthDateMatch[1];
+            const month = birthDateMatch[2].padStart(2, '0');
+            const day = birthDateMatch[3].padStart(2, '0');
+            info.birthDate = `${year}-${month}-${day}`;
+        }
+        // 解析地址 - 改进的正则匹配
+        // 1. 常规模式
+        const addressRegex1 = /住址[\s\:]*([\s\S]*?)(?=公民身份|出生|性别|签发)/;
+        // 2. 更宽松的模式
+        const addressRegex2 = /住址[\s\:]*([一-龥a-zA-Z0-9\s\.\-]+)/;
+        const addressMatch = processedText.match(addressRegex1) || processedText.match(addressRegex2);
+        if (addressMatch && addressMatch[1]) {
+            // 清理地址中的常见错误和多余空格
+            info.address = addressMatch[1].replace(/\s+/g, "").replace(/\n/g, "").trim();
+            // 限制地址长度并判断地址合理性
+            if (info.address.length > 70) {
+                info.address = info.address.substring(0, 70);
+            }
+            // 确保地址是合理的（不仅仅包含符号或数字）
+            if (!/[一-龥]/.test(info.address)) {
+                info.address = ""; // 如果没有中文字符，可能不是有效地址
+            }
         }
         // 解析签发机关
-        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);
+        const authorityRegex1 = /签发机关[\s\:]*([\s\S]*?)(?=有效|公民|出生|\d{8}|$)/;
+        const authorityRegex2 = /签发机关[\s\:]*([一-龥\s]+)/;
+        const authorityMatch = processedText.match(authorityRegex1) || processedText.match(authorityRegex2);
+        if (authorityMatch && authorityMatch[1]) {
+            info.issuingAuthority = authorityMatch[1].replace(/\s+/g, "").replace(/\n/g, "").trim();
+        }
+        // 解析有效期限 - 支持多种格式
+        // 1. 常规格式：YYYY.MM.DD-YYYY.MM.DD
+        const validPeriodRegex1 = /有效期限[\s\:]*(\d{4}[-\.\u5e74\s]\d{1,2}[-\.\u6708\s]\d{1,2}[日\s]*)[-\s]*(至|-)[-\s]*(\d{4}[-\.\u5e74\s]\d{1,2}[-\.\u6708\s]\d{1,2}[日]*|[永久长期]*)/;
+        // 2. 简化格式：YYYYMMDD-YYYYMMDD
+        const validPeriodRegex2 = /有效期限[\s\:]*(\d{8})[-\s]*(至|-)[-\s]*(\d{8}|[永久长期]*)/;
+        const validPeriodMatch = processedText.match(validPeriodRegex1) || processedText.match(validPeriodRegex2);
         if (validPeriodMatch) {
-            info.validPeriod = validPeriodMatch[0].replace("有效期限", "").trim();
+            // 格式化为统一的有效期限形式
+            if (validPeriodMatch[1] && validPeriodMatch[3]) {
+                const startDate = this.formatDateString(validPeriodMatch[1]);
+                const endDate = /\d/.test(validPeriodMatch[3]) ?
+                    this.formatDateString(validPeriodMatch[3]) :
+                    '长期有效';
+                info.validPeriod = `${startDate}-${endDate}`;
+            }
+            else {
+                info.validPeriod = validPeriodMatch[0].replace('有效期限', '').trim();
+            }
         }
         return info;
     }