id-scanner-lib 1.3.2 → 1.5.0

package/src/id-recognition/data-extractor.ts

@@ -1,262 +0,0 @@
-/**
- * @file 数据提取工具类
- * @description 提供身份证信息的验证和格式化功能
- * @module DataExtractor
- */
-
-import { IDCardInfo } from '../utils/types';
-
-/**
- * 数据提取工具类
- * 
- * 提供身份证信息的验证、提取和增强功能，可以从身份证号码中提取出生日期、性别等信息，
- * 并对OCR识别结果进行补充和验证
- * 
- * @example
- * ```typescript
- * // 验证身份证号码
- * const isValid = DataExtractor.validateIDNumber('110101199001011234');
- * 
- * // 从身份证号码提取出生日期
- * const birthDate = DataExtractor.extractBirthDateFromID('110101199001011234');
- * // 结果: '1990-01-01'
- * 
- * // 增强OCR识别结果
- * const enhancedInfo = DataExtractor.enhanceIDCardInfo({
- *   name: '张三',
- *   idNumber: '110101199001011234'
- * });
- * // 结果会自动补充性别和出生日期
- * ```
- */
-export class DataExtractor {
-  /**
-   * 验证身份证号码格式
-   * 
-   * 检查身份证号码的长度、格式和出生日期部分是否有效
-   * 
-   * @param {string} idNumber - 要验证的身份证号码
-   * @returns {boolean} 是否是有效的身份证号码
-   */
-  static 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));
-    
-    const date = new Date(year, month - 1, day);
-    if (
-      date.getFullYear() !== year || 
-      date.getMonth() + 1 !== month || 
-      date.getDate() !== day
-    ) {
-      return false;
-    }
-    
-    // 简单的校验规则，实际项目中可以加入更完善的验证
-    return true;
-  }
-  
-  /**
-   * 从身份证号码提取出生日期
-   * 
-   * @param {string} idNumber - 身份证号码
-   * @returns {string|null} 格式化的出生日期（YYYY-MM-DD），如果身份证号码无效则返回null
-   */
-  static extractBirthDateFromID(idNumber: string): string | null {
-    if (!this.validateIDNumber(idNumber)) {
-      return null;
-    }
-    
-    const year = idNumber.substr(6, 4);
-    const month = idNumber.substr(10, 2);
-    const day = idNumber.substr(12, 2);
-    
-    return `${year}-${month}-${day}`;
-  }
-  
-  /**
-   * 从身份证号码提取性别
-   * 
-   * 根据身份证号码第17位判断性别，奇数为男，偶数为女
-   * 
-   * @param {string} idNumber - 身份证号码
-   * @returns {string|null} '男'或'女'，如果身份证号码无效则返回null
-   */
-  static extractGenderFromID(idNumber: string): string | null {
-    if (!this.validateIDNumber(idNumber)) {
-      return null;
-    }
-    
-    // 第17位，奇数为男，偶数为女
-    const genderCode = parseInt(idNumber.charAt(16));
-    return genderCode % 2 === 1 ? '男' : '女';
-  }
-  
-  /**
-   * 从身份证号码提取地区编码
-   * 
-   * @param {string} idNumber - 身份证号码
-   * @returns {string|null} 地区编码（前6位），如果身份证号码无效则返回null
-   */
-  static extractRegionFromID(idNumber: string): string | null {
-    if (!this.validateIDNumber(idNumber)) {
-      return null;
-    }
-    
-    return idNumber.substr(0, 6);
-  }
-  
-  /**
-   * 合并并优化身份证信息
-   * 
-   * 使用多个来源的数据进行交叉验证和补充，如果OCR识别结果缺少某些信息，
-   * 但有身份证号码，则可以从号码中提取出生日期和性别等信息
-   * 
-   * @param {IDCardInfo} ocrInfo - OCR识别到的身份证信息
-   * @param {string} [idNumber] - 可选的外部提供的身份证号码，优先级高于OCR识别结果
-   * @returns {IDCardInfo} 增强后的身份证信息
-   */
-  static enhanceIDCardInfo(ocrInfo: IDCardInfo, idNumber?: string): IDCardInfo {
-    const result = { ...ocrInfo };
-    
-    // 如果OCR识别出身份证号，但没有识别出生日期或性别，则从身份证号码提取
-    if (result.idNumber && this.validateIDNumber(result.idNumber)) {
-      // 从身份证号提取出生日期
-      if (!result.birthDate) {
-        result.birthDate = this.extractBirthDateFromID(result.idNumber) || undefined;
-      }
-      
-      // 从身份证号提取性别
-      if (!result.gender) {
-        result.gender = this.extractGenderFromID(result.idNumber) || undefined;
-      }
-    }
-    
-    // 如果外部传入了身份证号，则优先使用它并提取信息
-    if (idNumber && this.validateIDNumber(idNumber)) {
-      result.idNumber = idNumber;
-      
-      // 使用身份证号码再次验证或补充信息
-      const birthDate = this.extractBirthDateFromID(idNumber);
-      if (birthDate) {
-        result.birthDate = birthDate;
-      }
-      
-      const gender = this.extractGenderFromID(idNumber);
-      if (gender) {
-        result.gender = gender;
-      }
-    }
-    
-    return result;
-  }
-  
-  /**
-   * 提取并验证身份证信息
-   * 
-   * @param idCardInfo 初步提取的身份证信息
-   * @returns 验证和增强后的身份证信息
-   */
-  extractAndValidate(idCardInfo: IDCardInfo): IDCardInfo {
-    const enhancedInfo = {...idCardInfo};
-    
-    // 验证和规范化身份证号
-    if (enhancedInfo.idNumber) {
-      enhancedInfo.idNumber = this.normalizeIDNumber(enhancedInfo.idNumber);
-      
-      // 如果身份证号有效，推断出生日期
-      if (this.validateIDNumber(enhancedInfo.idNumber)) {
-        if (!enhancedInfo.birthDate) {
-          enhancedInfo.birthDate = this.extractBirthDateFromID(enhancedInfo.idNumber);
-        }
-        
-        // 推断性别
-        if (!enhancedInfo.gender) {
-          enhancedInfo.gender = this.extractGenderFromID(enhancedInfo.idNumber);
-        }
-      }
-    }
-    
-    // 规范化日期格式
-    if (enhancedInfo.birthDate) {
-      enhancedInfo.birthDate = this.normalizeDate(enhancedInfo.birthDate);
-    }
-    
-    // 规范化地址信息
-    if (enhancedInfo.address) {
-      enhancedInfo.address = this.normalizeAddress(enhancedInfo.address);
-    }
-    
-    return enhancedInfo;
-  }
-  
-  /**
-   * 规范化身份证号码
-   */
-  private normalizeIDNumber(idNumber: string): string {
-    // 移除空格和特殊字符
-    return idNumber.replace(/[\s\-]/g, '').toUpperCase();
-  }
-  
-  /**
-   * 验证身份证号码是否有效
-   */
-  private validateIDNumber(idNumber: string): boolean {
-    // 简单验证身份证号码长度和格式
-    const idRegex = /(^\d{15}$)|(^\d{17}([0-9]|X)$)/;
-    return idRegex.test(idNumber);
-  }
-  
-  /**
-   * 从身份证号中提取出生日期
-   */
-  private extractBirthDateFromID(idNumber: string): string {
-    if (idNumber.length === 18) {
-      return `${idNumber.substring(6, 10)}-${idNumber.substring(10, 12)}-${idNumber.substring(12, 14)}`;
-    } else if (idNumber.length === 15) {
-      return `19${idNumber.substring(6, 8)}-${idNumber.substring(8, 10)}-${idNumber.substring(10, 12)}`;
-    }
-    return '';
-  }
-  
-  /**
-   * 从身份证号中提取性别信息
-   */
-  private extractGenderFromID(idNumber: string): string {
-    let sexCode: number;
-    if (idNumber.length === 18) {
-      sexCode = parseInt(idNumber.charAt(16));
-    } else {
-      sexCode = parseInt(idNumber.charAt(14));
-    }
-    return sexCode % 2 === 1 ? '男' : '女';
-  }
-  
-  /**
-   * 规范化日期格式
-   */
-  private normalizeDate(date: string): string {
-    // 简单的日期格式化逻辑
-    return date.replace(/(\d{4})(\d{2})(\d{2})/, '$1-$2-$3');
-  }
-  
-  /**
-   * 规范化地址信息
-   */
-  private normalizeAddress(address: string): string {
-    // 地址格式化逻辑
-    return address.trim();
-  }
-} 

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

@@ -1,363 +0,0 @@
-/**
- * @file 身份证检测模块
- * @description 提供自动检测和定位图像中的身份证功能
- * @module IDCardDetector
- */
-
-import { Camera } from "../utils/camera"
-import { ImageProcessor } from "../utils/image-processing"
-import { DetectionResult } from "../utils/types"
-import {
-  throttle,
-  LRUCache,
-  calculateImageFingerprint,
-} from "../utils/performance"
-import { Disposable } from "../utils/resource-manager"
-
-/**
- * IDCardDetector配置选项
- */
-export interface IDCardDetectorOptions {
-  onDetection?: (result: DetectionResult) => void
-  onError?: (error: Error) => void
-  detectionInterval?: number
-  maxImageDimension?: number
-  enableCache?: boolean
-  cacheSize?: number
-  logger?: (message: any) => void
-}
-
-/**
- * 身份证检测器类
- *
- * 通过图像处理和计算机视觉技术，实时检测视频流中的身份证，并提取身份证区域
- * 注意：当前实现是简化版，实际项目中建议使用OpenCV.js进行更精确的检测
- *
- * @example
- * ```typescript
- * // 创建身份证检测器
- * const detector = new IDCardDetector((result) => {
- *   if (result.success && result.croppedImage) {
- *     console.log('检测到身份证!');
- *     // 对裁剪出的身份证图像进行处理
- *     processIDCardImage(result.croppedImage);
- *   }
- * });
- *
- * // 启动检测
- * const videoElement = document.getElementById('video') as HTMLVideoElement;
- * await detector.start(videoElement);
- *
- * // 停止检测
- * detector.stop();
- * ```
- */
-export class IDCardDetector implements Disposable {
-  private camera: Camera
-  private detecting = false
-  private detectTimer: number | null = null
-  private onDetected?: (result: DetectionResult) => void
-  private onError?: (error: Error) => void
-  private detectionInterval: number
-  private maxImageDimension: number
-  private resultCache: LRUCache<string, DetectionResult>
-  private throttledDetect: ReturnType<typeof throttle>
-  private frameCount: number = 0
-  private lastDetectionTime: number = 0
-  private options: IDCardDetectorOptions
-
-  /**
-   * 创建身份证检测器实例
-   *
-   * @param options 身份证检测器配置选项，或者检测回调函数
-   */
-  constructor(
-    options?: IDCardDetectorOptions | ((result: DetectionResult) => void)
-  ) {
-    this.camera = new Camera()
-
-    if (typeof options === "function") {
-      // 兼容旧的构造函数方式
-      this.onDetected = options
-      this.options = {
-        detectionInterval: 200,
-        maxImageDimension: 800,
-        enableCache: true,
-        cacheSize: 20,
-        logger: console.log,
-      }
-    } else if (options) {
-      // 使用新的选项对象方式
-      this.options = {
-        detectionInterval: 200,
-        maxImageDimension: 800,
-        enableCache: true,
-        cacheSize: 20,
-        logger: console.log,
-        ...options,
-      }
-      this.onDetected = options.onDetection
-      this.onError = options.onError
-    } else {
-      this.options = {
-        detectionInterval: 200,
-        maxImageDimension: 800,
-        enableCache: true,
-        cacheSize: 20,
-        logger: console.log,
-      }
-    }
-
-    this.detectionInterval = this.options.detectionInterval!
-    this.maxImageDimension = this.options.maxImageDimension!
-
-    // 初始化结果缓存
-    this.resultCache = new LRUCache<string, DetectionResult>(
-      this.options.cacheSize
-    )
-
-    // 创建节流版本的检测函数
-    this.throttledDetect = throttle(
-      this.performDetection.bind(this),
-      this.detectionInterval
-    )
-  }
-
-  /**
-   * 启动身份证检测
-   *
-   * 初始化相机并开始连续检测视频帧中的身份证
-   *
-   * @param {HTMLVideoElement} videoElement - 用于显示相机画面的video元素
-   * @returns {Promise<void>} 启动完成的Promise
-   */
-  async start(videoElement: HTMLVideoElement): Promise<void> {
-    await this.camera.initialize(videoElement)
-    this.detecting = true
-    this.frameCount = 0
-    this.lastDetectionTime = 0
-    this.detect()
-  }
-
-  /**
-   * 停止身份证检测
-   */
-  stop(): void {
-    this.detecting = false
-    if (this.detectTimer !== null) {
-      cancelAnimationFrame(this.detectTimer)
-      this.detectTimer = null
-    }
-  }
-
-  /**
-   * 持续检测视频帧
-   *
-   * @private
-   */
-  private detect(): void {
-    if (!this.detecting) return
-
-    this.detectTimer = requestAnimationFrame(() => {
-      try {
-        this.frameCount++
-        const now = performance.now()
-
-        // 帧率控制 - 只有满足时间间隔的帧才进行检测
-        // 这样可以显著减少CPU使用率，同时保持良好的用户体验
-        if (
-          this.frameCount % 3 === 0 ||
-          now - this.lastDetectionTime >= this.detectionInterval
-        ) {
-          this.throttledDetect()
-          this.lastDetectionTime = now
-        }
-
-        // 继续下一帧检测
-        this.detect()
-      } catch (error) {
-        if (this.onError) {
-          this.onError(error as Error)
-        } else {
-          console.error("身份证检测错误:", error)
-        }
-
-        // 出错后延迟重试
-        setTimeout(() => {
-          if (this.detecting) {
-            this.detect()
-          }
-        }, 1000)
-      }
-    })
-  }
-
-  /**
-   * 执行单帧检测
-   *
-   * @private
-   */
-  private async performDetection(): Promise<void> {
-    if (!this.detecting || !this.camera) return
-
-    // 获取当前视频帧
-    const frame = this.camera.captureFrame()
-    if (!frame) return
-
-    // 检查缓存
-    if (this.options.enableCache) {
-      const fingerprint = calculateImageFingerprint(frame, 16) // 使用更大的尺寸提高特征区分度
-      const cachedResult = this.resultCache.get(fingerprint)
-
-      if (cachedResult) {
-        this.options.logger?.("使用缓存的检测结果")
-
-        // 使用缓存结果，但更新图像数据以确保最新
-        const updatedResult = {
-          ...cachedResult,
-          imageData: frame,
-        }
-
-        if (this.onDetected) {
-          this.onDetected(updatedResult)
-        }
-        return
-      }
-    }
-
-    // 降低分辨率以提高性能
-    const downsampledFrame = ImageProcessor.resizeImage(
-      frame,
-      this.maxImageDimension,
-      this.maxImageDimension
-    )
-
-    try {
-      // 检测身份证
-      const result = await this.detectIDCard(downsampledFrame)
-
-      // 如果检测成功，将原始图像添加到结果中
-      if (result.success) {
-        result.imageData = frame
-
-        // 缓存结果
-        if (this.options.enableCache) {
-          const fingerprint = calculateImageFingerprint(frame, 16)
-          this.resultCache.set(fingerprint, result)
-        }
-      }
-
-      // 处理检测结果
-      if (this.onDetected) {
-        this.onDetected(result)
-      }
-    } catch (error) {
-      if (this.onError) {
-        this.onError(error as Error)
-      } else {
-        console.error("身份证检测错误:", error)
-      }
-    }
-  }
-
-  /**
-   * 检测图像中的身份证
-   *
-   * @private
-   * @param {ImageData} imageData - 要分析的图像数据
-   * @returns {Promise<DetectionResult>} 检测结果
-   */
-  private async detectIDCard(imageData: ImageData): Promise<DetectionResult> {
-    // 1. 图像预处理
-    const grayscale = ImageProcessor.toGrayscale(imageData)
-
-    // 2. 检测矩形和边缘（简化版实现）
-    // 注意：实际应用中应使用OpenCV.js或其他计算机视觉库进行更精确的检测
-    // 此处仅作为概念性实现，使用基本矩形检测逻辑
-
-    // 模拟检测过程，随机判断是否找到身份证
-    // 在实际应用中，此处应当实现实际的计算机视觉算法
-    const detectionResult: DetectionResult = {
-      success: Math.random() > 0.3, // 70%的概率成功检测到
-      message: "身份证检测完成",
-    }
-
-    if (detectionResult.success) {
-      // 模拟一个身份证矩形区域
-      const width = imageData.width
-      const height = imageData.height
-
-      // 大致的身份证区域（按比例）
-      const rectWidth = Math.round(width * 0.7)
-      const rectHeight = Math.round(rectWidth * 0.618) // 身份证是黄金比例
-      const rectX = Math.round((width - rectWidth) / 2)
-      const rectY = Math.round((height - rectHeight) / 2)
-
-      // 添加四个角点
-      detectionResult.corners = [
-        { x: rectX, y: rectY },
-        { x: rectX + rectWidth, y: rectY },
-        { x: rectX + rectWidth, y: rectY + rectHeight },
-        { x: rectX, y: rectY + rectHeight },
-      ]
-
-      // 添加边界框
-      detectionResult.boundingBox = {
-        x: rectX,
-        y: rectY,
-        width: rectWidth,
-        height: rectHeight,
-      }
-
-      // 裁剪身份证图像
-      const canvas = document.createElement("canvas")
-      canvas.width = rectWidth
-      canvas.height = rectHeight
-      const ctx = canvas.getContext("2d")
-
-      if (ctx) {
-        const tempCanvas = ImageProcessor.imageDataToCanvas(imageData)
-        ctx.drawImage(
-          tempCanvas,
-          rectX,
-          rectY,
-          rectWidth,
-          rectHeight,
-          0,
-          0,
-          rectWidth,
-          rectHeight
-        )
-
-        detectionResult.croppedImage = ctx.getImageData(
-          0,
-          0,
-          rectWidth,
-          rectHeight
-        )
-      }
-
-      // 设置置信度
-      detectionResult.confidence = 0.7 + Math.random() * 0.3
-    }
-
-    return detectionResult
-  }
-
-  /**
-   * 清除检测结果缓存
-   */
-  clearCache(): void {
-    this.resultCache.clear()
-    this.options.logger?.("检测结果缓存已清除")
-  }
-
-  /**
-   * 释放资源
-   */
-  dispose(): void {
-    this.stop()
-    this.camera.release()
-    this.resultCache.clear()
-  }
-}