id-scanner-lib 1.1.1 → 1.2.2

package/dist/id-scanner-core.js

@@ -10471,6 +10471,166 @@
 	        }
 	        return imageData;
 	    }
+	    /**
+	     * 降低图像分辨率以提高处理速度
+	     *
+	     * 对于OCR和图像分析，降低分辨率可以在保持识别率的同时大幅提升处理速度
+	     *
+	     * @param {ImageData} imageData - 原图像数据
+	     * @param {number} [maxDimension=1000] - 目标最大尺寸（宽或高）
+	     * @returns {ImageData} 处理后的图像数据
+	     */
+	    static downsampleForProcessing(imageData, maxDimension = 1000) {
+	        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) {
+	        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) {
+	        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, processingFunction, chunks = 4) {
+	        // 如果不支持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((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);
+	    }
 	}
 
 	/**