Deploy vehicle damage detection system

.gitignore

@@ -0,0 +1,65 @@
+# Python
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+
+# Virtual environments
+autoVenv/
+venv/
+ENV/
+env/
+
+# IDE
+.vscode/
+.idea/
+*.swp
+*.swo
+*~
+
+# Testing
+.pytest_cache/
+.coverage
+htmlcov/
+test_output/
+
+# Gradio
+.gradio/
+flagged/
+
+# OS
+.DS_Store
+Thumbs.db
+
+# Logs
+*.log
+
+# Environment variables
+.env
+.env.local
+
+# Model files (if large)
+*.pt
+*.pth
+*.onnx
+*.weights
+
+# Temporary files
+*.tmp
+*.bak

README.md

@@ -1,12 +1,86 @@
 ---
 title: Vehicle Damage Detector
-emoji: 🏢
-colorFrom: indigo
-colorTo: gray
+emoji: 🚗
+colorFrom: blue
+colorTo: red
 sdk: gradio
-sdk_version: 5.49.1
+sdk_version: 5.0.0
 app_file: app.py
 pinned: false
+license: mit
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# 🚗 AI-Powered Vehicle Damage Detection System
+
+An intelligent system for automated vehicle damage assessment using AI/ML for car rental companies.
+
+## Features
+
+- **📸 Image Upload**: Upload vehicle images for damage detection
+- **🤖 AI Detection**: Powered by YOLOv11 trained on Roboflow dataset
+- **💰 Cost Estimation**: Automatic repair cost calculation
+- **📊 Comparison**: Side-by-side pickup vs return analysis
+- **🎯 23 Damage Classes**: Comprehensive damage type identification
+
+## Damage Classes
+
+The system can detect:
+- Dents (bonnet, door, fender, bumper, etc.)
+- Scratches (door, bumper, etc.)
+- Glass damage (windscreen, windows)
+- Light damage (headlights, taillights, etc.)
+- Paint damage (chips, traces)
+
+## How to Use
+
+1. **Single Image Detection**: Upload a vehicle image to detect damages
+2. **Compare Images**: Upload pickup and return images to identify new damages
+3. View annotated results with bounding boxes and damage details
+4. Get estimated repair costs
+
+## Technical Details
+
+- **Model**: YOLOv11 (Roboflow trained)
+- **Dataset**: Custom car damage detection dataset
+- **API**: Roboflow Inference SDK
+- **Framework**: Gradio for UI, FastAPI for REST endpoints
+
+## Local Development
+
+```bash
+# Install dependencies
+pip install -r requirements.txt
+
+# Run UI only
+python ui.py
+
+# Run API only
+python api.py
+
+# Run both
+python main.py
+
+# Run tests
+python test_suite.py
+```
+
+## API Endpoints
+
+- `POST /api/detect`: Single image damage detection
+- `POST /api/compare`: Compare pickup vs return images
+- `GET /api/health`: Health check
+- `GET /api/damage-classes`: List all damage classes
+
+## Architecture
+
+- `app.py`: Hugging Face Spaces entry point
+- `ui.py`: Gradio web interface
+- `api.py`: FastAPI REST API
+- `detector.py`: Core detection logic
+- `config.py`: Configuration and damage costs
+
+## Credits
+
+- Developed for AI-Powered Vehicle Condition Assessment Challenge
+- Model trained on Roboflow platform
+- Powered by Ultralytics YOLOv11

app.py

@@ -0,0 +1,15 @@
+"""
+Hugging Face Spaces entry point
+Launches the Gradio UI interface
+"""
+
+import gradio as gr
+from ui import create_interface
+
+if __name__ == "__main__":
+    interface = create_interface()
+    interface.launch(
+        server_name="0.0.0.0",
+        server_port=7860,
+        share=False
+    )

config.py

@@ -0,0 +1,22 @@
+"""
+Configuration settings for Vehicle Damage Detection System
+"""
+
+import os
+
+# Roboflow API Configuration
+ROBOFLOW_API_KEY = os.getenv("ROBOFLOW_API_KEY", "DvmKUUSUrM8rQBeil5V2")
+ROBOFLOW_MODEL_ID = os.getenv("ROBOFLOW_MODEL_ID", "car-damage-detection-5ioys-4z3z4/2")
+
+# Server Configuration
+HOST = os.getenv("HOST", "127.0.0.1")
+PORT = int(os.getenv("PORT", 7860))
+FASTAPI_PORT = int(os.getenv("FASTAPI_PORT", 8000))
+
+# Model Configuration
+CONFIDENCE_THRESHOLD = float(os.getenv("CONFIDENCE_THRESHOLD", 0.25))
+
+# Application Settings
+APP_TITLE = "AI-Powered Vehicle Damage Detection"
+APP_DESCRIPTION = "Automated vehicle damage assessment using AI for car rental inspection"
+VERSION = "1.0.0"

detector.py

@@ -0,0 +1,264 @@
+"""
+Vehicle Damage Detection System
+Core detection module using Roboflow API
+"""
+
+import base64
+import numpy as np
+from PIL import Image, ImageDraw, ImageFont
+from io import BytesIO
+from typing import List, Dict, Tuple
+
+
+class DamageDetector:
+    """Vehicle damage detection using Roboflow API"""
+    
+    # Damage class definitions (23 custom classes)
+    DAMAGE_CLASSES = [
+        'bonnet-dent', 'doorouter-dent', 'doorouter-paint-trace', 'doorouter-scratch',
+        'fender-dent', 'front-bumper-dent', 'front-bumper-scratch', 'Front-Windscreen-Damage',
+        'Headlight-Damage', 'Major-Rear-Bumper-Dent', 'medium-Bodypanel-Dent', 'paint-chip',
+        'paint-trace', 'pillar-dent', 'quaterpanel-dent', 'rear-bumper-dent',
+        'rear-bumper-scratch', 'Rear-windscreen-Damage', 'roof-dent', 'RunningBoard-Dent',
+        'Sidemirror-Damage', 'Signlight-Damage', 'Taillight-Damage'
+    ]
+    
+    # Repair cost estimation matrix (USD)
+    REPAIR_COSTS = {
+        # Dents
+        'bonnet-dent': {'minor': 150, 'moderate': 400, 'severe': 800},
+        'doorouter-dent': {'minor': 100, 'moderate': 350, 'severe': 700},
+        'fender-dent': {'minor': 120, 'moderate': 380, 'severe': 750},
+        'front-bumper-dent': {'minor': 100, 'moderate': 300, 'severe': 600},
+        'pillar-dent': {'minor': 200, 'moderate': 500, 'severe': 1000},
+        'quaterpanel-dent': {'minor': 150, 'moderate': 400, 'severe': 800},
+        'rear-bumper-dent': {'minor': 100, 'moderate': 300, 'severe': 600},
+        'roof-dent': {'minor': 200, 'moderate': 600, 'severe': 1200},
+        'medium-Bodypanel-Dent': {'minor': 150, 'moderate': 400, 'severe': 900},
+        'Major-Rear-Bumper-Dent': {'minor': 300, 'moderate': 700, 'severe': 1500},
+        'RunningBoard-Dent': {'minor': 80, 'moderate': 250, 'severe': 500},
+        
+        # Scratches
+        'doorouter-scratch': {'minor': 50, 'moderate': 150, 'severe': 400},
+        'front-bumper-scratch': {'minor': 50, 'moderate': 150, 'severe': 350},
+        'rear-bumper-scratch': {'minor': 50, 'moderate': 150, 'severe': 350},
+        
+        # Paint damage
+        'doorouter-paint-trace': {'minor': 60, 'moderate': 180, 'severe': 450},
+        'paint-chip': {'minor': 40, 'moderate': 120, 'severe': 300},
+        'paint-trace': {'minor': 50, 'moderate': 150, 'severe': 400},
+        
+        # Glass/Light damage
+        'Front-Windscreen-Damage': {'minor': 200, 'moderate': 500, 'severe': 1000},
+        'Rear-windscreen-Damage': {'minor': 200, 'moderate': 500, 'severe': 1000},
+        'Headlight-Damage': {'minor': 150, 'moderate': 400, 'severe': 800},
+        'Taillight-Damage': {'minor': 100, 'moderate': 300, 'severe': 600},
+        'Signlight-Damage': {'minor': 80, 'moderate': 200, 'severe': 400},
+        'Sidemirror-Damage': {'minor': 100, 'moderate': 300, 'severe': 600},
+    }
+    
+    def __init__(self, api_key: str, model_id: str):
+        """
+        Initialize Roboflow damage detector
+        
+        Args:
+            api_key: Roboflow API key
+            model_id: Roboflow model ID (workspace/project/version)
+        """
+        self.api_key = api_key
+        self.model_id = model_id
+        self.client = None
+        self._initialize_client()
+    
+    def _initialize_client(self):
+        """Initialize Roboflow API client"""
+        try:
+            from inference_sdk import InferenceHTTPClient
+            self.client = InferenceHTTPClient(
+                api_url="https://serverless.roboflow.com",
+                api_key=self.api_key
+            )
+            print(f"✓ Roboflow API initialized")
+            print(f"  Model: {self.model_id}")
+        except ImportError:
+            raise ImportError(
+                "inference-sdk not installed. Run: pip install inference-sdk"
+            )
+        except Exception as e:
+            raise RuntimeError(f"Failed to initialize Roboflow client: {e}")
+    
+    def detect_damages(self, image: Image.Image) -> List[Dict]:
+        """
+        Detect damages in an image using Roboflow API
+        
+        Args:
+            image: PIL Image object
+            
+        Returns:
+            List of damage detections with format:
+            [{
+                'bbox': [x1, y1, x2, y2],
+                'confidence': float,
+                'class': str,
+                'severity': str,
+                'estimated_cost': int
+            }]
+        """
+        # Convert image to base64
+        img_byte_arr = BytesIO()
+        image.save(img_byte_arr, format='JPEG')
+        img_base64 = base64.b64encode(img_byte_arr.getvalue()).decode('utf-8')
+        
+        # Call Roboflow API
+        result = self.client.infer(img_base64, model_id=self.model_id)
+        
+        # Parse detections
+        detections = []
+        img_array = np.array(image)
+        h, w = img_array.shape[:2]
+        
+        if 'predictions' in result:
+            for pred in result['predictions']:
+                # Convert from center coords to corners
+                x_center, y_center = pred['x'], pred['y']
+                width, height = pred['width'], pred['height']
+                
+                x1 = int(x_center - width / 2)
+                y1 = int(y_center - height / 2)
+                x2 = int(x_center + width / 2)
+                y2 = int(y_center + height / 2)
+                
+                class_name = pred['class']
+                confidence = pred['confidence']
+                
+                # Estimate severity
+                severity = self._estimate_severity(x1, y1, x2, y2, class_name, (h, w))
+                
+                # Get repair cost
+                cost = self.REPAIR_COSTS.get(class_name, {}).get(severity, 100)
+                
+                detections.append({
+                    'bbox': [x1, y1, x2, y2],
+                    'confidence': confidence,
+                    'class': class_name,
+                    'severity': severity,
+                    'estimated_cost': cost
+                })
+        
+        return detections
+    
+    def _estimate_severity(self, x1: int, y1: int, x2: int, y2: int, 
+                          damage_class: str, img_shape: Tuple[int, int]) -> str:
+        """
+        Estimate damage severity based on size and type
+        
+        Args:
+            x1, y1, x2, y2: Bounding box coordinates
+            damage_class: Type of damage
+            img_shape: (height, width) of image
+            
+        Returns:
+            'minor', 'moderate', or 'severe'
+        """
+        h, w = img_shape
+        bbox_area = (x2 - x1) * (y2 - y1)
+        img_area = h * w
+        damage_ratio = bbox_area / img_area
+        
+        # Critical damage types
+        critical_types = ['Major-Rear-Bumper-Dent', 'Front-Windscreen-Damage', 
+                         'Rear-windscreen-Damage']
+        
+        if damage_class in critical_types:
+            if damage_ratio > 0.05:
+                return 'severe'
+            elif damage_ratio > 0.02:
+                return 'moderate'
+            else:
+                return 'minor'
+        
+        # Standard damage assessment
+        if damage_ratio > 0.08:
+            return 'severe'
+        elif damage_ratio > 0.03:
+            return 'moderate'
+        else:
+            return 'minor'
+    
+    def draw_detections(self, image: Image.Image, detections: List[Dict], 
+                       color_map: Dict[str, str] = None) -> Image.Image:
+        """
+        Draw bounding boxes on image
+        
+        Args:
+            image: PIL Image
+            detections: List of detections from detect_damages()
+            color_map: Optional severity color mapping
+            
+        Returns:
+            Annotated PIL Image
+        """
+        if color_map is None:
+            color_map = {
+                'minor': 'yellow',
+                'moderate': 'orange',
+                'severe': 'red'
+            }
+        
+        img_copy = image.copy()
+        draw = ImageDraw.Draw(img_copy)
+        
+        try:
+            font = ImageFont.truetype("arial.ttf", 20)
+        except:
+            font = ImageFont.load_default()
+        
+        for det in detections:
+            x1, y1, x2, y2 = det['bbox']
+            severity = det['severity']
+            class_name = det['class']
+            confidence = det['confidence']
+            
+            color = color_map.get(severity, 'red')
+            
+            # Draw bounding box
+            draw.rectangle([x1, y1, x2, y2], outline=color, width=3)
+            
+            # Draw label
+            label = f"{class_name} ({confidence*100:.1f}%)"
+            draw.rectangle([x1, y1-25, x1+len(label)*10, y1], fill=color)
+            draw.text((x1+5, y1-22), label, fill='white', font=font)
+        
+        return img_copy
+    
+    def compare_images(self, pickup_img: Image.Image, 
+                      return_img: Image.Image) -> Dict:
+        """
+        Compare pickup and return images to find new damages
+        
+        Args:
+            pickup_img: Image from vehicle pickup
+            return_img: Image from vehicle return
+            
+        Returns:
+            Dictionary with comparison results
+        """
+        pickup_damages = self.detect_damages(pickup_img)
+        return_damages = self.detect_damages(return_img)
+        
+        # Find new damages (simple heuristic based on class count)
+        pickup_classes = [d['class'] for d in pickup_damages]
+        new_damages = [d for d in return_damages 
+                      if d['class'] not in pickup_classes or 
+                      pickup_classes.count(d['class']) < 
+                      [d['class'] for d in return_damages].count(d['class'])]
+        
+        total_new_cost = sum(d['estimated_cost'] for d in new_damages)
+        
+        return {
+            'pickup_damages': pickup_damages,
+            'return_damages': return_damages,
+            'new_damages': new_damages,
+            'total_new_cost': total_new_cost,
+            'summary': f"Found {len(new_damages)} new damage(s). Estimated cost: ${total_new_cost}"
+        }

requirements.txt

@@ -0,0 +1,16 @@
+# Core Dependencies
+gradio>=5.0.0
+fastapi>=0.100.0
+uvicorn>=0.23.0
+python-multipart>=0.0.6
+
+# AI/ML
+inference-sdk>=0.9.0
+numpy>=1.26.0
+Pillow>=10.1.0
+
+# Image Processing
+opencv-python>=4.8.1.78
+
+# Utilities
+requests>=2.31.0

ui.py

@@ -0,0 +1,334 @@
+"""
+Gradio Web UI for Vehicle Damage Detection
+User-friendly interface for vehicle inspection
+"""
+
+import gradio as gr
+import json
+from datetime import datetime
+from PIL import Image
+
+from detector import DamageDetector
+from config import (
+    ROBOFLOW_API_KEY,
+    ROBOFLOW_MODEL_ID,
+    HOST,
+    PORT,
+    APP_TITLE,
+    APP_DESCRIPTION
+)
+
+# Initialize detector
+detector = DamageDetector(
+    api_key=ROBOFLOW_API_KEY,
+    model_id=ROBOFLOW_MODEL_ID
+)
+
+
+def analyze_single_image(image):
+    """Analyze a single vehicle image for damages"""
+    
+    if image is None:
+        return None, "⚠️ Please upload an image!", None
+    
+    try:
+        # Convert to PIL Image
+        img = Image.fromarray(image).convert('RGB')
+        
+        # Detect damages
+        detections = detector.detect_damages(img)
+        
+        # Draw annotations
+        annotated_img = detector.draw_detections(img, detections)
+        
+        # Calculate statistics
+        total_cost = sum(d['estimated_cost'] for d in detections)
+        severity_counts = {
+            'minor': sum(1 for d in detections if d['severity'] == 'minor'),
+            'moderate': sum(1 for d in detections if d['severity'] == 'moderate'),
+            'severe': sum(1 for d in detections if d['severity'] == 'severe')
+        }
+        
+        # Generate report
+        report_md = f"""
+# 🚗 Vehicle Damage Analysis Report
+**Date:** {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}
+
+---
+
+## Summary
+{'✅ **No damages detected!**' if len(detections) == 0 else f'⚠️ **Found {len(detections)} damage(s)**'}
+
+## Statistics
+- **Total Damages:** {len(detections)}
+- **Minor:** {severity_counts['minor']} | **Moderate:** {severity_counts['moderate']} | **Severe:** {severity_counts['severe']}
+- **Estimated Repair Cost:** **${total_cost}**
+
+"""
+        
+        if detections:
+            report_md += "## Detailed Damage List\n\n"
+            report_md += "| # | Type | Severity | Confidence | Location | Cost |\n"
+            report_md += "|---|------|----------|------------|----------|------|\n"
+            for i, det in enumerate(detections, 1):
+                x1, y1 = det['bbox'][:2]
+                report_md += (
+                    f"| {i} | {det['class']} | {det['severity']} | "
+                    f"{det['confidence']*100:.1f}% | ({x1}, {y1}) | "
+                    f"${det['estimated_cost']} |\n"
+                )
+        
+        report_md += "\n---\n*Powered by Roboflow AI Detection*"
+        
+        # JSON output
+        json_output = json.dumps({
+            'timestamp': datetime.now().isoformat(),
+            'total_damages': len(detections),
+            'estimated_cost': total_cost,
+            'severity_breakdown': severity_counts,
+            'damages': [
+                {
+                    'class': d['class'],
+                    'severity': d['severity'],
+                    'confidence': f"{d['confidence']*100:.1f}%",
+                    'location': f"({d['bbox'][0]}, {d['bbox'][1]})",
+                    'estimated_cost': d['estimated_cost']
+                }
+                for d in detections
+            ]
+        }, indent=2)
+        
+        return annotated_img, report_md, json_output
+    
+    except Exception as e:
+        import traceback
+        error_msg = f"❌ **Error:** {str(e)}\n\n```\n{traceback.format_exc()}\n```"
+        return None, error_msg, None
+
+
+def compare_images_fn(pickup_image, return_image):
+    """Compare pickup and return images to find new damages"""
+    
+    if pickup_image is None or return_image is None:
+        return None, "⚠️ Please upload both pickup and return images!", None
+    
+    try:
+        # Convert to PIL Images
+        pickup_img = Image.fromarray(pickup_image).convert('RGB')
+        return_img = Image.fromarray(return_image).convert('RGB')
+        
+        # Compare images
+        comparison = detector.compare_images(pickup_img, return_img)
+        
+        # Draw annotations
+        pickup_annotated = detector.draw_detections(
+            pickup_img,
+            comparison['pickup_damages'],
+            {'minor': 'green', 'moderate': 'green', 'severe': 'green'}
+        )
+        
+        return_annotated = detector.draw_detections(
+            return_img,
+            comparison['new_damages']
+        )
+        
+        # Create side-by-side comparison
+        w1, h1 = pickup_annotated.size
+        w2, h2 = return_annotated.size
+        max_h = max(h1, h2)
+        
+        combined = Image.new('RGB', (w1 + w2, max_h), color='white')
+        combined.paste(pickup_annotated, (0, 0))
+        combined.paste(return_annotated, (w1, 0))
+        
+        # Generate report
+        new_cost = comparison['total_new_cost']
+        new_damages = comparison['new_damages']
+        
+        report_md = f"""
+# 🔄 Vehicle Comparison Report
+**Date:** {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}
+
+---
+
+## Summary
+- **Pickup Damages:** {len(comparison['pickup_damages'])}
+- **Return Damages:** {len(comparison['return_damages'])}
+- **New Damages:** {len(new_damages)}
+- **New Damage Cost:** **${new_cost}**
+
+{comparison['summary']}
+
+"""
+        
+        if new_damages:
+            report_md += "## New Damages Detected\n\n"
+            report_md += "| # | Type | Severity | Confidence | Cost |\n"
+            report_md += "|---|------|----------|------------|------|\n"
+            for i, det in enumerate(new_damages, 1):
+                report_md += (
+                    f"| {i} | {det['class']} | {det['severity']} | "
+                    f"{det['confidence']*100:.1f}% | ${det['estimated_cost']} |\n"
+                )
+        
+        report_md += "\n---\n*Green boxes = Existing | Red/Orange/Yellow = New damages*"
+        
+        # JSON output
+        json_output = json.dumps({
+            'timestamp': datetime.now().isoformat(),
+            'pickup_damages': len(comparison['pickup_damages']),
+            'return_damages': len(comparison['return_damages']),
+            'new_damages': len(new_damages),
+            'new_damage_cost': new_cost,
+            'new_damage_details': [
+                {
+                    'class': d['class'],
+                    'severity': d['severity'],
+                    'confidence': f"{d['confidence']*100:.1f}%",
+                    'estimated_cost': d['estimated_cost']
+                }
+                for d in new_damages
+            ]
+        }, indent=2)
+        
+        return combined, report_md, json_output
+    
+    except Exception as e:
+        import traceback
+        error_msg = f"❌ **Error:** {str(e)}\n\n```\n{traceback.format_exc()}\n```"
+        return None, error_msg, None
+
+
+# =============================================================================
+# BUILD GRADIO INTERFACE
+# =============================================================================
+
+with gr.Blocks(title=APP_TITLE, theme=gr.themes.Soft()) as demo:
+    
+    gr.Markdown(f"""
+    # 🚗 {APP_TITLE}
+    
+    {APP_DESCRIPTION}
+    """)
+    
+    with gr.Tabs() as tabs:
+        # Tab 1: Single Image Analysis
+        with gr.Tab("📸 Single Image Analysis"):
+            gr.Markdown("""
+            ### Quick Damage Detection
+            Upload a vehicle image to detect and analyze all damages instantly.
+            Supports multiple angles: front, rear, sides, roof, interior.
+            """)
+            
+            with gr.Row():
+                with gr.Column():
+                    single_input = gr.Image(
+                        label="📸 Upload Vehicle Image",
+                        type="numpy",
+                        sources=["upload", "webcam", "clipboard"]
+                    )
+                    analyze_btn = gr.Button(
+                        "🔍 Analyze Damages",
+                        variant="primary",
+                        size="lg"
+                    )
+                
+                with gr.Column():
+                    single_output_image = gr.Image(
+                        label="✅ Detected Damages (Annotated)"
+                    )
+            
+            single_output_report = gr.Markdown(label="📊 Analysis Report")
+            
+            with gr.Accordion("📋 JSON Output (for API integration)", open=False):
+                single_output_json = gr.Code(label="JSON Data", language="json")
+            
+            analyze_btn.click(
+                fn=analyze_single_image,
+                inputs=[single_input],
+                outputs=[single_output_image, single_output_report, single_output_json]
+            )
+        
+        # Tab 2: Comparison Mode
+        with gr.Tab("🔄 Comparison Mode"):
+            gr.Markdown("""
+            ### Compare Pickup vs Return
+            Upload vehicle photos from pickup and return to identify new damages.
+            Side-by-side comparison highlights what changed during rental.
+            """)
+            
+            with gr.Row():
+                with gr.Column():
+                    pickup_input = gr.Image(
+                        label="📸 Pickup Photo (Before Rental)",
+                        type="numpy",
+                        sources=["upload", "webcam", "clipboard"]
+                    )
+                
+                with gr.Column():
+                    return_input = gr.Image(
+                        label="📸 Return Photo (After Rental)",
+                        type="numpy",
+                        sources=["upload", "webcam", "clipboard"]
+                    )
+            
+            compare_btn = gr.Button(
+                "🔍 Compare & Analyze",
+                variant="primary",
+                size="lg"
+            )
+            
+            compare_output_image = gr.Image(
+                label="🔄 Side-by-Side Comparison"
+            )
+            
+            compare_output_report = gr.Markdown(label="📊 Comparison Report")
+            
+            with gr.Accordion("📋 JSON Output (for API integration)", open=False):
+                compare_output_json = gr.Code(label="JSON Data", language="json")
+            
+            compare_btn.click(
+                fn=compare_images_fn,
+                inputs=[pickup_input, return_input],
+                outputs=[compare_output_image, compare_output_report, compare_output_json]
+            )
+    
+    gr.Markdown("""
+    ---
+    ### 🔧 Technical Details
+    
+    **AI Model:** YOLOv11 custom-trained on Roboflow
+    **Detection Classes:** 23 specialized vehicle damage types
+    **API Integration:** REST/GraphQL endpoints available
+    **Supported Formats:** JPG, PNG, JPEG
+    **Camera Support:** Desktop, tablet, phone cameras via HTML5
+    
+    ### 📖 How It Works
+    
+    1. **Upload/Capture:** Use built-in cameras or upload images
+    2. **AI Detection:** Roboflow API identifies damages with confidence scores
+    3. **Analysis:** Severity estimation (minor/moderate/severe) and cost calculation
+    4. **Report:** Visual annotations + detailed breakdown + JSON export
+    
+    ### 📡 API Access
+    
+    REST API available at port 8000. See `/api/docs` for interactive documentation.
+    
+    **Endpoints:**
+    - `POST /api/detect` - Single image analysis
+    - `POST /api/compare` - Pickup vs return comparison
+    - `GET /api/damage-classes` - List all detectable damages
+    - `GET /api/repair-costs` - Cost estimation matrix
+    
+    ---
+    
+    *Powered by Roboflow AI • Built with Gradio & FastAPI*
+    """)
+
+
+if __name__ == "__main__":
+    demo.launch(
+        share=False,
+        server_name=HOST,
+        server_port=PORT
+    )