replate-camera 0.1.6 → 0.1.8

package/ios/ReplateCameraViewManager.swift

@@ -45,7 +45,6 @@ extension UIImage {
 class ReplateCameraView : UIView, ARSessionDelegate {
 
     static var arView: ARView!
-    static var anchor: ARAnchor!
     static var anchorEntity: AnchorEntity!
     static var model: Entity!
     static var spheresModels: [ModelEntity] = []
@@ -53,20 +52,27 @@ class ReplateCameraView : UIView, ARSessionDelegate {
     static var lowerSpheresSet: [Bool] = [Bool](repeating: false, count: 72)
     static var totalPhotosTaken: Int = 0
     static var photosFromDifferentAnglesTaken = 0
+    static var INSTANCE: ReplateCameraView!
 
     override init(frame: CGRect) {
         super.init(frame: frame)
         requestCameraPermissions()
 //        setupAR()
+        ReplateCameraView.INSTANCE = self
     }
 
     required init?(coder: NSCoder) {
         super.init(coder: coder)
         requestCameraPermissions()
+        ReplateCameraView.INSTANCE = self
 //        setupAR()
     }
 
-    
+    static func addRecognizer(){
+        let recognizer = UITapGestureRecognizer(target: ReplateCameraView.INSTANCE,
+                                                action: #selector(ReplateCameraView.INSTANCE.viewTapped(_:)))
+        ReplateCameraView.arView.addGestureRecognizer(recognizer)
+    }
     
     func requestCameraPermissions(){
 
@@ -94,6 +100,65 @@ class ReplateCameraView : UIView, ARSessionDelegate {
         print("Width: \(width), Height: \(height)")
         self.setupAR()
     }
+    
+    
+    @objc private func viewTapped(_ recognizer: UITapGestureRecognizer) {
+        print("VIEW TAPPED")
+//        guard !ReplateCameraView.arView.canBecomeFocused else {
+//            return
+//        }
+        
+        let tapLocation: CGPoint = recognizer.location(in: ReplateCameraView.arView)
+        let estimatedPlane: ARRaycastQuery.Target = .estimatedPlane
+        let alignment: ARRaycastQuery.TargetAlignment = .horizontal
+        
+        let result: [ARRaycastResult] = ReplateCameraView.arView.raycast(from: tapLocation,
+                                                       allowing: estimatedPlane,
+                                                       alignment: alignment)
+        
+        guard let rayCast: ARRaycastResult = result.first
+        else { return }
+        let anchor = AnchorEntity(raycastResult: rayCast)
+        print("ANCHOR FOUND\n", anchor.transform)
+        if (ReplateCameraView.model == nil && ReplateCameraView.anchorEntity == nil){
+            ReplateCameraView.anchorEntity = anchor
+            let anchorTransform = anchor.transform
+            //            let path = Bundle.main.path(forResource: "anchor", ofType: "usdz")!
+            //            let url = URL(fileURLWithPath: path)
+            //            let entity: ModelEntity = try! ModelEntity.loadModel(contentsOf: url)
+            
+            //            if #available(iOS 15.0, *) {
+            //                entity.model!.mesh.
+            //                ReplateCameraView.spheresModels = Array(entity.model!.mesh.contents.models)
+            //            }
+            //            entity.scale *= 4.5
+            //            entity.position = SIMD3(anchorTransform.columns.3.x, anchorTransform.columns.3.y, anchorTransform.columns.3.z)
+            
+            func createSphere(position: SIMD3<Float>) -> ModelEntity {
+                let sphereMesh = MeshResource.generateSphere(radius: 0.0025)
+                let sphereEntity = ModelEntity(mesh: sphereMesh, materials: [SimpleMaterial(color: .white.withAlphaComponent(0.7), isMetallic: false)])
+                sphereEntity.position = position
+                return sphereEntity
+            }
+            
+            func createSpheres(y: Float){
+                let radius = Float(0.1)
+                for i in 0..<72 {
+                    let angle = Float(i) * (Float.pi / 180) * 5 // 10 degrees in radians
+                    let x = radius * cos(angle)
+                    let z = radius * sin(angle)
+                    let spherePosition = SIMD3<Float>(x, y, z)
+                    let sphereEntity = createSphere(position: spherePosition)
+                    ReplateCameraView.spheresModels.append(sphereEntity)
+                    ReplateCameraView.anchorEntity.addChild(sphereEntity)
+                }
+            }
+            
+            createSpheres(y: 0.0)
+            createSpheres(y: 0.3)
+            ReplateCameraView.arView.scene.anchors.append(ReplateCameraView.anchorEntity)
+        }
+    }
 
     func setupAR() {
         print("Setup AR")
@@ -109,6 +174,10 @@ class ReplateCameraView : UIView, ARSessionDelegate {
 //        else { fatalError("See no reference object") }
 //        print(obj)
         configuration.planeDetection = ARWorldTrackingConfiguration.PlaneDetection.horizontal
+//        ReplateCameraView.arView.debugOptions = [
+//            .showAnchorOrigins,
+//            .showAnchorGeometry
+//        ]
         if #available(iOS 16.0, *) {
             print("recommendedVideoFormatForHighResolutionFrameCapturing")
             configuration.videoFormat = ARWorldTrackingConfiguration.recommendedVideoFormatForHighResolutionFrameCapturing ?? ARWorldTrackingConfiguration.recommendedVideoFormatFor4KResolution ?? ARWorldTrackingConfiguration.supportedVideoFormats[0]
@@ -123,61 +192,14 @@ class ReplateCameraView : UIView, ARSessionDelegate {
         }
 //        configuration.detectionObjects = obj
         ReplateCameraView.arView.session.run(configuration)
+        
+        ReplateCameraView.arView.addCoaching()
     }
 
     func session(_ session: ARSession, didAdd anchors: [ARAnchor]) {
-        print("ANCHOR FOUND")
-        if (ReplateCameraView.anchor == nil){
-            guard let _anchor = anchors.first else { return }
-            ReplateCameraView.anchor =  _anchor
-        }
-        if (ReplateCameraView.model == nil && ReplateCameraView.anchorEntity == nil){
-            let anchorTransform = ReplateCameraView.anchor.transform
-//            let path = Bundle.main.path(forResource: "anchor", ofType: "usdz")!
-//            let url = URL(fileURLWithPath: path)
-//            let entity: ModelEntity = try! ModelEntity.loadModel(contentsOf: url)
-            
-//            if #available(iOS 15.0, *) {
-//                entity.model!.mesh.
-//                ReplateCameraView.spheresModels = Array(entity.model!.mesh.contents.models)
-//            }
-//            entity.scale *= 4.5
-//            entity.position = SIMD3(anchorTransform.columns.3.x, anchorTransform.columns.3.y, anchorTransform.columns.3.z)
-            
-            func createSphere(position: SIMD3<Float>) -> ModelEntity {
-                let sphereMesh = MeshResource.generateSphere(radius: 0.0025)
-                let sphereEntity = ModelEntity(mesh: sphereMesh, materials: [SimpleMaterial(color: .white.withAlphaComponent(0.7), isMetallic: false)])
-                sphereEntity.position = position
-                return sphereEntity
-            }
-            
-            func createSpheres(y: Float){
-                let radius = Float(0.1)
-                for i in 0..<72 {
-                    let angle = Float(i) * (Float.pi / 180) * 5 // 10 degrees in radians
-                    let x = radius * cos(angle)
-                    let z = radius * sin(angle)
-                    let spherePosition = SIMD3<Float>(x, y, z)
-                    let sphereEntity = createSphere(position: spherePosition)
-                    ReplateCameraView.spheresModels.append(sphereEntity)
-                    ReplateCameraView.anchorEntity.addChild(sphereEntity)
-                }
-            }
-             
-            ReplateCameraView.anchorEntity = AnchorEntity()
-            createSpheres(y: 0.0)
-            createSpheres(y: 0.3)
-            ReplateCameraView.arView.scene.anchors.append(ReplateCameraView.anchorEntity)
-        }
+        
     }
 
-//    @objc func setCameraRect(_ node: NSNumber, rect: NSDictionary) {
-//        let x = rect["x"] as? CGFloat ?? 0
-//        let y = rect["y"] as? CGFloat ?? 0
-//        let width = rect["width"] as? CGFloat ?? 0
-//        let height = rect["height"] as? CGFloat ?? 0
-////        arView.(CGRect(x: x, y: y, width: width, height: height))
-//    }
 
     @objc var color: String = "" {
         didSet {
@@ -220,11 +242,17 @@ class ReplateCameraView : UIView, ARSessionDelegate {
         ReplateCameraView.arView.session.run(ARWorldTrackingConfiguration())
     }
 
-
 }
 
 @objc(ReplateCameraController)
-class ReplateCameraController: NSObject {
+class ReplateCameraController: RCTEventEmitter {
+    
+    static var INSTANCE: ReplateCameraController!
+    
+    override init() {
+        super.init()
+        ReplateCameraController.INSTANCE = self
+    }
 
     @objc(getPhotosCount:rejecter:)
     func getPhotosCount(_ resolver: RCTPromiseResolveBlock, rejecter: RCTPromiseRejectBlock) -> Void{
@@ -246,17 +274,17 @@ class ReplateCameraController: NSObject {
            
            //DEVICE ORIENTATION
            guard let anchorNode = ReplateCameraView.anchorEntity else {
-               rejecter("[ReplateCameraController]", "Error saving photo", NSError(domain: "ReplateCameraController", code: 001, userInfo: nil));
+               rejecter("[ReplateCameraController]", "No anchor set yet", NSError(domain: "ReplateCameraController", code: 001, userInfo: nil));
                return
            }
            
            // Assuming you have two points
-           let point1 = SIMD3<Float>(anchorNode.position.x,
-                                     anchorNode.position.y,
-                                     anchorNode.position.z)
-           let point2 = SIMD3<Float>(anchorNode.position.x,
-                                     anchorNode.position.y + 0.3,
-                                     anchorNode.position.z)
+           let point1 = SIMD3<Float>(anchorNode.position(relativeTo: nil).x,
+                                     anchorNode.position(relativeTo: nil).y,
+                                     anchorNode.position(relativeTo: nil).z)
+           let point2 = SIMD3<Float>(anchorNode.position(relativeTo: nil).x,
+                                     anchorNode.position(relativeTo: nil).y + 0.3,
+                                     anchorNode.position(relativeTo: nil).z)
            
            // Function to calculate the angle between two vectors
            func angleBetweenVectors(_ vector1: SIMD3<Float>, _ vector2: SIMD3<Float>) -> Float {
@@ -265,22 +293,33 @@ class ReplateCameraController: NSObject {
            }
            
            // Threshold angle for considering if the device is pointing towards a point
-           let thresholdAngle: Float = 0.3 // Adjust this threshold as needed
            var deviceTargetInFocus = -1
            // Check if the device is pointing towards one of the two points
            if let cameraTransform = ReplateCameraView.arView.session.currentFrame?.camera.transform {
                let deviceDirection = SIMD3<Float>(-cameraTransform.columns.2.x, -cameraTransform.columns.2.y, -cameraTransform.columns.2.z)
                
                let cameraPosition = SIMD3<Float>(cameraTransform.columns.3.x, cameraTransform.columns.3.y, cameraTransform.columns.3.z)
-               
                let directionToFirstPoint = normalize(point1 - cameraPosition)
                let directionToSecondPoint = normalize(point2 - cameraPosition)
                
+               let point1Distance = distance(point1, cameraPosition)
+               let point2Distance = distance(point2, cameraPosition)
+               let averageDistance = (point1Distance + point2Distance) / 2.0
+               
+               let baseThreshold: Float = 0.6  // adjust as needed
+               let distanceFactor: Float = 0.2  // adjust as needed
+               
+               let dynamicThreshold = baseThreshold + distanceFactor * sqrt(averageDistance)
+               
+               
                let angleToFirstPoint = angleBetweenVectors(deviceDirection, directionToFirstPoint)
                let angleToSecondPoint = angleBetweenVectors(deviceDirection, directionToSecondPoint)
-               print("Camera Y: \(cameraPosition.y)")
-               let isPointingAtFirstPoint = angleToFirstPoint < thresholdAngle && cameraPosition.y < 0.25
-               let isPointingAtSecondPoint = angleToSecondPoint < thresholdAngle && cameraPosition.y >= 0.25
+               print("Camera: \(cameraPosition)")
+               print("Point 1 position: \(point1) Point 2 position: \(point2)")
+               print("Angle to first: ", angleToFirstPoint, " Angle to second: ", angleToSecondPoint)
+               print("Threshold \(dynamicThreshold)")
+               let isPointingAtFirstPoint = angleToFirstPoint < dynamicThreshold && cameraPosition.y < anchorNode.position.y + 0.20
+               let isPointingAtSecondPoint = angleToSecondPoint < dynamicThreshold && cameraPosition.y >= anchorNode.position.y + 0.20
                if (isPointingAtFirstPoint) {
                    deviceTargetInFocus = 0
                }else if(isPointingAtSecondPoint){
@@ -304,6 +343,18 @@ class ReplateCameraController: NSObject {
                    let uiImage = UIImage(cgImage: cgImage)
                    let finImage = uiImage.rotate(radians: .pi/2) // Adjust radians as needed
 
+                   guard let components = finImage.averageColor()?.getRGBComponents()
+                   else {
+                       rejecter("[ReplateCameraController]", "Cannot get color components", NSError(domain: "ReplateCameraController", code: 003, userInfo: nil))
+                       return
+                   }
+                   let averagePixelColor = components.red + components.blue + components.green / 3
+                   print("Average pixel color: \(averagePixelColor)")
+                   if ((components.red + components.blue + components.green) / 3 < 0.15){
+                       rejecter("[ReplateCameraController]", "Image too dark", NSError(domain: "ReplateCameraController", code: 004, userInfo: nil))
+                       return
+                   }
+                   
                    print("Saving photo")
                    if let url = ReplateCameraController.saveImageAsJPEG(finImage) {
                        resolver(url.absoluteString)
@@ -330,7 +381,6 @@ class ReplateCameraController: NSObject {
     }
     
     
-    
     static func saveImageAsJPEG(_ image: UIImage) -> URL? {
         // Convert UIImage to Data with JPEG representation
         guard let imageData = image.jpegData(compressionQuality: 1.0) else {
@@ -363,12 +413,17 @@ class ReplateCameraController: NSObject {
             return nil
         }
     }
-
-
-   @objc
-   func constantsToExport() -> [String: Any]! {
-     return ["someKey": "someValue"]
-   }
+    
+    @objc
+    func sendTutorialEndedEvent(){
+        self.sendEvent(withName: "arTutorialCompleted", body: true)
+    }
+    
+    @objc
+    override func supportedEvents() -> [String]! {
+        return ["arTutorialCompleted"]
+    }
+    
     
     func updateSpheres(deviceTargetInFocus: Int) {
         guard let anchorNode = ReplateCameraView.anchorEntity else { return }
@@ -378,9 +433,9 @@ class ReplateCameraController: NSObject {
             let cameraTransform = frame.camera.transform
             
             // Calculate the angle between the camera and the anchor
-            let anchorPosition = SCNVector3(anchorNode.position.x,
-                                            anchorNode.position.y,
-                                            anchorNode.position.z)
+            let anchorPosition = SCNVector3(anchorNode.position(relativeTo: nil).x,
+                                            anchorNode.position(relativeTo: nil).y,
+                                            anchorNode.position(relativeTo: nil).z)
             let cameraPosition = SCNVector3(cameraTransform.columns.3.x,
                                             cameraTransform.columns.3.y,
                                             cameraTransform.columns.3.z)
@@ -409,9 +464,9 @@ class ReplateCameraController: NSObject {
         }
     }
     
-    func calculateAngle(_ vector1: SCNVector3, _ vector2: SCNVector3) -> Float {
+    func calculateAngle(_ camera: SCNVector3, _ anchor: SCNVector3) -> Float {
         // Calculate the angle in 2D plane (x-z plane) using atan2
-        let angle = atan2(vector1.z, vector1.x)
+        let angle = atan2(camera.z - anchor.z, camera.x - anchor.x)
         
         // Convert from radians to degrees
         var angleInDegrees = GLKMathRadiansToDegrees(Float(angle))
@@ -421,6 +476,14 @@ class ReplateCameraController: NSObject {
             angleInDegrees += 360
         }
         
+        // Rotate by 2.5 degrees to consider sphere-center, not sphere-begin
+        angleInDegrees += 2.5
+        
+        // If rotating resulted in angle > 360 degrees, subtract 360
+        if angleInDegrees >= 360 {
+            angleInDegrees -= 360
+        }
+        
         return angleInDegrees
     }
 
@@ -436,3 +499,94 @@ extension SCNVector3 {
         return a.x*b.x + a.y*b.y + a.z*b.z
     }
 }
+
+extension ARView: ARCoachingOverlayViewDelegate {
+    func addCoaching() {
+        print("ADD COACHING")
+        // Create a ARCoachingOverlayView object
+        let coachingOverlay = ARCoachingOverlayView()
+        // Make sure it rescales if the device orientation changes
+        coachingOverlay.autoresizingMask = [.flexibleWidth, .flexibleHeight]
+        self.addSubview(coachingOverlay)
+        coachingOverlay.center = self.convert(self.center, from:self.superview)
+        // Set the Augmented Reality goal
+        coachingOverlay.goal = .horizontalPlane
+        // Set the ARSession
+        coachingOverlay.session = self.session
+        // Set the delegate for any callbacks
+        coachingOverlay.delegate = self
+        coachingOverlay.setActive(true, animated: true)
+    }
+    // Example callback for the delegate object
+    public func coachingOverlayViewDidDeactivate(
+        _ coachingOverlayView: ARCoachingOverlayView
+    ) {
+        print("DEACTIVATED")
+        ReplateCameraController.INSTANCE.sendTutorialEndedEvent()
+        ReplateCameraView.addRecognizer()
+        print("CRASHED")
+    }
+}
+
+extension UIImage {
+    func averageColor() -> UIColor? {
+        // Convert UIImage to CGImage
+        guard let cgImage = self.cgImage else { return nil }
+        
+        // Get width and height of the image
+        let width = cgImage.width
+        let height = cgImage.height
+        
+        // Create a data provider from CGImage
+        guard let dataProvider = cgImage.dataProvider else { return nil }
+        
+        // Access pixel data
+        guard let pixelData = dataProvider.data else { return nil }
+        
+        // Create a pointer to the pixel data
+        let data: UnsafePointer<UInt8> = CFDataGetBytePtr(pixelData)
+        
+        var totalRed: CGFloat = 0
+        var totalGreen: CGFloat = 0
+        var totalBlue: CGFloat = 0
+        
+        // Loop through each pixel and calculate sum of RGB values
+        for y in 0..<height {
+            for x in 0..<width {
+                let pixelInfo: Int = ((width * y) + x) * 4
+                let red = CGFloat(data[pixelInfo]) / 255.0
+                let green = CGFloat(data[pixelInfo + 1]) / 255.0
+                let blue = CGFloat(data[pixelInfo + 2]) / 255.0
+                
+                totalRed += red
+                totalGreen += green
+                totalBlue += blue
+            }
+        }
+        
+        // Calculate average RGB values
+        let count = CGFloat(width * height)
+        let averageRed = totalRed / count
+        let averageGreen = totalGreen / count
+        let averageBlue = totalBlue / count
+        
+        // Create and return average color
+        return UIColor(red: averageRed, green: averageGreen, blue: averageBlue, alpha: 1.0)
+    }
+}
+
+extension UIColor {
+    func getRGBComponents() -> (red: CGFloat, green: CGFloat, blue: CGFloat)? {
+        var red: CGFloat = 0
+        var green: CGFloat = 0
+        var blue: CGFloat = 0
+        var alpha: CGFloat = 0
+        
+        // Check if the color can be converted to RGB
+        guard self.getRed(&red, green: &green, blue: &blue, alpha: &alpha) else {
+            return nil
+        }
+        
+        return (red, green, blue)
+    }
+}

package/package.json

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