@trustchex/react-native-sdk 1.360.0 → 1.362.0

package/ios/Camera/TrustchexCameraView.swift

@@ -45,9 +45,8 @@ class TrustchexCameraView: UIView {
     @objc var enableFaceDetection: Bool = false
     @objc var enableTextRecognition: Bool = false
     @objc var enableBarcodeScanning: Bool = false
-    @objc var enableMrzValidation: Bool = false
     @objc var includeBase64: Bool = false
-    @objc var targetFps: NSNumber = 6 {
+    @objc var targetFps: NSNumber = 10 {
         didSet {
             _targetFps = max(1, min(30, targetFps.int32Value))
         }
@@ -56,7 +55,7 @@ class TrustchexCameraView: UIView {
     private var _cameraType: String = "back"
     private var _torchEnabled = false
     private var _frameProcessingEnabled = false
-    private var _targetFps: Int32 = 6
+    private var _targetFps: Int32 = 10
     private var lastFrameTime: TimeInterval = 0
     private var isProcessing = false
     private var isRecording = false
@@ -122,25 +121,19 @@ class TrustchexCameraView: UIView {
             // Front camera: Use Full HD for high-quality liveness detection
             if session.canSetSessionPreset(.hd1920x1080) {
                 session.sessionPreset = .hd1920x1080
-                print("[TrustchexCamera] Front camera: Using Full HD 1920x1080")
             } else if session.canSetSessionPreset(.hd1280x720) {
                 session.sessionPreset = .hd1280x720
-                print("[TrustchexCamera] Front camera: Fallback to HD 1280x720")
             } else {
                 session.sessionPreset = .high
-                print("[TrustchexCamera] Front camera: Using high preset")
             }
         } else {
             // Back camera: Use Full HD for document scanning
             if session.canSetSessionPreset(.hd1920x1080) {
                 session.sessionPreset = .hd1920x1080
-                print("[TrustchexCamera] Back camera: Using Full HD 1920x1080")
             } else if session.canSetSessionPreset(.hd1280x720) {
                 session.sessionPreset = .hd1280x720
-                print("[TrustchexCamera] Back camera: Fallback to HD 1280x720")
             } else {
                 session.sessionPreset = .high
-                print("[TrustchexCamera] Back camera: Using high preset")
             }
         }
         let camera = selectBestCamera(for: cameraPosition)
@@ -203,13 +196,17 @@ class TrustchexCameraView: UIView {
             if supportedTypes.contains(.qr) { typesToEnable.append(.qr) }
             if supportedTypes.contains(.code128) { typesToEnable.append(.code128) }
             if supportedTypes.contains(.code39) { typesToEnable.append(.code39) }
+            if supportedTypes.contains(.code39Mod43) { typesToEnable.append(.code39Mod43) }
+            if supportedTypes.contains(.code93) { typesToEnable.append(.code93) }
             if supportedTypes.contains(.ean13) { typesToEnable.append(.ean13) }
             if supportedTypes.contains(.ean8) { typesToEnable.append(.ean8) }
+            if supportedTypes.contains(.upce) { typesToEnable.append(.upce) }
+            if supportedTypes.contains(.interleaved2of5) { typesToEnable.append(.interleaved2of5) }
+            if supportedTypes.contains(.itf14) { typesToEnable.append(.itf14) }
             if supportedTypes.contains(.aztec) { typesToEnable.append(.aztec) }
             if supportedTypes.contains(.dataMatrix) { typesToEnable.append(.dataMatrix) }
 
             metadataOutput.metadataObjectTypes = typesToEnable
-            print("[TrustchexCamera] Native barcode scanner enabled with types: \(typesToEnable)")
         }
         self.metadataOutput = metadataOutput
 
@@ -253,19 +250,16 @@ class TrustchexCameraView: UIView {
         // For document scanning, prefer wide angle camera for all models
         // This provides consistent behavior across iPhone 15, 15 Pro, and other devices
         if let wideAngleCamera = AVCaptureDevice.default(.builtInWideAngleCamera, for: .video, position: .back) {
-            print("[TrustchexCamera] Selected Wide Angle camera for document scanning")
             return wideAngleCamera
         }
 
         // Fallback: Try dual camera
         if let dualCamera = AVCaptureDevice.default(.builtInDualCamera, for: .video, position: .back) {
-            print("[TrustchexCamera] Selected Dual Camera for document scanning")
             return dualCamera
         }
 
         // Fallback: Try triple camera
         if let tripleCamera = AVCaptureDevice.default(.builtInTripleCamera, for: .video, position: .back) {
-            print("[TrustchexCamera] Selected Triple Camera for document scanning")
             return tripleCamera
         }
 
@@ -350,7 +344,7 @@ class TrustchexCameraView: UIView {
 
             camera.unlockForConfiguration()
         } catch {
-            print("Failed to configure camera: \(error)")
+            // Failed to configure camera
         }
     }
 
@@ -382,7 +376,7 @@ class TrustchexCameraView: UIView {
                 }
                 camera.unlockForConfiguration()
             } catch {
-                print("Failed to set torch: \(error)")
+                // Failed to set torch
             }
         }
     }
@@ -415,10 +409,6 @@ class TrustchexCameraView: UIView {
         enableBarcodeScanning = enabled
     }
 
-    func setEnableMrzValidation(_ enabled: Bool) {
-        enableMrzValidation = enabled
-    }
-
     func setIncludeBase64(_ enabled: Bool) {
         includeBase64 = enabled
     }
@@ -452,7 +442,7 @@ class TrustchexCameraView: UIView {
 
                 camera.unlockForConfiguration()
             } catch {
-                print("Failed to set focus point: \(error)")
+                // Failed to set focus point
             }
         }
     }
@@ -468,7 +458,7 @@ class TrustchexCameraView: UIView {
                 camera.setExposureTargetBias(bias, completionHandler: nil)
                 camera.unlockForConfiguration()
             } catch {
-                print("Failed to set exposure: \(error)")
+                // Failed to set exposure
             }
         }
     }
@@ -544,7 +534,6 @@ class TrustchexCameraView: UIView {
             // Check both our flag and the actual AVFoundation state
             guard self.isRecording || movieOutput.isRecording else { return }
 
-            print("[TrustchexCameraView] *** cancelRecording: marking as cancelled ***")
             self.isCancelledRecording = true
             movieOutput.stopRecording()
             // Do NOT set isRecording = false here — let the delegate handle it
@@ -558,10 +547,9 @@ class TrustchexCameraView: UIView {
                 let fileURL = URL(fileURLWithPath: filePath)
                 if FileManager.default.fileExists(atPath: filePath) {
                     try FileManager.default.removeItem(at: fileURL)
-                    print("[TrustchexCameraView] Successfully deleted recording at: \(filePath)")
                 }
             } catch {
-                print("[TrustchexCameraView] Failed to delete recording: \(error.localizedDescription)")
+                // Failed to delete recording
             }
         }
     }
@@ -614,7 +602,6 @@ class TrustchexCameraView: UIView {
 
         finishFallbackWorkItem = workItem
         DispatchQueue.main.asyncAfter(deadline: .now() + 0.5, execute: workItem)
-        print("[TrustchexCameraView] *** Fallback check scheduled for 0.5s from now ***")
     }
 
     private func switchCamera(to type: String) {
@@ -742,9 +729,6 @@ extension TrustchexCameraView: AVCaptureVideoDataOutputSampleBufferDelegate {
         
         let isBufferLandscape = pixelWidth > pixelHeight
 
-        // Log VisionImage metadata to understand coordinate space
-        NSLog("[VisionImage] Buffer: \(pixelWidth)x\(pixelHeight) | Orientation: \(isBufferLandscape ? "landscape→portrait (.right)" : "portrait (.up)") | Will report as: \(portraitWidth)x\(portraitHeight)")
-
         // Create oriented CIImage for ML Kit processing
         let ciImage = CIImage(cvPixelBuffer: pixelBuffer)
         let orientedImage = isBufferLandscape ? ciImage.oriented(.right) : ciImage
@@ -757,6 +741,9 @@ extension TrustchexCameraView: AVCaptureVideoDataOutputSampleBufferDelegate {
         }
         let visionImage = VisionImage(image: UIImage(cgImage: cgImage))
         visionImage.orientation = .up  // Already oriented correctly
+        
+        // Use original image for text recognition
+        let textVisionImage = visionImage
 
         // Generate JPEG base64 only when JS side explicitly needs the image
         // NOTE: Do NOT auto-generate for face detection - too expensive, causes frame drops
@@ -818,10 +805,9 @@ extension TrustchexCameraView: AVCaptureVideoDataOutputSampleBufferDelegate {
         let textSemaphore = DispatchSemaphore(value: 0)
         var resultText = ""
         if enableTextRecognition {
-            textRecognizer.process(visionImage) { text, error in
+            textRecognizer.process(textVisionImage) { text, error in
                 if let text = text {
                     resultText = text.text
-                    NSLog("[Text Recognition] Found \(text.blocks.count) blocks | Buffer: \(pixelWidth)x\(pixelHeight) | Portrait: \(portraitWidth)x\(portraitHeight) | Landscape: \(isBufferLandscape)")
                     for block in text.blocks {
                         var blockMap: [String: Any] = ["text": block.text]
                         let bb = block.frame
@@ -845,14 +831,12 @@ extension TrustchexCameraView: AVCaptureVideoDataOutputSampleBufferDelegate {
                             blockY = pixelWidth - Int(bb.origin.x) - Int(bb.width)
                             blockWidth = Int(bb.height)
                             blockHeight = Int(bb.width)
-                            NSLog("[Text Block] '\(block.text.prefix(8))...' | ROTATED: landscape(\(Int(bb.origin.x)),\(Int(bb.origin.y)),\(Int(bb.width)),\(Int(bb.height))) → portrait(x:\(blockX) y:\(blockY) w:\(blockWidth) h:\(blockHeight))")
                         } else {
                             // Already portrait, use directly
                             blockX = Int(bb.origin.x)
                             blockY = Int(bb.origin.y)
                             blockWidth = Int(bb.width)
                             blockHeight = Int(bb.height)
-                            NSLog("[Text Block] '\(block.text.prefix(8))...' | DIRECT: x:\(blockX) y:\(blockY) w:\(blockWidth) h:\(blockHeight)")
                         }
                         
                         blockMap["blockFrame"] = [
@@ -887,13 +871,6 @@ extension TrustchexCameraView: AVCaptureVideoDataOutputSampleBufferDelegate {
         _ = semaphore.wait(timeout: .now() + 2.0)
         _ = textSemaphore.wait(timeout: .now() + 2.0)
 
-        // MRZ validation (if enabled and text was recognized)
-        var mrzResultDict: [String: Any]? = nil
-        if enableMrzValidation && enableTextRecognition && !resultText.isEmpty {
-            let mrzResult = MRZValidator().validateWithCorrections(resultText)
-            mrzResultDict = mrzResult.toDictionary()
-        }
-
         // Only compute brightness if we haven't timed out or crashed
         // Brightness calculation restricted to scanning frame area (between 36% from top and 36% from bottom, 5% margins on sides)
         let brightness = computeBrightness(from: pixelBuffer, width: portraitWidth, height: portraitHeight)
@@ -921,9 +898,6 @@ extension TrustchexCameraView: AVCaptureVideoDataOutputSampleBufferDelegate {
         if enableBarcodeScanning {
             frameData["barcodes"] = barcodesArray
         }
-        if let mrzDict = mrzResultDict {
-            frameData["mrzResult"] = mrzDict
-        }
 
         DispatchQueue.main.async { [weak self] in
             self?.onFrameAvailable?(["frame": frameData])
@@ -1013,7 +987,6 @@ extension TrustchexCameraView: AVCaptureFileOutputRecordingDelegate {
 
         // If recording was cancelled, clean up the temp file and don't send any callback
         if wasCancelled {
-            print("[TrustchexCameraView] *** Recording was cancelled, cleaning up temp file ***")
             try? FileManager.default.removeItem(at: outputFileURL)
             return
         }
@@ -1110,7 +1083,6 @@ extension TrustchexCameraView: AVCaptureMetadataOutputObjectsDelegate {
             }
 
             let valuePreview = String(stringValue.prefix(50))
-            NSLog("[Native Barcode] ✓ FAST DETECTION: \(formatName) - \(valuePreview)")
 
             var barcodeMap: [String: Any] = [
                 "rawValue": stringValue,
@@ -1139,9 +1111,6 @@ extension TrustchexCameraView: AVCaptureMetadataOutputObjectsDelegate {
             let portraitRight = Int((1.0 - bounds.minY) * CGFloat(frameWidth))
             let portraitBottom = Int(bounds.maxX * CGFloat(frameHeight))
 
-            NSLog("[Native Barcode] Normalized bounds: (%.3f, %.3f) to (%.3f, %.3f)", bounds.minX, bounds.minY, bounds.maxX, bounds.maxY)
-            NSLog("[Native Barcode] Frame: \(frameWidth)x\(frameHeight), Portrait coords: (\(portraitLeft), \(portraitTop)) to (\(portraitRight), \(portraitBottom))")
-
             barcodeMap["boundingBox"] = [
                 "left": portraitLeft,
                 "top": portraitTop,

package/ios/OpenCV/OpenCVHelper.h

@@ -0,0 +1,17 @@
+#import <Foundation/Foundation.h>
+#import <UIKit/UIKit.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+@interface OpenCVHelper : NSObject
+
+/// Preprocesses an image for better OCR text recognition
+/// Applies bilateral filtering, CLAHE, and sharpening to enhance text clarity
+/// @param image The input UIImage to preprocess
+/// @param applyThresholding Whether to apply adaptive thresholding (for binary output)
+/// @return A preprocessed UIImage optimized for text recognition, or nil if preprocessing fails
++ (UIImage * _Nullable)preprocessImageForOCR:(UIImage *)image applyThresholding:(BOOL)applyThresholding;
+
+@end
+
+NS_ASSUME_NONNULL_END

package/ios/OpenCV/OpenCVHelper.mm

@@ -0,0 +1,128 @@
+#import "OpenCVHelper.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 OpenCVHelper
+
+// 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;
+}
+
++ (UIImage *)preprocessImageForOCR:(UIImage *)image applyThresholding:(BOOL)applyThresholding {
+    @try {
+        if (!image) return nil;
+
+        cv::Mat mat = [self imageToMat:image];
+        if (mat.empty()) return nil;
+
+        // Step 1: Convert to grayscale
+        cv::Mat gray;
+        cv::cvtColor(mat, gray, cv::COLOR_RGB2GRAY);
+        mat.release();
+
+        // Step 2: Suppress background using blackhat morphology
+        cv::Mat blackhat;
+        cv::Mat kernel = cv::getStructuringElement(cv::MORPH_RECT, cv::Size(15, 5));
+        cv::morphologyEx(gray, blackhat, cv::MORPH_BLACKHAT, kernel);
+        gray.release();
+
+        // Step 3: Advanced denoising - removes artifacts while keeping character details
+        cv::Mat denoised;
+        cv::fastNlMeansDenoising(blackhat, denoised, 6.0, 7, 21);
+        blackhat.release();
+
+        // Step 4: CLAHE for local contrast without over-amplifying noise
+        cv::Ptr<cv::CLAHE> clahe = cv::createCLAHE(2.0, cv::Size(8, 8));
+        cv::Mat enhanced;
+        clahe->apply(denoised, enhanced);
+        denoised.release();
+
+        // Step 5: Unsharp masking for clearer edges without halos
+        cv::Mat blurred;
+        cv::GaussianBlur(enhanced, blurred, cv::Size(0, 0), 1.2);
+        cv::Mat sharpened;
+        cv::addWeighted(enhanced, 1.8, blurred, -0.8, 0, sharpened);
+        blurred.release();
+        enhanced.release();
+
+        // Step 6: Normalize to full 0-255 range
+        // Ensures maximum contrast for ML Kit
+        cv::Mat result;
+        cv::normalize(sharpened, result, 0, 255, cv::NORM_MINMAX);
+        sharpened.release();
+
+        if (applyThresholding) {
+            cv::Mat thresholded;
+            cv::adaptiveThreshold(result, thresholded, 255, cv::ADAPTIVE_THRESH_GAUSSIAN_C, cv::THRESH_BINARY, 31, 10);
+            result.release();
+            result = thresholded;
+        }
+
+        UIImage *resultImage = [self matToImage:result];
+        result.release();
+
+        return resultImage;
+    } @catch (NSException *exception) {
+        NSLog(@"OpenCV preprocessing error: %@", exception.reason);
+        return nil;
+    }
+}
+
+@end

package/ios/OpenCV/OpenCVModule.h

@@ -1,4 +1,10 @@
 #import <React/RCTBridgeModule.h>
+#import <UIKit/UIKit.h>
 
 @interface OpenCVModule : NSObject <RCTBridgeModule>
+
+// Synchronous method for preprocessingimage for OCR
+// This is called directly from Swift camera code for better performance
+- (UIImage * _Nullable)preprocessImageForOCRSync:(UIImage * _Nonnull)image applyThresholding:(BOOL)applyThresholding;
+
 @end

package/ios/OpenCV/OpenCVModule.mm

@@ -805,6 +805,147 @@ RCT_EXPORT_METHOD(detectCardBounds:(NSString *)base64Image
         resolve(nil);
     }
 }
+// Preprocess image for better OCR text recognition using OpenCV
+RCT_EXPORT_METHOD(preprocessImageForOCR:(NSString *)base64Image
+                  applyThresholding:(BOOL)applyThresholding
+                  resolver:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject) {
+    @try {
+        UIImage *image = [self base64ToImage:base64Image];
+        if (!image) {
+            reject(@"DECODE_ERROR", @"Failed to decode image", nil);
+            return;
+        }
+
+        cv::Mat mat = [self imageToMat:image];
+        if (mat.empty()) {
+            reject(@"MAT_ERROR", @"Failed to convert image to Mat", 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);
+            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);
+    }
+}
+
+// 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;
+    } @catch (NSException *exception) {
+        NSLog(@"OpenCV preprocessing error: %@", exception.reason);
+        return nil;
+    }
+}
 
 @end
 

package/ios/TrustchexSDK-Bridging-Header.h

@@ -0,0 +1,8 @@
+//
+//  TrustchexSDK-Bridging-Header.h
+//  TrustchexSDK
+//
+//  Bridging header to expose Objective-C/C++ classes to Swift
+//
+
+#import "OpenCVHelper.h"