@trustchex/react-native-sdk 1.355.1 → 1.357.0

package/android/src/main/java/com/trustchex/reactnativesdk/opencv/OpenCVModule.kt

@@ -0,0 +1,818 @@
+package com.trustchex.reactnativesdk.opencv
+
+import android.graphics.Bitmap
+import android.graphics.BitmapFactory
+import android.util.Base64
+import com.facebook.react.bridge.*
+import org.opencv.android.OpenCVLoader
+import org.opencv.android.Utils
+import org.opencv.core.*
+import org.opencv.imgproc.Imgproc
+import java.io.ByteArrayOutputStream
+
+class OpenCVModule(reactContext: ReactApplicationContext) : ReactContextBaseJavaModule(reactContext) {
+
+    override fun getName() = "OpenCVModule"
+
+    companion object {
+        private var opencvInitialized = false
+        private const val HOLOGRAM_NON_ZERO_THRESHOLD = 600
+    }
+
+    init {
+        if (!opencvInitialized) {
+            opencvInitialized = OpenCVLoader.initLocal()
+        }
+    }
+
+    /**
+     * Detect hologram from a sequence of face images captured while torch is toggling.
+     * Mirrors the JS detectHologram logic:
+     * 1. Compute absdiff between consecutive frames
+     * 2. Convert to HSV, inRange filter for holographic colors
+     * 3. Blend significant diffs
+     * 4. Adaptive threshold on combined mask
+     * 5. Return hologram overlay + mask if non-zero count exceeds threshold
+     *
+     * @param base64Images Array of base64 JPEG face images
+     * @param threshold Non-zero pixel count threshold (default 3500)
+     * @param promise Returns { hologramImage, hologramMask } or null
+     */
+    @ReactMethod
+    fun detectHologram(base64Images: ReadableArray, threshold: Int, promise: Promise) {
+        // Run on background thread to avoid blocking the main/JS thread (matching iOS)
+        Thread {
+        try {
+            if (!opencvInitialized) {
+                promise.reject("OPENCV_ERROR", "OpenCV not initialized")
+                return@Thread
+            }
+
+            val imageCount = base64Images.size()
+            if (imageCount < 2) {
+                promise.resolve(null)
+                return@Thread
+            }
+
+            // Decode all images to Mat
+            val mats = mutableListOf<Mat>()
+            for (i in 0 until imageCount) {
+                val b64 = base64Images.getString(i) ?: continue
+                val mat = base64ToMat(b64) ?: continue
+                mats.add(mat)
+            }
+
+            if (mats.size < 2) {
+                mats.forEach { it.release() }
+                promise.resolve(null)
+                return@Thread
+            }
+
+            // Multi-range HSV filtering for holographic colors
+            // Range 1: Cyan-green holographic reflections
+            val lowerBound1 = Scalar(35.0, 80.0, 80.0)
+            val upperBound1 = Scalar(85.0, 255.0, 255.0)
+            // Range 2: Blue-violet holographic reflections
+            val lowerBound2 = Scalar(100.0, 80.0, 80.0)
+            val upperBound2 = Scalar(160.0, 255.0, 255.0)
+            val diffs = mutableListOf<Mat>()
+            val brightestImages = mutableListOf<Mat>()
+
+            for (i in 0 until mats.size - 1) {
+                val diff = Mat()
+                Core.absdiff(mats[i], mats[i + 1], diff)
+
+                val hsv = Mat()
+                Imgproc.cvtColor(diff, hsv, Imgproc.COLOR_RGB2HSV)
+
+                // Apply multi-range HSV filtering
+                val mask1 = Mat()
+                val mask2 = Mat()
+                val mask = Mat()
+                Core.inRange(hsv, lowerBound1, upperBound1, mask1)
+                Core.inRange(hsv, lowerBound2, upperBound2, mask2)
+                Core.bitwise_or(mask1, mask2, mask)
+                mask1.release()
+                mask2.release()
+
+                val maskNonZero = Core.countNonZero(mask)
+
+                if (maskNonZero > HOLOGRAM_NON_ZERO_THRESHOLD) {
+                    diffs.add(mask)
+                    brightestImages.add(mats[i].clone())
+                    brightestImages.add(mats[i + 1].clone())
+
+                    // Early termination: if first pair has very strong signal, skip rest
+                    if (i == 0 && maskNonZero > HOLOGRAM_NON_ZERO_THRESHOLD * 4) {
+                        diff.release()
+                        hsv.release()
+                        break
+                    }
+                } else {
+                    mask.release()
+                }
+
+                diff.release()
+                hsv.release()
+            }
+
+            mats.forEach { it.release() }
+            mats.clear()
+
+            if (diffs.isEmpty()) {
+                brightestImages.forEach { it.release() }
+                promise.resolve(null)
+                return@Thread
+            }
+
+            // Combine all difference masks
+            val hologramMask = diffs[0].clone()
+
+            for (i in 1 until diffs.size) {
+                Core.bitwise_or(hologramMask, diffs[i], hologramMask)
+            }
+
+            diffs.forEach { it.release() }
+
+            // Apply morphological operations to clean up the mask
+            val kernel = Imgproc.getStructuringElement(Imgproc.MORPH_ELLIPSE, org.opencv.core.Size(3.0, 3.0))
+            Imgproc.morphologyEx(hologramMask, hologramMask, Imgproc.MORPH_CLOSE, kernel)
+            Imgproc.morphologyEx(hologramMask, hologramMask, Imgproc.MORPH_OPEN, kernel)
+            kernel.release()
+
+            // Check if significant hologram detected
+            val count = Core.countNonZero(hologramMask)
+
+            if (count < threshold) {
+                hologramMask.release()
+                brightestImages.forEach { it.release() }
+                promise.resolve(null)
+                return@Thread
+            }
+
+            // Find the best image that shows the most hologram features
+            // Score each image based on how much hologram variation it shows in the mask regions
+            var bestImage = brightestImages[0]
+            var maxHologramScore = 0.0
+
+            for (img in brightestImages) {
+                // Calculate hologram visibility score by measuring color variation in mask regions
+                val maskedRegion = Mat()
+                img.copyTo(maskedRegion, hologramMask)
+
+                // Convert to HSV to measure saturation (hologram has high saturation)
+                val hsv = Mat()
+                Imgproc.cvtColor(maskedRegion, hsv, Imgproc.COLOR_RGB2HSV)
+
+                val channels = mutableListOf<Mat>()
+                Core.split(hsv, channels)
+
+                // Score based on average saturation in hologram regions
+                val saturationMean = Core.mean(channels[1], hologramMask)
+                val score = saturationMean.`val`[0]
+
+                channels.forEach { it.release() }
+                hsv.release()
+                maskedRegion.release()
+
+                if (score > maxHologramScore) {
+                    maxHologramScore = score
+                    bestImage = img
+                }
+            }
+
+            // Use the best image that shows the most prominent hologram - show full document
+            val hologram = Mat()
+            bestImage.copyTo(hologram)
+
+            brightestImages.forEach { it.release() }
+
+            // Convert results to base64
+            val hologramBase64 = matToBase64(hologram)
+            val maskBase64 = matToBase64(hologramMask)
+
+            hologram.release()
+            hologramMask.release()
+
+            if (hologramBase64 != null && maskBase64 != null) {
+                val resultMap = Arguments.createMap()
+                resultMap.putString("hologramImage", hologramBase64)
+                resultMap.putString("hologramMask", maskBase64)
+                promise.resolve(resultMap)
+            } else {
+                promise.resolve(null)
+            }
+        } catch (e: Exception) {
+            promise.reject("HOLOGRAM_ERROR", e.message)
+        }
+        }.start()
+    }
+
+    /**
+     * Compare two images for similarity using thresholded absdiff.
+     * Mirrors the JS areImagesSimilar logic:
+     * 1. Grayscale → GaussianBlur → Otsu threshold on both
+     * 2. absdiff between thresholded images
+     * 3. Count non-zero pixels
+     *
+     * @param base64Image1 First image (base64 JPEG)
+     * @param base64Image2 Second image (base64 JPEG)
+     * @param threshold Non-zero pixel count below which images are "similar" (default 15000)
+     * @param promise Returns boolean
+     */
+    @ReactMethod
+    fun areImagesSimilar(base64Image1: String, base64Image2: String, threshold: Int, promise: Promise) {
+        try {
+            if (!opencvInitialized) {
+                promise.resolve(false)
+                return
+            }
+
+            val mat1 = base64ToMat(base64Image1)
+            val mat2 = base64ToMat(base64Image2)
+
+            if (mat1 == null || mat2 == null) {
+                mat1?.release()
+                mat2?.release()
+                promise.resolve(false)
+                return
+            }
+
+            val thresh1 = applyThreshold(mat1)
+            val thresh2 = applyThreshold(mat2)
+
+            // Resize to match if different sizes
+            if (thresh1.size() != thresh2.size()) {
+                Imgproc.resize(thresh2, thresh2, thresh1.size())
+            }
+
+            val diff = Mat()
+            Core.absdiff(thresh1, thresh2, diff)
+            val count = Core.countNonZero(diff)
+
+            mat1.release()
+            mat2.release()
+            thresh1.release()
+            thresh2.release()
+            diff.release()
+
+            promise.resolve(count < threshold)
+        } catch (e: Exception) {
+            promise.resolve(false)
+        }
+    }
+
+    /**
+     * Crop face images from a full frame using face bounds from ML Kit.
+     * Returns array of base64 face images sorted by x-position (left to right).
+     *
+     * @param base64Image Full frame as base64 JPEG
+     * @param faceBounds ReadableArray of { x, y, width, height } face bounds
+     * @param imageWidth Full frame width
+     * @param imageHeight Full frame height
+     * @param promise Returns array of base64 cropped face images (240x320)
+     */
+    @ReactMethod
+    fun cropFaceImages(base64Image: String, faceBounds: ReadableArray, imageWidth: Int, imageHeight: Int, promise: Promise) {
+        try {
+            if (!opencvInitialized) {
+                promise.resolve(Arguments.createArray())
+                return
+            }
+
+            val mat = base64ToMat(base64Image)
+            if (mat == null) {
+                promise.resolve(Arguments.createArray())
+                return
+            }
+
+            // Collect bounds and sort by x position (left to right)
+            val boundsWithIndex = mutableListOf<Pair<Int, ReadableMap>>()
+            for (i in 0 until faceBounds.size()) {
+                val bounds = faceBounds.getMap(i) ?: continue
+                boundsWithIndex.add(Pair(i, bounds))
+            }
+            boundsWithIndex.sortBy { it.second.getDouble("x").toInt() }
+
+            val result = Arguments.createArray()
+
+            for ((_, bounds) in boundsWithIndex) {
+                val x = bounds.getDouble("x").toInt()
+                val y = bounds.getDouble("y").toInt()
+                val w = bounds.getDouble("width").toInt()
+                val h = bounds.getDouble("height").toInt()
+
+                if (w <= 0 || h <= 0) continue
+
+                // Add 25% padding around the face bounding box
+                val padX = (w * 0.25).toInt()
+                val padY = (h * 0.25).toInt()
+
+                // Face bounds from ML Kit are in portrait coordinates (matching the rotated JPEG)
+                val cropX = (x - padX).coerceAtLeast(0)
+                val cropY = (y - padY).coerceAtLeast(0)
+                val cropRight = (x + w + padX).coerceAtMost(mat.cols())
+                val cropBottom = (y + h + padY).coerceAtMost(mat.rows())
+                val cropW = cropRight - cropX
+                val cropH = cropBottom - cropY
+
+                if (cropW <= 0 || cropH <= 0) continue
+
+                val roi = Rect(cropX, cropY, cropW, cropH)
+                val cropped = Mat(mat, roi)
+
+                // Resize to standard 240x320
+                val resized = Mat()
+                Imgproc.resize(cropped, resized, Size(240.0, 320.0))
+
+                // Add face without blur check
+                val faceBase64 = matToBase64(resized)
+                if (faceBase64 != null) {
+                    result.pushString(faceBase64)
+                }
+
+                cropped.release()
+                resized.release()
+            }
+
+            mat.release()
+            promise.resolve(result)
+        } catch (e: Exception) {
+            promise.resolve(Arguments.createArray())
+        }
+    }
+
+    private fun applyThreshold(src: Mat): Mat {
+        val gray = Mat()
+        if (src.channels() > 1) {
+            Imgproc.cvtColor(src, gray, Imgproc.COLOR_RGB2GRAY)
+        } else {
+            src.copyTo(gray)
+        }
+        val ksize = Size(5.0, 5.0)
+        Imgproc.GaussianBlur(gray, gray, ksize, 0.0)
+        Imgproc.threshold(gray, gray, 0.0, 255.0, Imgproc.THRESH_BINARY + Imgproc.THRESH_OTSU)
+        return gray
+    }
+
+    /**
+     * Calculate average brightness of the full image.
+     * @param base64Image Base64 JPEG image
+     * @param promise Returns average brightness value (0-255)
+     */
+    @ReactMethod
+    fun getAverageBrightness(base64Image: String, promise: Promise) {
+        try {
+            val mat = base64ToMat(base64Image)
+            if (mat == null) {
+                promise.resolve(0.0)
+                return
+            }
+            val gray = Mat()
+            Imgproc.cvtColor(mat, gray, Imgproc.COLOR_RGB2GRAY)
+            val mean = Core.mean(gray)
+            mat.release()
+            gray.release()
+            promise.resolve(mean.`val`[0])
+        } catch (e: Exception) {
+            promise.resolve(0.0)
+        }
+    }
+
+    /**
+     * Check average brightness of a circular region within the image.
+     * @param base64Image Base64 JPEG image
+     * @param minX Region origin X
+     * @param minY Region origin Y
+     * @param width Region width
+     * @param height Region height
+     * @param threshold Brightness threshold
+     * @param promise Returns true if average brightness in circular region exceeds threshold
+     */
+    @ReactMethod
+    fun isCircularRegionBright(base64Image: String, minX: Int, minY: Int, width: Int, height: Int, threshold: Double, promise: Promise) {
+        try {
+            val mat = base64ToMat(base64Image)
+            if (mat == null) {
+                promise.resolve(false)
+                return
+            }
+            val gray = Mat()
+            Imgproc.cvtColor(mat, gray, Imgproc.COLOR_RGB2GRAY)
+
+            // Create circular mask
+            val mask = Mat.zeros(gray.rows(), gray.cols(), CvType.CV_8U)
+            val centerX = minX + width / 2
+            val centerY = minY + height / 2
+            val radius = Math.min(width, height) / 2
+            Imgproc.circle(mask, Point(centerX.toDouble(), centerY.toDouble()), radius, Scalar(255.0), -1)
+
+            val mean = Core.mean(gray, mask)
+            mat.release()
+            gray.release()
+            mask.release()
+            promise.resolve(mean.`val`[0] > threshold)
+        } catch (e: Exception) {
+            promise.resolve(false)
+        }
+    }
+
+    /**
+     * Check average brightness of a rectangular region within the image.
+     * @param base64Image Base64 JPEG image
+     * @param minX Region origin X
+     * @param minY Region origin Y
+     * @param width Region width
+     * @param height Region height
+     * @param threshold Brightness threshold
+     * @param promise Returns true if average brightness in rectangular region exceeds threshold
+     */
+    @ReactMethod
+    fun isRectangularRegionBright(base64Image: String, minX: Int, minY: Int, width: Int, height: Int, threshold: Double, promise: Promise) {
+        try {
+            val mat = base64ToMat(base64Image)
+            if (mat == null) {
+                promise.resolve(false)
+                return
+            }
+            val gray = Mat()
+            Imgproc.cvtColor(mat, gray, Imgproc.COLOR_RGB2GRAY)
+
+            // Validate region bounds
+            val x = Math.max(0, minX)
+            val y = Math.max(0, minY)
+            val w = Math.min(width, gray.cols() - x)
+            val h = Math.min(height, gray.rows() - y)
+
+            if (w <= 0 || h <= 0) {
+                mat.release()
+                gray.release()
+                promise.resolve(false)
+                return
+            }
+
+            // Extract ROI (Region of Interest)
+            val roi = org.opencv.core.Rect(x, y, w, h)
+            val regionMat = Mat(gray, roi)
+
+            // Calculate mean brightness within the region
+            val mean = Core.mean(regionMat)
+            
+            mat.release()
+            gray.release()
+            regionMat.release()
+            
+            promise.resolve(mean.`val`[0] > threshold)
+        } catch (e: Exception) {
+            promise.resolve(false)
+        }
+    }
+
+    /**
+     * Check if an image is blurry using Laplacian variance.
+     * @param base64Image Base64 JPEG image
+     * @param threshold Variance below this = blurry (default 10)
+     * @param promise Returns true if image is blurry
+     */
+    @ReactMethod
+    fun checkBlurry(base64Image: String, threshold: Double, promise: Promise) {
+        try {
+            val mat = base64ToMat(base64Image)
+            if (mat == null) {
+                promise.resolve(false)
+                return
+            }
+            val gray = Mat()
+            Imgproc.cvtColor(mat, gray, Imgproc.COLOR_RGB2GRAY)
+
+            val laplacian = Mat()
+            Imgproc.Laplacian(gray, laplacian, CvType.CV_64F)
+
+            val mean = MatOfDouble()
+            val stdDev = MatOfDouble()
+            Core.meanStdDev(laplacian, mean, stdDev)
+
+            val variance = if (stdDev.rows() > 0) {
+                val std = stdDev.get(0, 0)[0]
+                std * std
+            } else 0.0
+
+            mat.release()
+            gray.release()
+            laplacian.release()
+            mean.release()
+            stdDev.release()
+
+            promise.resolve(variance < threshold)
+        } catch (e: Exception) {
+            promise.resolve(false)
+        }
+    }
+
+    /**
+     * Check if a specific region of an image is blurry using Laplacian variance.
+     * This is useful for checking blur only in the area of interest (e.g., center region)
+     * while ignoring background blur from depth-of-field effects.
+     * 
+     * @param base64Image Base64 JPEG image
+     * @param centerXPercent Center X position as percentage (0.0-1.0)
+     * @param centerYPercent Center Y position as percentage (0.0-1.0)
+     * @param widthPercent Region width as percentage (0.0-1.0)
+     * @param heightPercent Region height as percentage (0.0-1.0)
+     * @param threshold Variance below this = blurry (default 100)
+     * @param promise Returns true if region is blurry
+     */
+    @ReactMethod
+    fun checkBlurryInRegion(
+        base64Image: String,
+        centerXPercent: Double,
+        centerYPercent: Double,
+        widthPercent: Double,
+        heightPercent: Double,
+        threshold: Double,
+        promise: Promise
+    ) {
+        try {
+            val mat = base64ToMat(base64Image)
+            if (mat == null) {
+                promise.resolve(false)
+                return
+            }
+
+            val imgWidth = mat.cols()
+            val imgHeight = mat.rows()
+
+            // Calculate region bounds
+            val regionWidth = (imgWidth * widthPercent).toInt().coerceAtLeast(1)
+            val regionHeight = (imgHeight * heightPercent).toInt().coerceAtLeast(1)
+            val regionX = ((imgWidth * centerXPercent) - regionWidth / 2).toInt().coerceIn(0, imgWidth - regionWidth)
+            val regionY = ((imgHeight * centerYPercent) - regionHeight / 2).toInt().coerceIn(0, imgHeight - regionHeight)
+
+            // Extract region of interest
+            val roi = Rect(regionX, regionY, regionWidth, regionHeight)
+            val regionMat = Mat(mat, roi)
+
+            val gray = Mat()
+            Imgproc.cvtColor(regionMat, gray, Imgproc.COLOR_RGB2GRAY)
+
+            val laplacian = Mat()
+            Imgproc.Laplacian(gray, laplacian, CvType.CV_64F)
+
+            val mean = MatOfDouble()
+            val stdDev = MatOfDouble()
+            Core.meanStdDev(laplacian, mean, stdDev)
+
+            val variance = if (stdDev.rows() > 0) {
+                val std = stdDev.get(0, 0)[0]
+                std * std
+            } else 0.0
+
+            mat.release()
+            regionMat.release()
+            gray.release()
+            laplacian.release()
+            mean.release()
+            stdDev.release()
+
+            promise.resolve(variance < threshold)
+        } catch (e: Exception) {
+            promise.resolve(false)
+        }
+    }
+
+    private fun base64ToMat(base64: String): Mat? {
+        return try {
+            val bytes = Base64.decode(base64, Base64.NO_WRAP)
+            val bitmap = BitmapFactory.decodeByteArray(bytes, 0, bytes.size) ?: return null
+            val mat = Mat()
+            Utils.bitmapToMat(bitmap, mat)
+            bitmap.recycle()
+            mat
+        } catch (e: Exception) {
+            null
+        }
+    }
+
+    /**
+     * Detect ID card boundaries based on text blocks and face positions.
+     * Creates a bounding rectangle that encompasses all detected elements.
+     *
+     * @param base64Image Base64 JPEG image
+     * @param textBlocks Array of detected text blocks with bounding boxes
+     * @param faces Array of detected faces with bounding boxes
+     * @param imageWidth Width of the image
+     * @param imageHeight Height of the image
+     * @param promise Returns card bounds as { x, y, width, height, corners: [{x, y}, ...] } or null
+     */
+    @ReactMethod
+    fun detectCardBounds(
+        base64Image: String,
+        textBlocks: ReadableArray,
+        faces: ReadableArray,
+        imageWidth: Int,
+        imageHeight: Int,
+        promise: Promise
+    ) {
+        try {
+            // Collect all element bounds for clustering
+            val allElements = mutableListOf<Rect>()
+
+            // Process text blocks
+            for (i in 0 until textBlocks.size()) {
+                val block = textBlocks.getMap(i) ?: continue
+                val frame = block.getMap("blockFrame") ?: continue
+
+                val x = frame.getInt("x")
+                val y = frame.getInt("y")
+                val width = frame.getInt("width")
+                val height = frame.getInt("height")
+
+                allElements.add(Rect(x, y, width, height))
+            }
+
+            // Process faces
+            for (i in 0 until faces.size()) {
+                val face = faces.getMap(i) ?: continue
+                val bounds = face.getMap("bounds") ?: continue
+
+                val x = bounds.getInt("x")
+                val y = bounds.getInt("y")
+                val width = bounds.getInt("width")
+                val height = bounds.getInt("height")
+
+                allElements.add(Rect(x, y, width, height))
+            }
+
+            if (allElements.isEmpty()) {
+                android.util.Log.d("OpenCVModule", "No elements detected for card bounds")
+                promise.resolve(null)
+                return
+            }
+
+            // Calculate the centroid of all elements
+            var centerX = 0
+            var centerY = 0
+            for (rect in allElements) {
+                val rectRight = rect.x + rect.width
+                val rectBottom = rect.y + rect.height
+                centerX += (rect.x + rectRight) / 2
+                centerY += (rect.y + rectBottom) / 2
+            }
+            centerX /= allElements.size
+            centerY /= allElements.size
+
+            // Calculate distances from centroid and filter outliers
+            val distances = allElements.map { rect ->
+                val rectRight = rect.x + rect.width
+                val rectBottom = rect.y + rect.height
+                val elemCenterX = (rect.x + rectRight) / 2
+                val elemCenterY = (rect.y + rectBottom) / 2
+                val dx = elemCenterX - centerX
+                val dy = elemCenterY - centerY
+                Math.sqrt((dx * dx + dy * dy).toDouble())
+            }
+
+            // Calculate median distance
+            val sortedDistances = distances.sorted()
+            val medianDistance = sortedDistances[sortedDistances.size / 2]
+
+            // Filter out elements that are more than 2x the median distance from center
+            // This removes outliers that are far from the main cluster
+            val threshold = medianDistance * 2.0
+            val filteredElements = allElements.filterIndexed { index, _ ->
+                distances[index] <= threshold
+            }
+
+            android.util.Log.d("OpenCVModule", "Filtered ${allElements.size - filteredElements.size} outlier elements (${allElements.size} -> ${filteredElements.size})")
+
+            if (filteredElements.isEmpty()) {
+                android.util.Log.d("OpenCVModule", "No elements after filtering outliers")
+                promise.resolve(null)
+                return
+            }
+
+            // Now calculate bounds from filtered elements
+            var minX = imageWidth
+            var minY = imageHeight
+            var maxX = 0
+            var maxY = 0
+
+            for (rect in filteredElements) {
+                val rectRight = rect.x + rect.width
+                val rectBottom = rect.y + rect.height
+                minX = Math.min(minX, rect.x)
+                minY = Math.min(minY, rect.y)
+                maxX = Math.max(maxX, rectRight)
+                maxY = Math.max(maxY, rectBottom)
+            }
+
+            val elementCount = filteredElements.size
+
+            android.util.Log.d("OpenCVModule", "Detected elements: $elementCount, bounds: ($minX, $minY) to ($maxX, $maxY)")
+
+            // Calculate raw bounding box from elements
+            val elementsWidth = maxX - minX
+            val elementsHeight = maxY - minY
+
+            android.util.Log.d("OpenCVModule", "Elements size: ${elementsWidth}x${elementsHeight}, frame: ${imageWidth}x${imageHeight}")
+
+            // Validate minimum size (elements should occupy at least 5% of frame)
+            val minArea = (imageWidth * imageHeight * 0.05).toInt()
+            if (elementsWidth * elementsHeight < minArea) {
+                android.util.Log.d("OpenCVModule", "Elements too small: ${elementsWidth * elementsHeight} < $minArea")
+                promise.resolve(null)
+                return
+            }
+
+            // Add minimal padding (5% on all sides) to create tight frame
+            val paddingX = (elementsWidth * 0.05).toInt()
+            val paddingY = (elementsHeight * 0.05).toInt()
+
+            // Calculate card bounds with padding, clamped to image boundaries
+            val cardX = Math.max(0, minX - paddingX)
+            val cardY = Math.max(0, minY - paddingY)
+            val cardRight = Math.min(imageWidth, maxX + paddingX)
+            val cardBottom = Math.min(imageHeight, maxY + paddingY)
+            val cardWidth = cardRight - cardX
+            val cardHeight = cardBottom - cardY
+
+            android.util.Log.d("OpenCVModule", "Card bounds: ($cardX, $cardY) ${cardWidth}x${cardHeight}")
+
+            // Validate aspect ratio is reasonable for a document (very lenient: 1.0 - 2.5)
+            val aspectRatio = cardWidth.toDouble() / cardHeight.toDouble().coerceAtLeast(1.0)
+            android.util.Log.d("OpenCVModule", "Card aspect ratio: $aspectRatio")
+
+            if (aspectRatio < 1.0 || aspectRatio > 2.5) {
+                android.util.Log.d("OpenCVModule", "Aspect ratio out of range: $aspectRatio")
+                promise.resolve(null)
+                return
+            }
+
+            // Create corner points (rectangular bounds)
+            val corners = WritableNativeArray()
+
+            // Top-left
+            val tl = WritableNativeMap()
+            tl.putDouble("x", cardX.toDouble())
+            tl.putDouble("y", cardY.toDouble())
+            corners.pushMap(tl)
+
+            // Top-right
+            val tr = WritableNativeMap()
+            tr.putDouble("x", (cardX + cardWidth).toDouble())
+            tr.putDouble("y", cardY.toDouble())
+            corners.pushMap(tr)
+
+            // Bottom-right
+            val br = WritableNativeMap()
+            br.putDouble("x", (cardX + cardWidth).toDouble())
+            br.putDouble("y", (cardY + cardHeight).toDouble())
+            corners.pushMap(br)
+
+            // Bottom-left
+            val bl = WritableNativeMap()
+            bl.putDouble("x", cardX.toDouble())
+            bl.putDouble("y", (cardY + cardHeight).toDouble())
+            corners.pushMap(bl)
+
+            val result = WritableNativeMap()
+            result.putInt("x", cardX)
+            result.putInt("y", cardY)
+            result.putInt("width", cardWidth)
+            result.putInt("height", cardHeight)
+            result.putArray("corners", corners)
+            result.putDouble("angle", 0.0)  // Rectangular alignment
+
+            promise.resolve(result)
+        } catch (e: Exception) {
+            promise.resolve(null)
+        }
+    }
+
+    private fun matToBase64(mat: Mat): String? {
+        return try {
+            val bitmap = Bitmap.createBitmap(mat.cols(), mat.rows(), Bitmap.Config.ARGB_8888)
+            // Convert single-channel to 3-channel for bitmap conversion
+            val colorMat = if (mat.channels() == 1) {
+                val rgb = Mat()
+                Imgproc.cvtColor(mat, rgb, Imgproc.COLOR_GRAY2RGBA)
+                rgb
+            } else if (mat.channels() == 3) {
+                val rgba = Mat()
+                Imgproc.cvtColor(mat, rgba, Imgproc.COLOR_RGB2RGBA)
+                rgba
+            } else {
+                mat
+            }
+            Utils.matToBitmap(colorMat, bitmap)
+            if (colorMat !== mat) colorMat.release()
+
+            val stream = ByteArrayOutputStream()
+            bitmap.compress(Bitmap.CompressFormat.JPEG, 80, stream)
+            bitmap.recycle()
+            Base64.encodeToString(stream.toByteArray(), Base64.NO_WRAP)
+        } catch (e: Exception) {
+            null
+        }
+    }
+}