LiDAR Scanner
Technical Guide

Chapter 01 What is LiDAR?

1.1 The Physics of Laser Depth Sensing

LiDAR stands for Light Detection and Ranging. The sensor fires invisible infrared laser pulses at a scene and measures the exact time each pulse takes to bounce back. Because light travels at a known speed (~300,000 km/s), the sensor calculates the distance to every point it hits.

1.2 iPad Pro LiDAR Specs

Chapter 02 How ARKit Uses the Sensor

2.1 Scene Reconstruction Pipeline

ARKit runs a multi-stage pipeline to turn raw LiDAR depth data into the clean 3D mesh your app receives:

2.2 ARMeshAnchor — The Data Container

Each ARMeshAnchor represents a region of the reconstructed mesh. It contains:

• geometry.vertices — buffer of Float3 positions (X, Y, Z in metres, local space)
• geometry.faces — buffer of triangle indices (3 × UInt32 per face)
• geometry.normals — surface normal vectors per vertex
• geometry.classification — per-face semantic label (floor, wall, etc.)
• transform — 4×4 matrix to convert local → world coordinates

Chapter 03 Project Setup (Xcode + Sideload)

3.1 What You Need

3.2 Step-by-Step: Create the Xcode Project

• Open Xcode → File → New → Project
• Select iOS → App → click Next
• Fill in: Product Name = LiDARScanner, Interface = SwiftUI, Language = Swift
• Choose a save location → Create
• Delete the auto-generated ContentView.swift (we replace it with our own)
• Drag in all 5 Swift files from the downloaded zip (LiDARScannerApp, ContentView, ARViewContainer, ScanManager, ShareSheet)
• Drag Info.plist into the project — in the dialog, choose "Copy items if needed"

Chapter 04 App Architecture & File Map

4.1 File Structure

4.2 Data Flow

Chapter 05 Full Code Walkthrough

5.1 App Entry Point — LiDARScannerApp.swift

The simplest file. Swift's @main attribute marks this as the application entry point. SwiftUI's App protocol launches a WindowGroup containing ContentView.

import SwiftUI

@main
struct LiDARScannerApp: App {
  var body: some Scene {
    WindowGroup {
      ContentView() // Root view
    }
  }
}Swift

5.2 ARView Bridge — ARViewContainer.swift

RealityKit's ARView is a UIKit component (UIView). SwiftUI cannot use UIKit views directly — you need a UIViewRepresentable wrapper. This struct is that bridge.

struct ARViewContainer: UIViewRepresentable {
  @ObservedObject var scanManager: ScanManager

  // Called ONCE: create the ARView
  func makeUIView(context: Context) -> ARView {
    let arView = ARView(frame: .zero)
    scanManager.setup(arView: arView) // hand off to ScanManager
    return arView
  }

  // Called on SwiftUI re-renders: nothing to update
  func updateUIView(_ uiView: ARView, context: Context) {}
}Swift

Chapter 06 Mesh Capture Logic (ScanManager)

6.1 Class Declaration & State

ScanManager inherits from NSObject (required by ARSessionDelegate), ObservableObject (so SwiftUI can react to changes), and ARSessionDelegate (to receive mesh updates from ARKit).

@MainActor
class ScanManager: NSObject, ObservableObject, ARSessionDelegate {
  // Published = SwiftUI watches these automatically
  @Published var meshAnchorCount: Int = 0
  @Published var totalVertexCount: Int = 0
  @Published var totalFaceCount: Int = 0
  @Published var statusMessage: String = "Move iPad to start scanning"
  @Published var showMesh: Bool = true

  // Internal storage: one entry per mesh region
  private var meshAnchors: [UUID: ARMeshAnchor] = [:]
  private weak var arView: ARView?
}Swift

6.2 Starting the AR Session

func setup(arView: ARView) {
  self.arView = arView
  arView.session.delegate = self

  guard ARWorldTrackingConfiguration
    .supportsSceneReconstruction(.meshWithClassification) else {
    statusMessage = "LiDAR not available"
    return
  }
  startSession()
}

private func startSession() {
  let config = ARWorldTrackingConfiguration()
  config.sceneReconstruction = .meshWithClassification
  config.environmentTexturing = .automatic
  config.planeDetection = [.horizontal, .vertical]
  arView?.session.run(config, options: [.resetTracking, .removeExistingAnchors])
  arView?.debugOptions = showMesh ? [.showSceneUnderstanding] : []
}Swift

6.3 Receiving Mesh Delegate Callbacks

nonisolated func session(_ session: ARSession, didAdd anchors: [ARAnchor]) {
  let meshes = anchors.compactMap { $0 as? ARMeshAnchor }
  guard !meshes.isEmpty else { return }
  Task { @MainActor in self.addMeshAnchors(meshes) }
}

nonisolated func session(_ session: ARSession, didUpdate anchors: [ARAnchor]) {
  let meshes = anchors.compactMap { $0 as? ARMeshAnchor }
  guard !meshes.isEmpty else { return }
  Task { @MainActor in self.updateMeshAnchors(meshes) }
}

nonisolated func session(_ session: ARSession, didRemove anchors: [ARAnchor]) {
  let ids = anchors.compactMap { $0 as? ARMeshAnchor }.map { $0.identifier }
  guard !ids.isEmpty else { return }
  Task { @MainActor in self.removeMeshAnchors(ids) }
}Swift

Chapter 07 Export Pipeline (USDZ / OBJ / PLY)

7.1 Overview: ARKit Geometry → ModelIO → File

7.2 Export Formats Compared

Chapter 08 UI Layer (SwiftUI)

8.1 Layout Structure

The UI is a ZStack — a layered stack. ARViewContainer fills the background (full screen camera feed + mesh), and all controls float on top as overlays.

ZStack {
  ARViewContainer(scanManager: scanManager)
    .ignoresSafeArea()
  VStack {
    // Top bar: title, status, mesh toggle button
    HStack { ... }.background(gradient: black → clear)
    Spacer()
    // Middle: vertex/face stats badges
    HStack { StatBadge(...) ... }
    // Bottom: Reset + Export buttons
    HStack { ... }.background(gradient: clear → black)
  }
}Swift

8.2 Reactive State

ContentView creates ScanManager as a @StateObject. Any change to its @Published properties automatically re-renders the relevant parts of the UI.

@StateObject private var scanManager = ScanManager()

// These auto-update the StatBadges:
scanManager.meshAnchorCount      // → "Anchors: 12"
scanManager.vertexCountFormatted  // → "Vertices: 48.2K"
scanManager.faceCountFormatted    // → "Faces: 31.7K"
scanManager.statusMessage         // → "Scanning... 12 mesh regions"Swift

Chapter 09 Known Limitations

Chapter 10 Next Steps & Upgrades

10.1 Texture Baking

The biggest missing feature: color on the exported mesh. Capture ARFrame.capturedImage alongside the depth, project camera pixels onto mesh triangles using the camera's intrinsic matrix, and bake a texture atlas into the OBJ export as an MTL material file. Apple's Object Capture API (on macOS) can do this automatically from a video scan.

10.2 Mesh Simplification

Raw ARKit meshes can be very dense. Adding a decimation step would shrink file sizes massively. ModelIO has built-in support via generateAmbientOcclusionTexture, or use a third-party lib like MeshOptimizer via Swift Package Manager.

10.3 Object Isolation

Use ARKit's mesh classification to filter and keep only specific surface types during export:

// Filter to only table-top objects during export
let classification = anchor.geometry.classificationOf(face: faceIndex)
if classification == .table || classification == .none {
  // include this face
}Swift

10.4 LiDAR → AI Texture Upgrade