react-native-rectangle-doc-scanner 13.2.0 → 13.4.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 {

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,18 +151,25 @@ class DocumentScannerView(context: ThemedReactContext) : FrameLayout(context), L
     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()
+        // Check if device is tablet (screen width >= 600dp)
+        val isTablet = (viewWidth / resources.displayMetrics.density) >= 600
 
-        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
+        if (isTablet) {
+            // Tablet: Fill entire view to prevent squished appearance
+            previewView.layout(0, 0, viewWidth, viewHeight)
+            overlayView.layout(0, 0, viewWidth, viewHeight)
+        } else {
+            // Phone: Use 4:3 aspect ratio with letterboxing
+            val targetAspectRatio = 3f / 4f // width/height
+            val targetWidth = viewWidth
+            val targetHeight = (viewWidth / targetAspectRatio).toInt()
+
+            val top = (viewHeight - targetHeight) / 2
+            val bottom = top + targetHeight
 
-        previewView.layout(left, top, right, bottom)
-        overlayView.layout(left, top, right, bottom)
+            previewView.layout(0, top, viewWidth, bottom)
+            overlayView.layout(0, top, viewWidth, bottom)
+        }
     }
 
     private fun initializeCameraWhenReady() {
@@ -264,36 +272,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,104 @@ class DocumentDetector {
             if (aspect < 0.45 || aspect > 2.8) {
                 return false
             }
+
+            // Enhanced validation: Check corner angles (should be close to 90°)
+            // Made more lenient: 50°-130° (was 60°-120°)
+            if (!hasValidCornerAngles(rectangle)) {
+                return false
+            }
+
+            // Enhanced validation: Check edge straightness
+            // Made more lenient: 20° tolerance (was 15°)
+            if (!hasValidEdgeStraightness(rectangle, srcMat)) {
+                return false
+            }
+
+            // Enhanced validation: Check margin from view edges (avoid detecting screen borders)
+            // Made more lenient: 3% margin (was 5%)
+            val margin = minDim * 0.03
+            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 50°-130° (allow ±40° from 90°, more lenient)
+            return angleTL in 50.0..130.0 && angleTR in 50.0..130.0 &&
+                   angleBL in 50.0..130.0 && angleBR in 50.0..130.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° (more lenient: 20° tolerance)
+                return angleDiff < 20.0 || angleDiff > 160.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.2.0",
+  "version": "13.4.0",
   "description": "Native-backed document scanner for React Native with customizable overlays.",
   "license": "MIT",
   "main": "dist/index.js",