react-native-rectangle-doc-scanner 13.0.0 → 13.2.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,8 @@ 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
+            // Match preview aspect ratio to avoid square analysis frames on some devices.
+            .setTargetAspectRatio(AspectRatio.RATIO_4_3)
             .setTargetRotation(targetRotation)  // Match preview rotation
             .build()
             .also {
@@ -201,6 +203,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()
 
@@ -265,10 +268,11 @@ class CameraController(
             return
         }
 
-        val rotationDegrees = imageProxy.imageInfo.rotationDegrees
         val imageWidth = imageProxy.width
         val imageHeight = imageProxy.height
 
+        val rotationDegrees = imageProxy.imageInfo.rotationDegrees
+
         // Calculate rotation using the same logic as TextureView transform
         val sensorOrientation = getCameraSensorOrientation()
         val displayRotationDegrees = when (textureView.display?.rotation ?: Surface.ROTATION_0) {
@@ -281,16 +285,16 @@ class CameraController(
 
         // Use the same rotation logic as updateTextureViewTransform
         val tabletUpsideDownFix = if (sensorOrientation == 0 && displayRotationDegrees == 90) 180 else 0
-        val effectiveRotation = if (sensorOrientation == 0) {
-            (displayRotationDegrees + tabletUpsideDownFix) % 360
-        } else {
-            sensorOrientation
-        }
+        val effectiveRotation = (displayRotationDegrees + tabletUpsideDownFix) % 360
 
-        Log.d(TAG, "[ANALYZE] Sensor: $sensorOrientation°, Display: $displayRotationDegrees°, Effective: $effectiveRotation°")
+        Log.d(
+            TAG,
+            "[ANALYZE] Sensor: $sensorOrientation°, Display: $displayRotationDegrees°, " +
+                "ImageProxy: $rotationDegrees°, Effective: $effectiveRotation°"
+        )
 
-        // Try ML Kit first
-        val inputImage = InputImage.fromMediaImage(mediaImage, rotationDegrees)
+        // Try ML Kit first (use the same rotation as preview/OpenCV)
+        val inputImage = InputImage.fromMediaImage(mediaImage, effectiveRotation)
 
         objectDetector.process(inputImage)
             .addOnSuccessListener { objects ->
@@ -490,10 +494,10 @@ class CameraController(
         val finalWidth = imageWidth
         val finalHeight = imageHeight
 
-        // Apply fit-center scaling to match TextureView display.
+        // Apply center-crop scaling to match TextureView display.
         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
@@ -579,26 +583,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)  // Use max to fill
 
         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 fully covers 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

@@ -67,6 +67,7 @@ class DocumentScannerView(context: ThemedReactContext) : FrameLayout(context), L
 
     companion object {
         private const val TAG = "DocumentScannerView"
+        private const val PREVIEW_ASPECT_RATIO = 3f / 4f // width:height (matches 3:4)
     }
 
     override val lifecycle: Lifecycle
@@ -111,6 +112,9 @@ class DocumentScannerView(context: ThemedReactContext) : FrameLayout(context), L
         addView(overlayView, 1)  // Add at index 1 (front)
         Log.d(TAG, "[INIT] OverlayView added, childCount: $childCount")
 
+        // Match camera UI look with letterboxing when preview doesn't fill the view.
+        setBackgroundColor(android.graphics.Color.BLACK)
+
         Log.d(TAG, "╔════════════════════════════════════════╗")
         Log.d(TAG, "║  DocumentScannerView INIT COMPLETE     ║")
         Log.d(TAG, "╚════════════════════════════════════════╝")
@@ -137,11 +141,29 @@ class DocumentScannerView(context: ThemedReactContext) : FrameLayout(context), L
     override fun onLayout(changed: Boolean, left: Int, top: Int, right: Int, bottom: Int) {
         super.onLayout(changed, left, top, right, bottom)
         if (changed) {
+            layoutPreviewAndOverlay(right - left, bottom - top)
             Log.d(TAG, "[LAYOUT] View size: ${right - left}x${bottom - top}, PreviewView: ${previewView.width}x${previewView.height}")
             cameraController?.refreshTransform()
         }
     }
 
+    private fun layoutPreviewAndOverlay(viewWidth: Int, viewHeight: Int) {
+        if (viewWidth <= 0 || viewHeight <= 0) return
+
+        // Always fill width to avoid left/right letterboxing.
+        val targetWidth = viewWidth
+        val targetHeight = (viewWidth / PREVIEW_ASPECT_RATIO).toInt()
+
+        val left = 0
+        // Center vertically; allows top/bottom crop when targetHeight > viewHeight.
+        val top = (viewHeight - targetHeight) / 2
+        val right = left + targetWidth
+        val bottom = top + targetHeight
+
+        previewView.layout(left, top, right, bottom)
+        overlayView.layout(left, top, right, bottom)
+    }
+
     private fun initializeCameraWhenReady() {
         // If view is already laid out, start camera immediately
         if (width > 0 && height > 0) {
@@ -213,17 +235,26 @@ class DocumentScannerView(context: ThemedReactContext) : FrameLayout(context), L
             lastDetectedImageHeight = imageHeight
         }
 
-        val rectangleOnScreen = if (rectangle != null && width > 0 && height > 0) {
+        val previewWidth = previewView.width
+        val previewHeight = previewView.height
+
+        val rectangleOnScreen = if (rectangle != null && previewWidth > 0 && previewHeight > 0) {
             cameraController?.mapRectangleToView(rectangle, imageWidth, imageHeight)
-                ?: DocumentDetector.transformRectangleToViewCoordinates(rectangle, imageWidth, imageHeight, width, height)
+                ?: DocumentDetector.transformRectangleToViewCoordinates(
+                    rectangle,
+                    imageWidth,
+                    imageHeight,
+                    previewWidth,
+                    previewHeight
+                )
         } else {
             null
         }
-        val smoothedRectangleOnScreen = smoothRectangle(rectangleOnScreen, width, height)
+        val smoothedRectangleOnScreen = smoothRectangle(rectangleOnScreen, previewWidth, previewHeight)
         lastRectangleOnScreen = smoothedRectangleOnScreen
         val quality = when {
-            smoothedRectangleOnScreen != null && width > 0 && height > 0 ->
-                DocumentDetector.evaluateRectangleQualityInView(smoothedRectangleOnScreen, width, height)
+            smoothedRectangleOnScreen != null && previewWidth > 0 && previewHeight > 0 ->
+                DocumentDetector.evaluateRectangleQualityInView(smoothedRectangleOnScreen, previewWidth, previewHeight)
             rectangle != null -> DocumentDetector.evaluateRectangleQuality(rectangle, imageWidth, imageHeight)
             else -> RectangleQuality.TOO_FAR
         }

package/package.json

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