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

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "rn-opencv-doc-perspective-correction",
-    "version": "1.0.8",
+    "version": "1.0.9",
     "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

@@ -1,203 +1,288 @@
-// @ts-nocheck
-import { OpenCV, OpenCVMat, ObjectType, DataTypes, ColorConversionCodes } from 'react-native-fast-opencv';
-
-export type Point = { x: number; y: number };
-
-export class DocumentScanner {
-    private static getDistance(p1: Point, p2: Point) {
-        return Math.sqrt(Math.pow(p1.x - p2.x, 2) + Math.pow(p1.y - p2.y, 2));
-    }
-
-    private static sortCorners(corners: Point[]): Point[] {
-        if (corners.length !== 4) return corners;
-
-        const center = corners.reduce(
-            (acc, cur) => ({ x: acc.x + cur.x / 4, y: acc.y + cur.y / 4 }),
-            { x: 0, y: 0 }
-        );
-
-        return corners.sort((a, b) => {
-            const angleA = Math.atan2(a.y - center.y, a.x - center.x);
-            const angleB = Math.atan2(b.y - center.y, b.x - center.x);
-            return angleA - angleB;
-        });
-    }
-
-    public static detectPageCorners(imageBase64: string): Point[] | undefined {
-        let src: OpenCVMat | null = null;
-        let gray: OpenCVMat | null = null;
-        let blurred: OpenCVMat | null = null;
-        let edges: OpenCVMat | null = null;
-        let contoursObj: any = null;
-        let hierarchyObj: any = null;
-
-        try {
-            src = OpenCV.base64ToMat(imageBase64);
-            gray = OpenCV.createObject(ObjectType.Mat, 0, 0, DataTypes.CV_8U);
-            blurred = OpenCV.createObject(ObjectType.Mat, 0, 0, DataTypes.CV_8U);
-            edges = OpenCV.createObject(ObjectType.Mat, 0, 0, DataTypes.CV_8U); // This will hold the threshold output
-
-            OpenCV.invoke('cvtColor', src, gray, ColorConversionCodes.COLOR_BGR2GRAY);
-
-            const ksize = OpenCV.createObject(ObjectType.Size, 5, 5);
-            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
-            OpenCV.invoke('threshold', blurred, edges, 0, 255, 8);
-
-            contoursObj = OpenCV.createObject(ObjectType.MatVector);
-            hierarchyObj = OpenCV.createObject(ObjectType.Mat, 0, 0, DataTypes.CV_8U);
-
-            // Using RETR_EXTERNAL similar to the Python script for outer contours
-            OpenCV.invoke('findContoursWithHierarchy', edges, contoursObj, hierarchyObj, 0 /* RETR_EXTERNAL */, 2 /* CHAIN_APPROX_SIMPLE */);
-
-            const contoursJS = OpenCV.toJSValue(contoursObj);
-            const contoursArray = contoursJS?.array || [];
-            const contoursSize = contoursArray.length;
-
-            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 = OpenCV.copyObjectFromVector(contoursObj, i);
-                const areaObj = OpenCV.invoke('contourArea', contour);
-                const area = areaObj ? areaObj.value : 0;
-                if (area > 5000) { // filter very small artifacts
-                    contourMetrics.push({ index: i, area, contour });
-                }
-            }
-
-            // Sort contours by area in descending order
-            contourMetrics.sort((a, b) => b.area - a.area);
-
-            let largestPoly: Point[] | undefined = 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;
-
-                const periObj = OpenCV.invoke('arcLength', contour, true);
-                const peri = periObj ? periObj.value : 0;
-                const approx = OpenCV.createObject(ObjectType.PointVector);
-                OpenCV.invoke('approxPolyDP', contour, approx, 0.02 * peri, true);
-
-                const approxJS = OpenCV.toJSValue(approx);
-                if (approxJS && approxJS.array && approxJS.array.length === 4) {
-                    largestPoly = approxJS.array as Point[];
-                    break; // Stop at the first 4-point polygon like python script
-                }
-            }
-
-
-
-            if (largestPoly && largestPoly.length === 4) {
-                return this.sortCorners(largestPoly);
-            }
-            return undefined;
-        } catch (e: any) {
-            console.error('Lỗi khi dò tìm góc tài liệu (OpenCV):', e);
-            throw new Error(`[OpenCV Corner Detection Error]: ${e.message}`);
-        } finally {
-            OpenCV.clearBuffers();
-        }
-    }
-
-    public static applyPerspectiveCorrection(imageBase64: string, corners: Point[]): string | undefined {
-        let src: OpenCVMat | null = null;
-        let dst: OpenCVMat | null = null;
-
-        try {
-            if (!corners || corners.length !== 4) throw new Error("Cần truyền vào đúng 4 điểm góc.");
-
-            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) return undefined;
-
-            src = OpenCV.base64ToMat(imageBase64);
-            dst = OpenCV.createObject(ObjectType.Mat, 0, 0, DataTypes.CV_8UC3);
-
-            const srcPoints = OpenCV.createObject(ObjectType.Point2fVector,
-                [
-                    OpenCV.createObject(ObjectType.Point2f, tl.x, tl.y),
-                    OpenCV.createObject(ObjectType.Point2f, tr.x, tr.y),
-                    OpenCV.createObject(ObjectType.Point2f, br.x, br.y),
-                    OpenCV.createObject(ObjectType.Point2f, bl.x, bl.y)
-                ]
-            );
-            const dstPoints = OpenCV.createObject(ObjectType.Point2fVector,
-                [
-                    OpenCV.createObject(ObjectType.Point2f, 0, 0),
-                    OpenCV.createObject(ObjectType.Point2f, maxWidth - 1, 0),
-                    OpenCV.createObject(ObjectType.Point2f, maxWidth - 1, maxHeight - 1),
-                    OpenCV.createObject(ObjectType.Point2f, 0, maxHeight - 1)
-                ]
-            );
-
-            const perspectiveMatrix = OpenCV.invoke('getPerspectiveTransform', srcPoints, dstPoints, 0);
-
-            const size = OpenCV.createObject(ObjectType.Size, maxWidth, maxHeight);
-            const borderValue = OpenCV.createObject(ObjectType.Scalar, 0);
-
-            OpenCV.invoke('warpPerspective', src, dst, perspectiveMatrix, size, 1 /* INTER_LINEAR */, 0 /* BORDER_CONSTANT */, borderValue);
-
-            const dstValue = 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);
-            }
-            return undefined;
-        } catch (e) {
-            console.error('Lỗi khi bóp phối cảnh tài liệu (OpenCV):', e);
-            return undefined;
-        } finally {
-            OpenCV.clearBuffers();
-        }
-    }
-
-    /**
-     * Xoay ảnh 90, -90 hoặc 180 độ
-     */
-    public static rotateImage(imageBase64: string, angle: 90 | -90 | 180): string | undefined {
-        let src: OpenCVMat | null = null;
-        let dst: OpenCVMat | null = null;
-        try {
-            src = OpenCV.base64ToMat(imageBase64);
-            dst = OpenCV.createObject(ObjectType.Mat, 0, 0, DataTypes.CV_8U);
-
-            let rotateCode = 0; // ROTATE_90_CLOCKWISE
-            if (angle === -90) rotateCode = 2; // ROTATE_90_COUNTERCLOCKWISE
-            else if (angle === 180) rotateCode = 1; // ROTATE_180
-
-            OpenCV.invoke('rotate', src, dst, rotateCode);
-
-            const dstValue = OpenCV.toJSValue(dst);
-            if (dstValue && dstValue.base64) {
-                return typeof dstValue.base64 === 'string' ? dstValue.base64 : String(dstValue.base64);
-            }
-            return undefined;
-        } catch (e: any) {
-            console.error('Lỗi khi xoay ảnh (OpenCV):', e);
-            return undefined;
-        } finally {
-            OpenCV.clearBuffers();
-        }
-    }
-}
-
+// @ts-nocheck
+import { OpenCV, OpenCVMat, ObjectType, DataTypes, ColorConversionCodes } from 'react-native-fast-opencv';
+
+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 class DocumentScanner {
+    private static getDistance(p1: Point, p2: Point) {
+        return Math.sqrt(Math.pow(p1.x - p2.x, 2) + Math.pow(p1.y - p2.y, 2));
+    }
+
+    private static sortCorners(corners: Point[]): Point[] {
+        if (corners.length !== 4) return corners;
+
+        const center = corners.reduce(
+            (acc, cur) => ({ x: acc.x + cur.x / 4, y: acc.y + cur.y / 4 }),
+            { x: 0, y: 0 }
+        );
+
+        return corners.sort((a, b) => {
+            const angleA = Math.atan2(a.y - center.y, a.x - center.x);
+            const angleB = Math.atan2(b.y - center.y, b.x - center.x);
+            return angleA - angleB;
+        });
+    }
+
+    public static detectPageCorners(imageBase64: string): Point[] | undefined {
+        let src: OpenCVMat | null = null;
+        let gray: OpenCVMat | null = null;
+        let blurred: OpenCVMat | null = null;
+        let edges: OpenCVMat | null = null;
+        let contoursObj: any = null;
+        let hierarchyObj: any = null;
+
+        try {
+            src = OpenCV.base64ToMat(imageBase64);
+            gray = OpenCV.createObject(ObjectType.Mat, 0, 0, DataTypes.CV_8U);
+            blurred = OpenCV.createObject(ObjectType.Mat, 0, 0, DataTypes.CV_8U);
+            edges = OpenCV.createObject(ObjectType.Mat, 0, 0, DataTypes.CV_8U);
+
+            OpenCV.invoke('cvtColor', src, gray, ColorConversionCodes.COLOR_BGR2GRAY);
+
+            const ksize = OpenCV.createObject(ObjectType.Size, 5, 5);
+            OpenCV.invoke('GaussianBlur', gray, blurred, ksize, 0);
+
+            // THRESH_BINARY + THRESH_OTSU = 8
+            OpenCV.invoke('threshold', blurred, edges, 0, 255, 8);
+
+            contoursObj = OpenCV.createObject(ObjectType.MatVector);
+            hierarchyObj = OpenCV.createObject(ObjectType.Mat, 0, 0, DataTypes.CV_8U);
+
+            OpenCV.invoke('findContoursWithHierarchy', edges, contoursObj, hierarchyObj, 0 /* RETR_EXTERNAL */, 2 /* CHAIN_APPROX_SIMPLE */);
+
+            const contoursJS = OpenCV.toJSValue(contoursObj);
+            const contoursArray = contoursJS?.array || [];
+            const contoursSize = contoursArray.length;
+
+            if (contoursSize === 0) {
+                return undefined;
+            }
+
+            let contourMetrics = [];
+            for (let i = 0; i < contoursSize; i++) {
+                const contour = OpenCV.copyObjectFromVector(contoursObj, i);
+                const areaObj = OpenCV.invoke('contourArea', contour);
+                const area = areaObj ? areaObj.value : 0;
+                if (area > 5000) {
+                    contourMetrics.push({ index: i, area, contour });
+                }
+            }
+
+            contourMetrics.sort((a, b) => b.area - a.area);
+
+            let largestPoly: Point[] | undefined = undefined;
+
+            for (let i = 0; i < contourMetrics.length; i++) {
+                const metric = contourMetrics[i];
+                const contour = metric.contour;
+
+                const periObj = OpenCV.invoke('arcLength', contour, true);
+                const peri = periObj ? periObj.value : 0;
+                const approx = OpenCV.createObject(ObjectType.PointVector);
+                OpenCV.invoke('approxPolyDP', contour, approx, 0.02 * peri, true);
+
+                const approxJS = OpenCV.toJSValue(approx);
+                if (approxJS && approxJS.array && approxJS.array.length === 4) {
+                    largestPoly = approxJS.array as Point[];
+                    break;
+                }
+            }
+
+            if (largestPoly && largestPoly.length === 4) {
+                return this.sortCorners(largestPoly);
+            }
+            return undefined;
+        } catch (e: any) {
+            console.error('Lỗi khi dò tìm góc tài liệu (OpenCV):', e);
+            throw new Error(`[OpenCV Corner Detection Error]: ${e.message}`);
+        } finally {
+            OpenCV.clearBuffers();
+        }
+    }
+
+    public static applyPerspectiveCorrection(imageBase64: string, corners: Point[]): string | undefined {
+        let src: OpenCVMat | null = null;
+        let dst: OpenCVMat | null = null;
+
+        try {
+            if (!corners || corners.length !== 4) throw new Error("Cần truyền vào đúng 4 điểm góc.");
+
+            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) return undefined;
+
+            src = OpenCV.base64ToMat(imageBase64);
+            dst = OpenCV.createObject(ObjectType.Mat, 0, 0, DataTypes.CV_8UC3);
+
+            const srcPoints = OpenCV.createObject(ObjectType.Point2fVector,
+                [
+                    OpenCV.createObject(ObjectType.Point2f, tl.x, tl.y),
+                    OpenCV.createObject(ObjectType.Point2f, tr.x, tr.y),
+                    OpenCV.createObject(ObjectType.Point2f, br.x, br.y),
+                    OpenCV.createObject(ObjectType.Point2f, bl.x, bl.y)
+                ]
+            );
+            const dstPoints = OpenCV.createObject(ObjectType.Point2fVector,
+                [
+                    OpenCV.createObject(ObjectType.Point2f, 0, 0),
+                    OpenCV.createObject(ObjectType.Point2f, maxWidth - 1, 0),
+                    OpenCV.createObject(ObjectType.Point2f, maxWidth - 1, maxHeight - 1),
+                    OpenCV.createObject(ObjectType.Point2f, 0, maxHeight - 1)
+                ]
+            );
+
+            const perspectiveMatrix = OpenCV.invoke('getPerspectiveTransform', srcPoints, dstPoints, 0);
+
+            const size = OpenCV.createObject(ObjectType.Size, maxWidth, maxHeight);
+            const borderValue = OpenCV.createObject(ObjectType.Scalar, 0);
+
+            OpenCV.invoke('warpPerspective', src, dst, perspectiveMatrix, size, 1 /* INTER_LINEAR */, 0 /* BORDER_CONSTANT */, borderValue);
+
+            const dstValue = OpenCV.toJSValue(dst);
+
+            if (dstValue && dstValue.base64) {
+                return typeof dstValue.base64 === 'string' ? dstValue.base64 : String(dstValue.base64);
+            }
+            return undefined;
+        } catch (e) {
+            console.error('Lỗi khi bóp phối cảnh tài liệu (OpenCV):', e);
+            return undefined;
+        } finally {
+            OpenCV.clearBuffers();
+        }
+    }
+
+    /**
+     * Xoay ảnh 90, -90 hoặc 180 độ
+     */
+    public static rotateImage(imageBase64: string, angle: 90 | -90 | 180): string | undefined {
+        let src: OpenCVMat | null = null;
+        let dst: OpenCVMat | null = null;
+        try {
+            src = OpenCV.base64ToMat(imageBase64);
+            dst = OpenCV.createObject(ObjectType.Mat, 0, 0, DataTypes.CV_8U);
+
+            let rotateCode = 0; // ROTATE_90_CLOCKWISE
+            if (angle === -90) rotateCode = 2; // ROTATE_90_COUNTERCLOCKWISE
+            else if (angle === 180) rotateCode = 1; // ROTATE_180
+
+            OpenCV.invoke('rotate', src, dst, rotateCode);
+
+            const dstValue = OpenCV.toJSValue(dst);
+            if (dstValue && dstValue.base64) {
+                return typeof dstValue.base64 === 'string' ? dstValue.base64 : String(dstValue.base64);
+            }
+            return undefined;
+        } catch (e: any) {
+            console.error('Lỗi khi xoay ảnh (OpenCV):', e);
+            return undefined;
+        } finally {
+            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)
+     */
+    public static analyzeColorComplexity(
+        imageBase64: string,
+        corners?: Point[],
+        colorThreshold: number = 18.0
+    ): OcrMethodHint {
+        let src: OpenCVMat | null = null;
+        let roi: OpenCVMat | null = null;
+        let lab: OpenCVMat | null = null;
+
+        try {
+            src = 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 = OpenCV.createObject(ObjectType.Point2fVector, [
+                            OpenCV.createObject(ObjectType.Point2f, tl.x, tl.y),
+                            OpenCV.createObject(ObjectType.Point2f, tr.x, tr.y),
+                            OpenCV.createObject(ObjectType.Point2f, br.x, br.y),
+                            OpenCV.createObject(ObjectType.Point2f, bl.x, bl.y),
+                        ]);
+                        const dstPts = OpenCV.createObject(ObjectType.Point2fVector, [
+                            OpenCV.createObject(ObjectType.Point2f, 0, 0),
+                            OpenCV.createObject(ObjectType.Point2f, maxWidth - 1, 0),
+                            OpenCV.createObject(ObjectType.Point2f, maxWidth - 1, maxHeight - 1),
+                            OpenCV.createObject(ObjectType.Point2f, 0, maxHeight - 1),
+                        ]);
+                        const perspM = OpenCV.invoke('getPerspectiveTransform', srcPts, dstPts, 0);
+                        const sz = OpenCV.createObject(ObjectType.Size, maxWidth, maxHeight);
+                        const borderVal = OpenCV.createObject(ObjectType.Scalar, 0);
+                        roi = OpenCV.createObject(ObjectType.Mat, 0, 0, DataTypes.CV_8UC3);
+                        OpenCV.invoke('warpPerspective', src, roi, perspM, sz, 1, 0, borderVal);
+                    }
+                } catch (_) {
+                    roi = null; // Crop lỗi → dùng toàn ảnh
+                }
+            }
+
+            const target = roi ?? src; // Dùng vùng crop nếu có, ngược lại toàn ả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);
+
+            // Đ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);
+
+            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
+
+            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
+        } finally {
+            OpenCV.clearBuffers();
+        }
+    }
+}