react-native-rectangle-doc-scanner 0.57.0 → 0.59.0

package/dist/DocScanner.js

@@ -278,157 +278,191 @@ 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);
-                mat = tempMat;
+                processed = 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;
             }
-            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';
+            // Additional blur and close pass to smooth jagged edges
+            step = 'gaussianBlur';
             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', 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 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 frameArea = width * height;
-            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 (area < 50) {
-                    continue;
-                }
-                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 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;
+            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;
                 }
-                catch (err) {
-                    // If convexHull fails, use original contour
-                    if (__DEV__) {
-                        console.warn('[DocScanner] convexHull failed, using original contour');
-                    }
+                if (!bestQuad || candidate.area > bestArea) {
+                    bestQuad = candidate.quad;
+                    bestArea = candidate.area;
                 }
-                step = `contour_${i}_arcLength`;
+            };
+            const evaluateContours = (inputMat, attemptLabel) => {
+                'worklet';
+                step = `findContours_${attemptLabel}`;
                 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}`;
+                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);
-                    react_native_fast_opencv_1.OpenCV.invoke('approxPolyDP', contourToUse, approx, epsilon, true);
-                    step = `contour_${i}_toJS_attempt_${attempt}`;
+                    const contour = react_native_fast_opencv_1.OpenCV.copyObjectFromVector(contours, i);
+                    step = `${attemptLabel}_contour_${i}_area`;
                     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);
+                    const { value: area } = react_native_fast_opencv_1.OpenCV.invoke('contourArea', contour, false);
+                    if (typeof area !== 'number' || !isFinite(area) || area < 60) {
+                        continue;
                     }
-                    if (candidate.length === 4) {
-                        approxArray = candidate;
-                        break;
+                    const resizedRatio = area / frameArea;
+                    if (resizedRatio < 0.00012 || resizedRatio > 0.98) {
+                        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);
+                    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;
                     }
-                    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);
+                    catch (err) {
+                        if (__DEV__ && !convexHullWarned) {
+                            console.warn('[DocScanner] convexHull failed, using original contour');
+                            convexHullWarned = true;
                         }
+                    }
+                    const { value: perimeter } = react_native_fast_opencv_1.OpenCV.invoke('arcLength', contourToUse, true);
+                    if (typeof perimeter !== 'number' || !isFinite(perimeter) || perimeter < 80) {
                         continue;
                     }
-                }
-                catch (err) {
-                    if (__DEV__) {
-                        console.warn('[DocScanner] convex check error:', err, 'points:', points);
+                    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;
+                        }
+                    }
+                    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;
                     }
-                    continue;
-                }
-                if (area > maxArea) {
-                    best = points;
-                    maxArea = area;
                 }
-            }
+                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();
             step = 'clearBuffers';
             reportStage(step);
             react_native_fast_opencv_1.OpenCV.clearBuffers();
             step = 'updateQuad';
             reportStage(step);
-            updateQuad(best);
+            updateQuad(bestQuad);
         }
         catch (error) {
             reportError(step, error);

package/package.json

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

package/src/DocScanner.tsx

@@ -344,182 +344,225 @@ 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);
-        mat = tempMat;
+        processed = 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;
       }
 
-      step = 'Canny';
-      reportStage(step);
-      // Configurable Canny parameters for adaptive edge detection
-      OpenCV.invoke('Canny', mat, mat, CANNY_LOW, CANNY_HIGH);
-
-      step = 'createContours';
+      // Additional blur and close pass to smooth jagged edges
+      step = 'gaussianBlur';
       reportStage(step);
-      const contours = OpenCV.createObject(ObjectType.PointVectorOfVectors);
-      OpenCV.invoke('findContours', mat, contours, RetrievalModes.RETR_EXTERNAL, ContourApproximationModes.CHAIN_APPROX_SIMPLE);
+      const gaussianKernel = OpenCV.createObject(ObjectType.Size, 5, 5);
+      OpenCV.invoke('GaussianBlur', processed, processed, gaussianKernel, 0);
+      OpenCV.invoke('morphologyEx', processed, processed, MorphTypes.MORPH_CLOSE, element);
 
-      let best: Point[] | null = null;
-      let maxArea = 0;
+      const baseMat = OpenCV.invoke('clone', processed);
       const frameArea = width * height;
-
-      step = 'toJSValue';
-      reportStage(step);
-      const contourVector = 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 = OpenCV.copyObjectFromVector(contours, i);
-
-        // Compute absolute area first
-        step = `contour_${i}_area_abs`;
-        reportStage(step);
-        const { value: area } = 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;
+      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 (area < 50) {
-          continue;
+        if (!bestQuad || candidate.area > bestArea) {
+          bestQuad = candidate.quad;
+          bestArea = candidate.area;
         }
+      };
+
+      const evaluateContours = (inputMat: unknown, attemptLabel: string): { quad: Point[]; area: number } | null => {
+        'worklet';
 
-        step = `contour_${i}_area`; // ratio stage
+        step = `findContours_${attemptLabel}`;
         reportStage(step);
-        const areaRatio = area / frameArea;
+        const contours = OpenCV.createObject(ObjectType.PointVectorOfVectors);
+        OpenCV.invoke('findContours', inputMat, contours, RetrievalModes.RETR_EXTERNAL, ContourApproximationModes.CHAIN_APPROX_SIMPLE);
 
-        if (__DEV__) {
-          console.log('[DocScanner] area', area, 'ratio', areaRatio);
-        }
+        const contourVector = OpenCV.toJSValue(contours);
+        const contourArray = Array.isArray(contourVector?.array) ? contourVector.array : [];
 
-        // Skip if area ratio is too small or too large
-        if (areaRatio < 0.0002 || areaRatio > 0.99) {
-          continue;
-        }
+        let bestLocal: { quad: Point[]; area: number } | null = null;
+
+        for (let i = 0; i < contourArray.length; i += 1) {
+          step = `${attemptLabel}_contour_${i}_copy`;
+          reportStage(step);
+          const contour = OpenCV.copyObjectFromVector(contours, i);
 
-        // Try to use convex hull for better corner detection
-        let contourToUse = contour;
-        try {
-          step = `contour_${i}_convexHull`;
+          step = `${attemptLabel}_contour_${i}_area`;
           reportStage(step);
-          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 { value: area } = OpenCV.invoke('contourArea', contour, false);
+          if (typeof area !== 'number' || !isFinite(area) || area < 60) {
+            continue;
           }
-        }
 
-        step = `contour_${i}_arcLength`;
-        reportStage(step);
-        const { value: perimeter } = OpenCV.invoke('arcLength', contourToUse, true);
-        const approx = OpenCV.createObject(ObjectType.PointVector);
+          const resizedRatio = area / frameArea;
+          if (resizedRatio < 0.00012 || resizedRatio > 0.98) {
+            continue;
+          }
 
-        let approxArray: Array<{ x: number; y: number }> = [];
+          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;
+            }
+          }
 
-        // 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 { value: perimeter } = OpenCV.invoke('arcLength', contourToUse, true);
+          if (typeof perimeter !== 'number' || !isFinite(perimeter) || perimeter < 80) {
+            continue;
+          }
 
-        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);
+          const approx = OpenCV.createObject(ObjectType.PointVector);
+          let approxArray: Array<{ x: number; y: number }> = [];
 
-          step = `contour_${i}_toJS_attempt_${attempt}`;
-          reportStage(step);
-          const approxValue = OpenCV.toJSValue(approx);
-          const candidate = Array.isArray(approxValue?.array) ? approxValue.array : [];
+          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);
 
-          if (__DEV__) {
-            console.log('[DocScanner] approx length', candidate.length, 'epsilon', epsilon);
+            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 (candidate.length === 4) {
-            approxArray = candidate as Array<{ x: number; y: number }>;
-            break;
+          if (approxArray.length !== 4) {
+            continue;
           }
-        }
 
-        // Only proceed if we found exactly 4 corners
-        if (approxArray.length !== 4) {
-          continue;
-        }
+          const isValidPoint = (pt: { x: number; y: number }) =>
+            typeof pt.x === 'number' && typeof pt.y === 'number' && isFinite(pt.x) && isFinite(pt.y);
 
-        step = `contour_${i}_convex`;
-        reportStage(step);
+          if (!approxArray.every(isValidPoint)) {
+            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 normalizedPoints: Point[] = approxArray.map((pt) => ({
+            x: pt.x / ratio,
+            y: pt.y / ratio,
+          }));
 
-        if (!approxArray.every(isValidPoint)) {
-          if (__DEV__) {
-            console.warn('[DocScanner] invalid points in approxArray', approxArray);
+          if (!isConvexQuadrilateral(normalizedPoints)) {
+            continue;
           }
-          continue;
-        }
 
-        const points: Point[] = approxArray.map((pt: { x: number; y: number }) => ({
-          x: pt.x / ratio,
-          y: pt.y / ratio,
-        }));
+          const sanitized = sanitizeQuad(orderQuadPoints(normalizedPoints));
+          if (!isValidQuad(sanitized)) {
+            continue;
+          }
 
-        // Verify the quadrilateral is convex (valid document shape)
-        try {
-          if (!isConvexQuadrilateral(points)) {
-            if (__DEV__) {
-              console.log('[DocScanner] not convex, skipping:', points);
-            }
+          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;
           }
-        } catch (err) {
-          if (__DEV__) {
-            console.warn('[DocScanner] convex check error:', err, 'points:', points);
+
+          const quadAreaValue = quadArea(sanitized);
+          const originalRatio = originalArea > 0 ? quadAreaValue / originalArea : 0;
+          if (originalRatio < 0.00012 || originalRatio > 0.92) {
+            continue;
           }
-          continue;
-        }
 
-        if (area > maxArea) {
-          best = points;
-          maxArea = area;
+          const candidate = {
+            quad: sanitized,
+            area: quadAreaValue,
+          };
+
+          if (!bestLocal || candidate.area > bestLocal.area) {
+            bestLocal = candidate;
+          }
         }
-      }
+
+        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();
 
       step = 'clearBuffers';
       reportStage(step);
       OpenCV.clearBuffers();
       step = 'updateQuad';
       reportStage(step);
-      updateQuad(best);
+      updateQuad(bestQuad);
     } catch (error) {
       reportError(step, error);
     }