Upload 4 files

furniture_matcher.py

@@ -0,0 +1,645 @@
+import os, sys, shutil
+# Set HF_HOME dynamically based on available disk space
+d_free = 0
+try:
+    d_free = shutil.disk_usage('D:/').free
+except Exception:
+    pass
+
+if d_free > 500 * 1024 * 1024:  # At least 500MB free
+    os.environ['HF_HOME'] = 'D:/hf_cache'
+else:
+    os.environ['HF_HOME'] = 'C:/hf_cache'
+
+os.environ['HF_HUB_DISABLE_SYMLINKS_WARNING'] = '1'
+if sys.stdout.encoding != 'utf-8':
+    sys.stdout.reconfigure(encoding='utf-8', errors='replace')
+if sys.stderr.encoding != 'utf-8':
+    sys.stderr.reconfigure(encoding='utf-8', errors='replace')
+"""
+Furniture Inventory Matcher — High-Precision Edition
+======================================================
+Problem: Given BEFORE/AFTER folders, report each item as:
+  ✅ FOUND   — same item detected in AFTER
+  ❌ MISSING — not found (could be moved/stolen/removed)
+
+Accuracy requirement: BOTH false-positives AND false-negatives must be minimal.
+
+Architecture (3-stage cascade):
+  Stage 1 — DINOv2 CLS global embedding  (fast, semantic)
+  Stage 2 — DINOv2 PATCH-level matching  (robust to crops/scale/partial views)
+  Stage 3 — SIFT + RANSAC geometry       (confirms spatial consistency)
+
+Why this combination?
+  • DINOv2 CLS  → understands "what" the object is (semantic identity)
+  • Patch match  → finds correspondences even if only part of object is visible
+  • SIFT/RANSAC  → geometric proof that pixel-level structure matches
+
+Invariant to: lighting, scale, rotation, partial occlusion, crop differences.
+
+Usage:
+    python furniture_matcher.py --before ./before --after ./after
+    python furniture_matcher.py --before ./before --after ./after --output ./report
+    python furniture_matcher.py --before ./before --after ./after --strict
+"""
+
+import os, sys, time, argparse, base64
+import numpy as np
+from pathlib import Path
+from PIL import Image
+
+# ── Torch / DINOv2 ──────────────────────────────────────────────────────────
+try:
+    import torch
+    from transformers import AutoImageProcessor, AutoModel
+except ImportError:
+    print("[ERROR] pip install torch transformers Pillow")
+    sys.exit(1)
+
+# ── OpenCV ───────────────────────────────────────────────────────────────────
+try:
+    import cv2
+    CV2_OK = True
+except ImportError:
+    CV2_OK = False
+    print("[WARNING] pip install opencv-python — geometric verification disabled")
+
+# ── Rich (prettier output) ───────────────────────────────────────────────────
+try:
+    from rich.console import Console
+    from rich.table import Table
+    from rich.panel import Panel
+    from rich.progress import Progress, SpinnerColumn, BarColumn, TextColumn, TaskProgressColumn
+    RICH = True
+    console = Console()
+except ImportError:
+    RICH = False
+    console = None
+
+# ═══════════════════════════════════════════════════════════════════════════
+#  CONFIGURATION
+# ═══════════════════════════════════════════════════════════════════════════
+MODEL_ID   = "facebook/dinov2-base"   # 86M params, ~330MB — excellent for furniture
+IMAGE_EXTS = {".jpg", ".jpeg", ".png", ".bmp", ".webp", ".tiff", ".tif"}
+DEVICE     = "cuda" if torch.cuda.is_available() else "cpu"
+
+# ── Score thresholds ─────────────────────────────────────────────────────────
+# Stage 1 (CLS global):
+CLS_CONFIRM_FOUND   = 0.88   # score ≥ this → FOUND immediately (very safe)
+CLS_CONFIRM_MISSING = 0.60   # score < this → MISSING immediately (very safe)
+# Between these → go to Stage 2
+
+# Stage 2 (patch-level):
+PATCH_CONFIRM_FOUND   = 0.72
+PATCH_CONFIRM_MISSING = 0.55
+# Between → go to Stage 3
+
+# Stage 3 (SIFT+RANSAC):
+MIN_GEO_INLIERS = 12
+
+# Patch matching params
+TOP_K_PATCHES  = 60     # use top-K best matching patches (ignores background)
+SIFT_FEATURES  = 2000
+LOWE_RATIO     = 0.75
+
+
+# ═══════════════════════════════════════════════════════════════════════════
+#  LOGGING
+# ═══════════════════════════════════════════════════════════════════════════
+def log(msg, style=""):
+    if RICH:
+        console.print(f"[{style}]{msg}[/{style}]" if style else msg)
+    else:
+        print(msg)
+
+
+def collect_images(folder: str) -> list[Path]:
+    p = Path(folder)
+    if not p.exists():
+        raise FileNotFoundError(f"Folder not found: {folder}")
+    imgs = sorted([f for f in p.rglob("*") if f.suffix.lower() in IMAGE_EXTS])
+    if not imgs:
+        raise ValueError(f"No images in: {folder}")
+    return imgs
+
+
+# ═══════════════════════════════════════════════════════════════════════════
+#  STAGE 1 + 2 — DINOv2 EMBEDDER
+#  Extracts BOTH CLS (global) and patch (local) embeddings
+# ═══════════════════════════════════════════════════════════════════════════
+class DinoEmbedder:
+    """
+    DINOv2-Large produces:
+      • CLS token  → 1 × 1024 vector  (global semantic identity)
+      • Patch tokens → N × 1024 matrix (local spatial features)
+
+    Patch tokens are the KEY for robustness:
+      - If an object is partially cropped, only some patches appear
+      - We match patches individually → robust to partial views
+      - DINOv2 patch features are inherently robust to lighting/scale
+    """
+
+    def __init__(self):
+        log(f"  Loading {MODEL_ID} on [{DEVICE.upper()}] ...", "dim")
+        self.proc  = AutoImageProcessor.from_pretrained(MODEL_ID)
+        self.model = AutoModel.from_pretrained(MODEL_ID).to(DEVICE).eval()
+        log("  DINOv2 model ready!", "dim green")
+
+    @torch.no_grad()
+    def embed(self, path: Path) -> dict:
+        """
+        Returns dict with:
+          'cls'    : np.ndarray (1024,)   L2-normalised global embedding
+          'patches': np.ndarray (N, 1024) L2-normalised patch embeddings
+        """
+        img    = Image.open(path).convert("RGB")
+        inputs = self.proc(images=img, return_tensors="pt").to(DEVICE)
+        out    = self.model(**inputs)
+
+        hidden = out.last_hidden_state          # (1, N+1, 1024)
+
+        # CLS token
+        cls = hidden[:, 0, :]                   # (1, 1024)
+        cls = cls / cls.norm(dim=-1, keepdim=True)
+        cls = cls.squeeze().cpu().numpy()
+
+        # Patch tokens (all except CLS)
+        patches = hidden[:, 1:, :]             # (1, N, 1024)
+        patches = patches / patches.norm(dim=-1, keepdim=True)
+        patches = patches.squeeze().cpu().numpy()   # (N, 1024)
+
+        return {"cls": cls, "patches": patches}
+
+    def embed_all(self, paths: list[Path], label: str) -> dict:
+        results = {}
+        if RICH:
+            with Progress(SpinnerColumn(), TextColumn(f"[cyan]{label}"),
+                          BarColumn(), TaskProgressColumn(), console=console) as prog:
+                task = prog.add_task("", total=len(paths))
+                for p in paths:
+                    try:    results[p] = self.embed(p)
+                    except Exception as e:
+                        console.print(f"  [red]skip {p.name}: {e}[/red]")
+                    prog.advance(task)
+        else:
+            for i, p in enumerate(paths, 1):
+                print(f"  [{i}/{len(paths)}] {p.name}")
+                try:    results[p] = self.embed(p)
+                except Exception as e:
+                    print(f"  skip: {e}")
+        return results
+
+
+# ═══════════════════════════════════════════════════════════════════════════
+#  PATCH-LEVEL SIMILARITY
+# ═══════════════════════════════════════════════════════════════════════════
+def patch_similarity(patches_a: np.ndarray, patches_b: np.ndarray) -> float:
+    """
+    For each patch in A, find its BEST matching patch in B.
+    Take the mean of the top-K matches (ignores background / non-matching patches).
+
+    This is robust because:
+      - Even if only 30% of the object is visible in one image,
+        those visible patches will still find their counterparts.
+      - Background patches will have low scores → filtered by top-K.
+
+    patches_a: (Na, D)
+    patches_b: (Nb, D)
+    Returns: float in [0, 1]
+    """
+    # Full cross-similarity matrix: (Na, Nb)
+    sim_matrix = patches_a @ patches_b.T          # all L2-normalised → cosine
+
+    # For each patch in A: best match score in B
+    max_per_patch = sim_matrix.max(axis=1)        # (Na,)
+
+    # Also for each patch in B: best match in A  (symmetric check)
+    max_per_patch_b = sim_matrix.max(axis=0)      # (Nb,)
+
+    # Combine: top-K from both directions → robust to asymmetric crops
+    all_scores = np.concatenate([max_per_patch, max_per_patch_b])
+    K = min(TOP_K_PATCHES * 2, len(all_scores))
+    top_k = np.partition(all_scores, -K)[-K:]
+
+    return float(top_k.mean())
+
+
+# ═══════════════════════════════════════════════════════════════════════════
+#  STAGE 3 — GEOMETRIC VERIFIER (SIFT + RANSAC)
+# ═══════════════════════════════════════════════════════════════════════════
+class GeoVerifier:
+    """
+    Last resort when semantic evidence is uncertain.
+    Uses classical SIFT keypoints + Lowe ratio test + RANSAC homography.
+    Returns (confirmed, inlier_count).
+    """
+
+    def __init__(self):
+        self.ok = CV2_OK
+        if self.ok:
+            self.sift    = cv2.SIFT_create(nfeatures=SIFT_FEATURES)
+            self.matcher = cv2.BFMatcher(cv2.NORM_L2, crossCheck=False)
+
+    def verify(self, a: Path, b: Path) -> tuple[bool, int]:
+        if not self.ok:
+            return False, 0
+        try:
+            ga = cv2.imread(str(a), cv2.IMREAD_GRAYSCALE)
+            gb = cv2.imread(str(b), cv2.IMREAD_GRAYSCALE)
+            if ga is None or gb is None:
+                return False, 0
+
+            kp_a, des_a = self.sift.detectAndCompute(ga, None)
+            kp_b, des_b = self.sift.detectAndCompute(gb, None)
+
+            if des_a is None or des_b is None or len(kp_a) < 6 or len(kp_b) < 6:
+                return False, 0
+
+            raw  = self.matcher.knnMatch(des_a, des_b, k=2)
+            good = [m for m, n in raw if m.distance < LOWE_RATIO * n.distance]
+
+            if len(good) < 6:
+                return False, 0
+
+            src = np.float32([kp_a[m.queryIdx].pt for m in good]).reshape(-1, 1, 2)
+            dst = np.float32([kp_b[m.trainIdx].pt for m in good]).reshape(-1, 1, 2)
+            _, mask = cv2.findHomography(src, dst, cv2.RANSAC, 5.0)
+
+            if mask is None:
+                return False, 0
+
+            inliers = int(mask.sum())
+            return inliers >= MIN_GEO_INLIERS, inliers
+
+        except Exception:
+            return False, 0
+
+
+# ═══════════════════════════════════════════════════════════════════════════
+#  RESULT
+# ═══════════════════════════════════════════════════════════════════════════
+class ItemResult:
+    def __init__(self, before_path: Path):
+        self.before_path = before_path
+        self.best_match  = None     # Path
+        self.cls_score   = 0.0
+        self.patch_score = 0.0
+        self.geo_inliers = 0
+        self.stage_used  = 0        # which stage made the decision
+        self.found       = False
+
+    @property
+    def confidence(self):
+        s = self.cls_score
+        if not self.found:             return "—"
+        if s >= 0.92:                  return "VERY HIGH"
+        if s >= 0.88:                  return "HIGH"
+        if self.patch_score >= 0.72:   return "MEDIUM (patch-verified)"
+        if self.geo_inliers >= 12:     return "MEDIUM (geo-verified)"
+        return "LOW"
+
+
+# ═══════════════════════════════════════════════════════════════════════════
+#  MAIN ENGINE
+# ═══════════════════════════════════════════════════════════════════════════
+class InventoryMatcher:
+
+    def __init__(self):
+        self.emb = DinoEmbedder()
+        self.geo = GeoVerifier()
+
+    # ── run ───────────────────────────────────────────────────────────────
+    def run(self, before_folder: str, after_folder: str) -> list[ItemResult]:
+
+        before_paths = collect_images(before_folder)
+        after_paths  = collect_images(after_folder)
+
+        if RICH:
+            console.print(Panel(
+                f"[bold]📁 Before:[/bold] {before_folder}  "
+                f"([yellow]{len(before_paths)} items[/yellow])\n"
+                f"[bold]📁 After: [/bold] {after_folder}  "
+                f"([yellow]{len(after_paths)} images[/yellow])\n"
+                f"[bold]⚙️  Stages:[/bold] DINOv2-CLS → Patch matching → SIFT+RANSAC\n"
+                f"[bold]🖥️  Device:[/bold] {DEVICE.upper()}",
+                title="[bold cyan]Furniture Inventory Matcher[/bold cyan]",
+                border_style="cyan"
+            ))
+        else:
+            print(f"\n{'='*60}")
+            print(f"Before: {before_folder} ({len(before_paths)} items)")
+            print(f"After:  {after_folder} ({len(after_paths)} images)")
+            print(f"Stages: DINOv2-CLS → Patch → SIFT+RANSAC")
+            print(f"Device: {DEVICE.upper()}\n{'='*60}\n")
+
+        # ── Embed all ──────────────────────────────────────────────────────
+        log("\n[Step 1/3] Embedding BEFORE folder …")
+        before_embs = self.emb.embed_all(before_paths, "BEFORE ")
+
+        log("\n[Step 2/3] Embedding AFTER folder …")
+        after_embs  = self.emb.embed_all(after_paths, "AFTER  ")
+
+        # ── Pre-compute CLS similarity matrix ─────────────────────────────
+        log("\n[Step 3/3] Matching items …")
+        before_list = list(before_embs.keys())
+        after_list  = list(after_embs.keys())
+
+        B_cls = np.stack([before_embs[p]["cls"] for p in before_list])  # (B, D)
+        A_cls = np.stack([after_embs[p]["cls"]  for p in after_list])   # (A, D)
+        cls_sim = B_cls @ A_cls.T                                        # (B, A)
+
+        results = []
+
+        for b_idx, b_path in enumerate(before_list):
+            item = ItemResult(b_path)
+            row  = cls_sim[b_idx]           # CLS similarities to all after images
+
+            # ── Find best candidate in AFTER ──────────────────────────────
+            best_a_idx  = int(np.argmax(row))
+            best_score  = float(row[best_a_idx])
+            best_a_path = after_list[best_a_idx]
+
+            item.cls_score  = best_score
+            item.best_match = best_a_path
+
+            # ══════════════════════════════════════════════════════════════
+            #  STAGE 1: CLS global score
+            # ══════════════════════════════════════════════════════════════
+            if best_score >= CLS_CONFIRM_FOUND:
+                item.found    = True
+                item.stage_used = 1
+
+            elif best_score < CLS_CONFIRM_MISSING:
+                item.found    = False
+                item.stage_used = 1
+
+            else:
+                # ══════════════════════════════════════════════════════════
+                #  STAGE 2: PATCH-level matching
+                #  Uncertain zone → look at individual patch correspondences
+                # ══════════════════════════════════════════════════════════
+                patches_b = before_embs[b_path]["patches"]
+                patches_a = after_embs[best_a_path]["patches"]
+                p_score   = patch_similarity(patches_b, patches_a)
+                item.patch_score = p_score
+                item.stage_used  = 2
+
+                if p_score >= PATCH_CONFIRM_FOUND:
+                    item.found = True
+
+                elif p_score < PATCH_CONFIRM_MISSING:
+                    item.found = False
+
+                else:
+                    # ══════════════════════════════════════════════════════
+                    #  STAGE 3: GEOMETRIC verification (SIFT + RANSAC)
+                    #  Last resort — pixel-level structural proof
+                    # ══════════════════════════════════════════════════════
+                    confirmed, inliers = self.geo.verify(b_path, best_a_path)
+                    item.geo_inliers = inliers
+                    item.found       = confirmed
+                    item.stage_used  = 3
+
+            results.append(item)
+
+        return results
+
+    # ── Console report ─────────────────────────────────────────────────────
+    def print_report(self, results: list[ItemResult]):
+        found   = [r for r in results if r.found]
+        missing = [r for r in results if not r.found]
+
+        if RICH:
+            console.print(Panel(
+                f"[bold green]✅ FOUND:   {len(found)} / {len(results)}[/bold green]\n"
+                f"[bold red]❌ MISSING: {len(missing)} / {len(results)}[/bold red]",
+                title="[bold]📋 Inventory Report[/bold]", border_style="magenta"
+            ))
+
+            if found:
+                t = Table(title="[green]✅ FOUND[/green]",
+                          border_style="green", header_style="bold")
+                t.add_column("Before",    style="cyan",   no_wrap=True)
+                t.add_column("After",     style="yellow", no_wrap=True)
+                t.add_column("CLS",       width=6)
+                t.add_column("Patch",     width=6)
+                t.add_column("Geo",       width=5)
+                t.add_column("Stage",     width=5)
+                t.add_column("Confidence",width=22)
+                for r in found:
+                    ps  = f"{r.patch_score:.3f}" if r.patch_score else "—"
+                    geo = str(r.geo_inliers)      if r.geo_inliers else "—"
+                    t.add_row(r.before_path.name, r.best_match.name,
+                              f"{r.cls_score:.3f}", ps, geo,
+                              str(r.stage_used), r.confidence)
+                console.print(t)
+
+            if missing:
+                t = Table(title="[red]❌ MISSING[/red]",
+                          border_style="red", header_style="bold")
+                t.add_column("Before",     style="cyan",  no_wrap=True)
+                t.add_column("Best CLS",   width=8)
+                t.add_column("Best Patch", width=9)
+                t.add_column("Closest In", style="dim",   no_wrap=True)
+                for r in missing:
+                    ps = f"{r.patch_score:.3f}" if r.patch_score else "—"
+                    nm = r.best_match.name if r.best_match else "—"
+                    t.add_row(r.before_path.name, f"{r.cls_score:.3f}", ps, nm)
+                console.print(t)
+        else:
+            print(f"\nFOUND:   {len(found)}/{len(results)}")
+            print(f"MISSING: {len(missing)}/{len(results)}")
+            if found:
+                print("\n✅ FOUND:")
+                for r in found:
+                    print(f"  {r.before_path.name:<35} → {r.best_match.name} "
+                          f"(cls:{r.cls_score:.3f} patch:{r.patch_score:.3f})")
+            if missing:
+                print("\n❌ MISSING:")
+                for r in missing:
+                    print(f"  {r.before_path.name:<35}  best cls:{r.cls_score:.3f}")
+
+    # ── HTML report ────────────────────────────────────────────────────────
+    def save_html(self, results: list[ItemResult], out_dir: str) -> str:
+        out = Path(out_dir)
+        out.mkdir(parents=True, exist_ok=True)
+
+        def b64img(path: Path):
+            try:
+                data = base64.b64encode(path.read_bytes()).decode()
+                ext  = path.suffix.lstrip(".") or "jpeg"
+                return f"data:image/{ext};base64,{data}"
+            except Exception:
+                return ""
+
+        cards = ""
+        for r in results:
+            is_found    = r.found
+            color       = "#16a34a" if is_found else "#dc2626"
+            bg_color    = "#0f2d1a" if is_found else "#2d0f0f"
+            border_c    = "#22c55e" if is_found else "#ef4444"
+            icon        = "✅" if is_found else "❌"
+            label       = "FOUND" if is_found else "MISSING"
+
+            before_src  = b64img(r.before_path)
+            after_html  = ""
+            if r.best_match:
+                after_src  = b64img(r.best_match)
+                after_name = r.best_match.name
+                after_html = f"""
+                <div class="arrow">→</div>
+                <div class="img-box">
+                    <div class="box-label">Best match · AFTER</div>
+                    <img src="{after_src}" alt="{after_name}"/>
+                    <div class="fname">{after_name}</div>
+                </div>"""
+
+            stage_labels = {1: "CLS only", 2: "Patch match", 3: "SIFT+RANSAC"}
+            stage_str    = stage_labels.get(r.stage_used, "")
+
+            scores_html = f"""
+            <div class="scores">
+              <span>CLS: <b>{r.cls_score:.3f}</b></span>
+              {'<span>Patch: <b>' + f'{r.patch_score:.3f}' + '</b></span>' if r.patch_score else ''}
+              {'<span>Geo inliers: <b>' + str(r.geo_inliers) + '</b></span>' if r.geo_inliers else ''}
+              <span>Decision: <b>{stage_str}</b></span>
+              {'<span>Confidence: <b>' + r.confidence + '</b></span>' if is_found else ''}
+            </div>"""
+
+            cards += f"""
+            <div class="card" style="background:{bg_color};border-color:{border_c}">
+                <div class="badge" style="background:{color}">{icon} {label}</div>
+                <div class="img-row">
+                    <div class="img-box">
+                        <div class="box-label">BEFORE</div>
+                        <img src="{before_src}" alt="{r.before_path.name}"/>
+                        <div class="fname">{r.before_path.name}</div>
+                    </div>
+                    {after_html}
+                </div>
+                {scores_html}
+            </div>"""
+
+        n_found   = sum(1 for r in results if r.found)
+        n_missing = len(results) - n_found
+
+        html = f"""<!DOCTYPE html>
+<html lang="en">
+<head>
+<meta charset="UTF-8">
+<meta name="viewport" content="width=device-width, initial-scale=1.0">
+<title>Furniture Inventory Report</title>
+<style>
+  *{{box-sizing:border-box;margin:0;padding:0;}}
+  body{{font-family:'Segoe UI',sans-serif;background:#0a0f1e;color:#e2e8f0;padding:2rem;}}
+  h1{{text-align:center;font-size:2rem;margin-bottom:.3rem;
+      background:linear-gradient(135deg,#38bdf8,#818cf8);
+      -webkit-background-clip:text;-webkit-text-fill-color:transparent;}}
+  .sub{{text-align:center;color:#64748b;font-size:.85rem;margin-bottom:1.5rem;}}
+
+  .summary{{display:flex;justify-content:center;gap:1.5rem;margin:1.5rem 0;flex-wrap:wrap;}}
+  .stat{{background:#1e293b;border-radius:14px;padding:.8rem 2rem;
+         text-align:center;border:1px solid #334155;}}
+  .stat .num{{font-size:2.2rem;font-weight:800;}}
+  .stat .lbl{{font-size:.8rem;color:#94a3b8;margin-top:.1rem;}}
+
+  .filters{{text-align:center;margin-bottom:1.5rem;}}
+  .fbtn{{background:#1e293b;border:1px solid #334155;color:#e2e8f0;
+          padding:.35rem 1.1rem;border-radius:999px;cursor:pointer;
+          margin:0 .25rem;font-size:.8rem;transition:.15s;}}
+  .fbtn:hover,.fbtn.active{{background:#38bdf8;color:#0a0f1e;border-color:#38bdf8;}}
+
+  .card{{border-radius:16px;padding:1.4rem;margin-bottom:1.4rem;
+         border:1px solid;box-shadow:0 4px 20px rgba(0,0,0,.5);}}
+  .badge{{display:inline-block;padding:.25rem .9rem;border-radius:999px;
+           font-weight:700;color:#fff;font-size:.82rem;margin-bottom:1rem;}}
+  .img-row{{display:flex;align-items:center;gap:1.2rem;flex-wrap:wrap;}}
+  .img-box{{flex:1;min-width:160px;text-align:center;}}
+  .img-box img{{max-width:100%;max-height:250px;border-radius:10px;
+                object-fit:contain;border:2px solid #334155;}}
+  .box-label{{font-size:.65rem;color:#94a3b8;text-transform:uppercase;
+               letter-spacing:.08em;margin-bottom:.3rem;}}
+  .fname{{font-size:.72rem;color:#475569;margin-top:.3rem;word-break:break-all;}}
+  .arrow{{font-size:2rem;color:#38bdf8;font-weight:bold;flex-shrink:0;}}
+  .scores{{display:flex;flex-wrap:wrap;gap:.6rem;margin-top:.9rem;}}
+  .scores span{{background:#0f172a;padding:.2rem .6rem;border-radius:6px;
+                font-size:.75rem;color:#94a3b8;}}
+  .scores b{{color:#e2e8f0;}}
+</style>
+</head>
+<body>
+<h1>🛋️ Furniture Inventory Report</h1>
+<p class="sub">DINOv2-Large · Patch Matching · SIFT+RANSAC · {len(results)} items</p>
+
+<div class="summary">
+  <div class="stat"><div class="num" style="color:#22c55e">{n_found}</div>
+    <div class="lbl">✅ FOUND</div></div>
+  <div class="stat"><div class="num" style="color:#ef4444">{n_missing}</div>
+    <div class="lbl">❌ MISSING</div></div>
+  <div class="stat"><div class="num" style="color:#94a3b8">{len(results)}</div>
+    <div class="lbl">Total Items</div></div>
+</div>
+
+<div class="filters">
+  <button class="fbtn active" onclick="filt('all',this)">All</button>
+  <button class="fbtn" onclick="filt('found',this)">✅ Found</button>
+  <button class="fbtn" onclick="filt('missing',this)">❌ Missing</button>
+</div>
+
+<div id="cards">{cards}</div>
+
+<script>
+function filt(type,btn){{
+  document.querySelectorAll('.fbtn').forEach(b=>b.classList.remove('active'));
+  btn.classList.add('active');
+  document.querySelectorAll('.card').forEach(c=>{{
+    const isMissing=c.querySelector('.badge').textContent.includes('MISSING');
+    if(type==='all') c.style.display='';
+    else if(type==='found') c.style.display=isMissing?'none':'';
+    else c.style.display=isMissing?'':'none';
+  }});
+}}
+</script>
+</body>
+</html>"""
+
+        path = out / "inventory_report.html"
+        path.write_text(html, encoding="utf-8")
+        return str(path)
+
+
+# ═══════════════════════════════════════════════════════════════════════════
+#  CLI
+# ═══════════════════════════════════════════════════════════════════════════
+def main():
+    p = argparse.ArgumentParser(
+        description="Furniture Inventory: find FOUND / MISSING items between two folders."
+    )
+    p.add_argument("--before",  required=True, help="Folder with reference images (before)")
+    p.add_argument("--after",   required=True, help="Folder with images to compare (after)")
+    p.add_argument("--output",  default=None,  help="Output folder for HTML report")
+    p.add_argument("--strict",  action="store_true",
+                   help="Raise thresholds to reduce false positives even further")
+    args = p.parse_args()
+
+    if args.strict:
+        global CLS_CONFIRM_FOUND, PATCH_CONFIRM_FOUND, MIN_GEO_INLIERS
+        CLS_CONFIRM_FOUND   = 0.90
+        PATCH_CONFIRM_FOUND = 0.76
+        MIN_GEO_INLIERS     = 18
+        log("Strict mode ON — thresholds raised ↑", "yellow")
+
+    t0      = time.time()
+    engine  = InventoryMatcher()
+    results = engine.run(args.before, args.after)
+    engine.print_report(results)
+
+    if args.output:
+        rpt = engine.save_html(results, args.output)
+        log(f"\n📄 Report → {rpt}", "bold green")
+
+    log(f"\n⏱  Finished in {time.time()-t0:.1f}s", "dim")
+
+
+if __name__ == "__main__":
+    main()

mllm_inspector.py

@@ -0,0 +1,139 @@
+import os
+import base64
+import json
+import google.generativeai as genai
+from groq import Groq
+from openai import OpenAI
+
+def encode_image(image_path):
+    with open(image_path, "rb") as image_file:
+        return base64.b64encode(image_file.read()).decode('utf-8')
+
+def get_prompt():
+    return """
+    You are an expert property inspector. 
+    Compare these two images: the first one is the "Before" state, and the second one is the "After" state of the same object.
+    Is there any damage, breakage, deep scratch, or negative change in the "After" image?
+    
+    Respond STRICTLY in JSON format with three keys:
+    1. "description": A detailed English description of the damage found. If no damage is found, state that it is intact.
+    2. "target_phrase": A short English phrase (2-4 words) describing the overall damaged parts (e.g., "damaged table and chairs"). If no damage, return "None".
+    3. "target_phrases_list": A list of highly specific, short English phrases (1-3 words each), breaking down every single damaged object separately to be used individually by an object detection model. (e.g., ["torn chair", "broken table corner", "cracked wall", "peeling paint", "torn curtain"]). If no damage, return [].
+    
+    Do not output any markdown text outside the JSON object.
+    """
+
+def inspect_with_gemini(image_before_path, image_after_path, api_key):
+    try:
+        from PIL import Image
+        genai.configure(api_key=api_key)
+        model = genai.GenerativeModel('gemini-2.0-flash')
+        img_before = Image.open(image_before_path)
+        img_after = Image.open(image_after_path)
+        
+        response = model.generate_content([get_prompt(), img_before, img_after])
+        text_response = response.text
+        if "```json" in text_response:
+            text_response = text_response.split("```json")[1].split("```")[0].strip()
+        return json.loads(text_response)
+    except Exception as e:
+        print(f"\n❌ خطأ في Gemini: {e}")
+        return None
+
+def inspect_with_groq(image_before_path, image_after_path, api_key):
+    try:
+        client = Groq(api_key=api_key)
+        base64_before = encode_image(image_before_path)
+        base64_after = encode_image(image_after_path)
+        
+        response = client.chat.completions.create(
+            model="llama-3.2-11b-vision-preview",
+            messages=[
+                {
+                    "role": "user",
+                    "content": [
+                        {"type": "text", "text": get_prompt()},
+                        {"type": "image_url", "image_url": {"url": f"data:image/jpeg;base64,{base64_before}"}},
+                        {"type": "image_url", "image_url": {"url": f"data:image/jpeg;base64,{base64_after}"}}
+                    ]
+                }
+            ],
+            temperature=0.1
+        )
+        
+        text_response = response.choices[0].message.content
+        import re
+        json_match = re.search(r'\{.*\}', text_response, re.DOTALL)
+        if json_match:
+            text_response = json_match.group(0)
+            
+        return json.loads(text_response)
+    except Exception as e:
+        print(f"\n❌ خطأ في Groq: {e}")
+        raise e
+
+def inspect_with_openai(image_before_path, image_after_path, api_key):
+    try:
+        client = OpenAI(api_key=api_key)
+        base64_before = encode_image(image_before_path)
+        base64_after = encode_image(image_after_path)
+        
+        response = client.chat.completions.create(
+            model="gpt-4o-mini",
+            messages=[
+                {
+                    "role": "user",
+                    "content": [
+                        {"type": "text", "text": get_prompt()},
+                        {"type": "image_url", "image_url": {"url": f"data:image/jpeg;base64,{base64_before}"}},
+                        {"type": "image_url", "image_url": {"url": f"data:image/jpeg;base64,{base64_after}"}}
+                    ]
+                }
+            ],
+            temperature=0.1,
+            response_format={"type": "json_object"}
+        )
+        return json.loads(response.choices[0].message.content)
+    except Exception as e:
+        print(f"\n❌ خطأ في OpenAI: {e}")
+        return None
+
+def inspect_with_openrouter(image_before_path, image_after_path, api_key):
+    try:
+        # OpenRouter uses the exact same OpenAI library but a different URL
+        client = OpenAI(
+            base_url="https://openrouter.ai/api/v1",
+            api_key=api_key,
+        )
+        base64_before = encode_image(image_before_path)
+        base64_after = encode_image(image_after_path)
+        
+        # Free vision model on OpenRouter!
+        response = client.chat.completions.create(
+            model="nvidia/nemotron-nano-12b-v2-vl:free",
+            messages=[
+                {
+                    "role": "user",
+                    "content": [
+                        {"type": "text", "text": get_prompt()},
+                        {"type": "image_url", "image_url": {"url": f"data:image/jpeg;base64,{base64_before}"}},
+                        {"type": "image_url", "image_url": {"url": f"data:image/jpeg;base64,{base64_after}"}}
+                    ]
+                }
+            ],
+            temperature=0.1
+        )
+        
+        if not hasattr(response, 'choices') or not response.choices:
+            raise ValueError(f"OpenRouter returned an invalid response: {response}")
+            
+        text_response = response.choices[0].message.content
+        import re
+        json_match = re.search(r'\{.*\}', text_response, re.DOTALL)
+        if json_match:
+            text_response = json_match.group(0)
+            
+        return json.loads(text_response)
+    except Exception as e:
+        print(f"\n❌ خطأ في الاتصال: {e}")
+        raise e

report_generator.py

@@ -0,0 +1,507 @@
+import os
+import base64
+from pathlib import Path
+
+def generate_combined_report(results, out_dir):
+    """
+    results is a list of dicts, each containing:
+      - 'before_path': Path
+      - 'after_path': Path or None
+      - 'status': 'INTACT' | 'DAMAGED' | 'MISSING'
+      - 'cls_score': float
+      - 'patch_score': float
+      - 'geo_inliers': int
+      - 'confidence': str
+      - 'stage_used': int
+      - 'damage_description': str
+      - 'target_phrases_list': list of str
+      - 'masked_after_path': Path or None
+    """
+    out = Path(out_dir)
+    out.mkdir(parents=True, exist_ok=True)
+
+    def b64img(path):
+        if not path or not os.path.exists(path):
+            return ""
+        try:
+            p = Path(path)
+            data = base64.b64encode(p.read_bytes()).decode()
+            ext = p.suffix.lstrip(".") or "jpeg"
+            return f"data:image/{ext};base64,{data}"
+        except Exception as e:
+            print(f"Error encoding image {path}: {e}")
+            return ""
+
+    cards = ""
+    for r in results:
+        status = r['status']
+        
+        # Determine styling based on status
+        if status == 'INTACT':
+            color = "#10b981"  # Emerald
+            bg_color = "rgba(16, 185, 129, 0.05)"
+            border_c = "rgba(16, 185, 129, 0.2)"
+            icon = "✅"
+            label = "INTACT / سليم"
+        elif status == 'DAMAGED':
+            color = "#f59e0b"  # Amber
+            bg_color = "rgba(245, 158, 11, 0.05)"
+            border_c = "rgba(245, 158, 11, 0.25)"
+            icon = "⚠️"
+            label = "DAMAGED / تالف"
+        else:
+            color = "#ef4444"  # Red
+            bg_color = "rgba(239, 68, 68, 0.05)"
+            border_c = "rgba(239, 68, 68, 0.2)"
+            icon = "❌"
+            label = "MISSING / مفقود"
+
+        before_src = b64img(r['before_path'])
+        
+        after_html = ""
+        if r['after_path']:
+            after_src = b64img(r['after_path'])
+            after_name = Path(r['after_path']).name
+            after_html = f"""
+            <div class="arrow">→</div>
+            <div class="img-box">
+                <div class="box-label">AFTER IMAGE / الصورة بعد</div>
+                <img src="{after_src}" alt="{after_name}"/>
+                <div class="fname">{after_name}</div>
+            </div>"""
+
+        mask_html = ""
+        if status == 'DAMAGED' and r['masked_after_path']:
+            mask_src = b64img(r['masked_after_path'])
+            mask_name = Path(r['masked_after_path']).name
+            mask_html = f"""
+            <div class="arrow">→</div>
+            <div class="img-box highlighted">
+                <div class="box-label" style="color:#f59e0b">🎯 DETECTED DAMAGE (SAM MASK) / الضرر المكتشف (قناع SAM)</div>
+                <img src="{mask_src}" alt="{mask_name}" style="border-color:#f59e0b"/>
+                <div class="fname" style="color:#f59e0b">{mask_name}</div>
+            </div>"""
+
+        stage_labels = {1: "DINOv2 CLS", 2: "DINOv2 Patch", 3: "SIFT+RANSAC"}
+        stage_str = stage_labels.get(r.get('stage_used', 0), "None")
+
+        # Matching metrics block
+        scores_html = ""
+        if r['after_path']:
+            scores_html = f"""
+            <div class="metric-chip">Match / مطابقة: <b>{stage_str}</b></div>
+            <div class="metric-chip">CLS score / درجة CLS: <b>{r['cls_score']:.3f}</b></div>
+            """
+            if r['patch_score']:
+                scores_html += f'<div class="metric-chip">Patch score / درجة الرقعة: <b>{r["patch_score"]:.3f}</b></div>'
+            if r['geo_inliers']:
+                scores_html += f'<div class="metric-chip">Geo Inliers / مطابقة هندسية: <b>{r["geo_inliers"]}</b></div>'
+            if r.get('confidence'):
+                scores_html += f'<div class="metric-chip">Confidence / ثقة: <b>{r["confidence"]}</b></div>'
+
+        # Damage Report Text Block
+        report_details_html = ""
+        if status == 'DAMAGED':
+            phrases_badges = "".join([f'<span class="phrase-tag">{p}</span>' for p in r['target_phrases_list']])
+            report_details_html = f"""
+            <div class="damage-report-box">
+                <h4>📝 AI Damage Assessment Report / تقرير فحص التلفيات بالذكاء الاصطناعي</h4>
+                <p class="desc">{r['damage_description']}</p>
+                <div class="phrases-container">
+                    <strong>Segmented features / الأجزاء المحددة:</strong>
+                    <div class="phrase-tags-row">{phrases_badges}</div>
+                </div>
+            </div>
+            """
+        elif status == 'INTACT':
+            report_details_html = f"""
+            <div class="intact-report-box">
+                <p>✨ AI analysis confirms this item is intact. No major damage or negative changes were detected. / يؤكد تحليل الذكاء الاصطناعي أن هذا العنصر سليم، ولم يتم رصد أي تلفيات أو تغييرات سلبية.</p>
+            </div>
+            """
+        else:
+            report_details_html = f"""
+            <div class="missing-report-box">
+                <p>🔍 This item from the before inventory could not be matched with any item in the after inventory. It may have been moved, stolen, or removed. / لم يتم العثور على مطابقة لهذا العنصر في صور البعد، قد يكون تم نقله، سرقته أو إزالته.</p>
+            </div>
+            """
+
+        cards += f"""
+        <div class="card" data-status="{status}" style="background:{bg_color};border-color:{border_c}">
+            <div class="card-header">
+                <div class="badge" style="background:{color}">{icon} {label}</div>
+                <div class="metrics-row">{scores_html}</div>
+            </div>
+            <div class="img-row">
+                <div class="img-box">
+                    <div class="box-label">BEFORE IMAGE / الصورة قبل</div>
+                    <img src="{before_src}" alt="{Path(r['before_path']).name}"/>
+                    <div class="fname">{Path(r['before_path']).name}</div>
+                </div>
+                {after_html}
+                {mask_html}
+            </div>
+            {report_details_html}
+        </div>"""
+
+    n_total = len(results)
+    n_intact = sum(1 for r in results if r['status'] == 'INTACT')
+    n_damaged = sum(1 for r in results if r['status'] == 'DAMAGED')
+    n_missing = sum(1 for r in results if r['status'] == 'MISSING')
+
+    html = f"""<!DOCTYPE html>
+<html lang="en">
+<head>
+<meta charset="UTF-8">
+<meta name="viewport" content="width=device-width, initial-scale=1.0">
+<title>AI Inventory & Damage Report</title>
+<style>
+  @import url('https://fonts.googleapis.com/css2?family=Inter:wght@300;400;500;600;700;800&family=Cairo:wght@300;400;600;700;800&display=swap');
+  
+  * {{
+    box-sizing: border-box;
+    margin: 0;
+    padding: 0;
+  }}
+  
+  body {{
+    font-family: 'Inter', 'Cairo', -apple-system, sans-serif;
+    background: #0b0f19;
+    color: #f1f5f9;
+    padding: 2.5rem 1.5rem;
+    line-height: 1.5;
+  }}
+  
+  .container {{
+    max-width: 1200px;
+    margin: 0 auto;
+  }}
+  
+  header {{
+    text-align: center;
+    margin-bottom: 2.5rem;
+  }}
+  
+  h1 {{
+    font-size: 2.5rem;
+    font-weight: 800;
+    margin-bottom: 0.5rem;
+    letter-spacing: -0.025em;
+    background: linear-gradient(135deg, #60a5fa, #34d399);
+    -webkit-background-clip: text;
+    -webkit-text-fill-color: transparent;
+  }}
+  
+  .sub {{
+    color: #94a3b8;
+    font-size: 1rem;
+    font-weight: 400;
+  }}
+  
+  .summary {{
+    display: grid;
+    grid-template-columns: repeat(auto-fit, minmax(180px, 1fr));
+    gap: 1.25rem;
+    margin: 2rem 0;
+  }}
+  
+  .stat {{
+    background: #1e293b;
+    border-radius: 16px;
+    padding: 1.25rem;
+    text-align: center;
+    border: 1px solid #334155;
+    transition: transform 0.2s, box-shadow 0.2s;
+  }}
+  
+  .stat:hover {{
+    transform: translateY(-2px);
+    box-shadow: 0 10px 15px -3px rgba(0, 0, 0, 0.3);
+  }}
+  
+  .stat .num {{
+    font-size: 2.25rem;
+    font-weight: 800;
+    line-height: 1.2;
+  }}
+  
+  .stat .lbl {{
+    font-size: 0.85rem;
+    color: #94a3b8;
+    font-weight: 500;
+    margin-top: 0.25rem;
+    text-transform: uppercase;
+    letter-spacing: 0.05em;
+  }}
+  
+  .filters {{
+    text-align: center;
+    margin-bottom: 2rem;
+  }}
+  
+  .fbtn {{
+    background: #1e293b;
+    border: 1px solid #334155;
+    color: #cbd5e1;
+    padding: 0.5rem 1.5rem;
+    border-radius: 9999px;
+    cursor: pointer;
+    margin: 0.25rem;
+    font-size: 0.875rem;
+    font-weight: 600;
+    transition: all 0.2s;
+  }}
+  
+  .fbtn:hover, .fbtn.active {{
+    background: #3b82f6;
+    color: #ffffff;
+    border-color: #3b82f6;
+    box-shadow: 0 4px 6px -1px rgba(59, 130, 246, 0.4);
+  }}
+  
+  .card {{
+    border-radius: 20px;
+    padding: 1.75rem;
+    margin-bottom: 2rem;
+    border: 1px solid;
+    box-shadow: 0 10px 25px -5px rgba(0, 0, 0, 0.4);
+    background: #111827;
+    transition: transform 0.2s;
+  }}
+  
+  .card:hover {{
+    transform: scale(1.005);
+  }}
+  
+  .card-header {{
+    display: flex;
+    justify-content: space-between;
+    align-items: center;
+    flex-wrap: wrap;
+    gap: 1rem;
+    margin-bottom: 1.25rem;
+    border-bottom: 1px solid rgba(255, 255, 255, 0.05);
+    padding-bottom: 1rem;
+  }}
+  
+  .badge {{
+    display: inline-block;
+    padding: 0.35rem 1.1rem;
+    border-radius: 9999px;
+    font-weight: 700;
+    color: #ffffff;
+    font-size: 0.85rem;
+    text-transform: uppercase;
+    letter-spacing: 0.025em;
+  }}
+  
+  .metrics-row {{
+    display: flex;
+    flex-wrap: wrap;
+    gap: 0.5rem;
+  }}
+  
+  .metric-chip {{
+    background: #1e293b;
+    border: 1px solid #334155;
+    padding: 0.25rem 0.75rem;
+    border-radius: 8px;
+    font-size: 0.75rem;
+    color: #94a3b8;
+  }}
+  
+  .metric-chip b {{
+    color: #f1f5f9;
+  }}
+  
+  .img-row {{
+    display: flex;
+    align-items: center;
+    gap: 1.5rem;
+    flex-wrap: wrap;
+    margin-bottom: 1.5rem;
+  }}
+  
+  .img-box {{
+    flex: 1;
+    min-width: 260px;
+    text-align: center;
+    background: #0f172a;
+    padding: 1rem;
+    border-radius: 12px;
+    border: 1px solid #1e293b;
+  }}
+  
+  .img-box img {{
+    max-width: 100%;
+    max-height: 280px;
+    border-radius: 8px;
+    object-fit: contain;
+    border: 2px solid #334155;
+    margin-top: 0.5rem;
+    background: #0b0f19;
+  }}
+  
+  .box-label {{
+    font-size: 0.75rem;
+    font-weight: 700;
+    color: #64748b;
+    text-transform: uppercase;
+    letter-spacing: 0.08em;
+  }}
+  
+  .fname {{
+    font-size: 0.75rem;
+    color: #475569;
+    margin-top: 0.5rem;
+    word-break: break-all;
+    font-family: monospace;
+  }}
+  
+  .arrow {{
+    font-size: 2rem;
+    color: #475569;
+    font-weight: 800;
+    flex-shrink: 0;
+  }}
+  
+  .damage-report-box {{
+    background: rgba(245, 158, 11, 0.03);
+    border: 1px dashed rgba(245, 158, 11, 0.2);
+    border-radius: 12px;
+    padding: 1.25rem;
+    margin-top: 1rem;
+  }}
+  
+  .damage-report-box h4 {{
+    color: #f59e0b;
+    font-size: 0.95rem;
+    font-weight: 700;
+    margin-bottom: 0.5rem;
+  }}
+  
+  .damage-report-box .desc {{
+    font-size: 0.9rem;
+    color: #e2e8f0;
+    margin-bottom: 0.75rem;
+  }}
+  
+  .phrases-container {{
+    display: flex;
+    align-items: center;
+    gap: 0.75rem;
+    flex-wrap: wrap;
+    font-size: 0.8rem;
+    color: #94a3b8;
+  }}
+  
+  .phrase-tags-row {{
+    display: flex;
+    flex-wrap: wrap;
+    gap: 0.35rem;
+  }}
+  
+  .phrase-tag {{
+    background: rgba(245, 158, 11, 0.1);
+    color: #f59e0b;
+    border: 1px solid rgba(245, 158, 11, 0.2);
+    padding: 0.15rem 0.5rem;
+    border-radius: 4px;
+    font-weight: 600;
+    font-size: 0.75rem;
+  }}
+  
+  .intact-report-box {{
+    background: rgba(16, 185, 129, 0.03);
+    border: 1px solid rgba(16, 185, 129, 0.15);
+    border-radius: 12px;
+    padding: 1rem 1.25rem;
+    font-size: 0.9rem;
+    color: #a7f3d0;
+  }}
+  
+  .missing-report-box {{
+    background: rgba(239, 68, 68, 0.03);
+    border: 1px solid rgba(239, 68, 68, 0.15);
+    border-radius: 12px;
+    padding: 1rem 1.25rem;
+    font-size: 0.9rem;
+    color: #fca5a5;
+  }}
+  
+  @media (max-width: 768px) {{
+    .arrow {{
+      display: none;
+    }}
+    .img-row {{
+      flex-direction: column;
+    }}
+    .img-box {{
+      width: 100%;
+    }}
+    .card-header {{
+      flex-direction: column;
+      align-items: flex-start;
+    }}
+  }}
+</style>
+</head>
+<body>
+<div class="container">
+  <header>
+    <h1>🏠 Property Inventory & Damage Report / تقرير جرد وتحديد تلفيات الممتلكات</h1>
+    <p class="sub">AI Matching & Inspection System · نظام المطابقة والفحص الذكي بالذكاء الاصطناعي (DINOv2 + Grounded-SAM + MLLM)</p>
+  </header>
+  
+  <div class="summary">
+    <div class="stat">
+      <div class="num" style="color:#22c55e">{n_intact}</div>
+      <div class="lbl">✅ Intact / سليم</div>
+    </div>
+    <div class="stat">
+      <div class="num" style="color:#f59e0b">{n_damaged}</div>
+      <div class="lbl">⚠️ Damaged / تالف</div>
+    </div>
+    <div class="stat">
+      <div class="num" style="color:#ef4444">{n_missing}</div>
+      <div class="lbl">❌ Missing / مفقود</div>
+    </div>
+    <div class="stat">
+      <div class="num" style="color:#3b82f6">{n_total}</div>
+      <div class="lbl">Total Items / إجمالي العناصر</div>
+    </div>
+  </div>
+  
+  <div class="filters">
+    <button class="fbtn active" onclick="filt('ALL', this)">All Items / كل العناصر</button>
+    <button class="fbtn" onclick="filt('INTACT', this)">✅ Intact / سليم</button>
+    <button class="fbtn" onclick="filt('DAMAGED', this)">⚠️ Damaged / تالف</button>
+    <button class="fbtn" onclick="filt('MISSING', this)">❌ Missing / مفقود</button>
+  </div>
+  
+  <div id="cards-container">
+    {cards}
+  </div>
+</div>
+
+<script>
+function filt(status, btn) {{
+  document.querySelectorAll('.fbtn').forEach(b => b.classList.remove('active'));
+  btn.classList.add('active');
+  document.querySelectorAll('.card').forEach(c => {{
+    const cardStatus = c.getAttribute('data-status');
+    if (status === 'ALL') {{
+      c.style.display = 'block';
+    }} else {{
+      c.style.display = cardStatus === status ? 'block' : 'none';
+    }}
+  }});
+}}
+</script>
+</body>
+</html>"""
+
+    # Escape curly braces in css and scripts properly (using %% for format double escape or format string)
+    report_file = out / "inventory_damage_report.html"
+    report_file.write_text(html, encoding="utf-8")
+    return str(report_file)

sam_masker.py

@@ -0,0 +1,106 @@
+import os
+import torch
+import numpy as np
+import cv2
+from PIL import Image
+
+_dino_processor = None
+_dino_model = None
+_sam_processor = None
+_sam_model = None
+
+def get_models(device):
+    global _dino_processor, _dino_model, _sam_processor, _sam_model
+    if _dino_model is None:
+        print("Loading Grounding DINO (Detector)...")
+        from transformers import AutoProcessor, AutoModelForZeroShotObjectDetection
+        _dino_processor = AutoProcessor.from_pretrained("IDEA-Research/grounding-dino-base")
+        _dino_model = AutoModelForZeroShotObjectDetection.from_pretrained("IDEA-Research/grounding-dino-base").to(device)
+        _dino_model.eval()
+        
+    if _sam_model is None:
+        print("Loading SAM (Segment Anything)...")
+        from transformers import SamModel, SamProcessor
+        _sam_processor = SamProcessor.from_pretrained("facebook/sam-vit-base")
+        _sam_model = SamModel.from_pretrained("facebook/sam-vit-base").to(device)
+        _sam_model.eval()
+        
+    return _dino_processor, _dino_model, _sam_processor, _sam_model
+
+def generate_damage_mask(image_path, target_phrases_list, output_path):
+    """
+    Segment the specified damage phrases in the image using Grounding DINO and SAM.
+    Saves the final visualized image to output_path.
+    Returns True on success, False on failure.
+    """
+    try:
+        device = "cuda" if torch.cuda.is_available() else "cpu"
+        d_proc, d_model, s_proc, s_model = get_models(device)
+        
+        # Load image
+        image = Image.open(image_path).convert("RGB")
+        image_np = np.array(image)
+        
+        # Format query for Grounding DINO (dot-separated)
+        text_prompt = ". ".join(target_phrases_list) + "."
+        
+        # Run detector
+        inputs = d_proc(images=image, text=text_prompt, return_tensors="pt").to(device)
+        with torch.no_grad():
+            outputs = d_model(**inputs)
+            
+        results = d_proc.post_process_grounded_object_detection(
+            outputs,
+            inputs.input_ids,
+            threshold=0.25,
+            text_threshold=0.25,
+            target_sizes=[image.size[::-1]]
+        )[0]
+        
+        boxes = results["boxes"]
+        scores = results["scores"]
+        defect_count = len(boxes)
+        
+        if defect_count == 0:
+            # If no damage is located, save the original image and return False
+            cv2.imwrite(output_path, cv2.cvtColor(image_np, cv2.COLOR_RGB2BGR))
+            return False
+            
+        # Run Segment Anything Model
+        box_list = [box.tolist() for box in boxes]
+        sam_inputs = s_proc(image, input_boxes=[box_list], return_tensors="pt").to(device)
+        with torch.no_grad():
+            sam_outputs = s_model(**sam_inputs)
+            
+        pred_masks = sam_outputs.pred_masks.squeeze(1)
+        masks = s_proc.image_processor.post_process_masks(
+            pred_masks,
+            sam_inputs["original_sizes"],
+            sam_inputs["reshaped_input_sizes"]
+        )[0]
+        
+        # Visualize detections and segmentations
+        annotated_img = image_np.copy()
+        for i in range(defect_count):
+            box = boxes[i].cpu().numpy()
+            # Draw green bounding box
+            cv2.rectangle(annotated_img, (int(box[0]), int(box[1])), (int(box[2]), int(box[3])), (0, 255, 0), 3)
+            
+            # Extract SAM mask
+            mask = masks[i][0].cpu().numpy()
+            covered_color = np.zeros_like(annotated_img)
+            covered_color[mask] = [255, 0, 0] # Red mask overlay
+            
+            alpha = 0.5
+            mask_indices = mask > 0
+            annotated_img[mask_indices] = annotated_img[mask_indices] * (1 - alpha) + covered_color[mask_indices] * alpha
+            
+            # Score label
+            score = scores[i].item()
+            cv2.putText(annotated_img, f"{score:.2f}", (int(box[0]), int(box[1]-10)), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 255, 0), 2)
+            
+        cv2.imwrite(output_path, cv2.cvtColor(annotated_img, cv2.COLOR_RGB2BGR))
+        return True
+    except Exception as e:
+        print(f"Error in generate_damage_mask: {e}")
+        return False