AI Object Measurement from Photos in Mobile Apps

A client wants to measure the length of a sofa from a single photo—without a tape measure or special equipment. We implemented this feature in mobile apps with accuracy up to 2% under proper conditions. Our experience: 5+ years in iOS/Android development, 30+ projects with AR and computer vision. We offer a turnkey solution: from method selection (LiDAR, SLAM, or monocular depth) to integration with your backend. Get a consultation—we'll evaluate your project in one day.

Which Measurement Method to Choose: LiDAR, SLAM, or Monocular Depth?

ARKit/ARCore (LiDAR or SLAM) is accurate but requires device support. iPhone 12 Pro and newer with LiDAR deliver 1–3 cm accuracy at distances up to 5 meters. ARCore on Android without LiDAR is worse, with 3–8 cm error.

Monocular depth estimation works on any device without LiDAR, using CNN to estimate depth from a single frame. MiDaS, DPT, Depth Anything V2 are current models. Accuracy is noticeably lower than LiDAR but sufficient for many tasks.

// iOS: method selection based on device capabilities
func selectMeasurementMethod() -> MeasurementMethod {
    if ARWorldTrackingConfiguration.supportsSceneReconstruction(.mesh) {
        return .lidarARKit // iPhone 12 Pro+, iPad Pro
    } else if ARWorldTrackingConfiguration.isSupported {
        return .slamARKit // ARKit without LiDAR
    } else {
        return .monocularDepth // fallback to CoreML model
    }
}

What Affects Measurement Accuracy?

Measurement accuracy directly depends on shooting conditions: lighting, surface texture, distance to the object, and camera angle. White walls without texture degrade SLAM tracking, and high lighting can cause overexposure. For stable results:

• Textured surfaces (black, glossy objects are harder to detect)
• Distance to the object no more than 5 m with LiDAR, 3 m with SLAM
• Minimize dynamic objects in the frame
• Proper camera focus

How We Implement Measurement via ARKit

// Measuring distance between two points in AR
class ARMeasurementSession: NSObject, ARSessionDelegate {
    var arView: ARSCNView!
    private var startAnchor: ARAnchor?
    private var endAnchor: ARAnchor?

    func placePoint(at screenPoint: CGPoint) -> MeasurementPoint? {
        // Raycast from screen to 3D world space
        guard let query = arView.raycastQuery(
            from: screenPoint,
            allowing: .estimatedPlane,
            alignment: .any
        ) else { return nil }
        guard let result = arView.session.raycast(query).first else { return nil }
        let worldPosition = result.worldTransform.columns.3 // position in meters
        return MeasurementPoint(
            position: SIMD3(worldPosition.x, worldPosition.y, worldPosition.z),
            confidence: result.targetAlignment == .horizontal ? .high : .medium
        )
    }

    func calculateDistance(from start: MeasurementPoint, to end: MeasurementPoint) -> Measurement<UnitLength> {
        let diff = end.position - start.position
        let distanceMeters = Double(simd_length(diff))
        return Measurement(value: distanceMeters, unit: .meters)
    }
}

A common mistake is not accounting that raycast works best on well-textured surfaces. A white wall produces poor SLAM tracking, causing AR markers to drift.

Displaying the Measurement in AR

func addMeasurementLine(from start: SIMD3<Float>, to end: SIMD3<Float>, distance: String) {
    let midpoint = (start + end) / 2
    // Line between points
    let lineNode = SCNNode(geometry: createCylinder(from: start, to: end))
    // Label with distance at midpoint
    let labelNode = SCNNode(geometry: SCNText(string: distance, extrusionDepth: 0.001))
    labelNode.position = SCNVector3(midpoint.x, midpoint.y + 0.02, midpoint.z)
    labelNode.scale = SCNVector3(0.005, 0.005, 0.005)
    labelNode.constraints = [SCNBillboardConstraint()] // always face the camera
    sceneRoot.addChildNode(lineNode)
    sceneRoot.addChildNode(labelNode)
}

Reference Object Approach for Photo Measurement

Without AR—an object of known size in the frame is needed. A bank card (85.6 × 53.98 mm) is a convenient reference:

// Android: measurement via reference object
class ReferenceObjectMeasurer {
    fun measureWithCard(bitmap: Bitmap, cardBoundingBox: RectF, objectBoundingBox: RectF): MeasurementResult {
        // Real card dimensions
        val cardRealWidth = 85.6f // mm
        val cardRealHeight = 53.98f

        // Pixels → mm
        val pixelsPerMmHorizontal = cardBoundingBox.width() / cardRealWidth
        val pixelsPerMmVertical = cardBoundingBox.height() / cardRealHeight

        // Perspective distortion correction (simplified)
        val correctionFactor = estimatePerspectiveCorrection(
            cardBoundingBox,
            imageDimensions = bitmap.width to bitmap.height
        )

        return MeasurementResult(
            widthMm = (objectBoundingBox.width() / pixelsPerMmHorizontal) * correctionFactor,
            heightMm = (objectBoundingBox.height() / pixelsPerMmVertical) * correctionFactor,
            accuracy = MeasurementAccuracy.MODERATE // ±5-10% without calibration
        )
    }
}

Card detection in the frame is done via ML Kit Object Detection or a custom YOLOv8 model (easy to train on 500 card photos in various conditions).

Process: From Idea to Release

1. Analytics — study business requirements, audience devices, required accuracy.
2. Design — choose architecture: native ARKit/ARCore or cross-platform, define measurement method (LiDAR/SLAM/monocular depth).
3. Implementation — develop MVP with basic UI (two points, line), integrate CoreML/ML Kit, configure calibration.
4. Testing — verify accuracy on 10+ devices under different shooting conditions, A/B tests.
5. Deployment — prepare for App Store and Google Play release, documentation, TestFlight/Firebase Distribution.

What's Included in the Work

• Architectural documentation and API description
• Integration with your CRM/backend via REST or GraphQL
• Training your team on using the feature
• 3 months of technical support
• Access to source code (with modification rights)
• Certificates from Apple and Google (if required)

We are certified Apple and Google developers. We guarantee measurement accuracy in compliance with App Store Review Guidelines (Section 4.2/5.1). Over 5 years, we have delivered 30+ projects in e-commerce, construction, and healthcare.