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

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,117 @@ 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.warn('[OpenCV] analyzeColorComplexity lỗi, fallback S:', e === null || e === void 0 ? void 0 : e.message);
+            // Ảnh ít màu thường dễ gây lỗi khi phân tích hơn nên ta Fallback về S
+            return 'S';
+        }
+        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.8",
+    "version": "1.0.11",
     "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,319 @@
-// @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;
+        let color3Channel: 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
+
+            // 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', 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);
+            // 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 S:', e?.message);
+            // Ảnh ít màu thường dễ gây lỗi khi phân tích hơn nên ta Fallback về S
+            return 'S';
+        } finally {
+            OpenCV.clearBuffers();
+        }
+    }
+}