id-scanner-lib 1.1.1 → 1.2.0

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

@@ -0,0 +1,146 @@
+/**
+ * @file OCR Worker处理模块
+ * @description 用于在Web Worker中执行OCR处理
+ * @module OCRWorker
+ */
+
+import type { IDCardInfo } from '../utils/types';
+
+/**
+ * OCR处理输入接口
+ */
+export interface OCRProcessInput {
+  imageBase64: string;
+  tessWorkerOptions?: any;
+}
+
+/**
+ * OCR处理输出接口
+ */
+export interface OCRProcessOutput {
+  idCardInfo: IDCardInfo;
+  processingTime: number;
+}
+
+/**
+ * 在Web Worker中执行OCR处理的函数
+ * 
+ * 该函数用于在使用 createWorker 创建的 Worker 中执行
+ * 
+ * @param input OCR处理输入数据
+ * @returns OCR处理结果
+ */
+export async function processOCRInWorker(input: OCRProcessInput): Promise<OCRProcessOutput> {
+  // 计时开始
+  const startTime = performance.now();
+  
+  // 加载Tesseract.js (Worker 环境下动态导入)
+  const { createWorker } = await import('tesseract.js');
+  
+  // 创建OCR Worker
+  const worker = createWorker(input.tessWorkerOptions || {
+    logger: (m: any) => console.log(m)
+  });
+  
+  try {
+    // 初始化OCR引擎
+    await worker.load();
+    await worker.loadLanguage('chi_sim');
+    await worker.initialize('chi_sim');
+    await worker.setParameters({
+      tessedit_char_whitelist: '0123456789X-年月日一二三四五六七八九十零壹贰叁肆伍陆柒捌玖拾ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz民族汉族满族回族维吾尔族藏族苗族彝族壮族朝鲜族侗族瑶族白族土家族哈尼族哈萨克族傣族黎族傈僳族佤族高山族拉祜族水族东乡族钠西族景颇族柯尔克孜族士族达斡尔族仫佬族羌族布朗族撒拉族毛南族仡佬族锡伯族阿昌族普米族塔吉克族怒族乌孜别克族俄罗斯族鄂温克族德昂族保安族裕固族京族塔塔尔族独龙族鄂伦春族赫哲族门巴族珞巴族基诺族男女性别住址出生公民身份号码签发机关有效期'
+    });
+    
+    // 识别图像
+    const { data } = await worker.recognize(input.imageBase64);
+    
+    // 解析识别结果
+    const idCardInfo = parseIDCardText(data.text);
+    
+    // 处理完成后终止worker
+    await worker.terminate();
+    
+    // 计算处理时间
+    const processingTime = performance.now() - startTime;
+    
+    // 返回处理结果
+    return {
+      idCardInfo,
+      processingTime
+    };
+  } catch (error) {
+    // 确保资源被释放
+    await worker.terminate();
+    throw error;
+  }
+}
+
+/**
+ * 解析身份证文本信息
+ * 
+ * 从OCR识别到的文本中提取结构化的身份证信息
+ * 
+ * @private
+ * @param {string} text - OCR识别到的文本
+ * @returns {IDCardInfo} 提取到的身份证信息对象
+ */
+function parseIDCardText(text: string): IDCardInfo {
+  const info: IDCardInfo = {};
+  
+  // 拆分为行
+  const lines = text.split('\n').filter(line => line.trim());
+  
+  // 解析身份证号码（最容易识别的部分）
+  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;
+    }
+  }
+  
+  // 解析性别和民族
+  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();
+  }
+  
+  // 解析签发机关
+  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);
+  if (validPeriodMatch) {
+    info.validPeriod = validPeriodMatch[0].replace('有效期限', '').trim();
+  }
+  
+  return info;
+} 

package/src/utils/image-processing.ts

@@ -154,4 +154,208 @@ export class ImageProcessor {
     
     return imageData;
   }
+
+  /**
+   * 降低图像分辨率以提高处理速度
+   * 
+   * 对于OCR和图像分析，降低分辨率可以在保持识别率的同时大幅提升处理速度
+   * 
+   * @param {ImageData} imageData - 原图像数据
+   * @param {number} [maxDimension=1000] - 目标最大尺寸（宽或高）
+   * @returns {ImageData} 处理后的图像数据
+   */
+  static downsampleForProcessing(imageData: ImageData, maxDimension: number = 1000): ImageData {
+    const { width, height } = imageData;
+    
+    // 如果图像尺寸已经小于或等于目标尺寸，则无需处理
+    if (width <= maxDimension && height <= maxDimension) {
+      return imageData;
+    }
+    
+    // 计算缩放比例，保持宽高比
+    const scale = maxDimension / Math.max(width, height);
+    const newWidth = Math.round(width * scale);
+    const newHeight = Math.round(height * scale);
+    
+    // 调整图像大小
+    return this.resize(imageData, newWidth, newHeight);
+  }
+
+  /**
+   * 转换图像为Base64格式，方便在Worker线程中传递
+   * 
+   * @param {ImageData} imageData - 原图像数据
+   * @returns {string} base64编码的图像数据
+   */
+  static imageDataToBase64(imageData: ImageData): string {
+    const canvas = this.imageDataToCanvas(imageData);
+    return canvas.toDataURL('image/jpeg', 0.7); // 使用较低质量的JPEG格式减少数据量
+  }
+
+  /**
+   * 从Base64字符串还原图像数据
+   * 
+   * @param {string} base64 - base64编码的图像数据
+   * @returns {Promise<ImageData>} 还原的图像数据
+   */
+  static async base64ToImageData(base64: string): Promise<ImageData> {
+    return new Promise((resolve, reject) => {
+      const img = new Image();
+      img.onload = () => {
+        const canvas = document.createElement('canvas');
+        canvas.width = img.width;
+        canvas.height = img.height;
+        const ctx = canvas.getContext('2d');
+        
+        if (!ctx) {
+          reject(new Error('无法创建Canvas上下文'));
+          return;
+        }
+        
+        ctx.drawImage(img, 0, 0);
+        const imageData = ctx.getImageData(0, 0, canvas.width, canvas.height);
+        resolve(imageData);
+      };
+      
+      img.onerror = () => {
+        reject(new Error('图像加载失败'));
+      };
+      
+      img.src = base64;
+    });
+  }
+
+  /**
+   * 使用Web Worker并行处理图像
+   * 此方法将图像分割为多个部分，并行处理以提高性能
+   * 
+   * @param {ImageData} imageData - 原图像数据
+   * @param {Function} processingFunction - 处理函数，接收ImageData返回ImageData
+   * @param {number} [chunks=4] - 分割的块数
+   * @returns {Promise<ImageData>} 处理后的图像数据
+   */
+  static async processImageInParallel(
+    imageData: ImageData, 
+    processingFunction: (imgData: ImageData) => ImageData,
+    chunks: number = 4
+  ): Promise<ImageData> {
+    // 如果不支持Worker或图像太小，直接处理
+    if (typeof Worker === 'undefined' || imageData.width * imageData.height < 100000) {
+      return processingFunction(imageData);
+    }
+    
+    // 创建结果canvas
+    const resultCanvas = document.createElement('canvas');
+    resultCanvas.width = imageData.width;
+    resultCanvas.height = imageData.height;
+    const resultCtx = resultCanvas.getContext('2d');
+    
+    if (!resultCtx) {
+      throw new Error('无法创建Canvas上下文');
+    }
+    
+    // 根据图像特性确定分割方向和每块大小
+    const isWide = imageData.width > imageData.height;
+    const chunkSize = Math.floor((isWide ? imageData.width : imageData.height) / chunks);
+    
+    // 创建Worker处理每个块
+    const promises = [];
+    
+    for (let i = 0; i < chunks; i++) {
+      const chunkCanvas = document.createElement('canvas');
+      const chunkCtx = chunkCanvas.getContext('2d');
+      
+      if (!chunkCtx) continue;
+      
+      let chunkImageData;
+      
+      if (isWide) {
+        // 水平分割
+        const startX = i * chunkSize;
+        const width = (i === chunks - 1) ? imageData.width - startX : chunkSize;
+        
+        chunkCanvas.width = width;
+        chunkCanvas.height = imageData.height;
+        
+        // 复制原图像数据到分块
+        const tempCanvas = this.imageDataToCanvas(imageData);
+        chunkCtx.drawImage(
+          tempCanvas, 
+          startX, 0, width, imageData.height,
+          0, 0, width, imageData.height
+        );
+        
+        chunkImageData = chunkCtx.getImageData(0, 0, width, imageData.height);
+      } else {
+        // 垂直分割
+        const startY = i * chunkSize;
+        const height = (i === chunks - 1) ? imageData.height - startY : chunkSize;
+        
+        chunkCanvas.width = imageData.width;
+        chunkCanvas.height = height;
+        
+        // 复制原图像数据到分块
+        const tempCanvas = this.imageDataToCanvas(imageData);
+        chunkCtx.drawImage(
+          tempCanvas, 
+          0, startY, imageData.width, height,
+          0, 0, imageData.width, height
+        );
+        
+        chunkImageData = chunkCtx.getImageData(0, 0, imageData.width, height);
+      }
+      
+      // 使用Worker处理
+      const workerCode = `
+        self.onmessage = function(e) {
+          const imageData = e.data.imageData;
+          const processingFunction = ${processingFunction.toString()};
+          const result = processingFunction(imageData);
+          self.postMessage({ result, index: e.data.index }, [result.data.buffer]);
+        }
+      `;
+      
+      const blob = new Blob([workerCode], { type: 'application/javascript' });
+      const workerUrl = URL.createObjectURL(blob);
+      const worker = new Worker(workerUrl);
+      
+      const promise = new Promise<{ result: ImageData, index: number }>((resolve) => {
+        worker.onmessage = function(e) {
+          resolve(e.data);
+          worker.terminate();
+          URL.revokeObjectURL(workerUrl);
+        };
+        
+        // 传输数据
+        worker.postMessage({ 
+          imageData: chunkImageData, 
+          index: i 
+        }, [chunkImageData.data.buffer]);
+      });
+      
+      promises.push(promise);
+    }
+    
+    // 等待所有Worker完成并组合结果
+    const results = await Promise.all(promises);
+    
+    // 按索引排序结果
+    results.sort((a, b) => a.index - b.index);
+    
+    // 将处理后的块绘制到结果canvas
+    for (let i = 0; i < results.length; i++) {
+      const { result } = results[i];
+      const tempCanvas = this.imageDataToCanvas(result);
+      
+      if (isWide) {
+        const startX = i * chunkSize;
+        resultCtx.drawImage(tempCanvas, startX, 0);
+      } else {
+        const startY = i * chunkSize;
+        resultCtx.drawImage(tempCanvas, 0, startY);
+      }
+    }
+    
+    return resultCtx.getImageData(0, 0, imageData.width, imageData.height);
+  }
 } 

package/src/utils/performance.ts

@@ -0,0 +1,208 @@
+/**
+ * @file 性能优化工具类
+ * @description 提供节流、防抖、缓存等性能优化功能
+ * @module PerformanceUtils
+ */
+
+/**
+ * 节流函数：限制函数在一定时间内只能执行一次
+ * 
+ * @param fn 需要节流的函数
+ * @param delay 延迟时间（毫秒）
+ * @returns 节流处理后的函数
+ */
+export function throttle<T extends (...args: any[]) => any>(
+  fn: T, 
+  delay: number
+): (...args: Parameters<T>) => void {
+  let lastCall = 0;
+  let timeoutId: number | null = null;
+  
+  return function(...args: Parameters<T>) {
+    const now = Date.now();
+    const remaining = delay - (now - lastCall);
+    
+    if (remaining <= 0) {
+      if (timeoutId) {
+        clearTimeout(timeoutId);
+        timeoutId = null;
+      }
+      lastCall = now;
+      fn.apply(this, args);
+    } else if (!timeoutId) {
+      timeoutId = window.setTimeout(() => {
+        lastCall = Date.now();
+        timeoutId = null;
+        fn.apply(this, args);
+      }, remaining);
+    }
+  };
+}
+
+/**
+ * 防抖函数：函数在最后一次调用后延迟指定时间执行
+ * 
+ * @param fn 需要防抖的函数
+ * @param delay 延迟时间（毫秒）
+ * @returns 防抖处理后的函数
+ */
+export function debounce<T extends (...args: any[]) => any>(
+  fn: T, 
+  delay: number
+): (...args: Parameters<T>) => void {
+  let timeoutId: number | null = null;
+  
+  return function(...args: Parameters<T>) {
+    if (timeoutId) {
+      clearTimeout(timeoutId);
+    }
+    
+    timeoutId = window.setTimeout(() => {
+      fn.apply(this, args);
+      timeoutId = null;
+    }, delay);
+  };
+}
+
+/**
+ * LRU缓存类 - 使用最近最少使用策略的缓存实现
+ */
+export class LRUCache<K, V> {
+  private cache = new Map<K, V>();
+  
+  /**
+   * 构造LRU缓存
+   * @param maxSize 缓存最大容量
+   */
+  constructor(private maxSize: number = 100) {}
+  
+  /**
+   * 获取缓存项
+   * @param key 缓存键
+   * @returns 缓存值或undefined
+   */
+  get(key: K): V | undefined {
+    if (!this.cache.has(key)) {
+      return undefined;
+    }
+    
+    // 获取值
+    const value = this.cache.get(key)!;
+    
+    // 将项移至最新位置（删除后重新添加）
+    this.cache.delete(key);
+    this.cache.set(key, value);
+    
+    return value;
+  }
+  
+  /**
+   * 设置缓存项
+   * @param key 缓存键
+   * @param value 缓存值
+   */
+  set(key: K, value: V): void {
+    // 如果键已存在，需要先删除
+    if (this.cache.has(key)) {
+      this.cache.delete(key);
+    }
+    
+    // 如果缓存已满，移除最老的项
+    if (this.cache.size >= this.maxSize) {
+      const oldestKey = this.cache.keys().next().value;
+      this.cache.delete(oldestKey);
+    }
+    
+    // 添加新项
+    this.cache.set(key, value);
+  }
+  
+  /**
+   * 删除缓存项
+   * @param key 缓存键
+   * @returns 是否成功删除
+   */
+  delete(key: K): boolean {
+    return this.cache.delete(key);
+  }
+  
+  /**
+   * 清空缓存
+   */
+  clear(): void {
+    this.cache.clear();
+  }
+  
+  /**
+   * 获取当前缓存大小
+   */
+  get size(): number {
+    return this.cache.size;
+  }
+  
+  /**
+   * 检查键是否存在
+   * @param key 缓存键
+   */
+  has(key: K): boolean {
+    return this.cache.has(key);
+  }
+}
+
+/**
+ * 图像指纹计算函数 - 用于检测相同或相似图像
+ * 
+ * @param imageData 图像数据
+ * @param size 指纹尺寸（默认8x8）
+ * @returns 图像指纹字符串
+ */
+export function calculateImageFingerprint(imageData: ImageData, size: number = 8): string {
+  // 1. 缩小图像到指定尺寸
+  const canvas = document.createElement('canvas');
+  canvas.width = size;
+  canvas.height = size;
+  const ctx = canvas.getContext('2d');
+  
+  if (!ctx) {
+    return '';
+  }
+  
+  // 创建一个临时canvas来绘制原始imageData
+  const tempCanvas = document.createElement('canvas');
+  tempCanvas.width = imageData.width;
+  tempCanvas.height = imageData.height;
+  const tempCtx = tempCanvas.getContext('2d');
+  
+  if (!tempCtx) {
+    return '';
+  }
+  
+  tempCtx.putImageData(imageData, 0, 0);
+  
+  // 缩小到目标尺寸
+  ctx.drawImage(tempCanvas, 0, 0, imageData.width, imageData.height, 0, 0, size, size);
+  
+  // 2. 转换为灰度
+  const smallImgData = ctx.getImageData(0, 0, size, size);
+  const grayValues = [];
+  
+  for (let i = 0; i < smallImgData.data.length; i += 4) {
+    const r = smallImgData.data[i];
+    const g = smallImgData.data[i + 1];
+    const b = smallImgData.data[i + 2];
+    // 转为灰度: 0.299r + 0.587g + 0.114b
+    const gray = Math.round(0.299 * r + 0.587 * g + 0.114 * b);
+    grayValues.push(gray);
+  }
+  
+  // 3. 计算平均值
+  const avg = grayValues.reduce((sum, val) => sum + val, 0) / grayValues.length;
+  
+  // 4. 比较每个像素与平均值，生成二进制指纹
+  let fingerprint = '';
+  for (const gray of grayValues) {
+    fingerprint += gray >= avg ? '1' : '0';
+  }
+  
+  return fingerprint;
+}