rn-opencv-doc-perspective-correction 1.0.9 → 1.0.12

package/dist/index.d.ts

@@ -2,6 +2,12 @@ export type Point = {
     x: number;
     y: number;
 };
+/**
+ * Gợi ý phương thức OCR nên dùng dựa trên phân tích màu sắc.
+ * 'G' = ML Kit (nhiều màu, ảnh thẻ, màu sắc phong phú)
+ * 'S' = Tesseract (ít màu, bản scan, giấy trắng)
+ */
+export type OcrMethodHint = 'G' | 'S';
 export declare class DocumentScanner {
     private static getDistance;
     private static sortCorners;
@@ -11,4 +17,18 @@ export declare class DocumentScanner {
      * Xoay ảnh 90, -90 hoặc 180 độ
      */
     static rotateImage(imageBase64: string, angle: 90 | -90 | 180): string | undefined;
+    /**
+     * Phân tích độ phức tạp màu sắc để gợi ý phương thức OCR phù hợp.
+     *
+     * - Nếu corners phát hiện thành công → crop vùng tài liệu và phân tích vùng đó
+     * - Nếu không có corners (phát hiện thất bại) → phân tích toàn bộ ảnh
+     * - Dùng không gian màu Lab, đo độ lệch chuẩn kênh a* (xanh↔đỏ) và b* (lam↔vàng)
+     * - stdA + stdB > threshold → nhiều màu sắc → 'G' (ML Kit, phù hợp thẻ, ảnh màu)
+     * - stdA + stdB ≤ threshold → ít màu sắc → 'S' (Tesseract, phù hợp giấy trắng, bản scan)
+     *
+     * @param imageBase64 Ảnh gốc base64 JPEG
+     * @param corners 4 góc tài liệu đã phát hiện (tuỳ chọn)
+     * @param colorThreshold Ngưỡng phân biệt (mặc định 18.0, điều chỉnh nếu cần tinh chỉnh)
+     */
+    static analyzeColorComplexity(imageBase64: string, corners?: Point[], colorThreshold?: number): OcrMethodHint;
 }

package/dist/index.js

@@ -28,18 +28,14 @@ class DocumentScanner {
             src = react_native_fast_opencv_1.OpenCV.base64ToMat(imageBase64);
             gray = react_native_fast_opencv_1.OpenCV.createObject(react_native_fast_opencv_1.ObjectType.Mat, 0, 0, react_native_fast_opencv_1.DataTypes.CV_8U);
             blurred = react_native_fast_opencv_1.OpenCV.createObject(react_native_fast_opencv_1.ObjectType.Mat, 0, 0, react_native_fast_opencv_1.DataTypes.CV_8U);
-            edges = react_native_fast_opencv_1.OpenCV.createObject(react_native_fast_opencv_1.ObjectType.Mat, 0, 0, react_native_fast_opencv_1.DataTypes.CV_8U); // This will hold the threshold output
+            edges = react_native_fast_opencv_1.OpenCV.createObject(react_native_fast_opencv_1.ObjectType.Mat, 0, 0, react_native_fast_opencv_1.DataTypes.CV_8U);
             react_native_fast_opencv_1.OpenCV.invoke('cvtColor', src, gray, react_native_fast_opencv_1.ColorConversionCodes.COLOR_BGR2GRAY);
             const ksize = react_native_fast_opencv_1.OpenCV.createObject(react_native_fast_opencv_1.ObjectType.Size, 5, 5);
             react_native_fast_opencv_1.OpenCV.invoke('GaussianBlur', gray, blurred, ksize, 0);
-            // Python uses: cv2.threshold(blurred, 0, 255, cv2.THRESH_BINARY + cv2.THRESH_OTSU)
-            // THRESH_BINARY = 0
-            // THRESH_OTSU = 8
             // THRESH_BINARY + THRESH_OTSU = 8
             react_native_fast_opencv_1.OpenCV.invoke('threshold', blurred, edges, 0, 255, 8);
             contoursObj = react_native_fast_opencv_1.OpenCV.createObject(react_native_fast_opencv_1.ObjectType.MatVector);
             hierarchyObj = react_native_fast_opencv_1.OpenCV.createObject(react_native_fast_opencv_1.ObjectType.Mat, 0, 0, react_native_fast_opencv_1.DataTypes.CV_8U);
-            // Using RETR_EXTERNAL similar to the Python script for outer contours
             react_native_fast_opencv_1.OpenCV.invoke('findContoursWithHierarchy', edges, contoursObj, hierarchyObj, 0 /* RETR_EXTERNAL */, 2 /* CHAIN_APPROX_SIMPLE */);
             const contoursJS = react_native_fast_opencv_1.OpenCV.toJSValue(contoursObj);
             const contoursArray = (contoursJS === null || contoursJS === void 0 ? void 0 : contoursJS.array) || [];
@@ -47,20 +43,17 @@ class DocumentScanner {
             if (contoursSize === 0) {
                 return undefined;
             }
-            // First pass: extract all areas to sort them and minimize JSI calls
             let contourMetrics = [];
             for (let i = 0; i < contoursSize; i++) {
                 const contour = react_native_fast_opencv_1.OpenCV.copyObjectFromVector(contoursObj, i);
                 const areaObj = react_native_fast_opencv_1.OpenCV.invoke('contourArea', contour);
                 const area = areaObj ? areaObj.value : 0;
-                if (area > 5000) { // filter very small artifacts
+                if (area > 5000) {
                     contourMetrics.push({ index: i, area, contour });
                 }
             }
-            // Sort contours by area in descending order
             contourMetrics.sort((a, b) => b.area - a.area);
             let largestPoly = undefined;
-            // Second pass: only check approxPolyDP for the largest ones
             for (let i = 0; i < contourMetrics.length; i++) {
                 const metric = contourMetrics[i];
                 const contour = metric.contour;
@@ -71,7 +64,7 @@ class DocumentScanner {
                 const approxJS = react_native_fast_opencv_1.OpenCV.toJSValue(approx);
                 if (approxJS && approxJS.array && approxJS.array.length === 4) {
                     largestPoly = approxJS.array;
-                    break; // Stop at the first 4-point polygon like python script
+                    break;
                 }
             }
             if (largestPoly && largestPoly.length === 4) {
@@ -122,7 +115,6 @@ class DocumentScanner {
             const borderValue = react_native_fast_opencv_1.OpenCV.createObject(react_native_fast_opencv_1.ObjectType.Scalar, 0);
             react_native_fast_opencv_1.OpenCV.invoke('warpPerspective', src, dst, perspectiveMatrix, size, 1 /* INTER_LINEAR */, 0 /* BORDER_CONSTANT */, borderValue);
             const dstValue = react_native_fast_opencv_1.OpenCV.toJSValue(dst);
-            // Fix "writeFile got an object" by guaranteeing string type
             if (dstValue && dstValue.base64) {
                 return typeof dstValue.base64 === 'string' ? dstValue.base64 : String(dstValue.base64);
             }
@@ -165,5 +157,116 @@ class DocumentScanner {
             react_native_fast_opencv_1.OpenCV.clearBuffers();
         }
     }
+    /**
+     * Phân tích độ phức tạp màu sắc để gợi ý phương thức OCR phù hợp.
+     *
+     * - Nếu corners phát hiện thành công → crop vùng tài liệu và phân tích vùng đó
+     * - Nếu không có corners (phát hiện thất bại) → phân tích toàn bộ ảnh
+     * - Dùng không gian màu Lab, đo độ lệch chuẩn kênh a* (xanh↔đỏ) và b* (lam↔vàng)
+     * - stdA + stdB > threshold → nhiều màu sắc → 'G' (ML Kit, phù hợp thẻ, ảnh màu)
+     * - stdA + stdB ≤ threshold → ít màu sắc → 'S' (Tesseract, phù hợp giấy trắng, bản scan)
+     *
+     * @param imageBase64 Ảnh gốc base64 JPEG
+     * @param corners 4 góc tài liệu đã phát hiện (tuỳ chọn)
+     * @param colorThreshold Ngưỡng phân biệt (mặc định 18.0, điều chỉnh nếu cần tinh chỉnh)
+     */
+    static analyzeColorComplexity(imageBase64, corners, colorThreshold = 18.0) {
+        var _a, _b, _c, _d, _e, _f;
+        let src = null;
+        let roi = null;
+        let lab = null;
+        let color3Channel = null;
+        try {
+            src = react_native_fast_opencv_1.OpenCV.base64ToMat(imageBase64);
+            // Nếu có corners hợp lệ → crop vùng tài liệu để phân tích chính xác hơn
+            if (corners && corners.length === 4) {
+                try {
+                    const sortedCorners = this.sortCorners([...corners]);
+                    const [tl, tr, br, bl] = sortedCorners;
+                    const widthA = this.getDistance(br, bl);
+                    const widthB = this.getDistance(tr, tl);
+                    const maxWidth = Math.max(Math.round(widthA), Math.round(widthB));
+                    const heightA = this.getDistance(tr, br);
+                    const heightB = this.getDistance(tl, bl);
+                    const maxHeight = Math.max(Math.round(heightA), Math.round(heightB));
+                    if (maxWidth > 0 && maxHeight > 0) {
+                        const srcPts = react_native_fast_opencv_1.OpenCV.createObject(react_native_fast_opencv_1.ObjectType.Point2fVector, [
+                            react_native_fast_opencv_1.OpenCV.createObject(react_native_fast_opencv_1.ObjectType.Point2f, tl.x, tl.y),
+                            react_native_fast_opencv_1.OpenCV.createObject(react_native_fast_opencv_1.ObjectType.Point2f, tr.x, tr.y),
+                            react_native_fast_opencv_1.OpenCV.createObject(react_native_fast_opencv_1.ObjectType.Point2f, br.x, br.y),
+                            react_native_fast_opencv_1.OpenCV.createObject(react_native_fast_opencv_1.ObjectType.Point2f, bl.x, bl.y),
+                        ]);
+                        const dstPts = react_native_fast_opencv_1.OpenCV.createObject(react_native_fast_opencv_1.ObjectType.Point2fVector, [
+                            react_native_fast_opencv_1.OpenCV.createObject(react_native_fast_opencv_1.ObjectType.Point2f, 0, 0),
+                            react_native_fast_opencv_1.OpenCV.createObject(react_native_fast_opencv_1.ObjectType.Point2f, maxWidth - 1, 0),
+                            react_native_fast_opencv_1.OpenCV.createObject(react_native_fast_opencv_1.ObjectType.Point2f, maxWidth - 1, maxHeight - 1),
+                            react_native_fast_opencv_1.OpenCV.createObject(react_native_fast_opencv_1.ObjectType.Point2f, 0, maxHeight - 1),
+                        ]);
+                        const perspM = react_native_fast_opencv_1.OpenCV.invoke('getPerspectiveTransform', srcPts, dstPts, 0);
+                        const sz = react_native_fast_opencv_1.OpenCV.createObject(react_native_fast_opencv_1.ObjectType.Size, maxWidth, maxHeight);
+                        const borderVal = react_native_fast_opencv_1.OpenCV.createObject(react_native_fast_opencv_1.ObjectType.Scalar, 0);
+                        roi = react_native_fast_opencv_1.OpenCV.createObject(react_native_fast_opencv_1.ObjectType.Mat, 0, 0, react_native_fast_opencv_1.DataTypes.CV_8UC3);
+                        react_native_fast_opencv_1.OpenCV.invoke('warpPerspective', src, roi, perspM, sz, 1, 0, borderVal);
+                    }
+                }
+                catch (_) {
+                    roi = null; // Crop lỗi → dùng toàn ảnh
+                }
+            }
+            const target = roi !== null && roi !== void 0 ? roi : src; // Dùng vùng crop nếu có, ngược lại toàn ảnh
+            // Bắt buộc chuyển đổi về 3 kênh màu BGR để tránh lỗi khi dùng COLOR_BGR2Lab
+            // Trường hợp file ảnh là Grayscale (1 kênh) hoặc BGRA (4 kênh trong suốt)
+            color3Channel = react_native_fast_opencv_1.OpenCV.createObject(react_native_fast_opencv_1.ObjectType.Mat, 0, 0, react_native_fast_opencv_1.DataTypes.CV_8UC3);
+            const channelsObj = react_native_fast_opencv_1.OpenCV.invoke('channels', target);
+            if (channelsObj && channelsObj.value === 1) {
+                react_native_fast_opencv_1.OpenCV.invoke('cvtColor', target, color3Channel, react_native_fast_opencv_1.ColorConversionCodes.COLOR_GRAY2BGR);
+            }
+            else if (channelsObj && channelsObj.value === 4) {
+                react_native_fast_opencv_1.OpenCV.invoke('cvtColor', target, color3Channel, react_native_fast_opencv_1.ColorConversionCodes.COLOR_BGRA2BGR);
+            }
+            else {
+                color3Channel = target; // Đã là 3 kênh
+            }
+            // Chuyển sang Lab (L=sáng/tối, a*=màu xanh↔đỏ, b*=màu lam↔vàng)
+            lab = react_native_fast_opencv_1.OpenCV.createObject(react_native_fast_opencv_1.ObjectType.Mat, 0, 0, react_native_fast_opencv_1.DataTypes.CV_8UC3);
+            react_native_fast_opencv_1.OpenCV.invoke('cvtColor', color3Channel, lab, react_native_fast_opencv_1.ColorConversionCodes.COLOR_BGR2Lab);
+            // Đo mean và stddev từng kênh
+            const meanMat = react_native_fast_opencv_1.OpenCV.createObject(react_native_fast_opencv_1.ObjectType.Mat, 0, 0, react_native_fast_opencv_1.DataTypes.CV_64F);
+            const stdMat = react_native_fast_opencv_1.OpenCV.createObject(react_native_fast_opencv_1.ObjectType.Mat, 0, 0, react_native_fast_opencv_1.DataTypes.CV_64F);
+            react_native_fast_opencv_1.OpenCV.invoke('meanStdDev', lab, meanMat, stdMat);
+            // Trích xuất stdDev một cách an toàn
+            const stdJS = react_native_fast_opencv_1.OpenCV.toJSValue(stdMat);
+            // react-native-fast-opencv thường chuyển `Mat` thành object JS có cấu trúc mảng 1 chiều trong prop `array` hoặc `data`
+            // hoặc trả về dưới dạng mảng lồng nhau
+            let stdA = 0;
+            let stdB = 0;
+            if (stdJS) {
+                if (Array.isArray(stdJS)) {
+                    // Nếu nó đã là array
+                    stdA = Array.isArray(stdJS[1]) ? stdJS[1][0] : (_a = stdJS[1]) !== null && _a !== void 0 ? _a : 0;
+                    stdB = Array.isArray(stdJS[2]) ? stdJS[2][0] : (_b = stdJS[2]) !== null && _b !== void 0 ? _b : 0;
+                }
+                else if (stdJS.array && Array.isArray(stdJS.array)) {
+                    stdA = (_c = stdJS.array[1]) !== null && _c !== void 0 ? _c : 0;
+                    stdB = (_d = stdJS.array[2]) !== null && _d !== void 0 ? _d : 0;
+                }
+                else if (stdJS.data && Array.isArray(stdJS.data)) {
+                    // Có một số version có định dạng `data`
+                    stdA = (_e = stdJS.data[1]) !== null && _e !== void 0 ? _e : 0;
+                    stdB = (_f = stdJS.data[2]) !== null && _f !== void 0 ? _f : 0;
+                }
+            }
+            const colorScore = stdA + stdB;
+            console.log(`[OCR Auto] colorScore=${colorScore.toFixed(2)} threshold=${colorThreshold} => ${colorScore > colorThreshold ? 'G (ML Kit)' : 'S (Tesseract)'}`);
+            return colorScore > colorThreshold ? 'G' : 'S';
+        }
+        catch (e) {
+            console.error('[OpenCV] analyzeColorComplexity lỗi:', e === null || e === void 0 ? void 0 : e.message);
+            throw new Error(`[OpenCV analyzeColorComplexity Error]: ${e === null || e === void 0 ? void 0 : e.message}`);
+        }
+        finally {
+            react_native_fast_opencv_1.OpenCV.clearBuffers();
+        }
+    }
 }
 exports.DocumentScanner = DocumentScanner;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "rn-opencv-doc-perspective-correction",
-    "version": "1.0.9",
+    "version": "1.0.12",
     "description": "A React Native library for document corner detection and perspective correction using react-native-fast-opencv",
     "main": "dist/index.js",
     "types": "dist/index.d.ts",

package/src/index.ts

@@ -218,6 +218,7 @@ export class DocumentScanner {
         let src: OpenCVMat | null = null;
         let roi: OpenCVMat | null = null;
         let lab: OpenCVMat | null = null;
+        let color3Channel: OpenCVMat | null = null;
 
         try {
             src = OpenCV.base64ToMat(imageBase64);
@@ -260,27 +261,56 @@ export class DocumentScanner {
 
             const target = roi ?? src; // Dùng vùng crop nếu có, ngược lại toàn ảnh
 
+            // Bắt buộc chuyển đổi về 3 kênh màu BGR để tránh lỗi khi dùng COLOR_BGR2Lab
+            // Trường hợp file ảnh là Grayscale (1 kênh) hoặc BGRA (4 kênh trong suốt)
+            color3Channel = OpenCV.createObject(ObjectType.Mat, 0, 0, DataTypes.CV_8UC3);
+            const channelsObj = OpenCV.invoke('channels', target);
+            if (channelsObj && channelsObj.value === 1) {
+                OpenCV.invoke('cvtColor', target, color3Channel, ColorConversionCodes.COLOR_GRAY2BGR);
+            } else if (channelsObj && channelsObj.value === 4) {
+                OpenCV.invoke('cvtColor', target, color3Channel, ColorConversionCodes.COLOR_BGRA2BGR);
+            } else {
+                color3Channel = target; // Đã là 3 kênh
+            }
+
             // Chuyển sang Lab (L=sáng/tối, a*=màu xanh↔đỏ, b*=màu lam↔vàng)
             lab = OpenCV.createObject(ObjectType.Mat, 0, 0, DataTypes.CV_8UC3);
-            OpenCV.invoke('cvtColor', target, lab, ColorConversionCodes.COLOR_BGR2Lab);
+            OpenCV.invoke('cvtColor', color3Channel, lab, ColorConversionCodes.COLOR_BGR2Lab);
 
             // Đo mean và stddev từng kênh
             const meanMat = OpenCV.createObject(ObjectType.Mat, 0, 0, DataTypes.CV_64F);
             const stdMat = OpenCV.createObject(ObjectType.Mat, 0, 0, DataTypes.CV_64F);
             OpenCV.invoke('meanStdDev', lab, meanMat, stdMat);
 
+            // Trích xuất stdDev một cách an toàn
             const stdJS = OpenCV.toJSValue(stdMat);
-            const stdArray: number[] = stdJS?.array ?? [];
-            const stdA = stdArray[1] ?? 0; // a*: xanh lá ↔ đỏ
-            const stdB = stdArray[2] ?? 0; // b*: lam ↔ vàng
+            // react-native-fast-opencv thường chuyển `Mat` thành object JS có cấu trúc mảng 1 chiều trong prop `array` hoặc `data`
+            // hoặc trả về dưới dạng mảng lồng nhau
+            let stdA = 0;
+            let stdB = 0;
+            
+            if (stdJS) {
+                if (Array.isArray(stdJS)) {
+                    // Nếu nó đã là array
+                    stdA = Array.isArray(stdJS[1]) ? stdJS[1][0] : stdJS[1] ?? 0;
+                    stdB = Array.isArray(stdJS[2]) ? stdJS[2][0] : stdJS[2] ?? 0;
+                } else if (stdJS.array && Array.isArray(stdJS.array)) {
+                    stdA = stdJS.array[1] ?? 0;
+                    stdB = stdJS.array[2] ?? 0;
+                } else if (stdJS.data && Array.isArray(stdJS.data)) {
+                    // Có một số version có định dạng `data`
+                    stdA = stdJS.data[1] ?? 0;
+                    stdB = stdJS.data[2] ?? 0;
+                }
+            }
 
             const colorScore = stdA + stdB;
             console.log(`[OCR Auto] colorScore=${colorScore.toFixed(2)} threshold=${colorThreshold} => ${colorScore > colorThreshold ? 'G (ML Kit)' : 'S (Tesseract)'}`);
 
             return colorScore > colorThreshold ? 'G' : 'S';
         } catch (e: any) {
-            console.warn('[OpenCV] analyzeColorComplexity lỗi, fallback G:', e?.message);
-            return 'G'; // Fallback an toàn về ML Kit
+            console.error('[OpenCV] analyzeColorComplexity lỗi:', e?.message);
+            throw new Error(`[OpenCV analyzeColorComplexity Error]: ${e?.message}`);
         } finally {
             OpenCV.clearBuffers();
         }