id-scanner-lib 1.3.0 → 1.3.3

package/src/id-recognition/id-detector.ts

@@ -2,6 +2,7 @@
  * @file 身份证检测模块
  * @description 提供自动检测和定位图像中的身份证功能
  * @module IDCardDetector
+ * @version 1.3.2
  */
 
 import { Camera } from "../utils/camera"
@@ -53,6 +54,8 @@ export interface IDCardDetectorOptions {
  * ```
  */
 export class IDCardDetector implements Disposable {
+  // 身份证标准宽高比（近似黄金比例）
+  private static readonly ID_CARD_ASPECT_RATIO = 1.58 // 标准身份证宽高比
   private camera: Camera
   private detecting = false
   private detectTimer: number | null = null
@@ -270,28 +273,32 @@ export class IDCardDetector implements Disposable {
   private async detectIDCard(imageData: ImageData): Promise<DetectionResult> {
     // 1. 图像预处理
     const grayscale = ImageProcessor.toGrayscale(imageData)
-
-    // 2. 检测矩形和边缘（简化版实现）
-    // 注意：实际应用中应使用OpenCV.js或其他计算机视觉库进行更精确的检测
-    // 此处仅作为概念性实现，使用基本矩形检测逻辑
-
-    // 模拟检测过程，随机判断是否找到身份证
-    // 在实际应用中，此处应当实现实际的计算机视觉算法
+    
+    // 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: DetectionResult = {
-      success: Math.random() > 0.3, // 70%的概率成功检测到
-      message: "身份证检测完成",
+      success: idCardRect !== null,
+      message: idCardRect ? "身份证检测成功" : "未检测到身份证",
     }
 
-    if (detectionResult.success) {
-      // 模拟一个身份证矩形区域
+    if (detectionResult.success && idCardRect) {
+      // 使用检测到的身份证矩形区域
       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)
+      
+      // 使用实际检测到的身份证区域
+      const rectWidth = idCardRect.width
+      const rectHeight = idCardRect.height
+      const rectX = idCardRect.x
+      const rectY = idCardRect.y
 
       // 添加四个角点
       detectionResult.corners = [
@@ -337,8 +344,8 @@ export class IDCardDetector implements Disposable {
         )
       }
 
-      // 设置置信度
-      detectionResult.confidence = 0.7 + Math.random() * 0.3
+      // 设置置信度 - 基于边缘强度和矩形形状评分
+      detectionResult.confidence = this.calculateConfidence(idCardRect, edgeData)
     }
 
     return detectionResult
@@ -360,4 +367,144 @@ export class IDCardDetector implements Disposable {
     this.camera.release()
     this.resultCache.clear()
   }
+  
+  /**
+   * 从边缘图像中检测矩形
+   * @param edgeData 边缘检测后的图像数据
+   * @returns 检测到的矩形数组
+   */
+  private detectRectangles(edgeData: ImageData): Array<{
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    confidence: number;
+  }> {
+    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);
+  }
+  
+  /**
+   * 使用积分图计算矩形区域内的总和
+   */
+  private calculateRectSum(integral: Uint32Array, x: number, y: number, w: number, h: number, stride: number): number {
+    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;
+  }
+  
+  /**
+   * 计算矩形周长上的边缘点数量
+   */
+  private calculateRectPerimeter(integral: Uint32Array, x: number, y: number, w: number, h: number, stride: number): number {
+    // 上边缘
+    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;
+  }
+  
+  /**
+   * 从检测到的矩形中找出最可能是身份证的矩形
+   */
+  private findIdCardRectangle(rectangles: Array<{x: number; y: number; width: number; height: number; confidence: number}>, imageWidth: number, imageHeight: number): {x: number; y: number; width: number; height: number; confidence: number} | null {
+    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];
+  }
+  
+  /**
+   * 计算身份证检测的置信度
+   */
+  private calculateConfidence(rect: {x: number; y: number; width: number; height: number; confidence: number} | null, edgeData: ImageData): number {
+    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);
+  }
 }

package/src/id-recognition/ocr-processor.ts

@@ -2,6 +2,7 @@
  * @file OCR处理模块
  * @description 提供身份证文字识别和信息提取功能
  * @module OCRProcessor
+ * @version 1.3.2
  */
 
 import { createWorker } from "tesseract.js"
@@ -231,67 +232,213 @@ export class OCRProcessor implements Disposable {
    * @param {string} text - OCR识别到的文本
    * @returns {IDCardInfo} 提取到的身份证信息对象
    */
+  /**
+   * 格式化日期字符串为标准格式 (YYYY-MM-DD)
+   * @param dateStr 原始日期字符串
+   * @returns 格式化后的日期字符串
+   */
+  private formatDateString(dateStr: string): string {
+    // 先尝试提取年月日
+    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 是否有效
+   */
+  private validateIDNumber(idNumber: string): boolean {
+    // 基本验证，校验位有效性和长度
+    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));
+    
+    if (month < 1 || month > 12 || day < 1 || day > 31) {
+      return false;
+    }
+    
+    // 更详细的检查可以添加校验位的验证等逻辑...
+    
+    return true;
+  }
+  
   private parseIDCardText(text: string): IDCardInfo {
     const info: IDCardInfo = {}
+    
+    // 预处理文本，清除多余空白
+    const processedText = text.replace(/\s+/g, " ").trim()
 
-    // 拆分为行
-    const lines = text.split("\n").filter((line) => line.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]
+    // 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
     }
 
-    // 解析姓名
-    for (const line of lines) {
-      if (
-        line.includes("姓名") ||
-        (line.length < 10 && line.length > 1 && !/\d/.test(line))
-      ) {
-        info.name = line.replace("姓名", "").trim()
-        break
+    // 解析姓名 - 使用多种策略
+    // 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()
+    // 解析性别和民族 - 多种模式匹配
+    // 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]
     }
 
-    // 解析出生日期
-    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]}`
+    // 解析出生日期 - 支持多种格式
+    // 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}`
     }
 
-    // 解析地址
-    const addressRegex = /住址([\s\S]*?)公民身份号码/
-    const addressMatch = text.match(addressRegex)
-    if (addressMatch) {
-      info.address = addressMatch[1].replace(/\n/g, "").trim()
+    // 解析地址 - 改进的正则匹配
+    // 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 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()
     }
 
-    // 解析有效期限
-    const validPeriodRegex = /有效期限([\s\S]*?)(-|至)/
-    const validPeriodMatch = text.match(validPeriodRegex)
+    // 解析有效期限 - 支持多种格式
+    // 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