id-scanner-lib 1.3.2 → 1.3.3

package/dist/id-scanner.js

@@ -284,6 +284,7 @@
      * @file 图像处理工具类
      * @description 提供图像预处理功能，用于提高OCR识别率
      * @module ImageProcessor
+     * @version 1.3.2
      */
     /**
      * 图像处理工具类
@@ -683,6 +684,278 @@
             // 获取新的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;
+        }
     }
 
     /**
@@ -1046,6 +1319,7 @@
      * @file 身份证检测模块
      * @description 提供自动检测和定位图像中的身份证功能
      * @module IDCardDetector
+     * @version 1.3.2
      */
     /**
      * 身份证检测器类
@@ -1253,25 +1527,24 @@
          */
         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 },
@@ -1296,8 +1569,8 @@
                     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;
         }
@@ -1316,7 +1589,123 @@
             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辅助工具类
@@ -1511,6 +1900,7 @@
      * @file OCR处理模块
      * @description 提供身份证文字识别和信息提取功能
      * @module OCRProcessor
+     * @version 1.3.2
      */
     /**
      * OCR处理器类
@@ -1672,57 +2062,184 @@
          * @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;
         }
@@ -1991,6 +2508,7 @@
      * @file 身份证防伪检测模块
      * @description 提供身份证防伪特征识别功能，区分真假身份证
      * @module AntiFakeDetector
+     * @version 1.3.2
      */
     /**
      * 身份证防伪特征检测器
@@ -2122,23 +2640,166 @@
          * @private
          */
         async detectUVInkFeatures(imageData) {
-            // 提取蓝色通道增强UV油墨可见度
-            const canvas = document.createElement("canvas");
-            canvas.width = imageData.width;
-            canvas.height = imageData.height;
-            const ctx = canvas.getContext("2d");
-            if (!ctx) {
-                return ["荧光油墨", false, 0];
-            }
-            ctx.putImageData(imageData, 0, 0);
-            // 分析蓝色通道中的特定模式
-            // 实际实现中应使用更复杂的算法提取UV特征
-            // 这里使用模拟实现
-            // 模拟检测: 70%的概率检测到，置信度0.65-0.95
-            const detected = Math.random() > 0.3;
-            const confidence = detected ? 0.65 + Math.random() * 0.3 : 0;
+            // 在真实身份证上，荧光油墨会在特定反光条件下呈现特定颜色特征
+            // 在普通可见光下，我们分析蓝色和紫外色通道分布特征
+            // 1. 提取蓝色通道并增强对比度
+            const blueChannel = this.extractColorChannel(imageData, 'blue');
+            // 2. 分析蓝色通道的分布特征
+            const { peaks, variance } = this.analyzeChannelDistribution(blueChannel);
+            // 3. 分析特定区域的颜色模式
+            const patternScore = this.detectUVColorPattern(imageData);
+            // 4. 计算综合得分
+            // 特征分析：荧光油墨在蓝色通道通常有显著峰值，且分布更聚集
+            let score = 0;
+            // 过多的峰值表明可能是真实身份证上的荧光特征
+            if (peaks > 3 && peaks < 10) {
+                score += 0.4;
+            }
+            // 方差越大，表示颜色对比度越高，更可能有荧光特征
+            if (variance > 1000) {
+                score += 0.3;
+            }
+            // 颜色模式得分
+            score += patternScore * 0.3;
+            // 重要区域分析
+            // 身份证头像区域通常不应具有荧光特征
+            const hasPortraitAreaFeatures = this.analyzePortraitArea(imageData);
+            if (hasPortraitAreaFeatures) {
+                // 头像区域不应该有荧光特征，如果有可能是伪造的
+                score -= 0.2;
+            }
+            // 求出最终分数并限制在[0,1]范围内
+            const confidence = Math.max(0, Math.min(1, score));
+            const detected = confidence > 0.55;
             return ["荧光油墨", detected, confidence];
         }
+        /**
+         * 从图像数据中提取指定颜色通道
+         * @param imageData 原始图像数据
+         * @param channel 通道名称（red, green, blue）
+         */
+        extractColorChannel(imageData, channel) {
+            const { data, width, height } = imageData;
+            const channelOffset = channel === 'red' ? 0 : channel === 'green' ? 1 : 2;
+            const channelData = new Uint8ClampedArray(width * height);
+            for (let i = 0; i < data.length; i += 4) {
+                const pixelIndex = i / 4;
+                channelData[pixelIndex] = data[i + channelOffset];
+            }
+            return channelData;
+        }
+        /**
+         * 分析颜色通道分布特征
+         * @param channelData 颜色通道数据
+         */
+        analyzeChannelDistribution(channelData) {
+            // 计算直方图
+            const histogram = new Array(256).fill(0);
+            for (let i = 0; i < channelData.length; i++) {
+                histogram[channelData[i]]++;
+            }
+            // 平滑直方图以减少噪声
+            const smoothedHistogram = this.smoothHistogram(histogram, 3);
+            // 计算峰值数量
+            let peaks = 0;
+            for (let i = 1; i < 255; i++) {
+                if (smoothedHistogram[i] > smoothedHistogram[i - 1] &&
+                    smoothedHistogram[i] > smoothedHistogram[i + 1] &&
+                    smoothedHistogram[i] > channelData.length * 0.01) { // 只计算显著峰值
+                    peaks++;
+                }
+            }
+            // 计算方差
+            let mean = 0;
+            for (let i = 0; i < channelData.length; i++) {
+                mean += channelData[i];
+            }
+            mean /= channelData.length;
+            let variance = 0;
+            for (let i = 0; i < channelData.length; i++) {
+                variance += Math.pow(channelData[i] - mean, 2);
+            }
+            variance /= channelData.length;
+            return { peaks, variance };
+        }
+        /**
+         * 平滑直方图以减少噪声
+         */
+        smoothHistogram(histogram, windowSize) {
+            const result = new Array(histogram.length).fill(0);
+            const halfWindow = Math.floor(windowSize / 2);
+            for (let i = 0; i < histogram.length; i++) {
+                let sum = 0;
+                let count = 0;
+                for (let j = Math.max(0, i - halfWindow); j <= Math.min(histogram.length - 1, i + halfWindow); j++) {
+                    sum += histogram[j];
+                    count++;
+                }
+                result[i] = sum / count;
+            }
+            return result;
+        }
+        /**
+         * 检测图像中的荧光颜色模式
+         */
+        detectUVColorPattern(imageData) {
+            // 分析特定组合颜色的出现频率，荧光油墨在可见光下也具有特定的颜色特征
+            const { data, width, height } = imageData;
+            let uvColorCount = 0;
+            // 寻找可能为荧光油墨的特定颜色模式
+            // 这些颜色通常是特定的蓝紫色调和高对比度
+            for (let i = 0; i < data.length; i += 4) {
+                const r = data[i];
+                const g = data[i + 1];
+                const b = data[i + 2];
+                // 检查是否是荧光油墨特有的颜色范围
+                // 这里使用简化的追踪条件，实际应用中应使用更复杂的颜色模型
+                if (b > 1.5 * r && b > 1.3 * g && b > 100) {
+                    uvColorCount++;
+                }
+            }
+            // 计算荧光颜色像素占比
+            const totalPixels = width * height;
+            const uvColorRatio = uvColorCount / totalPixels;
+            // 对于真实身份证，荧光颜色的占比应该在一定范围内
+            // 如果占比过高或过低，可能是伪造的
+            const idealRatio = 0.05; // 理想占比
+            const deviation = Math.abs(uvColorRatio - idealRatio) / idealRatio;
+            // 将差异转换为0-1的置信度分数
+            return Math.max(0, 1 - Math.min(1, deviation * 2));
+        }
+        /**
+         * 分析头像区域是否存在荧光特征
+         * 这个方法用于检测伪造的身份证，因为头像区域不应该有荧光特征
+         */
+        analyzePortraitArea(imageData) {
+            // 假设头像区域大约占据图片右上方四分之一的区域
+            const { width, height, data } = imageData;
+            const portraitX = Math.floor(width * 0.6);
+            const portraitY = Math.floor(height * 0.2);
+            const portraitWidth = Math.floor(width * 0.3);
+            const portraitHeight = Math.floor(height * 0.3);
+            let uvFeatureCount = 0;
+            let totalPixels = 0;
+            // 检查头像区域的荧光特征
+            for (let y = portraitY; y < portraitY + portraitHeight; y++) {
+                for (let x = portraitX; x < portraitX + portraitWidth; x++) {
+                    if (x >= 0 && x < width && y >= 0 && y < height) {
+                        const i = (y * width + x) * 4;
+                        const r = data[i];
+                        const g = data[i + 1];
+                        const b = data[i + 2];
+                        // 使用与上面相同的荧光颜色检测标准
+                        if (b > 1.5 * r && b > 1.3 * g && b > 100) {
+                            uvFeatureCount++;
+                        }
+                        totalPixels++;
+                    }
+                }
+            }
+            // 如果头像区域的荧光特征占比过高，可能是伪造的
+            return totalPixels > 0 && (uvFeatureCount / totalPixels) > 0.1;
+        }
         /**
          * 检测微缩文字
          *
@@ -2147,16 +2808,176 @@
          * @private
          */
         async detectMicroText(imageData) {
-            // 应用边缘检测突出微缩文字
-            ImageProcessor.toGrayscale(new ImageData(new Uint8ClampedArray(imageData.data), imageData.width, imageData.height));
-            // 寻找特定的微缩文字模式
-            // 实际实现中应使用计算机视觉算法寻找微小规则文字模式
-            // 这里使用模拟实现
-            // 模拟检测: 80%的概率检测到，置信度0.7-0.95
-            const detected = Math.random() > 0.2;
-            const confidence = detected ? 0.7 + Math.random() * 0.25 : 0;
+            // 微缩文字检测 - 身份证上的微缩文字是重要的防伪特征
+            // 这些文字很小，但会呈现规则的线条和高频组件
+            // 1. 转换图像为灰度图
+            const grayscale = ImageProcessor.toGrayscale(new ImageData(new Uint8ClampedArray(imageData.data), imageData.width, imageData.height));
+            // 2. 执行边缘检测突出微缩文字
+            const edgeData = ImageProcessor.detectEdges(grayscale, 40); // 强化的边缘检测
+            // 3. 分析频率特征 - 微缩文字呈现高频的边缘过渡
+            const frequencyFeatures = this.analyzeFrequencyFeatures(edgeData);
+            // 4. 检测微缩文字的具体区域
+            const microTextRegions = this.detectMicroTextRegions(edgeData);
+            // 5. 综合分析结果计算置信度
+            let score = 0;
+            // 频率特征分数
+            score += frequencyFeatures.score * 0.6;
+            // 区域特征分数
+            if (microTextRegions.count > 0) {
+                // 过多的区域也可能表示噪声，因此有一个最佳范围
+                const normalizedCount = Math.min(microTextRegions.count, 5) / 5;
+                score += normalizedCount * 0.4;
+            }
+            // 对置信度进行最终调整
+            const confidence = Math.max(0, Math.min(1, score));
+            const detected = confidence > 0.5;
             return ["微缩文字", detected, confidence];
         }
+        /**
+         * 分析边缘图像的频率特征
+         * 微缩文字呈现高频的边缘过渡
+         */
+        analyzeFrequencyFeatures(edgeData) {
+            const { data, width, height } = edgeData;
+            // 计算高频边缘分布
+            // 统计边缘过渡的变化频率
+            let highFreqTransitions = 0;
+            // 检测行方向的边缘变化
+            for (let y = 0; y < height; y++) {
+                let prevEdge = false;
+                let transitions = 0;
+                for (let x = 0; x < width; x++) {
+                    const i = (y * width + x) * 4;
+                    const isEdge = data[i] > 200;
+                    if (isEdge !== prevEdge) {
+                        transitions++;
+                        prevEdge = isEdge;
+                    }
+                }
+                // 每行的过渡频率
+                if (transitions > width * 0.1) { // 高频过渡行
+                    highFreqTransitions++;
+                }
+            }
+            // 计算列方向的边缘变化
+            let colHighFreqTransitions = 0;
+            for (let x = 0; x < width; x++) {
+                let prevEdge = false;
+                let transitions = 0;
+                for (let y = 0; y < height; y++) {
+                    const i = (y * width + x) * 4;
+                    const isEdge = data[i] > 200;
+                    if (isEdge !== prevEdge) {
+                        transitions++;
+                        prevEdge = isEdge;
+                    }
+                }
+                // 每列的过渡频率
+                if (transitions > height * 0.1) { // 高频过渡列
+                    colHighFreqTransitions++;
+                }
+            }
+            // 综合计算高频特征比例
+            const rowHighFreqRatio = highFreqTransitions / height;
+            const colHighFreqRatio = colHighFreqTransitions / width;
+            const highFreqRatio = (rowHighFreqRatio + colHighFreqRatio) / 2;
+            // 计算最终分数
+            // 真实的微缩文字应该有适度的高频特征，而不是极端的高或低
+            const idealRatio = 0.15; // 理想的高频比例
+            const deviationFactor = Math.abs(highFreqRatio - idealRatio) / idealRatio;
+            const score = Math.max(0, 1 - Math.min(1, deviationFactor * 3));
+            return { score, highFreqRatio };
+        }
+        /**
+         * 检测微缩文字区域
+         * 微缩文字通常呈现呈现规则的组合排列
+         */
+        detectMicroTextRegions(edgeData) {
+            const { data, width, height } = edgeData;
+            const visitedMap = new Array(width * height).fill(false);
+            const regions = [];
+            // 使用满足条件的连通区域寻找微缩文字区域
+            for (let y = 0; y < height; y++) {
+                for (let x = 0; x < width; x++) {
+                    const idx = y * width + x;
+                    const i = idx * 4;
+                    // 如果是边缘像素且未访问过
+                    if (data[i] > 200 && !visitedMap[idx]) {
+                        // 使用深度优先搜索找到连通的边缘区域
+                        const regionPoints = this.floodFillEdge(edgeData, x, y, visitedMap);
+                        // 分析区域
+                        if (regionPoints.length > 10) { // 小区域忽略
+                            const [minX, minY, maxX, maxY] = this.getBoundingBox(regionPoints);
+                            const regionWidth = maxX - minX + 1;
+                            const regionHeight = maxY - minY + 1;
+                            // 检查区域大小和纹理特征
+                            if (regionWidth > 5 && regionHeight > 5 &&
+                                regionWidth < width * 0.2 && regionHeight < height * 0.2) {
+                                // 计算区域密度
+                                const density = regionPoints.length / (regionWidth * regionHeight);
+                                // 检查并添加符合微缩文字特征的区域
+                                if (density > 0.1 && density < 0.5) { // 合适的密度范围
+                                    regions.push({
+                                        x: minX,
+                                        y: minY,
+                                        w: regionWidth,
+                                        h: regionHeight
+                                    });
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+            return { count: regions.length, regions };
+        }
+        /**
+         * 深度优先搜索连通的边缘区域
+         */
+        floodFillEdge(edgeData, startX, startY, visitedMap) {
+            const { data, width, height } = edgeData;
+            const stack = [];
+            const points = [];
+            const dx = [-1, 0, 1, -1, 1, -1, 0, 1];
+            const dy = [-1, -1, -1, 0, 0, 1, 1, 1];
+            // 起始点
+            stack.push({ x: startX, y: startY });
+            visitedMap[startY * width + startX] = true;
+            while (stack.length > 0) {
+                const { x, y } = stack.pop();
+                points.push({ x, y });
+                // 检查88个相邻方向
+                for (let i = 0; i < 8; i++) {
+                    const nx = x + dx[i];
+                    const ny = y + dy[i];
+                    if (nx >= 0 && nx < width && ny >= 0 && ny < height) {
+                        const nidx = ny * width + nx;
+                        const ni = nidx * 4;
+                        if (data[ni] > 200 && !visitedMap[nidx]) {
+                            stack.push({ x: nx, y: ny });
+                            visitedMap[nidx] = true;
+                        }
+                    }
+                }
+            }
+            return points;
+        }
+        /**
+         * 获取点集的外接矩形
+         */
+        getBoundingBox(points) {
+            let minX = Number.MAX_SAFE_INTEGER;
+            let minY = Number.MAX_SAFE_INTEGER;
+            let maxX = 0;
+            let maxY = 0;
+            for (const { x, y } of points) {
+                minX = Math.min(minX, x);
+                minY = Math.min(minY, y);
+                maxX = Math.max(maxX, x);
+                maxY = Math.max(maxY, y);
+            }
+            return [minX, minY, maxX, maxY];
+        }
         /**
          * 检测光变图案
          *