@trustchex/react-native-sdk 1.374.0 → 1.409.0

package/ios/OpenCV/OpenCVModule.mm

@@ -92,6 +92,7 @@ RCT_EXPORT_METHOD(cropFaceImages:(NSString *)base64Image
                   faceBounds:(NSArray *)faceBounds
                   imageWidth:(NSInteger)imageWidth
                   imageHeight:(NSInteger)imageHeight
+                  widerRightPadding:(BOOL)widerRightPadding
                   resolver:(RCTPromiseResolveBlock)resolve
                   rejecter:(RCTPromiseRejectBlock)reject) {
     @try {
@@ -122,13 +123,15 @@ RCT_EXPORT_METHOD(cropFaceImages:(NSString *)base64Image
             int width = [bounds[@"width"] intValue];
             int height = [bounds[@"height"] intValue];
 
-            // Add 25% padding (matching Android)
-            int padX = (int)(width * 0.25);
-            int padY = (int)(height * 0.25);
-            x = MAX(0, x - padX);
-            y = MAX(0, y - padY);
-            width = MIN(mat.cols - x, width + 2 * padX);
-            height = MIN(mat.rows - y, height + 2 * padY);
+            // Padding based on use case: hologram needs wider area on right/top/bottom, regular face is symmetric
+            int padLeft = (int)(width * 0.25);
+            int padRight = widerRightPadding ? (int)(width * 0.60) : (int)(width * 0.25);
+            int padTop = widerRightPadding ? (int)(height * 0.50) : (int)(height * 0.25);
+            int padBottom = widerRightPadding ? (int)(height * 0.50) : (int)(height * 0.25);
+            x = MAX(0, x - padLeft);
+            y = MAX(0, y - padTop);
+            width = MIN(mat.cols - x, width + padLeft + padRight);
+            height = MIN(mat.rows - y, height + padTop + padBottom);
 
             if (x >= 0 && y >= 0 && x + width <= mat.cols && y + height <= mat.rows && width > 0 && height > 0) {
                 cv::Rect roi(x, y, width, height);
@@ -216,6 +219,265 @@ RCT_EXPORT_METHOD(areImagesSimilar:(NSString *)base64Image1
     cv::threshold(gray, dst, 0, 255, cv::THRESH_BINARY + cv::THRESH_OTSU);
 }
 
+// Helper: Find translation offset between image and reference using feature matching
+- (cv::Point2d)findTranslationOffset:(cv::Mat)image reference:(cv::Mat)reference refGray:(cv::Mat)refGray {
+    if (image.empty() || reference.empty() || refGray.empty()) {
+        return cv::Point2d(0, 0);
+    }
+    
+    @try {
+        cv::Mat imgGray;
+        cv::cvtColor(image, imgGray, cv::COLOR_RGB2GRAY);
+        
+        // Detect ORB keypoints
+        cv::Ptr<cv::ORB> orb = cv::ORB::create(300);
+        std::vector<cv::KeyPoint> kpRef, kpImg;
+        cv::Mat descRef, descImg;
+        
+        orb->detectAndCompute(refGray, cv::noArray(), kpRef, descRef);
+        orb->detectAndCompute(imgGray, cv::noArray(), kpImg, descImg);
+        
+        if (descRef.empty() || descImg.empty()) {
+            return cv::Point2d(0, 0);
+        }
+        
+        // Match features
+        cv::Ptr<cv::DescriptorMatcher> matcher = cv::DescriptorMatcher::create(cv::DescriptorMatcher::BRUTEFORCE_HAMMING);
+        std::vector<cv::DMatch> matches;
+        matcher->match(descImg, descRef, matches);
+        
+        if (matches.empty()) {
+            return cv::Point2d(0, 0);
+        }
+        
+        // Filter good matches
+        double minDistance = matches[0].distance;
+        for (const auto& m : matches) {
+            if (m.distance < minDistance) minDistance = m.distance;
+        }
+        
+        std::vector<cv::DMatch> goodMatches;
+        for (const auto& m : matches) {
+            if (m.distance < 3 * minDistance && m.distance < 40.0) {
+                goodMatches.push_back(m);
+            }
+        }
+        
+        if (goodMatches.size() < 5) {
+            return cv::Point2d(0, 0);
+        }
+        
+        // Calculate median translation offset
+        std::vector<double> dxList, dyList;
+        for (const auto& m : goodMatches) {
+            cv::Point2f imgPt = kpImg[m.queryIdx].pt;
+            cv::Point2f refPt = kpRef[m.trainIdx].pt;
+            dxList.push_back(refPt.x - imgPt.x);
+            dyList.push_back(refPt.y - imgPt.y);
+        }
+        
+        // Use median to be robust against outliers
+        std::sort(dxList.begin(), dxList.end());
+        std::sort(dyList.begin(), dyList.end());
+        double medianDx = dxList[dxList.size() / 2];
+        double medianDy = dyList[dyList.size() / 2];
+        
+        return cv::Point2d(medianDx, medianDy);
+    } @catch (NSException *exception) {
+        return cv::Point2d(0, 0);
+    }
+}
+
+// Helper: Find common region and crop all images to it (no warping, just translation)
+- (std::vector<cv::Mat>)findAndCropToCommonRegion:(std::vector<cv::Mat>)images {
+    std::vector<cv::Mat> result;
+    
+    if (images.size() < 2) {
+        return result;
+    }
+    
+    @try {
+        cv::Mat reference = images[0];
+        cv::Mat refGray;
+        cv::cvtColor(reference, refGray, cv::COLOR_RGB2GRAY);
+        
+        // Track translation offsets for each image relative to reference
+        std::vector<cv::Point2d> offsets;
+        offsets.push_back(cv::Point2d(0, 0)); // Reference has no offset
+        
+        // Find translation offset for each image
+        for (size_t i = 1; i < images.size(); i++) {
+            cv::Point2d offset = [self findTranslationOffset:images[i] reference:reference refGray:refGray];
+            offsets.push_back(offset);
+        }
+        
+        // Calculate common region (intersection of all translated frames)
+        double commonX = 0.0;
+        double commonY = 0.0;
+        double commonWidth = reference.cols;
+        double commonHeight = reference.rows;
+        
+        for (const auto& offset : offsets) {
+            double dx = offset.x;
+            double dy = offset.y;
+            
+            commonX = std::max(commonX, -dx);
+            commonY = std::max(commonY, -dy);
+            commonWidth = std::min(commonWidth, (double)reference.cols - dx);
+            commonHeight = std::min(commonHeight, (double)reference.rows - dy);
+        }
+        
+        // Ensure valid region
+        if (commonWidth <= commonX || commonHeight <= commonY ||
+            commonWidth - commonX < 50 || commonHeight - commonY < 50) {
+            return result;
+        }
+        
+        cv::Rect cropRect(
+            (int)commonX,
+            (int)commonY,
+            (int)(commonWidth - commonX),
+            (int)(commonHeight - commonY)
+        );
+        
+        // Crop all images to common region
+        for (size_t i = 0; i < images.size(); i++) {
+            cv::Point2d offset = offsets[i];
+            cv::Rect adjustedRect(
+                (int)(cropRect.x + offset.x),
+                (int)(cropRect.y + offset.y),
+                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) {
+                cv::Mat cropped = images[i](adjustedRect).clone();
+                result.push_back(cropped);
+            } else {
+                // Fallback: use original
+                result.push_back(images[i].clone());
+            }
+        }
+        
+        return result;
+    } @catch (NSException *exception) {
+        return result;
+    }
+}
+
+// Helper: Align single image to reference using feature matching
+- (cv::Mat)alignImageToReference:(cv::Mat)image reference:(cv::Mat)reference refGray:(cv::Mat)refGray {
+    if (image.empty() || reference.empty() || refGray.empty()) {
+        return cv::Mat();
+    }
+    
+    @try {
+        cv::Mat imgGray;
+        cv::cvtColor(image, imgGray, cv::COLOR_RGB2GRAY);
+        
+        // Detect ORB keypoints and descriptors
+        cv::Ptr<cv::ORB> orb = cv::ORB::create(500);
+        std::vector<cv::KeyPoint> kpRef, kpImg;
+        cv::Mat descRef, descImg;
+        
+        orb->detectAndCompute(refGray, cv::noArray(), kpRef, descRef);
+        orb->detectAndCompute(imgGray, cv::noArray(), kpImg, descImg);
+        
+        if (descRef.empty() || descImg.empty()) {
+            return cv::Mat();
+        }
+        
+        // Match features using BFMatcher
+        cv::Ptr<cv::DescriptorMatcher> matcher = cv::DescriptorMatcher::create(cv::DescriptorMatcher::BRUTEFORCE_HAMMING);
+        std::vector<cv::DMatch> matches;
+        matcher->match(descImg, descRef, matches);
+        
+        if (matches.empty()) {
+            return cv::Mat();
+        }
+        
+        // Filter good matches
+        double minDistance = matches[0].distance;
+        for (const auto& m : matches) {
+            if (m.distance < minDistance) minDistance = m.distance;
+        }
+        
+        std::vector<cv::DMatch> goodMatches;
+        for (const auto& m : matches) {
+            if (m.distance < 3 * minDistance && m.distance < 50.0) {
+                goodMatches.push_back(m);
+            }
+        }
+        
+        if (goodMatches.size() < 10) {
+            return cv::Mat();
+        }
+        
+        // Extract matched points
+        std::vector<cv::Point2f> srcPoints, dstPoints;
+        for (const auto& m : goodMatches) {
+            srcPoints.push_back(kpImg[m.queryIdx].pt);
+            dstPoints.push_back(kpRef[m.trainIdx].pt);
+        }
+        
+        // Find homography
+        cv::Mat homography = cv::findHomography(srcPoints, dstPoints, cv::RANSAC, 5.0);
+        
+        if (homography.empty()) {
+            return cv::Mat();
+        }
+        
+        // Warp image to align with reference
+        // Use BORDER_REPLICATE to avoid black/white spaces in aligned images
+        cv::Mat aligned;
+        cv::warpPerspective(image, aligned, homography, reference.size(), 
+                          cv::INTER_LINEAR, cv::BORDER_REPLICATE);
+        
+        return aligned;
+    } @catch (NSException *exception) {
+        return cv::Mat();
+    }
+}
+
+// Helper: Align all images to first image as reference
+- (std::vector<cv::Mat>)alignFacesToReference:(std::vector<cv::Mat>&)images {
+    std::vector<cv::Mat> alignedImages;
+    
+    if (images.size() < 2) {
+        return alignedImages;
+    }
+    
+    @try {
+        cv::Mat reference = images[0];
+        
+        // Add reference image as-is
+        alignedImages.push_back(reference.clone());
+        
+        // Convert reference to grayscale
+        cv::Mat refGray;
+        cv::cvtColor(reference, refGray, cv::COLOR_RGB2GRAY);
+        
+        // Align remaining images
+        for (size_t i = 1; i < images.size(); i++) {
+            cv::Mat aligned = [self alignImageToReference:images[i] reference:reference refGray:refGray];
+            if (!aligned.empty()) {
+                alignedImages.push_back(aligned);
+            } else {
+                // Fallback to original if alignment fails
+                alignedImages.push_back(images[i].clone());
+            }
+        }
+        
+        return (alignedImages.size() >= 2) ? alignedImages : std::vector<cv::Mat>();
+    } @catch (NSException *exception) {
+        for (auto& m : alignedImages) { m.release(); }
+        return std::vector<cv::Mat>();
+    }
+}
+
 RCT_EXPORT_METHOD(detectHologram:(NSArray *)base64Images
                   threshold:(NSInteger)threshold
                   resolver:(RCTPromiseResolveBlock)resolve
@@ -223,10 +485,7 @@ RCT_EXPORT_METHOD(detectHologram:(NSArray *)base64Images
     // Run on background queue to avoid blocking the main/JS thread
     dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
     @try {
-        NSLog(@"[OpenCV] detectHologram called with %lu images, threshold: %ld", (unsigned long)base64Images.count, (long)threshold);
-
         if (base64Images.count < 2) {
-            NSLog(@"[OpenCV] Not enough images for hologram detection");
             resolve(nil);
             return;
         }
@@ -245,68 +504,81 @@ RCT_EXPORT_METHOD(detectHologram:(NSArray *)base64Images
             }
         }
 
-        NSLog(@"[OpenCV] Decoded %lu valid images", (unsigned long)mats.size());
-
         if (mats.size() < 2) {
-            NSLog(@"[OpenCV] Not enough valid decoded images");
             resolve(nil);
             return;
         }
 
-        NSLog(@"[OpenCV] Processing hologram detection...");
+        // Use original images directly (no alignment needed - HSV detects color changes regardless)
+        std::vector<cv::Mat>& imagesToProcess = mats;
 
-        // Multi-range HSV filtering for holographic colors (matching Android)
-        // Range 1: Cyan-green holographic reflections
-        cv::Scalar lowerBound1(35, 80, 80);
-        cv::Scalar upperBound1(85, 255, 255);
-        // Range 2: Blue-violet holographic reflections
-        cv::Scalar lowerBound2(100, 80, 80);
-        cv::Scalar upperBound2(160, 255, 255);
+        // Calculate adaptive threshold based on image size (1% of total pixels - balanced detection)
+        int imagePixels = imagesToProcess[0].rows * imagesToProcess[0].cols;
+        int adaptiveThreshold = (int)(imagePixels * 0.01);
+
+        // 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
+        cv::Scalar lowerBound1(40, 60, 60);
+        cv::Scalar upperBound1(75, 255, 220);
+        // Range 2: Blue-violet holographic spectrum
+        cv::Scalar lowerBound2(110, 60, 60);
+        cv::Scalar upperBound2(150, 255, 220);
 
         std::vector<cv::Mat> diffs;
         std::vector<cv::Mat> brightestImages;
 
-        const int HOLOGRAM_NON_ZERO_THRESHOLD = 600;
+        // Compare consecutive frames AND frames with gaps to catch both fast and slow color shifts
+        for (size_t i = 0; i < imagesToProcess.size() - 1; i++) {
+            // Gap 1: Consecutive frames (fast changes)
+            cv::Mat diff1;
+            cv::absdiff(imagesToProcess[i], imagesToProcess[i + 1], diff1);
+
+            cv::Mat hsv1;
+            cv::cvtColor(diff1, hsv1, cv::COLOR_RGB2HSV);
 
-        for (size_t i = 0; i < mats.size() - 1; i++) {
-            cv::Mat diff;
-            cv::absdiff(mats[i], mats[i + 1], diff);
+            cv::Mat mask1a, mask1b, mask1;
+            cv::inRange(hsv1, lowerBound1, upperBound1, mask1a);
+            cv::inRange(hsv1, lowerBound2, upperBound2, mask1b);
+            cv::bitwise_or(mask1a, mask1b, mask1);
 
-            cv::Mat hsv;
-            cv::cvtColor(diff, hsv, cv::COLOR_RGB2HSV);
+            int maskNonZero1 = cv::countNonZero(mask1);
 
-            // Apply multi-range HSV filtering
-            cv::Mat mask1, mask2, mask;
-            cv::inRange(hsv, lowerBound1, upperBound1, mask1);
-            cv::inRange(hsv, lowerBound2, upperBound2, mask2);
-            cv::bitwise_or(mask1, mask2, mask);
+            if (maskNonZero1 > adaptiveThreshold) {
+                diffs.push_back(mask1.clone());
+                brightestImages.push_back(imagesToProcess[i].clone());
+                brightestImages.push_back(imagesToProcess[i + 1].clone());
+            }
+
+            // Gap 3: Every third frame (slower color shifts) - only for frames that allow it
+            if (i + 3 < imagesToProcess.size()) {
+                cv::Mat diff3;
+                cv::absdiff(imagesToProcess[i], imagesToProcess[i + 3], diff3);
+
+                cv::Mat hsv3;
+                cv::cvtColor(diff3, hsv3, cv::COLOR_RGB2HSV);
 
-            int maskNonZero = cv::countNonZero(mask);
-            NSLog(@"[OpenCV] Image pair %zu→%zu: mask non-zero=%d (threshold=%d)", i, i+1, maskNonZero, HOLOGRAM_NON_ZERO_THRESHOLD);
+                cv::Mat mask3a, mask3b, mask3;
+                cv::inRange(hsv3, lowerBound1, upperBound1, mask3a);
+                cv::inRange(hsv3, lowerBound2, upperBound2, mask3b);
+                cv::bitwise_or(mask3a, mask3b, mask3);
 
-            if (maskNonZero > HOLOGRAM_NON_ZERO_THRESHOLD) {
-                diffs.push_back(mask.clone());
-                brightestImages.push_back(mats[i].clone());
-                brightestImages.push_back(mats[i + 1].clone());
-                NSLog(@"[OpenCV]   ✓ Mask added to diffs (significant variation)");
+                int maskNonZero3 = cv::countNonZero(mask3);
 
-                // Early termination: if first pair already has very strong signal, skip rest
-                if (i == 0 && maskNonZero > HOLOGRAM_NON_ZERO_THRESHOLD * 4) {
-                    NSLog(@"[OpenCV]   ⚡ Strong signal in first pair, skipping remaining pairs");
-                    break;
+                if (maskNonZero3 > adaptiveThreshold) {
+                    diffs.push_back(mask3.clone());
+                    brightestImages.push_back(imagesToProcess[i].clone());
+                    brightestImages.push_back(imagesToProcess[i + 3].clone());
                 }
-            } else {
-                NSLog(@"[OpenCV]   ✗ Mask rejected (insufficient variation)");
             }
         }
 
-        // Release original mats early
-        for (auto& m : mats) { m.release(); }
+        // Release processed mats
+        for (auto& m : imagesToProcess) { m.release(); }
         mats.clear();
-        NSLog(@"[OpenCV] Found %lu significant differences", (unsigned long)diffs.size());
-
+        
         if (diffs.empty()) {
-            NSLog(@"[OpenCV] No significant hologram features detected");
             for (auto& m : brightestImages) { m.release(); }
             resolve(nil);
             return;
@@ -314,7 +586,6 @@ RCT_EXPORT_METHOD(detectHologram:(NSArray *)base64Images
 
         // Combine all difference masks using bitwise_or (matching Android)
         cv::Mat hologramMask = diffs[0].clone();
-        NSLog(@"[OpenCV] Combining difference masks...");
 
         for (size_t i = 1; i < diffs.size(); i++) {
             cv::bitwise_or(hologramMask, diffs[i], hologramMask);
@@ -324,17 +595,14 @@ RCT_EXPORT_METHOD(detectHologram:(NSArray *)base64Images
         diffs.clear();
 
         // Apply morphological operations to clean up (matching Android)
-        NSLog(@"[OpenCV] Applying morphological operations...");
         cv::Mat kernel = cv::getStructuringElement(cv::MORPH_ELLIPSE, cv::Size(3, 3));
         cv::morphologyEx(hologramMask, hologramMask, cv::MORPH_CLOSE, kernel);
         cv::morphologyEx(hologramMask, hologramMask, cv::MORPH_OPEN, kernel);
 
         // Check if significant hologram detected
         int nonZeroCount = cv::countNonZero(hologramMask);
-        NSLog(@"[OpenCV] Hologram mask non-zero count: %d, threshold: %ld", nonZeroCount, (long)threshold);
 
         if (nonZeroCount < threshold) {
-            NSLog(@"[OpenCV] Hologram mask below threshold");
             hologramMask.release();
             for (auto& m : brightestImages) { m.release(); }
             resolve(nil);
@@ -372,10 +640,7 @@ RCT_EXPORT_METHOD(detectHologram:(NSArray *)base64Images
         for (auto& m : brightestImages) { m.release(); }
         brightestImages.clear();
 
-        NSLog(@"[OpenCV] Selected best hologram image with score: %f", maxScore);
-
         // Convert results to base64
-        NSLog(@"[OpenCV] Converting results to base64...");
         @autoreleasepool {
             UIImage *hologramImage = [self matToImage:bestImage];
             UIImage *maskImage = [self matToImage:hologramMask];
@@ -388,7 +653,6 @@ RCT_EXPORT_METHOD(detectHologram:(NSArray *)base64Images
                 NSString *maskBase64 = [self imageToBase64:maskImage];
 
                 if (hologramBase64 && maskBase64) {
-                    NSLog(@"[OpenCV] Hologram detection successful");
                     resolve(@{
                         @"hologramImage": hologramBase64,
                         @"hologramMask": maskBase64
@@ -398,7 +662,6 @@ RCT_EXPORT_METHOD(detectHologram:(NSArray *)base64Images
             }
         }
 
-        NSLog(@"[OpenCV] Failed to convert hologram results to base64");
         resolve(nil);
     } @catch (NSException *exception) {
         NSLog(@"[OpenCV] Exception in detectHologram: %@", exception.reason);
@@ -611,339 +874,158 @@ RCT_EXPORT_METHOD(checkBlurryInRegion:(NSString *)base64Image
     }
 }
 
-RCT_EXPORT_METHOD(detectCardBounds:(NSString *)base64Image
-                  textBlocks:(NSArray *)textBlocks
-                  faces:(NSArray *)faces
-                  imageWidth:(NSInteger)imageWidth
-                  imageHeight:(NSInteger)imageHeight
+/**
+ * Compare face shape/geometry between two face images.
+ * Analyzes aspect ratio, edges, and structural similarity.
+ * Device-side validation before backend FaceNet.
+ */
+RCT_EXPORT_METHOD(compareFaceShape:(NSString *)base64Image1
+                  secondImage:(NSString *)base64Image2
                   resolver:(RCTPromiseResolveBlock)resolve
                   rejecter:(RCTPromiseRejectBlock)reject) {
     @try {
-        // Collect all element bounds for clustering
-        NSMutableArray *allElements = [NSMutableArray array];
-
-        // Process text blocks
-        for (NSDictionary *block in textBlocks) {
-            NSDictionary *frame = block[@"blockFrame"];
-            if (!frame) continue;
-
-            int x = [frame[@"x"] intValue];
-            int y = [frame[@"y"] intValue];
-            int width = [frame[@"width"] intValue];
-            int height = [frame[@"height"] intValue];
-
-            [allElements addObject:@{
-                @"left": @(x),
-                @"top": @(y),
-                @"right": @(x + width),
-                @"bottom": @(y + height)
-            }];
-        }
-
-        // Process faces
-        for (NSDictionary *face in faces) {
-            NSDictionary *bounds = face[@"bounds"];
-            if (!bounds) continue;
-
-            int x = [bounds[@"x"] intValue];
-            int y = [bounds[@"y"] intValue];
-            int width = [bounds[@"width"] intValue];
-            int height = [bounds[@"height"] intValue];
-
-            [allElements addObject:@{
-                @"left": @(x),
-                @"top": @(y),
-                @"right": @(x + width),
-                @"bottom": @(y + height)
-            }];
-        }
-
-        if (allElements.count == 0) {
-            NSLog(@"[OpenCVModule] No elements detected for card bounds");
-            resolve(nil);
-            return;
-        }
-
-        // Calculate the centroid of all elements
-        int centerX = 0;
-        int centerY = 0;
-        for (NSDictionary *rect in allElements) {
-            centerX += ([rect[@"left"] intValue] + [rect[@"right"] intValue]) / 2;
-            centerY += ([rect[@"top"] intValue] + [rect[@"bottom"] intValue]) / 2;
-        }
-        centerX /= (int)allElements.count;
-        centerY /= (int)allElements.count;
-
-        // Calculate distances from centroid
-        NSMutableArray *distances = [NSMutableArray array];
-        for (NSDictionary *rect in allElements) {
-            int elemCenterX = ([rect[@"left"] intValue] + [rect[@"right"] intValue]) / 2;
-            int elemCenterY = ([rect[@"top"] intValue] + [rect[@"bottom"] intValue]) / 2;
-            int dx = elemCenterX - centerX;
-            int dy = elemCenterY - centerY;
-            double distance = sqrt(dx * dx + dy * dy);
-            [distances addObject:@(distance)];
-        }
-
-        // Calculate median distance
-        NSArray *sortedDistances = [distances sortedArrayUsingSelector:@selector(compare:)];
-        double medianDistance = [sortedDistances[sortedDistances.count / 2] doubleValue];
-
-        // Filter out elements that are more than 2x the median distance from center
-        double threshold = medianDistance * 2.0;
-        NSMutableArray *filteredElements = [NSMutableArray array];
-        for (NSUInteger i = 0; i < allElements.count; i++) {
-            if ([distances[i] doubleValue] <= threshold) {
-                [filteredElements addObject:allElements[i]];
-            }
-        }
-
-        NSLog(@"[OpenCVModule] Filtered %lu outlier elements (%lu -> %lu)",
-              (unsigned long)(allElements.count - filteredElements.count),
-              (unsigned long)allElements.count,
-              (unsigned long)filteredElements.count);
+        UIImage *image1 = [self base64ToImage:base64Image1];
+        UIImage *image2 = [self base64ToImage:base64Image2];
 
-        if (filteredElements.count == 0) {
-            NSLog(@"[OpenCVModule] No elements after filtering outliers");
-            resolve(nil);
+        if (!image1 || !image2) {
+            reject(@"DECODE_ERROR", @"Failed to decode face images", nil);
             return;
         }
 
-        // Now calculate bounds from filtered elements
-        int minX = (int)imageWidth;
-        int minY = (int)imageHeight;
-        int maxX = 0;
-        int maxY = 0;
-
-        for (NSDictionary *rect in filteredElements) {
-            minX = MIN(minX, [rect[@"left"] intValue]);
-            minY = MIN(minY, [rect[@"top"] intValue]);
-            maxX = MAX(maxX, [rect[@"right"] intValue]);
-            maxY = MAX(maxY, [rect[@"bottom"] intValue]);
-        }
-
-        int elementCount = (int)filteredElements.count;
-
-        NSLog(@"[OpenCVModule] Detected elements: %d, bounds: (%d, %d) to (%d, %d)", elementCount, minX, minY, maxX, maxY);
-
-        // Calculate raw bounding box from elements
-        int elementsWidth = maxX - minX;
-        int elementsHeight = maxY - minY;
-
-        NSLog(@"[OpenCVModule] Elements size: %dx%d, frame: %ldx%ld", elementsWidth, elementsHeight, (long)imageWidth, (long)imageHeight);
+        cv::Mat mat1 = [self imageToMat:image1];
+        cv::Mat mat2 = [self imageToMat:image2];
 
-        // Validate minimum size (elements should occupy at least 5% of frame)
-        int minArea = (int)(imageWidth * imageHeight * 0.05);
-        if (elementsWidth * elementsHeight < minArea) {
-            NSLog(@"[OpenCVModule] Elements too small: %d < %d", elementsWidth * elementsHeight, minArea);
-            resolve(nil);
+        if (mat1.empty() || mat2.empty()) {
+            reject(@"DECODE_ERROR", @"Failed to convert images to Mat", nil);
             return;
         }
 
-        // Add generous padding (15% on all sides) to ensure full card is captured
-        int paddingX = (int)(elementsWidth * 0.15);
-        int paddingY = (int)(elementsHeight * 0.15);
+        // Normalize sizes for comparison
+        cv::Size size(200, 200);
+        cv::Mat resized1, resized2;
+        cv::resize(mat1, resized1, size);
+        cv::resize(mat2, resized2, size);
 
-        // Calculate card bounds with padding, clamped to image boundaries
-        int cardX = MAX(0, minX - paddingX);
-        int cardY = MAX(0, minY - paddingY);
-        int cardRight = MIN((int)imageWidth, maxX + paddingX);
-        int cardBottom = MIN((int)imageHeight, maxY + paddingY);
-        int cardWidth = cardRight - cardX;
-        int cardHeight = cardBottom - cardY;
+        // Calculate aspect ratios
+        double aspectRatio1 = (double)mat1.cols / (double)mat1.rows;
+        double aspectRatio2 = (double)mat2.cols / (double)mat2.rows;
+        double aspectRatioDiff = fabs(aspectRatio1 - aspectRatio2);
+        BOOL aspectRatioMatch = aspectRatioDiff < 0.15; // 15% tolerance
 
-        NSLog(@"[OpenCVModule] Card bounds: (%d, %d) %dx%d", cardX, cardY, cardWidth, cardHeight);
+        // Edge detection for structural comparison
+        cv::Mat gray1, gray2;
+        cv::cvtColor(resized1, gray1, cv::COLOR_RGB2GRAY);
+        cv::cvtColor(resized2, gray2, cv::COLOR_RGB2GRAY);
 
-        // Validate aspect ratio is reasonable for a document (very lenient: 1.0 - 2.5)
-        double aspectRatio = (double)cardWidth / MAX((double)cardHeight, 1.0);
-        NSLog(@"[OpenCVModule] Card aspect ratio: %f", aspectRatio);
+        cv::Mat edges1, edges2;
+        cv::Canny(gray1, edges1, 50, 150);
+        cv::Canny(gray2, edges2, 50, 150);
 
-        if (aspectRatio < 1.0 || aspectRatio > 2.5) {
-            NSLog(@"[OpenCVModule] Aspect ratio out of range: %f", aspectRatio);
-            resolve(nil);
-            return;
-        }
-
-        // Create corner points (rectangular bounds)
-        NSMutableArray *corners = [NSMutableArray array];
-
-        // Top-left
-        [corners addObject:@{
-            @"x": @(cardX),
-            @"y": @(cardY)
-        }];
-
-        // Top-right
-        [corners addObject:@{
-            @"x": @(cardX + cardWidth),
-            @"y": @(cardY)
-        }];
-
-        // Bottom-right
-        [corners addObject:@{
-            @"x": @(cardX + cardWidth),
-            @"y": @(cardY + cardHeight)
-        }];
-
-        // Bottom-left
-        [corners addObject:@{
-            @"x": @(cardX),
-            @"y": @(cardY + cardHeight)
-        }];
+        // Compare edge structures
+        cv::Mat diff;
+        cv::absdiff(edges1, edges2, diff);
+        int diffCount = cv::countNonZero(diff);
+        int totalPixels = edges1.rows * edges1.cols;
+        int matchPixels = totalPixels - diffCount;
+        double shapeScore = (double)matchPixels / (double)totalPixels;
+
+        // Cleanup
+        mat1.release();
+        mat2.release();
+        resized1.release();
+        resized2.release();
+        gray1.release();
+        gray2.release();
+        edges1.release();
+        edges2.release();
+        diff.release();
 
         NSDictionary *result = @{
-            @"x": @(cardX),
-            @"y": @(cardY),
-            @"width": @(cardWidth),
-            @"height": @(cardHeight),
-            @"corners": corners,
-            @"angle": @(0.0)  // Rectangular alignment
+            @"shapeScore": @(shapeScore),
+            @"aspectRatioMatch": @(aspectRatioMatch),
+            @"aspectRatioDiff": @(aspectRatioDiff)
         };
-
         resolve(result);
     } @catch (NSException *exception) {
-        resolve(nil);
+        reject(@"FACE_SHAPE_ERROR", exception.reason, nil);
     }
 }
-// Preprocess image for better OCR text recognition using OpenCV
-RCT_EXPORT_METHOD(preprocessImageForOCR:(NSString *)base64Image
-                  applyThresholding:(BOOL)applyThresholding
+
+/**
+ * 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.
+ */
+RCT_EXPORT_METHOD(compareFaceVisualSimilarity:(NSString *)base64Image1
+                  secondImage:(NSString *)base64Image2
                   resolver:(RCTPromiseResolveBlock)resolve
                   rejecter:(RCTPromiseRejectBlock)reject) {
     @try {
-        UIImage *image = [self base64ToImage:base64Image];
-        if (!image) {
-            reject(@"DECODE_ERROR", @"Failed to decode image", nil);
-            return;
-        }
+        UIImage *image1 = [self base64ToImage:base64Image1];
+        UIImage *image2 = [self base64ToImage:base64Image2];
 
-        cv::Mat mat = [self imageToMat:image];
-        if (mat.empty()) {
-            reject(@"MAT_ERROR", @"Failed to convert image to Mat", nil);
+        if (!image1 || !image2) {
+            reject(@"DECODE_ERROR", @"Failed to decode face images", nil);
             return;
         }
 
-        // 1. Convert to grayscale
-        cv::Mat gray;
-        cv::cvtColor(mat, gray, cv::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
-        cv::Mat filtered;
-        cv::bilateralFilter(gray, filtered, 9, 75, 75);
-        gray.release();
-
-        // 3. Apply CLAHE (Contrast Limited Adaptive Histogram Equalization)
-        // This enhances local contrast, making text stand out better
-        cv::Ptr<cv::CLAHE> clahe = cv::createCLAHE(2.0, cv::Size(8, 8));
-        cv::Mat enhanced;
-        clahe->apply(filtered, enhanced);
-        filtered.release();
-
-        // 4. Sharpen the image to enhance text edges
-        // Use unsharp masking: original + (original - blurred) * amount
-        cv::Mat blurred;
-        cv::GaussianBlur(enhanced, blurred, cv::Size(0, 0), 3.0);
-        cv::Mat sharpened;
-        cv::addWeighted(enhanced, 1.5, blurred, -0.5, 0, sharpened);
-        blurred.release();
-        enhanced.release();
-
-        // 5. Optional: Apply adaptive thresholding for binary text extraction
-        cv::Mat result;
-        if (applyThresholding) {
-            cv::Mat thresholded;
-            // Use Gaussian adaptive threshold - better for varying illumination
-            cv::adaptiveThreshold(sharpened, thresholded, 255,
-                                cv::ADAPTIVE_THRESH_GAUSSIAN_C,
-                                cv::THRESH_BINARY, 11, 2);
-            sharpened.release();
-
-            // Apply morphological operations to clean up noise
-            cv::Mat kernel = cv::getStructuringElement(cv::MORPH_RECT, cv::Size(2, 2));
-            cv::morphologyEx(thresholded, result, cv::MORPH_CLOSE, kernel);
-            thresholded.release();
-            kernel.release();
-        } else {
-            result = sharpened;
-        }
-
-        UIImage *resultImage = [self matToImage:result];
-        result.release();
-
-        if (!resultImage) {
-            reject(@"ENCODE_ERROR", @"Failed to convert result to image", nil);
+        cv::Mat mat1 = [self imageToMat:image1];
+        cv::Mat mat2 = [self imageToMat:image2];
+
+        if (mat1.empty() || mat2.empty()) {
+            reject(@"DECODE_ERROR", @"Failed to convert images to Mat", nil);
             return;
         }
 
-        NSString *resultBase64 = [self imageToBase64:resultImage];
-        if (resultBase64) {
-            resolve(resultBase64);
-        } else {
-            reject(@"ENCODE_ERROR", @"Failed to encode result", nil);
-        }
-    } @catch (NSException *exception) {
-        reject(@"OCR_PREPROCESS_ERROR", exception.reason, nil);
-    }
-}
+        // Normalize sizes
+        cv::Size size(200, 200);
+        cv::Mat resized1, resized2;
+        cv::resize(mat1, resized1, size);
+        cv::resize(mat2, resized2, size);
+
+        // Convert to grayscale and equalize histogram for better comparison
+        cv::Mat gray1, gray2;
+        cv::cvtColor(resized1, gray1, cv::COLOR_RGB2GRAY);
+        cv::cvtColor(resized2, gray2, cv::COLOR_RGB2GRAY);
+        cv::equalizeHist(gray1, gray1);
+        cv::equalizeHist(gray2, gray2);
+
+        // Compute mean and standard deviation for both images
+        cv::Scalar mean1, stdDev1, mean2, stdDev2;
+        cv::meanStdDev(gray1, mean1, stdDev1);
+        cv::meanStdDev(gray2, mean2, stdDev2);
+
+        // Compute correlation coefficient (simplified SSIM approach)
+        cv::Mat normalizedGray1, normalizedGray2;
+        gray1.convertTo(normalizedGray1, CV_64F);
+        gray2.convertTo(normalizedGray2, CV_64F);
+
+        // Calculate correlation
+        cv::Mat product;
+        cv::multiply(normalizedGray1, normalizedGray2, product);
+        cv::Scalar sumScalar = cv::sum(product);
+        double correlation = sumScalar[0] / (gray1.rows * gray1.cols);
+
+        // Normalize to 0-1 range (simplified similarity score)
+        double similarity = std::max(0.0, std::min(1.0, correlation / 65536.0));
+
+        // Cleanup
+        mat1.release();
+        mat2.release();
+        resized1.release();
+        resized2.release();
+        gray1.release();
+        gray2.release();
+        normalizedGray1.release();
+        normalizedGray2.release();
+        product.release();
 
-// Synchronous version for direct Swift calls
-- (UIImage *)preprocessImageForOCRSync:(UIImage *)image applyThresholding:(BOOL)applyThresholding {
-    @try {
-        if (!image) return nil;
-
-        cv::Mat mat = [self imageToMat:image];
-        if (mat.empty()) return nil;
-
-        // 1. Convert to grayscale
-        cv::Mat gray;
-        cv::cvtColor(mat, gray, cv::COLOR_RGB2GRAY);
-        mat.release();
-
-        // 2. Apply bilateral filter for noise reduction while preserving edges
-        cv::Mat filtered;
-        cv::bilateralFilter(gray, filtered, 9, 75, 75);
-        gray.release();
-
-        // 3. Apply CLAHE (Contrast Limited Adaptive Histogram Equalization)
-        cv::Ptr<cv::CLAHE> clahe = cv::createCLAHE(2.0, cv::Size(8, 8));
-        cv::Mat enhanced;
-        clahe->apply(filtered, enhanced);
-        filtered.release();
-
-        // 4. Sharpen the image to enhance text edges
-        cv::Mat blurred;
-        cv::GaussianBlur(enhanced, blurred, cv::Size(0, 0), 3.0);
-        cv::Mat sharpened;
-        cv::addWeighted(enhanced, 1.5, blurred, -0.5, 0, sharpened);
-        blurred.release();
-        enhanced.release();
-
-        // 5. Optional: Apply adaptive thresholding for binary text extraction
-        cv::Mat result;
-        if (applyThresholding) {
-            cv::Mat thresholded;
-            cv::adaptiveThreshold(sharpened, thresholded, 255,
-                                cv::ADAPTIVE_THRESH_GAUSSIAN_C,
-                                cv::THRESH_BINARY, 11, 2);
-            sharpened.release();
-
-            cv::Mat kernel = cv::getStructuringElement(cv::MORPH_RECT, cv::Size(2, 2));
-            cv::morphologyEx(thresholded, result, cv::MORPH_CLOSE, kernel);
-            thresholded.release();
-            kernel.release();
-        } else {
-            result = sharpened;
-        }
-
-        UIImage *resultImage = [self matToImage:result];
-        result.release();
-
-        return resultImage;
+        NSDictionary *result = @{
+            @"similarity": @(similarity)
+        };
+        resolve(result);
     } @catch (NSException *exception) {
-        NSLog(@"OpenCV preprocessing error: %@", exception.reason);
-        return nil;
+        reject(@"FACE_SIMILARITY_ERROR", exception.reason, nil);
     }
 }