@trustchex/react-native-sdk 1.161.0

package/ios/VisionCameraPlugins/Cropper/Cropper.mm

@@ -0,0 +1,22 @@
+#import <Foundation/Foundation.h>
+#import <VisionCamera/FrameProcessorPlugin.h>
+#import <VisionCamera/FrameProcessorPluginRegistry.h>
+#import <VisionCamera/Frame.h>
+
+#if __has_include("TrustchexSDK/TrustchexSDK-Swift.h")
+#import "TrustchexSDK/TrustchexSDK-Swift.h"
+#else
+#import "TrustchexSDK-Swift.h"
+#endif
+
+@interface VisionCameraCropper (FrameProcessorPluginLoader)
+@end
+
+@implementation VisionCameraCropper (FrameProcessorPluginLoader)
++ (void)load {
+  [FrameProcessorPluginRegistry addFrameProcessorPlugin:@"crop"
+                                        withInitializer:^FrameProcessorPlugin*(VisionCameraProxyHolder* proxy, NSDictionary* options) {
+    return [[VisionCameraCropper alloc] initWithProxy:proxy withOptions:options];
+  }];
+}
+@end

package/ios/VisionCameraPlugins/Cropper/Cropper.swift

@@ -0,0 +1,145 @@
+import Foundation
+import UIKit
+import VisionCamera
+
+@objc(VisionCameraCropper)
+public class VisionCameraCropper: FrameProcessorPlugin {
+  static public var frameTaken: UIImage?
+
+  public override init(proxy: VisionCameraProxyHolder, options: [AnyHashable: Any]! = [:]) {
+    super.init(proxy: proxy, options: options)
+  }
+
+  public override func callback(_ frame: Frame, withArguments arguments: [AnyHashable: Any]?) -> Any
+  {
+    var cropResult: [String: Any] = [:]
+
+    guard let imageBuffer = CMSampleBufferGetImageBuffer(frame.buffer) else {
+      print("Failed to get CVPixelBuffer!")
+      return cropResult
+    }
+
+    let ciImage = CIImage(cvPixelBuffer: imageBuffer)
+
+    guard let cgImage = CIContext().createCGImage(ciImage, from: ciImage.extent) else {
+      print("Failed to create CGImage!")
+      return cropResult
+    }
+
+    var image = UIImage(cgImage: cgImage)
+    var degree: CGFloat = 0.0
+
+    // Handle orientation
+    if frame.orientation == UIImage.Orientation.left {
+      degree = 90.0
+    } else if frame.orientation == UIImage.Orientation.down {
+      degree = 180.0
+    }
+
+    if degree != 0.0 {
+      image = VisionCameraCropper.rotate(image: image, degree: degree)
+    }
+
+    // Handle crop region if provided
+    if let cropRegion = arguments?["cropRegion"] as? [String: Double] {
+      let imgWidth = Double(image.cgImage!.width)
+      let imgHeight = Double(image.cgImage!.height)
+      let left = (cropRegion["left"] ?? 0) / 100.0 * imgWidth
+      let top = (cropRegion["top"] ?? 0) / 100.0 * imgHeight
+      let width = (cropRegion["width"] ?? 100) / 100.0 * imgWidth
+      let height = (cropRegion["height"] ?? 100) / 100.0 * imgHeight
+
+      let cropRect = CGRect(
+        x: left,
+        y: top,
+        width: width,
+        height: height
+      ).integral
+
+      if let cropped = image.cgImage!.cropping(to: cropRect) {
+        image = UIImage(cgImage: cropped)
+      }
+    }
+
+    // Include base64 if requested
+    if let includeImageBase64 = arguments?["includeImageBase64"] as? Bool, includeImageBase64 {
+      cropResult["base64"] = VisionCameraCropper.getBase64FromImage(image)
+    }
+
+    // Save bitmap in memory if requested
+    if let saveBitmap = arguments?["saveBitmap"] as? Bool, saveBitmap {
+      VisionCameraCropper.frameTaken = image
+    }
+
+    // Save as file if requested
+    if let saveAsFile = arguments?["saveAsFile"] as? Bool, saveAsFile {
+      cropResult["path"] = saveImage(image)
+    }
+
+    return cropResult
+  }
+
+  private func saveImage(_ image: UIImage) -> String {
+    let url = FileManager.default.temporaryDirectory
+      .appendingPathComponent(UUID().uuidString)
+      .appendingPathExtension("jpeg")
+
+    do {
+      try image.jpegData(compressionQuality: 1.0)?.write(to: url)
+      return url.path
+    } catch {
+      print("Error saving image: \(error)")
+      return ""
+    }
+  }
+
+  @objc static func getBitmap() -> UIImage? {
+    return frameTaken
+  }
+
+  // MARK: - Utility Methods
+
+  public static func rotate(image: UIImage, degree: CGFloat) -> UIImage {
+    let radians = degree / (180.0 / .pi)
+    let rotatedSize = CGRect(origin: .zero, size: image.size)
+      .applying(CGAffineTransform(rotationAngle: CGFloat(radians)))
+      .integral.size
+
+    UIGraphicsBeginImageContext(rotatedSize)
+
+    if let context = UIGraphicsGetCurrentContext() {
+      let origin = CGPoint(
+        x: rotatedSize.width / 2.0,
+        y: rotatedSize.height / 2.0)
+      context.translateBy(x: origin.x, y: origin.y)
+      context.rotate(by: radians)
+      image.draw(
+        in: CGRect(
+          x: -origin.y, y: -origin.x,
+          width: image.size.width, height: image.size.height))
+      let rotatedImage = UIGraphicsGetImageFromCurrentImageContext()
+      UIGraphicsEndImageContext()
+
+      return rotatedImage ?? image
+    }
+
+    return image
+  }
+
+  public static func getBase64FromImage(_ image: UIImage) -> String {
+    let dataTmp = image.jpegData(compressionQuality: 1.0)
+    if let data = dataTmp {
+      return data.base64EncodedString()
+    }
+    return ""
+  }
+
+  public static func convertBase64ToImage(_ imageStr: String) -> UIImage? {
+    if let data = Data(base64Encoded: imageStr, options: .ignoreUnknownCharacters) {
+      if let image = UIImage(data: data) {
+        return image
+      }
+    }
+    return nil
+  }
+}

package/ios/VisionCameraPlugins/Cropper/CropperUtils.swift

@@ -0,0 +1,49 @@
+import Foundation
+import UIKit
+
+public class VisionCameraCropperUtils {
+
+  public static func rotate(image: UIImage, degree: CGFloat) -> UIImage {
+    let radians = degree / (180.0 / .pi)
+    let rotatedSize = CGRect(origin: .zero, size: image.size)
+      .applying(CGAffineTransform(rotationAngle: CGFloat(radians)))
+      .integral.size
+
+    UIGraphicsBeginImageContext(rotatedSize)
+
+    if let context = UIGraphicsGetCurrentContext() {
+      let origin = CGPoint(
+        x: rotatedSize.width / 2.0,
+        y: rotatedSize.height / 2.0)
+      context.translateBy(x: origin.x, y: origin.y)
+      context.rotate(by: radians)
+      image.draw(
+        in: CGRect(
+          x: -origin.y, y: -origin.x,
+          width: image.size.width, height: image.size.height))
+      let rotatedImage = UIGraphicsGetImageFromCurrentImageContext()
+      UIGraphicsEndImageContext()
+
+      return rotatedImage ?? image
+    }
+
+    return image
+  }
+
+  public static func getBase64FromImage(_ image: UIImage) -> String {
+    let dataTmp = image.jpegData(compressionQuality: 1.0)
+    if let data = dataTmp {
+      return data.base64EncodedString()
+    }
+    return ""
+  }
+
+  public static func convertBase64ToImage(_ imageStr: String) -> UIImage? {
+    if let data = Data(base64Encoded: imageStr, options: .ignoreUnknownCharacters) {
+      if let image = UIImage(data: data) {
+        return image
+      }
+    }
+    return nil
+  }
+}

package/ios/VisionCameraPlugins/FaceDetector/FaceDetectorFrameProcessorPlugin-Bridging-Header.h

@@ -0,0 +1,4 @@
+#if VISION_CAMERA_ENABLE_FRAME_PROCESSORS
+#import <VisionCamera/FrameProcessorPlugin.h>
+#import <VisionCamera/Frame.h>
+#endif

package/ios/VisionCameraPlugins/FaceDetector/FaceDetectorFrameProcessorPlugin.mm

@@ -0,0 +1,22 @@
+#import <Foundation/Foundation.h>
+#import <VisionCamera/FrameProcessorPlugin.h>
+#import <VisionCamera/FrameProcessorPluginRegistry.h>
+#import <VisionCamera/Frame.h>
+
+#if __has_include("TrustchexSDK/TrustchexSDK-Swift.h")
+#import "TrustchexSDK/TrustchexSDK-Swift.h"
+#else
+#import "TrustchexSDK-Swift.h"
+#endif
+
+@interface FaceDetectorFrameProcessorPlugin (FrameProcessorPluginLoader)
+@end
+
+@implementation FaceDetectorFrameProcessorPlugin (FrameProcessorPluginLoader)
++ (void)load {
+  [FrameProcessorPluginRegistry addFrameProcessorPlugin:@"detectFaces"
+                                        withInitializer:^FrameProcessorPlugin*(VisionCameraProxyHolder* proxy, NSDictionary* options) {
+    return [[FaceDetectorFrameProcessorPlugin alloc] initWithProxy:proxy withOptions:options];
+  }];
+}
+@end

package/ios/VisionCameraPlugins/FaceDetector/FaceDetectorFrameProcessorPlugin.swift

@@ -0,0 +1,320 @@
+import Foundation
+import VisionCamera
+import MLKitVision
+import MLKitFaceDetection
+import MLKitCommon
+import CoreML
+import UIKit
+import AVFoundation
+import SceneKit
+
+@objc(FaceDetectorFrameProcessorPlugin)
+public class FaceDetectorFrameProcessorPlugin: FrameProcessorPlugin {
+    // detection props
+    private var autoScale = false
+    private var faceDetector: FaceDetector! = nil
+    private var runLandmarks = false
+    private var runClassifications = false
+    private var runContours = false
+    private var trackingEnabled = false
+    private var windowWidth = 1.0
+    private var windowHeight = 1.0
+
+    public override init(proxy: VisionCameraProxyHolder, options: [AnyHashable: Any]! = [:]) {
+        super.init(proxy: proxy, options: options)
+        let config = getConfig(withArguments: options)
+
+        let windowWidthParam = config?["windowWidth"] as? Double
+        if windowWidthParam != nil && windowWidthParam != windowWidth {
+            windowWidth = CGFloat(windowWidthParam!)
+        }
+
+        let windowHeightParam = config?["windowHeight"] as? Double
+        if windowHeightParam != nil && windowHeightParam != windowHeight {
+            windowHeight = CGFloat(windowHeightParam!)
+        }
+
+        // handle auto scaling
+        autoScale = config?["autoScale"] as? Bool == true
+
+        // initializes faceDetector on creation
+        let minFaceSize = 0.15
+        let optionsBuilder = FaceDetectorOptions()
+        optionsBuilder.performanceMode = .fast
+        optionsBuilder.landmarkMode = .none
+        optionsBuilder.contourMode = .none
+        optionsBuilder.classificationMode = .none
+        optionsBuilder.minFaceSize = CGFloat(minFaceSize)
+        optionsBuilder.isTrackingEnabled = false
+
+        if config?["performanceMode"] as? String == "accurate" {
+            optionsBuilder.performanceMode = .accurate
+        }
+
+        if config?["landmarkMode"] as? String == "all" {
+            runLandmarks = true
+            optionsBuilder.landmarkMode = .all
+        }
+
+        if config?["classificationMode"] as? String == "all" {
+            runClassifications = true
+            optionsBuilder.classificationMode = .all
+        }
+
+        if config?["contourMode"] as? String == "all" {
+            runContours = true
+            optionsBuilder.contourMode = .all
+        }
+
+        let minFaceSizeParam = config?["minFaceSize"] as? Double
+        if minFaceSizeParam != nil && minFaceSizeParam != minFaceSize {
+            optionsBuilder.minFaceSize = CGFloat(minFaceSizeParam!)
+        }
+
+        if config?["trackingEnabled"] as? Bool == true {
+            trackingEnabled = true
+            optionsBuilder.isTrackingEnabled = true
+        }
+
+        faceDetector = FaceDetector.faceDetector(options: optionsBuilder)
+    }
+
+    func getConfig(withArguments arguments: [AnyHashable: Any]!) -> [String: Any]! {
+        if arguments.count > 0 {
+            let config = arguments.map { dictionary in
+                Dictionary(uniqueKeysWithValues: dictionary.map { (key, value) in
+                    (key as? String ?? "", value)
+                })
+            }
+            return config
+        }
+        return nil
+    }
+
+    func processBoundingBox(
+        from face: Face,
+        sourceWidth: CGFloat,
+        sourceHeight: CGFloat,
+        orientation: UIImage.Orientation,
+        scaleX: CGFloat,
+        scaleY: CGFloat
+    ) -> [String: Any] {
+        let boundingBox = face.frame
+        let width = boundingBox.width * scaleX
+        let height = boundingBox.height * scaleY
+        let x = boundingBox.origin.y * scaleX
+        let y = boundingBox.origin.x * scaleY
+
+        let bounds = [
+            "width": width,
+            "height": height,
+            "x": (-x + sourceWidth * scaleX) - width,
+            "y": y
+        ]
+
+        // Debug log the processed bounds
+        print("FaceDetector iOS: Processed bounds - x: \(bounds["x"] ?? 0), y: \(bounds["y"] ?? 0), width: \(bounds["width"] ?? 0), height: \(bounds["height"] ?? 0)")
+        print("FaceDetector iOS: Original bounds - x: \(boundingBox.origin.x), y: \(boundingBox.origin.y), width: \(boundingBox.width), height: \(boundingBox.height)")
+        print("FaceDetector iOS: Source dimensions - width: \(sourceWidth), height: \(sourceHeight), orientation: \(orientation)")
+
+        return bounds
+    }
+
+    func processLandmarks(
+        from face: Face,
+        scaleX: CGFloat,
+        scaleY: CGFloat
+    ) -> [String: [String: CGFloat?]] {
+        let faceLandmarkTypes = [
+            FaceLandmarkType.leftCheek,
+            FaceLandmarkType.leftEar,
+            FaceLandmarkType.leftEye,
+            FaceLandmarkType.mouthBottom,
+            FaceLandmarkType.mouthLeft,
+            FaceLandmarkType.mouthRight,
+            FaceLandmarkType.noseBase,
+            FaceLandmarkType.rightCheek,
+            FaceLandmarkType.rightEar,
+            FaceLandmarkType.rightEye
+        ]
+
+        let faceLandmarksTypesStrings = [
+            "LEFT_CHEEK",
+            "LEFT_EAR",
+            "LEFT_EYE",
+            "MOUTH_BOTTOM",
+            "MOUTH_LEFT",
+            "MOUTH_RIGHT",
+            "NOSE_BASE",
+            "RIGHT_CHEEK",
+            "RIGHT_EAR",
+            "RIGHT_EYE"
+        ]
+
+        var faceLandMarksTypesMap: [String: [String: CGFloat?]] = [:]
+        for i in 0..<faceLandmarkTypes.count {
+            let landmark = face.landmark(ofType: faceLandmarkTypes[i])
+            let position = [
+                "x": (landmark?.position.x ?? 0.0) * scaleX,
+                "y": (landmark?.position.y ?? 0.0) * scaleY
+            ]
+            faceLandMarksTypesMap[faceLandmarksTypesStrings[i]] = position
+        }
+
+        return faceLandMarksTypesMap
+    }
+
+    func processFaceContours(
+        from face: Face,
+        scaleX: CGFloat,
+        scaleY: CGFloat
+    ) -> [String: [[String: CGFloat]]] {
+        let faceContoursTypes = [
+            FaceContourType.face,
+            FaceContourType.leftCheek,
+            FaceContourType.leftEye,
+            FaceContourType.leftEyebrowBottom,
+            FaceContourType.leftEyebrowTop,
+            FaceContourType.lowerLipBottom,
+            FaceContourType.lowerLipTop,
+            FaceContourType.noseBottom,
+            FaceContourType.noseBridge,
+            FaceContourType.rightCheek,
+            FaceContourType.rightEye,
+            FaceContourType.rightEyebrowBottom,
+            FaceContourType.rightEyebrowTop,
+            FaceContourType.upperLipBottom,
+            FaceContourType.upperLipTop
+        ]
+
+        let faceContoursTypesStrings = [
+            "FACE",
+            "LEFT_CHEEK",
+            "LEFT_EYE",
+            "LEFT_EYEBROW_BOTTOM",
+            "LEFT_EYEBROW_TOP",
+            "LOWER_LIP_BOTTOM",
+            "LOWER_LIP_TOP",
+            "NOSE_BOTTOM",
+            "NOSE_BRIDGE",
+            "RIGHT_CHEEK",
+            "RIGHT_EYE",
+            "RIGHT_EYEBROW_BOTTOM",
+            "RIGHT_EYEBROW_TOP",
+            "UPPER_LIP_BOTTOM",
+            "UPPER_LIP_TOP"
+        ]
+
+        var faceContoursTypesMap: [String: [[String: CGFloat]]] = [:]
+        for i in 0..<faceContoursTypes.count {
+            let contour = face.contour(ofType: faceContoursTypes[i])
+            var pointsArray: [[String: CGFloat]] = []
+
+            if let points = contour?.points {
+                for point in points {
+                    let currentPointsMap = [
+                        "x": point.x * scaleX,
+                        "y": point.y * scaleY,
+                    ]
+                    pointsArray.append(currentPointsMap)
+                }
+                faceContoursTypesMap[faceContoursTypesStrings[i]] = pointsArray
+            }
+        }
+
+        return faceContoursTypesMap
+    }
+
+    func getOrientation(orientation: UIImage.Orientation) -> UIImage.Orientation {
+        switch orientation {
+        case .up:
+            // device is landscape left
+            return .up
+        case .left:
+            // device is portrait
+            return .right
+        case .down:
+            // device is landscape right
+            return .down
+        case .right:
+            // device is upside-down
+            return .left
+        default:
+            return .up
+        }
+    }
+
+    public override func callback(_ frame: Frame, withArguments arguments: [AnyHashable: Any]?) -> Any {
+        var result: [Any] = []
+
+        do {
+            // we need to invert sizes as frame is always -90deg rotated
+            let width = CGFloat(frame.height)
+            let height = CGFloat(frame.width)
+            let orientation = getOrientation(orientation: frame.orientation)
+            let image = VisionImage(buffer: frame.buffer)
+            image.orientation = orientation
+
+            var scaleX: CGFloat
+            var scaleY: CGFloat
+            if autoScale {
+                scaleX = windowWidth / width
+                scaleY = windowHeight / height
+            } else {
+                scaleX = CGFloat(1)
+                scaleY = CGFloat(1)
+            }
+
+            let faces: [Face] = try faceDetector!.results(in: image)
+            print("FaceDetector: Detected \(faces.count) faces")
+
+            for face in faces {
+                var map: [String: Any] = [:]
+
+                if runLandmarks {
+                    map["landmarks"] = processLandmarks(
+                        from: face,
+                        scaleX: scaleX,
+                        scaleY: scaleY
+                    )
+                }
+
+                if runClassifications {
+                    map["leftEyeOpenProbability"] = face.leftEyeOpenProbability
+                    map["rightEyeOpenProbability"] = face.rightEyeOpenProbability
+                    map["smilingProbability"] = face.smilingProbability
+                }
+
+                if runContours {
+                    map["contours"] = processFaceContours(
+                        from: face,
+                        scaleX: scaleX,
+                        scaleY: scaleY
+                    )
+                }
+
+                if trackingEnabled {
+                    map["trackingId"] = face.trackingID
+                }
+
+                map["rollAngle"] = face.headEulerAngleZ
+                map["pitchAngle"] = face.headEulerAngleX
+                map["yawAngle"] = face.headEulerAngleY
+                map["bounds"] = processBoundingBox(
+                    from: face,
+                    sourceWidth: width,
+                    sourceHeight: height,
+                    orientation: frame.orientation,
+                    scaleX: scaleX,
+                    scaleY: scaleY
+                )
+
+                result.append(map)
+            }
+        } catch let error {
+            print("FaceDetector: Error processing face detection: \(error)")
+        }
+
+        return result
+    }
+}

package/ios/VisionCameraPlugins/TextRecognition/TextRecognitionFrameProcessorPlugin-Bridging-Header.h

@@ -0,0 +1,4 @@
+#if VISION_CAMERA_ENABLE_FRAME_PROCESSORS
+#import <VisionCamera/FrameProcessorPlugin.h>
+#import <VisionCamera/Frame.h>
+#endif

package/ios/VisionCameraPlugins/TextRecognition/TextRecognitionFrameProcessorPlugin.mm

@@ -0,0 +1,27 @@
+#import <Foundation/Foundation.h>
+#import <VisionCamera/FrameProcessorPlugin.h>
+#import <VisionCamera/FrameProcessorPluginRegistry.h>
+#import <VisionCamera/Frame.h>
+
+
+#if __has_include("TrustchexSDK/TrustchexSDK-Swift.h")
+#import "TrustchexSDK/TrustchexSDK-Swift.h"
+#else
+#import "TrustchexSDK-Swift.h"
+#endif
+
+@interface TextRecognitionFrameProcessorPlugin (FrameProcessorPluginLoader)
+@end
+
+@implementation TextRecognitionFrameProcessorPlugin (FrameProcessorPluginLoader)
++ (void) load {
+  [FrameProcessorPluginRegistry addFrameProcessorPlugin:@"scanText"
+    withInitializer:^FrameProcessorPlugin*(VisionCameraProxyHolder* proxy, NSDictionary* options) {
+    return [[TextRecognitionFrameProcessorPlugin alloc] initWithProxy:proxy withOptions:options];
+  }];
+}
+@end
+
+
+
+