react-native-rectangle-doc-scanner 10.31.0 → 10.32.0

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

@@ -433,36 +433,83 @@ class CameraController(
         Log.d(TAG, "[CAMERAX] Transform refresh requested - handled automatically")
     }
 
-    // Simplified coordinate mapping for TextureView
+    // Coordinate mapping aligned with TextureView transform
     fun mapRectangleToView(rectangle: Rectangle?, imageWidth: Int, imageHeight: Int): Rectangle? {
         if (rectangle == null || imageWidth <= 0 || imageHeight <= 0) return null
 
-        // Fit-center scaling to avoid zoom/crop and keep mapping aligned with preview.
         val viewWidth = textureView.width.toFloat()
         val viewHeight = textureView.height.toFloat()
 
         if (viewWidth <= 0 || viewHeight <= 0) return null
 
-        val scaleX = viewWidth / imageWidth.toFloat()
-        val scaleY = viewHeight / imageHeight.toFloat()
-        val scale = scaleX.coerceAtMost(scaleY)
-        val scaledWidth = imageWidth * scale
-        val scaledHeight = imageHeight * scale
+        // Get sensor orientation to match transform rotation
+        val sensorOrientation = getCameraSensorOrientation()
+        val displayRotationDegrees = when (textureView.display?.rotation ?: Surface.ROTATION_0) {
+            Surface.ROTATION_0 -> 0
+            Surface.ROTATION_90 -> 90
+            Surface.ROTATION_180 -> 180
+            Surface.ROTATION_270 -> 270
+            else -> 0
+        }
+
+        val tabletUpsideDownFix = if (sensorOrientation == 0 && displayRotationDegrees == 90) 180 else 0
+        val rotationDegrees = ((displayRotationDegrees + tabletUpsideDownFix) % 360).toFloat()
+
+        // First, apply rotation to point coordinates
+        fun rotatePoint(point: org.opencv.core.Point): org.opencv.core.Point {
+            return when (rotationDegrees.toInt()) {
+                90 -> org.opencv.core.Point(
+                    imageHeight - point.y,
+                    point.x
+                )
+                180 -> org.opencv.core.Point(
+                    imageWidth - point.x,
+                    imageHeight - point.y
+                )
+                270 -> org.opencv.core.Point(
+                    point.y,
+                    imageWidth - point.x
+                )
+                else -> point  // 0 degrees, no rotation
+            }
+        }
+
+        // Determine rotated dimensions (same as transform)
+        val rotatedImageWidth = if (rotationDegrees == 90f || rotationDegrees == 270f) {
+            imageHeight
+        } else {
+            imageWidth
+        }
+        val rotatedImageHeight = if (rotationDegrees == 90f || rotationDegrees == 270f) {
+            imageWidth
+        } else {
+            imageHeight
+        }
+
+        // Use same fit-scaling as transform
+        val scaleX = viewWidth / rotatedImageWidth.toFloat()
+        val scaleY = viewHeight / rotatedImageHeight.toFloat()
+        val scale = scaleX.coerceAtMost(scaleY)  // Fit (not fill)
+
+        val scaledWidth = rotatedImageWidth * scale
+        val scaledHeight = rotatedImageHeight * scale
         val offsetX = (viewWidth - scaledWidth) / 2f
         val offsetY = (viewHeight - scaledHeight) / 2f
 
-        fun scalePoint(point: org.opencv.core.Point): org.opencv.core.Point {
+        // Apply rotation first, then scale and offset
+        fun transformPoint(point: org.opencv.core.Point): org.opencv.core.Point {
+            val rotated = rotatePoint(point)
             return org.opencv.core.Point(
-                point.x * scale + offsetX,
-                point.y * scale + offsetY
+                rotated.x * scale + offsetX,
+                rotated.y * scale + offsetY
             )
         }
 
         return Rectangle(
-            scalePoint(rectangle.topLeft),
-            scalePoint(rectangle.topRight),
-            scalePoint(rectangle.bottomLeft),
-            scalePoint(rectangle.bottomRight)
+            transformPoint(rectangle.topLeft),
+            transformPoint(rectangle.topRight),
+            transformPoint(rectangle.bottomLeft),
+            transformPoint(rectangle.bottomRight)
         )
     }
 

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

@@ -285,15 +285,24 @@ class DocumentDetector {
 
                         if (quad.total() == 4L && Imgproc.isContourConvex(MatOfPoint(*quad.toArray()))) {
                             val points = quad.toArray()
+                            val ordered = 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) {
+                            if (rectangularity >= 0.6 && isCandidateValid(ordered, srcMat)) {
                                 debugStats.candidates += 1
                                 val score = contourArea * rectangularity
                                 if (score > bestScore) {
+                                    val width = distance(ordered.topLeft, ordered.topRight)
+                                    val height = distance(ordered.topLeft, ordered.bottomLeft)
+                                    val aspect = if (height > 0.0) width / height else 0.0
                                     bestScore = score
-                                    largestRectangle = refineRectangle(grayMat, orderPoints(points))
+                                    debugStats.bestArea = contourArea
+                                    debugStats.bestRectangularity = rectangularity
+                                    debugStats.bestWidth = width
+                                    debugStats.bestHeight = height
+                                    debugStats.bestAspect = aspect
+                                    largestRectangle = refineRectangle(grayMat, ordered)
                                 }
                             }
                         } else {
@@ -308,10 +317,22 @@ class DocumentDetector {
                                     debugStats.candidates += 1
                                     val boxPoints = Array(4) { Point() }
                                     rotated.points(boxPoints)
+                                    val ordered = orderPoints(boxPoints)
+                                    if (!isCandidateValid(ordered, srcMat)) {
+                                        continue
+                                    }
                                     val score = contourArea * rectangularity
                                     if (score > bestScore) {
+                                        val width = distance(ordered.topLeft, ordered.topRight)
+                                        val height = distance(ordered.topLeft, ordered.bottomLeft)
+                                        val aspect = if (height > 0.0) width / height else 0.0
                                         bestScore = score
-                                        largestRectangle = refineRectangle(grayMat, orderPoints(boxPoints))
+                                        debugStats.bestArea = contourArea
+                                        debugStats.bestRectangularity = rectangularity
+                                        debugStats.bestWidth = width
+                                        debugStats.bestHeight = height
+                                        debugStats.bestAspect = aspect
+                                        largestRectangle = refineRectangle(grayMat, ordered)
                                     }
                                 }
                             }
@@ -356,6 +377,11 @@ class DocumentDetector {
                             "[DEBUG] cannyLow=$cannyLow cannyHigh=$cannyHigh " +
                                 "contours=${debugStats.contours} candidates=${debugStats.candidates} " +
                                 "bestScore=${String.format("%.1f", debugStats.bestScore)} " +
+                                "bestArea=${String.format("%.1f", debugStats.bestArea)} " +
+                                "bestRect=${String.format("%.2f", debugStats.bestRectangularity)} " +
+                                "bestW=${String.format("%.1f", debugStats.bestWidth)} " +
+                                "bestH=${String.format("%.1f", debugStats.bestHeight)} " +
+                                "bestAspect=${String.format("%.2f", debugStats.bestAspect)} " +
                                 "hasRect=${rectangle != null}"
                         )
                     }
@@ -374,7 +400,12 @@ class DocumentDetector {
         private data class DebugStats(
             var contours: Int = 0,
             var candidates: Int = 0,
-            var bestScore: Double = 0.0
+            var bestScore: Double = 0.0,
+            var bestArea: Double = 0.0,
+            var bestRectangularity: Double = 0.0,
+            var bestWidth: Double = 0.0,
+            var bestHeight: Double = 0.0,
+            var bestAspect: Double = 0.0
         )
 
         /**
@@ -393,6 +424,21 @@ class DocumentDetector {
             return Rectangle(topLeft, topRight, bottomLeft, bottomRight)
         }
 
+        private fun isCandidateValid(rectangle: Rectangle, srcMat: Mat): Boolean {
+            val width = distance(rectangle.topLeft, rectangle.topRight)
+            val height = distance(rectangle.topLeft, rectangle.bottomLeft)
+            val minDim = min(srcMat.cols(), srcMat.rows()).toDouble()
+            val minEdge = max(60.0, minDim * 0.08)
+            if (width < minEdge || height < minEdge) {
+                return false
+            }
+            val aspect = if (height > 0) width / height else 0.0
+            if (aspect < 0.45 || aspect > 2.8) {
+                return false
+            }
+            return true
+        }
+
         /**
          * Evaluate rectangle quality (matching iOS logic)
          */
@@ -437,7 +483,7 @@ class DocumentDetector {
             }
 
             val minDim = kotlin.math.min(viewWidth.toDouble(), viewHeight.toDouble())
-            val angleThreshold = max(90.0, minDim * 0.12)
+            val angleThreshold = max(140.0, minDim * 0.18)
 
             val topYDiff = abs(rectangle.topRight.y - rectangle.topLeft.y)
             val bottomYDiff = abs(rectangle.bottomLeft.y - rectangle.bottomRight.y)
@@ -448,7 +494,7 @@ class DocumentDetector {
                 return RectangleQuality.BAD_ANGLE
             }
 
-            val margin = max(80.0, minDim * 0.08)
+            val margin = max(50.0, minDim * 0.05)
             if (rectangle.topLeft.y > margin ||
                 rectangle.topRight.y > margin ||
                 rectangle.bottomLeft.y < (viewHeight - margin) ||

package/package.json

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