id-scanner-lib 1.6.7 → 1.7.0

package/src/modules/id-card/ocr-worker.ts

@@ -5,6 +5,7 @@
  */
 
 import { IDCardInfo, IDCardType } from './types';
+import { IDCardTextParser } from './id-card-text-parser';
 import { LoggerMessage } from 'tesseract.js';
 
 /**
@@ -57,7 +58,7 @@ export async function processOCRInWorker(
     const { data } = await worker.recognize(input.imageBase64);
 
     // 解析身份证信息
-    const idCardInfo = parseIDCardText(data.text);
+    const idCardInfo = IDCardTextParser.parse(data.text);
 
     // 释放Worker资源
     await worker.terminate();
@@ -74,186 +75,4 @@ export async function processOCRInWorker(
   }
 }
 
-/**
- * 解析身份证文本
- * @param text OCR识别的文本
- * @returns 解析后的身份证信息
- */
-function parseIDCardText(text: string): IDCardInfo {
-  const info: IDCardInfo = {};
-
-  // 预处理文本，清除多余空白
-  const processedText = text.replace(/\s+/g, ' ').trim();
-
-  // 解析身份证号码
-  const idNumberRegex = /(\d{17}[\dX])/;
-  const idNumberWithPrefixRegex = /公民身份号码[\s\:]*(\d{17}[\dX])/;
-
-  const basicMatch = processedText.match(idNumberRegex);
-  const prefixMatch = processedText.match(idNumberWithPrefixRegex);
-
-  if (prefixMatch && prefixMatch[1]) {
-    info.idNumber = prefixMatch[1];
-  } else if (basicMatch && basicMatch[1]) {
-    info.idNumber = basicMatch[1];
-  }
-
-  // 解析姓名
-  const nameWithLabelRegex = /姓名[\s\:]*([一-龥]{2,4})/;
-  const nameMatch = processedText.match(nameWithLabelRegex);
-
-  if (nameMatch && nameMatch[1]) {
-    info.name = nameMatch[1].trim();
-  } else {
-    // 备用方案：查找短行且内容全是汉字
-    const lines = processedText.split('\n').filter(line => line.trim());
-  for (const line of lines) {
-    if (
-        line.length >= 2 &&
-        line.length <= 5 &&
-        /^[一-龥]+$/.test(line) &&
-        !/性别|民族|住址|公民|签发|有效/.test(line)
-    ) {
-        info.name = line.trim();
-        break;
-      }
-    }
-  }
-
-  // 解析性别和民族
-  const genderAndNationalityRegex = /性别[\s\:]*([男女])[\s ]*民族[\s\:]*([一-龥]+族)/;
-  const genderOnlyRegex = /性别[\s\:]*([男女])/;
-  const nationalityOnlyRegex = /民族[\s\:]*([一-龥]+族)/;
-
-  const genderNationalityMatch = processedText.match(genderAndNationalityRegex);
-  const genderOnlyMatch = processedText.match(genderOnlyRegex);
-  const nationalityOnlyMatch = processedText.match(nationalityOnlyRegex);
-
-  if (genderNationalityMatch) {
-    info.gender = genderNationalityMatch[1];
-    info.ethnicity = genderNationalityMatch[2];
-  } else {
-    if (genderOnlyMatch) info.gender = genderOnlyMatch[1];
-    if (nationalityOnlyMatch) info.ethnicity = nationalityOnlyMatch[1];
-  }
-
-  // 根据内容判断身份证类型
-  if (processedText.includes('出生') || processedText.includes('公民身份号码')) {
-    info.type = IDCardType.FRONT; // 确保类型为枚举值而不是字符串
-  } else if (processedText.includes('签发机关') || processedText.includes('有效期')) {
-    info.type = IDCardType.BACK; // 确保类型为枚举值而不是字符串
-  }
-
-  // 解析出生日期
-  const birthDateRegex1 = /出生[\s\:]*(\d{4})年(\d{1,2})月(\d{1,2})[日号]/;
-  const birthDateRegex2 = /出生[\s\:]*(\d{4})[-\/\.](\d{1,2})[-\/\.](\d{1,2})/;
-  const birthDateRegex3 = /出生日期[\s\:]*(\d{4})[-\/\.\u5e74](\d{1,2})[-\/\.\u6708](\d{1,2})[日号]?/;
-
-  const birthDateMatch =
-    processedText.match(birthDateRegex1) ||
-    processedText.match(birthDateRegex2) ||
-    processedText.match(birthDateRegex3);
-
-  if (!birthDateMatch && info.idNumber && info.idNumber.length === 18) {
-    const year = info.idNumber.substring(6, 10);
-    const month = info.idNumber.substring(10, 12);
-    const day = info.idNumber.substring(12, 14);
-    info.birthDate = `${year}-${month}-${day}`;
-  } else if (birthDateMatch) {
-    const year = birthDateMatch[1];
-    const month = birthDateMatch[2].padStart(2, '0');
-    const day = birthDateMatch[3].padStart(2, '0');
-    info.birthDate = `${year}-${month}-${day}`;
-  }
-
-  // 解析地址
-  const addressRegex1 = /住址[\s\:]*([\s\S]*?)(?=公民身份|出生|性别|签发)/;
-  const addressRegex2 = /住址[\s\:]*([一-龥a-zA-Z0-9\s\.\-]+)/;
-
-  const addressMatch =
-    processedText.match(addressRegex1) || processedText.match(addressRegex2);
 
-  if (addressMatch && addressMatch[1]) {
-    info.address = addressMatch[1]
-      .replace(/\s+/g, '')
-      .replace(/\n/g, '')
-      .trim();
-
-    if (info.address.length > 70) {
-      info.address = info.address.substring(0, 70);
-    }
-
-    if (!/[一-龥]/.test(info.address)) {
-      info.address = '';
-    }
-  }
-
-  // 解析签发机关
-  const authorityRegex1 = /签发机关[\s\:]*([\s\S]*?)(?=有效|公民|出生|\d{8}|$)/;
-  const authorityRegex2 = /签发机关[\s\:]*([一-龥\s]+)/;
-
-  const authorityMatch =
-    processedText.match(authorityRegex1) ||
-    processedText.match(authorityRegex2);
-
-  if (authorityMatch && authorityMatch[1]) {
-    info.issueAuthority = authorityMatch[1]
-      .replace(/\s+/g, '')
-      .replace(/\n/g, '')
-      .trim();
-  }
-
-  // 解析有效期限
-  const validPeriodRegex1 = /有效期限[\s\:]*(\d{4}[-\.\u5e74\s]\d{1,2}[-\.\u6708\s]\d{1,2}[日\s]*)[-\s]*(至|-)[-\s]*(\d{4}[-\.\u5e74\s]\d{1,2}[-\.\u6708\s]\d{1,2}[日]*|[永久长期]*)/;
-  const validPeriodRegex2 = /有效期限[\s\:]*(\d{8})[-\s]*(至|-)[-\s]*(\d{8}|[永久长期]*)/;
-
-  const validPeriodMatch =
-    processedText.match(validPeriodRegex1) ||
-    processedText.match(validPeriodRegex2);
-
-  if (validPeriodMatch) {
-    if (validPeriodMatch[1] && validPeriodMatch[3]) {
-      const startDate = formatDateString(validPeriodMatch[1]);
-      const endDate = /\d/.test(validPeriodMatch[3])
-        ? formatDateString(validPeriodMatch[3])
-        : '长期有效';
-
-      info.validFrom = startDate;
-      info.validTo = endDate;
-      info.validPeriod = `${startDate}-${endDate}`;
-    } else {
-      info.validPeriod = validPeriodMatch[0].replace('有效期限', '').trim();
-    }
-  }
-
-  return info;
-}
-
-/**
- * 格式化日期字符串
- * @param dateStr 原始日期字符串
- * @returns 格式化后的日期字符串
- */
-function formatDateString(dateStr: string): string {
-  // 提取年月日
-  const dateMatch = dateStr.match(
-    /(\d{4})[-\.\u5e74\s]*(\d{1,2})[-\.\u6708\s]*(\d{1,2})[日]*/
-  );
-  if (dateMatch) {
-    const year = dateMatch[1];
-    const month = dateMatch[2].padStart(2, '0');
-    const day = dateMatch[3].padStart(2, '0');
-    return `${year}-${month}-${day}`;
-  }
-
-  // 纯数字格式如 20220101
-  if (/^\d{8}$/.test(dateStr)) {
-    const year = dateStr.substring(0, 4);
-    const month = dateStr.substring(4, 6);
-    const day = dateStr.substring(6, 8);
-    return `${year}-${month}-${day}`;
-  }
-
-  // 无法格式化，返回原始字符串
-  return dateStr;
-}

package/src/utils/canvas-pool.ts

@@ -0,0 +1,273 @@
+/**
+ * @file Canvas 对象池
+ * @description 提供 Canvas 元素的复用机制，减少内存分配和 GC 压力
+ * @module utils/canvas-pool
+ */
+
+/**
+ * Canvas 池条目
+ */
+interface CanvasPoolItem {
+  /** Canvas 元素 */
+  canvas: HTMLCanvasElement;
+  /** Canvas 2D 上下文 */
+  context: CanvasRenderingContext2D;
+  /** 是否正在使用 */
+  inUse: boolean;
+  /** 最近使用时间戳 */
+  lastUsed: number;
+  /** Canvas 尺寸标识 */
+  sizeKey: string;
+}
+
+/**
+ * Canvas 对象池
+ *
+ * 复用 Canvas 元素，避免频繁创建和销毁导致的内存抖动
+ *
+ * @example
+ * ```typescript
+ * const pool = CanvasPool.getInstance();
+ * const { canvas, context } = pool.acquire(100, 200);
+ * // 使用 canvas 进行绘制...
+ * pool.release(canvas);
+ * ```
+ */
+export class CanvasPool {
+  /** 单例实例 */
+  private static instance: CanvasPool | null = null;
+
+  /** Canvas 池存储 */
+  private pool: Map<string, CanvasPoolItem[]> = new Map();
+
+  /** 已借出的 Canvas */
+  private borrowed: Map<HTMLCanvasElement, CanvasPoolItem> = new Map();
+
+  /** 最大池大小（每个尺寸） */
+  private maxPoolSize: number = 4;
+
+  /** Canvas 尺寸容差（允许一定范围的尺寸复用） */
+  private sizeTolerance: number = 10;
+
+  /**
+   * 获取单例实例
+   */
+  public static getInstance(): CanvasPool {
+    if (!CanvasPool.instance) {
+      CanvasPool.instance = new CanvasPool();
+    }
+    return CanvasPool.instance;
+  }
+
+  /**
+   * 重置单例实例（主要用于测试）
+   */
+  public static resetInstance(): void {
+    if (CanvasPool.instance) {
+      CanvasPool.instance.dispose();
+      CanvasPool.instance = null;
+    }
+  }
+
+  /**
+   * 私有构造函数
+   */
+  private constructor() {
+    // 页面卸载前清理
+    if (typeof window !== 'undefined') {
+      window.addEventListener('beforeunload', () => this.dispose());
+    }
+  }
+
+  /**
+   * 生成尺寸键
+   * @param width 宽度
+   * @param height 高度
+   */
+  private getSizeKey(width: number, height: number): string {
+    return `${width}x${height}`;
+  }
+
+  /**
+   * 查找匹配的尺寸键（考虑容差）
+   * @param width 宽度
+   * @param height 高度
+   */
+  private findMatchingSizeKey(width: number, height: number): string | null {
+    for (const [key, items] of this.pool.entries()) {
+      const [w, h] = key.split('x').map(Number);
+      if (Math.abs(w - width) <= this.sizeTolerance &&
+          Math.abs(h - height) <= this.sizeTolerance) {
+        // 找到可用的
+        const available = items.filter(item => !item.inUse);
+        if (available.length > 0) {
+          return key;
+        }
+      }
+    }
+    return null;
+  }
+
+  /**
+   * 从池中获取 Canvas
+   *
+   * @param width  宽度
+   * @param height 高度
+   * @returns Canvas 和其上下文
+   */
+  public acquire(width: number, height: number): {
+    canvas: HTMLCanvasElement;
+    context: CanvasRenderingContext2D;
+  } {
+    // 先尝试精确匹配
+    let sizeKey = this.getSizeKey(width, height);
+    let items = this.pool.get(sizeKey);
+
+    // 如果没有精确匹配，尝试模糊匹配
+    if (!items || items.every(item => item.inUse)) {
+      const matchedKey = this.findMatchingSizeKey(width, height);
+      if (matchedKey) {
+        sizeKey = matchedKey;
+        items = this.pool.get(sizeKey);
+      }
+    }
+
+    // 如果没有可用的，创建一个新的
+    if (!items || items.every(item => item.inUse)) {
+      const canvas = document.createElement('canvas');
+      canvas.width = width;
+      canvas.height = height;
+      const context = canvas.getContext('2d')!;
+
+      const item: CanvasPoolItem = {
+        canvas,
+        context,
+        inUse: true,
+        lastUsed: Date.now(),
+        sizeKey: this.getSizeKey(width, height)
+      };
+
+      // 如果池已满，移除最老的
+      if (!items) {
+        items = [];
+        this.pool.set(sizeKey, items);
+      } else if (items.length >= this.maxPoolSize) {
+        // 找到最老的未使用项并移除
+        let oldestIdx = 0;
+        let oldestTime = Infinity;
+        items.forEach((item, idx) => {
+          if (!item.inUse && item.lastUsed < oldestTime) {
+            oldestTime = item.lastUsed;
+            oldestIdx = idx;
+          }
+        });
+        const removed = items.splice(oldestIdx, 1)[0];
+        this.borrowed.delete(removed.canvas);
+      }
+
+      items.push(item);
+      this.borrowed.set(canvas, item);
+
+      return { canvas, context };
+    }
+
+    // 找到一个空闲的
+    const available = items.find(item => !item.inUse)!;
+    available.inUse = true;
+    available.lastUsed = Date.now();
+
+    // 如果尺寸变化，更新 canvas
+    if (available.canvas.width !== width || available.canvas.height !== height) {
+      available.canvas.width = width;
+      available.canvas.height = height;
+      available.sizeKey = sizeKey;
+    }
+
+    // 清除之前的上下文状态
+    available.context.setTransform(1, 0, 0, 1, 0, 0);
+    available.context.clearRect(0, 0, width, height);
+
+    this.borrowed.set(available.canvas, available);
+
+    return { canvas: available.canvas, context: available.context };
+  }
+
+  /**
+   * 释放 Canvas 回池中
+   *
+   * @param canvas 要释放的 Canvas
+   */
+  public release(canvas: HTMLCanvasElement): void {
+    const item = this.borrowed.get(canvas);
+    if (!item) {
+      // 不属于我们管理的 Canvas，忽略
+      return;
+    }
+
+    item.inUse = false;
+    item.lastUsed = Date.now();
+    this.borrowed.delete(canvas);
+  }
+
+  /**
+   * 批量释放所有借出的 Canvas
+   */
+  public releaseAll(): void {
+    for (const [, item] of this.borrowed) {
+      item.inUse = false;
+      item.lastUsed = Date.now();
+    }
+    this.borrowed.clear();
+  }
+
+  /**
+   * 预热池（预创建指定尺寸的 Canvas）
+   *
+   * @param sizes 尺寸数组，每项为 [width, height]
+   */
+  public warmup(sizes: Array<[number, number]>): void {
+    for (const [width, height] of sizes) {
+      this.acquire(width, height);
+      // 立即释放，让它们进入池中
+      const sizeKey = this.getSizeKey(width, height);
+      const items = this.pool.get(sizeKey);
+      if (items && items.length > 0) {
+        const item = items[items.length - 1];
+        item.inUse = false;
+        this.borrowed.delete(item.canvas);
+      }
+    }
+  }
+
+  /**
+   * 获取池统计信息
+   */
+  public getStats(): {
+    totalItems: number;
+    borrowedCount: number;
+    poolSizes: Record<string, { total: number; available: number }>;
+  } {
+    let totalItems = 0;
+    let borrowedCount = 0;
+    const poolSizes: Record<string, { total: number; available: number }> = {};
+
+    for (const [key, items] of this.pool.entries()) {
+      totalItems += items.length;
+      borrowedCount += items.filter(i => i.inUse).length;
+      poolSizes[key] = {
+        total: items.length,
+        available: items.filter(i => !i.inUse).length
+      };
+    }
+
+    return { totalItems, borrowedCount, poolSizes };
+  }
+
+  /**
+   * 清理并释放所有资源
+   */
+  public dispose(): void {
+    this.pool.clear();
+    this.borrowed.clear();
+  }
+}

package/src/utils/edge-detector.ts

@@ -0,0 +1,232 @@
+/**
+ * @file 边缘检测器
+ * @description 提供边缘检测算法（Sobel、Canny等）
+ * @module utils/edge-detector
+ */
+
+/**
+ * 边缘检测器类
+ * 提供各种边缘检测算法用于图像处理
+ */
+export class EdgeDetector {
+  /**
+   * 使用Sobel算子进行边缘检测
+   * @param imageData 灰度图像数据
+   * @param threshold 边缘阈值，默认为30
+   * @returns 检测到边缘的图像数据
+   */
+  static detectEdges(imageData: ImageData, threshold: number = 30): ImageData {
+    const grayscaleImage = this.toGrayscale(new ImageData(new Uint8ClampedArray(imageData.data), imageData.width, imageData.height));
+    const width = grayscaleImage.width;
+    const height = grayscaleImage.height;
+    const inputData = grayscaleImage.data;
+    const outputData = new Uint8ClampedArray(inputData.length);
+    const sobelX = [-1, 0, 1, -2, 0, 2, -1, 0, 1];
+    const sobelY = [-1, -2, -1, 0, 0, 0, 1, 2, 1];
+    
+    for (let y = 1; y < height - 1; y++) {
+      for (let x = 1; x < width - 1; x++) {
+        let gx = 0, gy = 0;
+        for (let ky = -1; ky <= 1; ky++) {
+          for (let kx = -1; kx <= 1; kx++) {
+            const pixelPos = ((y + ky) * width + (x + kx)) * 4;
+            const pixelVal = inputData[pixelPos];
+            const kernelIdx = (ky + 1) * 3 + (kx + 1);
+            gx += pixelVal * sobelX[kernelIdx];
+            gy += pixelVal * sobelY[kernelIdx];
+          }
+        }
+        let magnitude = Math.sqrt(gx * gx + gy * gy);
+        magnitude = magnitude > threshold ? 255 : 0;
+        const pos = (y * width + x) * 4;
+        outputData[pos] = outputData[pos + 1] = outputData[pos + 2] = magnitude;
+        outputData[pos + 3] = 255;
+      }
+    }
+    
+    // 处理边缘
+    for (let i = 0; i < width * 4; i++) {
+      outputData[i] = 0;
+      outputData[(height - 1) * width * 4 + i] = 0;
+    }
+    for (let i = 0; i < height; i++) {
+      const leftPos = i * width * 4;
+      const rightPos = (i * width + width - 1) * 4;
+      for (let j = 0; j < 4; j++) {
+        outputData[leftPos + j] = 0;
+        outputData[rightPos + j] = 0;
+      }
+    }
+    
+    return new ImageData(outputData, width, height);
+  }
+
+  /**
+   * 卡尼-德里奇边缘检测
+   */
+  static cannyEdgeDetection(imageData: ImageData, lowThreshold: number = 20, highThreshold: number = 50): ImageData {
+    const grayscaleImage = this.toGrayscale(new ImageData(new Uint8ClampedArray(imageData.data), imageData.width, imageData.height));
+    const blurredImage = this.gaussianBlur(grayscaleImage, 1.5);
+    const { gradientMagnitude, gradientDirection } = this.computeGradients(blurredImage);
+    const nonMaxSuppressed = this.nonMaxSuppression(gradientMagnitude, gradientDirection, blurredImage.width, blurredImage.height);
+    const thresholdResult = this.hysteresisThresholding(nonMaxSuppressed, blurredImage.width, blurredImage.height, lowThreshold, highThreshold);
+    
+    const outputData = new Uint8ClampedArray(imageData.data.length);
+    for (let i = 0; i < thresholdResult.length; i++) {
+      const pos = i * 4;
+      const value = thresholdResult[i] ? 255 : 0;
+      outputData[pos] = outputData[pos + 1] = outputData[pos + 2] = value;
+      outputData[pos + 3] = 255;
+    }
+    return new ImageData(outputData, blurredImage.width, blurredImage.height);
+  }
+
+  private static toGrayscale(imageData: ImageData): ImageData {
+    const srcData = imageData.data;
+    const destData = new Uint8ClampedArray(srcData);
+    for (let i = 0; i < srcData.length; i += 4) {
+      const gray = srcData[i] * 0.3 + srcData[i + 1] * 0.59 + srcData[i + 2] * 0.11;
+      destData[i] = destData[i + 1] = destData[i + 2] = gray;
+      destData[i + 3] = srcData[i + 3];
+    }
+    return new ImageData(destData, imageData.width, imageData.height);
+  }
+
+  private static gaussianBlur(imageData: ImageData, sigma: number = 1.5): ImageData {
+    const width = imageData.width, height = imageData.height;
+    const inputData = imageData.data, outputData = new Uint8ClampedArray(inputData.length);
+    const kernelSize = Math.max(3, Math.floor(sigma * 3) * 2 + 1);
+    const halfKernel = Math.floor(kernelSize / 2);
+    const kernel = this.generateGaussianKernel(kernelSize, sigma);
+    
+    for (let y = 0; y < height; y++) {
+      for (let x = 0; x < width; x++) {
+        let sum = 0, weightSum = 0;
+        for (let ky = -halfKernel; ky <= halfKernel; ky++) {
+          for (let kx = -halfKernel; kx <= halfKernel; kx++) {
+            const pixelY = Math.min(Math.max(y + ky, 0), height - 1);
+            const pixelX = Math.min(Math.max(x + kx, 0), width - 1);
+            const pixelPos = (pixelY * width + pixelX) * 4;
+            const kernelY = ky + halfKernel, kernelX = kx + halfKernel;
+            const weight = kernel[kernelY * kernelSize + kernelX];
+            sum += inputData[pixelPos] * weight;
+            weightSum += weight;
+          }
+        }
+        const pos = (y * width + x) * 4;
+        const value = Math.round(sum / weightSum);
+        outputData[pos] = outputData[pos + 1] = outputData[pos + 2] = value;
+        outputData[pos + 3] = 255;
+      }
+    }
+    return new ImageData(outputData, width, height);
+  }
+
+  private static generateGaussianKernel(size: number, sigma: number): number[] {
+    const kernel = new Array(size * size);
+    const center = Math.floor(size / 2);
+    let sum = 0;
+    for (let y = 0; y < size; y++) {
+      for (let x = 0; x < size; x++) {
+        const distance = Math.sqrt((x - center) ** 2 + (y - center) ** 2);
+        kernel[y * size + x] = Math.exp(-(distance ** 2) / (2 * sigma ** 2));
+        sum += kernel[y * size + x];
+      }
+    }
+    for (let i = 0; i < kernel.length; i++) kernel[i] /= sum;
+    return kernel;
+  }
+
+  private static computeGradients(imageData: ImageData): { gradientMagnitude: number[], gradientDirection: number[] } {
+    const width = imageData.width, height = imageData.height;
+    const inputData = imageData.data;
+    const gradientMagnitude = new Array(width * height);
+    const gradientDirection = new Array(width * height);
+    const sobelX = [-1, 0, 1, -2, 0, 2, -1, 0, 1];
+    const sobelY = [-1, -2, -1, 0, 0, 0, 1, 2, 1];
+    
+    for (let y = 1; y < height - 1; y++) {
+      for (let x = 1; x < width - 1; x++) {
+        let gx = 0, gy = 0;
+        for (let ky = -1; ky <= 1; ky++) {
+          for (let kx = -1; kx <= 1; kx++) {
+            const pixelPos = ((y + ky) * width + (x + kx)) * 4;
+            const pixelVal = inputData[pixelPos];
+            const kernelIdx = (ky + 1) * 3 + (kx + 1);
+            gx += pixelVal * sobelX[kernelIdx];
+            gy += pixelVal * sobelY[kernelIdx];
+          }
+        }
+        const idx = y * width + x;
+        gradientMagnitude[idx] = Math.sqrt(gx * gx + gy * gy);
+        gradientDirection[idx] = Math.atan2(gy, gx);
+      }
+    }
+    return { gradientMagnitude, gradientDirection };
+  }
+
+  private static nonMaxSuppression(gradientMagnitude: number[], gradientDirection: number[], width: number, height: number): number[] {
+    const result = new Array(width * height).fill(0);
+    for (let y = 1; y < height - 1; y++) {
+      for (let x = 1; x < width - 1; x++) {
+        const idx = y * width + x;
+        const magnitude = gradientMagnitude[idx];
+        const direction = gradientDirection[idx];
+        const degrees = (direction * 180 / Math.PI + 180) % 180;
+        let neighbor1Idx: number, neighbor2Idx: number;
+        
+        if ((degrees >= 0 && degrees < 22.5) || (degrees >= 157.5 && degrees <= 180)) {
+          neighbor1Idx = idx - 1; neighbor2Idx = idx + 1;
+        } else if (degrees >= 22.5 && degrees < 67.5) {
+          neighbor1Idx = (y - 1) * width + (x + 1); neighbor2Idx = (y + 1) * width + (x - 1);
+        } else if (degrees >= 67.5 && degrees < 112.5) {
+          neighbor1Idx = (y - 1) * width + x; neighbor2Idx = (y + 1) * width + x;
+        } else {
+          neighbor1Idx = (y - 1) * width + (x - 1); neighbor2Idx = (y + 1) * width + (x + 1);
+        }
+        
+        if (magnitude >= gradientMagnitude[neighbor1Idx] && magnitude >= gradientMagnitude[neighbor2Idx]) {
+          result[idx] = magnitude;
+        }
+      }
+    }
+    return result;
+  }
+
+  private static hysteresisThresholding(nonMaxSuppressed: number[], width: number, height: number, lowThreshold: number, highThreshold: number): boolean[] {
+    const result = new Array(width * height).fill(false);
+    const visited = new Array(width * height).fill(false);
+    const stack: number[] = [];
+    
+    for (let i = 0; i < nonMaxSuppressed.length; i++) {
+      if (nonMaxSuppressed[i] >= highThreshold) {
+        result[i] = true;
+        stack.push(i);
+        visited[i] = true;
+      }
+    }
+    
+    const dx = [-1, 0, 1, -1, 1, -1, 0, 1];
+    const dy = [-1, -1, -1, 0, 0, 1, 1, 1];
+    
+    while (stack.length > 0) {
+      const currentIdx = stack.pop()!;
+      const currentX = currentIdx % width;
+      const currentY = Math.floor(currentIdx / width);
+      
+      for (let i = 0; i < 8; i++) {
+        const newX = currentX + dx[i];
+        const newY = currentY + dy[i];
+        if (newX >= 0 && newX < width && newY >= 0 && newY < height) {
+          const newIdx = newY * width + newX;
+          if (!visited[newIdx] && nonMaxSuppressed[newIdx] >= lowThreshold) {
+            result[newIdx] = true;
+            stack.push(newIdx);
+            visited[newIdx] = true;
+          }
+        }
+      }
+    }
+    return result;
+  }
+}