react-native-rectangle-doc-scanner 13.1.0 → 13.3.0

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

@@ -53,7 +53,9 @@ class CameraController(
 
     companion object {
         private const val TAG = "CameraController"
-        private const val ANALYSIS_TARGET_RESOLUTION = 1920 // Max dimension for analysis
+        // Increased resolution for better corner detection (was causing 640x480 downscale)
+        private const val ANALYSIS_TARGET_WIDTH = 1280
+        private const val ANALYSIS_TARGET_HEIGHT = 960
     }
 
     private fun getCameraSensorOrientation(): Int {
@@ -183,11 +185,11 @@ class CameraController(
                 Log.d(TAG, "[CAMERAX] SurfaceProvider set successfully")
             }
 
-        // ImageAnalysis UseCase for document detection
+        // ImageAnalysis UseCase for document detection with fixed high resolution
         imageAnalyzer = ImageAnalysis.Builder()
             .setBackpressureStrategy(ImageAnalysis.STRATEGY_KEEP_ONLY_LATEST)
-            // Match preview aspect ratio to avoid square analysis frames on some devices.
-            .setTargetAspectRatio(AspectRatio.RATIO_4_3)
+            // Use explicit resolution instead of aspect ratio to prevent 640x480 downscale
+            .setTargetResolution(Size(ANALYSIS_TARGET_WIDTH, ANALYSIS_TARGET_HEIGHT))
             .setTargetRotation(targetRotation)  // Match preview rotation
             .build()
             .also {
@@ -494,10 +496,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
@@ -583,26 +585,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,7 +67,8 @@ 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)
+        // Removed fixed aspect ratio to prevent squished preview on tablets
+        // Preview will now properly fill the view using center-crop scaling
     }
 
     override val lifecycle: Lifecycle
@@ -150,24 +151,10 @@ class DocumentScannerView(context: ThemedReactContext) : FrameLayout(context), L
     private fun layoutPreviewAndOverlay(viewWidth: Int, viewHeight: Int) {
         if (viewWidth <= 0 || viewHeight <= 0) return
 
-        val targetWidth: Int
-        val targetHeight: Int
-        val aspectHeight = (viewWidth / PREVIEW_ASPECT_RATIO).toInt()
-        if (aspectHeight <= viewHeight) {
-            targetWidth = viewWidth
-            targetHeight = aspectHeight
-        } else {
-            targetWidth = (viewHeight * PREVIEW_ASPECT_RATIO).toInt()
-            targetHeight = viewHeight
-        }
-
-        val left = (viewWidth - targetWidth) / 2
-        val top = if (targetHeight < viewHeight) 0 else (viewHeight - targetHeight) / 2
-        val right = left + targetWidth
-        val bottom = top + targetHeight
-
-        previewView.layout(left, top, right, bottom)
-        overlayView.layout(left, top, right, bottom)
+        // Fill entire view to prevent squished appearance on tablets
+        // CameraX will handle aspect ratio via center-crop in updateTextureViewTransform
+        previewView.layout(0, 0, viewWidth, viewHeight)
+        overlayView.layout(0, 0, viewWidth, viewHeight)
     }
 
     private fun initializeCameraWhenReady() {
@@ -270,36 +257,72 @@ class DocumentScannerView(context: ThemedReactContext) : FrameLayout(context), L
         }
     }
 
+    // Enhanced snap: Track corner movement per frame
+    private var consecutiveStableFrames = 0
+    private val requiredStableFrames = 3 // Require 3 consecutive stable frames for snap
+
     private fun smoothRectangle(rectangle: Rectangle?, viewWidth: Int, viewHeight: Int): Rectangle? {
         if (rectangle == null || viewWidth <= 0 || viewHeight <= 0) {
             lastSmoothedRectangleOnScreen = null
+            consecutiveStableFrames = 0
             return null
         }
 
         val prev = lastSmoothedRectangleOnScreen
         if (prev == null) {
             lastSmoothedRectangleOnScreen = rectangle
+            consecutiveStableFrames = 0
             return rectangle
         }
 
         val minDim = min(viewWidth, viewHeight).toDouble()
-        val snapThreshold = max(12.0, minDim * 0.015)
-        val smoothThreshold = max(24.0, minDim * 0.06)
-        val maxCornerDistance = max(
+        // Tighter snap threshold for better stability
+        val snapThreshold = max(10.0, minDim * 0.012)
+        val smoothThreshold = max(20.0, minDim * 0.05)
+
+        // Calculate max corner movement
+        val maxCornerDist = max(
             maxCornerDistance(prev, rectangle),
             maxCornerDistance(rectangle, prev)
         )
 
+        // Enhanced snap logic: Check individual corner distances
+        val allCornersStable = areAllCornersStable(prev, rectangle, snapThreshold)
+
         val result = when {
-            maxCornerDistance <= snapThreshold -> prev
-            maxCornerDistance <= smoothThreshold -> blendRectangle(prev, rectangle, 0.35)
-            else -> rectangle
+            // Snap only if all corners are stable AND we have consecutive stable frames
+            allCornersStable && maxCornerDist <= snapThreshold -> {
+                consecutiveStableFrames++
+                if (consecutiveStableFrames >= requiredStableFrames) {
+                    prev // Lock to previous position
+                } else {
+                    blendRectangle(prev, rectangle, 0.25) // Small blend while building stability
+                }
+            }
+            maxCornerDist <= smoothThreshold -> {
+                consecutiveStableFrames = 0
+                blendRectangle(prev, rectangle, 0.35)
+            }
+            else -> {
+                consecutiveStableFrames = 0
+                rectangle
+            }
         }
 
         lastSmoothedRectangleOnScreen = result
         return result
     }
 
+    /**
+     * Check if all 4 corners are within the snap threshold (not just max distance)
+     */
+    private fun areAllCornersStable(prev: Rectangle, current: Rectangle, threshold: Double): Boolean {
+        return distance(prev.topLeft, current.topLeft) <= threshold &&
+               distance(prev.topRight, current.topRight) <= threshold &&
+               distance(prev.bottomLeft, current.bottomLeft) <= threshold &&
+               distance(prev.bottomRight, current.bottomRight) <= threshold
+    }
+
     private fun maxCornerDistance(a: Rectangle, b: Rectangle): Double {
         return max(
             max(

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

@@ -436,9 +436,101 @@ class DocumentDetector {
             if (aspect < 0.45 || aspect > 2.8) {
                 return false
             }
+
+            // Enhanced validation: Check corner angles (should be close to 90°)
+            if (!hasValidCornerAngles(rectangle)) {
+                return false
+            }
+
+            // Enhanced validation: Check edge straightness
+            if (!hasValidEdgeStraightness(rectangle, srcMat)) {
+                return false
+            }
+
+            // Enhanced validation: Check margin from view edges (avoid detecting screen borders)
+            val margin = minDim * 0.05 // 5% margin
+            if (rectangle.topLeft.x < margin || rectangle.topLeft.y < margin ||
+                rectangle.topRight.x > srcMat.cols() - margin || rectangle.topRight.y < margin ||
+                rectangle.bottomLeft.x < margin || rectangle.bottomLeft.y > srcMat.rows() - margin ||
+                rectangle.bottomRight.x > srcMat.cols() - margin || rectangle.bottomRight.y > srcMat.rows() - margin) {
+                return false
+            }
+
             return true
         }
 
+        /**
+         * Check if all corners have angles close to 90° (within 60°-120° range)
+         */
+        private fun hasValidCornerAngles(rectangle: Rectangle): Boolean {
+            fun angleAt(p1: Point, vertex: Point, p2: Point): Double {
+                val v1x = p1.x - vertex.x
+                val v1y = p1.y - vertex.y
+                val v2x = p2.x - vertex.x
+                val v2y = p2.y - vertex.y
+
+                val dot = v1x * v2x + v1y * v2y
+                val len1 = sqrt(v1x * v1x + v1y * v1y)
+                val len2 = sqrt(v2x * v2x + v2y * v2y)
+
+                if (len1 < 1.0 || len2 < 1.0) return 90.0
+
+                val cosAngle = (dot / (len1 * len2)).coerceIn(-1.0, 1.0)
+                return Math.toDegrees(kotlin.math.acos(cosAngle))
+            }
+
+            val angleTL = angleAt(rectangle.topRight, rectangle.topLeft, rectangle.bottomLeft)
+            val angleTR = angleAt(rectangle.topLeft, rectangle.topRight, rectangle.bottomRight)
+            val angleBL = angleAt(rectangle.topLeft, rectangle.bottomLeft, rectangle.bottomRight)
+            val angleBR = angleAt(rectangle.topRight, rectangle.bottomRight, rectangle.bottomLeft)
+
+            // All angles should be within 60°-120° (allow ±30° from 90°)
+            return angleTL in 60.0..120.0 && angleTR in 60.0..120.0 &&
+                   angleBL in 60.0..120.0 && angleBR in 60.0..120.0
+        }
+
+        /**
+         * Check if edges are sufficiently straight (low deviation from fitted line)
+         */
+        private fun hasValidEdgeStraightness(rectangle: Rectangle, srcMat: Mat): Boolean {
+            val minDim = min(srcMat.cols(), srcMat.rows()).toDouble()
+            val maxDeviation = max(10.0, minDim * 0.02) // Allow 2% deviation
+
+            fun checkEdgeStraightness(p1: Point, p2: Point, p3: Point, p4: Point): Boolean {
+                // Check if points p1-p2 and p3-p4 form roughly parallel lines
+                val dx1 = p2.x - p1.x
+                val dy1 = p2.y - p1.y
+                val dx2 = p4.x - p3.x
+                val dy2 = p4.y - p3.y
+
+                val len1 = sqrt(dx1 * dx1 + dy1 * dy1)
+                val len2 = sqrt(dx2 * dx2 + dy2 * dy2)
+
+                if (len1 < 1.0 || len2 < 1.0) return true
+
+                // Normalize and compute angle difference
+                val dot = (dx1 * dx2 + dy1 * dy2) / (len1 * len2)
+                val angleDiff = Math.toDegrees(kotlin.math.acos(dot.coerceIn(-1.0, 1.0)))
+
+                // Parallel lines should have angle diff close to 0° or 180°
+                return angleDiff < 15.0 || angleDiff > 165.0
+            }
+
+            // Check top vs bottom edges
+            val topBottomOk = checkEdgeStraightness(
+                rectangle.topLeft, rectangle.topRight,
+                rectangle.bottomLeft, rectangle.bottomRight
+            )
+
+            // Check left vs right edges
+            val leftRightOk = checkEdgeStraightness(
+                rectangle.topLeft, rectangle.bottomLeft,
+                rectangle.topRight, rectangle.bottomRight
+            )
+
+            return topBottomOk && leftRightOk
+        }
+
         /**
          * Evaluate rectangle quality (matching iOS logic)
          */

package/package.json

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