🐌 MEDIUM: Optimize Performance Bottlenecks and Algorithms

[TangoEcho]

Problem Description

Several performance bottlenecks causing poor user experience, particularly in heatmap generation, AR node management, and spatial calculations.

Current Issues

1. O(n²) Heatmap Interpolation (WiFiSurveyManager.swift:400-454)

   • Nested loops creating coverage grid without spatial optimization
   • Performance degrades significantly with more measurement points
   • UI freezes during heatmap generation with >50 measurements

2. Inefficient AR Node Creation (ARVisualizationManager.swift:295-331)

   • Creating new SCNNode objects for every WiFi measurement
   • Poor object pooling implementation
   • Memory pressure and frame drops during AR sessions

3. Spatial Query Performance

   • Linear search for nearest neighbors in room analysis
   • No spatial indexing for furniture positioning
   • Expensive distance calculations repeated unnecessarily

Affected Files

• RoomPlanSimple/WiFiSurveyManager.swift (lines 400-454)
• RoomPlanSimple/ARVisualizationManager.swift (lines 295-331)
• RoomPlanSimple/RoomAnalyzer.swift (furniture clustering algorithms)

Current Problematic Code

O(n²) Heatmap Algorithm

// PROBLEMATIC CODE: O(n²) interpolation
func generateHeatmapData() -> [CoveragePoint] {
    var heatmapPoints: [CoveragePoint] = []
    
    // ❌ Nested loops create O(n²) complexity
    for x in stride(from: bounds.minX, to: bounds.maxX, by: gridSpacing) {
        for y in stride(from: bounds.minY, to: bounds.maxY, by: gridSpacing) {
            let gridPoint = simd_float2(x, y)
            
            // ❌ Linear search through all measurements for each grid point  
            var totalWeight: Float = 0
            var weightedSignal: Float = 0
            
            for measurement in measurements { // ❌ O(n) for each grid point
                let distance = simd_distance(gridPoint, measurement.location2D)
                let weight = 1.0 / max(distance, 0.1)
                totalWeight += weight
                weightedSignal += Float(measurement.signalStrength) * weight
            }
        }
    }
}

Inefficient Node Management

// PROBLEMATIC CODE: Poor object pooling
func getOrCreateMeasurementNode(for measurement: WiFiMeasurement) -> SCNNode {
    // ❌ Node pool not properly utilized
    if let pooledNode = nodePool.popLast() {
        // ❌ Complete reconfiguration instead of minimal updates
        configureNode(pooledNode, for: measurement) // Expensive reconfiguration
        return pooledNode
    }
    
    // ❌ Creating new nodes frequently causes memory pressure
    return createNewMeasurementNode(for: measurement)
}

Solution

1. Spatial Data Structure for Heatmap

// SOLUTION: Use spatial indexing for O(log n) lookups
class SpatialGrid {
    private let cellSize: Float
    private var cells: [Int: [WiFiMeasurement]] = [:]
    
    func insert(_ measurement: WiFiMeasurement) {
        let cellIndex = getCellIndex(for: measurement.location2D)
        cells[cellIndex, default: []].append(measurement)
    }
    
    func nearestNeighbors(to point: simd_float2, within radius: Float) -> [WiFiMeasurement] {
        let searchCells = getCellsInRadius(point, radius: radius)
        return searchCells.flatMap { cells[$0] ?? [] }
            .filter { simd_distance(point, $0.location2D) <= radius }
    }
}

// Optimized heatmap generation
func generateOptimizedHeatmap() -> [CoveragePoint] {
    let spatialGrid = SpatialGrid(cellSize: 2.0) // 2m cells
    
    // Build spatial index once: O(n)
    for measurement in measurements {
        spatialGrid.insert(measurement)
    }
    
    // Generate heatmap with spatial queries: O(n log n)
    return gridPoints.compactMap { gridPoint in
        let nearby = spatialGrid.nearestNeighbors(to: gridPoint, within: maxInterpolationDistance)
        return interpolateSignalStrength(at: gridPoint, from: nearby)
    }
}

2. Efficient Node Pool Management

// SOLUTION: Smart object pooling with minimal reconfiguration
class ARNodePool {
    private var availableNodes: [NodeType: [SCNNode]] = [:]
    private let maxPoolSize = 50
    
    func getNode(for type: NodeType) -> SCNNode {
        if let node = availableNodes[type]?.popLast() {
            // Minimal reconfiguration - only change what's necessary
            resetNodeState(node)
            return node
        }
        
        return createOptimizedNode(for: type)
    }
    
    func returnNode(_ node: SCNNode, type: NodeType) {
        guard availableNodes[type]?.count ?? 0 < maxPoolSize else { return }
        
        // Clean node for reuse
        node.removeAllAnimations()
        node.removeFromParentNode()
        
        availableNodes[type, default: []].append(node)
    }
    
    private func resetNodeState(_ node: SCNNode) {
        // Only update properties that actually change
        node.opacity = 1.0
        node.isHidden = false
        // Don't recreate geometry, materials, etc.
    }
}

3. Optimized Furniture Clustering

// SOLUTION: Spatial clustering with KD-tree
class FurnitureClusterer {
    private let maxDistance: Float
    private let kdTree: KDTree<CapturedRoom.Object>
    
    func clusterFurniture(_ objects: [CapturedRoom.Object]) -> [[CapturedRoom.Object]] {
        var clusters: [[CapturedRoom.Object]] = []
        var unprocessed = Set(objects.indices)
        
        while let seedIndex = unprocessed.first {
            unprocessed.remove(seedIndex)
            let seed = objects[seedIndex]
            
            // Use spatial index for efficient neighbor finding
            let neighbors = kdTree.neighborsWithinRadius(of: seed.position, radius: maxDistance)
            let cluster = [seed] + neighbors.filter { unprocessed.contains($0.index) }
            
            cluster.forEach { unprocessed.remove($0.index) }
            clusters.append(cluster.map { objects[$0.index] })
        }
        
        return clusters
    }
}

4. Background Processing for Heavy Operations

// SOLUTION: Background processing with progress updates
class PerformanceOptimizedAnalyzer {
    func analyzeRoom(_ capturedRoom: CapturedRoom) async -> RoomAnalysisResult {
        return await withTaskGroup(of: AnalysisComponent.self, returning: RoomAnalysisResult.self) { group in
            
            // Parallel processing of independent components
            group.addTask { await self.analyzeFurniture(capturedRoom.objects) }
            group.addTask { await self.analyzeWalls(capturedRoom.walls) }
            group.addTask { await self.analyzeFloors(capturedRoom.floors) }
            
            // Combine results efficiently
            var components: [AnalysisComponent] = []
            for await component in group {
                components.append(component)
            }
            
            return combineAnalysisResults(components)
        }
    }
}

Implementation Steps

1. Implement Spatial Data Structures (~3 days)

   • Create spatial grid for heatmap interpolation
   • Add KD-tree for furniture clustering
   • Replace linear searches with spatial queries

2. Optimize AR Node Management (~2 days)

   • Improve object pooling implementation
   • Minimize node reconfiguration
   • Add performance monitoring

3. Background Processing (~2 days)

   • Move heavy computations off main thread
   • Add progress reporting
   • Implement cancellation support

4. Performance Testing (~1 day)

   • Create performance benchmarks
   • Measure improvements
   • Add automated performance tests

Acceptance Criteria

• Heatmap generation <500ms for 100 measurements
• AR frame rate maintains 30+ FPS with 20+ nodes
• Furniture clustering <100ms for 50+ objects
• Main thread never blocks for >16ms
• Memory usage stable during heavy operations
• Performance tests pass in CI/CD pipeline

Performance Benchmarks

Current Performance (Baseline)

Heatmap Generation: 2.3s for 50 measurements
Furniture Clustering: 450ms for 30 objects  
AR Node Creation: 12ms per node
Memory Usage: 180MB peak during analysis

Target Performance

Heatmap Generation: <400ms for 100 measurements  
Furniture Clustering: <50ms for 50 objects
AR Node Creation: <2ms per node (pooled)
Memory Usage: <150MB peak during analysis

Testing Strategy

func testHeatmapPerformance() {
    let measurements = createMockMeasurements(count: 100)
    
    measure {
        let heatmap = wifiManager.generateHeatmapData(from: measurements)
        XCTAssertGreaterThan(heatmap.count, 0)
    }
    
    // Target: <400ms for 100 measurements
}

func testARNodePoolEfficiency() {
    let pool = ARNodePool()
    
    // Measure node reuse efficiency
    let startTime = CFAbsoluteTimeGetCurrent()
    
    for i in 0..<1000 {
        let node = pool.getNode(for: .measurement)
        // Simulate usage
        pool.returnNode(node, type: .measurement)
    }
    
    let duration = CFAbsoluteTimeGetCurrent() - startTime
    XCTAssertLessThan(duration, 0.1) // <100ms for 1000 operations
}

Benefits

• User Experience: Smooth, responsive interface
• Scalability: Handles larger datasets efficiently
• Battery Life: Reduced CPU usage extends battery
• Frame Rate: Stable AR performance
• Memory: Lower peak memory usage

Estimated Effort

• Priority: 🐌 Medium
• Effort: 1.5 weeks
• Impact: Medium-High - Significant UX improvement

Dependencies

• Should be done after threading fixes
• Can be parallelized with architectural refactoring