react-native-rectangle-doc-scanner 11.3.0 → 13.0.0

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

@@ -486,32 +486,11 @@ 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).
-        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
-        }
-
-        fun rotatePoint(point: org.opencv.core.Point): org.opencv.core.Point {
-            return if (sensorOrientation == 90) {
-                org.opencv.core.Point(
-                    point.y,
-                    imageWidth - point.x
-                )
-            } else {
-                point
-            }
-        }
-
-        val finalWidth = if (sensorOrientation == 90) imageHeight else imageWidth
-        val finalHeight = if (sensorOrientation == 90) imageWidth else imageHeight
+        // Rectangle coordinates are already in the rotated image space (effective rotation applied).
+        val finalWidth = imageWidth
+        val finalHeight = imageHeight
 
-        // Then apply fit-center scaling
+        // Apply fit-center scaling to match TextureView display.
         val scaleX = viewWidth / finalWidth.toFloat()
         val scaleY = viewHeight / finalHeight.toFloat()
         val scale = scaleX.coerceAtMost(scaleY)
@@ -522,10 +501,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
             )
         }
 
@@ -536,10 +514,9 @@ class CameraController(
             transformPoint(rectangle.bottomRight)
         )
 
-        Log.d(TAG, "[MAPPING] Sensor: ${sensorOrientation}°, Image: ${imageWidth}x${imageHeight} → Final: ${finalWidth}x${finalHeight}")
+        Log.d(TAG, "[MAPPING] 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/android/src/camera2/kotlin/com/reactnativerectangledocscanner/DocumentScannerView.kt

@@ -60,6 +60,7 @@ class DocumentScannerView(context: ThemedReactContext) : FrameLayout(context), L
     private var lastDetectedImageHeight = 0
     private var lastRectangleOnScreen: Rectangle? = null
     private var lastSmoothedRectangleOnScreen: Rectangle? = null
+    private val iouHistory = ArrayDeque<Rectangle>()
 
     // Coroutine scope for async operations
     private val scope = CoroutineScope(Dispatchers.Main + SupervisorJob())
@@ -175,6 +176,7 @@ class DocumentScannerView(context: ThemedReactContext) : FrameLayout(context), L
         }
     }
 
+
     private fun setupCamera() {
         try {
             Log.d(TAG, "[SETUP] Creating CameraController...")
@@ -305,23 +307,33 @@ class DocumentScannerView(context: ThemedReactContext) : FrameLayout(context), L
             overlayView.setRectangle(rectangleOnScreen, overlayColor)
         }
 
-        // Update stable counter based on quality
+        // Update stable counter based on quality + IOU stability
         if (rectangleCoordinates == null) {
             if (stableCounter != 0) {
                 Log.d(TAG, "Rectangle lost, resetting stableCounter")
             }
             stableCounter = 0
+            clearIouHistory()
         } else {
             when (quality) {
                 RectangleQuality.GOOD -> {
-                    stableCounter = min(stableCounter + 1, detectionCountBeforeCapture)
-                    Log.d(TAG, "Good rectangle detected, stableCounter: $stableCounter/$detectionCountBeforeCapture")
+                    val isStable = rectangleOnScreen?.let { updateIouHistory(it) } ?: false
+                    if (isStable) {
+                        stableCounter = min(stableCounter + 1, detectionCountBeforeCapture)
+                        Log.d(TAG, "Good rectangle detected, stableCounter: $stableCounter/$detectionCountBeforeCapture")
+                    } else {
+                        if (stableCounter > 0) {
+                            stableCounter--
+                        }
+                        Log.d(TAG, "Rectangle unstable (IOU), stableCounter: $stableCounter")
+                    }
                 }
                 RectangleQuality.BAD_ANGLE, RectangleQuality.TOO_FAR -> {
                     if (stableCounter > 0) {
                         stableCounter--
                     }
                     Log.d(TAG, "Bad rectangle detected (type: $quality), stableCounter: $stableCounter")
+                    clearIouHistory()
                 }
             }
         }
@@ -337,6 +349,52 @@ class DocumentScannerView(context: ThemedReactContext) : FrameLayout(context), L
         }
     }
 
+    private fun updateIouHistory(rectangle: Rectangle): Boolean {
+        if (iouHistory.size >= 3) {
+            iouHistory.removeFirst()
+        }
+        iouHistory.addLast(rectangle)
+        if (iouHistory.size < 3) {
+            return false
+        }
+        val r0 = iouHistory.elementAt(0)
+        val r1 = iouHistory.elementAt(1)
+        val r2 = iouHistory.elementAt(2)
+        val iou01 = rectangleIou(r0, r1)
+        val iou12 = rectangleIou(r1, r2)
+        val iou02 = rectangleIou(r0, r2)
+        return iou01 >= 0.85 && iou12 >= 0.85 && iou02 >= 0.85
+    }
+
+    private fun clearIouHistory() {
+        iouHistory.clear()
+    }
+
+    private fun rectangleIou(a: Rectangle, b: Rectangle): Double {
+        fun bounds(r: Rectangle): DoubleArray {
+            val minX = min(min(r.topLeft.x, r.topRight.x), min(r.bottomLeft.x, r.bottomRight.x))
+            val maxX = max(max(r.topLeft.x, r.topRight.x), max(r.bottomLeft.x, r.bottomRight.x))
+            val minY = min(min(r.topLeft.y, r.topRight.y), min(r.bottomLeft.y, r.bottomRight.y))
+            val maxY = max(max(r.topLeft.y, r.topRight.y), max(r.bottomLeft.y, r.bottomRight.y))
+            return doubleArrayOf(minX, minY, maxX, maxY)
+        }
+
+        val ab = bounds(a)
+        val bb = bounds(b)
+        val interLeft = max(ab[0], bb[0])
+        val interTop = max(ab[1], bb[1])
+        val interRight = min(ab[2], bb[2])
+        val interBottom = min(ab[3], bb[3])
+        val interW = max(0.0, interRight - interLeft)
+        val interH = max(0.0, interBottom - interTop)
+        val interArea = interW * interH
+        val areaA = max(0.0, (ab[2] - ab[0])) * max(0.0, (ab[3] - ab[1]))
+        val areaB = max(0.0, (bb[2] - bb[0])) * max(0.0, (bb[3] - bb[1]))
+        val union = areaA + areaB - interArea
+        if (union <= 0.0) return 0.0
+        return interArea / union
+    }
+
     fun capture() {
         captureWithPromise(null)
     }

package/dist/DocScanner.js

@@ -715,7 +715,7 @@ const NativeScanner = (0, react_1.forwardRef)(({ onCapture, overlayColor = DEFAU
     const overlayIsActive = autoCapture ? isAutoCapturing : (detectedRectangle?.stableCounter ?? 0) > 0;
     const detectionThreshold = autoCapture ? minStableFrames : 99999;
     return (react_1.default.createElement(react_native_1.View, { style: styles.container },
-        react_1.default.createElement(react_native_document_scanner_1.default, { ref: scannerRef, style: styles.scanner, detectionCountBeforeCapture: detectionThreshold, overlayColor: overlayColor, enableTorch: enableTorch, quality: normalizedQuality, useBase64: useBase64, manualOnly: false, detectionConfig: detectionConfig, onPictureTaken: handlePictureTaken, onError: handleError, onRectangleDetect: handleRectangleDetect }),
+        react_1.default.createElement(react_native_document_scanner_1.default, { ref: scannerRef, style: styles.scanner, detectionCountBeforeCapture: detectionThreshold, overlayColor: overlayColor, enableTorch: enableTorch, quality: normalizedQuality, useBase64: useBase64, manualOnly: react_native_1.Platform.OS === 'android', detectionConfig: detectionConfig, onPictureTaken: handlePictureTaken, onError: handleError, onRectangleDetect: handleRectangleDetect }),
         showGrid && overlayPolygon && (react_1.default.createElement(overlay_1.ScannerOverlay, { active: overlayIsActive, color: gridColor ?? overlayColor, lineWidth: gridLineWidth, polygon: overlayPolygon, clipRect: react_native_1.Platform.OS === 'android' ? null : (detectedRectangle?.previewViewport ?? null) })),
         showManualCaptureButton && (react_1.default.createElement(react_native_1.TouchableOpacity, { style: styles.button, onPress: handleManualCapture })),
         children));
@@ -725,16 +725,11 @@ exports.DocScanner = (0, react_1.forwardRef)((props, ref) => {
         if (react_native_1.Platform.OS !== 'android') {
             return;
         }
-        if (hasVisionCamera) {
-            console.log('[DocScanner] Using VisionCamera pipeline');
-        }
-        else {
-            console.warn('[DocScanner] VisionCamera pipeline unavailable, falling back to native view.', {
-                hasVisionCameraModule: Boolean(visionCameraModule),
-                hasReanimated: Boolean(reanimatedModule),
-            });
-        }
+        console.log('[DocScanner] Using native CameraX pipeline on Android');
     }, []);
+    if (react_native_1.Platform.OS === 'android') {
+        return react_1.default.createElement(NativeScanner, { ref: ref, ...props });
+    }
     if (hasVisionCamera) {
         return react_1.default.createElement(VisionCameraScanner, { ref: ref, ...props });
     }

package/package.json

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

package/src/DocScanner.tsx

@@ -994,7 +994,7 @@ const NativeScanner = forwardRef<DocScannerHandle, Props>(
         : detectedRectangle?.rectangleOnScreen ?? detectedRectangle?.rectangleCoordinates ?? null;
     const overlayIsActive = autoCapture ? isAutoCapturing : (detectedRectangle?.stableCounter ?? 0) > 0;
 
-  const detectionThreshold = autoCapture ? minStableFrames : 99999;
+    const detectionThreshold = autoCapture ? minStableFrames : 99999;
 
   return (
       <View style={styles.container}>
@@ -1006,7 +1006,7 @@ const NativeScanner = forwardRef<DocScannerHandle, Props>(
           enableTorch={enableTorch}
           quality={normalizedQuality}
           useBase64={useBase64}
-          manualOnly={false}
+          manualOnly={Platform.OS === 'android'}
           detectionConfig={detectionConfig}
           onPictureTaken={handlePictureTaken}
           onError={handleError}
@@ -1035,16 +1035,13 @@ export const DocScanner = forwardRef<DocScannerHandle, Props>((props, ref) => {
     if (Platform.OS !== 'android') {
       return;
     }
-    if (hasVisionCamera) {
-      console.log('[DocScanner] Using VisionCamera pipeline');
-    } else {
-      console.warn('[DocScanner] VisionCamera pipeline unavailable, falling back to native view.', {
-        hasVisionCameraModule: Boolean(visionCameraModule),
-        hasReanimated: Boolean(reanimatedModule),
-      });
-    }
+    console.log('[DocScanner] Using native CameraX pipeline on Android');
   }, []);
 
+  if (Platform.OS === 'android') {
+    return <NativeScanner ref={ref} {...props} />;
+  }
+
   if (hasVisionCamera) {
     return <VisionCameraScanner ref={ref} {...props} />;
   }