react-native-nitro-ar 2026.2.1 → 2026.2.2

package/ios/HybridARMeshAnchor.swift

@@ -34,12 +34,17 @@ final class HybridARMeshAnchor: HybridARMeshAnchorSpec {
 
     var vertices: [Double] {
         let geo = anchor.geometry
-        let vertexBuffer = geo.vertices
+        let vertexSource = geo.vertices
         var result: [Double] = []
-        result.reserveCapacity(vertexBuffer.count * 3)
+        result.reserveCapacity(vertexSource.count * 3)
 
-        for i in 0..<vertexBuffer.count {
-            let vertex = vertexBuffer[i]
+        let buffer = vertexSource.buffer
+        let stride = vertexSource.stride
+        let offset = vertexSource.offset
+
+        for i in 0..<vertexSource.count {
+            let vertexPointer = buffer.contents().advanced(by: offset + stride * i)
+            let vertex = vertexPointer.assumingMemoryBound(to: SIMD3<Float>.self).pointee
             result.append(Double(vertex.x))
             result.append(Double(vertex.y))
             result.append(Double(vertex.z))
@@ -49,27 +54,44 @@ final class HybridARMeshAnchor: HybridARMeshAnchorSpec {
 
     var faces: [Double] {
         let geo = anchor.geometry
-        let faceBuffer = geo.faces
+        let faceElement = geo.faces
         var result: [Double] = []
-        result.reserveCapacity(faceBuffer.count * 3)
-
-        for i in 0..<faceBuffer.count {
-            let indices = faceBuffer.vertexIndicesOf(faceWithIndex: i)
-            result.append(Double(indices[0]))
-            result.append(Double(indices[1]))
-            result.append(Double(indices[2]))
+        result.reserveCapacity(faceElement.count * 3)
+
+        let buffer = faceElement.buffer
+        let bytesPerIndex = faceElement.bytesPerIndex
+
+        for i in 0..<faceElement.count {
+            let facePointer = buffer.contents().advanced(by: bytesPerIndex * 3 * i)
+
+            if bytesPerIndex == 4 {
+                let indices = facePointer.assumingMemoryBound(to: UInt32.self)
+                result.append(Double(indices[0]))
+                result.append(Double(indices[1]))
+                result.append(Double(indices[2]))
+            } else if bytesPerIndex == 2 {
+                let indices = facePointer.assumingMemoryBound(to: UInt16.self)
+                result.append(Double(indices[0]))
+                result.append(Double(indices[1]))
+                result.append(Double(indices[2]))
+            }
         }
         return result
     }
 
     var normals: [Double] {
         let geo = anchor.geometry
-        let normalBuffer = geo.normals
+        let normalSource = geo.normals
         var result: [Double] = []
-        result.reserveCapacity(normalBuffer.count * 3)
+        result.reserveCapacity(normalSource.count * 3)
 
-        for i in 0..<normalBuffer.count {
-            let normal = normalBuffer[i]
+        let buffer = normalSource.buffer
+        let stride = normalSource.stride
+        let offset = normalSource.offset
+
+        for i in 0..<normalSource.count {
+            let normalPointer = buffer.contents().advanced(by: offset + stride * i)
+            let normal = normalPointer.assumingMemoryBound(to: SIMD3<Float>.self).pointee
             result.append(Double(normal.x))
             result.append(Double(normal.y))
             result.append(Double(normal.z))
@@ -79,15 +101,21 @@ final class HybridARMeshAnchor: HybridARMeshAnchorSpec {
 
     var classifications: [MeshClassification] {
         let geo = anchor.geometry
-        guard let classBuffer = geo.classification else {
+        guard let classSource = geo.classification else {
             return []
         }
 
         var result: [MeshClassification] = []
-        result.reserveCapacity(classBuffer.count)
+        result.reserveCapacity(classSource.count)
+
+        let buffer = classSource.buffer
+        let stride = classSource.stride
+        let offset = classSource.offset
 
-        for i in 0..<classBuffer.count {
-            let arClass = classBuffer[i]
+        for i in 0..<classSource.count {
+            let classPointer = buffer.contents().advanced(by: offset + stride * i)
+            let classValue = classPointer.assumingMemoryBound(to: UInt8.self).pointee
+            let arClass = ARMeshClassification(rawValue: Int(classValue)) ?? .none
             result.append(mapClassification(arClass))
         }
         return result

package/ios/HybridARSegmentationResult.swift

@@ -0,0 +1,344 @@
+import ARKit
+import CoreImage
+import NitroModules
+import Vision
+
+@available(iOS 17.0, *)
+final class HybridARSegmentationResult: HybridARSegmentationResultSpec {
+    let mask: VNInstanceMaskObservation
+    let selectedIndex: Int
+    let frame: ARFrame
+    weak var sceneView: ARSCNView?
+
+    private var _boundingBox: [Double] = []
+    private var _maskPixelCount: Double = 0
+    private var cachedDepthPoints: [Double]?
+
+    init(mask: VNInstanceMaskObservation, selectedIndex: Int, frame: ARFrame, sceneView: ARSCNView?) {
+        self.mask = mask
+        self.selectedIndex = selectedIndex
+        self.frame = frame
+        self.sceneView = sceneView
+        super.init()
+
+        // Calculate bounding box and pixel count
+        calculateMaskMetrics()
+    }
+
+    var success: Bool {
+        true
+    }
+
+    var boundingBox: [Double] {
+        _boundingBox
+    }
+
+    var maskPixelCount: Double {
+        _maskPixelCount
+    }
+
+    private func calculateMaskMetrics() {
+        guard let maskBuffer = try? mask.generateScaledMaskForImage(
+            forInstances: IndexSet(integer: selectedIndex),
+            from: VNImageRequestHandler(cvPixelBuffer: frame.capturedImage)
+        ) else {
+            _boundingBox = [0, 0, 1, 1]
+            _maskPixelCount = 0
+            return
+        }
+
+        CVPixelBufferLockBaseAddress(maskBuffer, .readOnly)
+        defer { CVPixelBufferUnlockBaseAddress(maskBuffer, .readOnly) }
+
+        let width = CVPixelBufferGetWidth(maskBuffer)
+        let height = CVPixelBufferGetHeight(maskBuffer)
+        guard let baseAddress = CVPixelBufferGetBaseAddress(maskBuffer) else {
+            _boundingBox = [0, 0, 1, 1]
+            _maskPixelCount = 0
+            return
+        }
+
+        let bytesPerRow = CVPixelBufferGetBytesPerRow(maskBuffer)
+        let buffer = baseAddress.assumingMemoryBound(to: UInt8.self)
+
+        var minX = width
+        var maxX = 0
+        var minY = height
+        var maxY = 0
+        var pixelCount = 0
+
+        for y in 0..<height {
+            for x in 0..<width {
+                let pixelValue = buffer[y * bytesPerRow + x]
+                if pixelValue > 127 {
+                    pixelCount += 1
+                    minX = min(minX, x)
+                    maxX = max(maxX, x)
+                    minY = min(minY, y)
+                    maxY = max(maxY, y)
+                }
+            }
+        }
+
+        if pixelCount > 0 {
+            _boundingBox = [
+                Double(minX) / Double(width),
+                Double(minY) / Double(height),
+                Double(maxX - minX) / Double(width),
+                Double(maxY - minY) / Double(height)
+            ]
+        } else {
+            _boundingBox = [0, 0, 1, 1]
+        }
+        _maskPixelCount = Double(pixelCount)
+    }
+
+    func getDepthPoints() throws -> [Double] {
+        if let cached = cachedDepthPoints {
+            print("[GetDepthPoints] Returning cached \(cached.count / 3) points")
+            return cached
+        }
+
+        guard let sceneDepth = frame.sceneDepth else {
+            print("[GetDepthPoints] No sceneDepth available (LiDAR required)")
+            return []
+        }
+
+        print("[GetDepthPoints] Scene depth available, extracting points...")
+        print("[GetDepthPoints] Camera image: \(CVPixelBufferGetWidth(frame.capturedImage))x\(CVPixelBufferGetHeight(frame.capturedImage))")
+
+        guard let maskBuffer = try? mask.generateScaledMaskForImage(
+            forInstances: IndexSet(integer: selectedIndex),
+            from: VNImageRequestHandler(cvPixelBuffer: frame.capturedImage)
+        ) else {
+            return []
+        }
+
+        let depthMap = sceneDepth.depthMap
+        CVPixelBufferLockBaseAddress(depthMap, .readOnly)
+        CVPixelBufferLockBaseAddress(maskBuffer, .readOnly)
+        defer {
+            CVPixelBufferUnlockBaseAddress(depthMap, .readOnly)
+            CVPixelBufferUnlockBaseAddress(maskBuffer, .readOnly)
+        }
+
+        let depthWidth = CVPixelBufferGetWidth(depthMap)
+        let depthHeight = CVPixelBufferGetHeight(depthMap)
+        let maskWidth = CVPixelBufferGetWidth(maskBuffer)
+        let maskHeight = CVPixelBufferGetHeight(maskBuffer)
+
+        print("[GetDepthPoints] Depth buffer: \(depthWidth)x\(depthHeight), Mask: \(maskWidth)x\(maskHeight)")
+
+        guard let depthBase = CVPixelBufferGetBaseAddress(depthMap),
+              let maskBase = CVPixelBufferGetBaseAddress(maskBuffer) else {
+            return []
+        }
+
+        let depthBytesPerRow = CVPixelBufferGetBytesPerRow(depthMap)
+        let maskBytesPerRow = CVPixelBufferGetBytesPerRow(maskBuffer)
+        let depthBuffer = depthBase.assumingMemoryBound(to: Float32.self)
+        let maskBufferPtr = maskBase.assumingMemoryBound(to: UInt8.self)
+
+        // Get camera image dimensions for coordinate scaling
+        let imageWidth = CVPixelBufferGetWidth(frame.capturedImage)
+        let imageHeight = CVPixelBufferGetHeight(frame.capturedImage)
+
+        // Intrinsics are in camera image coordinate space
+        let intrinsics = frame.camera.intrinsics
+        let fx = intrinsics[0][0]
+        let fy = intrinsics[1][1]
+        let cx = intrinsics[2][0]
+        let cy = intrinsics[2][1]
+
+        var points: [Double] = []
+        points.reserveCapacity(Int(_maskPixelCount) * 3)
+
+        // Sample points from the mask
+        let stepSize = max(1, Int(sqrt(_maskPixelCount / 1000))) // Limit to ~1000 points
+
+        for maskY in stride(from: 0, to: maskHeight, by: stepSize) {
+            for maskX in stride(from: 0, to: maskWidth, by: stepSize) {
+                let maskValue = maskBufferPtr[maskY * maskBytesPerRow + maskX]
+                guard maskValue > 127 else { continue }
+
+                // Map mask coordinates to depth coordinates
+                let depthX = maskX * depthWidth / maskWidth
+                let depthY = maskY * depthHeight / maskHeight
+
+                guard depthX < depthWidth, depthY < depthHeight else { continue }
+
+                let depthIndex = depthY * depthBytesPerRow / MemoryLayout<Float32>.stride + depthX
+                let depth = depthBuffer[depthIndex]
+
+                guard depth > 0, depth < 10 else { continue } // Valid depth range
+
+                // Scale depth coordinates to camera image space for use with intrinsics
+                let imageX = Float(depthX) * Float(imageWidth) / Float(depthWidth)
+                let imageY = Float(depthY) * Float(imageHeight) / Float(depthHeight)
+
+                // Convert to 3D point in camera space using properly scaled coordinates
+                let x = Double((imageX - cx) * depth / fx)
+                let y = Double((imageY - cy) * depth / fy)
+                let z = Double(depth)
+
+                // Transform to world space
+                let cameraTransform = frame.camera.transform
+                let worldPoint = simd_mul(cameraTransform, simd_float4(Float(x), Float(-y), Float(-z), 1))
+
+                points.append(Double(worldPoint.x))
+                points.append(Double(worldPoint.y))
+                points.append(Double(worldPoint.z))
+            }
+        }
+
+        print("[GetDepthPoints] Extracted \(points.count / 3) 3D points from depth data")
+
+        // Log point cloud bounds for debugging
+        if points.count >= 3 {
+            var minX = Double.greatestFiniteMagnitude, maxX = -Double.greatestFiniteMagnitude
+            var minY = Double.greatestFiniteMagnitude, maxY = -Double.greatestFiniteMagnitude
+            var minZ = Double.greatestFiniteMagnitude, maxZ = -Double.greatestFiniteMagnitude
+            for i in stride(from: 0, to: points.count, by: 3) {
+                minX = min(minX, points[i]); maxX = max(maxX, points[i])
+                minY = min(minY, points[i+1]); maxY = max(maxY, points[i+1])
+                minZ = min(minZ, points[i+2]); maxZ = max(maxZ, points[i+2])
+            }
+            print("[GetDepthPoints] Point cloud bounds: X[\(minX)...\(maxX)], Y[\(minY)...\(maxY)], Z[\(minZ)...\(maxZ)]")
+            print("[GetDepthPoints] Extents: X=\(maxX-minX)m, Y=\(maxY-minY)m, Z=\(maxZ-minZ)m")
+        }
+
+        cachedDepthPoints = points
+        return points
+    }
+
+    func measure() throws -> ARObjectMeasurement? {
+        let points = try getDepthPoints()
+        guard points.count >= 12 else { return nil } // Need at least 4 points
+
+        // Use PCA to compute oriented bounding box
+        let pointCount = points.count / 3
+        var sumX = 0.0, sumY = 0.0, sumZ = 0.0
+
+        // Calculate centroid
+        for i in 0..<pointCount {
+            sumX += points[i * 3]
+            sumY += points[i * 3 + 1]
+            sumZ += points[i * 3 + 2]
+        }
+        let centerX = sumX / Double(pointCount)
+        let centerY = sumY / Double(pointCount)
+        let centerZ = sumZ / Double(pointCount)
+
+        // Build covariance matrix
+        var cov = [[Double]](repeating: [Double](repeating: 0, count: 3), count: 3)
+        for i in 0..<pointCount {
+            let dx = points[i * 3] - centerX
+            let dy = points[i * 3 + 1] - centerY
+            let dz = points[i * 3 + 2] - centerZ
+
+            cov[0][0] += dx * dx
+            cov[0][1] += dx * dy
+            cov[0][2] += dx * dz
+            cov[1][1] += dy * dy
+            cov[1][2] += dy * dz
+            cov[2][2] += dz * dz
+        }
+        cov[1][0] = cov[0][1]
+        cov[2][0] = cov[0][2]
+        cov[2][1] = cov[1][2]
+
+        // Simple eigenvalue estimation using power iteration
+        let (axes, eigenvalues) = computeEigenvectors(cov)
+
+        // Project points onto principal axes to find extents
+        var minProj = [Double.greatestFiniteMagnitude, Double.greatestFiniteMagnitude, Double.greatestFiniteMagnitude]
+        var maxProj = [-Double.greatestFiniteMagnitude, -Double.greatestFiniteMagnitude, -Double.greatestFiniteMagnitude]
+
+        for i in 0..<pointCount {
+            let dx = points[i * 3] - centerX
+            let dy = points[i * 3 + 1] - centerY
+            let dz = points[i * 3 + 2] - centerZ
+
+            for a in 0..<3 {
+                let proj = dx * axes[a][0] + dy * axes[a][1] + dz * axes[a][2]
+                minProj[a] = min(minProj[a], proj)
+                maxProj[a] = max(maxProj[a], proj)
+            }
+        }
+
+        // Calculate dimensions (sorted: width >= height >= depth)
+        var dims = [
+            maxProj[0] - minProj[0],
+            maxProj[1] - minProj[1],
+            maxProj[2] - minProj[2]
+        ].sorted(by: >)
+
+        // Flatten axes for output
+        let flatAxes = axes.flatMap { $0 }
+
+        // Confidence based on point density and spread
+        let totalVariance = eigenvalues.reduce(0, +)
+        let confidence = min(1.0, Double(pointCount) / 500.0) * min(1.0, totalVariance / 0.1)
+
+        return ARObjectMeasurement(
+            width: dims[0],
+            height: dims[1],
+            depth: dims[2],
+            center: [centerX, centerY, centerZ],
+            axes: flatAxes,
+            confidence: confidence,
+            pointCount: Double(pointCount)
+        )
+    }
+
+    private func computeEigenvectors(_ matrix: [[Double]]) -> ([[Double]], [Double]) {
+        // Simplified power iteration for 3x3 symmetric matrix
+        var vectors: [[Double]] = [
+            [1, 0, 0],
+            [0, 1, 0],
+            [0, 0, 1]
+        ]
+        var eigenvalues = [0.0, 0.0, 0.0]
+
+        for i in 0..<3 {
+            var v = vectors[i]
+
+            // Power iteration
+            for _ in 0..<20 {
+                var newV = [0.0, 0.0, 0.0]
+                for row in 0..<3 {
+                    for col in 0..<3 {
+                        newV[row] += matrix[row][col] * v[col]
+                    }
+                }
+
+                // Orthogonalize against previous vectors
+                for j in 0..<i {
+                    let dot = newV[0] * vectors[j][0] + newV[1] * vectors[j][1] + newV[2] * vectors[j][2]
+                    newV[0] -= dot * vectors[j][0]
+                    newV[1] -= dot * vectors[j][1]
+                    newV[2] -= dot * vectors[j][2]
+                }
+
+                // Normalize
+                let len = sqrt(newV[0] * newV[0] + newV[1] * newV[1] + newV[2] * newV[2])
+                if len > 1e-10 {
+                    v = [newV[0] / len, newV[1] / len, newV[2] / len]
+                }
+            }
+
+            vectors[i] = v
+
+            // Calculate eigenvalue
+            var av = [0.0, 0.0, 0.0]
+            for row in 0..<3 {
+                for col in 0..<3 {
+                    av[row] += matrix[row][col] * v[col]
+                }
+            }
+            eigenvalues[i] = av[0] * v[0] + av[1] * v[1] + av[2] * v[2]
+        }
+
+        return (vectors, eigenvalues)
+    }
+}

package/ios/HybridARView.swift

@@ -2,6 +2,7 @@ import ARKit
 import SceneKit
 import UIKit
 import NitroModules
+import Vision
 
 class HybridARView: HybridARViewSpec {
     // The underlying AR view
@@ -90,13 +91,8 @@ class HybridARView: HybridARViewSpec {
     }
 
     private func updateOcclusionSettings() {
-        #if !targetEnvironment(simulator)
-        if #available(iOS 13.0, *) {
-            if peopleOcclusion == true {
-                arView.environment.sceneUnderstanding.options.insert(.occlusion)
-            }
-        }
-        #endif
+        // Occlusion is configured via frameSemantics in startSession/resetSession
+        // ARSCNView doesn't have an environment property like RealityKit's ARView
     }
 
     private func updateDebugOptions() {
@@ -202,6 +198,116 @@ class HybridARView: HybridARViewSpec {
         return false
     }
 
+    // MARK: - Object Segmentation & Measurement
+
+    func segmentObject(x: Double, y: Double) throws -> Promise<(any HybridARSegmentationResultSpec)?> {
+        return Promise.async { [weak self] in
+            guard let self = self else {
+                print("[SegmentObject] self is nil")
+                return nil
+            }
+
+            guard #available(iOS 17.0, *) else {
+                print("[SegmentObject] iOS 17+ required")
+                return nil
+            }
+
+            guard let frame = self.arView.session.currentFrame else {
+                print("[SegmentObject] No current frame")
+                return nil
+            }
+
+            let imageWidth = CGFloat(CVPixelBufferGetWidth(frame.capturedImage))
+            let imageHeight = CGFloat(CVPixelBufferGetHeight(frame.capturedImage))
+
+            print("[SegmentObject] Screen normalized: (\(x), \(y))")
+            print("[SegmentObject] Image size: \(imageWidth) x \(imageHeight)")
+
+            // Perform instance segmentation
+            let request = VNGenerateForegroundInstanceMaskRequest()
+            let handler = VNImageRequestHandler(cvPixelBuffer: frame.capturedImage, orientation: .right)
+
+            do {
+                try handler.perform([request])
+            } catch {
+                print("[SegmentObject] Vision request failed: \(error)")
+                return nil
+            }
+
+            guard let observation = request.results?.first else {
+                print("[SegmentObject] No segmentation results")
+                return nil
+            }
+
+            // Find which instance contains the tapped point
+            let instances = observation.allInstances
+            print("[SegmentObject] Found \(instances.count) instances")
+
+            if instances.isEmpty {
+                print("[SegmentObject] No foreground instances detected in scene")
+                return nil
+            }
+
+            // For now, just use the first (usually largest/most prominent) instance
+            // TODO: Improve tap-to-instance mapping
+            let selectedIndex = instances.first!
+
+            print("[SegmentObject] Selected instance \(selectedIndex)")
+            return HybridARSegmentationResult(
+                mask: observation,
+                selectedIndex: selectedIndex,
+                frame: frame,
+                sceneView: self.arView
+            )
+        }
+    }
+
+    func measureObject(x: Double, y: Double) throws -> Promise<ARObjectMeasurement?> {
+        return Promise.async { [weak self] in
+            guard let self = self else {
+                print("[MeasureObject] self is nil")
+                throw NSError(domain: "ARView", code: 1, userInfo: [NSLocalizedDescriptionKey: "View not available"])
+            }
+
+            guard #available(iOS 17.0, *) else {
+                print("[MeasureObject] iOS 17+ required")
+                throw NSError(domain: "ARView", code: 2, userInfo: [NSLocalizedDescriptionKey: "iOS 17+ required for object measurement"])
+            }
+
+            guard self.arView.session.currentFrame != nil else {
+                print("[MeasureObject] No current frame")
+                throw NSError(domain: "ARView", code: 3, userInfo: [NSLocalizedDescriptionKey: "No AR frame available"])
+            }
+
+            guard self.arView.session.currentFrame?.sceneDepth != nil else {
+                print("[MeasureObject] No scene depth - LiDAR required")
+                throw NSError(domain: "ARView", code: 4, userInfo: [NSLocalizedDescriptionKey: "LiDAR depth data not available. Is sceneDepth enabled?"])
+            }
+
+            print("[MeasureObject] Starting measurement at (\(x), \(y))")
+
+            // First segment the object
+            let segmentationResult = try await self.segmentObject(x: x, y: y).await()
+
+            guard let segmentation = segmentationResult as? HybridARSegmentationResult else {
+                print("[MeasureObject] Segmentation failed or no object found")
+                throw NSError(domain: "ARView", code: 5, userInfo: [NSLocalizedDescriptionKey: "No foreground object detected. Try pointing at a distinct object."])
+            }
+
+            print("[MeasureObject] Segmentation successful, measuring...")
+
+            // Then measure it
+            let measurement = try segmentation.measure()
+            if let m = measurement {
+                print("[MeasureObject] Measurement: W=\(m.width), H=\(m.height), D=\(m.depth), confidence=\(m.confidence)")
+            } else {
+                print("[MeasureObject] Measurement returned nil (not enough depth points?)")
+                throw NSError(domain: "ARView", code: 6, userInfo: [NSLocalizedDescriptionKey: "Not enough depth points for measurement. Move closer to the object."])
+            }
+            return measurement
+        }
+    }
+
     // MARK: - Session Control
 
     func startSession() throws {

package/lib/commonjs/index.js.map

@@ -1 +1 @@
-{"version":3,"names":["_reactNativeNitroModules","require","_ARViewConfig","_interopRequireDefault","e","__esModule","default","ARView","exports","getHostComponent","ARViewConfig","createARSession","NitroModules","createHybridObject","createARBoundingBoxBuilder"],"sourceRoot":"../../src","sources":["index.ts"],"mappings":";;;;;;;;AAAA,IAAAA,wBAAA,GAAAC,OAAA;AACA,IAAAC,aAAA,GAAAC,sBAAA,CAAAF,OAAA;AAA+E,SAAAE,uBAAAC,CAAA,WAAAA,CAAA,IAAAA,CAAA,CAAAC,UAAA,GAAAD,CAAA,KAAAE,OAAA,EAAAF,CAAA;AAiC/E;;AAeA;AACO,MAAMG,MAAM,GAAAC,OAAA,CAAAD,MAAA,GAAG,IAAAE,yCAAgB,EAA6B,QAAQ,EAAE,MAAMC,qBAAY,CAAC;;AAEhG;AACO,SAASC,eAAeA,CAAA,EAAc;EAC3C,OAAOC,qCAAY,CAACC,kBAAkB,CAAY,WAAW,CAAC;AAChE;AAEO,SAASC,0BAA0BA,CAAA,EAAyB;EACjE,OAAOF,qCAAY,CAACC,kBAAkB,CAAuB,sBAAsB,CAAC;AACtF","ignoreList":[]}
+{"version":3,"names":["_reactNativeNitroModules","require","_ARViewConfig","_interopRequireDefault","e","__esModule","default","ARView","exports","getHostComponent","ARViewConfig","createARSession","NitroModules","createHybridObject","createARBoundingBoxBuilder"],"sourceRoot":"../../src","sources":["index.ts"],"mappings":";;;;;;;;AAAA,IAAAA,wBAAA,GAAAC,OAAA;AACA,IAAAC,aAAA,GAAAC,sBAAA,CAAAF,OAAA;AAA+E,SAAAE,uBAAAC,CAAA,WAAAA,CAAA,IAAAA,CAAA,CAAAC,UAAA,GAAAD,CAAA,KAAAE,OAAA,EAAAF,CAAA;AAqC/E;;AAeA;AACO,MAAMG,MAAM,GAAAC,OAAA,CAAAD,MAAA,GAAG,IAAAE,yCAAgB,EAA6B,QAAQ,EAAE,MAAMC,qBAAY,CAAC;;AAEhG;AACO,SAASC,eAAeA,CAAA,EAAc;EAC3C,OAAOC,qCAAY,CAACC,kBAAkB,CAAY,WAAW,CAAC;AAChE;AAEO,SAASC,0BAA0BA,CAAA,EAAyB;EACjE,OAAOF,qCAAY,CAACC,kBAAkB,CAAuB,sBAAsB,CAAC;AACtF","ignoreList":[]}

package/lib/commonjs/specs/ARObjectMeasurement.nitro.js

@@ -0,0 +1,6 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+//# sourceMappingURL=ARObjectMeasurement.nitro.js.map

package/lib/commonjs/specs/ARObjectMeasurement.nitro.js.map

@@ -0,0 +1 @@
+{"version":3,"names":[],"sourceRoot":"../../../src","sources":["specs/ARObjectMeasurement.nitro.ts"],"mappings":"","ignoreList":[]}

package/lib/module/index.js.map

@@ -1 +1 @@
-{"version":3,"names":["getHostComponent","NitroModules","ARViewConfig","ARView","createARSession","createHybridObject","createARBoundingBoxBuilder"],"sourceRoot":"../../src","sources":["index.ts"],"mappings":";;AAAA,SAASA,gBAAgB,EAAEC,YAAY,QAAQ,4BAA4B;AAC3E,OAAOC,YAAY,MAAM,qDAAqD;;AAiC9E;;AAeA;AACA,OAAO,MAAMC,MAAM,GAAGH,gBAAgB,CAA6B,QAAQ,EAAE,MAAME,YAAY,CAAC;;AAEhG;AACA,OAAO,SAASE,eAAeA,CAAA,EAAc;EAC3C,OAAOH,YAAY,CAACI,kBAAkB,CAAY,WAAW,CAAC;AAChE;AAEA,OAAO,SAASC,0BAA0BA,CAAA,EAAyB;EACjE,OAAOL,YAAY,CAACI,kBAAkB,CAAuB,sBAAsB,CAAC;AACtF","ignoreList":[]}
+{"version":3,"names":["getHostComponent","NitroModules","ARViewConfig","ARView","createARSession","createHybridObject","createARBoundingBoxBuilder"],"sourceRoot":"../../src","sources":["index.ts"],"mappings":";;AAAA,SAASA,gBAAgB,EAAEC,YAAY,QAAQ,4BAA4B;AAC3E,OAAOC,YAAY,MAAM,qDAAqD;;AAqC9E;;AAeA;AACA,OAAO,MAAMC,MAAM,GAAGH,gBAAgB,CAA6B,QAAQ,EAAE,MAAME,YAAY,CAAC;;AAEhG;AACA,OAAO,SAASE,eAAeA,CAAA,EAAc;EAC3C,OAAOH,YAAY,CAACI,kBAAkB,CAAY,WAAW,CAAC;AAChE;AAEA,OAAO,SAASC,0BAA0BA,CAAA,EAAyB;EACjE,OAAOL,YAAY,CAACI,kBAAkB,CAAuB,sBAAsB,CAAC;AACtF","ignoreList":[]}

package/lib/module/specs/ARObjectMeasurement.nitro.js

@@ -0,0 +1,4 @@
+"use strict";
+
+export {};
+//# sourceMappingURL=ARObjectMeasurement.nitro.js.map

package/lib/module/specs/ARObjectMeasurement.nitro.js.map

@@ -0,0 +1 @@
+{"version":3,"names":[],"sourceRoot":"../../../src","sources":["specs/ARObjectMeasurement.nitro.ts"],"mappings":"","ignoreList":[]}

package/lib/typescript/src/index.d.ts

@@ -7,6 +7,7 @@ export type { ARDepthData } from "./specs/ARDepthData.nitro";
 export type { ARFrame } from "./specs/ARFrame.nitro";
 export type { ARDirectionalLightEstimate, ARLightEstimate, } from "./specs/ARLightEstimate.nitro";
 export type { ARMeasurement } from "./specs/ARMeasurement.nitro";
+export type { ARObjectMeasurement, ARSegmentationResult, } from "./specs/ARObjectMeasurement.nitro";
 export type { ARPlaneAnchor, ARPlaneGeometry, PlaneAlignment, PlaneClassification, } from "./specs/ARPlaneAnchor.nitro";
 export type { ARRaycastResult, RaycastAlignment, RaycastQuery, RaycastTarget, } from "./specs/ARRaycastResult.nitro";
 export type { ARMeshAnchor, LiDARCapabilities, MeshClassification, SceneReconstructionMode, } from "./specs/ARSceneMesh.nitro";

package/lib/typescript/src/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/index.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,oCAAoC,CAAC;AAC/E,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAC;AACzD,OAAO,KAAK,EAAE,aAAa,EAAE,WAAW,EAAE,MAAM,sBAAsB,CAAC;AAEvE,YAAY,EAAE,QAAQ,EAAE,MAAM,wBAAwB,CAAC;AACvD,YAAY,EAAE,oBAAoB,EAAE,MAAM,oCAAoC,CAAC;AAC/E,YAAY,EAAE,WAAW,EAAE,MAAM,2BAA2B,CAAC;AAC7D,YAAY,EAAE,OAAO,EAAE,MAAM,uBAAuB,CAAC;AACrD,YAAY,EACV,0BAA0B,EAC1B,eAAe,GAChB,MAAM,+BAA+B,CAAC;AACvC,YAAY,EAAE,aAAa,EAAE,MAAM,6BAA6B,CAAC;AAEjE,YAAY,EACV,aAAa,EACb,eAAe,EACf,cAAc,EACd,mBAAmB,GACpB,MAAM,6BAA6B,CAAC;AACrC,YAAY,EACV,eAAe,EACf,gBAAgB,EAChB,YAAY,EACZ,aAAa,GACd,MAAM,+BAA+B,CAAC;AACvC,YAAY,EACV,YAAY,EACZ,iBAAiB,EACjB,kBAAkB,EAClB,uBAAuB,GACxB,MAAM,2BAA2B,CAAC;AAEnC,YAAY,EACV,SAAS,EACT,sBAAsB,EACtB,UAAU,EACV,oBAAoB,EACpB,kBAAkB,EAClB,aAAa,EACb,mBAAmB,EACnB,cAAc,GACf,MAAM,yBAAyB,CAAC;AACjC,YAAY,EAAE,eAAe,EAAE,aAAa,EAAE,WAAW,EAAE,MAAM,sBAAsB,CAAC;AACxF,YAAY,EAAE,QAAQ,EAAE,MAAM,wBAAwB,CAAC;AACvD,YAAY,EAAE,UAAU,EAAE,kBAAkB,EAAE,MAAM,0BAA0B,CAAC;AAG/E,eAAO,MAAM,MAAM,kFAA6E,CAAC;AAGjG,wBAAgB,eAAe,IAAI,SAAS,CAE3C;AAED,wBAAgB,0BAA0B,IAAI,oBAAoB,CAEjE"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/index.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,oCAAoC,CAAC;AAC/E,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAC;AACzD,OAAO,KAAK,EAAE,aAAa,EAAE,WAAW,EAAE,MAAM,sBAAsB,CAAC;AAEvE,YAAY,EAAE,QAAQ,EAAE,MAAM,wBAAwB,CAAC;AACvD,YAAY,EAAE,oBAAoB,EAAE,MAAM,oCAAoC,CAAC;AAC/E,YAAY,EAAE,WAAW,EAAE,MAAM,2BAA2B,CAAC;AAC7D,YAAY,EAAE,OAAO,EAAE,MAAM,uBAAuB,CAAC;AACrD,YAAY,EACV,0BAA0B,EAC1B,eAAe,GAChB,MAAM,+BAA+B,CAAC;AACvC,YAAY,EAAE,aAAa,EAAE,MAAM,6BAA6B,CAAC;AACjE,YAAY,EACV,mBAAmB,EACnB,oBAAoB,GACrB,MAAM,mCAAmC,CAAC;AAE3C,YAAY,EACV,aAAa,EACb,eAAe,EACf,cAAc,EACd,mBAAmB,GACpB,MAAM,6BAA6B,CAAC;AACrC,YAAY,EACV,eAAe,EACf,gBAAgB,EAChB,YAAY,EACZ,aAAa,GACd,MAAM,+BAA+B,CAAC;AACvC,YAAY,EACV,YAAY,EACZ,iBAAiB,EACjB,kBAAkB,EAClB,uBAAuB,GACxB,MAAM,2BAA2B,CAAC;AAEnC,YAAY,EACV,SAAS,EACT,sBAAsB,EACtB,UAAU,EACV,oBAAoB,EACpB,kBAAkB,EAClB,aAAa,EACb,mBAAmB,EACnB,cAAc,GACf,MAAM,yBAAyB,CAAC;AACjC,YAAY,EAAE,eAAe,EAAE,aAAa,EAAE,WAAW,EAAE,MAAM,sBAAsB,CAAC;AACxF,YAAY,EAAE,QAAQ,EAAE,MAAM,wBAAwB,CAAC;AACvD,YAAY,EAAE,UAAU,EAAE,kBAAkB,EAAE,MAAM,0BAA0B,CAAC;AAG/E,eAAO,MAAM,MAAM,kFAA6E,CAAC;AAGjG,wBAAgB,eAAe,IAAI,SAAS,CAE3C;AAED,wBAAgB,0BAA0B,IAAI,oBAAoB,CAEjE"}

package/lib/typescript/src/specs/ARObjectMeasurement.nitro.d.ts

@@ -0,0 +1,34 @@
+import type { HybridObject } from "react-native-nitro-modules";
+/** Result of measuring an object in 3D space */
+export interface ARObjectMeasurement {
+    /** Width in meters (X axis) */
+    width: number;
+    /** Height in meters (Y axis) */
+    height: number;
+    /** Depth in meters (Z axis) */
+    depth: number;
+    /** Center position in world space [x, y, z] */
+    center: number[];
+    /** Orientation axes (3x3 matrix as 9 values) */
+    axes: number[];
+    /** Confidence score 0-1 */
+    confidence: number;
+    /** Number of 3D points used for measurement */
+    pointCount: number;
+}
+/** Result of object segmentation */
+export interface ARSegmentationResult extends HybridObject<{
+    ios: "swift";
+}> {
+    /** Whether segmentation was successful */
+    readonly success: boolean;
+    /** Bounding box in normalized coordinates [x, y, width, height] */
+    readonly boundingBox: number[];
+    /** Number of pixels in the mask */
+    readonly maskPixelCount: number;
+    /** Get 3D points within the segmented region (requires LiDAR) */
+    getDepthPoints(): number[];
+    /** Measure the segmented object */
+    measure(): ARObjectMeasurement | undefined;
+}
+//# sourceMappingURL=ARObjectMeasurement.nitro.d.ts.map