react-native-rectangle-doc-scanner 3.130.0 → 3.131.0

package/android/build.gradle

@@ -0,0 +1,78 @@
+buildscript {
+    ext.kotlin_version = '1.8.21'
+    repositories {
+        google()
+        mavenCentral()
+    }
+    dependencies {
+        classpath "com.android.tools.build:gradle:7.4.2"
+        classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"
+    }
+}
+
+apply plugin: 'com.android.library'
+apply plugin: 'kotlin-android'
+
+def safeExtGet(prop, fallback) {
+    rootProject.ext.has(prop) ? rootProject.ext.get(prop) : fallback
+}
+
+android {
+    compileSdkVersion safeExtGet('compileSdkVersion', 33)
+
+    defaultConfig {
+        minSdkVersion safeExtGet('minSdkVersion', 21)
+        targetSdkVersion safeExtGet('targetSdkVersion', 33)
+        versionCode 1
+        versionName "1.0"
+    }
+
+    buildTypes {
+        release {
+            minifyEnabled false
+        }
+    }
+
+    compileOptions {
+        sourceCompatibility JavaVersion.VERSION_1_8
+        targetCompatibility JavaVersion.VERSION_1_8
+    }
+
+    kotlinOptions {
+        jvmTarget = '1.8'
+    }
+
+    sourceSets {
+        main {
+            java.srcDirs += 'src/main/kotlin'
+        }
+    }
+}
+
+repositories {
+    google()
+    mavenCentral()
+}
+
+dependencies {
+    implementation "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version"
+    implementation "com.facebook.react:react-native:+"
+
+    // CameraX dependencies
+    def camerax_version = "1.3.0"
+    implementation "androidx.camera:camera-core:${camerax_version}"
+    implementation "androidx.camera:camera-camera2:${camerax_version}"
+    implementation "androidx.camera:camera-lifecycle:${camerax_version}"
+    implementation "androidx.camera:camera-view:${camerax_version}"
+
+    // OpenCV for document detection
+    implementation 'org.opencv:opencv:4.8.0'
+
+    // Coroutines for async operations
+    implementation 'org.jetbrains.kotlinx:kotlinx-coroutines-core:1.7.3'
+    implementation 'org.jetbrains.kotlinx:kotlinx-coroutines-android:1.7.3'
+
+    // AndroidX
+    implementation 'androidx.core:core-ktx:1.10.1'
+    implementation 'androidx.appcompat:appcompat:1.6.1'
+}

package/android/src/main/AndroidManifest.xml

@@ -3,6 +3,14 @@
     package="com.reactnativerectangledocscanner">
 
     <uses-permission android:name="android.permission.CAMERA" />
+    <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE"
+        android:maxSdkVersion="28" />
+    <uses-permission android:name="android.permission.READ_EXTERNAL_STORAGE"
+        android:maxSdkVersion="32" />
+
+    <uses-feature android:name="android.hardware.camera" android:required="true" />
+    <uses-feature android:name="android.hardware.camera.autofocus" android:required="false" />
+    <uses-feature android:name="android.hardware.camera.flash" android:required="false" />
 
     <application>
         <!-- Placeholder application entry, not used for libraries. -->

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

@@ -0,0 +1,229 @@
+package com.reactnativerectangledocscanner
+
+import android.content.Context
+import android.util.Log
+import android.util.Size
+import androidx.camera.core.*
+import androidx.camera.lifecycle.ProcessCameraProvider
+import androidx.camera.view.PreviewView
+import androidx.core.content.ContextCompat
+import androidx.lifecycle.LifecycleOwner
+import java.io.File
+import java.util.concurrent.ExecutorService
+import java.util.concurrent.Executors
+
+class CameraController(
+    private val context: Context,
+    private val lifecycleOwner: LifecycleOwner,
+    private val previewView: PreviewView
+) {
+    private var camera: Camera? = null
+    private var cameraProvider: ProcessCameraProvider? = null
+    private var imageCapture: ImageCapture? = null
+    private var imageAnalysis: ImageAnalysis? = null
+    private val cameraExecutor: ExecutorService = Executors.newSingleThreadExecutor()
+
+    private var useFrontCamera = false
+    private var torchEnabled = false
+
+    var onFrameAnalyzed: ((Rectangle?) -> Unit)? = null
+
+    companion object {
+        private const val TAG = "CameraController"
+    }
+
+    /**
+     * Start camera with preview and analysis
+     */
+    fun startCamera(
+        useFrontCam: Boolean = false,
+        enableDetection: Boolean = true
+    ) {
+        this.useFrontCamera = useFrontCam
+
+        val cameraProviderFuture = ProcessCameraProvider.getInstance(context)
+
+        cameraProviderFuture.addListener({
+            try {
+                cameraProvider = cameraProviderFuture.get()
+                bindCameraUseCases(enableDetection)
+            } catch (e: Exception) {
+                Log.e(TAG, "Failed to start camera", e)
+            }
+        }, ContextCompat.getMainExecutor(context))
+    }
+
+    /**
+     * Stop camera and release resources
+     */
+    fun stopCamera() {
+        cameraProvider?.unbindAll()
+        camera = null
+    }
+
+    /**
+     * Bind camera use cases (preview, capture, analysis)
+     */
+    private fun bindCameraUseCases(enableDetection: Boolean) {
+        val cameraProvider = cameraProvider ?: return
+
+        // Select camera
+        val cameraSelector = if (useFrontCamera) {
+            CameraSelector.DEFAULT_FRONT_CAMERA
+        } else {
+            CameraSelector.DEFAULT_BACK_CAMERA
+        }
+
+        // Preview use case
+        val preview = Preview.Builder()
+            .setTargetResolution(Size(1080, 1920))
+            .build()
+            .also {
+                it.setSurfaceProvider(previewView.surfaceProvider)
+            }
+
+        // Image capture use case (high resolution for document scanning)
+        imageCapture = ImageCapture.Builder()
+            .setCaptureMode(ImageCapture.CAPTURE_MODE_MAXIMIZE_QUALITY)
+            .setTargetResolution(Size(1920, 2560))
+            .build()
+
+        // Image analysis use case for rectangle detection
+        imageAnalysis = if (enableDetection) {
+            ImageAnalysis.Builder()
+                .setTargetResolution(Size(720, 1280))
+                .setBackpressureStrategy(ImageAnalysis.STRATEGY_KEEP_ONLY_LATEST)
+                .build()
+                .also { analysis ->
+                    analysis.setAnalyzer(cameraExecutor) { imageProxy ->
+                        analyzeFrame(imageProxy)
+                    }
+                }
+        } else {
+            null
+        }
+
+        try {
+            // Unbind all use cases before rebinding
+            cameraProvider.unbindAll()
+
+            // Bind use cases to camera
+            val useCases = mutableListOf<UseCase>(preview, imageCapture!!)
+            if (imageAnalysis != null) {
+                useCases.add(imageAnalysis!!)
+            }
+
+            camera = cameraProvider.bindToLifecycle(
+                lifecycleOwner,
+                cameraSelector,
+                *useCases.toTypedArray()
+            )
+
+            // Restore torch state if it was enabled
+            if (torchEnabled) {
+                setTorchEnabled(true)
+            }
+
+            Log.d(TAG, "Camera started successfully")
+        } catch (e: Exception) {
+            Log.e(TAG, "Failed to bind camera use cases", e)
+        }
+    }
+
+    /**
+     * Analyze frame for rectangle detection
+     */
+    private fun analyzeFrame(imageProxy: ImageProxy) {
+        try {
+            val buffer = imageProxy.planes[0].buffer
+            val bytes = ByteArray(buffer.remaining())
+            buffer.get(bytes)
+
+            // Note: Simplified - in production you'd convert ImageProxy to proper format
+            // For now, we'll skip real-time detection in the analyzer and do it on capture
+            onFrameAnalyzed?.invoke(null)
+        } catch (e: Exception) {
+            Log.e(TAG, "Error analyzing frame", e)
+        } finally {
+            imageProxy.close()
+        }
+    }
+
+    /**
+     * Capture photo
+     */
+    fun capturePhoto(
+        outputDirectory: File,
+        onImageCaptured: (File) -> Unit,
+        onError: (Exception) -> Unit
+    ) {
+        val imageCapture = imageCapture ?: run {
+            onError(Exception("Image capture not initialized"))
+            return
+        }
+
+        val photoFile = File(
+            outputDirectory,
+            "doc_scan_${System.currentTimeMillis()}.jpg"
+        )
+
+        val outputOptions = ImageCapture.OutputFileOptions.Builder(photoFile).build()
+
+        imageCapture.takePicture(
+            outputOptions,
+            ContextCompat.getMainExecutor(context),
+            object : ImageCapture.OnImageSavedCallback {
+                override fun onImageSaved(output: ImageCapture.OutputFileResults) {
+                    Log.d(TAG, "Photo capture succeeded: ${photoFile.absolutePath}")
+                    onImageCaptured(photoFile)
+                }
+
+                override fun onError(exception: ImageCaptureException) {
+                    Log.e(TAG, "Photo capture failed", exception)
+                    onError(exception)
+                }
+            }
+        )
+    }
+
+    /**
+     * Enable or disable torch (flashlight)
+     */
+    fun setTorchEnabled(enabled: Boolean) {
+        torchEnabled = enabled
+        camera?.cameraControl?.enableTorch(enabled)
+    }
+
+    /**
+     * Switch between front and back camera
+     */
+    fun switchCamera() {
+        useFrontCamera = !useFrontCamera
+        startCamera(useFrontCamera)
+    }
+
+    /**
+     * Check if torch is available
+     */
+    fun isTorchAvailable(): Boolean {
+        return camera?.cameraInfo?.hasFlashUnit() == true
+    }
+
+    /**
+     * Focus at specific point
+     */
+    fun focusAt(x: Float, y: Float) {
+        val factory = previewView.meteringPointFactory
+        val point = factory.createPoint(x, y)
+        val action = FocusMeteringAction.Builder(point).build()
+        camera?.cameraControl?.startFocusAndMetering(action)
+    }
+
+    /**
+     * Cleanup resources
+     */
+    fun shutdown() {
+        cameraExecutor.shutdown()
+        stopCamera()
+    }
+}

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

@@ -0,0 +1,263 @@
+package com.reactnativerectangledocscanner
+
+import android.graphics.Bitmap
+import android.util.Log
+import org.opencv.android.Utils
+import org.opencv.core.*
+import org.opencv.imgproc.Imgproc
+import kotlin.math.abs
+import kotlin.math.sqrt
+
+data class Rectangle(
+    val topLeft: Point,
+    val topRight: Point,
+    val bottomLeft: Point,
+    val bottomRight: Point
+) {
+    fun toMap(): Map<String, Map<String, Double>> {
+        return mapOf(
+            "topLeft" to mapOf("x" to topLeft.x, "y" to topLeft.y),
+            "topRight" to mapOf("x" to topRight.x, "y" to topRight.y),
+            "bottomLeft" to mapOf("x" to bottomLeft.x, "y" to bottomLeft.y),
+            "bottomRight" to mapOf("x" to bottomRight.x, "y" to bottomRight.y)
+        )
+    }
+}
+
+enum class RectangleQuality {
+    GOOD,
+    BAD_ANGLE,
+    TOO_FAR
+}
+
+class DocumentDetector {
+    companion object {
+        private const val TAG = "DocumentDetector"
+
+        init {
+            try {
+                System.loadLibrary("opencv_java4")
+                Log.d(TAG, "OpenCV library loaded successfully")
+            } catch (e: Exception) {
+                Log.e(TAG, "Failed to load OpenCV library", e)
+            }
+        }
+
+        /**
+         * Detect document rectangle in the bitmap
+         * Returns the largest detected rectangle or null if none found
+         */
+        fun detectRectangle(bitmap: Bitmap): Rectangle? {
+            val mat = Mat()
+            Utils.bitmapToMat(bitmap, mat)
+
+            val rectangle = detectRectangleInMat(mat)
+
+            mat.release()
+
+            return rectangle
+        }
+
+        /**
+         * Detect document rectangle in YUV image format (from camera)
+         */
+        fun detectRectangleInYUV(
+            yuvBytes: ByteArray,
+            width: Int,
+            height: Int,
+            rotation: Int
+        ): Rectangle? {
+            // Create Mat from YUV data
+            val yuvMat = Mat(height + height / 2, width, CvType.CV_8UC1)
+            yuvMat.put(0, 0, yuvBytes)
+
+            // Convert YUV to RGB
+            val rgbMat = Mat()
+            Imgproc.cvtColor(yuvMat, rgbMat, Imgproc.COLOR_YUV2RGB_NV21)
+
+            // Rotate if needed
+            if (rotation != 0) {
+                val rotationCode = when (rotation) {
+                    90 -> Core.ROTATE_90_CLOCKWISE
+                    180 -> Core.ROTATE_180
+                    270 -> Core.ROTATE_90_COUNTERCLOCKWISE
+                    else -> null
+                }
+                if (rotationCode != null) {
+                    Core.rotate(rgbMat, rgbMat, rotationCode)
+                }
+            }
+
+            val rectangle = detectRectangleInMat(rgbMat)
+
+            yuvMat.release()
+            rgbMat.release()
+
+            return rectangle
+        }
+
+        /**
+         * Core detection algorithm using OpenCV
+         */
+        private fun detectRectangleInMat(srcMat: Mat): Rectangle? {
+            val grayMat = Mat()
+            val blurredMat = Mat()
+            val cannyMat = Mat()
+
+            try {
+                // Convert to grayscale
+                if (srcMat.channels() > 1) {
+                    Imgproc.cvtColor(srcMat, grayMat, Imgproc.COLOR_RGB2GRAY)
+                } else {
+                    srcMat.copyTo(grayMat)
+                }
+
+                // Apply Gaussian blur to reduce noise
+                Imgproc.GaussianBlur(grayMat, blurredMat, Size(5.0, 5.0), 0.0)
+
+                // Apply Canny edge detection
+                Imgproc.Canny(blurredMat, cannyMat, 75.0, 200.0)
+
+                // Find contours
+                val contours = mutableListOf<MatOfPoint>()
+                val hierarchy = Mat()
+                Imgproc.findContours(
+                    cannyMat,
+                    contours,
+                    hierarchy,
+                    Imgproc.RETR_EXTERNAL,
+                    Imgproc.CHAIN_APPROX_SIMPLE
+                )
+
+                // Find the largest contour that approximates to a quadrilateral
+                var largestRectangle: Rectangle? = null
+                var largestArea = 0.0
+
+                for (contour in contours) {
+                    val contourArea = Imgproc.contourArea(contour)
+
+                    // Filter small contours
+                    if (contourArea < 1000) continue
+
+                    // Approximate contour to polygon
+                    val approx = MatOfPoint2f()
+                    val contour2f = MatOfPoint2f(*contour.toArray())
+                    val epsilon = 0.02 * Imgproc.arcLength(contour2f, true)
+                    Imgproc.approxPolyDP(contour2f, approx, epsilon, true)
+
+                    // Check if it's a quadrilateral
+                    if (approx.total() == 4L && Imgproc.isContourConvex(MatOfPoint(*approx.toArray()))) {
+                        val points = approx.toArray()
+
+                        if (contourArea > largestArea) {
+                            largestArea = contourArea
+                            largestRectangle = orderPoints(points)
+                        }
+                    }
+
+                    approx.release()
+                    contour2f.release()
+                }
+
+                hierarchy.release()
+                contours.forEach { it.release() }
+
+                return largestRectangle
+            } finally {
+                grayMat.release()
+                blurredMat.release()
+                cannyMat.release()
+            }
+        }
+
+        /**
+         * Order points in consistent order: topLeft, topRight, bottomLeft, bottomRight
+         */
+        private fun orderPoints(points: Array<Point>): Rectangle {
+            // Sort by y-coordinate
+            val sorted = points.sortedBy { it.y }
+
+            // Top two points
+            val topPoints = sorted.take(2).sortedBy { it.x }
+            val topLeft = topPoints[0]
+            val topRight = topPoints[1]
+
+            // Bottom two points
+            val bottomPoints = sorted.takeLast(2).sortedBy { it.x }
+            val bottomLeft = bottomPoints[0]
+            val bottomRight = bottomPoints[1]
+
+            return Rectangle(topLeft, topRight, bottomLeft, bottomRight)
+        }
+
+        /**
+         * Evaluate rectangle quality (matching iOS logic)
+         */
+        fun evaluateRectangleQuality(
+            rectangle: Rectangle,
+            imageWidth: Int,
+            imageHeight: Int
+        ): RectangleQuality {
+            // Check for bad angles
+            val topYDiff = abs(rectangle.topRight.y - rectangle.topLeft.y)
+            val bottomYDiff = abs(rectangle.bottomLeft.y - rectangle.bottomRight.y)
+            val leftXDiff = abs(rectangle.topLeft.x - rectangle.bottomLeft.x)
+            val rightXDiff = abs(rectangle.topRight.x - rectangle.bottomRight.x)
+
+            if (topYDiff > 100 || bottomYDiff > 100 || leftXDiff > 100 || rightXDiff > 100) {
+                return RectangleQuality.BAD_ANGLE
+            }
+
+            // Check if rectangle is too far from edges (too small)
+            val margin = 150.0
+            if (rectangle.topLeft.y > margin ||
+                rectangle.topRight.y > margin ||
+                rectangle.bottomLeft.y < (imageHeight - margin) ||
+                rectangle.bottomRight.y < (imageHeight - margin)
+            ) {
+                return RectangleQuality.TOO_FAR
+            }
+
+            return RectangleQuality.GOOD
+        }
+
+        /**
+         * Calculate perimeter of rectangle
+         */
+        fun calculatePerimeter(rectangle: Rectangle): Double {
+            val width = distance(rectangle.topLeft, rectangle.topRight)
+            val height = distance(rectangle.topLeft, rectangle.bottomLeft)
+            return 2 * (width + height)
+        }
+
+        /**
+         * Calculate distance between two points
+         */
+        private fun distance(p1: Point, p2: Point): Double {
+            val dx = p1.x - p2.x
+            val dy = p1.y - p2.y
+            return sqrt(dx * dx + dy * dy)
+        }
+
+        /**
+         * Transform rectangle coordinates from image space to view space
+         */
+        fun transformRectangleToViewCoordinates(
+            rectangle: Rectangle,
+            imageWidth: Int,
+            imageHeight: Int,
+            viewWidth: Int,
+            viewHeight: Int
+        ): Rectangle {
+            val scaleX = viewWidth.toDouble() / imageWidth
+            val scaleY = viewHeight.toDouble() / imageHeight
+
+            return Rectangle(
+                Point(rectangle.topLeft.x * scaleX, rectangle.topLeft.y * scaleY),
+                Point(rectangle.topRight.x * scaleX, rectangle.topRight.y * scaleY),
+                Point(rectangle.bottomLeft.x * scaleX, rectangle.bottomLeft.y * scaleY),
+                Point(rectangle.bottomRight.x * scaleX, rectangle.bottomRight.y * scaleY)
+            )
+        }
+    }
+}