@trustchex/react-native-sdk 1.355.1 → 1.357.0

package/ios/OpenCV/OpenCVModule.mm

@@ -0,0 +1,810 @@
+#import "OpenCVModule.h"
+#import <React/RCTLog.h>
+
+#ifdef __cplusplus
+#undef NO
+#undef YES
+#import <opencv2/opencv.hpp>
+#import <opencv2/imgcodecs/ios.h>
+#define NO __objc_no
+#define YES __objc_yes
+#endif
+
+@implementation OpenCVModule
+
+RCT_EXPORT_MODULE();
+
++ (BOOL)requiresMainQueueSetup {
+    return NO;
+}
+
+// Helper: Convert base64 string to UIImage
+- (UIImage *)base64ToImage:(NSString *)base64String {
+    if (!base64String || base64String.length == 0) return nil;
+    NSData *imageData = [[NSData alloc] initWithBase64EncodedString:base64String options:NSDataBase64DecodingIgnoreUnknownCharacters];
+    if (!imageData) return nil;
+    return [UIImage imageWithData:imageData];
+}
+
+// Helper: Convert UIImage to base64 string
+- (NSString *)imageToBase64:(UIImage *)image {
+    if (!image) return nil;
+    NSData *imageData = UIImageJPEGRepresentation(image, 0.8);
+    if (!imageData) return nil;
+    return [imageData base64EncodedStringWithOptions:0];
+}
+
+// Helper: Convert UIImage to cv::Mat
+- (cv::Mat)imageToMat:(UIImage *)image {
+    if (!image) return cv::Mat();
+
+    CGImageRef imageRef = image.CGImage;
+    CGColorSpaceRef colorSpace = CGImageGetColorSpace(imageRef);
+    size_t width = CGImageGetWidth(imageRef);
+    size_t height = CGImageGetHeight(imageRef);
+
+    cv::Mat mat(static_cast<int>(height), static_cast<int>(width), CV_8UC4);
+
+    CGContextRef context = CGBitmapContextCreate(mat.data, width, height, 8, mat.step[0],
+                                                 colorSpace, kCGImageAlphaPremultipliedLast | kCGBitmapByteOrderDefault);
+    if (!context) return cv::Mat();
+
+    CGContextDrawImage(context, CGRectMake(0, 0, width, height), imageRef);
+    CGContextRelease(context);
+
+    cv::Mat result;
+    cv::cvtColor(mat, result, cv::COLOR_RGBA2RGB);
+    return result;
+}
+
+// Helper: Convert cv::Mat to UIImage
+- (UIImage *)matToImage:(cv::Mat)mat {
+    if (mat.empty()) return nil;
+
+    cv::Mat rgba;
+    if (mat.channels() == 1) {
+        cv::cvtColor(mat, rgba, cv::COLOR_GRAY2RGBA);
+    } else if (mat.channels() == 3) {
+        cv::cvtColor(mat, rgba, cv::COLOR_RGB2RGBA);
+    } else {
+        rgba = mat.clone();
+    }
+
+    NSData *data = [NSData dataWithBytes:rgba.data length:rgba.elemSize() * rgba.total()];
+
+    CGColorSpaceRef colorSpace = CGColorSpaceCreateDeviceRGB();
+    CGDataProviderRef provider = CGDataProviderCreateWithCFData((__bridge CFDataRef)data);
+
+    CGImageRef imageRef = CGImageCreate(rgba.cols, rgba.rows, 8, 32, rgba.step[0],
+                                       colorSpace, kCGImageAlphaPremultipliedLast | kCGBitmapByteOrderDefault,
+                                       provider, NULL, false, kCGRenderingIntentDefault);
+
+    UIImage *image = [UIImage imageWithCGImage:imageRef];
+
+    CGImageRelease(imageRef);
+    CGDataProviderRelease(provider);
+    CGColorSpaceRelease(colorSpace);
+
+    return image;
+}
+
+RCT_EXPORT_METHOD(cropFaceImages:(NSString *)base64Image
+                  faceBounds:(NSArray *)faceBounds
+                  imageWidth:(NSInteger)imageWidth
+                  imageHeight:(NSInteger)imageHeight
+                  resolver:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject) {
+    @try {
+        UIImage *image = [self base64ToImage:base64Image];
+        if (!image) {
+            resolve(@[]);
+            return;
+        }
+
+        cv::Mat mat = [self imageToMat:image];
+        if (mat.empty()) {
+            resolve(@[]);
+            return;
+        }
+
+        // Sort face bounds by x position (left to right) to match Android
+        NSArray *sortedBounds = [faceBounds sortedArrayUsingComparator:^NSComparisonResult(NSDictionary *a, NSDictionary *b) {
+            int xA = [a[@"x"] intValue];
+            int xB = [b[@"x"] intValue];
+            return xA < xB ? NSOrderedAscending : (xA > xB ? NSOrderedDescending : NSOrderedSame);
+        }];
+
+        NSMutableArray *croppedFaces = [NSMutableArray array];
+
+        for (NSDictionary *bounds in sortedBounds) {
+            int x = [bounds[@"x"] intValue];
+            int y = [bounds[@"y"] intValue];
+            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);
+
+            if (x >= 0 && y >= 0 && x + width <= mat.cols && y + height <= mat.rows && width > 0 && height > 0) {
+                cv::Rect roi(x, y, width, height);
+                cv::Mat cropped = mat(roi).clone();
+
+                // Resize to 240x320 to match Android and reduce memory for hologram detection
+                cv::Mat resized;
+                cv::resize(cropped, resized, cv::Size(240, 320));
+                cropped.release();
+
+                // Add face without blur check
+                UIImage *croppedImage = [self matToImage:resized];
+                if (croppedImage) {
+                    NSString *base64 = [self imageToBase64:croppedImage];
+                    if (base64) {
+                        [croppedFaces addObject:base64];
+                    }
+                }
+                
+                resized.release();
+            }
+        }
+
+        resolve(croppedFaces);
+    } @catch (NSException *exception) {
+        reject(@"CROP_ERROR", exception.reason, nil);
+    }
+}
+
+RCT_EXPORT_METHOD(areImagesSimilar:(NSString *)base64Image1
+                  base64Image2:(NSString *)base64Image2
+                  threshold:(NSInteger)threshold
+                  resolver:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject) {
+    @try {
+        UIImage *image1 = [self base64ToImage:base64Image1];
+        UIImage *image2 = [self base64ToImage:base64Image2];
+
+        if (!image1 || !image2) {
+            resolve(@NO);
+            return;
+        }
+
+        cv::Mat mat1 = [self imageToMat:image1];
+        cv::Mat mat2 = [self imageToMat:image2];
+
+        if (mat1.empty() || mat2.empty()) {
+            resolve(@NO);
+            return;
+        }
+
+        // Resize to same size if different
+        if (mat1.size() != mat2.size()) {
+            cv::resize(mat2, mat2, mat1.size());
+        }
+
+        // Apply grayscale, blur, and threshold (matching Android)
+        cv::Mat thresh1, thresh2;
+        [self applyThreshold:mat1 output:thresh1];
+        [self applyThreshold:mat2 output:thresh2];
+
+        // Compute absolute difference
+        cv::Mat diff;
+        cv::absdiff(thresh1, thresh2, diff);
+
+        // Count non-zero pixels
+        int count = cv::countNonZero(diff);
+
+        BOOL isSimilar = count < threshold;
+        resolve(@(isSimilar));
+    } @catch (NSException *exception) {
+        reject(@"SIMILARITY_ERROR", exception.reason, nil);
+    }
+}
+
+// Helper: Apply grayscale, Gaussian blur, and Otsu threshold
+- (void)applyThreshold:(cv::Mat)src output:(cv::Mat&)dst {
+    cv::Mat gray;
+    if (src.channels() > 1) {
+        cv::cvtColor(src, gray, cv::COLOR_RGB2GRAY);
+    } else {
+        gray = src.clone();
+    }
+    cv::GaussianBlur(gray, gray, cv::Size(5, 5), 0);
+    cv::threshold(gray, dst, 0, 255, cv::THRESH_BINARY + cv::THRESH_OTSU);
+}
+
+RCT_EXPORT_METHOD(detectHologram:(NSArray *)base64Images
+                  threshold:(NSInteger)threshold
+                  resolver:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject) {
+    // 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;
+        }
+
+        // Decode all images to Mat - use std::vector for better memory management
+        std::vector<cv::Mat> mats;
+        for (NSString *base64 in base64Images) {
+            @autoreleasepool {
+                UIImage *image = [self base64ToImage:base64];
+                if (image) {
+                    cv::Mat mat = [self imageToMat:image];
+                    if (!mat.empty()) {
+                        mats.push_back(mat.clone());
+                    }
+                }
+            }
+        }
+
+        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...");
+
+        // 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);
+
+        std::vector<cv::Mat> diffs;
+        std::vector<cv::Mat> brightestImages;
+
+        const int HOLOGRAM_NON_ZERO_THRESHOLD = 600;
+
+        for (size_t i = 0; i < mats.size() - 1; i++) {
+            cv::Mat diff;
+            cv::absdiff(mats[i], mats[i + 1], diff);
+
+            cv::Mat hsv;
+            cv::cvtColor(diff, hsv, cv::COLOR_RGB2HSV);
+
+            // 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);
+
+            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);
+
+            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)");
+
+                // 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;
+                }
+            } else {
+                NSLog(@"[OpenCV]   ✗ Mask rejected (insufficient variation)");
+            }
+        }
+
+        // Release original mats early
+        for (auto& m : mats) { 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;
+        }
+
+        // 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);
+        }
+
+        for (auto& d : diffs) { d.release(); }
+        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);
+            return;
+        }
+
+        // Find best image based on saturation score in mask regions (matching Android)
+        cv::Mat bestImage = brightestImages[0].clone();
+        double maxScore = 0.0;
+
+        for (const auto& img : brightestImages) {
+            cv::Mat maskedRegion;
+            img.copyTo(maskedRegion, hologramMask);
+
+            cv::Mat hsvImg;
+            cv::cvtColor(maskedRegion, hsvImg, cv::COLOR_RGB2HSV);
+
+            std::vector<cv::Mat> channels;
+            cv::split(hsvImg, channels);
+
+            cv::Scalar satMean = cv::mean(channels[1], hologramMask);
+            double score = satMean[0];
+
+            maskedRegion.release();
+            hsvImg.release();
+            for (auto& c : channels) { c.release(); }
+
+            if (score > maxScore) {
+                maxScore = score;
+                bestImage.release();
+                bestImage = img.clone();
+            }
+        }
+
+        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];
+
+            bestImage.release();
+            hologramMask.release();
+
+            if (hologramImage && maskImage) {
+                NSString *hologramBase64 = [self imageToBase64:hologramImage];
+                NSString *maskBase64 = [self imageToBase64:maskImage];
+
+                if (hologramBase64 && maskBase64) {
+                    NSLog(@"[OpenCV] Hologram detection successful");
+                    resolve(@{
+                        @"hologramImage": hologramBase64,
+                        @"hologramMask": maskBase64
+                    });
+                    return;
+                }
+            }
+        }
+
+        NSLog(@"[OpenCV] Failed to convert hologram results to base64");
+        resolve(nil);
+    } @catch (NSException *exception) {
+        NSLog(@"[OpenCV] Exception in detectHologram: %@", exception.reason);
+        reject(@"HOLOGRAM_ERROR", exception.reason, nil);
+    }
+    }); // end dispatch_async
+}
+
+RCT_EXPORT_METHOD(getAverageBrightness:(NSString *)base64Image
+                  resolver:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject) {
+    @try {
+        UIImage *image = [self base64ToImage:base64Image];
+        if (!image) {
+            resolve(@(0.0));
+            return;
+        }
+
+        cv::Mat mat = [self imageToMat:image];
+        if (mat.empty()) {
+            resolve(@(0.0));
+            return;
+        }
+
+        cv::Mat gray;
+        cv::cvtColor(mat, gray, cv::COLOR_RGB2GRAY);
+        cv::Scalar mean = cv::mean(gray);
+
+        resolve(@(mean[0]));
+    } @catch (NSException *exception) {
+        resolve(@(0.0));
+    }
+}
+
+RCT_EXPORT_METHOD(isCircularRegionBright:(NSString *)base64Image
+                  minX:(NSInteger)minX
+                  minY:(NSInteger)minY
+                  width:(NSInteger)width
+                  height:(NSInteger)height
+                  threshold:(double)threshold
+                  resolver:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject) {
+    @try {
+        UIImage *image = [self base64ToImage:base64Image];
+        if (!image) {
+            resolve(@NO);
+            return;
+        }
+
+        cv::Mat mat = [self imageToMat:image];
+        if (mat.empty()) {
+            resolve(@NO);
+            return;
+        }
+
+        cv::Mat gray;
+        cv::cvtColor(mat, gray, cv::COLOR_RGB2GRAY);
+
+        // Create circular mask
+        cv::Mat mask = cv::Mat::zeros(gray.rows, gray.cols, CV_8U);
+        int centerX = minX + width / 2;
+        int centerY = minY + height / 2;
+        int radius = std::min(width, height) / 2;
+        cv::circle(mask, cv::Point(centerX, centerY), radius, cv::Scalar(255), -1);
+
+        cv::Scalar mean = cv::mean(gray, mask);
+        BOOL isBright = mean[0] > threshold;
+
+        resolve(@(isBright));
+    } @catch (NSException *exception) {
+        resolve(@NO);
+    }
+}
+
+RCT_EXPORT_METHOD(isRectangularRegionBright:(NSString *)base64Image
+                  minX:(NSInteger)minX
+                  minY:(NSInteger)minY
+                  width:(NSInteger)width
+                  height:(NSInteger)height
+                  threshold:(double)threshold
+                  resolver:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject) {
+    @try {
+        UIImage *image = [self base64ToImage:base64Image];
+        if (!image) {
+            resolve(@NO);
+            return;
+        }
+
+        cv::Mat mat = [self imageToMat:image];
+        if (mat.empty()) {
+            resolve(@NO);
+            return;
+        }
+
+        cv::Mat gray;
+        cv::cvtColor(mat, gray, cv::COLOR_RGB2GRAY);
+
+        // Validate region bounds
+        int x = std::max(0, (int)minX);
+        int y = std::max(0, (int)minY);
+        int w = std::min((int)width, gray.cols - x);
+        int h = std::min((int)height, gray.rows - y);
+
+        if (w <= 0 || h <= 0) {
+            resolve(@NO);
+            return;
+        }
+
+        // Extract ROI (Region of Interest)
+        cv::Rect roi(x, y, w, h);
+        cv::Mat regionMat = gray(roi);
+
+        // Calculate mean brightness within the region
+        cv::Scalar mean = cv::mean(regionMat);
+        BOOL isBright = mean[0] > threshold;
+
+        resolve(@(isBright));
+    } @catch (NSException *exception) {
+        resolve(@NO);
+    }
+}
+
+RCT_EXPORT_METHOD(checkBlurry:(NSString *)base64Image
+                  threshold:(double)threshold
+                  resolver:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject) {
+    @try {
+        UIImage *image = [self base64ToImage:base64Image];
+        if (!image) {
+            resolve(@NO);
+            return;
+        }
+
+        cv::Mat mat = [self imageToMat:image];
+        if (mat.empty()) {
+            resolve(@NO);
+            return;
+        }
+
+        cv::Mat gray;
+        cv::cvtColor(mat, gray, cv::COLOR_RGB2GRAY);
+
+        // Compute Laplacian
+        cv::Mat laplacian;
+        cv::Laplacian(gray, laplacian, CV_64F);
+
+        // Calculate variance
+        cv::Scalar mean, stdDev;
+        cv::meanStdDev(laplacian, mean, stdDev);
+        double variance = stdDev[0] * stdDev[0];
+
+        BOOL isBlurry = variance < threshold;
+        resolve(@(isBlurry));
+    } @catch (NSException *exception) {
+        resolve(@NO);
+    }
+}
+
+RCT_EXPORT_METHOD(checkBlurryInRegion:(NSString *)base64Image
+                  centerXPercent:(double)centerXPercent
+                  centerYPercent:(double)centerYPercent
+                  widthPercent:(double)widthPercent
+                  heightPercent:(double)heightPercent
+                  threshold:(double)threshold
+                  resolver:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject) {
+    @try {
+        UIImage *image = [self base64ToImage:base64Image];
+        if (!image) {
+            resolve(@NO);
+            return;
+        }
+
+        cv::Mat mat = [self imageToMat:image];
+        if (mat.empty()) {
+            resolve(@NO);
+            return;
+        }
+
+        int imgWidth = mat.cols;
+        int imgHeight = mat.rows;
+
+        // Calculate region bounds
+        int regionWidth = MAX(1, (int)(imgWidth * widthPercent));
+        int regionHeight = MAX(1, (int)(imgHeight * heightPercent));
+        int regionX = MAX(0, MIN(imgWidth - regionWidth, (int)(imgWidth * centerXPercent - regionWidth / 2)));
+        int regionY = MAX(0, MIN(imgHeight - regionHeight, (int)(imgHeight * centerYPercent - regionHeight / 2)));
+
+        // Extract region of interest
+        cv::Rect roi(regionX, regionY, regionWidth, regionHeight);
+        cv::Mat regionMat = mat(roi);
+
+        cv::Mat gray;
+        cv::cvtColor(regionMat, gray, cv::COLOR_RGB2GRAY);
+
+        // Compute Laplacian
+        cv::Mat laplacian;
+        cv::Laplacian(gray, laplacian, CV_64F);
+
+        // Calculate variance
+        cv::Scalar mean, stdDev;
+        cv::meanStdDev(laplacian, mean, stdDev);
+        double variance = stdDev[0] * stdDev[0];
+
+        BOOL isBlurry = variance < threshold;
+        resolve(@(isBlurry));
+    } @catch (NSException *exception) {
+        resolve(@NO);
+    }
+}
+
+RCT_EXPORT_METHOD(detectCardBounds:(NSString *)base64Image
+                  textBlocks:(NSArray *)textBlocks
+                  faces:(NSArray *)faces
+                  imageWidth:(NSInteger)imageWidth
+                  imageHeight:(NSInteger)imageHeight
+                  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);
+
+        if (filteredElements.count == 0) {
+            NSLog(@"[OpenCVModule] No elements after filtering outliers");
+            resolve(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);
+
+        // 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);
+            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);
+
+        // 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;
+
+        NSLog(@"[OpenCVModule] Card bounds: (%d, %d) %dx%d", cardX, cardY, cardWidth, cardHeight);
+
+        // 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);
+
+        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)
+        }];
+
+        NSDictionary *result = @{
+            @"x": @(cardX),
+            @"y": @(cardY),
+            @"width": @(cardWidth),
+            @"height": @(cardHeight),
+            @"corners": corners,
+            @"angle": @(0.0)  // Rectangular alignment
+        };
+
+        resolve(result);
+    } @catch (NSException *exception) {
+        resolve(nil);
+    }
+}
+
+@end
+