id-scanner-lib 1.3.2 → 1.3.3

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

@@ -2,6 +2,7 @@
  * @file 身份证防伪检测模块
  * @description 提供身份证防伪特征识别功能，区分真假身份证
  * @module AntiFakeDetector
+ * @version 1.3.2
  */
 
 import { ImageProcessor } from "../utils/image-processing"
@@ -184,27 +185,201 @@ export class AntiFakeDetector implements Disposable {
   private async detectUVInkFeatures(
     imageData: ImageData
   ): Promise<[string, boolean, number]> {
-    // 提取蓝色通道增强UV油墨可见度
-    const canvas = document.createElement("canvas")
-    canvas.width = imageData.width
-    canvas.height = imageData.height
-    const ctx = canvas.getContext("2d")
-
-    if (!ctx) {
-      return ["荧光油墨", false, 0]
+    // 在真实身份证上，荧光油墨会在特定反光条件下呈现特定颜色特征
+    // 在普通可见光下，我们分析蓝色和紫外色通道分布特征
+    
+    // 1. 提取蓝色通道并增强对比度
+    const blueChannel = this.extractColorChannel(imageData, 'blue');
+    
+    // 2. 分析蓝色通道的分布特征
+    const { peaks, variance } = this.analyzeChannelDistribution(blueChannel);
+    
+    // 3. 分析特定区域的颜色模式
+    const patternScore = this.detectUVColorPattern(imageData);
+    
+    // 4. 计算综合得分
+    // 特征分析：荧光油墨在蓝色通道通常有显著峰值，且分布更聚集
+    let score = 0;
+    
+    // 过多的峰值表明可能是真实身份证上的荧光特征
+    if (peaks > 3 && peaks < 10) {
+      score += 0.4;
     }
-
-    ctx.putImageData(imageData, 0, 0)
-
-    // 分析蓝色通道中的特定模式
-    // 实际实现中应使用更复杂的算法提取UV特征
-    // 这里使用模拟实现
-
-    // 模拟检测: 70%的概率检测到，置信度0.65-0.95
-    const detected = Math.random() > 0.3
-    const confidence = detected ? 0.65 + Math.random() * 0.3 : 0
-
-    return ["荧光油墨", detected, confidence]
+    
+    // 方差越大，表示颜色对比度越高，更可能有荧光特征
+    if (variance > 1000) {
+      score += 0.3;
+    }
+    
+    // 颜色模式得分
+    score += patternScore * 0.3;
+    
+    // 重要区域分析
+    // 身份证头像区域通常不应具有荧光特征
+    const hasPortraitAreaFeatures = this.analyzePortraitArea(imageData);
+    if (hasPortraitAreaFeatures) {
+      // 头像区域不应该有荧光特征，如果有可能是伪造的
+      score -= 0.2;
+    }
+    
+    // 求出最终分数并限制在[0,1]范围内
+    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);
+    
+    for (let i = 0; i < data.length; i += 4) {
+      const pixelIndex = i / 4;
+      channelData[pixelIndex] = data[i + channelOffset];
+    }
+    
+    return channelData;
+  }
+  
+  /**
+   * 分析颜色通道分布特征
+   * @param channelData 颜色通道数据
+   */
+  private analyzeChannelDistribution(channelData: Uint8ClampedArray): { peaks: number, variance: number } {
+    // 计算直方图
+    const histogram = new Array(256).fill(0);
+    for (let i = 0; i < channelData.length; i++) {
+      histogram[channelData[i]]++;
+    }
+    
+    // 平滑直方图以减少噪声
+    const smoothedHistogram = this.smoothHistogram(histogram, 3);
+    
+    // 计算峰值数量
+    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++;
+      }
+    }
+    
+    // 计算方差
+    let mean = 0;
+    for (let i = 0; i < channelData.length; i++) {
+      mean += channelData[i];
+    }
+    mean /= channelData.length;
+    
+    let variance = 0;
+    for (let i = 0; i < channelData.length; i++) {
+      variance += Math.pow(channelData[i] - mean, 2);
+    }
+    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);
+    
+    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++;
+      }
+      
+      result[i] = sum / count;
+    }
+    
+    return result;
+  }
+  
+  /**
+   * 检测图像中的荧光颜色模式
+   */
+  private detectUVColorPattern(imageData: ImageData): number {
+    // 分析特定组合颜色的出现频率，荧光油墨在可见光下也具有特定的颜色特征
+    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];
+      
+      // 检查是否是荧光油墨特有的颜色范围
+      // 这里使用简化的追踪条件，实际应用中应使用更复杂的颜色模型
+      if (b > 1.5 * r && b > 1.3 * g && b > 100) {
+        uvColorCount++;
+      }
+    }
+    
+    // 计算荧光颜色像素占比
+    const totalPixels = width * height;
+    const uvColorRatio = uvColorCount / totalPixels;
+    
+    // 对于真实身份证，荧光颜色的占比应该在一定范围内
+    // 如果占比过高或过低，可能是伪造的
+    const idealRatio = 0.05; // 理想占比
+    const deviation = Math.abs(uvColorRatio - idealRatio) / idealRatio;
+    
+    // 将差异转换为0-1的置信度分数
+    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;
+    
+    // 检查头像区域的荧光特征
+    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];
+          
+          // 使用与上面相同的荧光颜色检测标准
+          if (b > 1.5 * r && b > 1.3 * g && b > 100) {
+            uvFeatureCount++;
+          }
+          
+          totalPixels++;
+        }
+      }
+    }
+    
+    // 如果头像区域的荧光特征占比过高，可能是伪造的
+    return totalPixels > 0 && (uvFeatureCount / totalPixels) > 0.1;
   }
 
   /**
@@ -217,24 +392,230 @@ export class AntiFakeDetector implements Disposable {
   private async detectMicroText(
     imageData: ImageData
   ): Promise<[string, boolean, number]> {
-    // 应用边缘检测突出微缩文字
+    // 微缩文字检测 - 身份证上的微缩文字是重要的防伪特征
+    // 这些文字很小，但会呈现规则的线条和高频组件
+    
+    // 1. 转换图像为灰度图
     const grayscale = ImageProcessor.toGrayscale(
       new ImageData(
         new Uint8ClampedArray(imageData.data),
         imageData.width,
         imageData.height
       )
-    )
-
-    // 寻找特定的微缩文字模式
-    // 实际实现中应使用计算机视觉算法寻找微小规则文字模式
-    // 这里使用模拟实现
-
-    // 模拟检测: 80%的概率检测到，置信度0.7-0.95
-    const detected = Math.random() > 0.2
-    const confidence = detected ? 0.7 + Math.random() * 0.25 : 0
-
-    return ["微缩文字", detected, confidence]
+    );
+    
+    // 2. 执行边缘检测突出微缩文字
+    const edgeData = ImageProcessor.detectEdges(grayscale, 40); // 强化的边缘检测
+    
+    // 3. 分析频率特征 - 微缩文字呈现高频的边缘过渡
+    const frequencyFeatures = this.analyzeFrequencyFeatures(edgeData);
+    
+    // 4. 检测微缩文字的具体区域
+    const microTextRegions = this.detectMicroTextRegions(edgeData);
+    
+    // 5. 综合分析结果计算置信度
+    let score = 0;
+    
+    // 频率特征分数
+    score += frequencyFeatures.score * 0.6;
+    
+    // 区域特征分数
+    if (microTextRegions.count > 0) {
+      // 过多的区域也可能表示噪声，因此有一个最佳范围
+      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];
+  }
+  
+  /**
+   * 分析边缘图像的频率特征
+   * 微缩文字呈现高频的边缘过渡
+   */
+  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++;
+      }
+    }
+    
+    // 计算高频边缘分布
+    // 统计边缘过渡的变化频率
+    let highFreqTransitions = 0;
+    
+    // 检测行方向的边缘变化
+    for (let y = 0; y < height; y++) {
+      let prevEdge = false;
+      let transitions = 0;
+      
+      for (let x = 0; x < width; x++) {
+        const i = (y * width + x) * 4;
+        const isEdge = data[i] > 200;
+        
+        if (isEdge !== prevEdge) {
+          transitions++;
+          prevEdge = isEdge;
+        }
+      }
+      
+      // 每行的过渡频率
+      if (transitions > width * 0.1) { // 高频过渡行
+        highFreqTransitions++;
+      }
+    }
+    
+    // 计算列方向的边缘变化
+    let colHighFreqTransitions = 0;
+    for (let x = 0; x < width; x++) {
+      let prevEdge = false;
+      let transitions = 0;
+      
+      for (let y = 0; y < height; y++) {
+        const i = (y * width + x) * 4;
+        const isEdge = data[i] > 200;
+        
+        if (isEdge !== prevEdge) {
+          transitions++;
+          prevEdge = isEdge;
+        }
+      }
+      
+      // 每列的过渡频率
+      if (transitions > height * 0.1) { // 高频过渡列
+        colHighFreqTransitions++;
+      }
+    }
+    
+    // 综合计算高频特征比例
+    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 };
+  }
+  
+  /**
+   * 检测微缩文字区域
+   * 微缩文字通常呈现呈现规则的组合排列
+   */
+  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;
+        
+        // 如果是边缘像素且未访问过
+        if (data[i] > 200 && !visitedMap[idx]) {
+          // 使用深度优先搜索找到连通的边缘区域
+          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 (regionWidth > 5 && regionHeight > 5 && 
+                regionWidth < width * 0.2 && regionHeight < height * 0.2) {
+                
+              // 计算区域密度
+              const density = regionPoints.length / (regionWidth * regionHeight);
+              
+              // 检查并添加符合微缩文字特征的区域
+              if (density > 0.1 && density < 0.5) { // 合适的密度范围
+                regions.push({
+                  x: minX,
+                  y: minY,
+                  w: regionWidth,
+                  h: regionHeight
+                });
+              }
+            }
+          }
+        }
+      }
+    }
+    
+    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];
+    
+    // 起始点
+    stack.push({x: startX, y: startY});
+    visitedMap[startY * width + startX] = true;
+    
+    while (stack.length > 0) {
+      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];
+        
+        if (nx >= 0 && nx < width && ny >= 0 && ny < height) {
+          const nidx = ny * width + nx;
+          const ni = nidx * 4;
+          
+          if (data[ni] > 200 && !visitedMap[nidx]) {
+            stack.push({x: nx, y: ny});
+            visitedMap[nidx] = true;
+          }
+        }
+      }
+    }
+    
+    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);
+    }
+    
+    return [minX, minY, maxX, maxY];
   }
 
   /**

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);
+  }
 }