id-scanner-lib 1.3.3 → 1.5.0

package/src/{id-recognition → modules/id-card}/anti-fake-detector.ts

@@ -5,9 +5,9 @@
  * @version 1.3.2
  */
 
-import { ImageProcessor } from "../utils/image-processing"
-import { LRUCache, calculateImageFingerprint } from "../utils/performance"
-import { Disposable } from "../utils/resource-manager"
+import { ImageProcessor } from "../../utils/image-processing"
+import { LRUCache, calculateImageFingerprint } from "../../utils/performance"
+import { Disposable } from "../../utils/resource-manager"
 
 /**
  * 防伪检测结果
@@ -27,7 +27,7 @@ export interface AntiFakeDetectorOptions {
   sensitivity?: number // 敏感度 (0-1)，值越高越严格
   enableCache?: boolean // 是否启用缓存
   cacheSize?: number // 缓存大小
-  logger?: (message: any) => void // 日志记录器
+  logger?: (message: string) => void // 日志记录器，message 类型设为 string
 }
 
 /**
@@ -187,199 +187,212 @@ export class AntiFakeDetector implements Disposable {
   ): Promise<[string, boolean, number]> {
     // 在真实身份证上，荧光油墨会在特定反光条件下呈现特定颜色特征
     // 在普通可见光下，我们分析蓝色和紫外色通道分布特征
-    
+
     // 1. 提取蓝色通道并增强对比度
-    const blueChannel = this.extractColorChannel(imageData, 'blue');
-    
+    const blueChannel = this.extractColorChannel(imageData, "blue")
+
     // 2. 分析蓝色通道的分布特征
-    const { peaks, variance } = this.analyzeChannelDistribution(blueChannel);
-    
+    const { peaks, variance } = this.analyzeChannelDistribution(blueChannel)
+
     // 3. 分析特定区域的颜色模式
-    const patternScore = this.detectUVColorPattern(imageData);
-    
+    const patternScore = this.detectUVColorPattern(imageData)
+
     // 4. 计算综合得分
     // 特征分析：荧光油墨在蓝色通道通常有显著峰值，且分布更聚集
-    let score = 0;
-    
+    let score = 0
+
     // 过多的峰值表明可能是真实身份证上的荧光特征
     if (peaks > 3 && peaks < 10) {
-      score += 0.4;
+      score += 0.4
     }
-    
+
     // 方差越大，表示颜色对比度越高，更可能有荧光特征
     if (variance > 1000) {
-      score += 0.3;
+      score += 0.3
     }
-    
+
     // 颜色模式得分
-    score += patternScore * 0.3;
-    
+    score += patternScore * 0.3
+
     // 重要区域分析
     // 身份证头像区域通常不应具有荧光特征
-    const hasPortraitAreaFeatures = this.analyzePortraitArea(imageData);
+    const hasPortraitAreaFeatures = this.analyzePortraitArea(imageData)
     if (hasPortraitAreaFeatures) {
       // 头像区域不应该有荧光特征，如果有可能是伪造的
-      score -= 0.2;
+      score -= 0.2
     }
-    
+
     // 求出最终分数并限制在[0,1]范围内
-    const confidence = Math.max(0, Math.min(1, score));
-    const detected = confidence > 0.55;
-    
-    return ["荧光油墨", detected, confidence];
+    const confidence = Math.max(0, Math.min(1, score))
+    const detected = confidence > 0.55
+
+    return ["荧光油墨", detected, confidence]
   }
-  
+
   /**
    * 从图像数据中提取指定颜色通道
    * @param imageData 原始图像数据
    * @param channel 通道名称（red, green, blue）
    */
-  private extractColorChannel(imageData: ImageData, channel: 'red' | 'green' | 'blue'): Uint8ClampedArray {
-    const { data, width, height } = imageData;
-    const channelOffset = channel === 'red' ? 0 : channel === 'green' ? 1 : 2;
-    const channelData = new Uint8ClampedArray(width * height);
-    
+  private extractColorChannel(
+    imageData: ImageData,
+    channel: "red" | "green" | "blue"
+  ): Uint8ClampedArray {
+    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];
+      const pixelIndex = i / 4
+      channelData[pixelIndex] = data[i + channelOffset]
     }
-    
-    return channelData;
+
+    return channelData
   }
-  
+
   /**
    * 分析颜色通道分布特征
    * @param channelData 颜色通道数据
    */
-  private analyzeChannelDistribution(channelData: Uint8ClampedArray): { peaks: number, variance: number } {
+  private analyzeChannelDistribution(channelData: Uint8ClampedArray): {
+    peaks: number
+    variance: number
+  } {
     // 计算直方图
-    const histogram = new Array(256).fill(0);
+    const histogram = new Array(256).fill(0)
     for (let i = 0; i < channelData.length; i++) {
-      histogram[channelData[i]]++;
+      histogram[channelData[i]]++
     }
-    
+
     // 平滑直方图以减少噪声
-    const smoothedHistogram = this.smoothHistogram(histogram, 3);
-    
+    const smoothedHistogram = this.smoothHistogram(histogram, 3)
+
     // 计算峰值数量
-    let peaks = 0;
+    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++;
+      if (
+        smoothedHistogram[i] > smoothedHistogram[i - 1] &&
+        smoothedHistogram[i] > smoothedHistogram[i + 1] &&
+        smoothedHistogram[i] > channelData.length * 0.01
+      ) {
+        // 只计算显著峰值
+        peaks++
       }
     }
-    
+
     // 计算方差
-    let mean = 0;
+    let mean = 0
     for (let i = 0; i < channelData.length; i++) {
-      mean += channelData[i];
+      mean += channelData[i]
     }
-    mean /= channelData.length;
-    
-    let variance = 0;
+    mean /= channelData.length
+
+    let variance = 0
     for (let i = 0; i < channelData.length; i++) {
-      variance += Math.pow(channelData[i] - mean, 2);
+      variance += Math.pow(channelData[i] - mean, 2)
     }
-    variance /= channelData.length;
-    
-    return { peaks, variance };
+    variance /= channelData.length
+
+    return { peaks, variance }
   }
-  
+
   /**
    * 平滑直方图以减少噪声
    */
   private smoothHistogram(histogram: number[], windowSize: number): number[] {
-    const result = new Array(histogram.length).fill(0);
-    const halfWindow = Math.floor(windowSize / 2);
-    
+    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++;
+      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;
+
+      result[i] = sum / count
     }
-    
-    return result;
+
+    return result
   }
-  
+
   /**
    * 检测图像中的荧光颜色模式
    */
   private detectUVColorPattern(imageData: ImageData): number {
-    // 分析特定组合颜色的出现频率，荧光油墨在可见光下也具有特定的颜色特征
-    const { data, width, height } = imageData;
-    let uvColorCount = 0;
-    
+    // 分析特定组合颜色的出现频率，荧光油墨在可见光下也有特定的颜色特征
+    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];
-      
+      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++;
+        uvColorCount++
       }
     }
-    
+
     // 计算荧光颜色像素占比
-    const totalPixels = width * height;
-    const uvColorRatio = uvColorCount / totalPixels;
-    
+    const totalPixels = width * height
+    const uvColorRatio = uvColorCount / totalPixels
+
     // 对于真实身份证，荧光颜色的占比应该在一定范围内
     // 如果占比过高或过低，可能是伪造的
-    const idealRatio = 0.05; // 理想占比
-    const deviation = Math.abs(uvColorRatio - idealRatio) / idealRatio;
-    
+    const idealRatio = 0.05 // 理想占比
+    const deviation = Math.abs(uvColorRatio - idealRatio) / idealRatio
+
     // 将差异转换为0-1的置信度分数
-    return Math.max(0, 1 - Math.min(1, deviation * 2));
+    return Math.max(0, 1 - Math.min(1, deviation * 2))
   }
-  
+
   /**
    * 分析头像区域是否存在荧光特征
    * 这个方法用于检测伪造的身份证，因为头像区域不应该有荧光特征
    */
   private analyzePortraitArea(imageData: ImageData): boolean {
     // 假设头像区域大约占据图片右上方四分之一的区域
-    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;
-    
+    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];
-          
+          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++;
+            uvFeatureCount++
           }
-          
-          totalPixels++;
+
+          totalPixels++
         }
       }
     }
-    
+
     // 如果头像区域的荧光特征占比过高，可能是伪造的
-    return totalPixels > 0 && (uvFeatureCount / totalPixels) > 0.1;
+    return totalPixels > 0 && uvFeatureCount / totalPixels > 0.1
   }
 
   /**
@@ -394,7 +407,7 @@ export class AntiFakeDetector implements Disposable {
   ): Promise<[string, boolean, number]> {
     // 微缩文字检测 - 身份证上的微缩文字是重要的防伪特征
     // 这些文字很小，但会呈现规则的线条和高频组件
-    
+
     // 1. 转换图像为灰度图
     const grayscale = ImageProcessor.toGrayscale(
       new ImageData(
@@ -402,220 +415,241 @@ export class AntiFakeDetector implements Disposable {
         imageData.width,
         imageData.height
       )
-    );
-    
+    )
+
     // 2. 执行边缘检测突出微缩文字
-    const edgeData = ImageProcessor.detectEdges(grayscale, 40); // 强化的边缘检测
-    
+    const edgeData = ImageProcessor.detectEdges(grayscale, 40) // 强化的边缘检测
+
     // 3. 分析频率特征 - 微缩文字呈现高频的边缘过渡
-    const frequencyFeatures = this.analyzeFrequencyFeatures(edgeData);
-    
+    const frequencyFeatures = this.analyzeFrequencyFeatures(edgeData)
+
     // 4. 检测微缩文字的具体区域
-    const microTextRegions = this.detectMicroTextRegions(edgeData);
-    
+    const microTextRegions = this.detectMicroTextRegions(edgeData)
+
     // 5. 综合分析结果计算置信度
-    let score = 0;
-    
+    let score = 0
+
     // 频率特征分数
-    score += frequencyFeatures.score * 0.6;
-    
+    score += frequencyFeatures.score * 0.6
+
     // 区域特征分数
     if (microTextRegions.count > 0) {
       // 过多的区域也可能表示噪声，因此有一个最佳范围
-      const normalizedCount = Math.min(microTextRegions.count, 5) / 5;
-      score += normalizedCount * 0.4;
+      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];
+    const confidence = Math.max(0, Math.min(1, score))
+    const detected = confidence > 0.5
+
+    return ["微缩文字", detected, confidence]
   }
-  
+
   /**
    * 分析边缘图像的频率特征
    * 微缩文字呈现高频的边缘过渡
    */
-  private analyzeFrequencyFeatures(edgeData: ImageData): { score: number, highFreqRatio: number } {
-    const { data, width, height } = edgeData;
-    let edgeCount = 0;
-    let totalPixels = width * height;
-    
+  private analyzeFrequencyFeatures(edgeData: ImageData): {
+    score: number
+    highFreqRatio: number
+  } {
+    const { data, width, height } = edgeData
+    let edgeCount = 0
+    let totalPixels = width * height
+
     // 计算边缘像素的数量
     for (let i = 0; i < data.length; i += 4) {
-      if (data[i] > 200) { // 大于阈值的边缘像素
-        edgeCount++;
+      if (data[i] > 200) {
+        // 大于阈值的边缘像素
+        edgeCount++
       }
     }
-    
+
     // 计算高频边缘分布
     // 统计边缘过渡的变化频率
-    let highFreqTransitions = 0;
-    
+    let highFreqTransitions = 0
+
     // 检测行方向的边缘变化
     for (let y = 0; y < height; y++) {
-      let prevEdge = false;
-      let transitions = 0;
-      
+      let prevEdge = false
+      let transitions = 0
+
       for (let x = 0; x < width; x++) {
-        const i = (y * width + x) * 4;
-        const isEdge = data[i] > 200;
-        
+        const i = (y * width + x) * 4
+        const isEdge = data[i] > 200
+
         if (isEdge !== prevEdge) {
-          transitions++;
-          prevEdge = isEdge;
+          transitions++
+          prevEdge = isEdge
         }
       }
-      
+
       // 每行的过渡频率
-      if (transitions > width * 0.1) { // 高频过渡行
-        highFreqTransitions++;
+      if (transitions > width * 0.1) {
+        // 高频过渡行
+        highFreqTransitions++
       }
     }
-    
+
     // 计算列方向的边缘变化
-    let colHighFreqTransitions = 0;
+    let colHighFreqTransitions = 0
     for (let x = 0; x < width; x++) {
-      let prevEdge = false;
-      let transitions = 0;
-      
+      let prevEdge = false
+      let transitions = 0
+
       for (let y = 0; y < height; y++) {
-        const i = (y * width + x) * 4;
-        const isEdge = data[i] > 200;
-        
+        const i = (y * width + x) * 4
+        const isEdge = data[i] > 200
+
         if (isEdge !== prevEdge) {
-          transitions++;
-          prevEdge = isEdge;
+          transitions++
+          prevEdge = isEdge
         }
       }
-      
+
       // 每列的过渡频率
-      if (transitions > height * 0.1) { // 高频过渡列
-        colHighFreqTransitions++;
+      if (transitions > height * 0.1) {
+        // 高频过渡列
+        colHighFreqTransitions++
       }
     }
-    
+
     // 综合计算高频特征比例
-    const rowHighFreqRatio = highFreqTransitions / height;
-    const colHighFreqRatio = colHighFreqTransitions / width;
-    const highFreqRatio = (rowHighFreqRatio + colHighFreqRatio) / 2;
-    
+    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 };
+    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 }
   }
-  
+
   /**
    * 检测微缩文字区域
    * 微缩文字通常呈现呈现规则的组合排列
    */
-  private detectMicroTextRegions(edgeData: ImageData): { count: number, regions: Array<{x: number, y: number, w: number, h: number}> } {
-    const { data, width, height } = edgeData;
-    const visitedMap = new Array(width * height).fill(false);
-    const regions: Array<{x: number, y: number, w: number, h: number}> = [];
-    
+  private detectMicroTextRegions(edgeData: ImageData): {
+    count: number
+    regions: Array<{ x: number; y: number; w: number; h: number }>
+  } {
+    const { data, width, height } = edgeData
+    const visitedMap = new Array(width * height).fill(false)
+    const regions: Array<{ x: number; y: number; w: number; h: number }> = []
+
     // 使用满足条件的连通区域寻找微缩文字区域
     for (let y = 0; y < height; y++) {
       for (let x = 0; x < width; x++) {
-        const idx = y * width + x;
-        const i = idx * 4;
-        
+        const idx = y * width + x
+        const i = idx * 4
+
         // 如果是边缘像素且未访问过
         if (data[i] > 200 && !visitedMap[idx]) {
           // 使用深度优先搜索找到连通的边缘区域
-          const regionPoints = this.floodFillEdge(edgeData, x, y, visitedMap);
-          
+          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 (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) {
-                
+            if (
+              regionWidth > 5 &&
+              regionHeight > 5 &&
+              regionWidth < width * 0.2 &&
+              regionHeight < height * 0.2
+            ) {
               // 计算区域密度
-              const density = regionPoints.length / (regionWidth * regionHeight);
-              
+              const density = regionPoints.length / (regionWidth * regionHeight)
+
               // 检查并添加符合微缩文字特征的区域
-              if (density > 0.1 && density < 0.5) { // 合适的密度范围
+              if (density > 0.1 && density < 0.5) {
+                // 合适的密度范围
                 regions.push({
                   x: minX,
                   y: minY,
                   w: regionWidth,
-                  h: regionHeight
-                });
+                  h: regionHeight,
+                })
               }
             }
           }
         }
       }
     }
-    
-    return { count: regions.length, regions };
+
+    return { count: regions.length, regions }
   }
-  
+
   /**
    * 深度优先搜索连通的边缘区域
    */
-  private floodFillEdge(edgeData: ImageData, startX: number, startY: number, visitedMap: boolean[]): Array<{x: number, y: number}> {
-    const { data, width, height } = edgeData;
-    const stack: Array<{x: number, y: number}> = [];
-    const points: Array<{x: number, y: number}> = [];
-    const dx = [-1, 0, 1, -1, 1, -1, 0, 1];
-    const dy = [-1, -1, -1, 0, 0, 1, 1, 1];
-    
+  private floodFillEdge(
+    edgeData: ImageData,
+    startX: number,
+    startY: number,
+    visitedMap: boolean[]
+  ): Array<{ x: number; y: number }> {
+    const { data, width, height } = edgeData
+    const stack: Array<{ x: number; y: number }> = []
+    const points: Array<{ x: number; y: number }> = []
+    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;
-    
+    stack.push({ x: startX, y: startY })
+    visitedMap[startY * width + startX] = true
+
     while (stack.length > 0) {
-      const {x, y} = stack.pop()!;
-      points.push({x, y});
-      
+      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];
-        
+        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;
-          
+          const nidx = ny * width + nx
+          const ni = nidx * 4
+
           if (data[ni] > 200 && !visitedMap[nidx]) {
-            stack.push({x: nx, y: ny});
-            visitedMap[nidx] = true;
+            stack.push({ x: nx, y: ny })
+            visitedMap[nidx] = true
           }
         }
       }
     }
-    
-    return points;
+
+    return points
   }
-  
+
   /**
    * 获取点集的外接矩形
    */
-  private getBoundingBox(points: Array<{x: number, y: number}>): [number, number, number, number] {
-    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);
+  private getBoundingBox(
+    points: Array<{ x: number; y: number }>
+  ): [number, number, number, number] {
+    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];
+
+    return [minX, minY, maxX, maxY]
   }
 
   /**