Gaussian Splatting Scanner App

Project Overview

An iOS app for 3D scanning using Gaussian Splatting technology, powered by the KIRI Engine API. The app will provide functionality similar to Scaniverse, allowing users to capture, process, and view 3D models using advanced photogrammetry and 3D Gaussian Splatting techniques.

Current Implementation Status

✅ Completed Features

• iOS project structure with SwiftUI
• KIRI Engine API integration (3DGS, Photo Scan, Featureless Object)
• Camera interface with photo capture
• Processing workflow with real-time status
• 3D model viewer with SceneKit
• Interactive 3D controls (zoom, rotate, pan)
• Model information display
• Configuration management

🚧 Planned Features

• LiDAR Integration: Enhanced scanning for LiDAR-equipped devices
• Gallery Management: Local storage and organization of scans
• Social Features: Share scans similar to Scaniverse
• Advanced Export Options: Multiple file formats and sharing
• Offline Mode: Local processing capabilities
• ARKit Integration: AR preview and placement features

User Experience Features

• Real-time Camera Interface: Advanced camera controls with manual settings
• 3D Model Viewer: Interactive viewing of generated models
• Share & Export: Export models in various formats
• Gallery Management: Local storage and organization of scans
• Social Features: Share scans similar to Scaniverse

Technical Stack

iOS Development

• Language: Swift
• UI Framework: SwiftUI with UIKit components
• 3D Rendering: SceneKit/RealityKit
• Camera: AVFoundation
• Networking: URLSession for API calls

KIRI Engine API Integration

• Base URL: https://api.kiriengine.app/api/
• Authentication: API Key based
• Main Endpoints:
  • 3DGS Scan creation and processing
  • Photo Scan processing
  • Model retrieval and status checking
  • Balance and usage tracking

Key API Features to Implement

1. 3DGS Scan API: Create stunning 3D renders using 3D Gaussian Splatting
2. Photo Scan API: Traditional photogrammetry processing
3. Featureless Object Scan API: For challenging objects
4. Model Management: Download and manage processed models
5. Webhooks: Real-time processing status updates

App Architecture

Design Patterns

• MVVM Architecture: Clean separation of concerns
• Repository Pattern: For API and local data management
• Coordinator Pattern: For navigation flow

Key Components

1. Camera Module: Capture photos/videos for processing
2. API Service Layer: Handle KIRI Engine API communications
3. 3D Viewer: Display and interact with 3D models
4. Local Storage: Core Data for managing scans and metadata
5. Export Module: Handle various export formats

Development Phases

Phase 1: Project Setup & Core Infrastructure

• iOS project scaffolding
• KIRI Engine API integration setup
• Basic camera interface
• API authentication flow

Phase 2: Scanning Implementation

• Photo capture workflow
• 3DGS scan submission to KIRI API
• Processing status monitoring
• Basic model retrieval

Phase 3: 3D Viewing & Interaction

• SceneKit/RealityKit integration
• 3D model loading and display
• Touch gestures and controls
• Model metadata display

Phase 4: Advanced Features

• LiDAR integration
• Advanced camera controls
• Export functionality
• Social sharing features

Phase 5: Polish & Optimization

• UI/UX refinements
• Performance optimizations
• Error handling improvements
• App Store preparation

API Integration Details

Required API Endpoints

• POST /3dgs-scan: Create 3DGS scan task
• GET /3dgs-scan/{id}: Get scan status and results
• POST /photo-scan: Create photo scan task
• GET /model/{id}: Download processed models
• GET /balance: Check API usage and limits

Authentication

• API Key authentication required
• Secure storage of API credentials
• Rate limiting considerations

UI/UX Inspiration

Taking inspiration from Scaniverse:

• Clean, modern interface
• Intuitive camera controls
• Seamless scanning workflow
• Social discovery features
• Beautiful 3D model presentation

Technical Requirements

• iOS 15.0+ (for advanced camera features)
• LiDAR support for compatible devices
• Network connectivity for API calls
• Local storage for models and cache
• Metal support for 3D rendering

Getting Started

Prerequisites

• Xcode 15.0+
• iOS 15.0+ target device
• KIRI Engine API key (sign up at kiriengine.app)

Setup Instructions

1. Open the Project

   cd GaussianSplattingScanner
   open GaussianSplattingScanner.xcworkspace

2. Configure KIRI Engine API Key

   • Sign up for a KIRI Engine account at kiriengine.app
   • Get your API key from the dashboard
   • Open GaussianSplattingScannerPackage/Sources/GaussianSplattingScannerFeature/AppConfig.swift
   • Replace "YOUR_KIRI_ENGINE_API_KEY" with your actual API key:

   public static let kiriEngineAPIKey = "your_actual_api_key_here"

3. Build and Run

   • Select your iOS device (camera features require physical device)
   • Build and run the project (⌘+R)

Using the App

1. Choose Scan Type: Select from 3D Gaussian Splatting, Photo Scan, or Featureless Object
2. Capture Photos: Follow on-screen instructions to capture photos around your object
3. Process: Once you have enough photos, tap "Process" to upload to KIRI Engine
4. View Model: When processing completes, view your 3D model with interactive controls

Troubleshooting

• Camera Permission: Make sure to allow camera access when prompted
• API Key Error: Verify your KIRI Engine API key is correctly configured
• Network Issues: Ensure you have a stable internet connection for processing
• Simulator: The app requires a physical device for camera features

API Documentation

• KIRI Engine API Documentation
• KIRI Engine Website

Inspiration

• Scaniverse - Reference for UI/UX patterns and features

---

Project created: September 11, 2025 KIRI Engine API: https://docs.kiriengine.app/ Inspiration: Scaniverse (https://scaniverse.com/)