id-scanner-lib 1.0.0 → 1.2.0

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

@@ -7,6 +7,21 @@
 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;
+}
 
 /**
  * 身份证检测器类
@@ -33,18 +48,68 @@ import { DetectionResult } from '../utils/types';
  * detector.stop();
  * ```
  */
-export class IDCardDetector {
+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 {Function} [onDetected] - 身份证检测成功回调函数，接收检测结果对象
+   * @param options 身份证检测器配置选项，或者检测回调函数
    */
-  constructor(private onDetected?: (result: DetectionResult) => void) {
+  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);
   }
   
   /**
@@ -58,114 +123,212 @@ export class IDCardDetector {
   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 async detect(): Promise<void> {
+  private detect(): void {
     if (!this.detecting) return;
     
-    const imageData = this.camera.captureFrame();
-    
-    if (imageData) {
+    this.detectTimer = requestAnimationFrame(() => {
       try {
-        // 简单实现，因为没有完整的OpenCV.js
-        // 实际项目中应该使用OpenCV.js做更精确的边缘检测
-        const result = await this.detectIDCard(imageData);
+        this.frameCount++;
+        const now = performance.now();
         
-        if (this.onDetected) {
-          this.onDetected(result);
+        // 帧率控制 - 只有满足时间间隔的帧才进行检测
+        // 这样可以显著减少CPU使用率，同时保持良好的用户体验
+        if (this.frameCount % 3 === 0 || now - this.lastDetectionTime >= this.detectionInterval) {
+          this.throttledDetect();
+          this.lastDetectionTime = now;
         }
+        
+        // 继续下一帧检测
+        this.detect();
       } catch (error) {
-        console.error('身份证检测错误:', 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;
       }
     }
     
-    this.detectTimer = window.setTimeout(() => this.detect(), 200);
+    // 降低分辨率以提高性能
+    const downsampledFrame = ImageProcessor.downsampleForProcessing(frame, 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>} 检测结果，包含成功标志和裁剪后的身份证图像
+   * @param {ImageData} imageData - 要分析的图像数据
+   * @returns {Promise<DetectionResult>} 检测结果
    */
   private async detectIDCard(imageData: ImageData): Promise<DetectionResult> {
-    // 图像预处理
+    // 1. 图像预处理
     const grayscale = ImageProcessor.toGrayscale(imageData);
-    const enhanced = ImageProcessor.adjustBrightnessContrast(grayscale, 10, 30);
     
-    // 简化的身份证检测算法
-    // 在真实项目中，这里应该使用OpenCV.js进行轮廓检测和矩形检测
+    // 2. 检测矩形和边缘（简化版实现）
+    // 注意：实际应用中应使用OpenCV.js或其他计算机视觉库进行更精确的检测
+    // 此处仅作为概念性实现，使用基本矩形检测逻辑
     
-    // 模拟检测过程
-    const success = Math.random() > 0.7; // 模拟70%的概率检测成功
+    // 模拟检测过程，随机判断是否找到身份证
+    // 在实际应用中，此处应当实现实际的计算机视觉算法
+    const detectionResult: DetectionResult = {
+      success: Math.random() > 0.3, // 70%的概率成功检测到
+      message: '身份证检测完成'
+    };
     
-    if (success) {
-      // 模拟一个身份证区域，实际项目中应该是根据检测结果
-      const cardWidth = Math.floor(imageData.width * 0.8);
-      const cardHeight = Math.floor(cardWidth * 0.63); // 身份证比例大约是8:5
-      const x = Math.floor((imageData.width - cardWidth) / 2);
-      const y = Math.floor((imageData.height - cardHeight) / 2);
+    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);
       
-      // 模拟四个角点
-      const corners = [
-        { x, y }, // 左上
-        { x: x + cardWidth, y }, // 右上
-        { x: x + cardWidth, y: y + cardHeight }, // 右下
-        { x, y: y + cardHeight } // 左下
+      // 添加四个角点
+      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 = cardWidth;
-      canvas.height = cardHeight;
+      canvas.width = rectWidth;
+      canvas.height = rectHeight;
       const ctx = canvas.getContext('2d');
       
       if (ctx) {
-        // 从原图中裁剪身份证区域
-        const sourceCanvas = ImageProcessor.imageDataToCanvas(imageData);
+        const tempCanvas = ImageProcessor.imageDataToCanvas(imageData);
         ctx.drawImage(
-          sourceCanvas, 
-          x, y, cardWidth, cardHeight,
-          0, 0, cardWidth, cardHeight
+          tempCanvas,
+          rectX, rectY, rectWidth, rectHeight,
+          0, 0, rectWidth, rectHeight
         );
         
-        const croppedImage = ctx.getImageData(0, 0, cardWidth, cardHeight);
-        
-        return {
-          success: true,
-          corners,
-          croppedImage
-        };
+        detectionResult.croppedImage = ctx.getImageData(0, 0, rectWidth, rectHeight);
       }
+      
+      // 设置置信度
+      detectionResult.confidence = 0.7 + Math.random() * 0.3;
     }
     
-    return { success: false };
+    return detectionResult;
   }
   
   /**
-   * 停止身份证检测
-   * 
-   * 停止检测循环并释放相机资源
+   * 清除检测结果缓存
    */
-  stop(): void {
-    this.detecting = false;
-    
-    if (this.detectTimer) {
-      clearTimeout(this.detectTimer);
-      this.detectTimer = null;
-    }
-    
+  clearCache(): void {
+    this.resultCache.clear();
+    this.options.logger?.('检测结果缓存已清除');
+  }
+  
+  /**
+   * 释放资源
+   */
+  dispose(): void {
+    this.stop();
     this.camera.release();
+    this.resultCache.clear();
   }
 } 

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

@@ -7,6 +7,26 @@
 import { createWorker } from 'tesseract.js';
 import { IDCardInfo } from '../utils/types';
 import { ImageProcessor } from '../utils/image-processing';
+import { LRUCache, calculateImageFingerprint } from '../utils/performance';
+import { isWorkerSupported, createWorker as createCustomWorker } from '../utils/worker';
+import { processOCRInWorker, OCRProcessInput } from './ocr-worker';
+import { Disposable } from '../utils/resource-manager';
+
+/**
+ * OCR处理器选项接口
+ */
+export interface OCRProcessorOptions {
+  /** 是否使用Worker线程 */
+  useWorker?: boolean;
+  /** 是否启用结果缓存 */
+  enableCache?: boolean;
+  /** 缓存容量 */
+  cacheSize?: number;
+  /** 图像处理前的最大尺寸 */
+  maxImageDimension?: number;
+  /** 日志回调函数 */
+  logger?: (message: any) => void;
+}
 
 /**
  * OCR处理器类
@@ -29,10 +49,31 @@ import { ImageProcessor } from '../utils/image-processing';
  * await ocrProcessor.terminate();
  * ```
  */
-export class OCRProcessor {
+export class OCRProcessor implements Disposable {
   private worker: any = null;
+  private ocrWorker: ReturnType<typeof createCustomWorker<OCRProcessInput, { idCardInfo: IDCardInfo, processingTime: number }>> | null = null;
+  private initialized: boolean = false;
+  private resultCache: LRUCache<string, IDCardInfo>;
+  private options: OCRProcessorOptions;
   
-  constructor() {}
+  /**
+   * 创建OCR处理器实例
+   * 
+   * @param options OCR处理器选项
+   */
+  constructor(options: OCRProcessorOptions = {}) {
+    this.options = {
+      useWorker: isWorkerSupported(),
+      enableCache: true,
+      cacheSize: 50,
+      maxImageDimension: 1000,
+      logger: console.log,
+      ...options
+    };
+    
+    // 初始化缓存
+    this.resultCache = new LRUCache<string, IDCardInfo>(this.options.cacheSize);
+  }
   
   /**
    * 初始化OCR引擎
@@ -42,46 +83,100 @@ export class OCRProcessor {
    * @returns {Promise<void>} 初始化完成的Promise
    */
   async initialize(): Promise<void> {
-    this.worker = createWorker({
-      logger: (m: any) => console.log(m)
-    } as any);
-    
-    await this.worker.load();
-    await this.worker.loadLanguage('chi_sim');
-    await this.worker.initialize('chi_sim');
-    await this.worker.setParameters({
-      tessedit_char_whitelist: '0123456789X-年月日一二三四五六七八九十零壹贰叁肆伍陆柒捌玖拾ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz民族汉族满族回族维吾尔族藏族苗族彝族壮族朝鲜族侗族瑶族白族土家族哈尼族哈萨克族傣族黎族傈僳族佤族高山族拉祜族水族东乡族钠西族景颇族柯尔克孜族士族达斡尔族仫佬族羌族布朗族撒拉族毛南族仡佬族锡伯族阿昌族普米族塔吉克族怒族乌孜别克族俄罗斯族鄂温克族德昂族保安族裕固族京族塔塔尔族独龙族鄂伦春族赫哲族门巴族珞巴族基诺族男女性别住址出生公民身份号码签发机关有效期'
-    });
+    if (this.initialized) return;
+    
+    if (this.options.useWorker) {
+      // 使用自定义Worker线程处理OCR
+      this.ocrWorker = createCustomWorker<OCRProcessInput, { idCardInfo: IDCardInfo, processingTime: number }>(processOCRInWorker);
+      this.initialized = true;
+      this.options.logger?.('OCR Worker 初始化完成');
+    } else {
+      // 使用主线程处理OCR
+      this.worker = createWorker({
+        logger: this.options.logger
+      } as any);
+      
+      await this.worker.load();
+      await this.worker.loadLanguage('chi_sim');
+      await this.worker.initialize('chi_sim');
+      await this.worker.setParameters({
+        tessedit_char_whitelist: '0123456789X-年月日一二三四五六七八九十零壹贰叁肆伍陆柒捌玖拾ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz民族汉族满族回族维吾尔族藏族苗族彝族壮族朝鲜族侗族瑶族白族土家族哈尼族哈萨克族傣族黎族傈僳族佤族高山族拉祜族水族东乡族钠西族景颇族柯尔克孜族士族达斡尔族仫佬族羌族布朗族撒拉族毛南族仡佬族锡伯族阿昌族普米族塔吉克族怒族乌孜别克族俄罗斯族鄂温克族德昂族保安族裕固族京族塔塔尔族独龙族鄂伦春族赫哲族门巴族珞巴族基诺族男女性别住址出生公民身份号码签发机关有效期'
+      });
+      
+      this.initialized = true;
+      this.options.logger?.('OCR引擎初始化完成');
+    }
   }
   
   /**
    * 处理身份证图像并提取信息
-   * 
-   * 对身份证图像进行OCR识别，并从识别结果中提取结构化信息
-   * 
-   * @param {ImageData} imageData - 身份证图像数据
-   * @returns {Promise<IDCardInfo>} 提取到的身份证信息
+   * @param imageData 要处理的身份证图像数据
+   * @returns 提取的身份证信息
    */
   async processIDCard(imageData: ImageData): Promise<IDCardInfo> {
-    if (!this.worker) {
+    if (!this.initialized) {
       await this.initialize();
     }
     
-    // 图像预处理，提高OCR识别率
-    const enhancedImage = ImageProcessor.adjustBrightnessContrast(imageData, 15, 25);
+    // 计算图像指纹，用于缓存查找
+    if (this.options.enableCache) {
+      const fingerprint = calculateImageFingerprint(imageData);
+      
+      // 检查缓存中是否有结果
+      const cachedResult = this.resultCache.get(fingerprint);
+      if (cachedResult) {
+        this.options.logger?.('使用缓存的OCR结果');
+        return cachedResult;
+      }
+    }
     
-    // 转换ImageData为Canvas
-    const canvas = ImageProcessor.imageDataToCanvas(enhancedImage);
+    // 图像预处理：降低分辨率和增强对比度
+    const downsampledImage = ImageProcessor.downsampleForProcessing(imageData, this.options.maxImageDimension);
+    const enhancedImage = ImageProcessor.adjustBrightnessContrast(downsampledImage, 15, 25);
     
     // OCR识别
     try {
-      const { data } = await this.worker.recognize(canvas);
+      let idCardInfo: IDCardInfo;
+      
+      if (this.options.useWorker && this.ocrWorker) {
+        // 使用Worker线程处理
+        const base64Image = ImageProcessor.imageDataToBase64(enhancedImage);
+        
+        const result = await this.ocrWorker.postMessage({
+          imageBase64: base64Image,
+          tessWorkerOptions: {
+            logger: this.options.logger
+          }
+        });
+        
+        idCardInfo = result.idCardInfo;
+        this.options.logger?.(`OCR处理完成，用时: ${result.processingTime.toFixed(2)}ms`);
+      } else {
+        // 使用主线程处理
+        const startTime = performance.now();
+        
+        // 转换ImageData为Canvas
+        const canvas = ImageProcessor.imageDataToCanvas(enhancedImage);
+        
+        const { data } = await this.worker.recognize(canvas);
+        
+        // 解析身份证信息
+        idCardInfo = this.parseIDCardText(data.text);
+        
+        const processingTime = performance.now() - startTime;
+        this.options.logger?.(`OCR处理完成，用时: ${processingTime.toFixed(2)}ms`);
+      }
+      
+      // 缓存结果
+      if (this.options.enableCache) {
+        const fingerprint = calculateImageFingerprint(imageData);
+        this.resultCache.set(fingerprint, idCardInfo);
+      }
       
-      // 解析身份证信息
-      return this.parseIDCardText(data.text);
+      return idCardInfo;
     } catch (error) {
-      console.error('OCR识别错误:', error);
-      return {}; // 返回空对象
+      this.options.logger?.(`OCR识别错误: ${error}`);
+      return {} as IDCardInfo;
     }
   }
   
@@ -155,6 +250,14 @@ export class OCRProcessor {
     return info;
   }
   
+  /**
+   * 清除结果缓存
+   */
+  clearCache(): void {
+    this.resultCache.clear();
+    this.options.logger?.('OCR结果缓存已清除');
+  }
+  
   /**
    * 终止OCR引擎并释放资源
    * 
@@ -165,5 +268,20 @@ export class OCRProcessor {
       await this.worker.terminate();
       this.worker = null;
     }
+    
+    if (this.ocrWorker) {
+      this.ocrWorker.terminate();
+      this.ocrWorker = null;
+    }
+    
+    this.initialized = false;
+    this.options.logger?.('OCR引擎已终止');
+  }
+  
+  /**
+   * 释放资源
+   */
+  dispose(): Promise<void> {
+    return this.terminate();
   }
 }