react-native-rectangle-doc-scanner 0.69.0 → 0.70.0

package/android/build.gradle

@@ -50,6 +50,6 @@ dependencies {
     implementation "androidx.camera:camera-camera2:1.3.1"
     implementation "androidx.camera:camera-lifecycle:1.3.1"
     implementation "androidx.camera:camera-view:1.3.1"
-    implementation "com.google.mlkit:document-scanner:16.0.0-beta3"
     implementation "org.jetbrains.kotlinx:kotlinx-coroutines-android:1.7.3"
+    implementation "org.opencv:opencv-android:4.9.0"
 }

package/android/src/main/java/com/reactnativerectangledocscanner/RNRDocScannerView.kt

@@ -1,23 +1,52 @@
 package com.reactnativerectangledocscanner
 
+import android.Manifest
 import android.content.Context
+import android.content.pm.PackageManager
+import android.graphics.Bitmap
+import android.graphics.BitmapFactory
 import android.graphics.Color
+import android.media.Image
 import android.util.AttributeSet
 import android.util.Log
+import android.util.Size as AndroidSize
 import android.widget.FrameLayout
-import androidx.camera.core.ImageAnalysis
-import androidx.camera.core.ImageCapture
+import androidx.camera.core.*
 import androidx.camera.lifecycle.ProcessCameraProvider
 import androidx.camera.view.PreviewView
+import androidx.concurrent.futures.await
 import androidx.core.content.ContextCompat
+import androidx.lifecycle.LifecycleOwner
 import com.facebook.react.bridge.Arguments
 import com.facebook.react.bridge.Promise
 import com.facebook.react.bridge.ReactContext
 import com.facebook.react.bridge.WritableMap
 import com.facebook.react.uimanager.events.RCTEventEmitter
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.Job
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.withContext
+import org.opencv.android.OpenCVLoader
+import org.opencv.core.CvType
+import org.opencv.core.Mat
+import org.opencv.core.MatOfPoint
+import org.opencv.core.MatOfPoint2f
+import org.opencv.core.Point
+import org.opencv.core.Size as MatSize
+import org.opencv.imgproc.Imgproc
+import java.io.File
+import java.nio.ByteBuffer
+import java.text.SimpleDateFormat
+import java.util.Date
+import java.util.Locale
 import java.util.concurrent.ExecutorService
 import java.util.concurrent.Executors
+import kotlin.math.abs
+import kotlin.math.hypot
+import kotlin.math.max
 
+@androidx.camera.core.ExperimentalGetImage
 class RNRDocScannerView @JvmOverloads constructor(
   context: Context,
   attrs: AttributeSet? = null,
@@ -35,10 +64,16 @@ class RNRDocScannerView @JvmOverloads constructor(
 
   private val previewView: PreviewView = PreviewView(context)
   private var cameraProvider: ProcessCameraProvider? = null
+  private var camera: Camera? = null
   private var imageCapture: ImageCapture? = null
   private var imageAnalysis: ImageAnalysis? = null
   private var cameraExecutor: ExecutorService? = null
+  private val scope = CoroutineScope(Dispatchers.Main + Job())
+
   private var currentStableCounter: Int = 0
+  private var lastQuad: QuadPoints? = null
+  private var lastFrameSize: AndroidSize? = null
+  private var capturePromise: Promise? = null
   private var captureInFlight: Boolean = false
 
   init {
@@ -47,77 +82,263 @@ class RNRDocScannerView @JvmOverloads constructor(
       previewView,
       LayoutParams(LayoutParams.MATCH_PARENT, LayoutParams.MATCH_PARENT),
     )
+
+    if (!OpenCVLoader.initDebug()) {
+      Log.w(TAG, "Failed to initialise OpenCV - detection will not run.")
+    }
+
     initializeCamera()
   }
 
   private fun initializeCamera() {
+    if (!hasCameraPermission()) {
+      Log.w(TAG, "Camera permission missing. Detection will not start.")
+      return
+    }
+
     cameraExecutor = Executors.newSingleThreadExecutor()
     val providerFuture = ProcessCameraProvider.getInstance(context)
     providerFuture.addListener(
       {
-        cameraProvider = providerFuture.get()
-        // TODO: Configure Preview + ImageAnalysis + ML Kit processing.
+        scope.launch {
+          try {
+            cameraProvider = providerFuture.await()
+            bindCameraUseCases()
+          } catch (error: Exception) {
+            Log.e(TAG, "Failed to initialise camera", error)
+          }
+        }
       },
       ContextCompat.getMainExecutor(context),
     )
   }
 
-  fun emitRectangle(rectangle: WritableMap?) {
+  private fun hasCameraPermission(): Boolean {
+    return ContextCompat.checkSelfPermission(context, Manifest.permission.CAMERA) == PackageManager.PERMISSION_GRANTED
+  }
+
+  private fun bindCameraUseCases() {
+    val provider = cameraProvider ?: return
+    val lifecycleOwner = context as? LifecycleOwner
+    if (lifecycleOwner == null) {
+      Log.w(TAG, "Context is not a LifecycleOwner; cannot bind camera use cases.")
+      return
+    }
+    provider.unbindAll()
+
+    val preview = Preview.Builder()
+      .setTargetAspectRatio(AspectRatio.RATIO_4_3)
+      .setTargetRotation(previewView.display.rotation)
+      .build()
+      .also { it.setSurfaceProvider(previewView.surfaceProvider) }
+
+    imageCapture = ImageCapture.Builder()
+      .setCaptureMode(ImageCapture.CAPTURE_MODE_MINIMIZE_LATENCY)
+      .setTargetAspectRatio(AspectRatio.RATIO_4_3)
+      .setTargetRotation(previewView.display.rotation)
+      .build()
+
+    imageAnalysis = ImageAnalysis.Builder()
+      .setTargetAspectRatio(AspectRatio.RATIO_4_3)
+      .setBackpressureStrategy(ImageAnalysis.STRATEGY_KEEP_ONLY_LATEST)
+      .setOutputImageFormat(ImageAnalysis.OUTPUT_IMAGE_FORMAT_YUV_420_888)
+      .build()
+      .also { analysis ->
+        analysis.setAnalyzer(cameraExecutor!!) { imageProxy ->
+          try {
+            processFrame(imageProxy)
+          } catch (error: Exception) {
+            Log.e(TAG, "Frame processing error", error)
+            imageProxy.close()
+          }
+        }
+      }
+
+    val selector = CameraSelector.Builder()
+      .requireLensFacing(CameraSelector.LENS_FACING_BACK)
+      .build()
+
+    camera = provider.bindToLifecycle(
+      lifecycleOwner,
+      selector,
+      preview,
+      imageCapture,
+      imageAnalysis,
+    )
+
+    updateTorchMode(enableTorch)
+  }
+
+  private fun updateTorchMode(enabled: Boolean) {
+    camera?.cameraControl?.enableTorch(enabled)
+  }
+
+  private fun processFrame(imageProxy: ImageProxy) {
+    val mediaImage = imageProxy.image
+    if (mediaImage == null) {
+      imageProxy.close()
+      return
+    }
+
+    val frameSize = AndroidSize(imageProxy.width, imageProxy.height)
+    lastFrameSize = frameSize
+
+    val mat = yuvToMat(mediaImage, imageProxy.imageInfo.rotationDegrees)
+    val detectedQuad = detectDocument(mat, frameSize)
+
+    imageProxy.close()
+
+    scope.launch {
+      emitDetectionResult(detectedQuad, frameSize)
+      if (autoCapture && detectedQuad != null && currentStableCounter >= detectionCountBeforeCapture && !captureInFlight) {
+        triggerAutoCapture()
+      }
+    }
+  }
+
+  private fun emitDetectionResult(quad: QuadPoints?, frameSize: AndroidSize) {
+    val reactContext = context as? ReactContext ?: return
     val event: WritableMap = Arguments.createMap().apply {
-      if (rectangle != null) {
-        putMap("rectangleCoordinates", rectangle)
+      if (quad != null) {
+        val quadMap = Arguments.createMap().apply {
+          putMap("topLeft", quad.topLeft.toWritable())
+          putMap("topRight", quad.topRight.toWritable())
+          putMap("bottomRight", quad.bottomRight.toWritable())
+          putMap("bottomLeft", quad.bottomLeft.toWritable())
+        }
+        putMap("rectangleCoordinates", quadMap)
         currentStableCounter = (currentStableCounter + 1).coerceAtMost(detectionCountBeforeCapture)
+        lastQuad = quad
       } else {
         putNull("rectangleCoordinates")
         currentStableCounter = 0
+        lastQuad = null
       }
       putInt("stableCounter", currentStableCounter)
-      // Frame size placeholders until analysis is wired.
-      putDouble("frameWidth", width.toDouble())
-      putDouble("frameHeight", height.toDouble())
+      putDouble("frameWidth", frameSize.width.toDouble())
+      putDouble("frameHeight", frameSize.height.toDouble())
     }
 
-    (context as? ReactContext)
-      ?.getJSModule(RCTEventEmitter::class.java)
+    reactContext
+      .getJSModule(RCTEventEmitter::class.java)
       ?.receiveEvent(id, "onRectangleDetect", event)
   }
 
-  fun emitPictureTaken(payload: WritableMap) {
-    (context as? ReactContext)
-      ?.getJSModule(RCTEventEmitter::class.java)
-      ?.receiveEvent(id, "onPictureTaken", payload)
+  private fun triggerAutoCapture() {
+    startCapture(null)
   }
 
   fun capture(promise: Promise) {
+    startCapture(promise)
+  }
+
+  private fun startCapture(promise: Promise?) {
     if (captureInFlight) {
-      promise.reject("capture_in_progress", "A capture request is already running.")
+      promise?.reject("capture_in_progress", "A capture request is already running.")
       return
     }
 
     val imageCapture = this.imageCapture
     if (imageCapture == null) {
-      promise.reject("capture_unavailable", "Image capture is not initialised yet.")
+      promise?.reject("capture_unavailable", "Image capture is not initialised yet.")
       return
     }
 
+    val outputDir = context.cacheDir
+    val photoFile = File(
+      outputDir,
+      "docscan-${SimpleDateFormat("yyyyMMdd-HHmmss-SSS", Locale.US).format(Date())}.jpg",
+    )
+
+    val outputOptions = ImageCapture.OutputFileOptions.Builder(photoFile).build()
+
     captureInFlight = true
-    // TODO: Hook into ImageCapture#takePicture and ML Kit cropping.
-    postDelayed(
-      {
-        captureInFlight = false
-        promise.reject("not_implemented", "Native capture pipeline has not been implemented.")
+    pendingPromise = promise
+
+    imageCapture.takePicture(
+      outputOptions,
+      cameraExecutor ?: Executors.newSingleThreadExecutor(),
+      object : ImageCapture.OnImageSavedCallback {
+        override fun onImageSaved(outputFileResults: ImageCapture.OutputFileResults) {
+          scope.launch {
+            handleCaptureSuccess(photoFile)
+          }
+        }
+
+        override fun onError(exception: ImageCaptureException) {
+          scope.launch {
+            handleCaptureFailure(exception)
+          }
+        }
       },
-      100,
     )
   }
 
-  fun reset() {
+  private suspend fun handleCaptureSuccess(file: File) {
+    withContext(Dispatchers.IO) {
+      try {
+        val bitmap = BitmapFactory.decodeFile(file.absolutePath)
+        val width = bitmap.width
+        val height = bitmap.height
+
+        val frameSize = lastFrameSize
+        val quadForCapture = if (lastQuad != null && frameSize != null) {
+          val scaleX = width.toDouble() / frameSize.width.toDouble()
+          val scaleY = height.toDouble() / frameSize.height.toDouble()
+          lastQuad!!.scaled(scaleX, scaleY)
+        } else {
+          null
+        }
+
+        val croppedPath = if (quadForCapture != null) {
+          cropAndSave(bitmap, quadForCapture, file.parentFile ?: context.cacheDir)
+        } else {
+          file.absolutePath
+        }
+
+        val event = Arguments.createMap().apply {
+          putString("initialImage", "file://${file.absolutePath}")
+          putString("croppedImage", "file://$croppedPath")
+          putDouble("width", width.toDouble())
+          putDouble("height", height.toDouble())
+        }
+
+       withContext(Dispatchers.Main) {
+         emitPictureTaken(event)
+         pendingPromise?.resolve(event)
+         resetAfterCapture()
+       }
+      } catch (error: Exception) {
+        bitmap.recycle()
+
+        withContext(Dispatchers.Main) {
+          handleCaptureFailure(error)
+        }
+      }
+    }
+  }
+
+  private fun handleCaptureFailure(error: Exception) {
+    pendingPromise?.reject(error)
+    resetAfterCapture()
+  }
+
+  private fun resetAfterCapture() {
+    captureInFlight = false
+    pendingPromise = null
     currentStableCounter = 0
   }
 
-  private fun updateTorchMode(enabled: Boolean) {
-    // TODO: Toggle torch once camera is integrated.
-    Log.d("RNRDocScanner", "Torch set to $enabled (not yet wired).")
+  private fun emitPictureTaken(payload: WritableMap) {
+    val reactContext = context as? ReactContext ?: return
+    reactContext
+      .getJSModule(RCTEventEmitter::class.java)
+      ?.receiveEvent(id, "onPictureTaken", payload)
+  }
+
+  fun reset() {
+    currentStableCounter = 0
+    lastQuad = null
   }
 
   override fun onDetachedFromWindow() {
@@ -126,4 +347,190 @@ class RNRDocScannerView @JvmOverloads constructor(
     cameraExecutor = null
     cameraProvider?.unbindAll()
   }
+
+  // region Detection helpers
+
+  private fun yuvToMat(image: Image, rotationDegrees: Int): Mat {
+    val bufferY = image.planes[0].buffer.toByteArray()
+    val bufferU = image.planes[1].buffer.toByteArray()
+    val bufferV = image.planes[2].buffer.toByteArray()
+
+    val yuvBytes = ByteArray(bufferY.size + bufferU.size + bufferV.size)
+    bufferY.copyInto(yuvBytes, 0)
+    bufferV.copyInto(yuvBytes, bufferY.size)
+    bufferU.copyInto(yuvBytes, bufferY.size + bufferV.size)
+
+    val yuvMat = Mat(image.height + image.height / 2, image.width, CvType.CV_8UC1)
+    yuvMat.put(0, 0, yuvBytes)
+
+    val bgrMat = Mat()
+    Imgproc.cvtColor(yuvMat, bgrMat, Imgproc.COLOR_YUV2BGR_NV21, 3)
+    yuvMat.release()
+
+    val rotatedMat = Mat()
+    when (rotationDegrees) {
+      90 -> Core.rotate(bgrMat, rotatedMat, Core.ROTATE_90_CLOCKWISE)
+      180 -> Core.rotate(bgrMat, rotatedMat, Core.ROTATE_180)
+      270 -> Core.rotate(bgrMat, rotatedMat, Core.ROTATE_90_COUNTERCLOCKWISE)
+      else -> bgrMat.copyTo(rotatedMat)
+    }
+    bgrMat.release()
+    return rotatedMat
+  }
+
+  private fun detectDocument(mat: Mat, frameSize: AndroidSize): QuadPoints? {
+    if (mat.empty()) {
+      mat.release()
+      return null
+    }
+
+    val gray = Mat()
+    Imgproc.cvtColor(mat, gray, Imgproc.COLOR_BGR2GRAY)
+
+    val blurred = Mat()
+    Imgproc.GaussianBlur(gray, blurred, MatSize(5.0, 5.0), 0.0)
+
+    val edges = Mat()
+    Imgproc.Canny(blurred, edges, 50.0, 150.0)
+
+    val contours = ArrayList<MatOfPoint>()
+    val hierarchy = Mat()
+    Imgproc.findContours(edges, contours, hierarchy, Imgproc.RETR_EXTERNAL, Imgproc.CHAIN_APPROX_SIMPLE)
+
+    var bestQuad: QuadPoints? = null
+    var maxArea = 0.0
+    val frameArea = frameSize.width * frameSize.height.toDouble()
+
+    val approxCurve = MatOfPoint2f()
+    for (contour in contours) {
+      val contour2f = MatOfPoint2f(*contour.toArray())
+      val perimeter = Imgproc.arcLength(contour2f, true)
+      Imgproc.approxPolyDP(contour2f, approxCurve, 0.02 * perimeter, true)
+
+      val points = approxCurve.toArray()
+      if (points.size != 4) {
+        contour.release()
+        contour2f.release()
+        continue
+      }
+
+      val area = abs(Imgproc.contourArea(approxCurve))
+      if (area < frameArea * 0.10 || area > frameArea * 0.95) {
+        contour.release()
+        contour2f.release()
+        continue
+      }
+
+      if (area > maxArea && Imgproc.isContourConvex(approxCurve)) {
+        val ordered = orderPoints(points)
+        bestQuad = QuadPoints(
+          topLeft = ordered[0],
+          topRight = ordered[1],
+          bottomRight = ordered[2],
+          bottomLeft = ordered[3],
+        )
+        maxArea = area
+      }
+
+      contour.release()
+      contour2f.release()
+    }
+
+    gray.release()
+    blurred.release()
+    edges.release()
+    hierarchy.release()
+    approxCurve.release()
+    mat.release()
+
+    return bestQuad
+  }
+
+  private fun orderPoints(points: Array<Point>): Array<Point> {
+    val sorted = points.sortedBy { it.x + it.y }
+    val tl = sorted.first()
+    val br = sorted.last()
+    val remaining = points.filter { it != tl && it != br }
+    val (tr, bl) =
+      if (remaining[0].x > remaining[1].x) remaining[0] to remaining[1] else remaining[1] to remaining[0]
+    return arrayOf(tl, tr, br, bl)
+  }
+
+  // endregion
+
+  private fun cropAndSave(bitmap: Bitmap, quad: QuadPoints, outputDir: File): String {
+    val srcMat = Mat()
+    org.opencv.android.Utils.bitmapToMat(bitmap, srcMat)
+
+    val ordered = quad.toArray()
+    val widthA = hypot(ordered[2].x - ordered[3].x, ordered[2].y - ordered[3].y)
+    val widthB = hypot(ordered[1].x - ordered[0].x, ordered[1].y - ordered[0].y)
+    val heightA = hypot(ordered[1].x - ordered[2].x, ordered[1].y - ordered[2].y)
+    val heightB = hypot(ordered[0].x - ordered[3].x, ordered[0].y - ordered[3].y)
+
+    val maxWidth = max(widthA, widthB).toInt().coerceAtLeast(1)
+    val maxHeight = max(heightA, heightB).toInt().coerceAtLeast(1)
+
+    val srcPoints = MatOfPoint2f(*ordered)
+    val dstPoints = MatOfPoint2f(
+      Point(0.0, 0.0),
+      Point(maxWidth - 1.0, 0.0),
+      Point(maxWidth - 1.0, maxHeight - 1.0),
+      Point(0.0, maxHeight - 1.0),
+    )
+
+    val transform = Imgproc.getPerspectiveTransform(srcPoints, dstPoints)
+    val warped = Mat(MatSize(maxWidth.toDouble(), maxHeight.toDouble()), srcMat.type())
+    Imgproc.warpPerspective(srcMat, warped, transform, warped.size())
+
+    val croppedBitmap = Bitmap.createBitmap(maxWidth, maxHeight, Bitmap.Config.ARGB_8888)
+    org.opencv.android.Utils.matToBitmap(warped, croppedBitmap)
+
+    val outputFile = File(
+      outputDir,
+      "docscan-cropped-${SimpleDateFormat("yyyyMMdd-HHmmss-SSS", Locale.US).format(Date())}.jpg",
+    )
+    outputFile.outputStream().use { stream ->
+      croppedBitmap.compress(Bitmap.CompressFormat.JPEG, quality.coerceIn(10, 100), stream)
+    }
+
+    srcMat.release()
+    warped.release()
+    transform.release()
+    srcPoints.release()
+    dstPoints.release()
+
+    return outputFile.absolutePath
+  }
+
+  private fun Point.toWritable(): WritableMap = Arguments.createMap().apply {
+    putDouble("x", x)
+    putDouble("y", y)
+  }
+
+  private fun ByteBuffer.toByteArray(): ByteArray {
+    val bytes = ByteArray(remaining())
+    get(bytes)
+    rewind()
+    return bytes
+  }
+
+  companion object {
+    private const val TAG = "RNRDocScanner"
+  }
+}
+
+data class QuadPoints(
+  val topLeft: Point,
+  val topRight: Point,
+  val bottomRight: Point,
+  val bottomLeft: Point,
+) {
+  fun toArray(): Array<Point> = arrayOf(topLeft, topRight, bottomRight, bottomLeft)
+  fun scaled(scaleX: Double, scaleY: Double): QuadPoints = QuadPoints(
+    topLeft = Point(topLeft.x * scaleX, topLeft.y * scaleY),
+    topRight = Point(topRight.x * scaleX, topRight.y * scaleY),
+    bottomRight = Point(bottomRight.x * scaleX, bottomRight.y * scaleY),
+    bottomLeft = Point(bottomLeft.x * scaleX, bottomLeft.y * scaleY),
+  )
 }

package/ios/RNRDocScannerView.swift

@@ -1,10 +1,12 @@
 import AVFoundation
+import CoreImage
 import Foundation
 import React
+import UIKit
 import Vision
 
 @objc(RNRDocScannerView)
-class RNRDocScannerView: UIView {
+class RNRDocScannerView: UIView, AVCaptureVideoDataOutputSampleBufferDelegate, AVCapturePhotoCaptureDelegate {
   @objc var detectionCountBeforeCapture: NSNumber = 8
   @objc var autoCapture: Bool = true
   @objc var enableTorch: Bool = false {
@@ -21,11 +23,18 @@ class RNRDocScannerView: UIView {
   private let session = AVCaptureSession()
   private let sessionQueue = DispatchQueue(label: "com.reactnative.rectangledocscanner.session")
   private let analysisQueue = DispatchQueue(label: "com.reactnative.rectangledocscanner.analysis")
+  private let ciContext = CIContext()
+
   private var previewLayer: AVCaptureVideoPreviewLayer?
-  private var photoOutput = AVCapturePhotoOutput()
+  private let videoOutput = AVCaptureVideoDataOutput()
+  private let photoOutput = AVCapturePhotoOutput()
 
   private var currentStableCounter: Int = 0
+  private var isProcessingFrame = false
   private var isCaptureInFlight = false
+  private var lastObservation: VNRectangleObservation?
+  private var lastFrameSize: CGSize = .zero
+  private var photoCaptureCompletion: ((Result<RNRDocScannerCaptureResult, Error>) -> Void)?
 
   override init(frame: CGRect) {
     super.init(frame: frame)
@@ -76,10 +85,19 @@ class RNRDocScannerView: UIView {
       session.addInput(videoInput)
 
       if session.canAddOutput(photoOutput) {
+        photoOutput.isHighResolutionCaptureEnabled = true
         session.addOutput(photoOutput)
       }
 
-      // TODO: Wire up AVCaptureVideoDataOutput + rectangle detection pipeline.
+      videoOutput.videoSettings = [
+        kCVPixelBufferPixelFormatTypeKey as String: kCVPixelFormatType_420YpCbCr8BiPlanarFullRange,
+      ]
+      videoOutput.alwaysDiscardsLateVideoFrames = true
+      videoOutput.setSampleBufferDelegate(self, queue: analysisQueue)
+
+      if session.canAddOutput(videoOutput) {
+        session.addOutput(videoOutput)
+      }
     }
   }
 
@@ -115,16 +133,73 @@ class RNRDocScannerView: UIView {
     return AVCaptureDevice.devices(for: .video).first(where: { $0.position == position })
   }
 
+  // MARK: - Detection
+
+  func captureOutput(_ output: AVCaptureOutput, didOutput sampleBuffer: CMSampleBuffer, from connection: AVCaptureConnection) {
+    if isProcessingFrame {
+      return
+    }
+    guard let pixelBuffer = CMSampleBufferGetImageBuffer(sampleBuffer) else {
+      return
+    }
+
+    isProcessingFrame = true
+    CVPixelBufferLockBaseAddress(pixelBuffer, .readOnly)
+    let frameSize = CGSize(width: CVPixelBufferGetWidth(pixelBuffer), height: CVPixelBufferGetHeight(pixelBuffer))
+    lastFrameSize = frameSize
+    let orientation = currentExifOrientation()
+
+    defer {
+      CVPixelBufferUnlockBaseAddress(pixelBuffer, .readOnly)
+      isProcessingFrame = false
+    }
+
+    let request = VNDetectRectanglesRequest { [weak self] request, error in
+      guard let self else { return }
+
+      if let error {
+        NSLog("[RNRDocScanner] detection error: \(error)")
+        self.lastObservation = nil
+        self.handleDetectedRectangle(nil, frameSize: frameSize)
+        return
+      }
+
+      guard let observation = (request.results as? [VNRectangleObservation])?.first else {
+        self.lastObservation = nil
+        self.handleDetectedRectangle(nil, frameSize: frameSize)
+        return
+      }
+
+      self.lastObservation = observation
+      self.handleDetectedRectangle(observation, frameSize: frameSize)
+    }
+
+    request.maximumObservations = 1
+    request.minimumConfidence = 0.6
+    request.minimumAspectRatio = 0.3
+    request.maximumAspectRatio = 1.0
+    request.minimumSize = 0.15
+
+    let handler = VNImageRequestHandler(cvPixelBuffer: pixelBuffer, orientation: orientation, options: [:])
+    do {
+      try handler.perform([request])
+    } catch {
+      NSLog("[RNRDocScanner] Failed to run Vision request: \(error)")
+      lastObservation = nil
+      handleDetectedRectangle(nil, frameSize: frameSize)
+    }
+  }
+
   func handleDetectedRectangle(_ rectangle: VNRectangleObservation?, frameSize: CGSize) {
     guard let onRectangleDetect else { return }
 
     let payload: [String: Any?]
     if let rectangle {
       let points = [
-        point(from: rectangle.topLeft, frameSize: frameSize),
-        point(from: rectangle.topRight, frameSize: frameSize),
-        point(from: rectangle.bottomRight, frameSize: frameSize),
-        point(from: rectangle.bottomLeft, frameSize: frameSize),
+        pointForOverlay(from: rectangle.topLeft, frameSize: frameSize),
+        pointForOverlay(from: rectangle.topRight, frameSize: frameSize),
+        pointForOverlay(from: rectangle.bottomRight, frameSize: frameSize),
+        pointForOverlay(from: rectangle.bottomLeft, frameSize: frameSize),
       ]
 
       currentStableCounter = min(currentStableCounter + 1, Int(truncating: detectionCountBeforeCapture))
@@ -154,10 +229,12 @@ class RNRDocScannerView: UIView {
     }
   }
 
-  private func point(from normalizedPoint: CGPoint, frameSize: CGSize) -> CGPoint {
+  private func pointForOverlay(from normalizedPoint: CGPoint, frameSize: CGSize) -> CGPoint {
     CGPoint(x: normalizedPoint.x * frameSize.width, y: (1 - normalizedPoint.y) * frameSize.height)
   }
 
+  // MARK: - Capture
+
   func capture(completion: @escaping (Result<RNRDocScannerCaptureResult, Error>) -> Void) {
     sessionQueue.async { [weak self] in
       guard let self else { return }
@@ -167,23 +244,190 @@ class RNRDocScannerView: UIView {
         return
       }
 
-      guard photoOutput.connections.isEmpty == false else {
+      guard photoOutput.connection(with: .video) != nil else {
         completion(.failure(RNRDocScannerError.captureUnavailable))
         return
       }
 
       isCaptureInFlight = true
+      photoCaptureCompletion = completion
 
-      // TODO: Implement real capture logic; emit stub callback for now.
-      DispatchQueue.main.asyncAfter(deadline: .now() + 0.1) {
-        self.isCaptureInFlight = false
-        completion(.failure(RNRDocScannerError.notImplemented))
+      let settings = AVCapturePhotoSettings(format: [AVVideoCodecKey: AVVideoCodecType.jpeg])
+      settings.isHighResolutionPhotoEnabled = photoOutput.isHighResolutionCaptureEnabled
+      if photoOutput.supportedFlashModes.contains(.on) {
+        settings.flashMode = enableTorch ? .on : .off
       }
+
+      photoOutput.capturePhoto(with: settings, delegate: self)
     }
   }
 
   func resetStability() {
     currentStableCounter = 0
+    lastObservation = nil
+  }
+
+  // MARK: - AVCapturePhotoCaptureDelegate
+
+  func photoOutput(_ output: AVCapturePhotoOutput, didFinishProcessingPhoto photo: AVCapturePhoto, error: Error?) {
+    guard let completion = photoCaptureCompletion else {
+      isCaptureInFlight = false
+      return
+    }
+
+    if let error {
+      finishCapture(result: .failure(error))
+      return
+    }
+
+    guard let data = photo.fileDataRepresentation() else {
+      finishCapture(result: .failure(RNRDocScannerError.imageCreationFailed))
+      return
+    }
+
+    let dimensions = photoDimensions(photo: photo)
+    do {
+      let original = try serializeImageData(data, suffix: "original")
+      let croppedString: String?
+
+      if let croppedData = generateCroppedImage(from: data) {
+        croppedString = try serializeImageData(croppedData, suffix: "cropped").string
+      } else {
+        croppedString = original.string
+      }
+
+      let result = RNRDocScannerCaptureResult(
+        croppedImage: croppedString,
+        originalImage: original.string,
+        width: dimensions.width,
+        height: dimensions.height
+      )
+
+      finishCapture(result: .success(result))
+    } catch {
+      finishCapture(result: .failure(error))
+    }
+  }
+
+  func photoOutput(_ output: AVCapturePhotoOutput, didFinishCaptureFor resolvedSettings: AVCaptureResolvedPhotoSettings, error: Error?) {
+    if let error, isCaptureInFlight {
+      finishCapture(result: .failure(error))
+    }
+  }
+
+  private func finishCapture(result: Result<RNRDocScannerCaptureResult, Error>) {
+    let completion = photoCaptureCompletion
+    photoCaptureCompletion = nil
+    isCaptureInFlight = false
+
+    DispatchQueue.main.async {
+      switch result {
+      case let .success(payload):
+        completion?(.success(payload))
+        self.emitPictureTaken(payload)
+      case let .failure(error):
+        completion?(.failure(error))
+      }
+    }
+  }
+
+  private func emitPictureTaken(_ result: RNRDocScannerCaptureResult) {
+    guard let onPictureTaken else { return }
+    let payload: [String: Any] = [
+      "croppedImage": result.croppedImage ?? NSNull(),
+      "initialImage": result.originalImage,
+      "width": result.width,
+      "height": result.height,
+    ]
+    onPictureTaken(payload)
+  }
+
+  // MARK: - Helpers
+
+  private func currentExifOrientation() -> CGImagePropertyOrientation {
+    switch UIDevice.current.orientation {
+    case .landscapeLeft:
+      return .up
+    case .landscapeRight:
+      return .down
+    case .portraitUpsideDown:
+      return .left
+    default:
+      return .right
+    }
+  }
+
+  private func photoDimensions(photo: AVCapturePhoto) -> CGSize {
+    if let pixelBuffer = photo.pixelBuffer {
+      return CGSize(width: CVPixelBufferGetWidth(pixelBuffer), height: CVPixelBufferGetHeight(pixelBuffer))
+    }
+
+    let width = photo.metadata[kCGImagePropertyPixelWidth as String] as? Int ?? Int(lastFrameSize.width)
+    let height = photo.metadata[kCGImagePropertyPixelHeight as String] as? Int ?? Int(lastFrameSize.height)
+    return CGSize(width: CGFloat(width), height: CGFloat(height))
+  }
+
+  private func serializeImageData(_ data: Data, suffix: String) throws -> (string: String, url: URL?) {
+    let filename = "docscan-\(UUID().uuidString)-\(suffix).jpg"
+    let url = FileManager.default.temporaryDirectory.appendingPathComponent(filename)
+    do {
+      try data.write(to: url, options: .atomic)
+    } catch {
+      throw RNRDocScannerError.fileWriteFailed
+    }
+    return (url.absoluteString, url)
+  }
+
+  private func generateCroppedImage(from data: Data) -> Data? {
+    guard let ciImage = CIImage(data: data) else {
+      return nil
+    }
+
+    var observation: VNRectangleObservation? = nil
+    let request = VNDetectRectanglesRequest { request, _ in
+      observation = (request.results as? [VNRectangleObservation])?.first
+    }
+    request.maximumObservations = 1
+    request.minimumConfidence = 0.6
+
+    let handler = VNImageRequestHandler(ciImage: ciImage, options: [:])
+    try? handler.perform([request])
+
+    guard let targetObservation = observation ?? lastObservation else {
+      return nil
+    }
+
+    let size = ciImage.extent.size
+    let topLeft = normalizedPoint(targetObservation.topLeft, in: size, flipY: false)
+    let topRight = normalizedPoint(targetObservation.topRight, in: size, flipY: false)
+    let bottomLeft = normalizedPoint(targetObservation.bottomLeft, in: size, flipY: false)
+    let bottomRight = normalizedPoint(targetObservation.bottomRight, in: size, flipY: false)
+
+    guard let filter = CIFilter(name: "CIPerspectiveCorrection") else {
+      return nil
+    }
+
+    filter.setValue(ciImage, forKey: kCIInputImageKey)
+    filter.setValue(CIVector(cgPoint: topLeft), forKey: "inputTopLeft")
+    filter.setValue(CIVector(cgPoint: topRight), forKey: "inputTopRight")
+    filter.setValue(CIVector(cgPoint: bottomLeft), forKey: "inputBottomLeft")
+    filter.setValue(CIVector(cgPoint: bottomRight), forKey: "inputBottomRight")
+
+    guard let corrected = filter.outputImage else {
+      return nil
+    }
+
+    guard let cgImage = ciContext.createCGImage(corrected, from: corrected.extent) else {
+      return nil
+    }
+
+    let cropped = UIImage(cgImage: cgImage)
+    return cropped.jpegData(compressionQuality: CGFloat(max(0.05, min(1.0, quality.doubleValue / 100.0))))
+  }
+
+  private func normalizedPoint(_ point: CGPoint, in size: CGSize, flipY: Bool) -> CGPoint {
+    let yValue = flipY ? (1 - point.y) : point.y
+    return CGPoint(x: point.x * size.width, y: yValue * size.height)
   }
 }
 
@@ -197,7 +441,8 @@ struct RNRDocScannerCaptureResult {
 enum RNRDocScannerError: Error {
   case captureInProgress
   case captureUnavailable
-  case notImplemented
+  case imageCreationFailed
+  case fileWriteFailed
   case viewNotFound
 
   var code: String {
@@ -206,8 +451,10 @@ enum RNRDocScannerError: Error {
       return "capture_in_progress"
     case .captureUnavailable:
       return "capture_unavailable"
-    case .notImplemented:
-      return "not_implemented"
+    case .imageCreationFailed:
+      return "image_creation_failed"
+    case .fileWriteFailed:
+      return "file_write_failed"
     case .viewNotFound:
       return "view_not_found"
     }
@@ -219,8 +466,10 @@ enum RNRDocScannerError: Error {
       return "A capture request is already in flight."
     case .captureUnavailable:
       return "Photo output is not configured yet."
-    case .notImplemented:
-      return "Native capture is not implemented yet."
+    case .imageCreationFailed:
+      return "Unable to create image data from capture."
+    case .fileWriteFailed:
+      return "Failed to persist captured image to disk."
     case .viewNotFound:
       return "Unable to locate the native DocScanner view."
     }

package/ios/RNRDocScannerViewManager.swift

@@ -22,7 +22,7 @@ class RNRDocScannerViewManager: RCTViewManager {
         switch result {
         case let .success(payload):
           resolve([
-            "croppedImage": payload.croppedImage as Any,
+            "croppedImage": payload.croppedImage ?? NSNull(),
             "initialImage": payload.originalImage,
             "width": payload.width,
             "height": payload.height,

package/package.json

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