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

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

@@ -433,37 +433,105 @@ 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
+        // The image coordinates are in camera sensor space. We need to transform them
+        // to match how the TextureView displays the image (after rotation/scaling).
+
+        // CameraX provides images in sensor orientation. For a 90° sensor (most phones),
+        // the image is rotated 90° relative to natural portrait. We must rotate coordinates
+        // to match the final display orientation.
+        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
+        }
+
+        // Calculate the rotation needed to display the image correctly in portrait mode.
+        // This must match the rotation applied in updateTextureViewTransform.
+        val rotationDegrees = when {
+            // Tablet with landscape sensor in portrait: add 180° fix for upside-down
+            sensorOrientation == 0 && displayRotationDegrees == 90 -> 270f
+            // Phone with 90° sensor in portrait: rotate 90° to match
+            sensorOrientation == 90 && displayRotationDegrees == 0 -> 90f
+            // Default: use display rotation
+            else -> displayRotationDegrees.toFloat()
+        }
+
+        Log.d(TAG, "[MAPPING] Image: ${imageWidth}x${imageHeight}, Sensor: ${sensorOrientation}°, " +
+            "Display: ${displayRotationDegrees}°, Final rotation: ${rotationDegrees}°")
+
+        // Apply rotation to coordinates to match display orientation
+        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 dimensions after rotation
+        val rotatedImageWidth = if (rotationDegrees == 90f || rotationDegrees == 270f) {
+            imageHeight
+        } else {
+            imageWidth
+        }
+        val rotatedImageHeight = if (rotationDegrees == 90f || rotationDegrees == 270f) {
+            imageWidth
+        } else {
+            imageHeight
+        }
+
+        // Calculate scaling to fit the rotated image into the view (matching transform)
+        val scaleX = viewWidth / rotatedImageWidth.toFloat()
+        val scaleY = viewHeight / rotatedImageHeight.toFloat()
+        val scale = scaleX.coerceAtMost(scaleY)  // Fit (preserve aspect ratio)
+
+        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 {
+        // Transform coordinates: rotate first, then scale and center
+        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)
+        val result = Rectangle(
+            transformPoint(rectangle.topLeft),
+            transformPoint(rectangle.topRight),
+            transformPoint(rectangle.bottomLeft),
+            transformPoint(rectangle.bottomRight)
         )
+
+        Log.d(TAG, "[MAPPING] Original TL: (${rectangle.topLeft.x}, ${rectangle.topLeft.y}) → " +
+            "Transformed: (${result.topLeft.x}, ${result.topLeft.y})")
+
+        return result
     }
 
     fun getPreviewViewport(): android.graphics.RectF? {
@@ -503,10 +571,17 @@ class CameraController(
         val centerY = viewHeight / 2f
 
         // Calculate rotation from buffer to display coordinates.
-        // CameraX accounts for sensor orientation via targetRotation. Some tablets with landscape
-        // sensors report Display 90 in portrait but render upside down; add a 180° fix for that case.
-        val tabletUpsideDownFix = if (sensorOrientation == 0 && displayRotationDegrees == 90) 180 else 0
-        val rotationDegrees = ((displayRotationDegrees + tabletUpsideDownFix) % 360).toFloat()
+        // For portrait apps:
+        // - 90° sensor (phones): buffer is landscape → need 90° rotation to portrait
+        // - 0° sensor (tablets): buffer is portrait → need displayRotation adjustment
+        val rotationDegrees = when {
+            // Tablet with landscape sensor in portrait: add 180° fix for upside-down
+            sensorOrientation == 0 && displayRotationDegrees == 90 -> 270f
+            // Phone with 90° sensor in portrait: rotate 90° to match
+            sensorOrientation == 90 && displayRotationDegrees == 0 -> 90f
+            // Default: use display rotation
+            else -> displayRotationDegrees.toFloat()
+        }
 
         Log.d(TAG, "[TRANSFORM] Applying rotation: ${rotationDegrees}°")
 

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.33.0",
   "description": "Native-backed document scanner for React Native with customizable overlays.",
   "license": "MIT",
   "main": "dist/index.js",