react-native-rectangle-doc-scanner 10.23.0 → 10.25.0

package/android/src/camera2/kotlin/com/reactnativerectangledocscanner/DocumentScannerView.kt

@@ -25,6 +25,7 @@ import kotlinx.coroutines.delay
 import java.io.File
 import kotlin.math.min
 import kotlin.math.max
+import kotlin.math.hypot
 
 class DocumentScannerView(context: ThemedReactContext) : FrameLayout(context), LifecycleOwner {
     private val themedContext = context
@@ -58,6 +59,7 @@ class DocumentScannerView(context: ThemedReactContext) : FrameLayout(context), L
     private var lastDetectedImageWidth = 0
     private var lastDetectedImageHeight = 0
     private var lastRectangleOnScreen: Rectangle? = null
+    private var lastSmoothedRectangleOnScreen: Rectangle? = null
 
     // Coroutine scope for async operations
     private val scope = CoroutineScope(Dispatchers.Main + SupervisorJob())
@@ -215,19 +217,82 @@ class DocumentScannerView(context: ThemedReactContext) : FrameLayout(context), L
         } else {
             null
         }
-        lastRectangleOnScreen = rectangleOnScreen
+        val smoothedRectangleOnScreen = smoothRectangle(rectangleOnScreen, width, height)
+        lastRectangleOnScreen = smoothedRectangleOnScreen
         val quality = when {
-            rectangleOnScreen != null && width > 0 && height > 0 ->
-                DocumentDetector.evaluateRectangleQualityInView(rectangleOnScreen, width, height)
+            smoothedRectangleOnScreen != null && width > 0 && height > 0 ->
+                DocumentDetector.evaluateRectangleQualityInView(smoothedRectangleOnScreen, width, height)
             rectangle != null -> DocumentDetector.evaluateRectangleQuality(rectangle, imageWidth, imageHeight)
             else -> RectangleQuality.TOO_FAR
         }
 
         post {
-            onRectangleDetected(rectangleOnScreen, rectangle, quality, imageWidth, imageHeight)
+            onRectangleDetected(smoothedRectangleOnScreen, rectangle, quality, imageWidth, imageHeight)
         }
     }
 
+    private fun smoothRectangle(rectangle: Rectangle?, viewWidth: Int, viewHeight: Int): Rectangle? {
+        if (rectangle == null || viewWidth <= 0 || viewHeight <= 0) {
+            lastSmoothedRectangleOnScreen = null
+            return null
+        }
+
+        val prev = lastSmoothedRectangleOnScreen
+        if (prev == null) {
+            lastSmoothedRectangleOnScreen = rectangle
+            return rectangle
+        }
+
+        val minDim = min(viewWidth, viewHeight).toDouble()
+        val snapThreshold = max(12.0, minDim * 0.015)
+        val smoothThreshold = max(24.0, minDim * 0.06)
+        val maxCornerDistance = max(
+            maxCornerDistance(prev, rectangle),
+            maxCornerDistance(rectangle, prev)
+        )
+
+        val result = when {
+            maxCornerDistance <= snapThreshold -> prev
+            maxCornerDistance <= smoothThreshold -> blendRectangle(prev, rectangle, 0.35)
+            else -> rectangle
+        }
+
+        lastSmoothedRectangleOnScreen = result
+        return result
+    }
+
+    private fun maxCornerDistance(a: Rectangle, b: Rectangle): Double {
+        return max(
+            max(
+                distance(a.topLeft, b.topLeft),
+                distance(a.topRight, b.topRight)
+            ),
+            max(
+                distance(a.bottomLeft, b.bottomLeft),
+                distance(a.bottomRight, b.bottomRight)
+            )
+        )
+    }
+
+    private fun distance(p1: Point, p2: Point): Double {
+        return hypot(p1.x - p2.x, p1.y - p2.y)
+    }
+
+    private fun blendRectangle(a: Rectangle, b: Rectangle, t: Double): Rectangle {
+        fun lerp(p1: Point, p2: Point): Point {
+            val x = p1.x + (p2.x - p1.x) * t
+            val y = p1.y + (p2.y - p1.y) * t
+            return Point(x, y)
+        }
+
+        return Rectangle(
+            lerp(a.topLeft, b.topLeft),
+            lerp(a.topRight, b.topRight),
+            lerp(a.bottomLeft, b.bottomLeft),
+            lerp(a.bottomRight, b.bottomRight)
+        )
+    }
+
     private fun onRectangleDetected(
         rectangleOnScreen: Rectangle?,
         rectangleCoordinates: Rectangle?,

package/android/src/common/kotlin/com/reactnativerectangledocscanner/DocumentDetector.kt

@@ -173,8 +173,40 @@ class DocumentDetector {
                 // Apply a light blur to reduce noise without killing small edges.
                 Imgproc.GaussianBlur(grayMat, blurredMat, Size(5.0, 5.0), 0.0)
 
-                // Apply Canny edge detection with lower thresholds for better corner detection.
-                Imgproc.Canny(blurredMat, cannyMat, 30.0, 90.0)
+                fun computeMedian(mat: Mat): Double {
+                    val hist = Mat()
+                    return try {
+                        Imgproc.calcHist(
+                            listOf(mat),
+                            MatOfInt(0),
+                            Mat(),
+                            hist,
+                            MatOfInt(256),
+                            MatOfFloat(0f, 256f)
+                        )
+                        val total = mat.total().toDouble()
+                        var cumulative = 0.0
+                        var median = 0.0
+                        for (i in 0 until 256) {
+                            cumulative += hist.get(i, 0)[0]
+                            if (cumulative >= total * 0.5) {
+                                median = i.toDouble()
+                                break
+                            }
+                        }
+                        median
+                    } finally {
+                        hist.release()
+                    }
+                }
+
+                val median = computeMedian(blurredMat)
+                val sigma = 0.33
+                val cannyLow = max(20.0, (1.0 - sigma) * median)
+                val cannyHigh = max(60.0, (1.0 + sigma) * median)
+
+                // Apply Canny edge detection with adaptive thresholds for better corner detection.
+                Imgproc.Canny(blurredMat, cannyMat, cannyLow, cannyHigh)
                 val kernel = Imgproc.getStructuringElement(Imgproc.MORPH_RECT, Size(3.0, 3.0))
                 Imgproc.morphologyEx(cannyMat, morphMat, Imgproc.MORPH_CLOSE, kernel)
                 kernel.release()
@@ -218,8 +250,8 @@ class DocumentDetector {
                     )
 
                     var largestRectangle: Rectangle? = null
-                    var largestArea = 0.0
-                    val minArea = max(300.0, (srcMat.rows() * srcMat.cols()) * 0.0005)
+                    var bestScore = 0.0
+                    val minArea = max(800.0, (srcMat.rows() * srcMat.cols()) * 0.001)
 
                     for (contour in contours) {
                         val contourArea = Imgproc.contourArea(contour)
@@ -243,9 +275,15 @@ class DocumentDetector {
 
                         if (quad.total() == 4L && Imgproc.isContourConvex(MatOfPoint(*quad.toArray()))) {
                             val points = quad.toArray()
-                            if (contourArea > largestArea) {
-                                largestArea = contourArea
-                                largestRectangle = refineRectangle(grayMat, orderPoints(points))
+                            val rect = Imgproc.minAreaRect(MatOfPoint2f(*points))
+                            val rectArea = rect.size.area()
+                            val rectangularity = if (rectArea > 1.0) contourArea / rectArea else 0.0
+                            if (rectangularity >= 0.6) {
+                                val score = contourArea * rectangularity
+                                if (score > bestScore) {
+                                    bestScore = score
+                                    largestRectangle = refineRectangle(grayMat, orderPoints(points))
+                                }
                             }
                         } else {
                             // Fallback: use rotated bounding box when contour is near-rectangular.
@@ -255,11 +293,14 @@ class DocumentDetector {
                             val rectArea = rotated.size.area()
                             if (rectArea > 1.0) {
                                 val rectangularity = contourArea / rectArea
-                                if (rectangularity >= 0.6 && contourArea > largestArea) {
+                                if (rectangularity >= 0.6) {
                                     val boxPoints = Array(4) { Point() }
                                     rotated.points(boxPoints)
-                                    largestArea = contourArea
-                                    largestRectangle = refineRectangle(grayMat, orderPoints(boxPoints))
+                                    val score = contourArea * rectangularity
+                                    if (score > bestScore) {
+                                        bestScore = score
+                                        largestRectangle = refineRectangle(grayMat, orderPoints(boxPoints))
+                                    }
                                 }
                             }
                         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-rectangle-doc-scanner",
-  "version": "10.23.0",
+  "version": "10.25.0",
   "description": "Native-backed document scanner for React Native with customizable overlays.",
   "license": "MIT",
   "main": "dist/index.js",