Initial commit for Hugging Face Space deployment

.gitignore

@@ -0,0 +1,34 @@
+# Python
+__pycache__/
+*.pyc
+*.pyo
+*.pyd
+.Python
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+cardamage_venv/
+
+# VSCode
+.vscode/
+
+# OS
+.DS_Store
+Thumbs.db
+
+# Backup folders
+.backup_before_cleanup
+
+# Results/uploads
+app/static/results/
+app/static/uploads/
+damage_detection_dataset/
+inference_results/
+data/
+# Models and data
+models/
+damage_detection_dataset/
+inference_results/
+data/

Dockerfile

@@ -0,0 +1,22 @@
+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
+
+# Run FastAPI app with uvicorn
+CMD ["uvicorn", "app.main:app", "--host", "0.0.0.0", "--port", "7860"]

README.md

@@ -0,0 +1,23 @@
+---
+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/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,12 @@
+ultralytics
+opencv-python
+numpy
+matplotlib
+fastapi
+uvicorn
+ultralytics
+opencv-python
+numpy
+jinja2
+starlette
+requests

training/damage/data.yaml

@@ -0,0 +1,9 @@
+# YAML for YOLOv8 damage segmentation (1 class)
+path: E:/AI-ToolStack/Cardamagedetection/data/data_yolo_for_training/car_damage_dataset  # Root directory for dataset
+train: images/train  # Train images (relative to 'path')
+val: images/val  # Val images (relative to 'path')
+test: images/test  # Test images (relative to 'path')
+
+# Classes
+names: [damage]  # Class names
+nc: 1  # Number of classes

training/damage/train.py

@@ -0,0 +1,66 @@
+# YOLOv8 segmentation training for car damage detection
+from ultralytics import YOLO
+import multiprocessing
+import os
+
+def train():
+    # Start from YOLOv8 medium segmentation model
+    model = YOLO('../../models/yolov8m-seg.pt')
+
+    # Get the absolute path to the data.yaml file
+    current_dir = os.path.dirname(os.path.abspath(__file__))
+    data_yaml_path = os.path.join(current_dir, 'data.yaml')
+
+    # Train with optimized parameters
+    model.train(
+        data=data_yaml_path,  # Path to data configuration file
+        epochs=150,  # Number of epochs
+        imgsz=640,  # Image size
+        batch=4,    # Batch size
+        workers=4,  # Number of workers
+        project='../../models/damage/weights',  # Save directory
+        name='yolov8_damage_final',  # Run name
+        
+        # Learning rate strategy
+        lr0=0.0002,  # Initial learning rate
+        lrf=0.000001,  # Final learning rate
+        warmup_epochs=25,
+        warmup_momentum=0.8,
+        cos_lr=True,  # Use cosine learning rate scheduler
+        
+        # Loss weights
+        box=8.0,  # Box loss gain
+        cls=4.0,  # Class loss gain
+        dfl=2.5,  # DFL loss gain
+        
+        # Augmentation settings
+        augment=True,
+        mosaic=0.5,
+        mixup=0.2,
+        copy_paste=0.1,
+        degrees=20.0,
+        translate=0.2,
+        scale=0.4,
+        shear=10.0,
+        flipud=0.1,
+        fliplr=0.5,
+        hsv_h=0.015,
+        hsv_s=0.7,
+        hsv_v=0.4,
+        
+        # Other optimization settings
+        overlap_mask=True,  # Overlap mask segments
+        mask_ratio=4,  # Mask downsampling ratio
+        single_cls=True,  # Single class detection
+        rect=False,  # Rectangular training
+        cache=False,  # Cache images for faster training
+        patience=50,  # Early stopping patience
+        close_mosaic=10,  # Close mosaic augmentation epochs
+        deterministic=True,  # Deterministic mode
+        seed=42,  # Random seed
+        device=0  # GPU device
+    )
+
+if __name__ == '__main__':
+    multiprocessing.freeze_support()
+    train()

training/parts/data.yaml

@@ -0,0 +1,15 @@
+# YAML for YOLOv8 parts segmentation (5 classes)
+path: E:/AI-ToolStack/Cardamagedetection/data/data_yolo_for_training/car_parts_damage_dataset  # Root directory for dataset
+train: images/train  # Train images (relative to 'path')
+val: images/val  # Val images (relative to 'path')
+test: images/test  # Test images (relative to 'path')
+
+# Classes
+names:
+  0: headlamp
+  1: front_bumper
+  2: hood
+  3: door
+  4: rear_bumper
+
+nc: 5  # Number of classes

training/parts/train.py

@@ -0,0 +1,66 @@
+# YOLOv8 segmentation training for car parts detection
+from ultralytics import YOLO
+import multiprocessing
+import os
+
+def train():
+    # Start from YOLOv8 medium segmentation model
+    model = YOLO('../../models/yolov8m-seg.pt')
+
+    # Get the absolute path to the data.yaml file
+    current_dir = os.path.dirname(os.path.abspath(__file__))
+    data_yaml_path = os.path.join(current_dir, 'data.yaml')
+
+    # Train with optimized parameters for parts detection
+    model.train(
+        data=data_yaml_path,  # Path to data configuration file
+        epochs=100,  # Number of epochs
+        imgsz=640,  # Image size
+        batch=4,    # Batch size
+        workers=4,  # Number of workers
+        project='../../models/parts/weights',  # Save directory
+        name='yolov8_parts_final',  # Run name
+        
+        # Learning rate strategy
+        lr0=0.0002,  # Initial learning rate
+        lrf=0.000001,  # Final learning rate
+        warmup_epochs=20,  # Fewer warmup epochs for parts
+        warmup_momentum=0.8,
+        cos_lr=True,  # Use cosine learning rate scheduler
+        
+        # Loss weights
+        box=8.0,  # Box loss gain
+        cls=4.0,  # Class loss gain
+        dfl=2.5,  # DFL loss gain
+        
+        # Augmentation settings
+        augment=True,
+        mosaic=0.5,
+        mixup=0.2,
+        copy_paste=0.1,
+        degrees=20.0,
+        translate=0.2,
+        scale=0.4,
+        shear=10.0,
+        flipud=0.1,
+        fliplr=0.5,
+        hsv_h=0.015,
+        hsv_s=0.7,
+        hsv_v=0.4,
+        
+        # Other optimization settings
+        overlap_mask=True,  # Overlap mask segments
+        mask_ratio=4,  # Mask downsampling ratio
+        single_cls=False,  # Multiple classes for parts
+        rect=False,  # Rectangular training
+        cache=False,  # Cache images for faster training
+        patience=50,  # Early stopping patience
+        close_mosaic=10,  # Close mosaic augmentation epochs
+        deterministic=True,  # Deterministic mode
+        seed=42,  # Random seed
+        device=0  # GPU device
+    )
+
+if __name__ == '__main__':
+    multiprocessing.freeze_support()
+    train()

utils/balance_parts_dataset.py

@@ -0,0 +1,95 @@
+import json
+import os
+import shutil
+from collections import defaultdict
+import random
+from tqdm import tqdm
+
+def create_balanced_dataset(source_json, source_img_dir, target_dir, min_samples=50):
+    """
+    Create a balanced dataset for parts detection by sampling images with different parts.
+    
+    Args:
+        source_json (str): Path to source COCO JSON file
+        source_img_dir (str): Path to source images directory
+        target_dir (str): Path to target directory for balanced dataset
+        min_samples (int): Minimum number of samples per class
+    """
+    # Create target directories
+    os.makedirs(os.path.join(target_dir, 'images'), exist_ok=True)
+    os.makedirs(os.path.join(target_dir, 'labels'), exist_ok=True)
+    
+    # Load COCO annotations
+    with open(source_json, 'r') as f:
+        coco = json.load(f)
+    
+    # Group images by parts they contain
+    images_by_part = defaultdict(set)
+    image_to_anns = defaultdict(list)
+    
+    for ann in coco['annotations']:
+        img_id = ann['image_id']
+        cat_id = ann['category_id']
+        images_by_part[cat_id].add(img_id)
+        image_to_anns[img_id].append(ann)
+    
+    # Find images with balanced representation
+    selected_images = set()
+    for part_images in images_by_part.values():
+        # Sample min_samples images for each part
+        sample_size = min(min_samples, len(part_images))
+        selected_images.update(random.sample(list(part_images), sample_size))
+    
+    # Copy selected images and create labels
+    id_to_filename = {img['id']: img['file_name'] for img in coco['images']}
+    
+    print(f"Creating balanced dataset with {len(selected_images)} images...")
+    for img_id in tqdm(selected_images):
+        # Copy image
+        src_img = os.path.join(source_img_dir, id_to_filename[img_id])
+        dst_img = os.path.join(target_dir, 'images', id_to_filename[img_id])
+        shutil.copy2(src_img, dst_img)
+        
+        # Create YOLO label
+        base_name = os.path.splitext(id_to_filename[img_id])[0]
+        label_file = os.path.join(target_dir, 'labels', f"{base_name}.txt")
+        
+        # Convert annotations to YOLO format
+        anns = image_to_anns[img_id]
+        label_lines = []
+        
+        # Get image dimensions
+        from PIL import Image
+        im = Image.open(src_img)
+        w, h = im.size
+        
+        for ann in anns:
+            cat_id = ann['category_id']
+            # Convert segmentation to YOLO format
+            for seg in ann['segmentation']:
+                seg_norm = [str(x/w) if i%2==0 else str(x/h) for i,x in enumerate(seg)]
+                label_lines.append(f"{cat_id} {' '.join(seg_norm)}")
+        
+        # Write label file
+        with open(label_file, 'w') as f:
+            f.write('\n'.join(label_lines))
+
+if __name__ == "__main__":
+    current_dir = os.path.dirname(os.path.abspath(__file__))
+    base_dir = os.path.dirname(current_dir)
+    
+    # Process training set
+    create_balanced_dataset(
+        source_json=os.path.join(base_dir, "damage_detection_dataset", "train", "COCO_mul_train_annos.json"),
+        source_img_dir=os.path.join(base_dir, "damage_detection_dataset", "img"),
+        target_dir=os.path.join(base_dir, "data", "parts", "balanced", "train"),
+        min_samples=50
+    )
+    
+    # Process validation set
+    create_balanced_dataset(
+        source_json=os.path.join(base_dir, "damage_detection_dataset", "val", "COCO_mul_val_annos.json"),
+        source_img_dir=os.path.join(base_dir, "damage_detection_dataset", "img"),
+        target_dir=os.path.join(base_dir, "data", "parts", "balanced", "val"),
+        min_samples=10
+    )

utils/matching.py

@@ -0,0 +1,19 @@
+import numpy as np
+
+def get_overlapping_part(damage_mask, part_masks, part_labels):
+    max_iou = 0
+    matched_part = None
+    for mask, label in zip(part_masks, part_labels):
+        iou = np.sum(np.logical_and(damage_mask, mask)) / np.sum(np.logical_or(damage_mask, mask))
+        if iou > max_iou:
+            max_iou = iou
+            matched_part = label
+    return matched_part, max_iou
+
+def estimate_severity(area, part_label):
+    if area < 2000:
+        return "minor"
+    elif area < 8000:
+        return "moderate"
+    else:
+        return "severe" if part_label in ["front_bumper", "hood", "rear_bumper"] else "moderate"

utils/organize_complete_datasets.py

@@ -0,0 +1,220 @@
+import os
+import shutil
+import json
+from collections import defaultdict
+import random
+from tqdm import tqdm
+from PIL import Image
+
+def convert_coco_to_yolo(coco_json_path, images_dir, output_dir, class_map, split='train'):
+    """Convert COCO format annotations to YOLO format"""
+    if not os.path.exists(coco_json_path):
+        print(f"Warning: JSON file not found: {coco_json_path}")
+        return set()
+        
+    if not os.path.exists(images_dir):
+        print(f"Warning: Images directory not found: {images_dir}")
+        return set()
+    
+    print(f"\nProcessing {split} split...")
+    
+    # Create output directories
+    labels_dir = os.path.join(output_dir, 'labels', split)
+    images_dir_out = os.path.join(output_dir, 'images', split)
+    os.makedirs(labels_dir, exist_ok=True)
+    os.makedirs(images_dir_out, exist_ok=True)
+    
+    # Load COCO annotations
+    try:
+        with open(coco_json_path, 'r') as f:
+            coco = json.load(f)
+    except json.JSONDecodeError:
+        print(f"Error: Invalid JSON file: {coco_json_path}")
+        return set()
+    
+    # Create id to filename mapping
+    id_to_filename = {img['id']: img['file_name'] for img in coco['images']}
+    
+    # Group annotations by image
+    img_to_anns = defaultdict(list)
+    for ann in coco['annotations']:
+        img_to_anns[ann['image_id']].append(ann)
+    
+    # Process each image
+    processed_images = set()
+    for img_id, anns in tqdm(img_to_anns.items(), desc=f"Converting {split} set"):
+        img_file = id_to_filename[img_id]
+        img_path = os.path.join(images_dir, img_file)
+        
+        if not os.path.exists(img_path):
+            print(f"Warning: Image {img_path} not found, skipping...")
+            continue
+        
+        try:
+            # Copy image
+            shutil.copy2(img_path, os.path.join(images_dir_out, img_file))
+            
+            # Get image dimensions
+            with Image.open(img_path) as im:
+                w, h = im.size
+            
+            # Convert annotations
+            label_lines = []
+            for ann in anns:
+                cat_id = ann['category_id']
+                if cat_id not in class_map:
+                    print(f"Warning: Unknown category ID {cat_id} in {img_file}")
+                    continue
+                yolo_cls = class_map[cat_id]
+                
+                # Convert segmentation points
+                for seg in ann['segmentation']:
+                    coords = [str(x/w) if i%2==0 else str(x/h) for i,x in enumerate(seg)]
+                    label_lines.append(f"{yolo_cls} {' '.join(coords)}")
+            
+            # Write label file
+            label_file = os.path.join(labels_dir, os.path.splitext(img_file)[0] + '.txt')
+            with open(label_file, 'w') as f:
+                f.write('\n'.join(label_lines))
+            
+            processed_images.add(img_id)
+            
+        except (IOError, OSError) as e:
+            print(f"Error processing {img_file}: {str(e)}")
+            continue
+    
+    return processed_images
+
+def create_balanced_dataset(source_json, images_dir, output_dir, class_map, min_samples=50, split='train'):
+    """Create balanced dataset by sampling equal number of images per class"""
+    print(f"\nCreating balanced dataset for {split} split...")
+    
+    # Create output directories
+    labels_dir = os.path.join(output_dir, 'labels', split)
+    images_dir_out = os.path.join(output_dir, 'images', split)
+    os.makedirs(labels_dir, exist_ok=True)
+    os.makedirs(images_dir_out, exist_ok=True)
+    
+    # Load COCO annotations
+    with open(source_json, 'r') as f:
+        coco = json.load(f)
+    
+    # Group images by parts they contain
+    images_by_part = defaultdict(set)
+    image_to_anns = defaultdict(list)
+    
+    for ann in coco['annotations']:
+        img_id = ann['image_id']
+        cat_id = ann['category_id']
+        images_by_part[cat_id].add(img_id)
+        image_to_anns[img_id].append(ann)
+    
+    # Sample images for balanced dataset
+    selected_images = set()
+    for part_images in images_by_part.values():
+        sample_size = min(min_samples, len(part_images))
+        selected_images.update(random.sample(list(part_images), sample_size))
+    
+    # Convert selected images to YOLO format
+    id_to_filename = {img['id']: img['file_name'] for img in coco['images']}
+    
+    print(f"Processing {len(selected_images)} images for balanced {split} set...")
+    for img_id in tqdm(selected_images):
+        img_file = id_to_filename[img_id]
+        img_path = os.path.join(images_dir, img_file)
+        
+        if not os.path.exists(img_path):
+            print(f"Warning: Image {img_path} not found, skipping...")
+            continue
+        
+        # Copy image
+        shutil.copy2(img_path, os.path.join(images_dir_out, img_file))
+        
+        # Get image dimensions
+        with Image.open(img_path) as im:
+            w, h = im.size
+        
+        # Convert annotations
+        label_lines = []
+        for ann in image_to_anns[img_id]:
+            cat_id = ann['category_id']
+            yolo_cls = class_map[cat_id]
+            
+            # Convert segmentation points
+            for seg in ann['segmentation']:
+                coords = [str(x/w) if i%2==0 else str(x/h) for i,x in enumerate(seg)]
+                label_lines.append(f"{yolo_cls} {' '.join(coords)}")
+        
+        # Write label file
+        label_file = os.path.join(labels_dir, os.path.splitext(img_file)[0] + '.txt')
+        with open(label_file, 'w') as f:
+            f.write('\n'.join(label_lines))
+
+def main():
+    base_dir = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+    source_dir = os.path.join(base_dir, 'damage_detection_dataset')
+    
+    if not os.path.exists(source_dir):
+        print(f"Error: Source directory not found: {source_dir}")
+        return
+    
+    # Set up output directories
+    car_damage_dir = os.path.join(base_dir, 'data', 'data_yolo_for_training', 'car_damage_dataset')
+    car_parts_dir = os.path.join(base_dir, 'data', 'data_yolo_for_training', 'car_parts_damage_dataset')
+    
+    # Class mappings
+    damage_class_map = {1: 0}  # Assuming damage is class 1 in COCO format
+    parts_class_map = {1: 0, 2: 1, 3: 2, 4: 3, 5: 4}  # headlamp, front_bumper, hood, door, rear_bumper
+    
+    # Process car damage dataset (full dataset)
+    print("\nProcessing Car Damage Dataset...")
+    for split in ['train', 'val', 'test']:
+        json_name = 'COCO_train_annos.json' if split == 'train' else 'COCO_val_annos.json'
+        json_path = os.path.join(source_dir, split, json_name)
+        images_dir = os.path.join(source_dir, split)
+        
+        if os.path.exists(json_path):
+            convert_coco_to_yolo(
+                json_path,
+                images_dir,
+                car_damage_dir,
+                damage_class_map,
+                split
+            )
+        else:
+            print(f"Warning: JSON file not found for {split} split: {json_path}")
+    
+    # Process car parts dataset (balanced training, original val/test)
+    print("\nProcessing Car Parts Dataset...")
+    # Training set - balanced
+    train_json = os.path.join(source_dir, 'train', 'COCO_mul_train_annos.json')
+    if os.path.exists(train_json):
+        create_balanced_dataset(
+            train_json,
+            os.path.join(source_dir, 'train'),
+            car_parts_dir,
+            parts_class_map,
+            min_samples=50,
+            split='train'
+        )
+    else:
+        print(f"Warning: Training JSON file not found: {train_json}")
+    
+    # Validation and test sets - original
+    for split in ['val', 'test']:
+        json_path = os.path.join(source_dir, split, 'COCO_mul_val_annos.json')
+        images_dir = os.path.join(source_dir, split)
+        
+        if os.path.exists(json_path):
+            convert_coco_to_yolo(
+                json_path,
+                images_dir,
+                car_parts_dir,
+                parts_class_map,
+                split
+            )
+        else:
+            print(f"Warning: JSON file not found for {split} split: {json_path}")
+
+if __name__ == '__main__':
+    main()