@trustchex/react-native-sdk 1.374.0 → 1.381.0

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

@@ -16,7 +16,7 @@ class OpenCVModule(reactContext: ReactApplicationContext) : ReactContextBaseJava
 
     companion object {
         private var opencvInitialized = false
-        private const val HOLOGRAM_NON_ZERO_THRESHOLD = 600
+        private const val HOLOGRAM_NON_ZERO_THRESHOLD_PERCENT = 0.01 // 1% of total pixels - balanced detection
     }
 
     init {
@@ -68,56 +68,89 @@ class OpenCVModule(reactContext: ReactApplicationContext) : ReactContextBaseJava
                 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)
+            // Use original images directly (no alignment needed - HSV detects color changes regardless)
+            val imagesToProcess = mats
+
+            // Calculate adaptive threshold based on image size (0.5% of total pixels - strict hologram detection)
+            val imagePixels = imagesToProcess[0].rows() * imagesToProcess[0].cols()
+            val adaptiveThreshold = maxOf(1, (imagePixels * HOLOGRAM_NON_ZERO_THRESHOLD_PERCENT).toInt())
+
+            // HSV filtering for holographic rainbow spectrum (balanced - detect holograms, exclude white glares)
+            // Saturation 60+ = colorful holographic shifts, not desaturated white glares
+            // Value capped at 220 = exclude very bright white glares
+            // Range 1: Cyan-green holographic spectrum
+            val lowerBound1 = Scalar(40.0, 60.0, 60.0)
+            val upperBound1 = Scalar(75.0, 255.0, 220.0)
+            // Range 2: Blue-violet holographic spectrum
+            val lowerBound2 = Scalar(110.0, 60.0, 60.0)
+            val upperBound2 = Scalar(150.0, 255.0, 220.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)
+            // Compare consecutive frames AND frames with gaps to catch both fast and slow color shifts
+            for (i in 0 until imagesToProcess.size - 1) {
+                // Gap 1: Consecutive frames (fast changes)
+                val diff1 = Mat()
+                Core.absdiff(imagesToProcess[i], imagesToProcess[i + 1], diff1)
 
-                val hsv = Mat()
-                Imgproc.cvtColor(diff, hsv, Imgproc.COLOR_RGB2HSV)
+                val hsv1 = Mat()
+                Imgproc.cvtColor(diff1, hsv1, Imgproc.COLOR_RGB2HSV)
 
-                // Apply multi-range HSV filtering
+                val mask1a = Mat()
+                val mask1b = Mat()
                 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
-                    }
+                Core.inRange(hsv1, lowerBound1, upperBound1, mask1a)
+                Core.inRange(hsv1, lowerBound2, upperBound2, mask1b)
+                Core.bitwise_or(mask1a, mask1b, mask1)
+                mask1a.release()
+                mask1b.release()
+
+                val maskNonZero1 = Core.countNonZero(mask1)
+
+                if (maskNonZero1 > adaptiveThreshold) {
+                    diffs.add(mask1)
+                    brightestImages.add(imagesToProcess[i].clone())
+                    brightestImages.add(imagesToProcess[i + 1].clone())
                 } else {
-                    mask.release()
+                    mask1.release()
                 }
 
-                diff.release()
-                hsv.release()
+                diff1.release()
+                hsv1.release()
+
+                // Gap 3: Every third frame (slower color shifts) - only for frames that allow it
+                if (i + 3 < imagesToProcess.size) {
+                    val diff3 = Mat()
+                    Core.absdiff(imagesToProcess[i], imagesToProcess[i + 3], diff3)
+
+                    val hsv3 = Mat()
+                    Imgproc.cvtColor(diff3, hsv3, Imgproc.COLOR_RGB2HSV)
+
+                    val mask3a = Mat()
+                    val mask3b = Mat()
+                    val mask3 = Mat()
+                    Core.inRange(hsv3, lowerBound1, upperBound1, mask3a)
+                    Core.inRange(hsv3, lowerBound2, upperBound2, mask3b)
+                    Core.bitwise_or(mask3a, mask3b, mask3)
+                    mask3a.release()
+                    mask3b.release()
+
+                    val maskNonZero3 = Core.countNonZero(mask3)
+
+                    if (maskNonZero3 > adaptiveThreshold) {
+                        diffs.add(mask3)
+                        brightestImages.add(imagesToProcess[i].clone())
+                        brightestImages.add(imagesToProcess[i + 3].clone())
+                    } else {
+                        mask3.release()
+                    }
+
+                    diff3.release()
+                    hsv3.release()
+                }
             }
 
-            mats.forEach { it.release() }
-            mats.clear()
+            imagesToProcess.forEach { it.release() }
 
             if (diffs.isEmpty()) {
                 brightestImages.forEach { it.release() }
@@ -208,6 +241,413 @@ class OpenCVModule(reactContext: ReactApplicationContext) : ReactContextBaseJava
         }.start()
     }
 
+    /**
+     * Find common region across all frames and crop to it.
+     * Uses feature matching to find translation offsets, then calculates overlapping region.
+     * Returns cropped images without warping artifacts.
+     */
+    private fun findAndCropToCommonRegion(images: List<Mat>): MutableList<Mat> {
+        if (images.size < 2) return mutableListOf()
+
+        try {
+            val reference = images[0]
+            val refGray = Mat()
+            Imgproc.cvtColor(reference, refGray, Imgproc.COLOR_RGB2GRAY)
+
+            // Track translation offsets for each image relative to reference
+            val offsets = mutableListOf<Point>()
+            offsets.add(Point(0.0, 0.0)) // Reference has no offset
+
+            // Find translation offset for each image
+            for (i in 1 until images.size) {
+                val offset = findTranslationOffset(images[i], reference, refGray)
+                offsets.add(offset)
+            }
+
+            refGray.release()
+
+            // Calculate common region (intersection of all translated frames)
+            var commonX = 0.0
+            var commonY = 0.0
+            var commonWidth = reference.cols().toDouble()
+            var commonHeight = reference.rows().toDouble()
+
+            for (offset in offsets) {
+                val dx = offset.x
+                val dy = offset.y
+
+                // Update common region boundaries
+                commonX = maxOf(commonX, -dx)
+                commonY = maxOf(commonY, -dy)
+                commonWidth = minOf(commonWidth, reference.cols() - dx)
+                commonHeight = minOf(commonHeight, reference.rows() - dy)
+            }
+
+            // Ensure valid region
+            if (commonWidth <= commonX || commonHeight <= commonY ||
+                commonWidth - commonX < 50 || commonHeight - commonY < 50) {
+                // Region too small or invalid, return empty
+                return mutableListOf()
+            }
+
+            val cropRect = Rect(
+                commonX.toInt(),
+                commonY.toInt(),
+                (commonWidth - commonX).toInt(),
+                (commonHeight - commonY).toInt()
+            )
+
+            // Crop all images to common region
+            val croppedImages = mutableListOf<Mat>()
+            for (i in images.indices) {
+                val offset = offsets[i]
+                val adjustedRect = Rect(
+                    (cropRect.x + offset.x).toInt(),
+                    (cropRect.y + offset.y).toInt(),
+                    cropRect.width,
+                    cropRect.height
+                )
+
+                // Ensure rect is within image bounds
+                if (adjustedRect.x >= 0 && adjustedRect.y >= 0 &&
+                    adjustedRect.x + adjustedRect.width <= images[i].cols() &&
+                    adjustedRect.y + adjustedRect.height <= images[i].rows()) {
+                    val cropped = Mat(images[i], adjustedRect).clone()
+                    croppedImages.add(cropped)
+                } else {
+                    // Fallback: use original
+                    croppedImages.add(images[i].clone())
+                }
+            }
+
+            return croppedImages
+        } catch (e: Exception) {
+            return mutableListOf()
+        }
+    }
+
+    /**
+     * Find translation offset between image and reference using feature matching.
+     * Returns Point(dx, dy) representing pixel shift.
+     */
+    private fun findTranslationOffset(image: Mat, reference: Mat, refGray: Mat): Point {
+        try {
+            val imgGray = Mat()
+            Imgproc.cvtColor(image, imgGray, Imgproc.COLOR_RGB2GRAY)
+
+            // Detect ORB keypoints
+            val orb = org.opencv.features2d.ORB.create(300)
+            val kpRef = MatOfKeyPoint()
+            val descRef = Mat()
+            val kpImg = MatOfKeyPoint()
+            val descImg = Mat()
+
+            orb.detectAndCompute(refGray, Mat(), kpRef, descRef)
+            orb.detectAndCompute(imgGray, Mat(), kpImg, descImg)
+
+            imgGray.release()
+
+            if (descRef.empty() || descImg.empty()) {
+                kpRef.release()
+                descRef.release()
+                kpImg.release()
+                descImg.release()
+                return Point(0.0, 0.0)
+            }
+
+            // Match features
+            val matcher = org.opencv.features2d.DescriptorMatcher.create(
+                org.opencv.features2d.DescriptorMatcher.BRUTEFORCE_HAMMING
+            )
+            val matchesMat = MatOfDMatch()
+            matcher.match(descImg, descRef, matchesMat)
+            val matches = matchesMat.toList()
+
+            if (matches.isEmpty()) {
+                kpRef.release()
+                descRef.release()
+                kpImg.release()
+                descImg.release()
+                matchesMat.release()
+                return Point(0.0, 0.0)
+            }
+
+            // Filter good matches
+            val minDistance = matches.minOf { it.distance }
+            val goodMatches = matches.filter { it.distance < 3 * minDistance && it.distance < 40.0 }
+
+            if (goodMatches.size < 5) {
+                kpRef.release()
+                descRef.release()
+                kpImg.release()
+                descImg.release()
+                matchesMat.release()
+                return Point(0.0, 0.0)
+            }
+
+            // Calculate median translation offset
+            val imgKeypoints = kpImg.toArray()
+            val refKeypoints = kpRef.toArray()
+            val dxList = mutableListOf<Double>()
+            val dyList = mutableListOf<Double>()
+
+            for (match in goodMatches) {
+                val imgPt = imgKeypoints[match.queryIdx].pt
+                val refPt = refKeypoints[match.trainIdx].pt
+                dxList.add(refPt.x - imgPt.x)
+                dyList.add(refPt.y - imgPt.y)
+            }
+
+            kpRef.release()
+            descRef.release()
+            kpImg.release()
+            descImg.release()
+            matchesMat.release()
+
+            // Use median to be robust against outliers
+            dxList.sort()
+            dyList.sort()
+            val medianDx = dxList[dxList.size / 2]
+            val medianDy = dyList[dyList.size / 2]
+
+            return Point(medianDx, medianDy)
+        } catch (e: Exception) {
+            return Point(0.0, 0.0)
+        }
+    }
+
+    /**
+     * Align faces in multiple images to improve hologram detection accuracy.
+     * Uses feature matching (ORB) to find homography and warp images to reference frame.
+     *
+     * @param base64Images Array of base64 JPEG face images
+     * @param promise Returns array of aligned base64 images or original if alignment fails
+     */
+    @ReactMethod
+    fun alignFaces(base64Images: ReadableArray, promise: Promise) {
+        Thread {
+            try {
+                if (!opencvInitialized || base64Images.size() < 2) {
+                    promise.resolve(Arguments.fromList(base64Images.toArrayList()))
+                    return@Thread
+                }
+
+                val mats = mutableListOf<Mat>()
+                for (i in 0 until base64Images.size()) {
+                    val b64 = base64Images.getString(i) ?: continue
+                    val mat = base64ToMat(b64) ?: continue
+                    mats.add(mat)
+                }
+
+                if (mats.size < 2) {
+                    mats.forEach { it.release() }
+                    promise.resolve(Arguments.fromList(base64Images.toArrayList()))
+                    return@Thread
+                }
+
+                // Use first image as reference
+                val reference = mats[0]
+                val alignedImages = WritableNativeArray()
+                
+                // Add reference image as-is
+                val refBase64 = matToBase64(reference)
+                if (refBase64 != null) {
+                    alignedImages.pushString(refBase64)
+                }
+
+                // Convert reference to grayscale for feature detection
+                val refGray = Mat()
+                Imgproc.cvtColor(reference, refGray, Imgproc.COLOR_RGB2GRAY)
+
+                // Align remaining images to reference
+                for (i in 1 until mats.size) {
+                    val current = mats[i]
+                    val aligned = alignImageToReference(current, reference, refGray)
+                    
+                    if (aligned != null) {
+                        val alignedBase64 = matToBase64(aligned)
+                        if (alignedBase64 != null) {
+                            alignedImages.pushString(alignedBase64)
+                        }
+                        aligned.release()
+                    } else {
+                        // Fallback to original if alignment fails
+                        val originalBase64 = matToBase64(current)
+                        if (originalBase64 != null) {
+                            alignedImages.pushString(originalBase64)
+                        }
+                    }
+                }
+
+                refGray.release()
+                mats.forEach { it.release() }
+
+                promise.resolve(alignedImages)
+            } catch (e: Exception) {
+                promise.reject("ALIGN_FACES_ERROR", e.message)
+            }
+        }.start()
+    }
+
+    /**
+     * Align a single image to reference using feature matching.
+     * Returns aligned Mat or null if alignment fails.
+     */
+    private fun alignImageToReference(image: Mat, reference: Mat, refGray: Mat): Mat? {
+        try {
+            val imgGray = Mat()
+            Imgproc.cvtColor(image, imgGray, Imgproc.COLOR_RGB2GRAY)
+
+            // Detect ORB keypoints and descriptors
+            val orb = org.opencv.features2d.ORB.create(500)
+            val kpRef = MatOfKeyPoint()
+            val descRef = Mat()
+            val kpImg = MatOfKeyPoint()
+            val descImg = Mat()
+
+            orb.detectAndCompute(refGray, Mat(), kpRef, descRef)
+            orb.detectAndCompute(imgGray, Mat(), kpImg, descImg)
+
+            if (descRef.empty() || descImg.empty()) {
+                imgGray.release()
+                kpRef.release()
+                descRef.release()
+                kpImg.release()
+                descImg.release()
+                return null
+            }
+
+            // Match features using BFMatcher
+            val matcher = org.opencv.features2d.DescriptorMatcher.create(
+                org.opencv.features2d.DescriptorMatcher.BRUTEFORCE_HAMMING
+            )
+            val matchesMat = MatOfDMatch()
+            matcher.match(descImg, descRef, matchesMat)
+            val matches = matchesMat.toList()
+
+            // Filter good matches (distance < 3 * min_distance)
+            if (matches.isEmpty()) {
+                imgGray.release()
+                kpRef.release()
+                descRef.release()
+                kpImg.release()
+                descImg.release()
+                matchesMat.release()
+                return null
+            }
+
+            val minDistance = matches.minOf { it.distance }
+            val goodMatches = matches.filter { it.distance < 3 * minDistance && it.distance < 50.0 }
+
+            if (goodMatches.size < 10) {
+                imgGray.release()
+                kpRef.release()
+                descRef.release()
+                kpImg.release()
+                descImg.release()
+                matchesMat.release()
+                return null
+            }
+
+            // Extract matched points
+            val srcPoints = mutableListOf<Point>()
+            val dstPoints = mutableListOf<Point>()
+            val imgKeypoints = kpImg.toArray()
+            val refKeypoints = kpRef.toArray()
+
+            for (match in goodMatches) {
+                srcPoints.add(imgKeypoints[match.queryIdx].pt)
+                dstPoints.add(refKeypoints[match.trainIdx].pt)
+            }
+
+            // Find homography
+            val srcMat = MatOfPoint2f()
+            val dstMat = MatOfPoint2f()
+            srcMat.fromList(srcPoints)
+            dstMat.fromList(dstPoints)
+
+            val homography = org.opencv.calib3d.Calib3d.findHomography(
+                srcMat, dstMat, org.opencv.calib3d.Calib3d.RANSAC, 5.0
+            )
+
+            if (homography.empty()) {
+                imgGray.release()
+                kpRef.release()
+                descRef.release()
+                kpImg.release()
+                descImg.release()
+                matchesMat.release()
+                srcMat.release()
+                dstMat.release()
+                homography.release()
+                return null
+            }
+
+            // Warp image to align with reference
+            // Use BORDER_REPLICATE to avoid black/white spaces in aligned images
+            val aligned = Mat()
+            Imgproc.warpPerspective(
+                image, aligned, homography,
+                reference.size(),
+                Imgproc.INTER_LINEAR,
+                Core.BORDER_REPLICATE
+            )
+
+            imgGray.release()
+            kpRef.release()
+            descRef.release()
+            kpImg.release()
+            descImg.release()
+            matchesMat.release()
+            srcMat.release()
+            dstMat.release()
+            homography.release()
+
+            return aligned
+        } catch (e: Exception) {
+            return null
+        }
+    }
+
+    /**
+     * Align all images to first image as reference.
+     * Returns list of aligned Mats or empty list if alignment fails.
+     */
+    private fun alignFacesToReference(images: List<Mat>): MutableList<Mat> {
+        val alignedImages = mutableListOf<Mat>()
+        
+        if (images.size < 2) return alignedImages
+        
+        try {
+            val reference = images[0]
+            
+            // Add reference image as-is
+            alignedImages.add(reference.clone())
+            
+            // Convert reference to grayscale for feature detection
+            val refGray = Mat()
+            Imgproc.cvtColor(reference, refGray, Imgproc.COLOR_RGB2GRAY)
+            
+            // Align remaining images to reference
+            for (i in 1 until images.size) {
+                val aligned = alignImageToReference(images[i], reference, refGray)
+                if (aligned != null) {
+                    alignedImages.add(aligned)
+                } else {
+                    // Fallback to original if alignment fails
+                    alignedImages.add(images[i].clone())
+                }
+            }
+            
+            refGray.release()
+            
+            return if (alignedImages.size >= 2) alignedImages else mutableListOf()
+        } catch (e: Exception) {
+            alignedImages.forEach { it.release() }
+            return mutableListOf()
+        }
+    }
+
     /**
      * Compare two images for similarity using thresholded absdiff.
      * Mirrors the JS areImagesSimilar logic:
@@ -273,7 +713,7 @@ class OpenCVModule(reactContext: ReactApplicationContext) : ReactContextBaseJava
      * @param promise Returns array of base64 cropped face images (240x320)
      */
     @ReactMethod
-    fun cropFaceImages(base64Image: String, faceBounds: ReadableArray, imageWidth: Int, imageHeight: Int, promise: Promise) {
+    fun cropFaceImages(base64Image: String, faceBounds: ReadableArray, imageWidth: Int, imageHeight: Int, widerRightPadding: Boolean, promise: Promise) {
         try {
             if (!opencvInitialized) {
                 promise.resolve(Arguments.createArray())
@@ -304,15 +744,17 @@ class OpenCVModule(reactContext: ReactApplicationContext) : ReactContextBaseJava
 
                 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()
+                // Padding based on use case: hologram needs wider area on right/top/bottom, regular face is symmetric
+                val padLeft = (w * 0.25).toInt()
+                val padRight = if (widerRightPadding) (w * 0.60).toInt() else (w * 0.25).toInt()
+                val padTop = if (widerRightPadding) (h * 0.50).toInt() else (h * 0.25).toInt()
+                val padBottom = if (widerRightPadding) (h * 0.50).toInt() else (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 cropX = (x - padLeft).coerceAtLeast(0)
+                val cropY = (y - padTop).coerceAtLeast(0)
+                val cropRight = (x + w + padRight).coerceAtMost(mat.cols())
+                val cropBottom = (y + h + padBottom).coerceAtMost(mat.rows())
                 val cropW = cropRight - cropX
                 val cropH = cropBottom - cropY
 
@@ -593,189 +1035,6 @@ class OpenCVModule(reactContext: ReactApplicationContext) : ReactContextBaseJava
         }
     }
 
-    /**
-     * 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()) {
-                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
-            }
-
-            if (filteredElements.isEmpty()) {
-                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
-
-            // Calculate raw bounding box from elements
-            val elementsWidth = maxX - minX
-            val elementsHeight = maxY - minY
-
-            // Validate minimum size (elements should occupy at least 5% of frame)
-            val minArea = (imageWidth * imageHeight * 0.05).toInt()
-            if (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
-
-            // Validate aspect ratio is reasonable for a document (very lenient: 1.0 - 2.5)
-            val aspectRatio = cardWidth.toDouble() / cardHeight.toDouble().coerceAtLeast(1.0)
-
-            if (aspectRatio < 1.0 || aspectRatio > 2.5) {
-                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)
@@ -804,96 +1063,172 @@ class OpenCVModule(reactContext: ReactApplicationContext) : ReactContextBaseJava
     }
 
     /**
-     * Preprocess image for better OCR text recognition using OpenCV.
-     * Steps:
-     * 1. Convert to grayscale
-     * 2. Bilateral filter for noise reduction while preserving edges
-     * 3. CLAHE for adaptive contrast enhancement
-     * 4. Sharpen the image to enhance text edges
-     * 5. Optional: Adaptive threshold for high-contrast text extraction
+     * Compare face shape/geometry between two face images.
+     * Analyzes aspect ratio, edges, and structural similarity.
+     * Device-side validation before backend FaceNet.
      *
-     * @param base64Image Base64 encoded input image
-     * @param applyThresholding Whether to apply adaptive thresholding (default: false)
-     * @param promise Returns preprocessed image as base64
+     * @param base64Image1 Primary face image
+     * @param base64Image2 Secondary face image
+     * @param promise Returns { shapeScore: 0-1, aspectRatioMatch: boolean }
      */
     @ReactMethod
-    fun preprocessImageForOCR(base64Image: String, applyThresholding: Boolean, promise: Promise) {
+    fun compareFaceShape(base64Image1: String, base64Image2: String, promise: Promise) {
         try {
             if (!opencvInitialized) {
                 promise.reject("OPENCV_ERROR", "OpenCV not initialized")
                 return
             }
 
-            val mat = base64ToMat(base64Image)
-            if (mat == null) {
-                promise.reject("DECODE_ERROR", "Failed to decode image")
+            val mat1 = base64ToMat(base64Image1)
+            val mat2 = base64ToMat(base64Image2)
+
+            if (mat1 == null || mat2 == null) {
+                mat1?.release()
+                mat2?.release()
+                promise.reject("DECODE_ERROR", "Failed to decode face images")
                 return
             }
 
-            // 1. Convert to grayscale
-            val gray = Mat()
-            Imgproc.cvtColor(mat, gray, Imgproc.COLOR_RGB2GRAY)
-            mat.release()
-
-            // 2. Apply bilateral filter for noise reduction while preserving edges
-            // This is better than Gaussian blur for text as it keeps edges sharp
-            val filtered = Mat()
-            Imgproc.bilateralFilter(gray, filtered, 9, 75.0, 75.0)
-            gray.release()
+            // Normalize sizes for comparison
+            val size = Size(200.0, 200.0)
+            val resized1 = Mat()
+            val resized2 = Mat()
+            Imgproc.resize(mat1, resized1, size)
+            Imgproc.resize(mat2, resized2, size)
+
+            // Calculate aspect ratios
+            val aspectRatio1 = mat1.width().toDouble() / mat1.height().toDouble()
+            val aspectRatio2 = mat2.width().toDouble() / mat2.height().toDouble()
+            val aspectRatioDiff = kotlin.math.abs(aspectRatio1 - aspectRatio2)
+            val aspectRatioMatch = aspectRatioDiff < 0.15 // 15% tolerance
+
+            // Edge detection for structural comparison
+            val gray1 = Mat()
+            val gray2 = Mat()
+            Imgproc.cvtColor(resized1, gray1, Imgproc.COLOR_BGR2GRAY)
+            Imgproc.cvtColor(resized2, gray2, Imgproc.COLOR_BGR2GRAY)
+
+            val edges1 = Mat()
+            val edges2 = Mat()
+            // Canny edge detection
+            Imgproc.Canny(gray1, edges1, 50.0, 150.0)
+            Imgproc.Canny(gray2, edges2, 50.0, 150.0)
+
+            // Compare edge structures
+            val diff = Mat()
+            Core.absdiff(edges1, edges2, diff)
+            val diffCount = Core.countNonZero(diff)
+            val totalPixels = edges1.rows() * edges1.cols()
+            val matchPixels = totalPixels - diffCount
+            val shapeScore = matchPixels.toDouble() / totalPixels.toDouble()
 
-            // 3. Apply CLAHE (Contrast Limited Adaptive Histogram Equalization)
-            // This enhances local contrast, making text stand out better
-            val clahe = Imgproc.createCLAHE(2.0, Size(8.0, 8.0))
-            val enhanced = Mat()
-            clahe.apply(filtered, enhanced)
-            filtered.release()
-
-            // 4. Sharpen the image to enhance text edges
-            // Use unsharp masking: original + (original - blurred) * amount
-            val blurred = Mat()
-            Imgproc.GaussianBlur(enhanced, blurred, Size(0.0, 0.0), 3.0)
-            val sharpened = Mat()
-            Core.addWeighted(enhanced, 1.5, blurred, -0.5, 0.0, sharpened)
-            blurred.release()
-            enhanced.release()
-
-            // 5. Optional: Apply adaptive thresholding for binary text extraction
-            val result = if (applyThresholding) {
-                val thresholded = Mat()
-                // Use Gaussian adaptive threshold - better for varying illumination
-                Imgproc.adaptiveThreshold(
-                    sharpened,
-                    thresholded,
-                    255.0,
-                    Imgproc.ADAPTIVE_THRESH_GAUSSIAN_C,
-                    Imgproc.THRESH_BINARY,
-                    11,
-                    2.0
-                )
-                sharpened.release()
+            // Cleanup
+            mat1.release()
+            mat2.release()
+            resized1.release()
+            resized2.release()
+            gray1.release()
+            gray2.release()
+            edges1.release()
+            edges2.release()
+            diff.release()
 
-                // Apply morphological operations to clean up noise
-                val kernel = Imgproc.getStructuringElement(Imgproc.MORPH_RECT, Size(2.0, 2.0))
-                val cleaned = Mat()
-                Imgproc.morphologyEx(thresholded, cleaned, Imgproc.MORPH_CLOSE, kernel)
-                thresholded.release()
-                kernel.release()
+            val result = Arguments.createMap()
+            result.putDouble("shapeScore", shapeScore)
+            result.putBoolean("aspectRatioMatch", aspectRatioMatch)
+            result.putDouble("aspectRatioDiff", aspectRatioDiff)
+            promise.resolve(result)
+        } catch (e: Exception) {
+            promise.reject("FACE_SHAPE_ERROR", e.message)
+        }
+    }
 
-                cleaned
-            } else {
-                sharpened
+    /**
+     * Compare visual similarity between two face images using SSIM-like approach.
+     * Better than simple pixel difference for different lighting/angles.
+     * Device-side validation before backend FaceNet.
+     *
+     * @param base64Image1 Primary face image
+     * @param base64Image2 Secondary face image
+     * @param promise Returns { similarity: 0-1 }
+     */
+    @ReactMethod
+    fun compareFaceVisualSimilarity(base64Image1: String, base64Image2: String, promise: Promise) {
+        try {
+            if (!opencvInitialized) {
+                promise.reject("OPENCV_ERROR", "OpenCV not initialized")
+                return
             }
 
-            val resultBase64 = matToBase64(result)
-            result.release()
+            val mat1 = base64ToMat(base64Image1)
+            val mat2 = base64ToMat(base64Image2)
 
-            if (resultBase64 != null) {
-                promise.resolve(resultBase64)
-            } else {
-                promise.reject("ENCODE_ERROR", "Failed to encode result")
+            if (mat1 == null || mat2 == null) {
+                mat1?.release()
+                mat2?.release()
+                promise.reject("DECODE_ERROR", "Failed to decode face images")
+                return
             }
+
+            // Normalize sizes
+            val size = Size(200.0, 200.0)
+            val resized1 = Mat()
+            val resized2 = Mat()
+            Imgproc.resize(mat1, resized1, size)
+            Imgproc.resize(mat2, resized2, size)
+
+            // Convert to grayscale and equalize histogram for better comparison
+            val gray1 = Mat()
+            val gray2 = Mat()
+            Imgproc.cvtColor(resized1, gray1, Imgproc.COLOR_BGR2GRAY)
+            Imgproc.cvtColor(resized2, gray2, Imgproc.COLOR_BGR2GRAY)
+            Imgproc.equalizeHist(gray1, gray1)
+            Imgproc.equalizeHist(gray2, gray2)
+
+            // Compute mean and standard deviation for both images
+            val mean1 = MatOfDouble()
+            val stdDev1 = MatOfDouble()
+            val mean2 = MatOfDouble()
+            val stdDev2 = MatOfDouble()
+            Core.meanStdDev(gray1, mean1, stdDev1)
+            Core.meanStdDev(gray2, mean2, stdDev2)
+
+            // Compute correlation coefficient (simplified SSIM approach)
+            val normalizedGray1 = Mat()
+            val normalizedGray2 = Mat()
+            gray1.convertTo(normalizedGray1, CvType.CV_64F)
+            gray2.convertTo(normalizedGray2, CvType.CV_64F)
+
+            // Calculate correlation
+            val product = Mat()
+            Core.multiply(normalizedGray1, normalizedGray2, product)
+            val sumScalar = Core.sumElems(product)
+            val totalPixels = gray1.rows().toDouble() * gray1.cols().toDouble()
+            val correlation = sumScalar.`val`[0] / totalPixels
+
+            // Normalize to 0-1 range (simplified similarity score)
+            val similarity = kotlin.math.max(0.0, kotlin.math.min(1.0, correlation / 65536.0))
+
+            // Cleanup
+            mat1.release()
+            mat2.release()
+            resized1.release()
+            resized2.release()
+            gray1.release()
+            gray2.release()
+            mean1.release()
+            stdDev1.release()
+            mean2.release()
+            stdDev2.release()
+            normalizedGray1.release()
+            normalizedGray2.release()
+            product.release()
+
+            val result = Arguments.createMap()
+            result.putDouble("similarity", similarity)
+            promise.resolve(result)
         } catch (e: Exception) {
-            promise.reject("OCR_PREPROCESS_ERROR", e.message)
+            promise.reject("FACE_SIMILARITY_ERROR", e.message)
         }
     }
 }