rn-opencv-doc-perspective-correction 1.0.5 → 1.0.7

package/dist/index.d.ts

@@ -3,20 +3,12 @@ export type Point = {
     y: number;
 };
 export declare class DocumentScanner {
-    /**
-     * Tính khoảng cách Euclidean giữa 2 điểm
-     */
     private static getDistance;
-    /**
-     * Sắp xếp 4 điểm thành chuỗi TL, TR, BR, BL
-     */
     private static sortCorners;
-    /**
-     * Bước 1: Page Corner Detection (Auto-detect góc tài liệu)
-     */
     static detectPageCorners(imageBase64: string, onLog?: (msg: string) => void): Point[] | undefined;
+    static applyPerspectiveCorrection(imageBase64: string, corners: Point[], onLog?: (msg: string) => void): string | undefined;
     /**
-     * Bước 2: Perspective Correction
+     * Xoay ảnh 90, -90 hoặc 180 độ
      */
-    static applyPerspectiveCorrection(imageBase64: string, corners: Point[], onLog?: (msg: string) => void): string | undefined;
+    static rotateImage(imageBase64: string, angle: 90 | -90 | 180, onLog?: (msg: string) => void): string | undefined;
 }

package/dist/index.js

@@ -4,15 +4,9 @@ exports.DocumentScanner = void 0;
 // @ts-nocheck
 const react_native_fast_opencv_1 = require("react-native-fast-opencv");
 class DocumentScanner {
-    /**
-     * Tính khoảng cách Euclidean giữa 2 điểm
-     */
     static getDistance(p1, p2) {
         return Math.sqrt(Math.pow(p1.x - p2.x, 2) + Math.pow(p1.y - p2.y, 2));
     }
-    /**
-     * Sắp xếp 4 điểm thành chuỗi TL, TR, BR, BL
-     */
     static sortCorners(corners) {
         if (corners.length !== 4)
             return corners;
@@ -23,9 +17,6 @@ class DocumentScanner {
             return angleA - angleB;
         });
     }
-    /**
-     * Bước 1: Page Corner Detection (Auto-detect góc tài liệu)
-     */
     static detectPageCorners(imageBase64, onLog) {
         let src = null;
         let gray = null;
@@ -37,41 +28,55 @@ 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);
+            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
             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);
-            react_native_fast_opencv_1.OpenCV.invoke('Canny', blurred, edges, 50, 150);
+            // 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);
-            react_native_fast_opencv_1.OpenCV.invoke('findContoursWithHierarchy', edges, contoursObj, hierarchyObj, 1 /* RETR_LIST */, 2 /* CHAIN_APPROX_SIMPLE */);
+            // 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) || [];
             const contoursSize = contoursArray.length;
-            let maxArea = 0;
-            let largestPoly = undefined;
-            let foundContoursCount = 0;
+            if (contoursSize === 0) {
+                if (onLog)
+                    onLog(`[OpenCV] Không tìm thấy contours.`);
+                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 > 10000) { // Lọc bỏ các contour quá nhỏ
-                    foundContoursCount++;
+                if (area > 5000) { // filter very small artifacts
+                    contourMetrics.push({ index: i, area, contour });
                 }
-                if (area > maxArea && area > 10000) {
-                    const periObj = react_native_fast_opencv_1.OpenCV.invoke('arcLength', contour, true);
-                    const peri = periObj ? periObj.value : 0;
-                    const approx = react_native_fast_opencv_1.OpenCV.createObject(react_native_fast_opencv_1.ObjectType.PointVector);
-                    // Tăng eplison lên một chút để cho phép viền mấp mô hơn
-                    react_native_fast_opencv_1.OpenCV.invoke('approxPolyDP', contour, approx, 0.04 * peri, true);
-                    const approxJS = react_native_fast_opencv_1.OpenCV.toJSValue(approx);
-                    if (approxJS && approxJS.array && approxJS.array.length === 4) {
-                        maxArea = area;
-                        largestPoly = approxJS.array;
-                    }
+            }
+            // 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;
+                const periObj = react_native_fast_opencv_1.OpenCV.invoke('arcLength', contour, true);
+                const peri = periObj ? periObj.value : 0;
+                const approx = react_native_fast_opencv_1.OpenCV.createObject(react_native_fast_opencv_1.ObjectType.PointVector);
+                react_native_fast_opencv_1.OpenCV.invoke('approxPolyDP', contour, approx, 0.02 * peri, true);
+                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
                 }
             }
-            const logMsg = `[OpenCV] Đã tìm thấy ${contoursSize} contours. Số contour đủ lớn: ${foundContoursCount}`;
+            const logMsg = `[OpenCV] Contours: ${contoursSize}. Metrics pass: ${contourMetrics.length}. Poly detect: ${largestPoly ? 'Thành công' : 'Thất bại'}.`;
             console.log(logMsg);
             if (onLog)
                 onLog(logMsg);
@@ -90,9 +95,6 @@ class DocumentScanner {
             react_native_fast_opencv_1.OpenCV.clearBuffers();
         }
     }
-    /**
-     * Bước 2: Perspective Correction
-     */
     static applyPerspectiveCorrection(imageBase64, corners, onLog) {
         let src = null;
         let dst = null;
@@ -127,7 +129,12 @@ class DocumentScanner {
             const size = react_native_fast_opencv_1.OpenCV.createObject(react_native_fast_opencv_1.ObjectType.Size, maxWidth, maxHeight);
             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);
-            return react_native_fast_opencv_1.OpenCV.invoke('toBase64', dst);
+            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);
+            }
+            return undefined;
         }
         catch (e) {
             console.error('Lỗi khi bóp phối cảnh tài liệu (OpenCV):', e);
@@ -139,5 +146,36 @@ class DocumentScanner {
             react_native_fast_opencv_1.OpenCV.clearBuffers();
         }
     }
+    /**
+     * Xoay ảnh 90, -90 hoặc 180 độ
+     */
+    static rotateImage(imageBase64, angle, onLog) {
+        let src = null;
+        let dst = null;
+        try {
+            src = react_native_fast_opencv_1.OpenCV.base64ToMat(imageBase64);
+            dst = react_native_fast_opencv_1.OpenCV.createObject(react_native_fast_opencv_1.ObjectType.Mat, 0, 0, react_native_fast_opencv_1.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
+            react_native_fast_opencv_1.OpenCV.invoke('rotate', src, dst, rotateCode);
+            const dstValue = react_native_fast_opencv_1.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 xoay ảnh (OpenCV):', e);
+            if (onLog)
+                onLog(`[OpenCV Rotate Error]: ${e.message}`);
+            return undefined;
+        }
+        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.5",
+    "version": "1.0.7",
     "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

@@ -4,16 +4,10 @@ import { OpenCV, OpenCVMat, ObjectType, DataTypes, ColorConversionCodes } from '
 export type Point = { x: number; y: number };
 
 export class DocumentScanner {
-    /**
-     * Tính khoảng cách Euclidean giữa 2 điểm
-     */
     private static getDistance(p1: Point, p2: Point) {
         return Math.sqrt(Math.pow(p1.x - p2.x, 2) + Math.pow(p1.y - p2.y, 2));
     }
 
-    /**
-     * Sắp xếp 4 điểm thành chuỗi TL, TR, BR, BL
-     */
     private static sortCorners(corners: Point[]): Point[] {
         if (corners.length !== 4) return corners;
 
@@ -29,9 +23,6 @@ export class DocumentScanner {
         });
     }
 
-    /**
-     * Bước 1: Page Corner Detection (Auto-detect góc tài liệu)
-     */
     public static detectPageCorners(imageBase64: string, onLog?: (msg: string) => void): Point[] | undefined {
         let src: OpenCVMat | null = null;
         let gray: OpenCVMat | null = null;
@@ -44,52 +35,68 @@ export class DocumentScanner {
             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);
+            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);
 
-            OpenCV.invoke('Canny', blurred, edges, 50, 150);
+            // 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);
 
-            OpenCV.invoke('findContoursWithHierarchy', edges, contoursObj, hierarchyObj, 1 /* RETR_LIST */, 2 /* CHAIN_APPROX_SIMPLE */);
+            // 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;
 
-            let maxArea = 0;
-            let largestPoly: Point[] | undefined = undefined;
-            let foundContoursCount = 0;
+            if (contoursSize === 0) {
+                if (onLog) onLog(`[OpenCV] Không tìm thấy contours.`);
+                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 > 10000) { // Lọc bỏ các contour quá nhỏ
-                    foundContoursCount++;
+                if (area > 5000) { // filter very small artifacts
+                    contourMetrics.push({ index: i, area, contour });
                 }
+            }
 
-                if (area > maxArea && area > 10000) {
-                    const periObj = OpenCV.invoke('arcLength', contour, true);
-                    const peri = periObj ? periObj.value : 0;
-                    const approx = OpenCV.createObject(ObjectType.PointVector);
-                    // Tăng eplison lên một chút để cho phép viền mấp mô hơn
-                    OpenCV.invoke('approxPolyDP', contour, approx, 0.04 * peri, true);
-
-                    const approxJS = OpenCV.toJSValue(approx);
-                    if (approxJS && approxJS.array && approxJS.array.length === 4) {
-                        maxArea = area;
-                        largestPoly = approxJS.array as Point[];
-                    }
+            // 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
                 }
             }
-            const logMsg = `[OpenCV] Đã tìm thấy ${contoursSize} contours. Số contour đủ lớn: ${foundContoursCount}`;
+
+            const logMsg = `[OpenCV] Contours: ${contoursSize}. Metrics pass: ${contourMetrics.length}. Poly detect: ${largestPoly ? 'Thành công' : 'Thất bại'}.`;
             console.log(logMsg);
             if (onLog) onLog(logMsg);
 
@@ -106,9 +113,6 @@ export class DocumentScanner {
         }
     }
 
-    /**
-     * Bước 2: Perspective Correction
-     */
     public static applyPerspectiveCorrection(imageBase64: string, corners: Point[], onLog?: (msg: string) => void): string | undefined {
         let src: OpenCVMat | null = null;
         let dst: OpenCVMat | null = null;
@@ -156,7 +160,13 @@ export class DocumentScanner {
 
             OpenCV.invoke('warpPerspective', src, dst, perspectiveMatrix, size, 1 /* INTER_LINEAR */, 0 /* BORDER_CONSTANT */, borderValue);
 
-            return OpenCV.invoke('toBase64', dst);
+            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);
             if (onLog) onLog(`[OpenCV Perspective Correction Error]: ${(e as Error).message || e}`);
@@ -165,4 +175,35 @@ export class DocumentScanner {
             OpenCV.clearBuffers();
         }
     }
+
+    /**
+     * Xoay ảnh 90, -90 hoặc 180 độ
+     */
+    public static rotateImage(imageBase64: string, angle: 90 | -90 | 180, onLog?: (msg: string) => void): 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);
+            if (onLog) onLog(`[OpenCV Rotate Error]: ${e.message}`);
+            return undefined;
+        } finally {
+            OpenCV.clearBuffers();
+        }
+    }
 }
+