AI damage cost estimation by photo in mobile app

AI Damage Cost Estimation from Photos in Mobile Applications

Damage detection (previous stage) is technical work. Cost estimation is a task at the intersection of computer vision, repair standards databases, and country-specific business logic. The same dent on a fender costs differently in Moscow and Warsaw, at official dealer vs independent shop. System must understand this.

Cost Estimation Pipeline Architecture

Cost estimation isn't direct neural network output. It's multi-step calculation:

Photo → Damage detection → [type, severity, area, location]
                                          ↓
                             Repair standards database
                             (labor hours by work type)
                                          ↓
                             Regional rates
                             (hourly labor cost)
                                          ↓
                             Parts cost
                             (OEM vs aftermarket)
                                          ↓
                             Final estimate [min, expected, max]

Neural network only on first step—everything else is deterministic calculation from databases.

Repair Standards Databases

In Russia, de-facto standard—AUDATEX (now Solera) and GT Motive. They contain labor hours per operation for each vehicle: replace front fender Toyota Camry XV70—2.4 labor hours, dent repair—1.8 hours, paint—3.2 hours. API access requires partnership agreement.

For MVP without expensive licenses: open databases Mitchell1, AllData (US) or own database from public shop price lists via scraping + normalization.

// iOS: request cost calculation
struct DamageCostRequest: Codable {
    let vehicleInfo: VehicleInfo           // make, model, year
    let damageDetections: [DamageDetection]
    let repairLocation: RepairLocation     // city, country
    let repairType: RepairType             // dealer, certified, independent
}

struct VehicleInfo: Codable {
    let make: String
    let model: String
    let year: Int
    let bodyType: BodyType
    let vin: String?
}

// Response with itemized breakdown
struct DamageCostEstimate: Codable {
    let lineItems: [CostLineItem]
    let laborCost: MoneyAmount
    let partsCost: MoneyAmount
    let paintCost: MoneyAmount
    let totalMin: MoneyAmount
    let totalExpected: MoneyAmount
    let totalMax: MoneyAmount
    let currency: String
    let validUntilDate: Date           // rates change
    let disclaimer: String
}

struct CostLineItem: Codable {
    let description: String            // "Replace front bumper"
    let damageType: DamageType
    let panelLocation: PanelLocation   // front_bumper, hood, etc.
    let laborHours: Double
    let laborCostPerHour: MoneyAmount
    let partsCost: MoneyAmount?
    let repairVsReplaceRecommendation: RepairOption
}

Repair vs Replace Logic

For each damage, recommend: repair (dent-pull + paint) or part replacement. Simplified rule:

func recommendRepairOption(
    damage: DamageDetection,
    panel: PanelInfo
) -> RepairOption {
    let damageAreaRatio = damage.maskAreaPx / panel.totalAreaPx

    // Damage > 40% of part → replace, not repair
    if damageAreaRatio > 0.4 { return .replace }

    // Structural damage → replace only
    if damage.severity == .structural { return .replace }

    // If repair costs > 70% of new part—replace
    let repairEstimate = calculateRepairCost(damage, panel)
    let partPrice = panel.partPrice.aftermarket
    if repairEstimate > partPrice * 0.7 { return .replace }

    return .repair
}

UI: Understandable Output for Non-Technical Users

Insurance agents or car owners don't read "MMA standard 2.4 h/hrs." Interface shows clear breakdown:

@Composable
fun CostEstimateScreen(estimate: DamageCostEstimate) {
    Column(modifier = Modifier.padding(16.dp)) {

        // Total cost—large and first
        TotalCostBanner(
            min = estimate.totalMin,
            expected = estimate.totalExpected,
            max = estimate.totalMax
        )

        Spacer(Modifier.height(24.dp))

        // Breakdown by category
        SectionHeader("Cost Breakdown")
        CostBreakdownBar(
            labor = estimate.laborCost,
            parts = estimate.partsCost,
            paint = estimate.paintCost
        )

        Spacer(Modifier.height(16.dp))

        // Line items by damage
        SectionHeader("Damages and Work")
        estimate.lineItems.forEach { item ->
            DamageLineItemCard(item = item)
        }

        // Disclaimer—mandatory
        DisclaimerText(text = estimate.disclaimer)
    }
}

Range min–expected–max is more honest than exact figure. Exact figure creates false expectations and conflicts at billing.

Timeline Estimates

Backend with damage detection (YOLOv8) + cost calculation using fixed regional database + iOS/Android mobile client—2–3 weeks. Full system with Audatex/GT Motive integration, regional rates, current parts prices, PDF report export with signature—1–3 months.