Upload 61 files

.gitattributes

@@ -0,0 +1,64 @@
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.mlmodel filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tar filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz filter=lfs diff=lfs merge=lfs -text
+*.zip filter=lfs diff=lfs merge=lfs -text
+*.zst filter=lfs diff=lfs merge=lfs -text
+*tfevents* filter=lfs diff=lfs merge=lfs -text
+app/static/results/1d91cb91-46f0-4123-9b3d-dd963a4a1b8b_damage.png filter=lfs diff=lfs merge=lfs -text
+app/static/results/1d91cb91-46f0-4123-9b3d-dd963a4a1b8b_parts.png filter=lfs diff=lfs merge=lfs -text
+app/static/results/2b9a2716-12dc-4fec-8b1b-8a26375e4fd9_damage.png filter=lfs diff=lfs merge=lfs -text
+app/static/results/2b9a2716-12dc-4fec-8b1b-8a26375e4fd9_parts.png filter=lfs diff=lfs merge=lfs -text
+app/static/results/4ea85461-64cd-4c8b-8ef9-3c9635df076b_damage.png filter=lfs diff=lfs merge=lfs -text
+app/static/results/4ea85461-64cd-4c8b-8ef9-3c9635df076b_parts.png filter=lfs diff=lfs merge=lfs -text
+app/static/results/706f091d-f713-4f34-88b1-b3eaa5082483_damage.png filter=lfs diff=lfs merge=lfs -text
+app/static/results/706f091d-f713-4f34-88b1-b3eaa5082483_parts.png filter=lfs diff=lfs merge=lfs -text
+app/static/results/86665944-f463-4be3-87be-2227b667ea4d_damage.png filter=lfs diff=lfs merge=lfs -text
+app/static/results/86665944-f463-4be3-87be-2227b667ea4d_parts.png filter=lfs diff=lfs merge=lfs -text
+app/static/results/8f2e9c10-9e39-415b-b634-e9cacff08670_damage.png filter=lfs diff=lfs merge=lfs -text
+app/static/results/8f2e9c10-9e39-415b-b634-e9cacff08670_parts.png filter=lfs diff=lfs merge=lfs -text
+app/static/results/9be81a29-214a-48af-ba99-8cab54a56d66_damage.png filter=lfs diff=lfs merge=lfs -text
+app/static/results/9be81a29-214a-48af-ba99-8cab54a56d66_parts.png filter=lfs diff=lfs merge=lfs -text
+app/static/results/db93084e-16d1-4448-b841-1ce1c0e1c201_damage.png filter=lfs diff=lfs merge=lfs -text
+app/static/results/db93084e-16d1-4448-b841-1ce1c0e1c201_parts.png filter=lfs diff=lfs merge=lfs -text
+app/static/results/de9bda87-c237-4c6b-8748-1ab245d4ec57_damage.png filter=lfs diff=lfs merge=lfs -text
+app/static/results/de9bda87-c237-4c6b-8748-1ab245d4ec57_parts.png filter=lfs diff=lfs merge=lfs -text
+app/static/results/f0a7c31c-d1cf-460a-abff-d32d76faa384_damage.png filter=lfs diff=lfs merge=lfs -text
+app/static/results/f0a7c31c-d1cf-460a-abff-d32d76faa384_parts.png filter=lfs diff=lfs merge=lfs -text
+app/static/results/fdfef36b-2942-4bc8-bb26-ad6aad32d471_parts.png filter=lfs diff=lfs merge=lfs -text
+app/static/uploads/1d91cb91-46f0-4123-9b3d-dd963a4a1b8b.jpg filter=lfs diff=lfs merge=lfs -text
+app/static/uploads/2b9a2716-12dc-4fec-8b1b-8a26375e4fd9.jpg filter=lfs diff=lfs merge=lfs -text
+app/static/uploads/4ea85461-64cd-4c8b-8ef9-3c9635df076b.jpg filter=lfs diff=lfs merge=lfs -text
+app/static/uploads/706f091d-f713-4f34-88b1-b3eaa5082483.jpg filter=lfs diff=lfs merge=lfs -text
+app/static/uploads/86665944-f463-4be3-87be-2227b667ea4d.jpg filter=lfs diff=lfs merge=lfs -text
+app/static/uploads/8f2e9c10-9e39-415b-b634-e9cacff08670.jpg filter=lfs diff=lfs merge=lfs -text
+app/static/uploads/9be81a29-214a-48af-ba99-8cab54a56d66.jpg filter=lfs diff=lfs merge=lfs -text
+app/static/uploads/db93084e-16d1-4448-b841-1ce1c0e1c201.jpg filter=lfs diff=lfs merge=lfs -text

Dockerfile

@@ -0,0 +1,24 @@
+FROM python:3.10-slim
+
+WORKDIR /code
+
+# Install system dependencies
+RUN apt-get update && apt-get install -y \
+    build-essential \
+    libgl1-mesa-glx \
+    && rm -rf /var/lib/apt/lists/*
+
+# Install Python dependencies
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Copy app code
+COPY . .
+
+# Expose port
+EXPOSE 7860
+
+ENV PATH="/root/.local/bin:$PATH"
+
+# Run FastAPI app with uvicorn
+CMD ["uvicorn", "app.main:app", "--host", "0.0.0.0", "--port", "7860"]

README.md

@@ -0,0 +1,24 @@
+---
+title: Car Damage & Parts Detection
+emoji: 🚗
+colorFrom: blue
+colorTo: indigo
+sdk: docker
+app_file: app/main.py
+pinned: false
+---
+
+# Car Damage & Parts Detection
+
+Upload a car image to detect damaged regions and parts using YOLOv8 models.
+
+## How to use
+- Upload a car image.
+- View annotated results and JSON output.
+
+## Deployment
+This Space uses FastAPI and YOLOv8, running in a Docker container.
+
+## Model Weights
+Model weights are downloaded at startup from public cloud links (not included in repo).
+

app/main.py

@@ -0,0 +1,58 @@
+
+# --- Model download logic (Hugging Face Hub) ---
+import os
+import requests
+
+def download_if_missing(url, dest):
+    if not os.path.exists(dest):
+        print(f"Downloading model from {url} to {dest}...")
+        os.makedirs(os.path.dirname(dest), exist_ok=True)
+        with requests.get(url, stream=True) as r:
+            r.raise_for_status()
+            with open(dest, "wb") as f:
+                for chunk in r.iter_content(chunk_size=8192):
+                    f.write(chunk)
+        print("Download complete.")
+
+# Hugging Face direct download links
+DAMAGE_MODEL_URL = "https://huggingface.co/AItoolstack/car_damage_detection/resolve/main/yolov8_models/damage/weights/weights/best.pt"
+PARTS_MODEL_URL = "https://huggingface.co/AItoolstack/car_damage_detection/resolve/main/yolov8_models/parts/weights/weights/best.pt"
+
+DAMAGE_MODEL_PATH = os.path.join("models", "damage", "weights", "weights", "best.pt")
+PARTS_MODEL_PATH = os.path.join("models", "parts", "weights", "weights", "best.pt")
+
+download_if_missing(DAMAGE_MODEL_URL, DAMAGE_MODEL_PATH)
+download_if_missing(PARTS_MODEL_URL, PARTS_MODEL_PATH)
+
+from fastapi import FastAPI, File, UploadFile, BackgroundTasks
+from fastapi.staticfiles import StaticFiles
+from fastapi.templating import Jinja2Templates
+from fastapi.responses import JSONResponse, HTMLResponse
+from fastapi.middleware.cors import CORSMiddleware
+import uvicorn
+from datetime import datetime
+import aiofiles
+from pathlib import Path
+import uuid
+from app.routers import inference
+
+app = FastAPI(title="Car Damage Detection API")
+
+# CORS middleware
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# Mount static files
+app.mount("/static", StaticFiles(directory="app/static"), name="static")
+templates = Jinja2Templates(directory="app/templates")
+
+# Include routers
+app.include_router(inference.router)
+
+if __name__ == "__main__":
+    uvicorn.run("main:app", host="0.0.0.0", port=8000, reload=True)

app/routers/inference.py

@@ -0,0 +1,218 @@
+
+from fastapi import APIRouter, Request, UploadFile, File, Form
+from fastapi.responses import HTMLResponse, FileResponse, JSONResponse
+from fastapi.templating import Jinja2Templates
+from starlette.background import BackgroundTask
+import shutil
+import os
+import uuid
+from pathlib import Path
+from typing import Optional
+import json
+import base64
+from ultralytics import YOLO
+import cv2
+import numpy as np
+
+
+# Templates directory
+TEMPLATES_DIR = os.path.join(os.path.dirname(os.path.dirname(__file__)), "templates")
+templates = Jinja2Templates(directory=TEMPLATES_DIR)
+
+router = APIRouter()
+
+UPLOAD_DIR = os.path.join(os.path.dirname(os.path.dirname(__file__)), "static", "uploads")
+RESULTS_DIR = os.path.join(os.path.dirname(os.path.dirname(__file__)), "static", "results")
+
+os.makedirs(UPLOAD_DIR, exist_ok=True)
+os.makedirs(RESULTS_DIR, exist_ok=True)
+
+ALLOWED_EXTENSIONS = {"jpg", "jpeg", "png", "tiff", "tif"}
+
+# Model paths
+BASE_DIR = os.path.dirname(os.path.dirname(os.path.dirname(__file__)))
+DAMAGE_MODEL_PATH = os.path.join(BASE_DIR, "models", "damage", "weights", "weights", "best.pt")
+PARTS_MODEL_PATH = os.path.join(BASE_DIR, "models", "parts", "weights", "weights", "best.pt")
+
+# Class names for parts
+PARTS_CLASS_NAMES = ['headlamp', 'front_bumper', 'hood', 'door', 'rear_bumper']
+
+# Helper: Run YOLO inference and return results
+def run_yolo_inference(model_path, image_path, task='segment'):
+    model = YOLO(model_path)
+    results = model.predict(source=image_path, imgsz=640, conf=0.25, save=False, task=task)
+    return results[0]
+
+# Helper: Draw masks and confidence on image
+def draw_masks_and_conf(image_path, yolo_result, class_names=None):
+    img = cv2.imread(image_path)
+    overlay = img.copy()
+    out_img = img.copy()
+    colors = [(255,0,0), (0,255,0), (0,0,255), (255,255,0), (255,0,255), (0,255,255)]
+    for i, box in enumerate(yolo_result.boxes):
+        conf = float(box.conf[0])
+        cls = int(box.cls[0])
+        color = colors[cls % len(colors)]
+        # Draw bbox
+        x1, y1, x2, y2 = map(int, box.xyxy[0])
+        cv2.rectangle(overlay, (x1, y1), (x2, y2), color, 2)
+        label = f"{class_names[cls] if class_names else 'damage'}: {conf:.2f}"
+        cv2.putText(overlay, label, (x1, y1-10), cv2.FONT_HERSHEY_SIMPLEX, 0.6, color, 2)
+        # Draw mask if available
+        if hasattr(yolo_result, 'masks') and yolo_result.masks is not None:
+            mask = yolo_result.masks.data[i].cpu().numpy()
+            mask = (mask * 255).astype(np.uint8)
+            mask = cv2.resize(mask, (x2-x1, y2-y1))
+            roi = overlay[y1:y2, x1:x2]
+            colored_mask = np.zeros_like(roi)
+            colored_mask[mask > 127] = color
+            overlay[y1:y2, x1:x2] = cv2.addWeighted(roi, 0.5, colored_mask, 0.5, 0)
+    out_img = cv2.addWeighted(overlay, 0.7, img, 0.3, 0)
+    return out_img
+
+# Helper: Generate JSON output
+def generate_json_output(filename, damage_result, parts_result):
+    # Damage severity: use max confidence
+    severity_score = float(max([float(box.conf[0]) for box in damage_result.boxes], default=0))
+    damage_regions = []
+    for box in damage_result.boxes:
+        x1, y1, x2, y2 = map(float, box.xyxy[0])
+        conf = float(box.conf[0])
+        damage_regions.append({"bbox": [x1, y1, x2, y2], "confidence": conf})
+    # Parts
+    parts = []
+    for i, box in enumerate(parts_result.boxes):
+        x1, y1, x2, y2 = map(float, box.xyxy[0])
+        conf = float(box.conf[0])
+        cls = int(box.cls[0])
+        # Damage %: use mask area / bbox area if available
+        damage_percentage = None
+        if hasattr(parts_result, 'masks') and parts_result.masks is not None:
+            mask = parts_result.masks.data[i].cpu().numpy()
+            mask_area = np.sum(mask > 0.5)
+            bbox_area = (x2-x1)*(y2-y1)
+            damage_percentage = float(mask_area / bbox_area) if bbox_area > 0 else None
+        parts.append({
+            "part": PARTS_CLASS_NAMES[cls] if cls < len(PARTS_CLASS_NAMES) else str(cls),
+            "damaged": True,
+            "confidence": conf,
+            "damage_percentage": damage_percentage,
+            "bbox": [x1, y1, x2, y2]
+        })
+    # Optionally, add base64 masks
+    # (not implemented here for brevity)
+    return {
+        "filename": filename,
+        "damage": {
+            "severity_score": severity_score,
+            "regions": damage_regions
+        },
+        "parts": parts,
+        "cost_estimate": None
+    }
+
+# Dummy login credentials
+def check_login(username: str, password: str) -> bool:
+    return username == "demo" and password == "demo123"
+
+@router.get("/", response_class=HTMLResponse)
+def home(request: Request):
+    return templates.TemplateResponse("index.html", {"request": request, "result": None})
+
+@router.post("/login", response_class=HTMLResponse)
+def login(request: Request, username: str = Form(...), password: str = Form(...)):
+    if check_login(username, password):
+        return templates.TemplateResponse("index.html", {"request": request, "result": None, "user": username})
+    return templates.TemplateResponse("login.html", {"request": request, "error": "Invalid credentials"})
+
+@router.get("/login", response_class=HTMLResponse)
+def login_page(request: Request):
+    return templates.TemplateResponse("login.html", {"request": request})
+
+@router.post("/upload", response_class=HTMLResponse)
+def upload_image(request: Request, file: UploadFile = File(...)):
+    ext = file.filename.split(".")[-1].lower()
+    if ext not in ALLOWED_EXTENSIONS:
+        return templates.TemplateResponse("index.html", {"request": request, "error": "Unsupported file type."})
+
+    # Save uploaded file
+    session_id = str(uuid.uuid4())
+    upload_path = os.path.join(UPLOAD_DIR, f"{session_id}.{ext}")
+    with open(upload_path, "wb") as buffer:
+        shutil.copyfileobj(file.file, buffer)
+
+    # Run both inferences
+    try:
+        damage_result = run_yolo_inference(DAMAGE_MODEL_PATH, upload_path)
+        parts_result = run_yolo_inference(PARTS_MODEL_PATH, upload_path)
+
+        # Save annotated images
+        damage_img_path = os.path.join(RESULTS_DIR, f"{session_id}_damage.png")
+        parts_img_path = os.path.join(RESULTS_DIR, f"{session_id}_parts.png")
+        json_path = os.path.join(RESULTS_DIR, f"{session_id}_result.json")
+        damage_img_url = f"/static/results/{session_id}_damage.png"
+        parts_img_url = f"/static/results/{session_id}_parts.png"
+        json_url = f"/static/results/{session_id}_result.json"
+
+        # Defensive: set to None by default
+        damage_img = None
+        parts_img = None
+        json_output = None
+
+        # Only save and set if inference returns boxes
+        if hasattr(damage_result, 'boxes') and len(damage_result.boxes) > 0:
+            damage_img = draw_masks_and_conf(upload_path, damage_result)
+            cv2.imwrite(damage_img_path, damage_img)
+        if hasattr(parts_result, 'boxes') and len(parts_result.boxes) > 0:
+            parts_img = draw_masks_and_conf(upload_path, parts_result, class_names=PARTS_CLASS_NAMES)
+            cv2.imwrite(parts_img_path, parts_img)
+        if (hasattr(damage_result, 'boxes') and len(damage_result.boxes) > 0) or (hasattr(parts_result, 'boxes') and len(parts_result.boxes) > 0):
+            json_output = generate_json_output(file.filename, damage_result, parts_result)
+            with open(json_path, "w") as jf:
+                json.dump(json_output, jf, indent=2)
+
+        # Prepare URLs for download (only if files exist)
+        result = {
+            "filename": file.filename,
+            "damage_image": damage_img_url if damage_img is not None else None,
+            "parts_image": parts_img_url if parts_img is not None else None,
+            "json": json_output,
+            "json_download": json_url if json_output is not None else None
+        }
+        # Debug log
+        print("[DEBUG] Result dict:", result)
+    except Exception as e:
+        result = {
+            "filename": file.filename,
+            "error": f"Inference failed: {str(e)}",
+            "damage_image": None,
+            "parts_image": None,
+            "json": None,
+            "json_download": None
+        }
+        print("[ERROR] Inference failed:", e)
+
+    import threading
+    import time
+    def delayed_cleanup():
+        time.sleep(300)  # 5 minutes
+        try:
+            os.remove(upload_path)
+        except Exception:
+            pass
+        for suffix in ["_damage.png", "_parts.png", "_result.json"]:
+            try:
+                os.remove(os.path.join(RESULTS_DIR, f"{session_id}{suffix}"))
+            except Exception:
+                pass
+
+    threading.Thread(target=delayed_cleanup, daemon=True).start()
+
+    return templates.TemplateResponse(
+        "index.html",
+        {
+            "request": request,
+            "result": result,
+            "original_image": f"/static/uploads/{session_id}.{ext}"
+        }
+    )

app/static/css/style.css

@@ -0,0 +1,140 @@
+@import url('https://fonts.googleapis.com/css2?family=Roboto:wght@400;700&display=swap');
+
+body {
+    font-family: 'Roboto', Arial, sans-serif;
+    background: #f4f6fa;
+    margin: 0;
+    padding: 0;
+}
+.header {
+    background: linear-gradient(90deg, #003366 60%, #e30613 100%);
+    color: #fff;
+    padding: 24px 0 12px 0;
+    text-align: center;
+    box-shadow: 0 2px 8px #00336622;
+}
+.logo {
+    max-width: 180px;
+    margin-bottom: 10px;
+}
+@media (max-width: 600px) {
+    .logo {
+        max-width: 90px !important;
+        right: 10px !important;
+        top: 10px !important;
+    }
+    .header h2 { font-size: 1.1em; }
+}
+.container {
+    max-width: 950px;
+    margin: 40px auto 0 auto;
+    background: #fff;
+    padding: 32px 32px 24px 32px;
+    border-radius: 12px;
+    box-shadow: 0 4px 24px #00336622;
+}
+h2, h3, h4 {
+    color: #003366;
+    margin-top: 0;
+}
+form {
+    margin-bottom: 24px;
+    display: flex;
+    flex-direction: column;
+    align-items: center;
+}
+input[type="file"] {
+    margin-bottom: 16px;
+    font-size: 16px;
+}
+button {
+    background: #e30613;
+    color: #fff;
+    border: none;
+    padding: 12px 32px;
+    border-radius: 6px;
+    font-size: 16px;
+    font-weight: 700;
+    cursor: pointer;
+    transition: background 0.2s;
+    margin-bottom: 10px;
+}
+button:hover {
+    background: #003366;
+}
+.error {
+    color: #e30613;
+    margin-bottom: 16px;
+    font-weight: 700;
+}
+.images-row {
+    display: flex;
+    gap: 32px;
+    margin-bottom: 24px;
+    justify-content: center;
+    flex-wrap: wrap;
+}
+.result-img {
+    max-width: 260px;
+    border: 2px solid #e30613;
+    border-radius: 8px;
+    box-shadow: 0 2px 8px #00336622;
+    margin-bottom: 8px;
+}
+.result-label {
+    text-align: center;
+    font-weight: 700;
+    color: #003366;
+    margin-bottom: 8px;
+}
+.download-btn {
+    display: inline-block;
+    background: #003366;
+    color: #fff;
+    padding: 8px 18px;
+    border-radius: 5px;
+    text-decoration: none;
+    font-weight: 700;
+    margin-right: 10px;
+    margin-bottom: 10px;
+    transition: background 0.2s;
+}
+.download-btn:hover {
+    background: #e30613;
+}
+pre.json-output {
+    background: #f0f0f0;
+    padding: 16px;
+    border-radius: 6px;
+    font-size: 15px;
+    overflow-x: auto;
+    color: #222;
+    margin-bottom: 12px;
+    box-shadow: 0 1px 4px #00336611;
+}
+.copy-btn {
+    background: #e30613;
+    color: #fff;
+    border: none;
+    border-radius: 4px;
+    padding: 6px 14px;
+    font-size: 14px;
+    font-weight: 700;
+    cursor: pointer;
+    margin-bottom: 10px;
+    float: right;
+}
+.copy-btn:hover {
+    background: #003366;
+}
+.footer {
+    text-align: center;
+    color: #888;
+    font-size: 15px;
+    margin: 40px 0 10px 0;
+}
+@media (max-width: 900px) {
+    .container { padding: 16px; }
+    .images-row { gap: 12px; }
+    .result-img { max-width: 98vw; }
+}

app/static/results/4ea85461-64cd-4c8b-8ef9-3c9635df076b_result.json

@@ -0,0 +1,86 @@
+{
+  "filename": "28.jpg",
+  "damage": {
+    "severity_score": 0.7707259058952332,
+    "regions": [
+      {
+        "bbox": [
+          522.2720947265625,
+          530.5602416992188,
+          728.9972534179688,
+          892.2079467773438
+        ],
+        "confidence": 0.7707259058952332
+      },
+      {
+        "bbox": [
+          660.1974487304688,
+          512.72119140625,
+          927.4169921875,
+          883.8523559570312
+        ],
+        "confidence": 0.6494596600532532
+      },
+      {
+        "bbox": [
+          196.1370086669922,
+          277.27374267578125,
+          366.7127990722656,
+          712.44775390625
+        ],
+        "confidence": 0.32863757014274597
+      }
+    ]
+  },
+  "parts": [
+    {
+      "part": "hood",
+      "damaged": true,
+      "confidence": 0.9392628073692322,
+      "damage_percentage": 0.20169149219339333,
+      "bbox": [
+        411.4404296875,
+        342.9278869628906,
+        952.9636840820312,
+        578.835693359375
+      ]
+    },
+    {
+      "part": "headlamp",
+      "damaged": true,
+      "confidence": 0.9351847171783447,
+      "damage_percentage": 1.7647002993974346,
+      "bbox": [
+        531.9706420898438,
+        553.8896484375,
+        706.9000854492188,
+        656.3943481445312
+      ]
+    },
+    {
+      "part": "door",
+      "damaged": true,
+      "confidence": 0.9011728763580322,
+      "damage_percentage": 0.29901854346557094,
+      "bbox": [
+        143.66470336914062,
+        224.3675537109375,
+        391.3798522949219,
+        737.7504272460938
+      ]
+    },
+    {
+      "part": "front_bumper",
+      "damaged": true,
+      "confidence": 0.8590587377548218,
+      "damage_percentage": 0.03409931158993679,
+      "bbox": [
+        461.2880859375,
+        534.1759033203125,
+        978.0007934570312,
+        874.1959838867188
+      ]
+    }
+  ],
+  "cost_estimate": null
+}

app/static/results/9be81a29-214a-48af-ba99-8cab54a56d66_result.json

@@ -0,0 +1,83 @@
+{
+  "filename": "72.jpg",
+  "damage": {
+    "severity_score": 0.6467820405960083,
+    "regions": [
+      {
+        "bbox": [
+          20.340744018554688,
+          93.4926986694336,
+          112.2962646484375,
+          271.3760986328125
+        ],
+        "confidence": 0.6467820405960083
+      },
+      {
+        "bbox": [
+          129.6874237060547,
+          107.35161590576172,
+          238.290771484375,
+          377.91192626953125
+        ],
+        "confidence": 0.43937909603118896
+      },
+      {
+        "bbox": [
+          127.2110595703125,
+          23.03559684753418,
+          353.25946044921875,
+          420.0022888183594
+        ],
+        "confidence": 0.3795366883277893
+      },
+      {
+        "bbox": [
+          126.8061752319336,
+          38.61054611206055,
+          242.341064453125,
+          433.29034423828125
+        ],
+        "confidence": 0.3542208969593048
+      }
+    ]
+  },
+  "parts": [
+    {
+      "part": "hood",
+      "damaged": true,
+      "confidence": 0.746218204498291,
+      "damage_percentage": 0.2284878057871993,
+      "bbox": [
+        1.409912109375,
+        666.6517944335938,
+        200.2979278564453,
+        1020.8939819335938
+      ]
+    },
+    {
+      "part": "hood",
+      "damaged": true,
+      "confidence": 0.5614964962005615,
+      "damage_percentage": 0.04930226900457474,
+      "bbox": [
+        265.2085876464844,
+        582.6806030273438,
+        1017.8049926757812,
+        1016.5338745117188
+      ]
+    },
+    {
+      "part": "hood",
+      "damaged": true,
+      "confidence": 0.5332340598106384,
+      "damage_percentage": 0.25070920790460405,
+      "bbox": [
+        0.0,
+        501.2841796875,
+        358.5841369628906,
+        680.34912109375
+      ]
+    }
+  ],
+  "cost_estimate": null
+}

app/templates/index.html

@@ -0,0 +1,82 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <title>Car Damage Detection</title>
+    <link rel="stylesheet" href="/static/css/style.css">
+    <script>
+    function copyJSON() {
+        const pre = document.getElementById('json-pre');
+        if (pre) {
+            navigator.clipboard.writeText(pre.innerText);
+            alert('JSON copied to clipboard!');
+        }
+    }
+    function toggleJSON() {
+        const block = document.getElementById('json-block');
+        const btn = document.getElementById('toggle-json-btn');
+        if (block.style.display === 'none') {
+            block.style.display = 'block';
+            btn.innerText = 'Hide JSON';
+        } else {
+            block.style.display = 'none';
+            btn.innerText = 'Show JSON';
+        }
+    }
+    </script>
+</head>
+<body>
+    <div class="header" style="position:relative;">
+        <h2 style="margin:0;">Car Damage & Parts Detection</h2>
+        <img src="/static/img/logo.png" alt="Logo" class="logo" style="position:absolute; top:18px; right:32px; max-width:110px;">
+    </div>
+    <div class="container">
+        <form method="post" action="/upload" enctype="multipart/form-data">
+            <input type="file" name="file" accept="image/*" required>
+            <button type="submit">Upload & Analyze</button>
+        </form>
+        {% if error %}<div class="error">{{ error }}</div>{% endif %}
+        {% if result %}
+        <div class="results">
+            <h3>Results</h3>
+            <div class="images-row">
+                <div>
+                    <div class="result-label">Original</div>
+                    <img src="{{ original_image }}" alt="Original Image" class="result-img">
+                </div>
+                {% if result.damage_image is defined and result.damage_image %}
+                <div>
+                    <div class="result-label">Damage Prediction</div>
+                    <img src="{{ result.damage_image }}" alt="Damage Prediction" class="result-img">
+                </div>
+                {% endif %}
+                {% if result.parts_image is defined and result.parts_image %}
+                <div>
+                    <div class="result-label">Parts Prediction</div>
+                    <img src="{{ result.parts_image }}" alt="Parts Prediction" class="result-img">
+                </div>
+                {% endif %}
+            </div>
+            {% if result.json is defined and result.json %}
+                <h4 style="margin-bottom:8px;">JSON Output</h4>
+                <button class="copy-btn" onclick="copyJSON()" type="button">Copy JSON</button>
+                <button class="copy-btn" id="toggle-json-btn" onclick="toggleJSON()" type="button" style="margin-left:10px;">Show JSON</button>
+                <div id="json-block" style="display:none;">
+                    <pre class="json-output" id="json-pre">{{ result.json | tojson(indent=2) }}</pre>
+                </div>
+                <a class="download-btn" href="{{ result.json_download }}" download>Download JSON</a>
+            {% endif %}
+            {% if result.damage_image is defined and result.damage_image %}
+                <a class="download-btn" href="{{ result.damage_image }}" download>Download Damage Image</a>
+            {% endif %}
+            {% if result.parts_image is defined and result.parts_image %}
+                <a class="download-btn" href="{{ result.parts_image }}" download>Download Parts Image</a>
+            {% endif %}
+        </div>
+        {% endif %}
+    </div>
+    <div class="footer">
+        &copy; {{ 2025 }} RSA/Intact. All rights reserved.
+    </div>
+</body>
+</html>

app/templates/login.html

@@ -0,0 +1,22 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <title>Login - Car Damage Detection</title>
+    <link rel="stylesheet" href="/static/css/style.css">
+</head>
+<body>
+    <div class="container">
+        <img src="/static/img/logo.png" alt="Logo" class="logo">
+        <h2>Login</h2>
+        {% if error %}<div class="error">{{ error }}</div>{% endif %}
+        <form method="post" action="/login">
+            <label for="username">Username:</label>
+            <input type="text" id="username" name="username" required><br>
+            <label for="password">Password:</label>
+            <input type="password" id="password" name="password" required><br>
+            <button type="submit">Login</button>
+        </form>
+    </div>
+</body>
+</html>

configs/damage_config.yaml

@@ -0,0 +1,13 @@
+# Example Detectron2 config for damage model (1 class: damage)
+_BASE_: "COCO-InstanceSegmentation/mask_rcnn_R_50_FPN_3x.yaml"
+MODEL:
+  ROI_HEADS:
+    NUM_CLASSES: 1
+DATASETS:
+  TRAIN: ("damage_train",)
+  TEST: ("damage_val",)
+SOLVER:
+  IMS_PER_BATCH: 2
+  BASE_LR: 0.00025
+  MAX_ITER: 3000
+OUTPUT_DIR: "./weights/damage_model"

configs/parts_config.yaml

@@ -0,0 +1,13 @@
+# Example Detectron2 config for parts model (5 classes)
+_BASE_: "COCO-InstanceSegmentation/mask_rcnn_R_50_FPN_3x.yaml"
+MODEL:
+  ROI_HEADS:
+    NUM_CLASSES: 5
+DATASETS:
+  TRAIN: ("parts_train",)
+  TEST: ("parts_val",)
+SOLVER:
+  IMS_PER_BATCH: 2
+  BASE_LR: 0.00025
+  MAX_ITER: 3000
+OUTPUT_DIR: "./weights/parts_model"

inference/damage_inference.py

@@ -0,0 +1,58 @@
+# Inference and visualization for YOLOv8 damage segmentation on unseen images
+from ultralytics import YOLO
+import os
+from glob import glob
+import sys
+
+def run_inference():    # Get absolute paths
+    base_dir = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+    model_path = os.path.join(base_dir, 'models', 'damage', 'weights', 'weights', 'best.pt')
+    img_dir = os.path.join(base_dir, 'damage_detection_dataset', 'img')
+    out_dir = os.path.join(base_dir, 'inference_results', 'damage')
+    
+    # Validate paths
+    if not os.path.exists(model_path):
+        print(f"Error: Model weights not found at {model_path}")
+        return
+    
+    if not os.path.exists(img_dir):
+        print(f"Error: Image directory not found at {img_dir}")
+        return
+    
+    # Create output directory
+    os.makedirs(out_dir, exist_ok=True)
+    
+    # Get all images in the dataset
+    all_imgs = sorted(glob(os.path.join(img_dir, '*.jpg')))
+    if not all_imgs:
+        print(f"No images found in {img_dir}")
+        return
+    
+    try:
+        # Load model
+        model = YOLO(model_path)
+        
+        # Run inference and save results
+        for img_path in all_imgs:
+            try:
+                results = model.predict(
+                    source=img_path,
+                    save=True,
+                    project=out_dir,
+                    name='',
+                    imgsz=640,
+                    conf=0.25
+                )
+                print(f'Processed: {os.path.basename(img_path)}')
+            except Exception as e:
+                print(f"Error processing {os.path.basename(img_path)}: {str(e)}")
+                continue
+        
+        print(f'Inference complete. Results saved to {out_dir}')
+        
+    except Exception as e:
+        print(f"Error loading model: {str(e)}")
+        return
+
+if __name__ == '__main__':
+    run_inference()

inference/parts_inference.py

@@ -0,0 +1,74 @@
+# Inference on unseen images for YOLOv8 parts segmentation
+from ultralytics import YOLO
+import os
+from glob import glob
+
+def run_inference():    # Get absolute paths
+    base_dir = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+    model_path = os.path.join(base_dir, 'models', 'parts', 'weights', 'weights', 'best.pt')
+    img_dir = os.path.join(base_dir, 'damage_detection_dataset', 'img')
+    train_dir = os.path.join(base_dir, 'data', 'data_yolo_for_training', 'car_parts_damage_dataset', 'images', 'train')
+    out_dir = os.path.join(base_dir, 'inference_results', 'parts')
+    
+    # Validate paths
+    if not os.path.exists(model_path):
+        print(f"Error: Model weights not found at {model_path}")
+        return
+    
+    if not os.path.exists(img_dir):
+        print(f"Error: Image directory not found at {img_dir}")
+        return
+    
+    if not os.path.exists(train_dir):
+        print(f"Warning: Training directory not found at {train_dir}")
+        print("Will run inference on all images instead of just unseen ones")
+        train_imgs = set()
+    else:
+        # Get all images used for training
+        train_imgs = set(os.listdir(train_dir))
+    
+    # Create output directory
+    os.makedirs(out_dir, exist_ok=True)
+    
+    # Get all images in original dataset
+    all_imgs = set(os.listdir(img_dir))
+    # Select images not used in training
+    unseen_imgs = sorted(list(all_imgs - train_imgs))
+    
+    if not unseen_imgs:
+        print(f"No images found for inference in {img_dir}")
+        return
+    
+    try:
+        # Load model
+        model = YOLO(model_path)
+        
+        # Class names for visualization
+        class_names = ['headlamp', 'front_bumper', 'hood', 'door', 'rear_bumper']
+        
+        # Run inference on each unseen image
+        for img_name in unseen_imgs:
+            try:
+                img_path = os.path.join(img_dir, img_name)
+                results = model.predict(
+                    source=img_path,
+                    save=True,
+                    project=out_dir,
+                    name='',
+                    imgsz=640,
+                    conf=0.25,
+                    classes=list(range(len(class_names)))  # All classes
+                )
+                print(f'Processed: {img_name}')
+            except Exception as e:
+                print(f"Error processing {img_name}: {str(e)}")
+                continue
+        
+        print(f'Inference complete. Results saved to {out_dir}')
+        
+    except Exception as e:
+        print(f"Error loading model: {str(e)}")
+        return
+
+if __name__ == '__main__':
+    run_inference()

requirements.txt

@@ -0,0 +1,11 @@
+ultralytics
+opencv-python
+numpy
+matplotlib
+fastapi
+uvicorn[standard]
+ultralytics
+opencv-python
+jinja2
+starlette
+requests