id-scanner-lib 1.3.0 → 1.3.3

package/README.md

@@ -3,6 +3,8 @@
 纯前端实现的TypeScript身份证与二维码识别库，无需后端支持，所有处理均在浏览器端完成。结合高性能图像处理与OCR技术，提供完整的识别解决方案。
 
 [![NPM Version](https://img.shields.io/npm/v/id-scanner-lib.svg)](https://www.npmjs.com/package/id-scanner-lib)
+[![GitHub Stars](https://img.shields.io/github/stars/agions/id-scanner-lib.svg?style=social)](https://github.com/agions/id-scanner-lib)
+[![Bundle Size](https://img.shields.io/bundlephobia/minzip/id-scanner-lib)](https://bundlephobia.com/package/id-scanner-lib)
 [![License](https://img.shields.io/npm/l/id-scanner-lib.svg)](https://github.com/agions/id-scanner-lib/blob/master/LICENSE)
 
 ## 技术特性
@@ -11,6 +13,7 @@
 - **二维码扫描**：基于jsQR实现高精度二维码识别与解码
 - **条形码识别**：支持EAN-13、CODE-128等常见一维码格式
 - **身份证OCR**：基于Tesseract.js的优化OCR引擎，精确提取身份证信息
+- **身份证防伪检测**：检测多种防伪特征，有效识别伪造证件
 - **图像处理优化**：内置多种图像预处理算法，提高识别率
 - **支持多种数据源**：摄像头实时视频流、图片文件、URL、Base64等
 - **高效缓存机制**：内置LRU缓存，避免重复识别，提升性能
@@ -25,9 +28,10 @@
 | 二维码识别 | 50-150ms     | >98%   | 取决于图像质量   |
 | 条形码识别 | 70-200ms     | >95%   | 支持多种格式     |
 | 身份证OCR  | 300-800ms    | >90%   | 优化后的识别速度 |
+| 防伪检测   | 100-200ms    | >85%   | 多特征综合分析   |
 | 图像处理   | 20-100ms     | -      | 视处理操作而定   |
 
-## 最新版本 (v1.3.0)
+## 最新版本 (v1.3.2)
 
 - **图像处理引擎升级**：
   - 增强的图像锐化算法，提高低光照环境下的识别率
@@ -41,30 +45,129 @@
   - 批量图像处理API
   - 内置图像压缩功能
   - 一体化演示组件
+  - **身份证防伪检测**：识别多种防伪特征，检测伪造证件
+    - 支持荧光油墨、微缩文字、光变图案等5种防伪特征检测
+    - 基于多特征综合评分，提供置信度评估
+    - 缓存机制提高重复检测性能
 - **架构改进**：
   - 资源自动释放机制
   - 更精细的模块划分
   - 增强的错误处理
 
+## 版本路线图
+
+### v1.4.0：人脸比对与活体检测
+
+- **人脸比对模块**：
+  - 身份证照片与现场采集照片的比对功能
+  - 基于深度学习的人脸特征提取与分析
+  - 提供相似度评分与置信度
+- **活体检测**：
+  - 眨眼、张嘴等动作检测防止照片欺骗
+  - 基于光线反射的3D检测技术
+  - 多帧分析提高检测准确率
+- **安全增强**：
+  - 本地处理所有数据，保护隐私
+  - 结果加密存储选项
+  - 合规性验证工具
+
+### v1.5.0：多证件类型支持
+
+- **护照识别**：
+  - MRZ码（机读区）解析
+  - 多国护照模板适配
+  - 芯片信息读取（ePassport支持）
+- **驾驶证识别**：
+  - 驾驶证OCR识别
+  - 驾驶资格与限制条件解析
+  - 国际驾照支持
+- **营业执照识别**：
+  - 企业信息提取
+  - 统一社会信用代码验证
+  - 经营范围解析
+- **银行卡识别**：
+  - 卡号、有效期识别
+  - 银行标识解析
+  - BIN码验证
+
+### v1.6.0：UI/UX改进与组件库升级
+
+- **现代化UI框架**：
+  - 基于Web Components的组件系统
+  - 自适应扫描界面
+  - 多主题支持（含暗色模式）
+- **交互体验优化**：
+  - 实时扫描引导框
+  - 智能对焦与取景提示
+  - 证件边缘自动检测与校正
+- **可访问性支持**：
+  - 屏幕阅读器兼容
+  - 键盘导航
+  - 多语言本地化
+- **动效与反馈**：
+  - 平滑过渡动画
+  - 触觉反馈（移动设备）
+  - 声音反馈与语音提示
+
+### v1.7.0：性能与架构优化
+
+- **WebAssembly实现**：
+  - 核心图像处理算法WASM化
+  - 性能提升3-5倍
+  - 更低的CPU占用
+- **离线支持**：
+  - 完整离线运行能力
+  - 基于IndexedDB的本地缓存
+  - Service Worker支持
+- **微前端集成**：
+  - React/Vue/Angular专用组件
+  - 更简单的集成API
+  - TypeScript类型增强
+- **渐进式加载**：
+  - 核心功能快速加载
+  - 按需延迟加载附加模块
+  - 预测性加载提高响应速度
+
+### v2.0.0：企业级解决方案
+
+- **云端协同验证**：
+  - 可选云端验证API
+  - 本地与云端结果比对
+  - 多级安全验证
+- **高级分析功能**：
+  - 证件使用统计与分析
+  - 风险评估模型
+  - 异常检测系统
+- **行业解决方案包**：
+  - 金融行业KYC流程集成
+  - 酒店/零售快速登记系统
+  - 政务/安防高安全性验证
+- **企业级管理功能**：
+  - 多租户支持
+  - 批量处理队列
+  - 完整审计日志
+
 ## 系统架构
 
 ```
-┌─────────────────────────────────────────────────────────────┐
+┌────────────────────────────────────────────────────────────┐
 │                       IDScanner 主模块                      │
 ├─────────────┬─────────────────┬────────────────────────────┤
 │  QRScanner  │  BarcodeScanner │        IDCardDetector      │
 ├─────────────┴─────────────────┴────────────────────────────┤
-│                 Camera (视频流捕获与处理)                    │
-└─────────────────────────────────────────────────────────────┘
+│                 Camera (视频流捕获与处理)                     │
+└────────────────────────────────────────────────────────────┘
                            ▲
                            │
                            ▼
-┌─────────────────────────────────────────────────────────────┐
+┌────────────────────────────────────────────────────────────┐
 │                   核心处理引擎                               │
 ├─────────────────┬─────────────────┬────────────────────────┤
 │  OCRProcessor   │  DataExtractor  │     ImageProcessor     │
-│  (文字识别)      │  (数据提取验证)  │     (图像预处理)       │
-└─────────────────┴─────────────────┴────────────────────────┘
+│  (文字识别)      │  (数据提取验证)   │    (图像预处理)          │
+├─────────────────┴─────────────────┴────────────────────────┤
+│              AntiFakeDetector (身份证防伪检测)                │
+└────────────────────────────────────────────────────────────┘
 ```
 
 ## 安装与使用
@@ -79,22 +182,22 @@ npm install id-scanner-lib --save
 
 ```html
 <!-- 生产环境 (压缩版) -->
-<script src="https://cdn.jsdelivr.net/npm/id-scanner-lib@1.3.0/dist/id-scanner.min.js"></script>
+<script src="https://cdn.jsdelivr.net/npm/id-scanner-lib@1.3.1/dist/id-scanner.min.js"></script>
 
 <!-- 开发环境 (未压缩) -->
-<script src="https://cdn.jsdelivr.net/npm/id-scanner-lib@1.3.0/dist/id-scanner.js"></script>
+<script src="https://cdn.jsdelivr.net/npm/id-scanner-lib@1.3.1/dist/id-scanner.js"></script>
 ```
 
 ## 包体积优化
 
-v1.3.0版本通过代码分割和Tree-shaking极大地优化了包体积：
+v1.3.1版本通过代码分割和Tree-shaking极大地优化了包体积：
 
 | 模块            | 大小 (gzip) | 说明             |
 | --------------- | ----------- | ---------------- |
-| 完整包(min.js)  | 25KB        | 包含所有功能     |
-| 核心包(min.js)  | 90KB        | 基础功能，无OCR  |
-| OCR模块(min.js) | 14KB        | 仅文字识别       |
-| QR模块(min.js)  | 6KB         | 仅二维码识别     |
+| 完整包(min.js)  | 93KB        | 包含所有功能     |
+| 核心包(min.js)  | 186KB       | 基础功能，无OCR  |
+| OCR模块(min.js) | 70KB        | 仅文字识别       |
+| QR模块(min.js)  | 60KB        | 仅二维码识别     |
 | ESM模块         | 各模块更小  | 支持Tree-shaking |
 
 ## 最佳实践：按需引入
@@ -107,7 +210,8 @@ import { IDScanner } from 'id-scanner-lib';
 
 const scanner = new IDScanner({
   onQRCodeScanned: (result) => console.log('扫描结果:', result),
-  onIDCardScanned: (info) => console.log('身份证信息:', info)
+  onIDCardScanned: (info) => console.log('身份证信息:', info),
+  onAntiFakeDetected: (result) => console.log('防伪检测结果:', result)
 });
 ```
 
@@ -176,12 +280,57 @@ document.getElementById('fileInput').addEventListener('change', async (e) => {
     // 处理身份证图像
     const idInfo = await scanner.processIDCardImage(compressed);
     console.log('身份证信息:', idInfo);
+  
+    // 检查防伪检测结果
+    if (idInfo.antiFakeResult) {
+      console.log('防伪检测结果:', idInfo.antiFakeResult);
+      if (idInfo.antiFakeResult.isAuthentic) {
+        console.log('证件验证通过');
+      } else {
+        console.log('警告：可能为伪造证件');
+      }
+    }
   } catch (error) {
     console.error('处理失败:', error);
   }
 });
 ```
 
+### 身份证防伪检测
+
+```javascript
+import { IDScanner } from 'id-scanner-lib';
+
+const scanner = new IDScanner({
+  // 防伪检测结果回调
+  onAntiFakeDetected: (result) => {
+    if (result.isAuthentic) {
+      console.log('身份证验证通过，检测到的防伪特征：', result.detectedFeatures);
+    } else {
+      console.log('警告：可能是伪造证件！', result.message);
+      // 显示安全提示
+      document.getElementById('warning').style.display = 'block';
+    }
+  }
+});
+
+await scanner.initialize();
+
+// 方法1：单独进行防伪检测
+const antiFakeResult = await scanner.detectIDCardAntiFake(idCardImage);
+console.log('防伪检测结果：', antiFakeResult);
+console.log('检测置信度：', antiFakeResult.confidence);
+
+// 方法2：身份证识别时自动进行防伪检测
+const idInfo = await scanner.processIDCardImage(idCardImage);
+// 防伪检测结果包含在返回的信息中
+if (idInfo.antiFakeResult && idInfo.antiFakeResult.isAuthentic) {
+  // 身份证真实，继续处理
+} else {
+  // 提示可能为伪造证件
+}
+```
+
 ### 使用内置演示组件
 
 ```javascript
@@ -243,6 +392,23 @@ OCR引擎基于Tesseract.js进行了一系列优化：
 3. **多线程处理**：使用Web Worker避免主线程阻塞
 4. **结果缓存**：相同图像指纹不重复计算，提高响应速度
 
+### 身份证防伪检测技术
+
+防伪检测模块能识别身份证中的多种防伪特征：
+
+1. **荧光油墨特征**：检测特定区域的荧光反应模式
+2. **微缩文字**：识别证件上的微小文字，伪造证件难以复制
+3. **光变图案**：检测特定角度下的光变效果
+4. **雕刻凹印**：通过纹理检测特定的凹印模式
+5. **隐形图案**：识别证件上的幽灵图像和隐形水印
+
+算法结合多种图像处理技术：
+
+- 特定光谱通道提取与分析
+- 边缘检测与微文字模式识别
+- 对比度与光照调整突出隐形特征
+- 自适应阈值处理增强识别准确度
+
 ### 图像增强算法
 
 针对不同场景提供最佳图像处理策略：
@@ -276,24 +442,55 @@ OCR引擎基于Tesseract.js进行了一系列优化：
 
 ## 应用场景
 
-- **网上银行身份验证**：快速验证用户身份信息
-- **酒店登记系统**：自动录入住客信息
+- **网上银行身份验证**：快速验证用户身份信息，检测伪造证件
+- **酒店登记系统**：自动录入住客信息并验证证件真伪
 - **自助服务终端**：无需人工，自动处理证件信息
-- **企业内部系统**：员工证件信息采集
+- **企业内部系统**：员工证件信息采集与验证
 - **活动签到系统**：快速扫码签到与证件登记
 
-## 后续开发计划
+## 发布指南
+
+### 发布到NPM
+
+```bash
+# 1. 确保版本号正确
+npm version [patch|minor|major]
+
+# 2. 构建生产版本
+npm run build:prod
+
+# 3. 发布到NPM
+npm publish
 
-- [ ] 身份证防伪识别功能
-- [ ] 护照和其他证件支持
-- [ ] 离线模型支持
-- [ ] 人脸比对功能
-- [ ] WebAssembly优化
+# 4. 生成标签
+git push origin --tags
+```
+
+### 发布到GitHub
+
+```bash
+# 1. 提交代码变更
+git add .
+git commit -m "发布 v1.x.x"
+
+# 2. 推送到GitHub
+git push origin main
+
+# 3. 创建Release
+# 访问 https://github.com/agions/id-scanner-lib/releases/new
+# 选择对应的标签，填写Release说明
+```
 
 ## 贡献指南
 
 欢迎贡献代码、报告问题或提出新功能建议。请通过GitHub Issues或Pull Requests参与项目。
 
+1. Fork项目仓库
+2. 创建你的特性分支 (`git checkout -b feature/amazing-feature`)
+3. 提交你的更改 (`git commit -m '添加一些很棒的功能'`)
+4. 推送到分支 (`git push origin feature/amazing-feature`)
+5. 打开Pull Request
+
 ## 许可证
 
 本项目采用MIT许可证。详见[LICENSE](LICENSE)文件。
@@ -303,5 +500,6 @@ OCR引擎基于Tesseract.js进行了一系列优化：
 <p align="center">
   <a href="https://github.com/agions/id-scanner-lib">GitHub</a> • 
   <a href="https://www.npmjs.com/package/id-scanner-lib">NPM</a> • 
-  <a href="https://github.com/agions/id-scanner-lib/issues">Issues</a>
+  <a href="https://github.com/agions/id-scanner-lib/issues">Issues</a> •
+  <a href="https://github.com/agions/id-scanner-lib/releases">Releases</a>
 </p>

package/dist/id-scanner-core.esm.js

@@ -10368,6 +10368,7 @@ function _mergeNamespaces(e,t){return t.forEach((function(t){t&&"string"!=typeof
  * @file 图像处理工具类
  * @description 提供图像预处理功能，用于提高OCR识别率
  * @module ImageProcessor
+ * @version 1.3.2
  */
 /**
  * 图像处理工具类
@@ -10767,6 +10768,278 @@ class ImageProcessor {
         // 获取新的ImageData
         return ctx.getImageData(0, 0, newWidth, newHeight);
     }
+    /**
+     * 边缘检测算法，用于识别图像中的边缘
+     * 基于Sobel算子实现
+     *
+     * @param imageData 原始图像数据，应已转为灰度图
+     * @param threshold 边缘阈值，默认为30
+     * @returns 检测到边缘的图像数据
+     */
+    static detectEdges(imageData, threshold = 30) {
+        // 确保输入图像是灰度图
+        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);
+        // Sobel算子 - 水平和垂直方向
+        const sobelX = [-1, 0, 1, -2, 0, 2, -1, 0, 1];
+        const sobelY = [-1, -2, -1, 0, 0, 0, 1, 2, 1];
+        // 对每个像素应用Sobel算子
+        for (let y = 1; y < height - 1; y++) {
+            for (let x = 1; x < width - 1; x++) {
+                let gx = 0;
+                let 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);
+    }
+    /**
+     * 卡尼-德里奇边缘检测
+     * 相比Sobel更精确的边缘检测算法
+     *
+     * @param imageData 灰度图像数据
+     * @param lowThreshold 低阈值
+     * @param highThreshold 高阈值
+     * @returns 边缘检测结果
+     */
+    static cannyEdgeDetection(imageData, lowThreshold = 20, highThreshold = 50) {
+        const grayscaleImage = this.toGrayscale(new ImageData(new Uint8ClampedArray(imageData.data), imageData.width, imageData.height));
+        // 1. 高斯模糊
+        const blurredImage = this.gaussianBlur(grayscaleImage, 1.5);
+        // 2. 使用Sobel算子计算梯度
+        const { gradientMagnitude, gradientDirection } = this.computeGradients(blurredImage);
+        // 3. 非极大值抛弃
+        const nonMaxSuppressed = this.nonMaxSuppression(gradientMagnitude, gradientDirection, blurredImage.width, blurredImage.height);
+        // 4. 双阈值处理
+        const thresholdResult = this.hysteresisThresholding(nonMaxSuppressed, blurredImage.width, blurredImage.height, lowThreshold, highThreshold);
+        // 创建输出图像
+        const outputData = new Uint8ClampedArray(imageData.data.length);
+        // 将结果转换为ImageData
+        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);
+    }
+    /**
+     * 高斯模糊
+     */
+    static gaussianBlur(imageData, sigma = 1.5) {
+        const width = imageData.width;
+        const height = imageData.height;
+        const inputData = imageData.data;
+        const 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;
+                let 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;
+                        const 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);
+    }
+    /**
+     * 生成高斯核
+     */
+    static generateGaussianKernel(size, sigma) {
+        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);
+                const value = Math.exp(-(distance ** 2) / (2 * sigma ** 2));
+                kernel[y * size + x] = value;
+                sum += value;
+            }
+        }
+        // 归一化
+        for (let i = 0; i < kernel.length; i++) {
+            kernel[i] /= sum;
+        }
+        return kernel;
+    }
+    /**
+     * 计算梯度强度和方向
+     */
+    static computeGradients(imageData) {
+        const width = imageData.width;
+        const height = imageData.height;
+        const inputData = imageData.data;
+        const gradientMagnitude = new Array(width * height);
+        const gradientDirection = new Array(width * height);
+        // Sobel算子
+        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;
+                let 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);
+            }
+        }
+        // 处理边界
+        for (let y = 0; y < height; y++) {
+            for (let x = 0; x < width; x++) {
+                if (y === 0 || y === height - 1 || x === 0 || x === width - 1) {
+                    const idx = y * width + x;
+                    gradientMagnitude[idx] = 0;
+                    gradientDirection[idx] = 0;
+                }
+            }
+        }
+        return { gradientMagnitude, gradientDirection };
+    }
+    /**
+     * 非极大值抛弃
+     */
+    static nonMaxSuppression(gradientMagnitude, gradientDirection, width, height) {
+        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, neighbor2Idx;
+                // 将方向量化为四个方向: 0°, 45°, 90°, 135°
+                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) {
+                    // 45度方向
+                    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 {
+                    // 135度方向
+                    neighbor1Idx = (y - 1) * width + (x - 1);
+                    neighbor2Idx = (y + 1) * width + (x + 1);
+                }
+                // 检查当前像素是否是最大值
+                if (magnitude >= gradientMagnitude[neighbor1Idx] &&
+                    magnitude >= gradientMagnitude[neighbor2Idx]) {
+                    result[idx] = magnitude;
+                }
+            }
+        }
+        return result;
+    }
+    /**
+     * 双阈值处理
+     */
+    static hysteresisThresholding(nonMaxSuppressed, width, height, lowThreshold, highThreshold) {
+        const result = new Array(width * height).fill(false);
+        const visited = new Array(width * height).fill(false);
+        const stack = [];
+        // 标记强边缘点
+        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);
+            // 检查88个相邻方向
+            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;
+    }
 }
 
 /**