react-native-rectangle-doc-scanner 10.35.0 → 10.37.0

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

@@ -457,69 +457,36 @@ class CameraController(
             else -> 0
         }
 
-        // The coordinates coming from ImageAnalysis are in sensor's native orientation.
-        // For a 90° sensor (phones in portrait), the camera buffer is landscape but coordinates
-        // are in sensor space. We need to rotate coordinates to match the display orientation.
+        // For sensor 90° (phones): coordinates are in sensor space, need 90° rotation
+        // For sensor 0° (tablets): coordinates are already correct orientation
 
-        // The TextureView rotation for display
-        val tabletUpsideDownFix = if (sensorOrientation == 0 && displayRotationDegrees == 90) 180 else 0
-        val textureViewRotation = ((displayRotationDegrees + tabletUpsideDownFix) % 360).toFloat()
-
-        // For coordinate mapping: we need to account for BOTH sensor orientation AND display rotation
-        // - Sensor 90° + Display 0°: Coordinates are in landscape sensor space, need 90° rotation to portrait
-        // - Sensor 0° + Display 90°: Coordinates are in portrait, need 270° rotation (display + fix)
-        val rotationDegrees = if (sensorOrientation == 90 && displayRotationDegrees == 0) {
-            90f  // Rotate coordinates 90° to match portrait display
-        } else {
-            textureViewRotation  // Use TextureView rotation
-        }
-
-        Log.d(TAG, "[MAPPING] Image: ${imageWidth}x${imageHeight}, Sensor: ${sensorOrientation}°, " +
-            "Display: ${displayRotationDegrees}°, TextureView rotation: ${textureViewRotation}°, " +
-            "Coordinate rotation: ${rotationDegrees}°")
-
-        // Apply rotation to coordinates to match display orientation
+        // First rotate coordinates if needed (sensor 90° means image is rotated 90° CW in sensor space)
         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(
+            return if (sensorOrientation == 90) {
+                // Rotate 90° CCW to convert from sensor space to display space
+                org.opencv.core.Point(
                     point.y,
                     imageWidth - point.x
                 )
-                else -> point  // 0 degrees, no rotation
+            } else {
+                point
             }
         }
 
-        // Determine dimensions after rotation
-        val rotatedImageWidth = if (rotationDegrees == 90f || rotationDegrees == 270f) {
-            imageHeight
-        } else {
-            imageWidth
-        }
-        val rotatedImageHeight = if (rotationDegrees == 90f || rotationDegrees == 270f) {
-            imageWidth
-        } else {
-            imageHeight
-        }
+        // After rotation, determine final dimensions
+        val finalWidth = if (sensorOrientation == 90) imageHeight else imageWidth
+        val finalHeight = if (sensorOrientation == 90) 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)
+        // Then apply fit-center scaling
+        val scaleX = viewWidth / finalWidth.toFloat()
+        val scaleY = viewHeight / finalHeight.toFloat()
+        val scale = scaleX.coerceAtMost(scaleY)
 
-        val scaledWidth = rotatedImageWidth * scale
-        val scaledHeight = rotatedImageHeight * scale
+        val scaledWidth = finalWidth * scale
+        val scaledHeight = finalHeight * scale
         val offsetX = (viewWidth - scaledWidth) / 2f
         val offsetY = (viewHeight - scaledHeight) / 2f
 
-        // 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(
@@ -535,8 +502,11 @@ class CameraController(
             transformPoint(rectangle.bottomRight)
         )
 
-        Log.d(TAG, "[MAPPING] Original TL: (${rectangle.topLeft.x}, ${rectangle.topLeft.y}) → " +
-            "Transformed: (${result.topLeft.x}, ${result.topLeft.y})")
+        Log.d(TAG, "[MAPPING] Sensor: ${sensorOrientation}°, Image: ${imageWidth}x${imageHeight} → Final: ${finalWidth}x${finalHeight}")
+        Log.d(TAG, "[MAPPING] View: ${viewWidth.toInt()}x${viewHeight.toInt()}, Scale: $scale, Offset: ($offsetX, $offsetY)")
+        Log.d(TAG, "[MAPPING] TL: (${rectangle.topLeft.x}, ${rectangle.topLeft.y}) → " +
+            "Rotated: (${rotatePoint(rectangle.topLeft).x}, ${rotatePoint(rectangle.topLeft).y}) → " +
+            "Final: (${result.topLeft.x}, ${result.topLeft.y})")
 
         return result
     }

package/package.json

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