rn-opencv-doc-perspective-correction 1.0.18 → 1.0.20

package/dist/index.d.ts

@@ -22,6 +22,11 @@ export declare class DocumentScanner {
     private static getAngleRange;
     /** Fallback: 4 góc của toàn bộ ảnh (như Python gốc khi không tìm được contour) */
     private static buildFullImageCorners;
+    /**
+     * Tìm tứ giác tốt nhất từ một MatVector contours.
+     * Trả về { poly, area, angleRange } hoặc null nếu không tìm được.
+     */
+    private static findBestQuad;
     static detectPageCorners(imageBase64: string): Point[] | undefined;
     static applyPerspectiveCorrection(imageBase64: string, corners: Point[]): string | undefined;
     /**

package/dist/index.js

@@ -55,163 +55,236 @@ class DocumentScanner {
             { x: 0, y: h }, // bottom-left
         ];
     }
+    /**
+     * Tìm tứ giác tốt nhất từ một MatVector contours.
+     * Trả về { poly, area, angleRange } hoặc null nếu không tìm được.
+     */
+    static findBestQuad(contoursObj, contoursSize, imgArea, minAreaRatio, pipelineName) {
+        var _a, _b, _c;
+        const allMetrics = [];
+        let maxRawArea = 0;
+        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 > maxRawArea)
+                maxRawArea = area;
+            allMetrics.push({ area, contour });
+        }
+        allMetrics.sort((a, b) => b.area - a.area);
+        const top = allMetrics.slice(0, 5);
+        let bestPoly;
+        let bestArea = 0;
+        let bestAngle = 999;
+        const debug = [];
+        for (let i = 0; i < top.length; i++) {
+            const m = top[i];
+            // Thử nhiều epsilon (10→120px) để approxPolyDP ra đúng 4 đỉnh
+            let fPts = null;
+            let fVerts = 0;
+            let fAngle = 999;
+            let fApproxArea = 0;
+            for (let ep = 10; ep <= 120; ep += 5) {
+                const approx = react_native_fast_opencv_1.OpenCV.createObject(react_native_fast_opencv_1.ObjectType.PointVector);
+                react_native_fast_opencv_1.OpenCV.invoke('approxPolyDP', m.contour, approx, ep, true);
+                const approxJS = react_native_fast_opencv_1.OpenCV.toJSValue(approx);
+                const verts = (_b = (_a = approxJS === null || approxJS === void 0 ? void 0 : approxJS.array) === null || _a === void 0 ? void 0 : _a.length) !== null && _b !== void 0 ? _b : 0;
+                if (verts === 4) {
+                    const pts = approxJS.array;
+                    const sorted = this.sortCorners([...pts]);
+                    const angleRange = this.getAngleRange(sorted);
+                    // Lấy diện tích polygon 4-điểm (đúng như Python: contourArea(approx))
+                    const aObj = react_native_fast_opencv_1.OpenCV.invoke('contourArea', approx);
+                    const approxArea = aObj ? ((_c = aObj.value) !== null && _c !== void 0 ? _c : 0) : 0;
+                    if (angleRange < fAngle) {
+                        fAngle = angleRange;
+                        fPts = pts;
+                        fVerts = verts;
+                        fApproxArea = approxArea;
+                    }
+                    if (approxArea > imgArea * minAreaRatio && angleRange < 40) {
+                        if (approxArea > bestArea || (approxArea === bestArea && angleRange < bestAngle)) {
+                            bestPoly = pts;
+                            bestArea = approxArea;
+                            bestAngle = angleRange;
+                        }
+                        break;
+                    }
+                }
+            }
+            debug.push(`  [${pipelineName}:C${i}] raw=${m.area.toFixed(0)}(${(m.area / imgArea * 100).toFixed(1)}%) ` +
+                `approx=${fApproxArea > 0 ? fApproxArea.toFixed(0) + '(' + ((fApproxArea / imgArea * 100).toFixed(1)) + '%)' : '-'} ` +
+                `v=${fVerts} a=${fAngle === 999 ? '-' : fAngle.toFixed(1)}° ` +
+                `ok=${fApproxArea > imgArea * minAreaRatio && fAngle < 40}`);
+        }
+        if (bestPoly && bestPoly.length === 4) {
+            return { poly: bestPoly, area: bestArea, angleRange: bestAngle, debug };
+        }
+        return null;
+    }
     static detectPageCorners(imageBase64) {
-        var _a, _b;
-        let src = null;
-        let resized = null;
-        let gray = null;
-        let blurred = null;
-        let closed = null;
-        let edges = null;
-        let dilated = null;
-        let contoursObj = null;
-        let hierarchyObj = null;
+        var _a, _b, _c, _d, _e, _f;
         try {
-            src = react_native_fast_opencv_1.OpenCV.base64ToMat(imageBase64);
+            const src = react_native_fast_opencv_1.OpenCV.base64ToMat(imageBase64);
             const jsSrc = react_native_fast_opencv_1.OpenCV.toJSValue(src);
             const origCols = jsSrc.cols || 1000;
             const origRows = jsSrc.rows || 1000;
             const targetHeight = 500.0;
             const ratio = origRows / targetHeight;
             const targetWidth = Math.max(1, Math.round(origCols / ratio));
-            resized = react_native_fast_opencv_1.OpenCV.createObject(react_native_fast_opencv_1.ObjectType.Mat, 0, 0, react_native_fast_opencv_1.DataTypes.CV_8U);
+            const resized = react_native_fast_opencv_1.OpenCV.createObject(react_native_fast_opencv_1.ObjectType.Mat, 0, 0, react_native_fast_opencv_1.DataTypes.CV_8U);
             const dstSize = react_native_fast_opencv_1.OpenCV.createObject(react_native_fast_opencv_1.ObjectType.Size, targetWidth, targetHeight);
             try {
                 react_native_fast_opencv_1.OpenCV.invoke('resize', src, resized, dstSize, 0, 0, 1 /* INTER_LINEAR */);
             }
-            catch (err) {
-                resized = src; // Fallback an toàn
+            catch (_) {
+                // nếu resize fail, dùng src gốc — ratio=1
             }
-            // BƯỚC 1: Chuyển sang ảnh xám (Grayscale)
-            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);
+            // Grayscale + Blur
+            const 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);
             react_native_fast_opencv_1.OpenCV.invoke('cvtColor', resized, gray, react_native_fast_opencv_1.ColorConversionCodes.COLOR_BGR2GRAY);
-            // BƯỚC 2: GaussianBlur 7x7 (theo andrewdcampbell)
-            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);
+            const 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);
             const ksize = react_native_fast_opencv_1.OpenCV.createObject(react_native_fast_opencv_1.ObjectType.Size, 7, 7);
             react_native_fast_opencv_1.OpenCV.invoke('GaussianBlur', gray, blurred, ksize, 0);
-            // BƯỚC 3: MORPH_CLOSE (kernel RECT 9x9) – nối các lỗ trống giữa cạnh viền
-            // Thiếu bước này là nguyên nhân chính khiến contour bị đứt đoạn
-            const MORPH_SIZE = 9;
-            const morphKernelSize = react_native_fast_opencv_1.OpenCV.createObject(react_native_fast_opencv_1.ObjectType.Size, MORPH_SIZE, MORPH_SIZE);
-            const morphKernel = react_native_fast_opencv_1.OpenCV.invoke('getStructuringElement', 0 /* MORPH_RECT */, morphKernelSize);
-            closed = 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 morphCloseUsed = true;
+            const imgArea = targetWidth * targetHeight;
+            const MIN_AREA = 0.15; // 15% — khoan dung hơn Python gốc (25%)
+            const allDebug = [];
+            let winner = null;
+            // ═══════════════════════════════════════════════════════════════
+            // PIPELINE 1: Adaptive Threshold → contour KÍN (method chính)
+            //
+            // Adaptive threshold tạo ảnh binary phân biệt foreground/background.
+            // findContours trên binary image cho contour KÍN → area = diện tích thật.
+            // Đây thay thế LSD line detection (không có trong react-native-fast-opencv).
+            // ═══════════════════════════════════════════════════════════════
             try {
-                react_native_fast_opencv_1.OpenCV.invoke('morphologyEx', blurred, closed, 3 /* MORPH_CLOSE */, morphKernel);
+                const adaptive = react_native_fast_opencv_1.OpenCV.createObject(react_native_fast_opencv_1.ObjectType.Mat, 0, 0, react_native_fast_opencv_1.DataTypes.CV_8U);
+                // ADAPTIVE_THRESH_GAUSSIAN_C = 1, THRESH_BINARY_INV = 1
+                // blockSize=15 (must be odd), C=10
+                react_native_fast_opencv_1.OpenCV.invoke('adaptiveThreshold', blurred, adaptive, 255, 1 /* GAUSSIAN_C */, 1 /* BINARY_INV */, 15, 10);
+                // MORPH_CLOSE để nối vùng tài liệu lại — kernel lớn 15x15
+                const closeKSz = react_native_fast_opencv_1.OpenCV.createObject(react_native_fast_opencv_1.ObjectType.Size, 15, 15);
+                const closeK = react_native_fast_opencv_1.OpenCV.invoke('getStructuringElement', 0 /* RECT */, closeKSz);
+                const adaptClosed = 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('morphologyEx', adaptive, adaptClosed, 3 /* MORPH_CLOSE */, closeK);
+                const cnt1 = react_native_fast_opencv_1.OpenCV.createObject(react_native_fast_opencv_1.ObjectType.MatVector);
+                const hier1 = 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', adaptClosed, cnt1, hier1, 0 /* RETR_EXTERNAL */, 2 /* CHAIN_APPROX_SIMPLE */);
+                const js1 = react_native_fast_opencv_1.OpenCV.toJSValue(cnt1);
+                const sz1 = (_b = (_a = js1 === null || js1 === void 0 ? void 0 : js1.array) === null || _a === void 0 ? void 0 : _a.length) !== null && _b !== void 0 ? _b : 0;
+                console.log(`[DocDetect] P1(AdaptThresh): ${sz1} contours`);
+                if (sz1 > 0) {
+                    const r1 = this.findBestQuad(cnt1, sz1, imgArea, MIN_AREA, 'P1');
+                    if (r1) {
+                        allDebug.push(...r1.debug);
+                        if (!winner || r1.area > winner.area) {
+                            winner = { poly: r1.poly, area: r1.area, angleRange: r1.angleRange };
+                        }
+                    }
+                    else if (r1 === null) {
+                        // Ghi debug dù không tìm được
+                    }
+                }
             }
-            catch (_morphErr) {
-                closed = blurred; // Fallback nếu thiết bị không hỗ trợ
-                morphCloseUsed = false;
+            catch (p1Err) {
+                console.log('[DocDetect] P1 failed:', p1Err);
             }
-            // BƯỚC 4: Canny (0, 84) – ngưỡng thấp theo andrewdcampbell
-            // threshold1=0: chấp nhận TẤT CẢ cạnh yếu nếu liên kết với cạnh mạnh
-            // threshold2=84: ngưỡng cạnh mạnh vừa phải
-            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('Canny', closed, edges, 0, 84);
-            // BƯỚC 5: Dilate 3x3 – nối các pixel viền lân cận bị đứt
-            const dilKernelSize = react_native_fast_opencv_1.OpenCV.createObject(react_native_fast_opencv_1.ObjectType.Size, 3, 3);
-            const dilKernel = react_native_fast_opencv_1.OpenCV.invoke('getStructuringElement', 0 /* MORPH_RECT */, dilKernelSize);
-            dilated = 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 dilateUsed = true;
+            // ═══════════════════════════════════════════════════════════════
+            // PIPELINE 2: Canny (giống Python gốc andrewdcampbell)
+            //
+            // MORPH_CLOSE trên grayscale → Canny → dilate mạnh → contours.
+            // Dilate 7x7 x2 iterations để NỐI edge fragments thành contour kín.
+            // ═══════════════════════════════════════════════════════════════
             try {
-                react_native_fast_opencv_1.OpenCV.invoke('morphologyEx', edges, dilated, 1 /* MORPH_DILATE */, dilKernel);
-            }
-            catch (_dilErr) {
-                dilated = edges; // Fallback
-                dilateUsed = false;
-            }
-            // BƯỚC 6: Tìm Contours — dùng RETR_EXTERNAL (đúng như Python gốc, không phải RETR_LIST)
-            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', dilated, 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;
-            const imgArea = targetWidth * targetHeight;
-            console.log(`[DocDetect] imgSize=${origCols}x${origRows} → resize=${targetWidth}x${targetHeight} | morphClose=${morphCloseUsed} dilate=${dilateUsed} | totalContours=${contoursSize}`);
-            if (contoursSize === 0) {
-                // Fallback: trả toàn bộ ảnh (như Python gốc)
-                console.log('[DocDetect] contoursSize=0, fallback to full image');
-                return this.buildFullImageCorners(origCols, origRows);
+                // MORPH_CLOSE 9x9 trên grayscale (đúng Python)
+                const morphSz = react_native_fast_opencv_1.OpenCV.createObject(react_native_fast_opencv_1.ObjectType.Size, 9, 9);
+                const morphK = react_native_fast_opencv_1.OpenCV.invoke('getStructuringElement', 0 /* RECT */, morphSz);
+                const morphed = 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('morphologyEx', blurred, morphed, 3 /* MORPH_CLOSE */, morphK);
+                // Canny (0, 84)
+                const cannyOut = 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('Canny', morphed, cannyOut, 0, 84);
+                // Dilate MẠNH: kernel 7x7 — nối edge fragments lại thành contour kín
+                const dilSz = react_native_fast_opencv_1.OpenCV.createObject(react_native_fast_opencv_1.ObjectType.Size, 7, 7);
+                const dilK = react_native_fast_opencv_1.OpenCV.invoke('getStructuringElement', 0 /* RECT */, dilSz);
+                const dilOut = 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('morphologyEx', cannyOut, dilOut, 1 /* MORPH_DILATE */, dilK);
+                // MORPH_CLOSE lần nữa trên edge image để đóng gap
+                const closeSz2 = react_native_fast_opencv_1.OpenCV.createObject(react_native_fast_opencv_1.ObjectType.Size, 11, 11);
+                const closeK2 = react_native_fast_opencv_1.OpenCV.invoke('getStructuringElement', 0 /* RECT */, closeSz2);
+                const closedEdge = 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('morphologyEx', dilOut, closedEdge, 3 /* MORPH_CLOSE */, closeK2);
+                const cnt2 = react_native_fast_opencv_1.OpenCV.createObject(react_native_fast_opencv_1.ObjectType.MatVector);
+                const hier2 = 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', closedEdge, cnt2, hier2, 0 /* RETR_EXTERNAL */, 2 /* CHAIN_APPROX_SIMPLE */);
+                const js2 = react_native_fast_opencv_1.OpenCV.toJSValue(cnt2);
+                const sz2 = (_d = (_c = js2 === null || js2 === void 0 ? void 0 : js2.array) === null || _c === void 0 ? void 0 : _c.length) !== null && _d !== void 0 ? _d : 0;
+                console.log(`[DocDetect] P2(CannyStrong): ${sz2} contours`);
+                if (sz2 > 0) {
+                    const r2 = this.findBestQuad(cnt2, sz2, imgArea, MIN_AREA, 'P2');
+                    if (r2) {
+                        allDebug.push(...r2.debug);
+                        if (!winner || r2.area > winner.area) {
+                            winner = { poly: r2.poly, area: r2.area, angleRange: r2.angleRange };
+                        }
+                    }
+                }
             }
-            // Lấy top 5 contour lớn nhất (đúng như Python: cnts[:5])
-            const allContourMetrics = [];
-            let maxContourArea = 0;
-            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 > maxContourArea)
-                    maxContourArea = area;
-                allContourMetrics.push({ index: i, area, contour });
+            catch (p2Err) {
+                console.log('[DocDetect] P2 failed:', p2Err);
             }
-            allContourMetrics.sort((a, b) => b.area - a.area);
-            const top5 = allContourMetrics.slice(0, 5);
-            console.log(`[DocDetect] top5 areas: ${top5.map(m => m.area.toFixed(0)).join(', ')} | imgArea=${imgArea.toFixed(0)}`);
-            // MIN_QUAD_AREA_RATIO = 0.25 (Python gốc), với fallback 0.05 cho ảnh nhỏ
-            const MIN_QUAD_AREA_RATIO = imgArea > 50000 ? 0.25 : 0.05;
-            let bestPoly = undefined;
-            let bestArea = 0;
-            let bestAngleRange = 999;
-            const debugCandidates = [];
-            for (let i = 0; i < top5.length; i++) {
-                const metric = top5[i];
-                const contour = metric.contour;
-                // Python gốc dùng epsilon = 80 pixel tuyệt đối (không phải % perimeter!)
-                // approxPolyDP(c, 80, True) — epsilon cố định
-                // Ta thử range 10→100 pixel, bước 10, để tìm ra 4 đỉnh
-                let foundPts = null;
-                let foundVerts = 0;
-                let foundAngle = 999;
-                for (let epPx = 10; epPx <= 120; epPx += 5) {
-                    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, epPx, true);
-                    const approxJS = react_native_fast_opencv_1.OpenCV.toJSValue(approx);
-                    const verts = (_b = (_a = approxJS === null || approxJS === void 0 ? void 0 : approxJS.array) === null || _a === void 0 ? void 0 : _a.length) !== null && _b !== void 0 ? _b : 0;
-                    if (verts === 4) {
-                        const pts = approxJS.array;
-                        const sorted = this.sortCorners([...pts]);
-                        const angleRange = this.getAngleRange(sorted);
-                        if (angleRange < foundAngle) {
-                            foundAngle = angleRange;
-                            foundPts = pts;
-                            foundVerts = verts;
-                        }
-                        // is_valid_contour: area > MIN_QUAD_AREA_RATIO và angle_range < 40
-                        if (metric.area > imgArea * MIN_QUAD_AREA_RATIO && angleRange < 40) {
-                            if (metric.area > bestArea || (metric.area === bestArea && angleRange < bestAngleRange)) {
-                                bestPoly = pts;
-                                bestArea = metric.area;
-                                bestAngleRange = angleRange;
-                            }
-                            break;
+            // ═══════════════════════════════════════════════════════════════
+            // PIPELINE 3: OTSU threshold (binary toàn cục)
+            //
+            // Cho ảnh có tương phản rõ giữa tài liệu và nền.
+            // ═══════════════════════════════════════════════════════════════
+            try {
+                const otsu = react_native_fast_opencv_1.OpenCV.createObject(react_native_fast_opencv_1.ObjectType.Mat, 0, 0, react_native_fast_opencv_1.DataTypes.CV_8U);
+                // threshold type = THRESH_BINARY_INV + THRESH_OTSU = 1 + 8 = 9
+                react_native_fast_opencv_1.OpenCV.invoke('threshold', blurred, otsu, 0, 255, 9);
+                // MORPH_CLOSE lớn để nối vùng
+                const oCloseSz = react_native_fast_opencv_1.OpenCV.createObject(react_native_fast_opencv_1.ObjectType.Size, 15, 15);
+                const oCloseK = react_native_fast_opencv_1.OpenCV.invoke('getStructuringElement', 0 /* RECT */, oCloseSz);
+                const otsuClosed = 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('morphologyEx', otsu, otsuClosed, 3 /* MORPH_CLOSE */, oCloseK);
+                const cnt3 = react_native_fast_opencv_1.OpenCV.createObject(react_native_fast_opencv_1.ObjectType.MatVector);
+                const hier3 = 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', otsuClosed, cnt3, hier3, 0 /* RETR_EXTERNAL */, 2 /* CHAIN_APPROX_SIMPLE */);
+                const js3 = react_native_fast_opencv_1.OpenCV.toJSValue(cnt3);
+                const sz3 = (_f = (_e = js3 === null || js3 === void 0 ? void 0 : js3.array) === null || _e === void 0 ? void 0 : _e.length) !== null && _f !== void 0 ? _f : 0;
+                console.log(`[DocDetect] P3(OTSU): ${sz3} contours`);
+                if (sz3 > 0) {
+                    const r3 = this.findBestQuad(cnt3, sz3, imgArea, MIN_AREA, 'P3');
+                    if (r3) {
+                        allDebug.push(...r3.debug);
+                        if (!winner || r3.area > winner.area) {
+                            winner = { poly: r3.poly, area: r3.area, angleRange: r3.angleRange };
                         }
                     }
                 }
-                debugCandidates.push(`  [C${i}] area=${metric.area.toFixed(0)}px²(${(metric.area / imgArea * 100).toFixed(1)}%) ` +
-                    `foundVerts=${foundVerts} bestAngle=${foundAngle === 999 ? 'N/A' : foundAngle.toFixed(1)}° ` +
-                    `valid=${metric.area > imgArea * MIN_QUAD_AREA_RATIO && foundAngle < 40}`);
             }
-            console.log(`[DocDetect] Candidates:\n${debugCandidates.join('\n')}`);
-            console.log(`[DocDetect] Result: bestPoly=${bestPoly ? 'found' : 'NOT FOUND'} area=${bestArea.toFixed(0)} angleRange=${bestAngleRange === 999 ? 'N/A' : bestAngleRange.toFixed(1)}°`);
-            // BƯỚC 7: Trả về góc, scale về kích thước ảnh gốc
-            if (bestPoly && bestPoly.length === 4) {
-                const actualRatio = (resized === src) ? 1.0 : ratio;
-                const originalCorners = bestPoly.map(p => ({
-                    x: Math.round(p.x * actualRatio),
-                    y: Math.round(p.y * actualRatio)
+            catch (p3Err) {
+                console.log('[DocDetect] P3 failed:', p3Err);
+            }
+            // ═══════════════════════════════════════════════════════════════
+            // Trả kết quả
+            // ═══════════════════════════════════════════════════════════════
+            console.log(`[DocDetect] All debug:\n${allDebug.join('\n')}`);
+            if (winner) {
+                console.log(`[DocDetect] ✓ Winner: area=${winner.area.toFixed(0)}(${(winner.area / imgArea * 100).toFixed(1)}%) angle=${winner.angleRange.toFixed(1)}°`);
+                const originalCorners = winner.poly.map(p => ({
+                    x: Math.round(p.x * ratio),
+                    y: Math.round(p.y * ratio)
                 }));
                 return this.sortCorners(originalCorners);
             }
-            // Giống Python gốc: nếu không tìm được → dùng toàn bộ ảnh làm fallback
-            // "If we did not find any valid contours, just use the whole image"
-            console.log(`[DocDetect] No valid quad found (minArea=${(MIN_QUAD_AREA_RATIO * 100).toFixed(0)}%, maxContour=${maxContourArea.toFixed(0)}px²). Fallback to full image.`);
+            // Không pipeline nào thành công
+            console.log('[DocDetect] ✗ All pipelines failed');
             throw new Error(`Không phát hiện được viền tài liệu.\n` +
                 `Ảnh: ${origCols}x${origRows}px | Resize: ${targetWidth}x${targetHeight}px\n` +
-                `Contours kiểm tra: ${top5.length}/${contoursSize} | MinArea: ${(MIN_QUAD_AREA_RATIO * 100).toFixed(0)}%\n` +
-                `Contour lớn nhất: ${maxContourArea.toFixed(0)}px² (${(maxContourArea / imgArea * 100).toFixed(1)}% ảnh)\n` +
-                `Chi tiết:\n${debugCandidates.join('\n')}\n` +
-                `Gợi ý: Tài liệu cần chiếm ít nhất ${(MIN_QUAD_AREA_RATIO * 100).toFixed(0)}% diện tích khung hình, viền phải tương phản với nền.`);
+                `MinArea: ${(MIN_AREA * 100).toFixed(0)}%\n` +
+                `Chi tiết:\n${allDebug.join('\n')}\n` +
+                `Gợi ý: Hãy đảm bảo tài liệu chiếm ≥15% khung hình, viền rõ ràng, nền tương phản.`);
         }
         catch (e) {
             // Trích message từ mọi dạng exception (Error object, string, native, undefined...)

package/package.json

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

@@ -69,20 +69,94 @@ export class DocumentScanner {
         ];
     }
 
-    public static detectPageCorners(imageBase64: string): Point[] | undefined {
-        let src: OpenCVMat | null = null;
-        let resized: OpenCVMat | null = null;
-        let gray: OpenCVMat | null = null;
-        let blurred: OpenCVMat | null = null;
-        let closed: OpenCVMat | null = null;
-        let edges: OpenCVMat | null = null;
-        let dilated: OpenCVMat | null = null;
-        let contoursObj: any = null;
-        let hierarchyObj: any = null;
+    /**
+     * Tìm tứ giác tốt nhất từ một MatVector contours.
+     * Trả về { poly, area, angleRange } hoặc null nếu không tìm được.
+     */
+    private static findBestQuad(
+        contoursObj: any,
+        contoursSize: number,
+        imgArea: number,
+        minAreaRatio: number,
+        pipelineName: string,
+    ): { poly: Point[]; area: number; angleRange: number; debug: string[] } | null {
+        const allMetrics: { area: number; contour: any }[] = [];
+        let maxRawArea = 0;
+
+        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 > maxRawArea) maxRawArea = area;
+            allMetrics.push({ area, contour });
+        }
+        allMetrics.sort((a, b) => b.area - a.area);
+        const top = allMetrics.slice(0, 5);
+
+        let bestPoly: Point[] | undefined;
+        let bestArea = 0;
+        let bestAngle = 999;
+        const debug: string[] = [];
+
+        for (let i = 0; i < top.length; i++) {
+            const m = top[i];
+
+            // Thử nhiều epsilon (10→120px) để approxPolyDP ra đúng 4 đỉnh
+            let fPts: Point[] | null = null;
+            let fVerts = 0;
+            let fAngle = 999;
+            let fApproxArea = 0;
+
+            for (let ep = 10; ep <= 120; ep += 5) {
+                const approx = OpenCV.createObject(ObjectType.PointVector);
+                OpenCV.invoke('approxPolyDP', m.contour, approx, ep, true);
+                const approxJS = OpenCV.toJSValue(approx);
+                const verts = approxJS?.array?.length ?? 0;
+
+                if (verts === 4) {
+                    const pts = approxJS.array as Point[];
+                    const sorted = this.sortCorners([...pts]);
+                    const angleRange = this.getAngleRange(sorted);
+
+                    // Lấy diện tích polygon 4-điểm (đúng như Python: contourArea(approx))
+                    const aObj = OpenCV.invoke('contourArea', approx);
+                    const approxArea = aObj ? (aObj.value ?? 0) : 0;
+
+                    if (angleRange < fAngle) {
+                        fAngle = angleRange;
+                        fPts = pts;
+                        fVerts = verts;
+                        fApproxArea = approxArea;
+                    }
+
+                    if (approxArea > imgArea * minAreaRatio && angleRange < 40) {
+                        if (approxArea > bestArea || (approxArea === bestArea && angleRange < bestAngle)) {
+                            bestPoly = pts;
+                            bestArea = approxArea;
+                            bestAngle = angleRange;
+                        }
+                        break;
+                    }
+                }
+            }
+
+            debug.push(
+                `  [${pipelineName}:C${i}] raw=${m.area.toFixed(0)}(${(m.area/imgArea*100).toFixed(1)}%) ` +
+                `approx=${fApproxArea > 0 ? fApproxArea.toFixed(0)+'('+((fApproxArea/imgArea*100).toFixed(1))+'%)' : '-'} ` +
+                `v=${fVerts} a=${fAngle === 999 ? '-' : fAngle.toFixed(1)}° ` +
+                `ok=${fApproxArea > imgArea * minAreaRatio && fAngle < 40}`
+            );
+        }
+
+        if (bestPoly && bestPoly.length === 4) {
+            return { poly: bestPoly, area: bestArea, angleRange: bestAngle, debug };
+        }
+        return null;
+    }
 
+    public static detectPageCorners(imageBase64: string): Point[] | undefined {
         try {
-            src = OpenCV.base64ToMat(imageBase64);
-            
+            const src = OpenCV.base64ToMat(imageBase64);
             const jsSrc = OpenCV.toJSValue(src);
             const origCols = jsSrc.cols || 1000;
             const origRows = jsSrc.rows || 1000;
@@ -91,168 +165,183 @@ export class DocumentScanner {
             const ratio = origRows / targetHeight;
             const targetWidth = Math.max(1, Math.round(origCols / ratio));
 
-            resized = OpenCV.createObject(ObjectType.Mat, 0, 0, DataTypes.CV_8U);
+            const resized = OpenCV.createObject(ObjectType.Mat, 0, 0, DataTypes.CV_8U);
             const dstSize = OpenCV.createObject(ObjectType.Size, targetWidth, targetHeight);
-            
             try {
                 OpenCV.invoke('resize', src, resized, dstSize, 0, 0, 1 /* INTER_LINEAR */);
-            } catch (err) {
-                resized = src; // Fallback an toàn
+            } catch (_) {
+                // nếu resize fail, dùng src gốc — ratio=1
             }
 
-            // BƯỚC 1: Chuyển sang ảnh xám (Grayscale)
-            gray = OpenCV.createObject(ObjectType.Mat, 0, 0, DataTypes.CV_8U);
+            // Grayscale + Blur
+            const gray = OpenCV.createObject(ObjectType.Mat, 0, 0, DataTypes.CV_8U);
             OpenCV.invoke('cvtColor', resized, gray, ColorConversionCodes.COLOR_BGR2GRAY);
 
-            // BƯỚC 2: GaussianBlur 7x7 (theo andrewdcampbell)
-            blurred = OpenCV.createObject(ObjectType.Mat, 0, 0, DataTypes.CV_8U);
+            const blurred = OpenCV.createObject(ObjectType.Mat, 0, 0, DataTypes.CV_8U);
             const ksize = OpenCV.createObject(ObjectType.Size, 7, 7);
             OpenCV.invoke('GaussianBlur', gray, blurred, ksize, 0);
 
-            // BƯỚC 3: MORPH_CLOSE (kernel RECT 9x9) – nối các lỗ trống giữa cạnh viền
-            // Thiếu bước này là nguyên nhân chính khiến contour bị đứt đoạn
-            const MORPH_SIZE = 9;
-            const morphKernelSize = OpenCV.createObject(ObjectType.Size, MORPH_SIZE, MORPH_SIZE);
-            const morphKernel = OpenCV.invoke('getStructuringElement', 0 /* MORPH_RECT */, morphKernelSize);
-            closed = OpenCV.createObject(ObjectType.Mat, 0, 0, DataTypes.CV_8U);
-            let morphCloseUsed = true;
+            const imgArea = targetWidth * targetHeight;
+            const MIN_AREA = 0.15; // 15% — khoan dung hơn Python gốc (25%)
+
+            const allDebug: string[] = [];
+            let winner: { poly: Point[]; area: number; angleRange: number } | null = null;
+
+            // ═══════════════════════════════════════════════════════════════
+            // PIPELINE 1: Adaptive Threshold → contour KÍN (method chính)
+            //
+            // Adaptive threshold tạo ảnh binary phân biệt foreground/background.
+            // findContours trên binary image cho contour KÍN → area = diện tích thật.
+            // Đây thay thế LSD line detection (không có trong react-native-fast-opencv).
+            // ═══════════════════════════════════════════════════════════════
             try {
-                OpenCV.invoke('morphologyEx', blurred, closed, 3 /* MORPH_CLOSE */, morphKernel);
-            } catch (_morphErr) {
-                closed = blurred; // Fallback nếu thiết bị không hỗ trợ
-                morphCloseUsed = false;
+                const adaptive = OpenCV.createObject(ObjectType.Mat, 0, 0, DataTypes.CV_8U);
+                // ADAPTIVE_THRESH_GAUSSIAN_C = 1, THRESH_BINARY_INV = 1
+                // blockSize=15 (must be odd), C=10
+                OpenCV.invoke('adaptiveThreshold', blurred, adaptive,
+                    255, 1 /* GAUSSIAN_C */, 1 /* BINARY_INV */, 15, 10);
+
+                // MORPH_CLOSE để nối vùng tài liệu lại — kernel lớn 15x15
+                const closeKSz = OpenCV.createObject(ObjectType.Size, 15, 15);
+                const closeK = OpenCV.invoke('getStructuringElement', 0 /* RECT */, closeKSz);
+                const adaptClosed = OpenCV.createObject(ObjectType.Mat, 0, 0, DataTypes.CV_8U);
+                OpenCV.invoke('morphologyEx', adaptive, adaptClosed, 3 /* MORPH_CLOSE */, closeK);
+
+                const cnt1 = OpenCV.createObject(ObjectType.MatVector);
+                const hier1 = OpenCV.createObject(ObjectType.Mat, 0, 0, DataTypes.CV_8U);
+                OpenCV.invoke('findContoursWithHierarchy', adaptClosed, cnt1, hier1,
+                    0 /* RETR_EXTERNAL */, 2 /* CHAIN_APPROX_SIMPLE */);
+
+                const js1 = OpenCV.toJSValue(cnt1);
+                const sz1 = js1?.array?.length ?? 0;
+                console.log(`[DocDetect] P1(AdaptThresh): ${sz1} contours`);
+
+                if (sz1 > 0) {
+                    const r1 = this.findBestQuad(cnt1, sz1, imgArea, MIN_AREA, 'P1');
+                    if (r1) {
+                        allDebug.push(...r1.debug);
+                        if (!winner || r1.area > winner.area) {
+                            winner = { poly: r1.poly, area: r1.area, angleRange: r1.angleRange };
+                        }
+                    } else if (r1 === null) {
+                        // Ghi debug dù không tìm được
+                    }
+                }
+            } catch (p1Err) {
+                console.log('[DocDetect] P1 failed:', p1Err);
             }
 
-            // BƯỚC 4: Canny (0, 84) – ngưỡng thấp theo andrewdcampbell
-            // threshold1=0: chấp nhận TẤT CẢ cạnh yếu nếu liên kết với cạnh mạnh
-            // threshold2=84: ngưỡng cạnh mạnh vừa phải
-            edges = OpenCV.createObject(ObjectType.Mat, 0, 0, DataTypes.CV_8U);
-            OpenCV.invoke('Canny', closed, edges, 0, 84);
-
-            // BƯỚC 5: Dilate 3x3 – nối các pixel viền lân cận bị đứt
-            const dilKernelSize = OpenCV.createObject(ObjectType.Size, 3, 3);
-            const dilKernel = OpenCV.invoke('getStructuringElement', 0 /* MORPH_RECT */, dilKernelSize);
-            dilated = OpenCV.createObject(ObjectType.Mat, 0, 0, DataTypes.CV_8U);
-            let dilateUsed = true;
+            // ═══════════════════════════════════════════════════════════════
+            // PIPELINE 2: Canny (giống Python gốc andrewdcampbell)
+            //
+            // MORPH_CLOSE trên grayscale → Canny → dilate mạnh → contours.
+            // Dilate 7x7 x2 iterations để NỐI edge fragments thành contour kín.
+            // ═══════════════════════════════════════════════════════════════
             try {
-                OpenCV.invoke('morphologyEx', edges, dilated, 1 /* MORPH_DILATE */, dilKernel);
-            } catch (_dilErr) {
-                dilated = edges; // Fallback
-                dilateUsed = false;
-            }
-
-            // BƯỚC 6: Tìm Contours — dùng RETR_EXTERNAL (đúng như Python gốc, không phải RETR_LIST)
-            contoursObj = OpenCV.createObject(ObjectType.MatVector);
-            hierarchyObj = OpenCV.createObject(ObjectType.Mat, 0, 0, DataTypes.CV_8U);
-            OpenCV.invoke('findContoursWithHierarchy', dilated, contoursObj, hierarchyObj,
-                0 /* RETR_EXTERNAL */, 2 /* CHAIN_APPROX_SIMPLE */);
-
-            const contoursJS = OpenCV.toJSValue(contoursObj);
-            const contoursArray = contoursJS?.array || [];
-            const contoursSize = contoursArray.length;
-
-            const imgArea = targetWidth * targetHeight;
-            console.log(`[DocDetect] imgSize=${origCols}x${origRows} → resize=${targetWidth}x${targetHeight} | morphClose=${morphCloseUsed} dilate=${dilateUsed} | totalContours=${contoursSize}`);
-
-            if (contoursSize === 0) {
-                // Fallback: trả toàn bộ ảnh (như Python gốc)
-                console.log('[DocDetect] contoursSize=0, fallback to full image');
-                return this.buildFullImageCorners(origCols, origRows);
-            }
-
-            // Lấy top 5 contour lớn nhất (đúng như Python: cnts[:5])
-            const allContourMetrics = [];
-            let maxContourArea = 0;
-            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 > maxContourArea) maxContourArea = area;
-                allContourMetrics.push({ index: i, area, contour });
-            }
-            allContourMetrics.sort((a, b) => b.area - a.area);
-            const top5 = allContourMetrics.slice(0, 5);
-
-            console.log(`[DocDetect] top5 areas: ${top5.map(m => m.area.toFixed(0)).join(', ')} | imgArea=${imgArea.toFixed(0)}`);
-
-            // MIN_QUAD_AREA_RATIO = 0.25 (Python gốc), với fallback 0.05 cho ảnh nhỏ
-            const MIN_QUAD_AREA_RATIO = imgArea > 50000 ? 0.25 : 0.05;
-
-            let bestPoly: Point[] | undefined = undefined;
-            let bestArea = 0;
-            let bestAngleRange = 999;
-            const debugCandidates: string[] = [];
-
-            for (let i = 0; i < top5.length; i++) {
-                const metric = top5[i];
-                const contour = metric.contour;
-
-                // Python gốc dùng epsilon = 80 pixel tuyệt đối (không phải % perimeter!)
-                // approxPolyDP(c, 80, True) — epsilon cố định
-                // Ta thử range 10→100 pixel, bước 10, để tìm ra 4 đỉnh
-                let foundPts: Point[] | null = null;
-                let foundVerts = 0;
-                let foundAngle = 999;
-
-                for (let epPx = 10; epPx <= 120; epPx += 5) {
-                    const approx = OpenCV.createObject(ObjectType.PointVector);
-                    OpenCV.invoke('approxPolyDP', contour, approx, epPx, true);
-                    const approxJS = OpenCV.toJSValue(approx);
-                    const verts = approxJS?.array?.length ?? 0;
-
-                    if (verts === 4) {
-                        const pts = approxJS.array as Point[];
-                        const sorted = this.sortCorners([...pts]);
-                        const angleRange = this.getAngleRange(sorted);
-
-                        if (angleRange < foundAngle) {
-                            foundAngle = angleRange;
-                            foundPts = pts;
-                            foundVerts = verts;
+                // MORPH_CLOSE 9x9 trên grayscale (đúng Python)
+                const morphSz = OpenCV.createObject(ObjectType.Size, 9, 9);
+                const morphK = OpenCV.invoke('getStructuringElement', 0 /* RECT */, morphSz);
+                const morphed = OpenCV.createObject(ObjectType.Mat, 0, 0, DataTypes.CV_8U);
+                OpenCV.invoke('morphologyEx', blurred, morphed, 3 /* MORPH_CLOSE */, morphK);
+
+                // Canny (0, 84)
+                const cannyOut = OpenCV.createObject(ObjectType.Mat, 0, 0, DataTypes.CV_8U);
+                OpenCV.invoke('Canny', morphed, cannyOut, 0, 84);
+
+                // Dilate MẠNH: kernel 7x7 — nối edge fragments lại thành contour kín
+                const dilSz = OpenCV.createObject(ObjectType.Size, 7, 7);
+                const dilK = OpenCV.invoke('getStructuringElement', 0 /* RECT */, dilSz);
+                const dilOut = OpenCV.createObject(ObjectType.Mat, 0, 0, DataTypes.CV_8U);
+                OpenCV.invoke('morphologyEx', cannyOut, dilOut, 1 /* MORPH_DILATE */, dilK);
+
+                // MORPH_CLOSE lần nữa trên edge image để đóng gap
+                const closeSz2 = OpenCV.createObject(ObjectType.Size, 11, 11);
+                const closeK2 = OpenCV.invoke('getStructuringElement', 0 /* RECT */, closeSz2);
+                const closedEdge = OpenCV.createObject(ObjectType.Mat, 0, 0, DataTypes.CV_8U);
+                OpenCV.invoke('morphologyEx', dilOut, closedEdge, 3 /* MORPH_CLOSE */, closeK2);
+
+                const cnt2 = OpenCV.createObject(ObjectType.MatVector);
+                const hier2 = OpenCV.createObject(ObjectType.Mat, 0, 0, DataTypes.CV_8U);
+                OpenCV.invoke('findContoursWithHierarchy', closedEdge, cnt2, hier2,
+                    0 /* RETR_EXTERNAL */, 2 /* CHAIN_APPROX_SIMPLE */);
+
+                const js2 = OpenCV.toJSValue(cnt2);
+                const sz2 = js2?.array?.length ?? 0;
+                console.log(`[DocDetect] P2(CannyStrong): ${sz2} contours`);
+
+                if (sz2 > 0) {
+                    const r2 = this.findBestQuad(cnt2, sz2, imgArea, MIN_AREA, 'P2');
+                    if (r2) {
+                        allDebug.push(...r2.debug);
+                        if (!winner || r2.area > winner.area) {
+                            winner = { poly: r2.poly, area: r2.area, angleRange: r2.angleRange };
                         }
+                    }
+                }
+            } catch (p2Err) {
+                console.log('[DocDetect] P2 failed:', p2Err);
+            }
 
-                        // is_valid_contour: area > MIN_QUAD_AREA_RATIO và angle_range < 40
-                        if (metric.area > imgArea * MIN_QUAD_AREA_RATIO && angleRange < 40) {
-                            if (metric.area > bestArea || (metric.area === bestArea && angleRange < bestAngleRange)) {
-                                bestPoly = pts;
-                                bestArea = metric.area;
-                                bestAngleRange = angleRange;
-                            }
-                            break;
+            // ═══════════════════════════════════════════════════════════════
+            // PIPELINE 3: OTSU threshold (binary toàn cục)
+            //
+            // Cho ảnh có tương phản rõ giữa tài liệu và nền.
+            // ═══════════════════════════════════════════════════════════════
+            try {
+                const otsu = OpenCV.createObject(ObjectType.Mat, 0, 0, DataTypes.CV_8U);
+                // threshold type = THRESH_BINARY_INV + THRESH_OTSU = 1 + 8 = 9
+                OpenCV.invoke('threshold', blurred, otsu, 0, 255, 9);
+
+                // MORPH_CLOSE lớn để nối vùng
+                const oCloseSz = OpenCV.createObject(ObjectType.Size, 15, 15);
+                const oCloseK = OpenCV.invoke('getStructuringElement', 0 /* RECT */, oCloseSz);
+                const otsuClosed = OpenCV.createObject(ObjectType.Mat, 0, 0, DataTypes.CV_8U);
+                OpenCV.invoke('morphologyEx', otsu, otsuClosed, 3 /* MORPH_CLOSE */, oCloseK);
+
+                const cnt3 = OpenCV.createObject(ObjectType.MatVector);
+                const hier3 = OpenCV.createObject(ObjectType.Mat, 0, 0, DataTypes.CV_8U);
+                OpenCV.invoke('findContoursWithHierarchy', otsuClosed, cnt3, hier3,
+                    0 /* RETR_EXTERNAL */, 2 /* CHAIN_APPROX_SIMPLE */);
+
+                const js3 = OpenCV.toJSValue(cnt3);
+                const sz3 = js3?.array?.length ?? 0;
+                console.log(`[DocDetect] P3(OTSU): ${sz3} contours`);
+
+                if (sz3 > 0) {
+                    const r3 = this.findBestQuad(cnt3, sz3, imgArea, MIN_AREA, 'P3');
+                    if (r3) {
+                        allDebug.push(...r3.debug);
+                        if (!winner || r3.area > winner.area) {
+                            winner = { poly: r3.poly, area: r3.area, angleRange: r3.angleRange };
                         }
                     }
                 }
-
-                debugCandidates.push(
-                    `  [C${i}] area=${metric.area.toFixed(0)}px²(${(metric.area/imgArea*100).toFixed(1)}%) ` +
-                    `foundVerts=${foundVerts} bestAngle=${foundAngle === 999 ? 'N/A' : foundAngle.toFixed(1)}° ` +
-                    `valid=${metric.area > imgArea * MIN_QUAD_AREA_RATIO && foundAngle < 40}`
-                );
+            } catch (p3Err) {
+                console.log('[DocDetect] P3 failed:', p3Err);
             }
 
-            console.log(`[DocDetect] Candidates:\n${debugCandidates.join('\n')}`);
-            console.log(`[DocDetect] Result: bestPoly=${bestPoly ? 'found' : 'NOT FOUND'} area=${bestArea.toFixed(0)} angleRange=${bestAngleRange === 999 ? 'N/A' : bestAngleRange.toFixed(1)}°`);
+            // ═══════════════════════════════════════════════════════════════
+            // Trả kết quả
+            // ═══════════════════════════════════════════════════════════════
+            console.log(`[DocDetect] All debug:\n${allDebug.join('\n')}`);
 
-            // BƯỚC 7: Trả về góc, scale về kích thước ảnh gốc
-            if (bestPoly && bestPoly.length === 4) {
-                const actualRatio = (resized === src) ? 1.0 : ratio;
-                const originalCorners = bestPoly.map(p => ({
-                    x: Math.round(p.x * actualRatio),
-                    y: Math.round(p.y * actualRatio)
+            if (winner) {
+                console.log(`[DocDetect] ✓ Winner: area=${winner.area.toFixed(0)}(${(winner.area/imgArea*100).toFixed(1)}%) angle=${winner.angleRange.toFixed(1)}°`);
+                const originalCorners = winner.poly.map(p => ({
+                    x: Math.round(p.x * ratio),
+                    y: Math.round(p.y * ratio)
                 }));
                 return this.sortCorners(originalCorners);
             }
 
-            // Giống Python gốc: nếu không tìm được → dùng toàn bộ ảnh làm fallback
-            // "If we did not find any valid contours, just use the whole image"
-            console.log(`[DocDetect] No valid quad found (minArea=${(MIN_QUAD_AREA_RATIO*100).toFixed(0)}%, maxContour=${maxContourArea.toFixed(0)}px²). Fallback to full image.`);
+            // Không pipeline nào thành công
+            console.log('[DocDetect] ✗ All pipelines failed');
             throw new Error(
                 `Không phát hiện được viền tài liệu.\n` +
                 `Ảnh: ${origCols}x${origRows}px | Resize: ${targetWidth}x${targetHeight}px\n` +
-                `Contours kiểm tra: ${top5.length}/${contoursSize} | MinArea: ${(MIN_QUAD_AREA_RATIO*100).toFixed(0)}%\n` +
-                `Contour lớn nhất: ${maxContourArea.toFixed(0)}px² (${(maxContourArea/imgArea*100).toFixed(1)}% ảnh)\n` +
-                `Chi tiết:\n${debugCandidates.join('\n')}\n` +
-                `Gợi ý: Tài liệu cần chiếm ít nhất ${(MIN_QUAD_AREA_RATIO*100).toFixed(0)}% diện tích khung hình, viền phải tương phản với nền.`
+                `MinArea: ${(MIN_AREA*100).toFixed(0)}%\n` +
+                `Chi tiết:\n${allDebug.join('\n')}\n` +
+                `Gợi ý: Hãy đảm bảo tài liệu chiếm ≥15% khung hình, viền rõ ràng, nền tương phản.`
             );
         } catch (e: any) {
             // Trích message từ mọi dạng exception (Error object, string, native, undefined...)