Upload 3 files

car_core/README.md

@@ -0,0 +1,38 @@
+
+# Car Damage Inspector (Hugging Face-ready)
+
+An open-source, one-file Gradio app that:
+1) Classifies car damage type with a transformer classifier.
+2) Detects damage regions & severity (Light/Moderate/Severe) with YOLOv8.
+
+**Models used**
+- `beingamit99/car_damage_detection` (image classification)
+- `nezahatkorkmaz/car-damage-level-detection-yolov8` (YOLOv8 detector)
+
+## Quickstart (local)
+
+```bash
+python -m venv .venv && source .venv/bin/activate  # Windows: .venv\Scripts\activate
+pip install -r requirements.txt
+python app.py
+```
+
+Open the Gradio link shown in the terminal and upload a car photo.
+
+## Deploy to Hugging Face Spaces
+
+1. Create a new **Space** (Python).  
+2. Upload these three files:
+   - `app.py`
+   - `requirements.txt`
+   - `README.md`
+3. The Space will auto-build, download models on first run, and serve the UI.
+
+## Notes
+- First inference will download model weights; allow a little time.
+- Gate logic is heuristic: if the top classification score < 0.5 (or model predicts an explicit *no-damage* class), the app returns "No visible damage".
+- Replace/extend with your own gate (e.g., a dedicated binary model) if desired.
+- Outputs:
+  - **JSON** with top-3 labels and YOLO detections,
+  - **Overlay image** with bounding boxes,
+  - **Raw YOLO JSON** (for debugging/integration).

car_core/app.py

@@ -0,0 +1,95 @@
+
+import gradio as gr
+from PIL import Image
+from typing import Tuple, Any, Dict, List
+
+# Lazy imports to speed cold start
+clf = None
+yolo_severity = None
+
+def _load_models():
+    global clf, yolo_severity
+    if clf is None:
+        from transformers import pipeline
+        # Image classification (damage types)
+        clf = pipeline("image-classification", model="beingamit99/car_damage_detection")
+    if yolo_severity is None:
+        from ultralytics import YOLO
+        # YOLOv8 severity detector (Light/Moderate/Severe)
+        yolo_severity = YOLO("nezahatkorkmaz/car-damage-level-detection-yolov8")
+
+def analyze(img: Image.Image) -> Tuple[Dict[str, Any], Image.Image, Any]:
+    """
+    Returns:
+      - JSON summary (gate + top labels + detections)
+      - Overlay image with boxes
+      - Raw YOLO JSON (string or dict)
+    """
+    _load_models()
+
+    # --- Gate using classifier ---
+    # If model has a 'no_damage' label use it; otherwise treat max score < 0.5 as "no damage"
+    preds = sorted(clf(img), key=lambda x: x["score"], reverse=True)
+    top = preds[0] if preds else {"label": "unknown", "score": 0.0}
+    label_lower = top["label"].lower()
+    if "no" in label_lower and "damage" in label_lower:
+        gate = False
+    else:
+        gate = top["score"] >= 0.5
+
+    if not gate:
+        return {"gate": "No visible damage", "classification_top": top}, img, {"detections": []}
+
+    # --- Top-3 labels for type ---
+    top3 = [{"label": p["label"], "score": float(p["score"])} for p in preds[:3]]
+
+    # --- YOLO severity boxes ---
+    yres = yolo_severity.predict(img)
+    result = yres[0]
+    plotted = result.plot()  # numpy array with drawn boxes
+
+    dets = []
+    if result.boxes is not None and len(result.boxes) > 0:
+        # class names if available
+        names = result.names if hasattr(result, "names") else {}
+        for i in range(len(result.boxes)):
+            b = result.boxes[i]
+            xyxy = b.xyxy[0].tolist()
+            conf = float(b.conf[0].item())
+            cls_id = int(b.cls[0].item())
+            cls_name = names.get(cls_id, str(cls_id))
+            dets.append({
+                "bbox_xyxy": [float(x) for x in xyxy],
+                "confidence": conf,
+                "class_id": cls_id,
+                "class_name": cls_name
+            })
+
+    summary = {"gate": "Damaged", "classification_top3": top3, "detections": dets}
+    try:
+        raw_json = result.tojson()  # string
+    except Exception:
+        raw_json = {"error": "tojson failed"}
+
+    from PIL import Image as _Image
+    return summary, _Image.fromarray(plotted), raw_json
+
+demo = gr.Interface(
+    fn=analyze,
+    inputs=gr.Image(type="pil", label="Upload a car photo"),
+    outputs=[
+        gr.JSON(label="Results (gate + top labels + detections)"),
+        gr.Image(label="Detections Overlay"),
+        gr.JSON(label="Raw YOLO JSON")
+    ],
+    title="Car Damage Inspector",
+    description=(
+        "Fast, open-source car damage analysis.\n"
+        "- Step 1: Classify damage type (ViT).\n"
+        "- Step 2: Detect severity with YOLOv8 (boxes).\n"
+        "Models: beingamit99/car_damage_detection, nezahatkorkmaz/car-damage-level-detection-yolov8."
+    ),
+)
+
+if __name__ == "__main__":
+    demo.launch()

car_core/requirements.txt

@@ -0,0 +1,12 @@
+
+# Core app
+gradio==4.44.0
+pillow>=10.3.0
+
+# Models
+transformers>=4.41.0
+torch>=2.1.0
+torchvision>=0.16.0
+
+# YOLO
+ultralytics>=8.3.0