react-native-rectangle-doc-scanner 3.241.0 → 3.243.0

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

@@ -70,6 +70,8 @@ class CameraController(
             .build()
     )
     private var lastRefineTimestamp = 0L
+    private var lastRectangle: Rectangle? = null
+    private var lastRectangleTimestamp = 0L
 
     var onFrameAnalyzed: ((Rectangle?, Int, Int) -> Unit)? = null
 
@@ -213,7 +215,7 @@ class CameraController(
             }
 
             val previewSizes = streamConfigMap.getOutputSizes(SurfaceTexture::class.java)
-            previewSize = chooseBestSize(previewSizes, viewAspect, null)
+            previewSize = chooseBestSize(previewSizes, viewAspect, null, preferClosestAspect = true)
 
             val analysisSizes = streamConfigMap.getOutputSizes(ImageFormat.YUV_420_888)
             analysisSize = chooseBestSize(analysisSizes, viewAspect, ANALYSIS_MAX_AREA)
@@ -390,7 +392,7 @@ class CameraController(
 
                 val frameWidth = if (rotationDegrees == 90 || rotationDegrees == 270) image.height else image.width
                 val frameHeight = if (rotationDegrees == 90 || rotationDegrees == 270) image.width else image.height
-                onFrameAnalyzed?.invoke(rectangle, frameWidth, frameHeight)
+                onFrameAnalyzed?.invoke(smoothRectangle(rectangle), frameWidth, frameHeight)
             }
             .addOnFailureListener { e ->
                 Log.e(TAG, "[CAMERA2] ML Kit detection failed", e)
@@ -485,31 +487,45 @@ class CameraController(
 
         val matrix = Matrix()
         bufferRect.offset(centerX - bufferRect.centerX(), centerY - bufferRect.centerY())
-        matrix.setRectToRect(bufferRect, viewRect, Matrix.ScaleToFit.FILL)
+        matrix.setRectToRect(viewRect, bufferRect, Matrix.ScaleToFit.FILL)
+        val scale = max(viewWidth / bufferWidth, viewHeight / bufferHeight)
+        matrix.postScale(scale, scale, centerX, centerY)
         matrix.postRotate(rotation.toFloat(), centerX, centerY)
         previewView.setTransform(matrix)
     }
 
-    private fun chooseBestSize(sizes: Array<Size>?, targetAspect: Double, maxArea: Int?): Size? {
+    private fun chooseBestSize(
+        sizes: Array<Size>?,
+        targetAspect: Double,
+        maxArea: Int?,
+        preferClosestAspect: Boolean = false
+    ): Size? {
         if (sizes == null || sizes.isEmpty()) return null
         val sorted = sizes.sortedByDescending { it.width * it.height }
 
-        val matching = sorted.filter {
-            val aspect = it.width.toDouble() / it.height.toDouble()
-            abs(aspect - targetAspect) <= ANALYSIS_ASPECT_TOLERANCE && (maxArea == null || it.width * it.height <= maxArea)
-        }
-
-        if (matching.isNotEmpty()) {
-            return matching.first()
-        }
-
         val capped = if (maxArea != null) {
             sorted.filter { it.width * it.height <= maxArea }
         } else {
             sorted
         }
 
-        return capped.firstOrNull() ?: sorted.first()
+        if (capped.isEmpty()) {
+            return sorted.first()
+        }
+
+        if (preferClosestAspect) {
+            return capped.minWithOrNull(
+                compareBy<Size> { abs(it.width.toDouble() / it.height.toDouble() - targetAspect) }
+                    .thenByDescending { it.width * it.height }
+            )
+        }
+
+        val matching = capped.filter {
+            val aspect = it.width.toDouble() / it.height.toDouble()
+            abs(aspect - targetAspect) <= ANALYSIS_ASPECT_TOLERANCE
+        }
+
+        return matching.firstOrNull() ?: capped.first()
     }
 
     private fun rotateAndMirror(bitmap: Bitmap, rotationDegrees: Int, mirror: Boolean): Bitmap {
@@ -528,7 +544,7 @@ class CameraController(
 
     private fun shouldRefineWithOpenCv(): Boolean {
         val now = System.currentTimeMillis()
-        if (now - lastRefineTimestamp < 200) {
+        if (now - lastRefineTimestamp < 150) {
             return false
         }
         lastRefineTimestamp = now
@@ -538,7 +554,16 @@ class CameraController(
     private fun refineWithOpenCv(image: Image, rotationDegrees: Int, mlBox: Rect): Rectangle? {
         return try {
             val nv21 = imageToNv21(image)
-            val openCvRect = DocumentDetector.detectRectangleInYUV(nv21, image.width, image.height, rotationDegrees)
+            val uprightWidth = if (rotationDegrees == 90 || rotationDegrees == 270) image.height else image.width
+            val uprightHeight = if (rotationDegrees == 90 || rotationDegrees == 270) image.width else image.height
+            val expanded = expandRect(mlBox, uprightWidth, uprightHeight, 0.2f)
+            val openCvRect = DocumentDetector.detectRectangleInYUVWithRoi(
+                nv21,
+                image.width,
+                image.height,
+                rotationDegrees,
+                expanded
+            )
             if (openCvRect == null) {
                 null
             } else {
@@ -560,6 +585,48 @@ class CameraController(
         )
     }
 
+    private fun expandRect(box: Rect, maxWidth: Int, maxHeight: Int, ratio: Float): Rect {
+        val padX = (box.width() * ratio).toInt()
+        val padY = (box.height() * ratio).toInt()
+        val left = (box.left - padX).coerceAtLeast(0)
+        val top = (box.top - padY).coerceAtLeast(0)
+        val right = (box.right + padX).coerceAtMost(maxWidth)
+        val bottom = (box.bottom + padY).coerceAtMost(maxHeight)
+        return Rect(left, top, right, bottom)
+    }
+
+    private fun smoothRectangle(current: Rectangle?): Rectangle? {
+        val now = System.currentTimeMillis()
+        val last = lastRectangle
+        if (current == null) {
+            if (last != null && now - lastRectangleTimestamp < 250) {
+                return last
+            }
+            lastRectangle = null
+            return null
+        }
+
+        val smoothed = if (last != null && now - lastRectangleTimestamp < 500) {
+            val t = 0.35
+            Rectangle(
+                Point(lerp(last.topLeft.x, current.topLeft.x, t), lerp(last.topLeft.y, current.topLeft.y, t)),
+                Point(lerp(last.topRight.x, current.topRight.x, t), lerp(last.topRight.y, current.topRight.y, t)),
+                Point(lerp(last.bottomLeft.x, current.bottomLeft.x, t), lerp(last.bottomLeft.y, current.bottomLeft.y, t)),
+                Point(lerp(last.bottomRight.x, current.bottomRight.x, t), lerp(last.bottomRight.y, current.bottomRight.y, t))
+            )
+        } else {
+            current
+        }
+
+        lastRectangle = smoothed
+        lastRectangleTimestamp = now
+        return smoothed
+    }
+
+    private fun lerp(start: Double, end: Double, t: Double): Double {
+        return start + (end - start) * t
+    }
+
     private fun rectangleBounds(rectangle: Rectangle): Rect {
         val left = listOf(rectangle.topLeft.x, rectangle.bottomLeft.x, rectangle.topRight.x, rectangle.bottomRight.x).minOrNull() ?: 0.0
         val right = listOf(rectangle.topLeft.x, rectangle.bottomLeft.x, rectangle.topRight.x, rectangle.bottomRight.x).maxOrNull() ?: 0.0

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

@@ -1,6 +1,7 @@
 package com.reactnativerectangledocscanner
 
 import android.graphics.Bitmap
+import android.graphics.Rect
 import android.util.Log
 import org.opencv.android.Utils
 import org.opencv.core.*
@@ -98,6 +99,59 @@ class DocumentDetector {
             return rectangle
         }
 
+        /**
+         * Detect rectangle within a region-of-interest (ROI) in YUV image.
+         * The ROI is specified in the rotated image coordinate space.
+         */
+        fun detectRectangleInYUVWithRoi(
+            yuvBytes: ByteArray,
+            width: Int,
+            height: Int,
+            rotation: Int,
+            roi: Rect
+        ): Rectangle? {
+            val yuvMat = Mat(height + height / 2, width, CvType.CV_8UC1)
+            yuvMat.put(0, 0, yuvBytes)
+
+            val rgbMat = Mat()
+            Imgproc.cvtColor(yuvMat, rgbMat, Imgproc.COLOR_YUV2RGB_NV21)
+
+            if (rotation != 0) {
+                val rotationCode = when (rotation) {
+                    90 -> Core.ROTATE_90_CLOCKWISE
+                    180 -> Core.ROTATE_180
+                    270 -> Core.ROTATE_90_COUNTERCLOCKWISE
+                    else -> null
+                }
+                if (rotationCode != null) {
+                    Core.rotate(rgbMat, rgbMat, rotationCode)
+                }
+            }
+
+            val x = roi.left.coerceIn(0, rgbMat.cols() - 1)
+            val y = roi.top.coerceIn(0, rgbMat.rows() - 1)
+            val right = roi.right.coerceIn(x + 1, rgbMat.cols())
+            val bottom = roi.bottom.coerceIn(y + 1, rgbMat.rows())
+            val w = right - x
+            val h = bottom - y
+            val roiRect = org.opencv.core.Rect(x, y, w, h)
+
+            val roiMat = Mat(rgbMat, roiRect)
+            val rectangle = detectRectangleInMat(roiMat)
+            roiMat.release()
+            yuvMat.release()
+            rgbMat.release()
+
+            return rectangle?.let {
+                Rectangle(
+                    Point(it.topLeft.x + x, it.topLeft.y + y),
+                    Point(it.topRight.x + x, it.topRight.y + y),
+                    Point(it.bottomLeft.x + x, it.bottomLeft.y + y),
+                    Point(it.bottomRight.x + x, it.bottomRight.y + y)
+                )
+            }
+        }
+
         /**
          * Core detection algorithm using OpenCV
          */

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

@@ -312,7 +312,13 @@ class DocumentScannerView(context: ThemedReactContext) : FrameLayout(context), L
         try {
             // Detect rectangle in captured image
             val bitmap = BitmapFactory.decodeFile(imageFile.absolutePath)
-            val detectedRectangle = DocumentDetector.detectRectangle(bitmap)
+                ?: throw IllegalStateException("decode_failed")
+            val detectedRectangle = try {
+                DocumentDetector.detectRectangle(bitmap)
+            } catch (e: Exception) {
+                Log.w(TAG, "Rectangle detection failed, using original image", e)
+                null
+            }
 
             // Process image with detected rectangle
             val shouldCrop = detectedRectangle != null && stableCounter > 0

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

@@ -194,7 +194,8 @@ object ImageProcessor {
         saturation: Float = 1f,
         shouldCrop: Boolean = true
     ): ProcessedImage {
-        var initialBitmap = BitmapFactory.decodeFile(imagePath)
+        val initialBitmap = BitmapFactory.decodeFile(imagePath)
+            ?: throw IllegalStateException("decode_failed")
         var croppedBitmap = initialBitmap
 
         // Apply perspective correction if rectangle detected and cropping enabled

package/package.json

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