react-native-rectangle-doc-scanner 4.1.0 → 4.3.0

package/android/src/main/kotlin/com/reactnativerectangledocscanner/CameraController.kt

@@ -34,6 +34,7 @@ import java.util.concurrent.atomic.AtomicReference
 import java.util.concurrent.atomic.AtomicBoolean
 import kotlin.math.abs
 import kotlin.math.max
+import kotlin.math.min
 
 class CameraController(
     private val context: Context,
@@ -217,11 +218,13 @@ class CameraController(
             val previewSizes = streamConfigMap.getOutputSizes(SurfaceTexture::class.java)
             previewSize = chooseBestSize(previewSizes, viewAspect, null, preferClosestAspect = true)
 
+            val previewAspect = previewSize?.let { it.width.toDouble() / it.height.toDouble() } ?: viewAspect
             val analysisSizes = streamConfigMap.getOutputSizes(ImageFormat.YUV_420_888)
-            analysisSize = chooseBestSize(analysisSizes, viewAspect, null, preferClosestAspect = true)
+            analysisSize = chooseBestSize(analysisSizes, previewAspect, null, preferClosestAspect = true)
 
             val captureSizes = streamConfigMap.getOutputSizes(ImageFormat.JPEG)
-            captureSize = captureSizes?.maxByOrNull { it.width * it.height }
+            captureSize = chooseBestSize(captureSizes, previewAspect, null, preferClosestAspect = true)
+                ?: captureSizes?.maxByOrNull { it.width * it.height }
 
             setupImageReaders()
 
@@ -540,17 +543,22 @@ class CameraController(
             return sorted.first()
         }
 
+        fun aspectDiff(size: Size): Double {
+            val w = size.width.toDouble()
+            val h = size.height.toDouble()
+            val direct = abs(w / h - targetAspect)
+            val inverted = abs(h / w - targetAspect)
+            return min(direct, inverted)
+        }
+
         if (preferClosestAspect) {
             return capped.minWithOrNull(
-                compareBy<Size> { abs(it.width.toDouble() / it.height.toDouble() - targetAspect) }
+                compareBy<Size> { aspectDiff(it) }
                     .thenByDescending { it.width * it.height }
             )
         }
 
-        val matching = capped.filter {
-            val aspect = it.width.toDouble() / it.height.toDouble()
-            abs(aspect - targetAspect) <= ANALYSIS_ASPECT_TOLERANCE
-        }
+        val matching = capped.filter { aspectDiff(it) <= ANALYSIS_ASPECT_TOLERANCE }
 
         return matching.firstOrNull() ?: capped.first()
     }
@@ -580,7 +588,7 @@ class CameraController(
             val uprightWidth = if (rotationDegrees == 90 || rotationDegrees == 270) imageHeight else imageWidth
             val uprightHeight = if (rotationDegrees == 90 || rotationDegrees == 270) imageWidth else imageHeight
             val openCvRect = if (mlBox != null) {
-                val expanded = expandRect(mlBox, uprightWidth, uprightHeight, 0.1f)
+                val expanded = expandRect(mlBox, uprightWidth, uprightHeight, 0.25f)
                 DocumentDetector.detectRectangleInYUVWithRoi(
                     nv21,
                     imageWidth,
@@ -592,7 +600,7 @@ class CameraController(
                 DocumentDetector.detectRectangleInYUV(nv21, imageWidth, imageHeight, rotationDegrees)
             }
             if (openCvRect == null) {
-                mlBox?.let { boxToRectangle(insetBox(it, 0.85f)) }
+                mlBox?.let { boxToRectangle(insetBox(it, 0.9f)) }
             } else {
                 openCvRect
             }

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

@@ -173,8 +173,8 @@ class DocumentDetector {
                 // Apply a light blur to reduce noise without killing small edges.
                 Imgproc.GaussianBlur(grayMat, blurredMat, Size(3.0, 3.0), 0.0)
 
-                // Apply Canny edge detection with slightly lower thresholds for small documents.
-                Imgproc.Canny(blurredMat, cannyMat, 50.0, 150.0)
+                // Apply Canny edge detection with lower thresholds for small, low-contrast documents.
+                Imgproc.Canny(blurredMat, cannyMat, 40.0, 120.0)
                 val kernel = Imgproc.getStructuringElement(Imgproc.MORPH_RECT, Size(3.0, 3.0))
                 Imgproc.morphologyEx(cannyMat, morphMat, Imgproc.MORPH_CLOSE, kernel)
                 kernel.release()
@@ -192,7 +192,7 @@ class DocumentDetector {
 
                     var largestRectangle: Rectangle? = null
                     var largestArea = 0.0
-                    val minArea = max(500.0, (srcMat.rows() * srcMat.cols()) * 0.0008)
+                    val minArea = max(300.0, (srcMat.rows() * srcMat.cols()) * 0.0005)
 
                     for (contour in contours) {
                         val contourArea = Imgproc.contourArea(contour)
@@ -200,18 +200,43 @@ class DocumentDetector {
 
                         val approx = MatOfPoint2f()
                         val contour2f = MatOfPoint2f(*contour.toArray())
-                        val epsilon = 0.018 * Imgproc.arcLength(contour2f, true)
+                        val arcLength = Imgproc.arcLength(contour2f, true)
+                        val epsilon = 0.018 * arcLength
                         Imgproc.approxPolyDP(contour2f, approx, epsilon, true)
+                        val relaxed = if (approx.total() != 4L) {
+                            MatOfPoint2f().apply {
+                                Imgproc.approxPolyDP(contour2f, this, 0.03 * arcLength, true)
+                            }
+                        } else {
+                            null
+                        }
+                        val quad = if (relaxed?.total() == 4L) relaxed else approx
 
-                        if (approx.total() == 4L && Imgproc.isContourConvex(MatOfPoint(*approx.toArray()))) {
-                            val points = approx.toArray()
+                        if (quad.total() == 4L && Imgproc.isContourConvex(MatOfPoint(*quad.toArray()))) {
+                            val points = quad.toArray()
                             if (contourArea > largestArea) {
                                 largestArea = contourArea
                                 largestRectangle = orderPoints(points)
                             }
+                        } else {
+                            // Fallback: use rotated bounding box when contour is near-rectangular.
+                            val contour2fForRect = MatOfPoint2f(*contour.toArray())
+                            val rotated = Imgproc.minAreaRect(contour2fForRect)
+                            contour2fForRect.release()
+                            val rectArea = rotated.size.area()
+                            if (rectArea > 1.0) {
+                                val rectangularity = contourArea / rectArea
+                                if (rectangularity >= 0.6 && contourArea > largestArea) {
+                                    val boxPoints = Array(4) { Point() }
+                                    rotated.points(boxPoints)
+                                    largestArea = contourArea
+                                    largestRectangle = orderPoints(boxPoints)
+                                }
+                            }
                         }
 
                         approx.release()
+                        relaxed?.release()
                         contour2f.release()
                     }
 

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

@@ -30,6 +30,7 @@ class DocumentScannerView(context: ThemedReactContext) : FrameLayout(context), L
     private val themedContext = context
     private val previewView: TextureView
     private val overlayView: OverlayView
+    private val useNativeOverlay = false
     private var cameraController: CameraController? = null
     private val lifecycleRegistry = LifecycleRegistry(this)
 
@@ -224,8 +225,10 @@ class DocumentScannerView(context: ThemedReactContext) : FrameLayout(context), L
         imageWidth: Int,
         imageHeight: Int
     ) {
-        // Update overlay
-        overlayView.setRectangle(rectangleOnScreen, overlayColor)
+        // Update native overlay only when explicitly enabled to avoid double-rendering with JS overlay
+        if (useNativeOverlay) {
+            overlayView.setRectangle(rectangleOnScreen, overlayColor)
+        }
 
         // Update stable counter based on quality
         if (rectangleCoordinates == null) {
@@ -327,14 +330,9 @@ class DocumentScannerView(context: ThemedReactContext) : FrameLayout(context), L
             // Detect rectangle in captured image
             val bitmap = BitmapFactory.decodeFile(imageFile.absolutePath)
                 ?: throw IllegalStateException("decode_failed")
-            var detectedRectangle = try {
-                DocumentDetector.detectRectangle(bitmap)
-            } catch (e: Exception) {
-                Log.w(TAG, "Rectangle detection failed, using original image", e)
-                null
-            }
-            if (detectedRectangle == null && lastDetectedImageWidth > 0 && lastDetectedImageHeight > 0) {
-                val rectangleFromView = lastRectangleOnScreen?.let {
+            var detectedRectangle: Rectangle? = null
+            val rectangleFromView = if (lastDetectedImageWidth > 0 && lastDetectedImageHeight > 0) {
+                lastRectangleOnScreen?.let {
                     viewToImageRectangle(
                         it,
                         width,
@@ -343,15 +341,35 @@ class DocumentScannerView(context: ThemedReactContext) : FrameLayout(context), L
                         lastDetectedImageHeight
                     )
                 }
-                val fallbackRect = rectangleFromView ?: lastDetectedRectangle
-                if (fallbackRect != null) {
-                    detectedRectangle = scaleRectangleToBitmap(
-                        fallbackRect,
-                        lastDetectedImageWidth,
-                        lastDetectedImageHeight,
-                        bitmap.width,
-                        bitmap.height
-                    )
+            } else {
+                null
+            }
+            if (rectangleFromView != null) {
+                detectedRectangle = scaleRectangleToBitmap(
+                    rectangleFromView,
+                    lastDetectedImageWidth,
+                    lastDetectedImageHeight,
+                    bitmap.width,
+                    bitmap.height
+                )
+            } else {
+                detectedRectangle = try {
+                    DocumentDetector.detectRectangle(bitmap)
+                } catch (e: Exception) {
+                    Log.w(TAG, "Rectangle detection failed, using original image", e)
+                    null
+                }
+                if (detectedRectangle == null && lastDetectedImageWidth > 0 && lastDetectedImageHeight > 0) {
+                    val fallbackRect = lastDetectedRectangle
+                    if (fallbackRect != null) {
+                        detectedRectangle = scaleRectangleToBitmap(
+                            fallbackRect,
+                            lastDetectedImageWidth,
+                            lastDetectedImageHeight,
+                            bitmap.width,
+                            bitmap.height
+                        )
+                    }
                 }
             }
 

package/package.json

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