react-native-rectangle-doc-scanner 0.60.0 → 0.64.0

package/dist/DocScanner.js

@@ -278,191 +278,157 @@ const DocScanner = ({ onCapture, overlayColor = '#e7a649', autoCapture = true, m
             const element = react_native_fast_opencv_1.OpenCV.invoke('getStructuringElement', react_native_fast_opencv_1.MorphShapes.MORPH_RECT, morphologyKernel);
             step = 'morphologyEx';
             reportStage(step);
+            // MORPH_CLOSE to fill small holes in edges
             react_native_fast_opencv_1.OpenCV.invoke('morphologyEx', mat, mat, react_native_fast_opencv_1.MorphTypes.MORPH_CLOSE, element);
+            // MORPH_OPEN to remove small noise
             react_native_fast_opencv_1.OpenCV.invoke('morphologyEx', mat, mat, react_native_fast_opencv_1.MorphTypes.MORPH_OPEN, element);
-            const ADAPTIVE_THRESH_GAUSSIAN_C = 1;
-            const THRESH_BINARY = 0;
-            const THRESH_OTSU = 8;
             // Bilateral filter for edge-preserving smoothing (better quality than Gaussian)
             step = 'bilateralFilter';
             reportStage(step);
-            let processed = mat;
             try {
                 const tempMat = react_native_fast_opencv_1.OpenCV.createObject(react_native_fast_opencv_1.ObjectType.Mat);
                 react_native_fast_opencv_1.OpenCV.invoke('bilateralFilter', mat, tempMat, 9, 75, 75);
-                processed = tempMat;
+                mat = tempMat;
             }
             catch (error) {
                 if (__DEV__) {
                     console.warn('[DocScanner] bilateralFilter unavailable, falling back to GaussianBlur', error);
                 }
+                step = 'gaussianBlurFallback';
+                reportStage(step);
                 const blurKernel = react_native_fast_opencv_1.OpenCV.createObject(react_native_fast_opencv_1.ObjectType.Size, 5, 5);
                 react_native_fast_opencv_1.OpenCV.invoke('GaussianBlur', mat, mat, blurKernel, 0);
-                processed = mat;
             }
-            // Additional blur and close pass to smooth jagged edges
-            step = 'gaussianBlur';
+            step = 'Canny';
+            reportStage(step);
+            // Configurable Canny parameters for adaptive edge detection
+            react_native_fast_opencv_1.OpenCV.invoke('Canny', mat, mat, CANNY_LOW, CANNY_HIGH);
+            step = 'createContours';
             reportStage(step);
-            const gaussianKernel = react_native_fast_opencv_1.OpenCV.createObject(react_native_fast_opencv_1.ObjectType.Size, 5, 5);
-            react_native_fast_opencv_1.OpenCV.invoke('GaussianBlur', processed, processed, gaussianKernel, 0);
-            react_native_fast_opencv_1.OpenCV.invoke('morphologyEx', processed, processed, react_native_fast_opencv_1.MorphTypes.MORPH_CLOSE, element);
-            const baseMat = react_native_fast_opencv_1.OpenCV.invoke('clone', processed);
+            const contours = react_native_fast_opencv_1.OpenCV.createObject(react_native_fast_opencv_1.ObjectType.PointVectorOfVectors);
+            react_native_fast_opencv_1.OpenCV.invoke('findContours', mat, contours, react_native_fast_opencv_1.RetrievalModes.RETR_EXTERNAL, react_native_fast_opencv_1.ContourApproximationModes.CHAIN_APPROX_SIMPLE);
+            let best = null;
+            let maxArea = 0;
             const frameArea = width * height;
-            const originalArea = frame.width * frame.height;
-            const minEdgeThreshold = Math.max(14, Math.min(frame.width, frame.height) * MIN_EDGE_RATIO);
-            const epsilonValues = [
-                0.001, 0.002, 0.003, 0.004, 0.005, 0.006, 0.007, 0.008, 0.009,
-                0.01, 0.012, 0.015, 0.018, 0.02, 0.025, 0.03, 0.035, 0.04, 0.05,
-                0.06, 0.07, 0.08, 0.09, 0.1, 0.12,
-            ];
-            let bestQuad = null;
-            let bestArea = 0;
-            let convexHullWarned = false;
-            const considerCandidate = (candidate) => {
-                'worklet';
-                if (!candidate) {
-                    return;
+            step = 'toJSValue';
+            reportStage(step);
+            const contourVector = react_native_fast_opencv_1.OpenCV.toJSValue(contours);
+            const contourArray = Array.isArray(contourVector?.array) ? contourVector.array : [];
+            for (let i = 0; i < contourArray.length; i += 1) {
+                step = `contour_${i}_copy`;
+                reportStage(step);
+                const contour = react_native_fast_opencv_1.OpenCV.copyObjectFromVector(contours, i);
+                // Compute absolute area first
+                step = `contour_${i}_area_abs`;
+                reportStage(step);
+                const { value: area } = react_native_fast_opencv_1.OpenCV.invoke('contourArea', contour, false);
+                // Skip extremely small contours, but keep threshold very low to allow distant documents
+                if (typeof area !== 'number' || !isFinite(area)) {
+                    continue;
                 }
-                if (!bestQuad || candidate.area > bestArea) {
-                    bestQuad = candidate.quad;
-                    bestArea = candidate.area;
+                if (area < 50) {
+                    continue;
                 }
-            };
-            const evaluateContours = (inputMat, attemptLabel) => {
-                'worklet';
-                step = `findContours_${attemptLabel}`;
+                step = `contour_${i}_area`; // ratio stage
                 reportStage(step);
-                const contours = react_native_fast_opencv_1.OpenCV.createObject(react_native_fast_opencv_1.ObjectType.PointVectorOfVectors);
-                react_native_fast_opencv_1.OpenCV.invoke('findContours', inputMat, contours, react_native_fast_opencv_1.RetrievalModes.RETR_EXTERNAL, react_native_fast_opencv_1.ContourApproximationModes.CHAIN_APPROX_SIMPLE);
-                const contourVector = react_native_fast_opencv_1.OpenCV.toJSValue(contours);
-                const contourArray = Array.isArray(contourVector?.array) ? contourVector.array : [];
-                let bestLocal = null;
-                for (let i = 0; i < contourArray.length; i += 1) {
-                    step = `${attemptLabel}_contour_${i}_copy`;
-                    reportStage(step);
-                    const contour = react_native_fast_opencv_1.OpenCV.copyObjectFromVector(contours, i);
-                    step = `${attemptLabel}_contour_${i}_area`;
+                const areaRatio = area / frameArea;
+                if (__DEV__) {
+                    console.log('[DocScanner] area', area, 'ratio', areaRatio);
+                }
+                // Skip if area ratio is too small or too large
+                if (areaRatio < 0.0002 || areaRatio > 0.99) {
+                    continue;
+                }
+                // Try to use convex hull for better corner detection
+                let contourToUse = contour;
+                try {
+                    step = `contour_${i}_convexHull`;
                     reportStage(step);
-                    const { value: area } = react_native_fast_opencv_1.OpenCV.invoke('contourArea', contour, false);
-                    if (typeof area !== 'number' || !isFinite(area) || area < 60) {
-                        continue;
-                    }
-                    const resizedRatio = area / frameArea;
-                    if (resizedRatio < 0.00012 || resizedRatio > 0.98) {
-                        continue;
+                    const hull = react_native_fast_opencv_1.OpenCV.createObject(react_native_fast_opencv_1.ObjectType.PointVector);
+                    react_native_fast_opencv_1.OpenCV.invoke('convexHull', contour, hull, false, true);
+                    contourToUse = hull;
+                }
+                catch (err) {
+                    // If convexHull fails, use original contour
+                    if (__DEV__) {
+                        console.warn('[DocScanner] convexHull failed, using original contour');
                     }
-                    let contourToUse = contour;
-                    try {
-                        const hull = react_native_fast_opencv_1.OpenCV.createObject(react_native_fast_opencv_1.ObjectType.PointVector);
-                        react_native_fast_opencv_1.OpenCV.invoke('convexHull', contour, hull, false, true);
-                        contourToUse = hull;
+                }
+                step = `contour_${i}_arcLength`;
+                reportStage(step);
+                const { value: perimeter } = react_native_fast_opencv_1.OpenCV.invoke('arcLength', contourToUse, true);
+                const approx = react_native_fast_opencv_1.OpenCV.createObject(react_native_fast_opencv_1.ObjectType.PointVector);
+                let approxArray = [];
+                // Try more epsilon values from 0.1% to 10% for difficult shapes
+                const epsilonValues = [
+                    0.001, 0.002, 0.003, 0.004, 0.005, 0.006, 0.007, 0.008, 0.009,
+                    0.01, 0.012, 0.015, 0.018, 0.02, 0.025, 0.03, 0.04, 0.05, 0.06, 0.07, 0.08, 0.09, 0.1
+                ];
+                for (let attempt = 0; attempt < epsilonValues.length; attempt += 1) {
+                    const epsilon = epsilonValues[attempt] * perimeter;
+                    step = `contour_${i}_approxPolyDP_attempt_${attempt}`;
+                    reportStage(step);
+                    react_native_fast_opencv_1.OpenCV.invoke('approxPolyDP', contourToUse, approx, epsilon, true);
+                    step = `contour_${i}_toJS_attempt_${attempt}`;
+                    reportStage(step);
+                    const approxValue = react_native_fast_opencv_1.OpenCV.toJSValue(approx);
+                    const candidate = Array.isArray(approxValue?.array) ? approxValue.array : [];
+                    if (__DEV__) {
+                        console.log('[DocScanner] approx length', candidate.length, 'epsilon', epsilon);
                     }
-                    catch (err) {
-                        if (__DEV__ && !convexHullWarned) {
-                            console.warn('[DocScanner] convexHull failed, using original contour');
-                            convexHullWarned = true;
-                        }
+                    if (candidate.length === 4) {
+                        approxArray = candidate;
+                        break;
                     }
-                    const { value: perimeter } = react_native_fast_opencv_1.OpenCV.invoke('arcLength', contourToUse, true);
-                    if (typeof perimeter !== 'number' || !isFinite(perimeter) || perimeter < 80) {
-                        continue;
+                }
+                // Only proceed if we found exactly 4 corners
+                if (approxArray.length !== 4) {
+                    continue;
+                }
+                step = `contour_${i}_convex`;
+                reportStage(step);
+                // Validate points before processing
+                const isValidPoint = (pt) => {
+                    return typeof pt.x === 'number' && typeof pt.y === 'number' &&
+                        !isNaN(pt.x) && !isNaN(pt.y) &&
+                        isFinite(pt.x) && isFinite(pt.y);
+                };
+                if (!approxArray.every(isValidPoint)) {
+                    if (__DEV__) {
+                        console.warn('[DocScanner] invalid points in approxArray', approxArray);
                     }
-                    const approx = react_native_fast_opencv_1.OpenCV.createObject(react_native_fast_opencv_1.ObjectType.PointVector);
-                    let approxArray = [];
-                    for (let attempt = 0; attempt < epsilonValues.length; attempt += 1) {
-                        const epsilon = epsilonValues[attempt] * perimeter;
-                        step = `${attemptLabel}_contour_${i}_approx_${attempt}`;
-                        reportStage(step);
-                        react_native_fast_opencv_1.OpenCV.invoke('approxPolyDP', contourToUse, approx, epsilon, true);
-                        const approxValue = react_native_fast_opencv_1.OpenCV.toJSValue(approx);
-                        const candidate = Array.isArray(approxValue?.array) ? approxValue.array : [];
-                        if (candidate.length === 4) {
-                            approxArray = candidate;
-                            break;
+                    continue;
+                }
+                const points = approxArray.map((pt) => ({
+                    x: pt.x / ratio,
+                    y: pt.y / ratio,
+                }));
+                // Verify the quadrilateral is convex (valid document shape)
+                try {
+                    if (!isConvexQuadrilateral(points)) {
+                        if (__DEV__) {
+                            console.log('[DocScanner] not convex, skipping:', points);
                         }
-                    }
-                    if (approxArray.length !== 4) {
-                        continue;
-                    }
-                    const isValidPoint = (pt) => typeof pt.x === 'number' && typeof pt.y === 'number' && isFinite(pt.x) && isFinite(pt.y);
-                    if (!approxArray.every(isValidPoint)) {
-                        continue;
-                    }
-                    const normalizedPoints = approxArray.map((pt) => ({
-                        x: pt.x / ratio,
-                        y: pt.y / ratio,
-                    }));
-                    if (!isConvexQuadrilateral(normalizedPoints)) {
-                        continue;
-                    }
-                    const sanitized = (0, quad_1.sanitizeQuad)((0, quad_1.orderQuadPoints)(normalizedPoints));
-                    if (!(0, quad_1.isValidQuad)(sanitized)) {
-                        continue;
-                    }
-                    const edges = (0, quad_1.quadEdgeLengths)(sanitized);
-                    const minEdge = Math.min(...edges);
-                    const maxEdge = Math.max(...edges);
-                    if (!Number.isFinite(minEdge) || minEdge < minEdgeThreshold) {
                         continue;
                     }
-                    const aspectRatio = maxEdge / Math.max(minEdge, 1);
-                    if (!Number.isFinite(aspectRatio) || aspectRatio > 8.5) {
-                        continue;
-                    }
-                    const quadAreaValue = (0, quad_1.quadArea)(sanitized);
-                    const originalRatio = originalArea > 0 ? quadAreaValue / originalArea : 0;
-                    if (originalRatio < 0.00012 || originalRatio > 0.92) {
-                        continue;
-                    }
-                    const candidate = {
-                        quad: sanitized,
-                        area: quadAreaValue,
-                    };
-                    if (!bestLocal || candidate.area > bestLocal.area) {
-                        bestLocal = candidate;
+                }
+                catch (err) {
+                    if (__DEV__) {
+                        console.warn('[DocScanner] convex check error:', err, 'points:', points);
                     }
+                    continue;
                 }
-                return bestLocal;
-            };
-            const runCanny = (label, low, high) => {
-                'worklet';
-                const working = react_native_fast_opencv_1.OpenCV.invoke('clone', baseMat);
-                step = `${label}_canny`;
-                reportStage(step);
-                react_native_fast_opencv_1.OpenCV.invoke('Canny', working, working, low, high);
-                react_native_fast_opencv_1.OpenCV.invoke('morphologyEx', working, working, react_native_fast_opencv_1.MorphTypes.MORPH_CLOSE, element);
-                considerCandidate(evaluateContours(working, label));
-            };
-            const runAdaptive = (label, blockSize, c) => {
-                'worklet';
-                const working = react_native_fast_opencv_1.OpenCV.invoke('clone', baseMat);
-                step = `${label}_adaptive`;
-                reportStage(step);
-                react_native_fast_opencv_1.OpenCV.invoke('adaptiveThreshold', working, working, 255, ADAPTIVE_THRESH_GAUSSIAN_C, THRESH_BINARY, blockSize, c);
-                react_native_fast_opencv_1.OpenCV.invoke('morphologyEx', working, working, react_native_fast_opencv_1.MorphTypes.MORPH_CLOSE, element);
-                considerCandidate(evaluateContours(working, label));
-            };
-            const runOtsu = () => {
-                'worklet';
-                const working = react_native_fast_opencv_1.OpenCV.invoke('clone', baseMat);
-                step = 'otsu_threshold';
-                reportStage(step);
-                react_native_fast_opencv_1.OpenCV.invoke('threshold', working, working, 0, 255, THRESH_BINARY | THRESH_OTSU);
-                react_native_fast_opencv_1.OpenCV.invoke('morphologyEx', working, working, react_native_fast_opencv_1.MorphTypes.MORPH_CLOSE, element);
-                considerCandidate(evaluateContours(working, 'otsu'));
-            };
-            runCanny('canny_primary', CANNY_LOW, CANNY_HIGH);
-            runCanny('canny_soft', Math.max(6, CANNY_LOW * 0.6), Math.max(CANNY_LOW * 1.2, CANNY_HIGH * 0.75));
-            runCanny('canny_hard', Math.max(12, CANNY_LOW * 1.1), CANNY_HIGH * 1.25);
-            runAdaptive('adaptive_19', 19, 7);
-            runAdaptive('adaptive_23', 23, 5);
-            runOtsu();
+                if (area > maxArea) {
+                    best = points;
+                    maxArea = area;
+                }
+            }
             step = 'clearBuffers';
             reportStage(step);
             react_native_fast_opencv_1.OpenCV.clearBuffers();
             step = 'updateQuad';
             reportStage(step);
-            updateQuad(bestQuad);
+            updateQuad(best);
         }
         catch (error) {
             reportError(step, error);

package/dist/index.d.ts

@@ -5,4 +5,3 @@ export type { FullDocScannerResult, FullDocScannerProps, FullDocScannerStrings,
 export type { Point, Quad, Rectangle, CapturedDocument } from './types';
 export type { DetectionConfig } from './DocScanner';
 export { quadToRectangle, rectangleToQuad, scaleCoordinates, scaleRectangle, } from './utils/coordinate';
-export { DocumentDetector } from './utils/documentDetection';

package/dist/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DocumentDetector = exports.scaleRectangle = exports.scaleCoordinates = exports.rectangleToQuad = exports.quadToRectangle = exports.FullDocScanner = exports.CropEditor = exports.DocScanner = void 0;
+exports.scaleRectangle = exports.scaleCoordinates = exports.rectangleToQuad = exports.quadToRectangle = exports.FullDocScanner = exports.CropEditor = exports.DocScanner = void 0;
 // Main components
 var DocScanner_1 = require("./DocScanner");
 Object.defineProperty(exports, "DocScanner", { enumerable: true, get: function () { return DocScanner_1.DocScanner; } });
@@ -14,5 +14,3 @@ Object.defineProperty(exports, "quadToRectangle", { enumerable: true, get: funct
 Object.defineProperty(exports, "rectangleToQuad", { enumerable: true, get: function () { return coordinate_1.rectangleToQuad; } });
 Object.defineProperty(exports, "scaleCoordinates", { enumerable: true, get: function () { return coordinate_1.scaleCoordinates; } });
 Object.defineProperty(exports, "scaleRectangle", { enumerable: true, get: function () { return coordinate_1.scaleRectangle; } });
-var documentDetection_1 = require("./utils/documentDetection");
-Object.defineProperty(exports, "DocumentDetector", { enumerable: true, get: function () { return documentDetection_1.DocumentDetector; } });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-rectangle-doc-scanner",
-  "version": "0.60.0",
+  "version": "0.64.0",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "repository": {

package/src/DocScanner.tsx

@@ -344,225 +344,182 @@ export const DocScanner: React.FC<Props> = ({
       const element = OpenCV.invoke('getStructuringElement', MorphShapes.MORPH_RECT, morphologyKernel);
       step = 'morphologyEx';
       reportStage(step);
+      // MORPH_CLOSE to fill small holes in edges
       OpenCV.invoke('morphologyEx', mat, mat, MorphTypes.MORPH_CLOSE, element);
+      // MORPH_OPEN to remove small noise
       OpenCV.invoke('morphologyEx', mat, mat, MorphTypes.MORPH_OPEN, element);
 
-      const ADAPTIVE_THRESH_GAUSSIAN_C = 1;
-      const THRESH_BINARY = 0;
-      const THRESH_OTSU = 8;
-
       // Bilateral filter for edge-preserving smoothing (better quality than Gaussian)
       step = 'bilateralFilter';
       reportStage(step);
-      let processed = mat;
       try {
         const tempMat = OpenCV.createObject(ObjectType.Mat);
         OpenCV.invoke('bilateralFilter', mat, tempMat, 9, 75, 75);
-        processed = tempMat;
+        mat = tempMat;
       } catch (error) {
         if (__DEV__) {
           console.warn('[DocScanner] bilateralFilter unavailable, falling back to GaussianBlur', error);
         }
+        step = 'gaussianBlurFallback';
+        reportStage(step);
         const blurKernel = OpenCV.createObject(ObjectType.Size, 5, 5);
         OpenCV.invoke('GaussianBlur', mat, mat, blurKernel, 0);
-        processed = mat;
       }
 
-      // Additional blur and close pass to smooth jagged edges
-      step = 'gaussianBlur';
+      step = 'Canny';
+      reportStage(step);
+      // Configurable Canny parameters for adaptive edge detection
+      OpenCV.invoke('Canny', mat, mat, CANNY_LOW, CANNY_HIGH);
+
+      step = 'createContours';
       reportStage(step);
-      const gaussianKernel = OpenCV.createObject(ObjectType.Size, 5, 5);
-      OpenCV.invoke('GaussianBlur', processed, processed, gaussianKernel, 0);
-      OpenCV.invoke('morphologyEx', processed, processed, MorphTypes.MORPH_CLOSE, element);
+      const contours = OpenCV.createObject(ObjectType.PointVectorOfVectors);
+      OpenCV.invoke('findContours', mat, contours, RetrievalModes.RETR_EXTERNAL, ContourApproximationModes.CHAIN_APPROX_SIMPLE);
 
-      const baseMat = OpenCV.invoke('clone', processed);
+      let best: Point[] | null = null;
+      let maxArea = 0;
       const frameArea = width * height;
-      const originalArea = frame.width * frame.height;
-      const minEdgeThreshold = Math.max(14, Math.min(frame.width, frame.height) * MIN_EDGE_RATIO);
-      const epsilonValues = [
-        0.001, 0.002, 0.003, 0.004, 0.005, 0.006, 0.007, 0.008, 0.009,
-        0.01, 0.012, 0.015, 0.018, 0.02, 0.025, 0.03, 0.035, 0.04, 0.05,
-        0.06, 0.07, 0.08, 0.09, 0.1, 0.12,
-      ];
-
-      let bestQuad: Point[] | null = null;
-      let bestArea = 0;
-      let convexHullWarned = false;
-
-      const considerCandidate = (candidate: { quad: Point[]; area: number } | null) => {
-        'worklet';
-        if (!candidate) {
-          return;
-        }
-        if (!bestQuad || candidate.area > bestArea) {
-          bestQuad = candidate.quad;
-          bestArea = candidate.area;
-        }
-      };
 
-      const evaluateContours = (inputMat: unknown, attemptLabel: string): { quad: Point[]; area: number } | null => {
-        'worklet';
+      step = 'toJSValue';
+      reportStage(step);
+      const contourVector = OpenCV.toJSValue(contours);
+      const contourArray = Array.isArray(contourVector?.array) ? contourVector.array : [];
 
-        step = `findContours_${attemptLabel}`;
+      for (let i = 0; i < contourArray.length; i += 1) {
+        step = `contour_${i}_copy`;
         reportStage(step);
-        const contours = OpenCV.createObject(ObjectType.PointVectorOfVectors);
-        OpenCV.invoke('findContours', inputMat, contours, RetrievalModes.RETR_EXTERNAL, ContourApproximationModes.CHAIN_APPROX_SIMPLE);
+        const contour = OpenCV.copyObjectFromVector(contours, i);
 
-        const contourVector = OpenCV.toJSValue(contours);
-        const contourArray = Array.isArray(contourVector?.array) ? contourVector.array : [];
+        // Compute absolute area first
+        step = `contour_${i}_area_abs`;
+        reportStage(step);
+        const { value: area } = OpenCV.invoke('contourArea', contour, false);
 
-        let bestLocal: { quad: Point[]; area: number } | null = null;
+        // Skip extremely small contours, but keep threshold very low to allow distant documents
+        if (typeof area !== 'number' || !isFinite(area)) {
+          continue;
+        }
 
-        for (let i = 0; i < contourArray.length; i += 1) {
-          step = `${attemptLabel}_contour_${i}_copy`;
-          reportStage(step);
-          const contour = OpenCV.copyObjectFromVector(contours, i);
+        if (area < 50) {
+          continue;
+        }
 
-          step = `${attemptLabel}_contour_${i}_area`;
+        step = `contour_${i}_area`; // ratio stage
+        reportStage(step);
+        const areaRatio = area / frameArea;
+
+        if (__DEV__) {
+          console.log('[DocScanner] area', area, 'ratio', areaRatio);
+        }
+
+        // Skip if area ratio is too small or too large
+        if (areaRatio < 0.0002 || areaRatio > 0.99) {
+          continue;
+        }
+
+        // Try to use convex hull for better corner detection
+        let contourToUse = contour;
+        try {
+          step = `contour_${i}_convexHull`;
           reportStage(step);
-          const { value: area } = OpenCV.invoke('contourArea', contour, false);
-          if (typeof area !== 'number' || !isFinite(area) || area < 60) {
-            continue;
+          const hull = OpenCV.createObject(ObjectType.PointVector);
+          OpenCV.invoke('convexHull', contour, hull, false, true);
+          contourToUse = hull;
+        } catch (err) {
+          // If convexHull fails, use original contour
+          if (__DEV__) {
+            console.warn('[DocScanner] convexHull failed, using original contour');
           }
+        }
 
-          const resizedRatio = area / frameArea;
-          if (resizedRatio < 0.00012 || resizedRatio > 0.98) {
-            continue;
-          }
+        step = `contour_${i}_arcLength`;
+        reportStage(step);
+        const { value: perimeter } = OpenCV.invoke('arcLength', contourToUse, true);
+        const approx = OpenCV.createObject(ObjectType.PointVector);
 
-          let contourToUse = contour;
-          try {
-            const hull = OpenCV.createObject(ObjectType.PointVector);
-            OpenCV.invoke('convexHull', contour, hull, false, true);
-            contourToUse = hull;
-          } catch (err) {
-            if (__DEV__ && !convexHullWarned) {
-              console.warn('[DocScanner] convexHull failed, using original contour');
-              convexHullWarned = true;
-            }
-          }
+        let approxArray: Array<{ x: number; y: number }> = [];
 
-          const { value: perimeter } = OpenCV.invoke('arcLength', contourToUse, true);
-          if (typeof perimeter !== 'number' || !isFinite(perimeter) || perimeter < 80) {
-            continue;
-          }
+        // Try more epsilon values from 0.1% to 10% for difficult shapes
+        const epsilonValues = [
+          0.001, 0.002, 0.003, 0.004, 0.005, 0.006, 0.007, 0.008, 0.009,
+          0.01, 0.012, 0.015, 0.018, 0.02, 0.025, 0.03, 0.04, 0.05, 0.06, 0.07, 0.08, 0.09, 0.1
+        ];
 
-          const approx = OpenCV.createObject(ObjectType.PointVector);
-          let approxArray: Array<{ x: number; y: number }> = [];
+        for (let attempt = 0; attempt < epsilonValues.length; attempt += 1) {
+          const epsilon = epsilonValues[attempt] * perimeter;
+          step = `contour_${i}_approxPolyDP_attempt_${attempt}`;
+          reportStage(step);
+          OpenCV.invoke('approxPolyDP', contourToUse, approx, epsilon, true);
 
-          for (let attempt = 0; attempt < epsilonValues.length; attempt += 1) {
-            const epsilon = epsilonValues[attempt] * perimeter;
-            step = `${attemptLabel}_contour_${i}_approx_${attempt}`;
-            reportStage(step);
-            OpenCV.invoke('approxPolyDP', contourToUse, approx, epsilon, true);
+          step = `contour_${i}_toJS_attempt_${attempt}`;
+          reportStage(step);
+          const approxValue = OpenCV.toJSValue(approx);
+          const candidate = Array.isArray(approxValue?.array) ? approxValue.array : [];
 
-            const approxValue = OpenCV.toJSValue(approx);
-            const candidate = Array.isArray(approxValue?.array) ? approxValue.array : [];
-            if (candidate.length === 4) {
-              approxArray = candidate as Array<{ x: number; y: number }>;
-              break;
-            }
+          if (__DEV__) {
+            console.log('[DocScanner] approx length', candidate.length, 'epsilon', epsilon);
           }
 
-          if (approxArray.length !== 4) {
-            continue;
+          if (candidate.length === 4) {
+            approxArray = candidate as Array<{ x: number; y: number }>;
+            break;
           }
+        }
 
-          const isValidPoint = (pt: { x: number; y: number }) =>
-            typeof pt.x === 'number' && typeof pt.y === 'number' && isFinite(pt.x) && isFinite(pt.y);
-
-          if (!approxArray.every(isValidPoint)) {
-            continue;
-          }
+        // Only proceed if we found exactly 4 corners
+        if (approxArray.length !== 4) {
+          continue;
+        }
 
-          const normalizedPoints: Point[] = approxArray.map((pt) => ({
-            x: pt.x / ratio,
-            y: pt.y / ratio,
-          }));
+        step = `contour_${i}_convex`;
+        reportStage(step);
 
-          if (!isConvexQuadrilateral(normalizedPoints)) {
-            continue;
-          }
+        // Validate points before processing
+        const isValidPoint = (pt: { x: number; y: number }) => {
+          return typeof pt.x === 'number' && typeof pt.y === 'number' &&
+                 !isNaN(pt.x) && !isNaN(pt.y) &&
+                 isFinite(pt.x) && isFinite(pt.y);
+        };
 
-          const sanitized = sanitizeQuad(orderQuadPoints(normalizedPoints));
-          if (!isValidQuad(sanitized)) {
-            continue;
+        if (!approxArray.every(isValidPoint)) {
+          if (__DEV__) {
+            console.warn('[DocScanner] invalid points in approxArray', approxArray);
           }
+          continue;
+        }
 
-          const edges = quadEdgeLengths(sanitized);
-          const minEdge = Math.min(...edges);
-          const maxEdge = Math.max(...edges);
-          if (!Number.isFinite(minEdge) || minEdge < minEdgeThreshold) {
-            continue;
-          }
-          const aspectRatio = maxEdge / Math.max(minEdge, 1);
-          if (!Number.isFinite(aspectRatio) || aspectRatio > 8.5) {
-            continue;
-          }
+        const points: Point[] = approxArray.map((pt: { x: number; y: number }) => ({
+          x: pt.x / ratio,
+          y: pt.y / ratio,
+        }));
 
-          const quadAreaValue = quadArea(sanitized);
-          const originalRatio = originalArea > 0 ? quadAreaValue / originalArea : 0;
-          if (originalRatio < 0.00012 || originalRatio > 0.92) {
+        // Verify the quadrilateral is convex (valid document shape)
+        try {
+          if (!isConvexQuadrilateral(points)) {
+            if (__DEV__) {
+              console.log('[DocScanner] not convex, skipping:', points);
+            }
             continue;
           }
-
-          const candidate = {
-            quad: sanitized,
-            area: quadAreaValue,
-          };
-
-          if (!bestLocal || candidate.area > bestLocal.area) {
-            bestLocal = candidate;
+        } catch (err) {
+          if (__DEV__) {
+            console.warn('[DocScanner] convex check error:', err, 'points:', points);
           }
+          continue;
         }
 
-        return bestLocal;
-      };
-
-      const runCanny = (label: string, low: number, high: number) => {
-        'worklet';
-        const working = OpenCV.invoke('clone', baseMat);
-        step = `${label}_canny`;
-        reportStage(step);
-        OpenCV.invoke('Canny', working, working, low, high);
-        OpenCV.invoke('morphologyEx', working, working, MorphTypes.MORPH_CLOSE, element);
-        considerCandidate(evaluateContours(working, label));
-      };
-
-      const runAdaptive = (label: string, blockSize: number, c: number) => {
-        'worklet';
-        const working = OpenCV.invoke('clone', baseMat);
-        step = `${label}_adaptive`;
-        reportStage(step);
-        OpenCV.invoke('adaptiveThreshold', working, working, 255, ADAPTIVE_THRESH_GAUSSIAN_C, THRESH_BINARY, blockSize, c);
-        OpenCV.invoke('morphologyEx', working, working, MorphTypes.MORPH_CLOSE, element);
-        considerCandidate(evaluateContours(working, label));
-      };
-
-      const runOtsu = () => {
-        'worklet';
-        const working = OpenCV.invoke('clone', baseMat);
-        step = 'otsu_threshold';
-        reportStage(step);
-        OpenCV.invoke('threshold', working, working, 0, 255, THRESH_BINARY | THRESH_OTSU);
-        OpenCV.invoke('morphologyEx', working, working, MorphTypes.MORPH_CLOSE, element);
-        considerCandidate(evaluateContours(working, 'otsu'));
-      };
-
-      runCanny('canny_primary', CANNY_LOW, CANNY_HIGH);
-      runCanny('canny_soft', Math.max(6, CANNY_LOW * 0.6), Math.max(CANNY_LOW * 1.2, CANNY_HIGH * 0.75));
-      runCanny('canny_hard', Math.max(12, CANNY_LOW * 1.1), CANNY_HIGH * 1.25);
-
-      runAdaptive('adaptive_19', 19, 7);
-      runAdaptive('adaptive_23', 23, 5);
-      runOtsu();
+        if (area > maxArea) {
+          best = points;
+          maxArea = area;
+        }
+      }
 
       step = 'clearBuffers';
       reportStage(step);
       OpenCV.clearBuffers();
       step = 'updateQuad';
       reportStage(step);
-      updateQuad(bestQuad);
+      updateQuad(best);
     } catch (error) {
       reportError(step, error);
     }

package/src/index.ts

@@ -20,4 +20,3 @@ export {
   scaleCoordinates,
   scaleRectangle,
 } from './utils/coordinate';
-export { DocumentDetector } from './utils/documentDetection';

package/src/utils/documentDetection.ts

@@ -1,278 +0,0 @@
-import {
-  OpenCV,
-  ColorConversionCodes,
-  MorphShapes,
-  MorphTypes,
-  RetrievalModes,
-  ContourApproximationModes,
-} from 'react-native-fast-opencv';
-import type { Point } from '../types';
-
-type MatLike = { release?: () => void } | null | undefined;
-
-type Size = { width: number; height: number };
-
-type Quad = [Point, Point, Point, Point];
-
-const OUTPUT_SIZE: Size = { width: 800, height: 600 };
-const MIN_AREA = 1000;
-const GAUSSIAN_KERNEL: Size = { width: 5, height: 5 };
-const MORPH_KERNEL: Size = { width: 3, height: 3 };
-const ADAPTIVE_THRESH_GAUSSIAN_C = 1;
-const THRESH_BINARY = 0;
-
-const safeRelease = (mat: MatLike) => {
-  if (mat && typeof mat.release === 'function') {
-    mat.release();
-  }
-};
-
-const normalizePoint = (value: unknown): Point | null => {
-  if (!value) {
-    return null;
-  }
-
-  if (Array.isArray(value) && value.length >= 2) {
-    const [x, y] = value;
-    const px = Number(x);
-    const py = Number(y);
-    return Number.isFinite(px) && Number.isFinite(py) ? { x: px, y: py } : null;
-  }
-
-  if (typeof value === 'object') {
-    const maybePoint = value as { x?: unknown; y?: unknown };
-    const px = Number(maybePoint.x);
-    const py = Number(maybePoint.y);
-    return Number.isFinite(px) && Number.isFinite(py) ? { x: px, y: py } : null;
-  }
-
-  return null;
-};
-
-const toPointArray = (value: unknown): Point[] | null => {
-  if (!value) {
-    return null;
-  }
-
-  if (Array.isArray(value)) {
-    const points = value.map(normalizePoint).filter((point): point is Point => point !== null);
-    return points.length === value.length ? points : null;
-  }
-
-  if (typeof value === 'object') {
-    const mat = value as { data32F?: number[]; data64F?: number[]; data32S?: number[] };
-    const data = mat.data32F ?? mat.data64F ?? mat.data32S;
-    if (!data || data.length < 8) {
-      return null;
-    }
-
-    const points: Point[] = [];
-    for (let i = 0; i + 1 < data.length; i += 2) {
-      const x = data[i];
-      const y = data[i + 1];
-      if (Number.isFinite(x) && Number.isFinite(y)) {
-        points.push({ x, y });
-      }
-    }
-
-    return points.length >= 4 ? points.slice(0, 4) : null;
-  }
-
-  return null;
-};
-
-const ensureQuad = (points: Point[] | null): Quad | null => {
-  if (!points || points.length < 4) {
-    return null;
-  }
-
-  const quad: Quad = [points[0], points[1], points[2], points[3]];
-  for (const point of quad) {
-    if (typeof point.x !== 'number' || typeof point.y !== 'number') {
-      return null;
-    }
-  }
-
-  return quad;
-};
-
-/**
- * Provides document detection utilities using react-native-fast-opencv.
- */
-export class DocumentDetector {
-  private static initialized = false;
-
-  /** Initialize OpenCV runtime once */
-  static async initialize(): Promise<void> {
-    if (!DocumentDetector.initialized) {
-      await OpenCV.initialize();
-      DocumentDetector.initialized = true;
-    }
-  }
-
-  /** Find document contours and return the largest quadrilateral */
-  static async findDocumentContours(imagePath: string): Promise<Quad | null> {
-    await DocumentDetector.initialize();
-
-    let image: MatLike;
-    let gray: MatLike;
-    let blurred: MatLike;
-    let thresh: MatLike;
-    let morphed: MatLike;
-    let kernel: MatLike;
-
-    try {
-      image = OpenCV.imread(imagePath);
-      gray = OpenCV.cvtColor(image, ColorConversionCodes.COLOR_BGR2GRAY);
-      blurred = OpenCV.GaussianBlur(gray, GAUSSIAN_KERNEL, 0);
-
-      thresh = OpenCV.adaptiveThreshold(
-        blurred,
-        255,
-        ADAPTIVE_THRESH_GAUSSIAN_C,
-        THRESH_BINARY,
-        11,
-        2,
-      );
-
-      kernel = OpenCV.getStructuringElement(MorphShapes.MORPH_RECT, MORPH_KERNEL);
-      morphed = OpenCV.morphologyEx(thresh, MorphTypes.MORPH_CLOSE, kernel);
-
-      const contours = OpenCV.findContours(
-        morphed,
-        RetrievalModes.RETR_EXTERNAL,
-        ContourApproximationModes.CHAIN_APPROX_SIMPLE,
-      );
-
-      let largestQuad: Quad | null = null;
-      let maxArea = 0;
-
-      for (const contour of contours) {
-        const area = OpenCV.contourArea(contour);
-        if (area <= maxArea || area <= MIN_AREA) {
-          continue;
-        }
-
-        const perimeter = OpenCV.arcLength(contour, true);
-        const approx = OpenCV.approxPolyDP(contour, 0.02 * perimeter, true);
-        const points = ensureQuad(toPointArray(approx));
-
-        safeRelease(approx as MatLike);
-
-        if (!points) {
-          continue;
-        }
-
-        maxArea = area;
-        largestQuad = points;
-      }
-
-      return largestQuad;
-    } catch (error) {
-      if (__DEV__) {
-        console.error('[DocumentDetector] findDocumentContours error', error);
-      }
-      return null;
-    } finally {
-      safeRelease(kernel);
-      safeRelease(morphed);
-      safeRelease(thresh);
-      safeRelease(blurred);
-      safeRelease(gray);
-      safeRelease(image);
-    }
-  }
-
-  /** Apply a perspective transform using detected corners */
-  static async perspectiveTransform(
-    imagePath: string,
-    corners: Quad,
-    outputSize: Size = OUTPUT_SIZE,
-  ): Promise<string | null> {
-    await DocumentDetector.initialize();
-
-    let image: MatLike;
-    let srcPoints: MatLike;
-    let dstPoints: MatLike;
-    let transformMatrix: MatLike;
-    let warped: MatLike;
-
-    try {
-      image = OpenCV.imread(imagePath);
-
-      srcPoints = OpenCV.matFromArray(4, 1, OpenCV.CV_32FC2, [
-        corners[0].x,
-        corners[0].y,
-        corners[1].x,
-        corners[1].y,
-        corners[2].x,
-        corners[2].y,
-        corners[3].x,
-        corners[3].y,
-      ]);
-
-      dstPoints = OpenCV.matFromArray(4, 1, OpenCV.CV_32FC2, [
-        0,
-        0,
-        outputSize.width,
-        0,
-        outputSize.width,
-        outputSize.height,
-        0,
-        outputSize.height,
-      ]);
-
-      transformMatrix = OpenCV.getPerspectiveTransform(srcPoints, dstPoints);
-
-      warped = OpenCV.warpPerspective(image, transformMatrix, outputSize);
-
-      const outputPath = imagePath.replace(/\.jpg$/i, '_normalized.jpg');
-      OpenCV.imwrite(outputPath, warped);
-
-      return outputPath;
-    } catch (error) {
-      if (__DEV__) {
-        console.error('[DocumentDetector] perspectiveTransform error', error);
-      }
-      return null;
-    } finally {
-      safeRelease(warped);
-      safeRelease(transformMatrix);
-      safeRelease(dstPoints);
-      safeRelease(srcPoints);
-      safeRelease(image);
-    }
-  }
-
-  /** Detect document and apply normalization */
-  static async detectAndNormalize(imagePath: string, outputSize?: Size): Promise<string | null> {
-    try {
-      const corners = await DocumentDetector.findDocumentContours(imagePath);
-      if (!corners) {
-        if (__DEV__) {
-          console.log('[DocumentDetector] No document detected');
-        }
-        return null;
-      }
-
-      return DocumentDetector.perspectiveTransform(imagePath, corners, outputSize ?? OUTPUT_SIZE);
-    } catch (error) {
-      if (__DEV__) {
-        console.error('[DocumentDetector] detectAndNormalize error', error);
-      }
-      return null;
-    }
-  }
-
-  /** Only detect document corners without transforming */
-  static async getDocumentBounds(imagePath: string): Promise<Quad | null> {
-    try {
-      return DocumentDetector.findDocumentContours(imagePath);
-    } catch (error) {
-      if (__DEV__) {
-        console.error('[DocumentDetector] getDocumentBounds error', error);
-      }
-      return null;
-    }
-  }
-}