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

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

@@ -123,6 +123,7 @@ class CameraController(
         Log.d(TAG, "[CAMERAX] Setting target rotation to ROTATION_0 (portrait-only app)")
 
         preview = Preview.Builder()
+            .setTargetAspectRatio(AspectRatio.RATIO_4_3)
             .setTargetRotation(targetRotation)  // Force portrait
             .build()
             .also { previewUseCase ->
@@ -185,7 +186,7 @@ class CameraController(
         // ImageAnalysis UseCase for document detection
         imageAnalyzer = ImageAnalysis.Builder()
             .setBackpressureStrategy(ImageAnalysis.STRATEGY_KEEP_ONLY_LATEST)
-            .setTargetResolution(android.util.Size(1920, 1440))  // Higher resolution for better small-edge detection
+            .setTargetAspectRatio(AspectRatio.RATIO_4_3)
             .setTargetRotation(targetRotation)  // Match preview rotation
             .build()
             .also {
@@ -201,6 +202,7 @@ class CameraController(
         // ImageCapture UseCase
         imageCapture = ImageCapture.Builder()
             .setCaptureMode(ImageCapture.CAPTURE_MODE_MAXIMIZE_QUALITY)
+            .setTargetAspectRatio(AspectRatio.RATIO_4_3)
             .setTargetRotation(targetRotation)  // Match preview rotation
             .build()
 
@@ -442,45 +444,14 @@ class CameraController(
 
         if (viewWidth <= 0 || viewHeight <= 0) return null
 
-        // The image coordinates are in camera sensor space. We need to transform them
-        // to match how the TextureView displays the image (after rotation/scaling).
+        // Image coordinates are already in display orientation (rotation applied before detection).
+        val finalWidth = imageWidth
+        val finalHeight = imageHeight
 
-        // 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
-        }
-
-        // For sensor 90° (phones): coordinates are in sensor space, need 90° rotation
-        // For sensor 0° (tablets): coordinates are already correct 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 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
-            }
-        }
-
-        // After rotation, determine final dimensions
-        val finalWidth = if (sensorOrientation == 90) imageHeight else imageWidth
-        val finalHeight = if (sensorOrientation == 90) imageWidth else imageHeight
-
-        // Then apply fit-center scaling
+        // Apply the same center-crop scaling as the TextureView transform.
         val scaleX = viewWidth / finalWidth.toFloat()
         val scaleY = viewHeight / finalHeight.toFloat()
-        val scale = scaleX.coerceAtMost(scaleY)
+        val scale = scaleX.coerceAtLeast(scaleY)
 
         val scaledWidth = finalWidth * scale
         val scaledHeight = finalHeight * scale
@@ -488,10 +459,9 @@ class CameraController(
         val offsetY = (viewHeight - scaledHeight) / 2f
 
         fun transformPoint(point: org.opencv.core.Point): org.opencv.core.Point {
-            val rotated = rotatePoint(point)
             return org.opencv.core.Point(
-                rotated.x * scale + offsetX,
-                rotated.y * scale + offsetY
+                point.x * scale + offsetX,
+                point.y * scale + offsetY
             )
         }
 
@@ -502,10 +472,9 @@ class CameraController(
             transformPoint(rectangle.bottomRight)
         )
 
-        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] Image: ${imageWidth}x${imageHeight} → View: ${viewWidth.toInt()}x${viewHeight.toInt()}")
+        Log.d(TAG, "[MAPPING] 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
@@ -548,10 +517,8 @@ 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()
+        // CameraX provides buffers in sensor orientation; rotate to match display.
+        val rotationDegrees = ((sensorOrientation - displayRotationDegrees + 360) % 360).toFloat()
 
         Log.d(TAG, "[TRANSFORM] Applying rotation: ${rotationDegrees}°")
 
@@ -571,26 +538,17 @@ class CameraController(
             bufferHeight
         }
 
-        // Scale to fit within the view while maintaining aspect ratio (no zoom/crop)
+        // Scale to fill the view while maintaining aspect ratio (center-crop).
         val scaleX = viewWidth.toFloat() / rotatedBufferWidth.toFloat()
         val scaleY = viewHeight.toFloat() / rotatedBufferHeight.toFloat()
-        val scale = scaleX.coerceAtMost(scaleY)  // Use min to fit
+        val scale = scaleX.coerceAtLeast(scaleY)
 
         Log.d(TAG, "[TRANSFORM] Rotated buffer: ${rotatedBufferWidth}x${rotatedBufferHeight}, ScaleX: $scaleX, ScaleY: $scaleY, Using: $scale")
 
         matrix.postScale(scale, scale, centerX, centerY)
 
-        // Track the actual preview viewport within the view for clipping overlays.
-        val scaledWidth = rotatedBufferWidth * scale
-        val scaledHeight = rotatedBufferHeight * scale
-        val offsetX = (viewWidth - scaledWidth) / 2f
-        val offsetY = (viewHeight - scaledHeight) / 2f
-        previewViewport = android.graphics.RectF(
-            offsetX,
-            offsetY,
-            offsetX + scaledWidth,
-            offsetY + scaledHeight
-        )
+        // With center-crop, the preview fills the view bounds.
+        previewViewport = android.graphics.RectF(0f, 0f, viewWidth.toFloat(), viewHeight.toFloat())
 
         textureView.setTransform(matrix)
         Log.d(TAG, "[TRANSFORM] Transform applied successfully")

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

@@ -749,7 +749,7 @@ class DocumentScannerView(context: ThemedReactContext) : FrameLayout(context), L
         if (viewWidth == 0 || viewHeight == 0 || imageWidth == 0 || imageHeight == 0) {
             return rectangle
         }
-        val scale = min(
+        val scale = max(
             viewWidth.toDouble() / imageWidth.toDouble(),
             viewHeight.toDouble() / imageHeight.toDouble()
         )

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

@@ -540,7 +540,7 @@ class DocumentDetector {
                 return rectangle
             }
 
-            val scale = min(
+            val scale = max(
                 viewWidth.toDouble() / imageWidth.toDouble(),
                 viewHeight.toDouble() / imageHeight.toDouble()
             )
@@ -553,10 +553,7 @@ class DocumentDetector {
             fun mapPoint(point: Point): Point {
                 val x = (point.x * scale) + offsetX
                 val y = (point.y * scale) + offsetY
-                return Point(
-                    x.coerceIn(0.0, viewWidth.toDouble()),
-                    y.coerceIn(0.0, viewHeight.toDouble())
-                )
+                return Point(x, y)
             }
 
             return Rectangle(

package/package.json

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