Upload 15 files

Dockerfile

@@ -0,0 +1,26 @@
+FROM python:3.10-slim
+
+ENV PYTHONDONTWRITEBYTECODE=1
+ENV PYTHONUNBUFFERED=1
+
+WORKDIR /app
+
+# --- SYSTEM DEPENDENCIES (CRITICAL FOR OPENCV / YOLO) ---
+RUN apt-get update && apt-get install -y \
+    build-essential \
+    gcc \
+    libgl1 \
+    libglib2.0-0 \
+    && rm -rf /var/lib/apt/lists/*
+
+# --- PYTHON DEPENDENCIES ---
+COPY requirements.txt .
+RUN pip install --no-cache-dir --upgrade pip \
+    && pip install --no-cache-dir -r requirements.txt
+
+# --- APP CODE ---
+COPY . .
+
+EXPOSE 7860
+
+CMD ["uvicorn", "app:app", "--host", "0.0.0.0", "--port", "7860"]

Notebooks/Model_Compression.ipynb

@@ -0,0 +1,276 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "671818be",
+   "metadata": {},
+   "source": [
+    "# Model Conversion or Compression \n",
+    "**This notebook demonstrates how to convert a PyTorch model to FP16 precision, which can reduce the model size and potentially speed up inference on compatible hardware. We will use the `FusionClassifier` as an example, but the same approach can be applied to other models as well.**\n",
+    "\n",
+    "**From FP32 to FP16**"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "id": "b1715593",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Loading weights: 100%|██████████| 342/342 [00:00<00:00, 2845.51it/s]\n",
+      "[transformers] \u001b[1mConvNextModel LOAD REPORT\u001b[0m from: facebook/convnext-small-224\n",
+      "Key               | Status     |  | \n",
+      "------------------+------------+--+-\n",
+      "classifier.bias   | UNEXPECTED |  | \n",
+      "classifier.weight | UNEXPECTED |  | \n",
+      "\n",
+      "Notes:\n",
+      "- UNEXPECTED:\tcan be ignored when loading from different task/architecture; not ok if you expect identical arch.\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "============================================================\n",
+      "Initializing model...\n",
+      "============================================================\n",
+      "Model weights loaded successfully.\n",
+      "Model converted to FP16.\n",
+      "============================================================\n",
+      "FP16 model saved successfully.\n",
+      "Saved Path : D:\\DamageLens\\checkpoints\\best_fusion_model_fp16.pth\n",
+      "FP16 Model Size : 135.77 MB\n",
+      "============================================================\n"
+     ]
+    }
+   ],
+   "source": [
+    "import os\n",
+    "import torch\n",
+    "import torch.nn as nn\n",
+    "import torchvision.models as models\n",
+    "from transformers import ConvNextModel\n",
+    "\n",
+    "\n",
+    "# =========================================================\n",
+    "# FUSION MODEL\n",
+    "# =========================================================\n",
+    "\n",
+    "class FusionClassifier(nn.Module):\n",
+    "    def __init__(self, num_classes, convnext_model_name=\"facebook/convnext-small-224\"):\n",
+    "        super().__init__()\n",
+    "\n",
+    "        # -------------------------------------------------\n",
+    "        # EfficientNet-V2-S\n",
+    "        # -------------------------------------------------\n",
+    "        eff = models.efficientnet_v2_s(\n",
+    "            weights=models.EfficientNet_V2_S_Weights.IMAGENET1K_V1\n",
+    "        )\n",
+    "\n",
+    "        # Freeze all\n",
+    "        for param in eff.parameters():\n",
+    "            param.requires_grad = False\n",
+    "\n",
+    "        # Unfreeze last stages\n",
+    "        for param in eff.features[5].parameters():\n",
+    "            param.requires_grad = True\n",
+    "\n",
+    "        for param in eff.features[6].parameters():\n",
+    "            param.requires_grad = True\n",
+    "\n",
+    "        for param in eff.features[7].parameters():\n",
+    "            param.requires_grad = True\n",
+    "\n",
+    "        self.eff_features = eff.features\n",
+    "        self.eff_avgpool = eff.avgpool\n",
+    "        self.eff_out_dim = eff.classifier[1].in_features  # 1280\n",
+    "\n",
+    "        # -------------------------------------------------\n",
+    "        # ConvNeXt Small\n",
+    "        # -------------------------------------------------\n",
+    "        cnx = ConvNextModel.from_pretrained(convnext_model_name)\n",
+    "\n",
+    "        # Freeze all\n",
+    "        for param in cnx.parameters():\n",
+    "            param.requires_grad = False\n",
+    "\n",
+    "        # Unfreeze stages\n",
+    "        for param in cnx.encoder.stages[2].parameters():\n",
+    "            param.requires_grad = True\n",
+    "\n",
+    "        for param in cnx.encoder.stages[3].parameters():\n",
+    "            param.requires_grad = True\n",
+    "\n",
+    "        for param in cnx.layernorm.parameters():\n",
+    "            param.requires_grad = True\n",
+    "\n",
+    "        self.cnx_backbone = cnx\n",
+    "        self.cnx_out_dim = 768\n",
+    "\n",
+    "        # -------------------------------------------------\n",
+    "        # Fusion Head\n",
+    "        # -------------------------------------------------\n",
+    "        fused_dim = self.eff_out_dim + self.cnx_out_dim\n",
+    "\n",
+    "        self.fusion_head = nn.Sequential(\n",
+    "            nn.Dropout(0.4),\n",
+    "\n",
+    "            nn.Linear(fused_dim, 512),\n",
+    "            nn.LayerNorm(512),\n",
+    "            nn.GELU(),\n",
+    "\n",
+    "            nn.Dropout(0.3),\n",
+    "\n",
+    "            nn.Linear(512, 256),\n",
+    "            nn.LayerNorm(256),\n",
+    "            nn.GELU(),\n",
+    "\n",
+    "            nn.Dropout(0.2),\n",
+    "\n",
+    "            nn.Linear(256, num_classes)\n",
+    "        )\n",
+    "\n",
+    "    def forward(self, pixel_values_eff, pixel_values_cnx):\n",
+    "\n",
+    "        # EfficientNet branch\n",
+    "        x_eff = self.eff_features(pixel_values_eff)\n",
+    "        x_eff = self.eff_avgpool(x_eff)\n",
+    "        x_eff = torch.flatten(x_eff, 1)\n",
+    "\n",
+    "        # ConvNeXt branch\n",
+    "        cnx_out = self.cnx_backbone(\n",
+    "            pixel_values=pixel_values_cnx,\n",
+    "            return_dict=True\n",
+    "        )\n",
+    "\n",
+    "        x_cnx = cnx_out.pooler_output\n",
+    "\n",
+    "        # Fusion\n",
+    "        fused = torch.cat([x_eff, x_cnx], dim=1)\n",
+    "\n",
+    "        logits = self.fusion_head(fused)\n",
+    "\n",
+    "        return logits\n",
+    "\n",
+    "\n",
+    "# =========================================================\n",
+    "# CONFIG\n",
+    "# =========================================================\n",
+    "\n",
+    "class_map = {\n",
+    "    0: \"Front Breakage\",\n",
+    "    1: \"Front Crushed\",\n",
+    "    2: \"Front Normal\",\n",
+    "    3: \"Rear Breakage\",\n",
+    "    4: \"Rear Crushed\",\n",
+    "    5: \"Rear Normal\"\n",
+    "}\n",
+    "\n",
+    "device = torch.device(\"cpu\")\n",
+    "\n",
+    "CHECKPOINT_PATH = r\"D:\\DamageLens\\checkpoints\\best_fusion_model.pt\"\n",
+    "\n",
+    "SAVE_FP16_PATH = r\"D:\\DamageLens\\checkpoints\\best_fusion_model_fp16.pth\"\n",
+    "\n",
+    "NUM_CLASSES = len(class_map)\n",
+    "\n",
+    "CONVNEXT_MODEL_NAME = \"facebook/convnext-small-224\"\n",
+    "\n",
+    "\n",
+    "# =========================================================\n",
+    "# INITIALIZE MODEL\n",
+    "# =========================================================\n",
+    "\n",
+    "model = FusionClassifier(\n",
+    "    num_classes=NUM_CLASSES,\n",
+    "    convnext_model_name=CONVNEXT_MODEL_NAME\n",
+    ")\n",
+    "\n",
+    "print(\"=\" * 60)\n",
+    "print(\"Initializing model...\")\n",
+    "print(\"=\" * 60)\n",
+    "\n",
+    "\n",
+    "# =========================================================\n",
+    "# LOAD TRAINED WEIGHTS\n",
+    "# =========================================================\n",
+    "\n",
+    "checkpoint = torch.load(\n",
+    "    CHECKPOINT_PATH,\n",
+    "    map_location=device\n",
+    ")\n",
+    "\n",
+    "# If checkpoint contains state_dict\n",
+    "if \"model_state_dict\" in checkpoint:\n",
+    "    model.load_state_dict(checkpoint[\"model_state_dict\"])\n",
+    "\n",
+    "# If checkpoint is directly state_dict\n",
+    "else:\n",
+    "    model.load_state_dict(checkpoint)\n",
+    "\n",
+    "print(\"Model weights loaded successfully.\")\n",
+    "\n",
+    "\n",
+    "# =========================================================\n",
+    "# CONVERT TO FP16\n",
+    "# =========================================================\n",
+    "\n",
+    "model = model.half()\n",
+    "\n",
+    "print(\"Model converted to FP16.\")\n",
+    "\n",
+    "\n",
+    "# =========================================================\n",
+    "# CREATE CHECKPOINT DIRECTORY\n",
+    "# =========================================================\n",
+    "\n",
+    "os.makedirs(\"checkpoints\", exist_ok=True)\n",
+    "\n",
+    "\n",
+    "# =========================================================\n",
+    "# SAVE FP16 MODEL\n",
+    "# =========================================================\n",
+    "\n",
+    "torch.save(\n",
+    "    model.state_dict(),\n",
+    "    SAVE_FP16_PATH\n",
+    ")\n",
+    "\n",
+    "print(\"=\" * 60)\n",
+    "print(\"FP16 model saved successfully.\")\n",
+    "print(f\"Saved Path : {SAVE_FP16_PATH}\")\n",
+    "\n",
+    "size_mb = os.path.getsize(SAVE_FP16_PATH) / (1024 * 1024)\n",
+    "\n",
+    "print(f\"FP16 Model Size : {size_mb:.2f} MB\")\n",
+    "print(\"=\" * 60)"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "myvenv",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.11.0"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

app.py

@@ -0,0 +1,107 @@
+import os
+import uuid
+import shutil
+from fastapi import FastAPI, UploadFile, File, HTTPException
+from fastapi.staticfiles import StaticFiles
+from PIL import Image
+from fastapi.middleware.cors import CORSMiddleware
+from dotenv import load_dotenv
+from scripts.gradcam import get_resnet_gradcam, get_fusion_gradcam
+from scripts.yolo import get_yolo_damage_boxes
+from scripts.model_loader import initialize_models
+
+load_dotenv()
+app = FastAPI()
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+UPLOAD_DIR = "static/uploads"
+RESULT_DIR = "static/results"
+os.makedirs(UPLOAD_DIR, exist_ok=True)
+os.makedirs(RESULT_DIR, exist_ok=True)
+app.mount("/static", StaticFiles(directory="static"), name="static")
+class_map = {
+    0: "Front Breakage",
+    1: "Front Crushed",
+    2: "Front Normal",
+    3: "Rear Breakage",
+    4: "Rear Crushed",
+    5: "Rear Normal"
+}
+resnet_predictor, fusion_predictor = initialize_models(class_map)
+
+@app.get("/")
+def api_status():
+    return {"status": "API is running"}
+
+@app.post("/predict")
+async def predict_and_generate_cams(file: UploadFile = File(...), mode: str = "resnet"):
+    mode = mode.lower()
+    if mode not in {"resnet", "fusion"}:
+        raise HTTPException(status_code=400, detail="mode must be 'resnet' or 'fusion'")
+    unique_id = str(uuid.uuid4())
+    input_filename = f"{unique_id}_input.jpg"
+    input_path = os.path.join(UPLOAD_DIR, input_filename)
+    with open(input_path, "wb") as buffer:
+        shutil.copyfileobj(file.file, buffer)
+    if mode == "resnet":
+        output_name = f"{unique_id}_resnet.jpg"
+        output_path = os.path.join(RESULT_DIR, output_name)
+        get_resnet_gradcam(input_path, resnet_predictor, output_path)
+        selected_viz = f"/static/results/{output_name}"
+        resnet_viz = selected_viz
+        fusion_viz = None
+    else:
+        output_name = f"{unique_id}_fusion.jpg"
+        output_path = os.path.join(RESULT_DIR, output_name)
+        get_fusion_gradcam(input_path, fusion_predictor, output_path)
+        selected_viz = f"/static/results/{output_name}"
+        resnet_viz = None
+        fusion_viz = selected_viz
+    return {
+        "status": "success",
+        "original_image": f"/static/uploads/{input_filename}",
+        "selected_viz": selected_viz,
+        "resnet_viz": resnet_viz,
+        "fusion_viz": fusion_viz,
+        "mode": mode
+    }
+
+@app.post("/predict/resnet")
+async def resnet_prediction(image: UploadFile = File(...)):
+    try:
+        image = Image.open(image.file).convert("RGB")
+    except Exception:
+        raise HTTPException(status_code=400, detail="Invalid image file")
+    return resnet_predictor.resnet_predict(image_input=image)
+
+@app.post("/predict/fusion")
+async def fusion_prediction(image: UploadFile = File(...)):
+    try:
+        image = Image.open(image.file).convert("RGB")
+    except Exception:
+        raise HTTPException(status_code=400, detail="Invalid image file")
+    return fusion_predictor.predict(image_input=image)
+
+@app.post("/predict/yolo")
+async def yolo_detection(file: UploadFile = File(...)):
+    unique_id = str(uuid.uuid4())
+    input_filename = f"{unique_id}_input.jpg"
+    yolo_out_name = f"{unique_id}_yolo.jpg"
+    input_path = os.path.join(UPLOAD_DIR, input_filename)
+    yolo_path = os.path.join(RESULT_DIR, yolo_out_name)
+    with open(input_path, "wb") as buffer:
+        shutil.copyfileobj(file.file, buffer)
+    result = get_yolo_damage_boxes(input_path, yolo_path)
+    return {
+        "status": "success",
+        "original_image": f"/static/uploads/{input_filename}",
+        "yolo_image": f"/static/results/{yolo_out_name}",
+        "detections": result["detections"],
+        "total_detections": result["total_detections"],
+        "message": result["message"]
+    }

checkpoints/best_fusion_model_fp16.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:59cede9aca6c4b39b6447458ddb9cdc3e3ba06c5d972ad62b6807bfcd0afa466
+size 142369497

checkpoints/best_resnet_model.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:688cbd4f9eb2e97b6e67287b23f5f750b0367dfb08844704d49075fb086bbdd5
+size 130360907

checkpoints/damage_detector.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:7c3b9222d9977b5bfd78d65ea6be9d609c81de473349bb3f362088a86ba07f9f
+size 51189913

index.html

@@ -0,0 +1,419 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Car Damage AI</title>
+    <script src="https://cdn.plot.ly/plotly-2.27.0.min.js"></script>
+    <style>
+        @import url('https://fonts.googleapis.com/css2?family=Inter:wght@300;400;600;800&display=swap');
+
+        :root {
+            --bg-dark: #09090b;
+            --bg-card: #18181b; 
+            --text-primary: #e2e8f0;
+            --text-secondary: #a1a1aa;
+            --accent: #00c6ff;
+            --accent-hover: #0072ff;
+            --glass: rgba(255, 255, 255, 0.03);
+            --card-border: #27272a;
+        }
+
+        * { margin: 0; padding: 0; box-sizing: border-box; font-family: 'Inter', sans-serif; }
+
+        body {
+            background-color: var(--bg-dark);
+            color: var(--text-primary);
+            min-height: 100vh;
+            display: flex;
+            justify-content: center;
+            align-items: flex-start;
+            padding: 40px 20px;
+            background-image: radial-gradient(circle at top right, rgba(0, 198, 255, 0.05) 0%, transparent 40%);
+        }
+
+        .container {
+            width: 100%;
+            max-width: 850px;
+            background: var(--bg-card);
+            border-radius: 20px;
+            padding: 35px;
+            box-shadow: 0 20px 40px rgba(0,0,0,0.6);
+            animation: slideUpFade 0.6s ease-out forwards;
+            border: 1px solid var(--card-border);
+        }
+
+        @keyframes slideUpFade { from { opacity: 0; transform: translateY(30px); } to { opacity: 1; transform: translateY(0); } }
+
+        /* Shimmering Main Title */
+        .shimmer-text {
+            text-align: center;
+            font-size: 2.5rem;
+            font-weight: 800;
+            background: linear-gradient(90deg, #e2e8f0 0%, #ffffff 25%, #00c6ff 50%, #e2e8f0 75%, #e2e8f0 100%);
+            background-size: 200% auto;
+            color: transparent;
+            -webkit-background-clip: text;
+            background-clip: text;
+            animation: shimmer 4s linear infinite;
+            margin-bottom: 0.2rem;
+        }
+        @keyframes shimmer { 0% { background-position: -200% center; } 100% { background-position: 200% center; } }
+
+        .subtitle { text-align: center; color: var(--text-secondary); font-size: 1rem; margin-bottom: 25px; }
+
+        /* Warning Box */
+        .warning-box {
+            background: rgba(0, 198, 255, 0.1);
+            border-left: 4px solid var(--accent);
+            color: var(--text-primary);
+            padding: 12px 15px;
+            border-radius: 8px;
+            margin-bottom: 25px;
+            font-size: 0.9rem;
+            display: flex;
+            align-items: center;
+            gap: 12px;
+        }
+
+        /* Controls Section */
+        .controls-grid {
+            display: grid;
+            grid-template-columns: 1fr 1fr;
+            gap: 20px;
+            margin-bottom: 25px;
+        }
+
+        .file-wrapper {
+            position: relative; height: 160px; border: 2px dashed #444; border-radius: 16px;
+            display: flex; justify-content: center; align-items: center; cursor: pointer;
+            transition: all 0.3s ease; background: var(--glass); overflow: hidden;
+        }
+        .file-wrapper:hover { border-color: var(--accent); background: rgba(0, 198, 255, 0.05); }
+        .file-wrapper input { position: absolute; width: 100%; height: 100%; opacity: 0; cursor: pointer; z-index: 2; }
+
+        .settings-card {
+            background: rgba(0,0,0,0.2);
+            border-radius: 16px;
+            padding: 20px;
+            border: 1px solid var(--card-border);
+            display: flex;
+            flex-direction: column;
+            justify-content: center;
+        }
+        
+        select {
+            width: 100%; background: #27272a; border: 1px solid #3f3f46; padding: 14px; 
+            border-radius: 12px; color: white; outline: none; margin-top: 10px; font-size: 1rem;
+        }
+        select:focus { border-color: var(--accent); }
+
+        /* Preview Area & Animations */
+        .image-area {
+            width: 100%; height: 350px; background: #09090b; border-radius: 16px;
+            margin-bottom: 25px; display: none; justify-content: center; align-items: center;
+            overflow: hidden; position: relative; border: 1px solid var(--card-border);
+        }
+        .image-area img { max-width: 100%; max-height: 100%; object-fit: contain; z-index: 1;}
+
+        /* Scanner Animation */
+        .scan-line {
+            position: absolute; top: -10%; left: 0; width: 100%; height: 5px;
+            background: var(--accent); box-shadow: 0 0 15px var(--accent), 0 0 30px var(--accent);
+            z-index: 5; opacity: 0.8; display: none; animation: scanMove 2s ease-in-out infinite; filter: blur(1px);
+        }
+        @keyframes scanMove { 0% { top: -10%; opacity: 0.5; } 50% { opacity: 1; } 100% { top: 110%; opacity: 0.5; } }
+
+        /* Loader Overlay */
+        .loader-overlay {
+            position: absolute; top: 0; left: 0; width: 100%; height: 100%;
+            background: rgba(0,0,0,0.65); backdrop-filter: blur(4px);
+            display: none; flex-direction: column; justify-content: center; align-items: center; z-index: 10;
+        }
+        .spinner {
+            width: 50px; height: 50px; border: 4px solid rgba(0, 198, 255, 0.2);
+            border-top: 4px solid var(--accent); border-radius: 50%;
+            animation: spin 1s cubic-bezier(0.68, -0.55, 0.27, 1.55) infinite; margin-bottom: 15px;
+        }
+        @keyframes spin { 100% { transform: rotate(360deg); } }
+
+        /* Buttons */
+        .btn { 
+            width: 100%; padding: 16px; background: linear-gradient(135deg, var(--accent) 0%, var(--accent-hover) 100%);
+            color: white; border: none; border-radius: 12px; cursor: pointer; font-weight: 700; font-size: 1rem; 
+            transition: all 0.3s ease; box-shadow: 0 4px 15px rgba(0, 114, 255, 0.3);
+        }
+        .btn:hover:not(:disabled) { transform: scale(1.02); box-shadow: 0 8px 25px rgba(0, 198, 255, 0.5); }
+        .btn:disabled { background: #444; color: #888; box-shadow: none; transform: none; cursor: not-allowed;}
+
+        /* Results Tabs */
+        .results-section { display: none; margin-top: 30px; animation: slideUpFade 0.5s ease-out; }
+        .tabs { display: flex; gap: 10px; margin-bottom: 20px; border-bottom: 1px solid var(--card-border); padding-bottom: 10px; overflow-x: auto; }
+        .tab { 
+            padding: 10px 20px; cursor: pointer; border-radius: 8px; color: var(--text-secondary); 
+            font-weight: 600; transition: all 0.3s ease; white-space: nowrap;
+        }
+        .tab.active { background: rgba(0, 198, 255, 0.1); color: var(--accent); }
+        .tab-content { display: none; }
+        .tab-content.active { display: block; animation: slideUpFade 0.4s ease-out; }
+
+        /* Progress Bar */
+        .progress-wrapper { background: #27272a; border-radius: 20px; overflow: hidden; height: 12px; margin: 10px 0 20px 0; box-shadow: inset 0 2px 4px rgba(0,0,0,0.5); }
+        .progress-fill { height: 100%; background: linear-gradient(90deg, var(--accent), var(--accent-hover)); border-radius: 20px; width: 0%; transition: width 1.5s cubic-bezier(0.22, 1, 0.36, 1); }
+
+        /* Final Prediction Text */
+        .big-text { font-size: 2.5rem; font-weight: 800; background: -webkit-linear-gradient(45deg, #00c6ff, #0072ff); -webkit-background-clip: text; -webkit-text-fill-color: transparent; margin-bottom: 5px; }
+
+        /* Images Grid (Attention Maps) */
+        .img-grid { display: grid; grid-template-columns: repeat(3, 1fr); gap: 15px; }
+        .img-card { background: rgba(0,0,0,0.3); border: 1px solid var(--card-border); border-radius: 12px; padding: 10px; text-align: center; }
+        .img-card img { width: 100%; border-radius: 8px; margin-top: 10px; }
+
+        /* YOLO Grid */
+        .yolo-grid { display: grid; grid-template-columns: 1.5fr 1fr; gap: 20px; }
+        .log-box { background: rgba(0,0,0,0.3); border: 1px solid var(--card-border); border-radius: 12px; padding: 20px; height: 100%; }
+        .detection-item { background: #27272a; padding: 12px; border-radius: 8px; margin-bottom: 10px; border-left: 4px solid var(--accent); box-shadow: 0 2px 4px rgba(0,0,0,0.2); }
+
+        @media (max-width: 768px) {
+            .controls-grid, .img-grid, .yolo-grid { grid-template-columns: 1fr; }
+            .shimmer-text { font-size: 2rem; }
+        }
+    </style>
+</head>
+<body>
+
+<div class="container">
+    <div class="shimmer-text">🚗 Car Damage AI</div>
+    <div class="subtitle">Fusion Intelligence: ResNet + YOLO</div>
+
+    <div class="warning-box">
+        <span style="font-size: 1.2rem;">⏱️</span>
+        <span><b>Note:</b> The first analysis may take up to 3-4 mins while models warm up. Subsequent requests are faster!</span>
+    </div>
+
+    <div class="controls-grid">
+        <div class="file-wrapper">
+            <input type="file" id="fileInput" accept="image/jpeg, image/png, image/jpg">
+            <div style="text-align: center;">
+                <p style="font-size: 2.5rem; margin-bottom: 5px;">📷</p>
+                <p style="color:#a1a1aa; font-weight: 500;">Tap or Drag & Drop Vehicle Image</p>
+            </div>
+        </div>
+        
+        <div class="settings-card">
+            <h3 style="font-size: 1.1rem; margin-bottom: 5px;">⚙️ Analysis Settings</h3>
+            <p style="font-size: 0.85rem; color: var(--text-secondary);">Select the neural network pipeline.</p>
+            <select id="engineMode">
+                <option value="fusion">Fusion</option>
+                <option value="resnet">ResNet</option>
+            </select>
+        </div>
+    </div>
+
+    <div class="image-area" id="previewBox">
+        <img id="displayImage" src="" alt="Car Image">
+        <div class="scan-line" id="scanLine"></div>
+        <div class="loader-overlay" id="loader">
+            <div class="spinner"></div>
+            <p style="color:white; font-weight:600; letter-spacing: 1px; margin-bottom: 5px;">🧠 ANALYZING...</p>
+            <p id="loaderStatusText" style="color:#00c6ff; font-size:0.9rem;">Extracting features...</p>
+        </div>
+    </div>
+
+    <button class="btn" id="analyzeBtn" onclick="analyze()">🚀 Run AI Analysis</button>
+
+    <div class="results-section" id="resultsSection">
+        <div class="tabs">
+            <div class="tab active" onclick="switchResultTab('tab-pred')">📊 Prediction</div>
+            <div class="tab" onclick="switchResultTab('tab-attention')">👀 Attention Maps</div>
+            <div class="tab" onclick="switchResultTab('tab-yolo')">🎯 Localization</div>
+        </div>
+
+        <div id="tab-pred" class="tab-content active">
+            <div class="settings-card">
+                <div id="finalPredText" class="big-text">--</div>
+                <div style="font-weight: 600; margin-top: 5px;" id="confText">Confidence Score: 0%</div>
+                <div class="progress-wrapper">
+                    <div class="progress-fill" id="confBar"></div>
+                </div>
+                <h3 style="margin: 15px 0 5px 0; font-size: 1.1rem;">Probability Distribution</h3>
+                <div id="plotlyChart" style="width:100%; height:300px;"></div>
+            </div>
+        </div>
+
+        <div id="tab-attention" class="tab-content">
+            <div class="img-grid">
+                <div class="img-card">
+                    <div style="font-weight:600; color:#e2e8f0;">Original Image</div>
+                    <img id="camOriginal" src="" alt="Original Image">
+                </div>
+                <div class="img-card">
+                    <div id="camSelectedLabel" style="font-weight:600; color:#e2e8f0;">Selected Grad-CAM</div>
+                    <img id="camSelected" src="" alt="Selected Grad-CAM">
+                </div>
+            </div>
+        </div>
+
+        <div id="tab-yolo" class="tab-content">
+            <div class="yolo-grid">
+                <div class="settings-card">
+                    <h3 style="margin-bottom: 10px;">Bounding Boxes</h3>
+                    <img id="yoloImage" src="" alt="YOLO Output" style="width: 100%; border-radius: 8px;">
+                </div>
+                <div class="log-box">
+                    <h3 style="margin-bottom: 15px;">Detection Log</h3>
+                    <div id="yoloLogContainer">
+                        </div>
+                </div>
+            </div>
+        </div>
+    </div>
+
+</div>
+
+<script>
+    const API_URL = "http://127.0.0.1:8000";
+    let currentFile = null;
+
+    // DOM Elements
+    const fileInput = document.getElementById('fileInput');
+    const displayImage = document.getElementById('displayImage');
+    const previewBox = document.getElementById('previewBox');
+    const resultsSection = document.getElementById('resultsSection');
+    const loader = document.getElementById('loader');
+    const loaderStatusText = document.getElementById('loaderStatusText');
+    const scanLine = document.getElementById('scanLine');
+    const analyzeBtn = document.getElementById('analyzeBtn');
+
+    fileInput.addEventListener('change', e => {
+        if(e.target.files[0]) {
+            currentFile = e.target.files[0];
+            const reader = new FileReader();
+            reader.onload = x => {
+                displayImage.src = x.target.result;
+                previewBox.style.display = 'flex';
+                resultsSection.style.display = 'none'; // Hide old results
+            };
+            reader.readAsDataURL(currentFile);
+        }
+    });
+
+    // --- BUG FIX IS HERE ---
+    function switchResultTab(tabId) {
+        // 1. Remove active state from all tabs and panels
+        document.querySelectorAll('.tab').forEach(t => t.classList.remove('active'));
+        document.querySelectorAll('.tab-content').forEach(c => c.classList.remove('active'));
+        
+        // 2. Find the tab button that corresponds to this panel and make it active
+        const tabButton = document.querySelector(`.tab[onclick*="${tabId}"]`);
+        if(tabButton) {
+            tabButton.classList.add('active');
+        }
+
+        // 3. Make the specific panel active
+        document.getElementById(tabId).classList.add('active');
+
+        // 4. Resize Plotly chart if switching back to its tab to prevent layout squash
+        if(tabId === 'tab-pred') {
+            window.dispatchEvent(new Event('resize'));
+        }
+    }
+
+    // Plotly Chart Helper
+    function drawChart(dataObj, title) {
+        const labels = Object.keys(dataObj);
+        const values = Object.values(dataObj);
+
+        const trace = {
+            x: labels,
+            y: values,
+            type: 'bar',
+            marker: { color: '#00c6ff', line: { color: '#0072ff', width: 1.5 } },
+            opacity: 0.85
+        };
+
+        const layout = {
+            title: title || '',
+            paper_bgcolor: 'rgba(0,0,0,0)',
+            plot_bgcolor: 'rgba(0,0,0,0)',
+            font: { family: 'Inter', color: '#a1a1aa' },
+            margin: { l: 40, r: 10, t: 30, b: 40 },
+            xaxis: { title: 'Classes' },
+            yaxis: { title: 'Probability', range: [0, 1] }
+        };
+
+        Plotly.newPlot('plotlyChart', [trace], layout, {displayModeBar: false, responsive: true});
+    }
+
+    async function analyze() {
+        if(!currentFile) return alert("Please upload an image first.");
+        
+        const engineMode = document.getElementById('engineMode').value; // fusion or resnet
+
+        // UI Prep
+        loader.style.display = 'flex';
+        scanLine.style.display = 'block';
+        analyzeBtn.disabled = true;
+        analyzeBtn.innerText = "Processing...";
+        resultsSection.style.display = 'none';
+
+        const formData = new FormData();
+        formData.append('image', currentFile);
+
+        try {
+            loaderStatusText.innerText = "Extracting features...";
+            const predRes = await fetch(`${API_URL}/predict/${engineMode}`, { method: 'POST', body: formData });
+            if (!predRes.ok) throw new Error("Prediction API failed");
+            const predData = await predRes.json();
+
+            loaderStatusText.innerText = "Generating Grad-CAM...";
+            const camForm = new FormData();
+            camForm.append('file', currentFile);
+            const camRes = await fetch(`${API_URL}/predict?mode=${engineMode}`, { method: 'POST', body: camForm });
+            if (!camRes.ok) throw new Error("Grad-CAM API failed");
+            const camData = await camRes.json();
+
+            loaderStatusText.innerText = "Running YOLO detection...";
+            const yoloRes = await fetch(`${API_URL}/predict/yolo`, { method: 'POST', body: camForm });
+            if (!yoloRes.ok) throw new Error("YOLO API failed");
+            const yoloData = await yoloRes.json();
+
+            const highestClass = Object.keys(predData).reduce((a, b) => predData[a] > predData[b] ? a : b);
+            const highestScore = predData[highestClass] || 0;
+            document.getElementById('finalPredText').innerText = highestClass;
+            document.getElementById('confText').innerText = `Confidence Score: ${(highestScore * 100).toFixed(2)}%`;
+            drawChart(predData, `${engineMode.toUpperCase()} Output`);
+            setTimeout(() => { document.getElementById('confBar').style.width = `${(highestScore * 100).toFixed(2)}%`; }, 100);
+
+            document.getElementById('camOriginal').src = `${API_URL}${camData.original_image}`;
+            document.getElementById('camSelected').src = `${API_URL}${camData.selected_viz}`;
+            document.getElementById('camSelectedLabel').innerText = engineMode === 'fusion' ? 'Fusion Grad-CAM' : 'ResNet Grad-CAM';
+
+            document.getElementById('yoloImage').src = `${API_URL}${yoloData.yolo_image}`;
+            const logContainer = document.getElementById('yoloLogContainer');
+            if (!yoloData.detections || yoloData.detections.length === 0) {
+                logContainer.innerHTML = '<div style="color: #a1a1aa; padding: 10px;">🟢 No damage boxes detected.</div>';
+            } else {
+                let logHTML = `<div style="color: #ffcc00; margin-bottom: 10px; font-weight:600;">🔴 Found ${yoloData.total_detections} damage region(s).</div>`;
+                yoloData.detections.forEach((det, idx) => {
+                    logHTML += `<div class="detection-item"><b style="color: #e2e8f0;">Region ${idx + 1}</b><br><span style="color: #a1a1aa; font-size: 0.9em;">${det.label} · ${(det.confidence * 100).toFixed(1)}%</span></div>`;
+                });
+                logContainer.innerHTML = logHTML;
+            }
+
+            resultsSection.style.display = 'block';
+            switchResultTab('tab-pred');
+        } catch (error) {
+            alert(`Error connecting to AI server. Details: ${error.message}`);
+            console.error(error);
+        } finally {
+            loader.style.display = 'none';
+            scanLine.style.display = 'none';
+            analyzeBtn.disabled = false;
+            analyzeBtn.innerText = "🚀 Run AI Analysis";
+        }
+    }
+</script>
+
+</body>
+</html>

requirements.txt

@@ -0,0 +1,12 @@
+torch
+torchvision
+transformers
+fastapi
+uvicorn
+dotenv
+matplotlib
+opencv-python
+python-multipart
+ultralytics
+plotly
+pandas

scripts/gradcam.py

@@ -0,0 +1,100 @@
+import cv2
+import numpy as np
+from PIL import Image
+import torch
+import torch.nn.functional as F
+
+def get_resnet_gradcam(image_path, predictor, output_path):
+    model = predictor.model
+    device = predictor.device
+    model.eval()
+    features, gradients = [], []
+
+    def forward_hook(module, input, output):
+        features.append(output)
+    def backward_hook(module, grad_in, grad_out):
+        gradients.append(grad_out[0])
+
+    target_layer = model.model.layer4[-1]
+    handle_fw = target_layer.register_forward_hook(forward_hook)
+    handle_bw = target_layer.register_full_backward_hook(backward_hook)
+
+    original_img = Image.open(image_path).convert("RGB")
+    input_tensor = predictor.test_transforms(original_img).unsqueeze(0).to(device)
+    model.zero_grad()
+    output = model(input_tensor)
+    pred_class_idx = output.argmax(dim=1).item()
+    score = output[0, pred_class_idx]
+    score.backward()
+
+    handle_fw.remove()
+    handle_bw.remove()
+
+    acts = features[0].cpu().data.numpy()[0]
+    grads = gradients[0].cpu().data.numpy()[0]
+    weights = np.mean(grads, axis=(1, 2))
+    cam = np.zeros(acts.shape[1:], dtype=np.float32)
+    for i, w in enumerate(weights):
+        cam += w * acts[i]
+
+    cam = np.maximum(cam, 0)
+    cam = cv2.resize(cam, (original_img.width, original_img.height))
+    cam = (cam - np.min(cam)) / (np.max(cam) - np.min(cam) + 1e-8)
+    heatmap = cv2.applyColorMap(np.uint8(255 * cam), cv2.COLORMAP_JET)
+    original_np = np.array(original_img)
+    overlay = cv2.addWeighted(cv2.cvtColor(original_np, cv2.COLOR_RGB2BGR), 0.6, heatmap, 0.4, 0)
+    cv2.imwrite(output_path, overlay)
+    return True
+
+def get_fusion_gradcam(image_path, predictor, output_path):
+    model = predictor.model
+    device = predictor.device
+    model.eval()
+    target_layer = model.eff_features[-1]
+    activation = None
+
+    def forward_hook(module, inp, out):
+        nonlocal activation
+        activation = out
+        activation.retain_grad()
+
+    handle = target_layer.register_forward_hook(forward_hook)
+    original_img = Image.open(image_path).convert("RGB")
+    pixel_eff = predictor.eff_normalize(original_img).unsqueeze(0).to(device)
+    inputs_cnx = predictor.convnext_processor(images=original_img, return_tensors="pt")
+    pixel_cnx = inputs_cnx["pixel_values"].to(device)
+
+    if next(model.parameters()).dtype == torch.float16:
+        pixel_eff = pixel_eff.half()
+        pixel_cnx = pixel_cnx.half()
+
+    model.zero_grad()
+    output = model(pixel_eff, pixel_cnx)
+    pred_class_idx = output.argmax(dim=1).item()
+    score = output[0, pred_class_idx]
+    score.backward()
+    handle.remove()
+
+    if activation is None or activation.grad is None:
+        raise RuntimeError("Gradients could not be extracted. Ensure requires_grad=True is properly set.")
+
+    acts = activation[0].detach().float()
+    grads = activation.grad[0].detach().float()
+    weights = grads.mean(dim=(1, 2), keepdim=True)
+    cam = torch.sum(weights * acts, dim=0)
+    cam = F.relu(cam)
+    cam = cam.cpu().numpy()
+
+    if cam.max() > cam.min():
+        cam = (cam - cam.min()) / (cam.max() - cam.min())
+    else:
+        cam = np.zeros_like(cam)
+
+    cam = np.uint8(255 * cam)
+    cam_resized = cv2.resize(cam, (original_img.width, original_img.height), interpolation=cv2.INTER_LINEAR)
+    heatmap = cv2.applyColorMap(cam_resized, cv2.COLORMAP_JET)
+    original_np = np.array(original_img)
+    original_bgr = cv2.cvtColor(original_np, cv2.COLOR_RGB2BGR)
+    overlay = cv2.addWeighted(original_bgr, 0.5, heatmap, 0.6, 0)
+    cv2.imwrite(output_path, overlay)
+    return True

scripts/model_loader.py

@@ -0,0 +1,38 @@
+import os
+from pathlib import Path
+from .prediction_helper import ResnetCarDamagePredictor, FusionCarDamagePredictor
+
+CHECKPOINT_DIR = Path(__file__).resolve().parents[1] / "checkpoints"
+MODEL_FILES = {
+    "resnet": "best_resnet_model.pt",
+    "fusion": "best_fusion_model_fp16.pth",
+    "yolo": "damage_detector.pt",
+}
+
+
+def get_checkpoint_path(model_key: str) -> Path:
+    if model_key not in MODEL_FILES:
+        raise ValueError(f"Unknown model key: {model_key}")
+
+    path = CHECKPOINT_DIR / MODEL_FILES[model_key]
+    if not path.exists():
+        raise FileNotFoundError(f"Checkpoint not found: {path}")
+    return path
+
+
+class ModelLoader:
+    def __init__(self):
+        self.base_dir = CHECKPOINT_DIR
+
+    def get_model_path(self, model_key: str) -> Path:
+        return get_checkpoint_path(model_key)
+
+
+def initialize_models(class_map):
+    resnet_path = get_checkpoint_path("resnet")
+    fusion_path = get_checkpoint_path("fusion")
+
+    resnet_predictor = ResnetCarDamagePredictor(resnet_path, class_map)
+    fusion_predictor = FusionCarDamagePredictor(fusion_path, class_map)
+
+    return resnet_predictor, fusion_predictor

scripts/prediction_helper.py

@@ -0,0 +1,175 @@
+import os
+import torch
+import torch.nn as nn
+from torchvision import transforms, models
+from PIL import Image, UnidentifiedImageError
+from transformers import ConvNextModel, ConvNextImageProcessor
+
+class Car_Classifier_Resnet(nn.Module):
+    def __init__(self, num_classes):
+        super().__init__()
+        self.model = models.resnet18(weights="DEFAULT")
+        for param in self.model.parameters():
+            param.requires_grad = False
+        for param in self.model.layer3.parameters():
+            param.requires_grad = True
+        for param in self.model.layer4.parameters():
+            param.requires_grad = True
+        self.model.fc = nn.Sequential(
+            nn.Dropout(0.5),
+            nn.Linear(self.model.fc.in_features, 256),
+            nn.ReLU(),
+            nn.Dropout(0.3),
+            nn.Linear(256, num_classes)
+        )
+
+    def forward(self, x):
+        return self.model(x)
+
+class ResnetCarDamagePredictor:
+    def __init__(self, checkpoint_path, class_map):
+        self.device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+        self.class_map = class_map
+        self.test_transforms = transforms.Compose([
+            transforms.Resize((128, 128)),
+            transforms.ToTensor(),
+            transforms.Normalize([0.485, 0.456, 0.406],
+                                 [0.229, 0.224, 0.225])
+        ])
+        try:
+            self.model = Car_Classifier_Resnet(num_classes=len(class_map))
+            checkpoint = torch.load(checkpoint_path, map_location=self.device)
+            state_dict = checkpoint.get("model_state_dict", checkpoint)
+            self.model.load_state_dict(state_dict)
+            self.model.to(self.device)
+            self.model.eval()
+        except Exception as e:
+            raise RuntimeError(f"Failed to load ResNet model: {str(e)}")
+
+    def resnet_predict(self, image_input):
+        try:
+            if isinstance(image_input, str):
+                image = Image.open(image_input).convert("RGB")
+            elif isinstance(image_input, Image.Image):
+                image = image_input.convert("RGB")
+            else:
+                raise TypeError("image_input must be a file path or PIL.Image")
+            image = self.test_transforms(image)
+            image = image.unsqueeze(0).to(self.device)
+            with torch.no_grad():
+                outputs = self.model(image)
+            probs = torch.nn.functional.softmax(outputs, dim=1)[0]
+            class_probs = {
+                self.class_map[i]: float(probs[i].item())
+                for i in range(len(self.class_map))
+            }
+            return dict(sorted(class_probs.items(), key=lambda x: x[1], reverse=True))
+        except UnidentifiedImageError:
+            raise ValueError("Invalid image file provided")
+        except Exception as e:
+            raise RuntimeError(f"ResNet prediction failed: {str(e)}")
+
+class FusionClassifier(nn.Module):
+    def __init__(self, num_classes, convnext_model_name="facebook/convnext-small-224"):
+        super().__init__()
+        eff = models.efficientnet_v2_s(weights=models.EfficientNet_V2_S_Weights.IMAGENET1K_V1)
+        for param in eff.parameters():
+            param.requires_grad = False
+        for param in eff.features[5].parameters():
+            param.requires_grad = True
+        for param in eff.features[6].parameters():
+            param.requires_grad = True
+        for param in eff.features[7].parameters():
+            param.requires_grad = True
+        self.eff_features = eff.features
+        self.eff_avgpool = eff.avgpool
+        self.eff_out_dim = eff.classifier[1].in_features
+        cnx = ConvNextModel.from_pretrained(convnext_model_name)
+        for param in cnx.parameters():
+            param.requires_grad = False
+        for param in cnx.encoder.stages[2].parameters():
+            param.requires_grad = True
+        for param in cnx.encoder.stages[3].parameters():
+            param.requires_grad = True
+        for param in cnx.layernorm.parameters():
+            param.requires_grad = True
+        self.cnx_backbone = cnx
+        self.cnx_out_dim = 768
+        fused_dim = self.eff_out_dim + self.cnx_out_dim
+        self.fusion_head = nn.Sequential(
+            nn.Dropout(p=0.4),
+            nn.Linear(fused_dim, 512),
+            nn.LayerNorm(512),
+            nn.GELU(),
+            nn.Dropout(p=0.3),
+            nn.Linear(512, 256),
+            nn.LayerNorm(256),
+            nn.GELU(),
+            nn.Dropout(p=0.2),
+            nn.Linear(256, num_classes)
+        )
+
+    def forward(self, pixel_values_eff, pixel_values_cnx):
+        x_eff = self.eff_features(pixel_values_eff)
+        x_eff = self.eff_avgpool(x_eff)
+        x_eff = torch.flatten(x_eff, 1)
+        cnx_out = self.cnx_backbone(pixel_values=pixel_values_cnx, return_dict=True)
+        x_cnx = cnx_out.pooler_output
+        fused = torch.cat([x_eff, x_cnx], dim=1)
+        return self.fusion_head(fused)
+
+class FusionCarDamagePredictor:
+    def __init__(self, checkpoint_path, class_map, convnext_model_name="facebook/convnext-small-224"):
+        self.device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+        self.class_map = class_map
+        self.eff_normalize = transforms.Compose([
+            transforms.Resize((260, 260)),
+            transforms.ToTensor(),
+            transforms.Normalize([0.485, 0.456, 0.406],
+                                 [0.229, 0.224, 0.225])
+        ])
+        self.convnext_processor = ConvNextImageProcessor.from_pretrained(convnext_model_name)
+        try:
+            self.model = FusionClassifier(
+                num_classes=len(class_map),
+                convnext_model_name=convnext_model_name
+            )
+            checkpoint = torch.load(checkpoint_path, map_location=self.device)
+            state_dict = checkpoint.get("model_state_dict", checkpoint)
+            first_tensor = next(iter(state_dict.values()))
+            if first_tensor.dtype == torch.float16:
+                self.model = self.model.half()
+            self.model.load_state_dict(state_dict)
+            self.model.to(self.device)
+            self.model.eval()
+        except Exception as e:
+            raise RuntimeError(f"Failed to load Fusion model: {str(e)}")
+
+    def predict(self, image_input):
+        try:
+            if isinstance(image_input, str):
+                image = Image.open(image_input).convert("RGB")
+            elif isinstance(image_input, Image.Image):
+                image = image_input.convert("RGB")
+            else:
+                raise TypeError("image_input must be a file path or PIL.Image")
+            pixel_eff = self.eff_normalize(image)
+            pixel_eff = pixel_eff.unsqueeze(0).to(self.device)
+            inputs_cnx = self.convnext_processor(images=image, return_tensors="pt")
+            pixel_cnx = inputs_cnx["pixel_values"].to(self.device)
+            if next(self.model.parameters()).dtype == torch.float16:
+                pixel_eff = pixel_eff.half()
+                pixel_cnx = pixel_cnx.half()
+            with torch.no_grad():
+                logits = self.model(pixel_eff, pixel_cnx)
+                probs = torch.nn.functional.softmax(logits, dim=1)[0]
+            class_probs = {
+                self.class_map[i]: float(probs[i].item())
+                for i in range(len(self.class_map))
+            }
+            return dict(sorted(class_probs.items(), key=lambda x: x[1], reverse=True))
+        except UnidentifiedImageError:
+            raise ValueError("Invalid image file provided")
+        except Exception as e:
+            raise RuntimeError(f"Fusion prediction failed: {str(e)}")
+    

scripts/yolo.py

@@ -0,0 +1,57 @@
+import cv2
+import numpy as np
+from PIL import Image
+from ultralytics import YOLO
+from scripts.model_loader import ModelLoader
+
+yolo_model = None
+
+def get_yolo_model():
+    global yolo_model
+    if yolo_model is None:
+        loader = ModelLoader()
+        yolo_path = loader.get_model_path("yolo")
+        yolo_model = YOLO(str(yolo_path))
+    return yolo_model
+
+
+def get_yolo_damage_boxes(image_path, output_path):
+    try:
+        image = Image.open(image_path).convert("RGB")
+        model = get_yolo_model()
+        results = model.predict(
+            source=image,
+            conf=0.05,
+            imgsz=640,
+            verbose=False
+        )
+
+        result = results[0]
+        boxes = result.boxes
+        detections = []
+
+        if boxes is not None and len(boxes) > 0:
+            for box in boxes:
+                conf = float(box.conf[0])
+                cls_id = int(box.cls[0])
+                label = yolo_model.names[cls_id]
+                x1, y1, x2, y2 = map(int, box.xyxy[0])
+
+                detections.append({
+                    "label": label,
+                    "confidence": round(conf, 4),
+                    "box": [x1, y1, x2, y2]
+                })
+
+        plotted_bgr = result.plot()
+        plotted_rgb = plotted_bgr[..., ::-1]
+        cv2.imwrite(output_path, plotted_rgb)
+
+        return {
+            "detections": detections,
+            "total_detections": len(detections),
+            "message": "No damage detected" if len(detections) == 0 else "Detections found"
+        }
+
+    except Exception as e:
+        raise RuntimeError(f"YOLO failed: {str(e)}")