replate-camera 0.4.0 → 0.5.0

package/ios/ReplateCameraViewManager.swift

@@ -1255,49 +1255,59 @@ class ReplateCameraController: NSObject {
         return context.createCGImage(ciImage, from: ciImage.extent)
     }
 
-    func saveImageAsJPEG(_ image: UIImage) -> URL? {
-        let cameraTransform = getCameraTransformString(from: ReplateCameraView.arView.session)
-
-        guard let imageData = image.jpegData(compressionQuality: 1),
-              let source = CGImageSourceCreateWithData(imageData as CFData, nil) else {
-            return nil
-        }
-
-        let temporaryDirectoryURL = URL(fileURLWithPath: NSTemporaryDirectory(), isDirectory: true)
-        let uniqueFilename = "image_\(Date().timeIntervalSince1970).jpg"
-        let fileURL = temporaryDirectoryURL.appendingPathComponent(uniqueFilename)
-
-        guard let imageProperties = CGImageSourceCopyPropertiesAtIndex(source, 0, nil) as? [CFString: Any] else {
-            return nil
-        }
-
-        var mutableMetadata = imageProperties
-        mutableMetadata[kCGImagePropertyExifDictionary] = [
-            kCGImagePropertyExifUserComment: cameraTransform
-        ]
-
-        guard let destination = CGImageDestinationCreateWithURL(
-            fileURL as CFURL,
-            kUTTypeJPEG,
-            1,
-            nil
-        ) else {
-            return nil
-        }
-
-        CGImageDestinationAddImageFromSource(
-            destination,
-            source,
-            0,
-            mutableMetadata as CFDictionary
-        )
-
-        guard CGImageDestinationFinalize(destination) else {
-            return nil
-        }
-
-        return fileURL
+  func saveImageAsJPEG(_ image: UIImage) -> URL? {
+    let cameraTransform = getCameraTransformString(from: ReplateCameraView.arView.session)
+    let gravityVector = getGravityVectorString(from: ReplateCameraView.arView.session)
+    
+    guard let imageData = image.jpegData(compressionQuality: 1),
+          let source = CGImageSourceCreateWithData(imageData as CFData, nil) else {
+      return nil
+    }
+    
+    let temporaryDirectoryURL = URL(fileURLWithPath: NSTemporaryDirectory(), isDirectory: true)
+    let uniqueFilename = "image_\(Date().timeIntervalSince1970).jpg"
+    let fileURL = temporaryDirectoryURL.appendingPathComponent(uniqueFilename)
+    
+    guard let imageProperties = CGImageSourceCopyPropertiesAtIndex(source, 0, nil) as? [CFString: Any] else {
+      return nil
+    }
+    
+    var mutableMetadata = imageProperties
+    mutableMetadata[kCGImagePropertyExifDictionary] = [
+      kCGImagePropertyExifUserComment: "\(cameraTransform ?? "")|\(gravityVector)"
+    ]
+    
+    guard let destination = CGImageDestinationCreateWithURL(
+      fileURL as CFURL,
+      kUTTypeJPEG,
+      1,
+      nil
+    ) else {
+      return nil
+    }
+    
+    CGImageDestinationAddImageFromSource(
+      destination,
+      source,
+      0,
+      mutableMetadata as CFDictionary
+    )
+    
+    guard CGImageDestinationFinalize(destination) else {
+      return nil
     }
+    
+    return fileURL
+  }
+  
+  func getGravityVectorString(from session: ARSession) -> String? {
+    guard let currentFrame = session.currentFrame else {
+      return nil
+    }
+    
+    let gravityVector = currentFrame.camera.eulerAngles // gravity vector is in Euler angles (x, y, z)
+    return "\(gravityVector.x),\(gravityVector.y),\(gravityVector.z)"
+  }
 
     func getCameraTransformString(from session: ARSession) -> String? {
         guard let currentFrame = session.currentFrame else {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "replate-camera",
-  "version": "0.4.0",
+  "version": "0.5.0",
   "description": "Camera component for Replate Manager",
   "main": "lib/commonjs/index",
   "module": "lib/module/index",

package/ios/camera-controller-complete-part2.swift

@@ -1,296 +0,0 @@
-private func resizeImage(_ image: CIImage, to targetSize: CGSize) -> CIImage? {
-        guard let scaleFilter = CIFilter(name: "CILanczosScaleTransform") else { return nil }
-        
-        scaleFilter.setValue(image, forKey: kCIInputImageKey)
-        scaleFilter.setValue(targetSize.width / image.extent.width, forKey: kCIInputScaleKey)
-        scaleFilter.setValue(1.0, forKey: kCIInputAspectRatioKey)
-        
-        return scaleFilter.outputImage
-    }
-    
-    // MARK: - Entity Management
-    private func setOpacityToCircle(circleId: Int, opacity: Float) {
-        DispatchQueue.main.async {
-            for i in 0..<72 {
-                let offset = circleId == 0 ? 0 : 72
-                guard i + offset < ReplateCameraView.spheresModels.count else { continue }
-                
-                let entity = ReplateCameraView.spheresModels[i + offset]
-                self.updateEntityMaterial(entity, opacity: opacity)
-            }
-        }
-    }
-    
-    private func updateEntityMaterial(_ entity: ModelEntity, opacity: Float) {
-        guard let material = entity.model?.materials.first as? SimpleMaterial else { return }
-        
-        if #available(iOS 15.0, *) {
-            let newMaterial = SimpleMaterial(
-                color: material.color.tint.withAlphaComponent(CGFloat(opacity)),
-                roughness: 1,
-                isMetallic: false
-            )
-            entity.model?.materials[0] = newMaterial
-        }
-    }
-    
-    private func updateSpheres(deviceTargetInfo: DeviceTargetInfo, cameraTransform: simd_float4x4, completion: @escaping (Bool) -> Void) {
-        var completionCalled = false
-        
-        func safeCompletion(_ result: Bool) {
-            guard !completionCalled else {
-                print("Completion already called")
-                return
-            }
-            completionCalled = true
-            completion(result)
-        }
-        
-        // Validate spheres initialization
-        guard ReplateCameraView.spheresModels.count >= 144 else {
-            print("[updateSpheres] Spheres not fully initialized. Count: \(ReplateCameraView.spheresModels.count)")
-            safeCompletion(false)
-            return
-        }
-        
-        // Get anchor
-        guard let anchorNode = ReplateCameraView.anchorEntity else {
-            print("[updateSpheres] No anchor entity found.")
-            safeCompletion(false)
-            return
-        }
-        
-        // Calculate camera metrics
-        let cameraDistance = isCameraWithinRange(
-            cameraTransform: cameraTransform,
-            anchorEntity: anchorNode
-        )
-        
-        // Calculate sphere index
-        let angleDegrees = Self.angleBetweenAnchorXAndCamera(
-            anchor: anchorNode,
-            cameraTransform: cameraTransform
-        )
-        let sphereIndex = max(Int(round(angleDegrees / 5.0)), 0) % 72
-        
-        DispatchQueue.main.async {
-            self.processSphereUpdate(
-                sphereIndex: sphereIndex,
-                targetIndex: deviceTargetInfo.targetIndex,
-                completion: safeCompletion
-            )
-        }
-    }
-    
-    private func processSphereUpdate(sphereIndex: Int, targetIndex: Int, completion: @escaping (Bool) -> Void) {
-        var mesh: ModelEntity?
-        var newAngle = false
-        var callback: RCTResponseSenderBlock?
-        
-        if targetIndex == 1 {
-            guard sphereIndex < ReplateCameraView.upperSpheresSet.count else {
-                print("[updateSpheres] Sphere index out of bounds")
-                completion(false)
-                return
-            }
-            
-            if !ReplateCameraView.upperSpheresSet[sphereIndex] {
-                ReplateCameraView.upperSpheresSet[sphereIndex] = true
-                ReplateCameraView.photosFromDifferentAnglesTaken += 1
-                newAngle = true
-                
-                guard 72 + sphereIndex < ReplateCameraView.spheresModels.count else {
-                    print("[updateSpheres] Upper spheresModels index out of range")
-                    completion(false)
-                    return
-                }
-                
-                mesh = ReplateCameraView.spheresModels[72 + sphereIndex]
-                
-                if ReplateCameraView.upperSpheresSet.allSatisfy({ $0 }) {
-                    callback = ReplateCameraController.completedUpperSpheresCallback
-                    ReplateCameraController.completedUpperSpheresCallback = nil
-                }
-            }
-        } else if targetIndex == 0 {
-            guard sphereIndex < ReplateCameraView.lowerSpheresSet.count else {
-                print("[updateSpheres] Lower sphere index out of range")
-                completion(false)
-                return
-            }
-            
-            if !ReplateCameraView.lowerSpheresSet[sphereIndex] {
-                ReplateCameraView.lowerSpheresSet[sphereIndex] = true
-                ReplateCameraView.photosFromDifferentAnglesTaken += 1
-                newAngle = true
-                
-                guard sphereIndex < ReplateCameraView.spheresModels.count else {
-                    print("[updateSpheres] Lower spheresModels index out of range")
-                    completion(false)
-                    return
-                }
-                
-                mesh = ReplateCameraView.spheresModels[sphereIndex]
-                
-                if ReplateCameraView.lowerSpheresSet.allSatisfy({ $0 }) {
-                    callback = ReplateCameraController.completedLowerSpheresCallback
-                    ReplateCameraController.completedLowerSpheresCallback = nil
-                }
-            }
-        }
-        
-        if let mesh = mesh {
-            let material = SimpleMaterial(color: .green, roughness: 1, isMetallic: false)
-            mesh.model?.materials[0] = material
-            ReplateCameraView.generateImpactFeedback(strength: .light)
-        }
-        
-        callback?([])
-        completion(newAngle)
-    }
-    
-    // MARK: - Anchor Validation
-    private func isAnchorNodeValid(_ anchorNode: AnchorEntity) -> Bool {
-        var isValid = false
-        DispatchQueue.main.sync {
-            let transform = anchorNode.transform
-            let position = transform.translation
-            let rotation = transform.rotation
-            let scale = transform.scale
-            
-            isValid = !position.isNaN &&
-                     !rotation.isNaN &&
-                     scale != SIMD3<Float>(0, 0, 0) &&
-                     abs(length(rotation.vector) - 1.0) < 0.0001
-        }
-        return isValid
-    }
-    
-    // MARK: - Distance and Angle Calculations
-    private func isCameraWithinRange(cameraTransform: simd_float4x4, anchorEntity: AnchorEntity) -> Int {
-        var distance: Float = 0
-        
-        DispatchQueue.main.sync {
-            let cameraPosition = SIMD3<Float>(
-                cameraTransform.columns.3.x,
-                cameraTransform.columns.3.y,
-                cameraTransform.columns.3.z
-            )
-            let anchorPosition = anchorEntity.transform.translation
-            distance = distanceBetween(cameraPosition, anchorPosition)
-        }
-        
-        return distance <= Self.MIN_DISTANCE ? -1 :
-               distance >= Self.MAX_DISTANCE ? 1 : 0
-    }
-    
-    private func distanceBetween(_ pos1: SIMD3<Float>, _ pos2: SIMD3<Float>) -> Float {
-        let difference = pos1 - pos2
-        return sqrt(dot(difference, difference))
-    }
-    
-    // MARK: - Static Utility Methods
-    static func getTransformRelativeToAnchor(anchor: AnchorEntity, cameraTransform: simd_float4x4) -> simd_float4x4 {
-        var relativeTransform: simd_float4x4!
-        DispatchQueue.main.sync {
-            let anchorTransform = anchor.transformMatrix(relativeTo: nil)
-            relativeTransform = anchorTransform.inverse * cameraTransform
-        }
-        return relativeTransform
-    }
-    
-    static func angleBetweenAnchorXAndCamera(anchor: AnchorEntity, cameraTransform: simd_float4x4) -> Float {
-        var angleDegrees: Float = 0
-        
-        DispatchQueue.main.sync {
-            let anchorTransform = anchor.transform.matrix
-            let anchorPositionXZ = simd_float2(
-                anchor.transform.translation.x,
-                anchor.transform.translation.z
-            )
-            let relativeCameraPositionXZ = simd_float2(
-                cameraTransform.columns.3.x,
-                cameraTransform.columns.3.z
-            )
-            
-            let directionXZ = relativeCameraPositionXZ - anchorPositionXZ
-            let anchorXAxisXZ = simd_float2(
-                anchorTransform.columns.0.x,
-                anchorTransform.columns.0.z
-            )
-            
-            let angle = atan2(directionXZ.y, directionXZ.x) -
-                       atan2(anchorXAxisXZ.y, anchorXAxisXZ.x)
-            
-            angleDegrees = angle * (180.0 / .pi)
-            if angleDegrees < 0 {
-                angleDegrees += 360
-            }
-        }
-        
-        return angleDegrees
-    }
-    
-    static func cgImage(from ciImage: CIImage) -> CGImage? {
-        let context = CIContext(options: nil)
-        return context.createCGImage(ciImage, from: ciImage.extent)
-    }
-    
-    static func saveImageAsJPEG(_ image: UIImage) -> URL? {
-        let cameraTransform = getCameraTransformString(from: ReplateCameraView.arView.session)
-        
-        guard let imageData = image.jpegData(compressionQuality: 1),
-              let source = CGImageSourceCreateWithData(imageData as CFData, nil) else {
-            return nil
-        }
-        
-        let temporaryDirectoryURL = URL(fileURLWithPath: NSTemporaryDirectory(), isDirectory: true)
-        let uniqueFilename = "image_\(Date().timeIntervalSince1970).jpg"
-        let fileURL = temporaryDirectoryURL.appendingPathComponent(uniqueFilename)
-        
-        guard let imageProperties = CGImageSourceCopyPropertiesAtIndex(source, 0, nil) as? [CFString: Any] else {
-            return nil
-        }
-        
-        var mutableMetadata = imageProperties
-        mutableMetadata[kCGImagePropertyExifDictionary] = [
-            kCGImagePropertyExifUserComment: cameraTransform
-        ]
-        
-        guard let destination = CGImageDestinationCreateWithURL(
-            fileURL as CFURL,
-            kUTTypeJPEG,
-            1,
-            nil
-        ) else {
-            return nil
-        }
-        
-        CGImageDestinationAddImageFromSource(
-            destination,
-            source,
-            0,
-            mutableMetadata as CFDictionary
-        )
-        
-        guard CGImageDestinationFinalize(destination) else {
-            return nil
-        }
-        
-        return fileURL
-    }
-    
-    static func getCameraTransformString(from session: ARSession) -> String? {
-        guard let currentFrame = session.currentFrame else {
-            return nil
-        }
-        
-        let transform = currentFrame.camera.transform
-        return """
-        \(transform.columns.0.x),\(transform.columns.0.y),\(transform.columns.0.z),\(transform.columns.0.w);
-        \(transform.columns.1.x),\(transform.columns.1.y),\(transform.columns.1.z),\(transform.columns.1.w);
-        \(transform.columns.2.x),\(transform.columns.2.y),\(transform.columns.2.z),\(transform.columns.2.w);
-        \(transform.columns.3.x),\(transform.columns.3.y),\(transform.columns.3.z),\(transform.columns.3.w)
-        """
-    }
-}

package/ios/camera-controller-complete.swift

@@ -1,363 +0,0 @@
-import ARKit
-import RealityKit
-import UIKit
-import AVFoundation
-import ImageIO
-import MobileCoreServices
-
-        guard !hasCalledBack else {
-// MARK: - Supporting Types
-enum ARError: Error {
-    case noAnchor
-    case invalidAnchor
-    case notInFocus
-    case captureError
-    case tooManyImages
-    case processingError
-    case savingError
-    case transformError
-    case lightingError
-    case unknown
-
-    var localizedDescription: String {
-        switch self {
-        case .noAnchor: return "[ReplateCameraController] No anchor set yet"
-        case .invalidAnchor: return "[ReplateCameraController] AnchorNode is not valid"
-        case .notInFocus: return "[ReplateCameraController] Object not in focus"
-        case .captureError: return "[ReplateCameraController] Error capturing image"
-        case .tooManyImages: return "[ReplateCameraController] Too many images and the last one's not from a new angle"
-        case .processingError: return "[ReplateCameraController] Error processing image"
-        case .savingError: return "[ReplateCameraController] Error saving photo"
-        case .transformError: return "[ReplateCameraController] Camera transform data not available"
-        case .lightingError: return "[ReplateCameraController] Image too dark"
-        case .unknown: return "[ReplateCameraController] Unknown error occurred"
-        }
-    }
-}
-
-struct DeviceTargetInfo {
-    let isInFocus: Bool
-    let targetIndex: Int
-    let transform: simd_float4x4
-    let cameraPosition: SIMD3<Float>
-    let deviceDirection: SIMD3<Float>
-
-    var isValidTarget: Bool {
-        return targetIndex != -1
-    }
-}
-
-class SafeCallbackHandler {
-    private let resolver: RCTPromiseResolveBlock
-    private let rejecter: RCTPromiseRejectBlock
-    private var hasCalledBack = false
-    private let lock = NSLock()
-
-    init(resolver: @escaping RCTPromiseResolveBlock, rejecter: @escaping RCTPromiseRejectBlock) {
-        self.resolver = resolver
-        self.rejecter = rejecter
-    }
-
-    func resolve(_ result: Any) {
-        lock.lock()
-        defer { lock.unlock() }
-
-            print("resolver: Callback already invoked.")
-            return
-        }
-        hasCalledBack = true
-        resolver(result)
-    }
-
-    func reject(_ error: ARError) {
-        lock.lock()
-        defer { lock.unlock() }
-
-        guard !hasCalledBack else {
-            print("rejecter: Callback already invoked.")
-            return
-        }
-        hasCalledBack = true
-        rejecter(
-            String(describing: error),
-            error.localizedDescription,
-            NSError(domain: "ReplateCameraController", code: 0, userInfo: nil)
-        )
-    }
-}
-
-// MARK: - Main Controller
-@objc(ReplateCameraController)
-class ReplateCameraController: NSObject {
-    // MARK: - Static Properties
-    private static let lock = NSLock()
-    private static let arQueue = DispatchQueue(label: "com.replate.ar.controller", qos: .userInteractive)
-
-    // Configuration Constants
-    private static let MIN_DISTANCE: Float = 0.15
-    private static let MAX_DISTANCE: Float = 0.45
-    private static let ANGLE_THRESHOLD: Float = 0.6
-    private static let TARGET_IMAGE_SIZE = CGSize(width: 1728, height: 1296)
-    private static let MIN_AMBIENT_INTENSITY: CGFloat = 650
-
-    // Callbacks
-    static var completedTutorialCallback: RCTResponseSenderBlock?
-    static var anchorSetCallback: RCTResponseSenderBlock?
-    static var completedUpperSpheresCallback: RCTResponseSenderBlock?
-    static var completedLowerSpheresCallback: RCTResponseSenderBlock?
-    static var openedTutorialCallback: RCTResponseSenderBlock?
-    static var tooCloseCallback: RCTResponseSenderBlock?
-    static var tooFarCallback: RCTResponseSenderBlock?
-
-    // MARK: - Callback Registration Methods
-    @objc(registerOpenedTutorialCallback:)
-    func registerOpenedTutorialCallback(_ callback: @escaping RCTResponseSenderBlock) {
-        Self.lock.lock()
-        defer { Self.lock.unlock() }
-        ReplateCameraController.openedTutorialCallback = callback
-    }
-
-    @objc(registerCompletedTutorialCallback:)
-    func registerCompletedTutorialCallback(_ callback: @escaping RCTResponseSenderBlock) {
-        Self.lock.lock()
-        defer { Self.lock.unlock() }
-        ReplateCameraController.completedTutorialCallback = callback
-    }
-
-    @objc(registerAnchorSetCallback:)
-    func registerAnchorSetCallback(_ callback: @escaping RCTResponseSenderBlock) {
-        Self.lock.lock()
-        defer { Self.lock.unlock() }
-        ReplateCameraController.anchorSetCallback = callback
-    }
-
-    @objc(registerCompletedUpperSpheresCallback:)
-    func registerCompletedUpperSpheresCallback(_ callback: @escaping RCTResponseSenderBlock) {
-        Self.lock.lock()
-        defer { Self.lock.unlock() }
-        ReplateCameraController.completedUpperSpheresCallback = callback
-    }
-
-    @objc(registerCompletedLowerSpheresCallback:)
-    func registerCompletedLowerSpheresCallback(_ callback: @escaping RCTResponseSenderBlock) {
-        Self.lock.lock()
-        defer { Self.lock.unlock() }
-        ReplateCameraController.completedLowerSpheresCallback = callback
-    }
-
-    @objc(registerTooCloseCallback:)
-    func registerTooCloseCallback(_ callback: @escaping RCTResponseSenderBlock) {
-        Self.lock.lock()
-        defer { Self.lock.unlock() }
-        ReplateCameraController.tooCloseCallback = callback
-    }
-
-    @objc(registerTooFarCallback:)
-    func registerTooFarCallback(_ callback: @escaping RCTResponseSenderBlock) {
-        Self.lock.lock()
-        defer { Self.lock.unlock() }
-        ReplateCameraController.tooFarCallback = callback
-    }
-
-    // MARK: - Public Methods
-    @objc(getPhotosCount:rejecter:)
-    func getPhotosCount(_ resolver: RCTPromiseResolveBlock, rejecter: RCTPromiseRejectBlock) {
-        Self.lock.lock()
-        let count = ReplateCameraView.totalPhotosTaken
-        Self.lock.unlock()
-        resolver(count)
-    }
-
-    @objc(isScanComplete:rejecter:)
-    func isScanComplete(_ resolver: RCTPromiseResolveBlock, rejecter: RCTPromiseRejectBlock) {
-        Self.lock.lock()
-        let isComplete = ReplateCameraView.photosFromDifferentAnglesTaken == 144
-        Self.lock.unlock()
-        resolver(isComplete)
-    }
-
-    @objc(getRemainingAnglesToScan:rejecter:)
-    func getRemainingAnglesToScan(_ resolver: RCTPromiseResolveBlock, rejecter: RCTPromiseRejectBlock) {
-        Self.lock.lock()
-        let remaining = 144 - ReplateCameraView.photosFromDifferentAnglesTaken
-        Self.lock.unlock()
-        resolver(remaining)
-    }
-
-    @objc
-    func reset() {
-        DispatchQueue.main.async {
-            ReplateCameraView.INSTANCE.reset()
-        }
-    }
-
-    // MARK: - Photo Capture and Processing
-    @objc(takePhoto:resolver:rejecter:)
-    func takePhoto(_ unlimited: Bool = false, resolver: @escaping RCTPromiseResolveBlock, rejecter: @escaping RCTPromiseRejectBlock) {
-        Self.arQueue.async { [weak self] in
-            guard let self = self else { return }
-
-            let callbackHandler = SafeCallbackHandler(resolver: resolver, rejecter: rejecter)
-
-            do {
-                try self.validateAndProcessPhoto(unlimited: unlimited, callbackHandler: callbackHandler)
-            } catch let error as ARError {
-                callbackHandler.reject(error)
-            } catch {
-                callbackHandler.reject(.unknown)
-            }
-        }
-    }
-
-    private func validateAndProcessPhoto(unlimited: Bool, callbackHandler: SafeCallbackHandler) throws {
-        let anchorEntity = try getValidAnchorEntity()
-        let deviceTargetInfo = try getDeviceTargetInfo(anchorEntity: anchorEntity)
-
-        if deviceTargetInfo.isValidTarget {
-            try processTargetedDevice(deviceTargetInfo: deviceTargetInfo, unlimited: unlimited, callbackHandler: callbackHandler)
-        } else {
-            throw ARError.notInFocus
-        }
-    }
-
-    private func getValidAnchorEntity() throws -> AnchorEntity {
-        var anchorEntity: AnchorEntity?
-
-        DispatchQueue.main.sync {
-            anchorEntity = ReplateCameraView.anchorEntity
-        }
-
-        guard let anchor = anchorEntity else {
-            throw ARError.noAnchor
-        }
-
-        guard isAnchorNodeValid(anchor) else {
-            throw ARError.invalidAnchor
-        }
-
-        return anchor
-    }
-
-    private func getDeviceTargetInfo(anchorEntity: AnchorEntity) throws -> DeviceTargetInfo {
-        guard let frame = ReplateCameraView.arView.session.currentFrame else {
-            throw ARError.transformError
-        }
-
-        let cameraTransform = frame.camera.transform
-        let relativeCameraTransform = Self.getTransformRelativeToAnchor(anchor: anchorEntity, cameraTransform: cameraTransform)
-
-        var anchorPosition: SIMD3<Float>!
-        DispatchQueue.main.sync {
-            anchorPosition = anchorEntity.position(relativeTo: nil)
-        }
-
-        let cameraPosition = SIMD3<Float>(cameraTransform.columns.3.x, cameraTransform.columns.3.y, cameraTransform.columns.3.z)
-        let deviceDirection = normalize(SIMD3<Float>(-cameraTransform.columns.2.x, -cameraTransform.columns.2.y, -cameraTransform.columns.2.z))
-        let directionToAnchor = normalize(anchorPosition - cameraPosition)
-        let angleToAnchor = acos(dot(deviceDirection, directionToAnchor))
-
-        let targetIndex = determineTargetIndex(angleToAnchor: angleToAnchor, relativeCameraTransform: relativeCameraTransform)
-
-        return DeviceTargetInfo(
-            isInFocus: angleToAnchor < Self.ANGLE_THRESHOLD,
-            targetIndex: targetIndex,
-            transform: relativeCameraTransform,
-            cameraPosition: cameraPosition,
-            deviceDirection: deviceDirection
-        )
-    }
-
-    private func determineTargetIndex(angleToAnchor: Float, relativeCameraTransform: simd_float4x4) -> Int {
-        guard angleToAnchor < Self.ANGLE_THRESHOLD else { return -1 }
-
-        let spheresHeight = ReplateCameraView.spheresHeight
-        let distanceBetweenCircles = ReplateCameraView.distanceBetweenCircles
-        let twoThirdsDistance = spheresHeight + distanceBetweenCircles + distanceBetweenCircles/5
-        let cameraHeight = relativeCameraTransform.columns.3.y
-
-        return cameraHeight < twoThirdsDistance ? 0 : 1
-    }
-
-    private func processTargetedDevice(deviceTargetInfo: DeviceTargetInfo, unlimited: Bool, callbackHandler: SafeCallbackHandler) throws {
-        DispatchQueue.main.async { [weak self] in
-            guard let self = self else { return }
-
-            self.updateCircleFocus(targetIndex: deviceTargetInfo.targetIndex)
-            self.checkCameraDistance(deviceTargetInfo: deviceTargetInfo)
-
-            self.updateSpheres(
-                deviceTargetInfo: deviceTargetInfo,
-                cameraTransform: deviceTargetInfo.transform
-            ) { success in
-                if !unlimited && !success {
-                    callbackHandler.reject(.tooManyImages)
-                    return
-                }
-
-                self.captureAndProcessImage(callbackHandler: callbackHandler)
-            }
-        }
-    }
-
-    private func updateCircleFocus(targetIndex: Int) {
-        if targetIndex != ReplateCameraView.circleInFocus {
-            setOpacityToCircle(circleId: ReplateCameraView.circleInFocus, opacity: 0.5)
-            setOpacityToCircle(circleId: targetIndex, opacity: 1)
-            ReplateCameraView.circleInFocus = targetIndex
-            ReplateCameraView.generateImpactFeedback(strength: .heavy)
-        }
-    }
-
-    private func checkCameraDistance(deviceTargetInfo: DeviceTargetInfo) {
-        let distance = isCameraWithinRange(
-            cameraTransform: deviceTargetInfo.transform,
-            anchorEntity: ReplateCameraView.anchorEntity!
-        )
-
-        switch distance {
-        case 1:
-            ReplateCameraController.tooFarCallback?([])
-        case -1:
-            ReplateCameraController.tooCloseCallback?([])
-        default:
-            break
-        }
-    }
-
-    // MARK: - Image Processing
-    private func captureAndProcessImage(callbackHandler: SafeCallbackHandler) {
-        guard let frame = ReplateCameraView.arView?.session.currentFrame else {
-            callbackHandler.reject(.captureError)
-            return
-        }
-
-        // Check lighting conditions
-        if let lightEstimate = frame.lightEstimate {
-            guard lightEstimate.ambientIntensity >= Self.MIN_AMBIENT_INTENSITY else {
-                callbackHandler.reject(.lightingError)
-                return
-            }
-        }
-
-        processAndSaveImage(frame.capturedImage, callbackHandler: callbackHandler)
-    }
-
-    private func processAndSaveImage(_ pixelBuffer: CVPixelBuffer, callbackHandler: SafeCallbackHandler) {
-        let ciImage = CIImage(cvImageBuffer: pixelBuffer)
-
-        guard let resizedImage = resizeImage(ciImage, to: Self.TARGET_IMAGE_SIZE),
-              let cgImage = Self.cgImage(from: resizedImage),
-              let rotatedImage = UIImage(cgImage: cgImage).rotate(radians: .pi / 2),
-              let savedURL = Self.saveImageAsJPEG(rotatedImage) else {
-            callbackHandler.reject(.processingError)
-            return
-        }
-
-        callbackHandler.resolve(savedURL.absoluteString)
-    }
-
-    private func resizeImage(_ image: CIImage, to targetSize: CGSize) -> CIImage? {
-        guard let scaleFilter = CIFilter(name: "CILanczosScaleTransform") else { return nil }
-
-        scaleFilter.setValue(image, forKey: kCIInputImageKey)
-        scaleFilter.setValue(targetSize.

package/ios/camera-controller-refactor.swift

@@ -1,213 +0,0 @@
-@objc(ReplateCameraController)
-class ReplateCameraController: NSObject {
-    // MARK: - Static Properties
-    private static let lock = NSLock()
-    private static let arQueue = DispatchQueue(label: "com.replate.ar.controller", qos: .userInteractive)
-    
-    // Callback Properties
-    static var completedTutorialCallback: RCTResponseSenderBlock?
-    static var anchorSetCallback: RCTResponseSenderBlock?
-    static var completedUpperSpheresCallback: RCTResponseSenderBlock?
-    static var completedLowerSpheresCallback: RCTResponseSenderBlock?
-    static var openedTutorialCallback: RCTResponseSenderBlock?
-    static var tooCloseCallback: RCTResponseSenderBlock?
-    static var tooFarCallback: RCTResponseSenderBlock?
-    
-    // Constants
-    private static let MIN_DISTANCE: Float = 0.15
-    private static let MAX_DISTANCE: Float = 0.45
-    private static let ANGLE_THRESHOLD: Float = 0.6
-    
-    // MARK: - Callback Registration
-    @objc(registerOpenedTutorialCallback:)
-    func registerOpenedTutorialCallback(_ callback: @escaping RCTResponseSenderBlock) {
-        Self.lock.lock()
-        defer { Self.lock.unlock() }
-        ReplateCameraController.openedTutorialCallback = callback
-    }
-    
-    // Similar registrations for other callbacks...
-    
-    // MARK: - Public Methods
-    @objc(getPhotosCount:rejecter:)
-    func getPhotosCount(_ resolver: RCTPromiseResolveBlock, rejecter: RCTPromiseRejectBlock) {
-        Self.lock.lock()
-        let count = ReplateCameraView.totalPhotosTaken
-        Self.lock.unlock()
-        resolver(count)
-    }
-    
-    @objc(takePhoto:resolver:rejecter:)
-    func takePhoto(_ unlimited: Bool = false, resolver: @escaping RCTPromiseResolveBlock, rejecter: @escaping RCTPromiseRejectBlock) {
-        Self.arQueue.async { [weak self] in
-            guard let self = self else { return }
-            
-            let callbackHandler = SafeCallbackHandler(resolver: resolver, rejecter: rejecter)
-            
-            do {
-                try self.validateAndProcessPhoto(unlimited: unlimited, callbackHandler: callbackHandler)
-            } catch let error as ARError {
-                callbackHandler.reject(error)
-            } catch {
-                callbackHandler.reject(.unknown)
-            }
-        }
-    }
-    
-    // MARK: - Private Methods
-    private func validateAndProcessPhoto(unlimited: Bool, callbackHandler: SafeCallbackHandler) throws {
-        guard let anchorEntity = getValidAnchorEntity() else {
-            throw ARError.noAnchor
-        }
-        
-        let deviceTargetInfo = try getDeviceTargetInfo(anchorEntity: anchorEntity)
-        
-        if deviceTargetInfo.isInFocus {
-            handleFocusedDevice(deviceTargetInfo: deviceTargetInfo, unlimited: unlimited, callbackHandler: callbackHandler)
-        } else {
-            throw ARError.notInFocus
-        }
-    }
-    
-    private func getValidAnchorEntity() -> AnchorEntity? {
-        var anchorEntity: AnchorEntity?
-        DispatchQueue.main.sync {
-            anchorEntity = ReplateCameraView.anchorEntity
-            if let anchor = anchorEntity {
-                guard isAnchorNodeValid(anchor) else {
-                    return nil
-                }
-            }
-        }
-        return anchorEntity
-    }
-    
-    private func handleFocusedDevice(deviceTargetInfo: DeviceTargetInfo, unlimited: Bool, callbackHandler: SafeCallbackHandler) {
-        DispatchQueue.main.async {
-            self.updateCircleFocus(deviceTargetInfo: deviceTargetInfo)
-            
-            self.updateSpheres(deviceTargetInfo: deviceTargetInfo) { success in
-                if !unlimited && !success {
-                    callbackHandler.reject(.tooManyImages)
-                    return
-                }
-                
-                self.captureAndProcessImage(callbackHandler: callbackHandler)
-            }
-        }
-    }
-    
-    private func captureAndProcessImage(callbackHandler: SafeCallbackHandler) {
-        guard let image = ReplateCameraView.arView?.session.currentFrame?.capturedImage else {
-            callbackHandler.reject(.captureError)
-            return
-        }
-        
-        processAndSaveImage(image, callbackHandler: callbackHandler)
-    }
-    
-    private func processAndSaveImage(_ pixelBuffer: CVPixelBuffer, callbackHandler: SafeCallbackHandler) {
-        // Image processing implementation...
-    }
-    
-    // MARK: - Entity Management
-    private func setOpacityToCircle(circleId: Int, opacity: Float) {
-        DispatchQueue.main.async {
-            for i in 0..<72 {
-                let offset = circleId == 0 ? 0 : 72
-                guard let entity = ReplateCameraView.spheresModels[safe: i + offset] else { continue }
-                
-                self.updateEntityMaterial(entity, opacity: opacity)
-            }
-        }
-    }
-    
-    private func updateEntityMaterial(_ entity: ModelEntity, opacity: Float) {
-        guard let material = entity.model?.materials.first as? SimpleMaterial else { return }
-        
-        if #available(iOS 15.0, *) {
-            let newMaterial = SimpleMaterial(
-                color: material.color.tint.withAlphaComponent(CGFloat(opacity)),
-                roughness: 1,
-                isMetallic: false
-            )
-            entity.model?.materials[0] = newMaterial
-        }
-    }
-    
-    // MARK: - Utility Methods
-    private func isAnchorNodeValid(_ anchorNode: AnchorEntity) -> Bool {
-        var isValid = false
-        DispatchQueue.main.sync {
-            let transform = anchorNode.transform
-            let position = transform.translation
-            let rotation = transform.rotation
-            let scale = transform.scale
-            
-            isValid = !position.isNaN &&
-                     !rotation.isNaN &&
-                     scale != SIMD3<Float>(0, 0, 0) &&
-                     abs(length(rotation.vector) - 1.0) < 0.0001
-        }
-        return isValid
-    }
-}
-
-// MARK: - Supporting Types
-extension ReplateCameraController {
-    struct DeviceTargetInfo {
-        let isInFocus: Bool
-        let targetIndex: Int
-        let transform: simd_float4x4
-    }
-    
-    enum ARError: Error {
-        case noAnchor
-        case invalidAnchor
-        case notInFocus
-        case captureError
-        case tooManyImages
-        case unknown
-    }
-    
-    class SafeCallbackHandler {
-        private let resolver: RCTPromiseResolveBlock
-        private let rejecter: RCTPromiseRejectBlock
-        private var hasCalledBack = false
-        private let lock = NSLock()
-        
-        init(resolver: @escaping RCTPromiseResolveBlock, rejecter: @escaping RCTPromiseRejectBlock) {
-            self.resolver = resolver
-            self.rejecter = rejecter
-        }
-        
-        func resolve(_ result: Any) {
-            lock.lock()
-            defer { lock.unlock() }
-            
-            guard !hasCalledBack else { return }
-            hasCalledBack = true
-            resolver(result)
-        }
-        
-        func reject(_ error: ARError) {
-            lock.lock()
-            defer { lock.unlock() }
-            
-            guard !hasCalledBack else { return }
-            hasCalledBack = true
-            rejecter(
-                String(describing: error),
-                error.localizedDescription,
-                NSError(domain: "ReplateCameraController", code: 0, userInfo: nil)
-            )
-        }
-    }
-}
-
-// MARK: - Array Extension
-extension Array {
-    subscript(safe index: Index) -> Element? {
-        indices.contains(index) ? self[index] : nil
-    }
-}

package/ios/complete-ar-refactor.swift

@@ -1,264 +0,0 @@
-import ARKit
-import RealityKit
-import UIKit
-import AVFoundation
-import ImageIO
-import MobileCoreServices
-
-// MARK: - RCTViewManager
-@objc(ReplateCameraViewManager)
-class ReplateCameraViewManager: RCTViewManager {
-    override func view() -> ReplateCameraView {
-        return ReplateCameraView()
-    }
-    
-    @objc override static func requiresMainQueueSetup() -> Bool {
-        return false
-    }
-}
-
-// MARK: - UIImage Extension
-extension UIImage {
-    func rotate(radians: Float) -> UIImage {
-        var newSize = CGRect(origin: .zero, size: self.size)
-            .applying(CGAffineTransform(rotationAngle: CGFloat(radians))).size
-        newSize.width = floor(newSize.width)
-        newSize.height = floor(newSize.height)
-        
-        UIGraphicsBeginImageContextWithOptions(newSize, false, self.scale)
-        guard let context = UIGraphicsGetCurrentContext() else { return self }
-        
-        context.translateBy(x: newSize.width / 2, y: newSize.height / 2)
-        context.rotate(by: CGFloat(radians))
-        self.draw(in: CGRect(x: -self.size.width / 2,
-                            y: -self.size.height / 2,
-                            width: self.size.width,
-                            height: self.size.height))
-        
-        let newImage = UIGraphicsGetImageFromCurrentImageContext() ?? self
-        UIGraphicsEndImageContext()
-        
-        return newImage
-    }
-}
-
-// MARK: - ReplateCameraView
-class ReplateCameraView: UIView, ARSessionDelegate {
-    // MARK: - Static Properties
-    private static let lock = NSLock()
-    private static let arQueue = DispatchQueue(label: "com.replate.ar", qos: .userInteractive)
-    
-    // AR View and Core Components
-    static var arView: ARView!
-    static var anchorEntity: AnchorEntity?
-    static var model: Entity!
-    static var sessionId: UUID!
-    static var INSTANCE: ReplateCameraView!
-    
-    // Scene Configuration
-    static var width = CGFloat(0)
-    static var height = CGFloat(0)
-    static var isPaused = false
-    
-    // Sphere Properties
-    static var spheresModels: [ModelEntity] = []
-    static var upperSpheresSet = [Bool](repeating: false, count: 72)
-    static var lowerSpheresSet = [Bool](repeating: false, count: 72)
-    static var sphereRadius = Float(0.004)
-    static var spheresRadius = Float(0.13)
-    static var sphereAngle = Float(5)
-    static var spheresHeight = Float(0.10)
-    static var distanceBetweenCircles = Float(0.10)
-    
-    // Focus and Navigation
-    static var focusModel: Entity!
-    static var circleInFocus = 0
-    static var dragSpeed = CGFloat(7000)
-    static var dotAnchors: [AnchorEntity] = []
-    
-    // Statistics
-    static var totalPhotosTaken = 0
-    static var photosFromDifferentAnglesTaken = 0
-    
-    // Thread Safety
-    private static var isResetting = false
-    
-    // MARK: - Initialization
-    override init(frame: CGRect) {
-        super.init(frame: frame)
-        setupInitialState()
-    }
-    
-    required init?(coder: NSCoder) {
-        super.init(coder: coder)
-        setupInitialState()
-    }
-    
-    private func setupInitialState() {
-        requestCameraPermissions()
-        ReplateCameraView.INSTANCE = self
-    }
-    
-    // MARK: - Layout
-    override func layoutSubviews() {
-        super.layoutSubviews()
-        Self.lock.lock()
-        defer { Self.lock.unlock() }
-        
-        ReplateCameraView.width = frame.width
-        ReplateCameraView.height = frame.height
-    }
-    
-    // MARK: - AR Setup and Configuration
-    static func setupAR() {
-        arQueue.async {
-            guard let instance = INSTANCE else { return }
-            
-            let configuration = ARWorldTrackingConfiguration()
-            configuration.isLightEstimationEnabled = true
-            configuration.planeDetection = .horizontal
-            
-            DispatchQueue.main.async {
-                configureARView(configuration)
-                addRecognizers()
-            }
-        }
-    }
-    
-    private static func configureARView(_ configuration: ARWorldTrackingConfiguration) {
-        configureRenderOptions()
-        configureVideoFormat(configuration)
-        
-        arView.session.run(configuration)
-        arView.addCoaching()
-        sessionId = arView.session.identifier
-    }
-    
-    private static func configureRenderOptions() {
-        let renderOptions: [ARView.RenderOptions] = [
-            .disableMotionBlur,
-            .disableCameraGrain,
-            .disableAREnvironmentLighting,
-            .disableHDR,
-            .disableFaceMesh,
-            .disableGroundingShadows,
-            .disablePersonOcclusion
-        ]
-        
-        renderOptions.forEach { arView.renderOptions.insert($0) }
-    }
-    
-    private static func configureVideoFormat(_ configuration: ARWorldTrackingConfiguration) {
-        if #available(iOS 16.0, *) {
-            configuration.videoFormat = ARWorldTrackingConfiguration.recommendedVideoFormatForHighResolutionFrameCapturing
-                ?? ARWorldTrackingConfiguration.recommendedVideoFormatFor4KResolution
-                ?? highestResolutionFormat()
-        } else {
-            configuration.videoFormat = highestResolutionFormat()
-        }
-    }
-    
-    private static func highestResolutionFormat() -> ARConfiguration.VideoFormat {
-        return ARWorldTrackingConfiguration.supportedVideoFormats.max(by: { format1, format2 in
-            let resolution1 = format1.imageResolution.width * format1.imageResolution.height
-            let resolution2 = format2.imageResolution.width * format2.imageResolution.height
-            return resolution1 < resolution2
-        })!
-    }
-    
-    // MARK: - Gesture Recognition
-    static func addRecognizers() {
-        guard let instance = INSTANCE else { return }
-        
-        let recognizers = [
-            UITapGestureRecognizer(target: instance, action: #selector(instance.viewTapped)),
-            UIPanGestureRecognizer(target: instance, action: #selector(instance.handlePan)),
-            UIPinchGestureRecognizer(target: instance, action: #selector(instance.handlePinch))
-        ]
-        
-        recognizers.forEach { arView.addGestureRecognizer($0) }
-    }
-    
-    // MARK: - Entity Management
-    func createSpheres(y: Float) {
-        DispatchQueue.main.async {
-            let radius = ReplateCameraView.spheresRadius
-            
-            for i in 0..<72 {
-                let angle = Float(i) * (Float.pi / 180) * 5
-                let position = SIMD3(
-                    radius * cos(angle),
-                    y,
-                    radius * sin(angle)
-                )
-                
-                let sphere = self.createSphere(position: position)
-                ReplateCameraView.spheresModels.append(sphere)
-                ReplateCameraView.anchorEntity?.addChild(sphere)
-            }
-        }
-    }
-    
-    func createSphere(position: SIMD3<Float>) -> ModelEntity {
-        let sphereMesh = MeshResource.generateSphere(radius: ReplateCameraView.sphereRadius)
-        let material = SimpleMaterial(color: .white.withAlphaComponent(1), roughness: 1, isMetallic: false)
-        let sphere = ModelEntity(mesh: sphereMesh, materials: [material])
-        sphere.position = position
-        return sphere
-    }
-    
-    // MARK: - Reset Functionality
-    @objc static func reset() {
-        arQueue.async {
-            Self.lock.lock()
-            defer { Self.lock.unlock() }
-            
-            if isResetting { return }
-            isResetting = true
-            
-            DispatchQueue.main.async {
-                tearDownARSession()
-                resetProperties()
-                setupNewARView()
-                isResetting = false
-            }
-        }
-    }
-    
-    private static func tearDownARSession() {
-        arView?.session.pause()
-        arView?.session.delegate = nil
-        arView?.scene.anchors.removeAll()
-        arView?.removeFromSuperview()
-        arView?.window?.resignKey()
-    }
-    
-    private static func resetProperties() {
-        anchorEntity = nil
-        model = nil
-        spheresModels.removeAll()
-        upperSpheresSet = [Bool](repeating: false, count: 72)
-        lowerSpheresSet = [Bool](repeating: false, count: 72)
-        totalPhotosTaken = 0
-        photosFromDifferentAnglesTaken = 0
-        sphereRadius = 0.004
-        spheresRadius = 0.13
-        sphereAngle = 5
-        spheresHeight = 0.10
-        dragSpeed = 7000
-        dotAnchors.removeAll()
-    }
-    
-    private static func setupNewARView() {
-        guard let instance = INSTANCE else { return }
-        
-        arView = ARView(frame: CGRect(x: 0, y: 0, width: width, height: height))
-        arView.backgroundColor = instance.hexStringToUIColor(hexColor: "#32a852")
-        instance.addSubview(arView)
-        arView.session.delegate = instance
-        setupAR()
-    }
-    
-    // Continue with the rest of your implementation...
-    // Including ARSessionDelegate methods, gesture handlers, and utility functions
-}