Upload 4 files

Dockerfile

@@ -1,44 +1,37 @@
-# Use a lightweight official Python runtime as a parent image
+# Use Python 3.10 slim image
 FROM python:3.10-slim
 
-# Set environment variables
+# Prevent Python from writing pyc files and buffering stdout/stderr
 ENV PYTHONUNBUFFERED=1 \
     PYTHONDONTWRITEBYTECODE=1 \
-    HOME=/home/user \
-    PATH=/home/user/.local/bin:$PATH
+    HF_HOME=/tmp/hf_cache
 
-# Create a non-root user
-RUN useradd -m -u 1000 user
+# Set working directory
+WORKDIR /code
 
-# Install system dependencies for OpenCV, FFmpeg, and Git
+# Install system dependencies for OpenCV and basic compilation
 RUN apt-get update && apt-get install -y --no-install-recommends \
-    ffmpeg \
-    libgl1 \
-    libglib2.0-0 \
     build-essential \
+    libgl1-mesa-glx \
+    libglib2.0-0 \
     git \
     && rm -rf /var/lib/apt/lists/*
 
-# Set up workspace directory and change ownership to the non-root user
-RUN mkdir -p /home/user/app && chown -R user:user /home/user/app
-
-# Switch to the non-root user
-USER user
-WORKDIR /home/user/app
+# Copy and install python dependencies
+COPY requirements.txt /code/requirements.txt
+RUN pip install --no-cache-dir --upgrade -r /code/requirements.txt
 
-# Copy the requirements file first to leverage Docker cache
-COPY --chown=user:user requirements.txt .
+# Create cache directories and set permissions for Hugging Face container user
+RUN mkdir -p /tmp/hf_cache && chmod -R 777 /tmp/hf_cache
 
-# Install PyTorch and requirements
-RUN pip install --no-cache-dir --upgrade pip && \
-    pip install --no-cache-dir torch torchvision --index-url https://download.pytorch.org/whl/cpu && \
-    pip install --no-cache-dir -r requirements.txt
+# Copy application files
+COPY . /code
 
-# Copy the rest of the application code
-COPY --chown=user:user . .
+# Change permissions to make files writable by Hugging Face default user (UID 1000)
+RUN chmod -R 777 /code
 
-# Expose port 7860 (Hugging Face Spaces default port)
+# Expose port 7860 for Hugging Face Space
 EXPOSE 7860
 
-# Start the Gradio application
-CMD ["python", "app.py"]
+# Run Streamlit on Hugging Face standard port
+CMD ["streamlit", "run", "app.py", "--server.port=7860", "--server.address=0.0.0.0"]

README.md

@@ -1,33 +1,28 @@
 ---
-title: SAM 3 Concept Video Tracker
+title: Property Damage Inspector & Matcher
 emoji: 🏠
 colorFrom: blue
-colorTo: pink
+colorTo: green
 sdk: docker
+app_port: 7860
 pinned: false
-license: mit
 ---
 
-# 🏠 SAM 3 Concept Video Tracker
+# 🏠 AI Property Damage Inspector & Inventory Matcher
+An advanced computer vision pipeline combining **DINOv2**, **Grounded-SAM**, and **MLLMs (Gemini, Llama Vision, GPT-4o)** to automate inventory matching and damage assessment between "Before" and "After" states.
 
-This Hugging Face Space hosts the **SAM 3 Concept Video Tracker** application, built using Gradio, Hugging Face `transformers` and Meta's **Segment Anything Model 3 (SAM 3)**.
+## 🌟 Key Features
+- **Directory-wide Batch Comparison:** Matches items between two folders automatically using a DINOv2 cls, patch matching, and SIFT+RANSAC cascade.
+- **AI-Powered Damage Detection:** Inspects matched pairs for deep scratches, breakages, or tears using multi-API providers (Gemini, OpenRouter, OpenAI, Groq).
+- **Damage Segmentation (Grounded-SAM):** Automatically generates precise segmentation masks where damage is located using Grounding DINO + SAM.
+- **Premium Bilingual Reports:** Exports a consolidated, interactive, self-contained dark-mode HTML report (English & Arabic) embedding all base64-encoded images.
 
-## Features
-- **Single Video Input:** Upload any video and start tracking.
-- **Open-Vocabulary Text Prompting:** Simply type a list of comma-separated concepts you want to track (e.g. `chair, couch, bed`).
-- **Unified Video Tracking:** Uses `facebook/sam3`'s internal video memory state to automatically detect, segment, and track the concepts across frames with persistent tracking IDs.
-- **Detailed Tracking IDs Report:** Outputs the exact tracking IDs associated with each class in a clean markdown table.
-- **Interactive Duration Slider:** Limit video duration easily to save memory.
+## 🚀 Deployment on Hugging Face Spaces
+This repository is configured to deploy directly to Hugging Face Spaces using **Docker**.
 
-## Running Locally
-To launch the application locally:
-```bash
-pip install -r requirements.txt
-python app.py
-```
-Or build the Docker container:
-```bash
-docker build -t sam3-video-tracker .
-docker run -p 7860:7860 sam3-video-tracker
-```
-Note: Since `facebook/sam3` is gated, you must provide a valid Hugging Face Access Token in the textbox inside the Gradio UI.
+### How to Deploy:
+1. Create a new Space on [Hugging Face](https://huggingface.co/new-space).
+2. Select **Docker** as the SDK.
+3. Upload all the files from this directory.
+4. Add your API keys (e.g., `OPENROUTER_API_KEY`, `GEMINI_API_KEY`) under **Settings > Variables and secrets** in your Hugging Face Space if you want to preload them.
+5. Hugging Face will build the container and start the web UI automatically.

app.py

@@ -1,553 +1,415 @@
+import streamlit as st
 import os
-import cv2
-import tempfile
-import colorsys
-import subprocess
-import numpy as np
-from collections import defaultdict
-from collections.abc import Mapping, Sequence
-from typing import Any
-import gradio as gr
-from PIL import Image, ImageDraw, ImageFont
+from PIL import Image
+from dotenv import load_dotenv
+from mllm_inspector import inspect_with_gemini, inspect_with_groq, inspect_with_openai, inspect_with_openrouter
+from pathlib import Path
+from furniture_matcher import InventoryMatcher
+from report_generator import generate_combined_report
 
-try:
-    from transformers import Sam3VideoModel, Sam3VideoProcessor
-    import torch
-    HAS_TRANSFORMERS_SAM3 = True
-    torch.set_num_threads(2)
-except ImportError:
-    HAS_TRANSFORMERS_SAM3 = False
+# Load environment variables
+load_dotenv(override=True)
 
-def to_device_recursive(obj: Any, device: str | torch.device) -> Any:
-    """Return a new object where all torch.Tensors reachable from `obj` are moved to the given device."""
-    device = torch.device(device)
-    memo = {}
+# Configure Streamlit page
+st.set_page_config(page_title="Property Damage Inspector", page_icon="🏠", layout="wide")
 
-    def _convert(x: Any) -> Any:
-        obj_id = id(x)
-        if obj_id in memo:
-            return memo[obj_id]
+# Custom CSS
+st.markdown("""
+<style>
+    .stApp { font-family: 'Inter', 'Segoe UI', sans-serif; }
+    .stButton>button { width: 100%; border-radius: 8px; font-weight: bold; background-color: #4CAF50; color: white; }
+    .css-1d391kg { padding-top: 2rem; }
+</style>
+""", unsafe_allow_html=True)
 
-        if isinstance(x, torch.Tensor):
-            y = x.to(device)
-            memo[obj_id] = y
-            return y
+st.title("🏠 AI Property Damage Inspector")
+st.markdown("---")
 
-        if isinstance(x, Mapping):
-            if isinstance(x, defaultdict):
-                y = defaultdict(x.default_factory)
-                memo[obj_id] = y
-                for k, v in x.items():
-                    y[k] = _convert(v)
-                return y
+# Sidebar for configuration
+st.sidebar.header("⚙️ Settings")
+provider = st.sidebar.selectbox("Select AI Provider", [
+    "OpenRouter (Free - Llama Vision)", 
+    "Groq (Free - Fast Vision)",
+    "Google Gemini", 
+    "OpenAI (GPT-4o)", 
+    "Manual Mode (Skip API)"
+])
 
-            try:
-                y = type(x)((k, _convert(v)) for k, v in x.items())
-                memo[obj_id] = y
-                return y
-            except TypeError:
-                y = {k: _convert(v) for k, v in x.items()}
-                memo[obj_id] = y
-                return y
-
-        if isinstance(x, Sequence) and not isinstance(x, (str, bytes, bytearray)):
-            if isinstance(x, list):
-                y = [_convert(v) for v in x]
-            elif isinstance(x, tuple):
-                y = type(x)(_convert(v) for v in x)
-            else:
-                try:
-                    y = type(x)(_convert(v) for v in x)
-                except TypeError:
-                    y = [_convert(v) for v in x]
-            memo[obj_id] = y
-            return y
+# Handle API Key
+api_key = ""
+if provider != "Manual Mode (Skip API)":
+    if "OpenRouter" in provider:
+        api_key = os.getenv("OPENROUTER_API_KEY", "")
+        if api_key:
+            st.sidebar.success("✅ OpenRouter API Key loaded securely.")
+        else:
+            api_key = st.sidebar.text_input("🔑 Enter OpenRouter API Key:", type="password")
+    elif "Groq" in provider:
+        api_key = os.getenv("GROQ_API_KEY", "")
+        if api_key:
+            st.sidebar.success("✅ Groq API Key loaded securely.")
+        else:
+            api_key = st.sidebar.text_input("🔑 Enter Groq API Key:", type="password")
+    else:
+        api_key = st.sidebar.text_input("🔑 Enter API Key:", type="password")
 
-        if hasattr(x, "__dict__") and not isinstance(x, type):
-            new_obj = x.__class__.__new__(x.__class__)
-            memo[obj_id] = new_obj
-            for name, value in vars(x).items():
-                setattr(new_obj, name, _convert(value))
-            return new_obj
+st.sidebar.markdown("---")
+st.sidebar.info("💡 **Tip:** In Manual Mode, no internet is required. The system will use your local GPU to draw masks.")
 
-        memo[obj_id] = x
-        return x
+app_mode = st.sidebar.radio("Select App Mode / اختر وضع التطبيق", [
+    "📸 Single Image Pair Mode / وضع فحص صورة مفردة",
+    "📁 Directory-wide Batch Mode / وضع جرد المجلدات بالكامل"
+])
 
-    return _convert(obj)
+st.sidebar.markdown("---")
 
-def transcode_to_h264(input_path, output_path):
-    """Transcodes video to H.264 codec using ffmpeg so it plays natively in all browsers."""
-    if os.path.exists(output_path):
-        try:
-            os.remove(output_path)
-        except Exception:
-            pass
-            
-    cmd = [
-        'ffmpeg', '-y',
-        '-i', input_path,
-        '-vcodec', 'libx264',
-        '-pix_fmt', 'yuv420p',
-        '-preset', 'fast',
-        '-crf', '23',
-        output_path
-    ]
+def save_optimized_image(uploaded_file, target_path, max_dim=1600):
     try:
-        subprocess.run(cmd, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL, check=True)
-        return output_path
+        # Load image with PIL
+        img = Image.open(uploaded_file)
+        
+        # Convert to RGB (to prevent issues saving as JPEG)
+        if img.mode != "RGB":
+            img = img.convert("RGB")
+            
+        # Get dimensions
+        width, height = img.size
+        if max(width, height) > max_dim:
+            # Calculate new dimensions preserving aspect ratio
+            if width > height:
+                new_width = max_dim
+                new_height = int(height * (max_dim / width))
+            else:
+                new_height = max_dim
+                new_width = int(width * (max_dim / height))
+                
+            try:
+                resample_filter = Image.Resampling.LANCZOS
+            except AttributeError:
+                resample_filter = Image.ANTIALIAS
+                
+            img = img.resize((new_width, new_height), resample=resample_filter)
+            
+        # Save as JPEG with good quality
+        img.save(target_path, "JPEG", quality=85)
+        return True
     except Exception as e:
-        print(f"Transcoding failed: {e}. Returning original video.")
-        return input_path
-
-def overlay_masks_on_frame(
-    frame: Image.Image,
-    masks_per_object: dict[int, np.ndarray],
-    color_by_obj: dict[int, tuple[int, int, int]],
-    alpha: float = 0.5,
-) -> Image.Image:
-    """Overlays segmentation masks on a frame with the given alpha transparency."""
-    base = np.array(frame).astype(np.float32) / 255.0
-    height, width = base.shape[:2]
-    overlay = base.copy()
+        # Fallback to direct write if anything goes wrong
+        uploaded_file.seek(0)
+        with open(target_path, "wb") as f:
+            f.write(uploaded_file.getbuffer())
+        return False
 
-    for obj_id, mask in masks_per_object.items():
-        if mask is None:
-            continue
-        if mask.dtype != np.float32:
-            mask = mask.astype(np.float32)
-        if mask.ndim == 3:
-            mask = mask.squeeze()
-        mask = np.clip(mask, 0.0, 1.0)
-        color = np.array(color_by_obj.get(obj_id, (255, 0, 0)), dtype=np.float32) / 255.0
-        a = alpha
-        m = mask[..., None]
-        overlay = (1.0 - a * m) * overlay + (a * m) * color
+if app_mode == "📸 Single Image Pair Mode / وضع فحص صورة مفردة":
+    # Uploaders
+    st.subheader("📸 Upload Images")
+    col1, col2 = st.columns(2)
 
-    out = np.clip(overlay * 255.0, 0, 255).astype(np.uint8)
-    return Image.fromarray(out)
+    with col1:
+        st.markdown("### Original Image (Before)")
+        before_file = st.file_uploader("Upload intact image", type=["jpg", "jpeg", "png"], key="before")
 
-def pastel_color_for_prompt(prompt_text: str) -> tuple[int, int, int]:
-    """Generate a consistent color for a prompt text using a deterministic hash."""
-    char_sum = sum(ord(c) for c in prompt_text)
-    hue = ((char_sum * 2654435761) % 360) / 360.0
-    saturation = 0.5
-    value = 0.95
-    r_f, g_f, b_f = colorsys.hsv_to_rgb(hue, saturation, value)
-    return int(r_f * 255), int(g_f * 255), int(b_f * 255)
+    with col2:
+        st.markdown("### Current Image (After)")
+        after_file = st.file_uploader("Upload damaged image", type=["jpg", "jpeg", "png"], key="after")
 
-# Global caches to avoid reloading the model on every run if the token remains the same
-_cached_model = None
-_cached_processor = None
-_cached_model_id = None
-
-def get_sam3_model_and_processor(model_id="facebook/sam3", hf_token=None):
-    """Loads the SAM 3 model and processor with authentication lazily."""
-    global _cached_model, _cached_processor, _cached_model_id
-    
-    token = hf_token.strip() if (hf_token and hf_token.strip()) else os.environ.get("HF_TOKEN")
-    if token:
-        token = token.strip()
-        
-    if token:
-        try:
-            from huggingface_hub import login
-            login(token=token)
-            print("Logged into Hugging Face Hub successfully.")
-        except Exception as e:
-            raise RuntimeError(f"Hugging Face Hub authentication failed: {e}")
-            
-    if _cached_model is not None and _cached_model_id == model_id:
-        return _cached_model, _cached_processor
+    if before_file and after_file:
+        # Save and optimize uploaded files temporarily
+        os.makedirs("temp", exist_ok=True)
+        before_path = os.path.join("temp", "before_temp.jpg")
+        after_path = os.path.join("temp", "after_temp.jpg")
         
-    try:
-        device = "cuda" if torch.cuda.is_available() else "cpu"
-        dtype = torch.float32 if device == "cpu" else torch.bfloat16
-        
-        print(f"Loading {model_id} on {device}...")
-        processor = Sam3VideoProcessor.from_pretrained(model_id)
-        model = Sam3VideoModel.from_pretrained(model_id, torch_dtype=dtype).to(device).eval()
-        
-        _cached_model = model
-        _cached_processor = processor
-        _cached_model_id = model_id
-        
-        return model, processor
-    except Exception as e:
-        raise RuntimeError(
-            f"Failed to load SAM 3 model '{model_id}': {e}. "
-            "Please ensure you have requested access to the gated model on Hugging Face "
-            "and provided a valid access token in the text box."
-        )
+        save_optimized_image(before_file, before_path)
+        save_optimized_image(after_file, after_path)
 
-def is_different_enough(img1, img2, threshold=0.92):
-    """Detects if two images are visually different enough based on HSV histogram correlation."""
-    # Convert PIL Images to HSV numpy arrays
-    arr1 = cv2.cvtColor(np.array(img1), cv2.COLOR_RGB2HSV)
-    arr2 = cv2.cvtColor(np.array(img2), cv2.COLOR_RGB2HSV)
-    
-    # Calculate histogram
-    hist1 = cv2.calcHist([arr1], [0, 1], None, [30, 32], [0, 180, 0, 256])
-    hist2 = cv2.calcHist([arr2], [0, 1], None, [30, 32], [0, 180, 0, 256])
-    
-    cv2.normalize(hist1, hist1, 0, 1, cv2.NORM_MINMAX)
-    cv2.normalize(hist2, hist2, 0, 1, cv2.NORM_MINMAX)
-    
-    corr = cv2.compareHist(hist1, hist2, cv2.HISTCMP_CORREL)
-    return corr < threshold
+        # Display images side by side
+        c1, c2 = st.columns(2)
+        with c1: st.image(before_path, use_container_width=True)
+        with c2: st.image(after_path, use_container_width=True)
 
-def analyze_video_sam3(video_path, text_prompts, hf_token, max_duration=8.0, progress=gr.Progress()):
-    """
-    Core callback function:
-    1. Loads the video frames.
-    2. Logs into Hugging Face and initializes Sam3VideoModel / Sam3VideoProcessor.
-    3. Runs text prompt object tracking across the frames.
-    4. Overlays masks and labels, and generates the annotated output video.
-    5. Returns the video path and the tracking IDs list.
-    """
-    if not HAS_TRANSFORMERS_SAM3:
-        return None, "# ⚠️ Dependency Error\n\nThe Hugging Face `transformers` library on this system does not support SAM 3. Please upgrade it."
+        st.markdown("---")
         
-    if not video_path:
-        return None, "# ⚠️ Error\nPlease upload a video first."
-        
-    if not text_prompts or not text_prompts.strip():
-        return None, "# ⚠️ Error\nPlease enter at least one text prompt concept to track (e.g. 'chair, couch')."
-        
-    progress(0.05, desc="Authenticating and loading SAM 3 video model...")
-    try:
-        model, processor = get_sam3_model_and_processor(model_id="facebook/sam3", hf_token=hf_token)
-    except Exception as e:
-        return None, f"# ⚠️ Model Loading Error\n\n{e}"
-        
-    progress(0.10, desc="Loading video frames...")
-    cap = cv2.VideoCapture(video_path)
-    if not cap.isOpened():
-        return None, f"# ⚠️ Error\nCould not open video file: {video_path}"
-        
-    orig_fps = cap.get(cv2.CAP_PROP_FPS)
-    total_frames = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
-    width = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
-    height = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
-    
-    orig_fps = orig_fps if orig_fps and orig_fps > 0 else 15.0
-    
-    # Target 12 FPS for smooth output rendering
-    target_fps = 12.0
-    frame_skip = max(1, int(orig_fps / target_fps))
-    fps = orig_fps / frame_skip
-    max_frames = int(max_duration * fps)
-    
-    # Resize resolution to speed up CPU inference dramatically
-    max_dim = 256
-    scale = 1.0
-    if max(height, width) > max_dim:
-        scale = max_dim / max(height, width)
-    new_width = int(width * scale)
-    new_height = int(height * scale)
-    
-    frames = []
-    frame_idx_read = 0
-    while len(frames) < max_frames:
-        ret, frame = cap.read()
-        if not ret:
-            break
-        if frame_idx_read % frame_skip == 0:
-            if scale < 1.0:
-                frame = cv2.resize(frame, (new_width, new_height), interpolation=cv2.INTER_AREA)
-            frame_rgb = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
-            frames.append(Image.fromarray(frame_rgb))
-        frame_idx_read += 1
-    cap.release()
-    
-    if not frames:
-        return None, "# ⚠️ Error\nNo frames could be loaded from the video."
-        
-    # Extract motion-based keyframes to minimize model run times
-    progress(0.12, desc="Extracting keyframes...")
-    keyframes = [frames[0]]
-    keyframe_indices = [0]
-    max_gap = 24  # Force a keyframe at least every 2 seconds (24 frames at 12 FPS)
-    min_gap = 8   # Wait at least 0.66 seconds between keyframes to save CPU time
-    
-    for i in range(1, len(frames)):
-        gap = i - keyframe_indices[-1]
-        if gap >= max_gap:
-            keyframes.append(frames[i])
-            keyframe_indices.append(i)
-        elif gap >= min_gap:
-            if is_different_enough(frames[i], keyframes[-1], threshold=0.94):
-                keyframes.append(frames[i])
-                keyframe_indices.append(i)
+        # Manual mode check
+        manual_phrases = []
+        if provider == "Manual Mode (Skip API)":
+            manual_input = st.text_input("✍️ Enter damage phrases manually (comma-separated, e.g., torn chair, broken table):")
+            if manual_input:
+                manual_phrases = [p.strip() for p in manual_input.split(',')]
+
+        if st.button("🚀 Start Inspection", type="primary"):
+            if provider != "Manual Mode (Skip API)" and not api_key:
+                st.error("❌ Please enter or configure your API Key first.")
+            elif provider == "Manual Mode (Skip API)" and not manual_phrases:
+                st.error("❌ Please enter damage phrases manually.")
+            else:
+                target_phrases_list = []
                 
-    print(f"Total frames: {len(frames)}, Extracted keyframes: {len(keyframes)}")
-    progress(0.13, desc=f"Extracted {len(keyframes)} keyframes from {len(frames)} total frames.")
-        
-    progress(0.15, desc="Initializing SAM 3 video session...")
-    
-    device = "cuda" if torch.cuda.is_available() else "cpu"
-    dtype = torch.float32 if device == "cpu" else torch.bfloat16
-    
-    # Initialize video session with keyframes only
-    session = processor.init_video_session(
-        video=keyframes,
-        inference_device=device,
-        inference_state_device=device,
-        processing_device=device,
-        video_storage_device="cpu",
-        dtype=dtype,
-    )
-    
-    # Parse comma-separated prompt concepts
-    prompt_list = [p.strip() for p in text_prompts.split(",") if p.strip()]
-    session = processor.add_text_prompt(inference_session=session, text=prompt_list)
-    
-    masks_by_frame = defaultdict(dict)
-    color_by_obj = {}
-    obj_to_prompt = {}
-    track_db = defaultdict(set)
-    
-    progress(0.20, desc="Running SAM 3 Vision Encoder on CPU... (This takes 3-5 minutes, please wait)")
-    
-    session = to_device_recursive(session, device)
-    
-    frame_count = len(keyframes)
-    with torch.no_grad():
-        for model_outputs in model.propagate_in_video_iterator(
-            inference_session=session,
-            start_frame_idx=0,
-            max_frame_num_to_track=frame_count,
-        ):
-            processed_outputs = processor.postprocess_outputs(session, model_outputs)
-            k_frame_idx = model_outputs.frame_idx  # index in keyframes list
-            
-            object_ids = processed_outputs["object_ids"]
-            masks = processed_outputs["masks"]
-            prompt_to_obj_ids = processed_outputs.get("prompt_to_obj_ids", {})
-            
-            # Map object IDs to prompt classes
-            for prompt, obj_ids in prompt_to_obj_ids.items():
-                for oid in obj_ids:
-                    oid_int = int(oid)
-                    obj_to_prompt[oid_int] = prompt
-                    track_db[prompt].add(oid_int)
-                    if oid_int not in color_by_obj:
-                        color_by_obj[oid_int] = pastel_color_for_prompt(prompt)
-                        
-            num_objects = len(object_ids)
-            if num_objects > 0:
-                for mask_idx in range(num_objects):
-                    current_obj_id = int(object_ids[mask_idx].item())
-                    mask_2d = masks[mask_idx].float().cpu().numpy()
-                    if mask_2d.ndim == 3:
-                        mask_2d = mask_2d.squeeze()
-                    mask_2d = (mask_2d > 0.0).astype(np.uint8)
-                    masks_by_frame[k_frame_idx][current_obj_id] = mask_2d
+                if provider != "Manual Mode (Skip API)":
+                    with st.spinner("⏳ Analyzing images using AI..."):
+                        try:
+                            if "OpenRouter" in provider:
+                                res = inspect_with_openrouter(before_path, after_path, api_key)
+                            elif "Groq" in provider:
+                                res = inspect_with_groq(before_path, after_path, api_key)
+                            elif "Gemini" in provider:
+                                res = inspect_with_gemini(before_path, after_path, api_key)
+                            elif "OpenAI" in provider:
+                                res = inspect_with_openai(before_path, after_path, api_key)
+                            else:
+                                res = None
+                            
+                            if res:
+                                st.success("✅ Analysis Complete!")
+                                st.markdown("### 📝 Inspection Report:")
+                                st.info(res.get("description", ""))
+                                target_phrases_list = res.get("target_phrases_list", [])
+                                
+                                st.markdown("#### 🎯 Detected Damage for Segmentation:")
+                                for p in target_phrases_list:
+                                    st.markdown(f"- `{p}`")
+                            else:
+                                st.error("❌ Failed to extract report. Check your API key or connection.")
+                        except Exception as e:
+                            st.error(f"❌ Unexpected error: {e}")
+                else:
+                    target_phrases_list = manual_phrases
                     
-            progress(0.20 + 0.60 * ((k_frame_idx + 1) / frame_count), desc=f"Propagating: Keyframe {k_frame_idx + 1}/{frame_count}...")
+                if target_phrases_list:
+                    with st.spinner("🎯 Running Grounded-SAM to precisely locate damage... Please wait..."):
+                        try:
+                            from sam_masker import generate_damage_mask
+                            output_path = os.path.join("temp", "final_result_gui.jpg")
+                            success = generate_damage_mask(after_path, target_phrases_list, output_path)
+                            
+                            if success:
+                                st.markdown("---")
+                                st.subheader("🎉 Final Damage Assessment")
+                                st.image(output_path, use_container_width=True)
+                                
+                                with open(output_path, "rb") as file:
+                                    st.download_button(
+                                        label="💾 Download Final Image",
+                                        data=file,
+                                        file_name="damage_report.jpg",
+                                        mime="image/jpeg"
+                                    )
+                                st.balloons()
+                            else:
+                                st.warning("⚠️ The vision model could not precisely locate the damage.")
+                        except ImportError as e:
+                            st.error(f"❌ Failed to load vision library. Is lang-sam installed? Error: {e}")
+
+else:
+    # Directory-wide Batch Mode
+    st.subheader("📁 Directory-wide Batch Mode / وضع جرد المجلدات بالكامل")
+    st.markdown("Compare all images in a 'Before' folder to find corresponding items in an 'After' folder, run AI inspection, and produce a unified report.")
+
+    col1, col2 = st.columns(2)
+    with col1:
+        before_dir = st.text_input("📁 Before Folder Path / مسار مجلد صور (قبل)", "./before")
+    with col2:
+        after_dir = st.text_input("📁 After Folder Path / مسار مجلد صور (بعد)", "./after")
+
+    # Manual mode check
+    manual_phrases = []
+    if provider == "Manual Mode (Skip API)":
+        manual_input = st.text_input("✍️ Enter damage phrases manually (comma-separated, e.g., torn chair, broken table):", key="batch_manual")
+        if manual_input:
+            manual_phrases = [p.strip() for p in manual_input.split(',')]
+
+    if st.button("🚀 Start Batch Inspection / بدء الفحص الشامل", type="primary", key="start_batch"):
+        if provider != "Manual Mode (Skip API)" and not api_key:
+            st.error("❌ Please enter or configure your API Key first.")
+        elif provider == "Manual Mode (Skip API)" and not manual_phrases:
+            st.error("❌ Please enter damage phrases manually.")
+        elif not os.path.exists(before_dir) or not os.path.exists(after_dir):
+            st.error("❌ One or both directory paths do not exist. Please check the paths.")
+        else:
+            results_for_report = []
+            os.makedirs("temp", exist_ok=True)
             
-    session = to_device_recursive(session, "cpu")
-    
-    progress(0.80, desc="Rendering transparent mask overlays on video...")
-    annotated_frames = []
-    
-    scale_factor = new_height / 720.0
-    font_size = max(10, int(13 * scale_factor))
-    try:
-        font = ImageFont.truetype("arial.ttf", font_size)
-    except Exception:
-        font = ImageFont.load_default()
-        
-    for frame_idx, frame in enumerate(frames):
-        # Find the closest keyframe index
-        closest_k = min(range(len(keyframe_indices)), key=lambda k: abs(keyframe_indices[k] - frame_idx))
-        frame_masks = masks_by_frame.get(closest_k, {})
-        # Overlay masks on frame
-        annotated_img = overlay_masks_on_frame(frame, frame_masks, color_by_obj, alpha=0.55)
-        
-        # Draw labels
-        draw = ImageDraw.Draw(annotated_img)
-        for obj_id, mask in frame_masks.items():
-            if np.any(mask):
-                rows = np.any(mask, axis=1)
-                cols = np.any(mask, axis=0)
-                y_min, y_max = np.where(rows)[0][[0, -1]]
-                x_min, x_max = np.where(cols)[0][[0, -1]]
+            # Instantiate the matcher
+            progress_bar = st.progress(0.0)
+            status_text = st.empty()
+            
+            status_text.text("⏳ Loading DINOv2 models and initializing batch matcher...")
+            try:
+                matcher = InventoryMatcher()
+            except Exception as e:
+                st.error(f"❌ Failed to load matching model: {e}")
+                st.stop()
+                
+            status_text.text("Step 1/3: Matching inventory items via DINOv2 & SIFT...")
+            try:
+                match_results = matcher.run(before_dir, after_dir)
+            except Exception as e:
+                st.error(f"❌ Error during matching: {e}")
+                st.stop()
                 
-                label_x = int(x_min)
-                label_y = max(5, int(y_min) - int(20 * scale_factor))
+            total_items = len(match_results)
+            
+            for idx, item in enumerate(match_results):
+                # Calculate progress fraction
+                progress_val = float(idx + 1) / total_items
+                progress_bar.progress(progress_val)
                 
-                prompt = obj_to_prompt.get(obj_id, "object")
-                label_text = f"#{obj_id} {prompt}"
-                obj_color = color_by_obj.get(obj_id, (255, 255, 255))
+                status = "INTACT"
+                damage_desc = "Intact"
+                target_phrases = []
+                masked_after_path = None
                 
-                padding = max(2, int(4 * scale_factor))
-                bbox = draw.textbbox((label_x, label_y), label_text, font=font)
-                draw.rectangle(
-                    [(bbox[0] - padding, bbox[1] - padding), (bbox[2] + padding, bbox[3] + padding)],
-                    fill=obj_color,
-                    outline=None
-                )
-                draw.text((label_x, label_y), label_text, fill=(255, 255, 255), font=font)
+                if item.found and item.best_match:
+                    status_text.text(f"Checking item [{idx+1}/{total_items}]: {item.before_path.name} -> {item.best_match.name} for damage...")
+                    
+                    res = None
+                    if provider != "Manual Mode (Skip API)":
+                        try:
+                            if "OpenRouter" in provider:
+                                res = inspect_with_openrouter(str(item.before_path), str(item.best_match), api_key)
+                            elif "Groq" in provider:
+                                res = inspect_with_groq(str(item.before_path), str(item.best_match), api_key)
+                            elif "Gemini" in provider:
+                                res = inspect_with_gemini(str(item.before_path), str(item.best_match), api_key)
+                            elif "OpenAI" in provider:
+                                res = inspect_with_openai(str(item.before_path), str(item.best_match), api_key)
+                        except Exception as api_err:
+                            st.warning(f"⚠️ API error for {item.before_path.name}: {api_err}")
+                    else:
+                        # In manual mode, we just pass the manual phrases
+                        res = {
+                            "description": f"Manual inspection checking for: {', '.join(manual_phrases)}",
+                            "target_phrases_list": manual_phrases
+                        }
+                    
+                    if res:
+                        target_phrases = res.get("target_phrases_list", [])
+                        target_phrases = [p.strip() for p in target_phrases if p and p.strip().lower() != "none"]
+                        
+                        if target_phrases:
+                            status = "DAMAGED"
+                            damage_desc = res.get("description", "Damage detected.")
+                            
+                            masked_out_path = os.path.join("temp", f"masked_{item.best_match.name}")
+                            from sam_masker import generate_damage_mask
+                            mask_success = generate_damage_mask(str(item.best_match), target_phrases, masked_out_path)
+                            if mask_success:
+                                masked_after_path = masked_out_path
+                            else:
+                                masked_after_path = None
+                        else:
+                            status = "INTACT"
+                            damage_desc = res.get("description", "Intact. No major damage detected.")
+                    else:
+                        status = "INTACT"
+                        damage_desc = "Intact (inspection skipped/failed)."
+                else:
+                    status_text.text(f"Item [{idx+1}/{total_items}]: {item.before_path.name} is MISSING...")
+                    status = "MISSING"
+                    damage_desc = "Item from before inventory was not found in the after inventory."
+                    
+                results_for_report.append({
+                    'before_path': str(item.before_path),
+                    'after_path': str(item.best_match) if (item.found and item.best_match) else None,
+                    'status': status,
+                    'cls_score': float(item.cls_score),
+                    'patch_score': float(item.patch_score) if item.patch_score else 0.0,
+                    'geo_inliers': int(item.geo_inliers) if item.geo_inliers else 0,
+                    'confidence': item.confidence,
+                    'stage_used': int(item.stage_used),
+                    'damage_description': damage_desc,
+                    'target_phrases_list': target_phrases,
+                    'masked_after_path': masked_after_path
+                })
                 
-        annotated_frames.append(annotated_img)
+            st.session_state.batch_results = results_for_report
+            status_text.success("🎉 Batch Inspection Completed successfully / اكتمل الفحص الشامل بنجاح!")
+            st.balloons()
+
+    # Results dashboard
+    if "batch_results" in st.session_state:
+        st.markdown("---")
+        st.header("📊 Inspection Results / نتائج الفحص")
+        
+        n_total = len(st.session_state.batch_results)
+        n_intact = sum(1 for r in st.session_state.batch_results if r['status'] == 'INTACT')
+        n_damaged = sum(1 for r in st.session_state.batch_results if r['status'] == 'DAMAGED')
+        n_missing = sum(1 for r in st.session_state.batch_results if r['status'] == 'MISSING')
         
-    progress(0.90, desc="Writing video output...")
-    temp_fd, temp_output_path = tempfile.mkstemp(suffix=".mp4")
-    os.close(temp_fd)
-    
-    fourcc = cv2.VideoWriter_fourcc(*'mp4v')
-    out_video = cv2.VideoWriter(temp_output_path, fourcc, fps, (new_width, new_height))
-    
-    for img in annotated_frames:
-        frame_bgr = cv2.cvtColor(np.array(img), cv2.COLOR_RGB2BGR)
-        out_video.write(frame_bgr)
-    out_video.release()
-    
-    progress(0.95, desc="Transcoding video to H.264...")
-    h264_output_path = temp_output_path.replace(".mp4", "_h264.mp4")
-    final_output_path = transcode_to_h264(temp_output_path, h264_output_path)
-    
-    if final_output_path == h264_output_path:
+        col_stat1, col_stat2, col_stat3, col_stat4 = st.columns(4)
+        with col_stat1:
+            st.metric("Total Items / إجمالي العناصر", n_total)
+        with col_stat2:
+            st.metric("Intact / سليم", n_intact)
+        with col_stat3:
+            st.metric("Damaged / تالف", n_damaged)
+        with col_stat4:
+            st.metric("Missing / مفقود", n_missing)
+            
+        # Download Button for the Report
         try:
-            os.remove(temp_output_path)
-        except Exception:
-            pass
+            report_path = generate_combined_report(st.session_state.batch_results, "temp")
+            with open(report_path, "r", encoding="utf-8") as f:
+                html_content = f.read()
             
-    progress(1.0, desc="Done!")
-    
-    # Calculate Max-Visible Count per concept (maximum visible in any single keyframe)
-    max_visible = defaultdict(int)
-    for k_idx in range(len(keyframes)):
-        frame_masks = masks_by_frame.get(k_idx, {})
-        current_visible = defaultdict(int)
-        for obj_id, mask in frame_masks.items():
-            if np.any(mask):
-                prompt = obj_to_prompt.get(obj_id)
-                if prompt:
-                    current_visible[prompt] += 1
-        for prompt, count in current_visible.items():
-            if count > max_visible[prompt]:
-                max_visible[prompt] = count
-                
-    # Generate list report
-    report_md = "# 📋 Apartment Inspection & Counting Report\n\n"
-    report_md += "Below is the comparison between the **Total Tracked IDs** (which can double-count objects if they temporarily go out of view and get assigned a new ID) and the **Max-Visible Count** (which avoids double-counting by finding the peak number of objects visible simultaneously in a single frame):\n\n"
-    
-    # Create a markdown table
-    report_md += "| Category | Unique Tracked IDs | Max-Visible Count | Detailed Tracking IDs |\n"
-    report_md += "| :--- | :---: | :---: | :--- |\n"
-    
-    for prompt in sorted(track_db.keys()):
-        obj_ids = sorted(list(track_db[prompt]))
-        if obj_ids:
-            ids_str = ", ".join(f"`#{oid}`" for oid in obj_ids)
-            tracked_count = len(obj_ids)
-            max_vis = max_visible.get(prompt, 0)
-            category_name = prompt.capitalize()
-            report_md += f"| **{category_name}** | {tracked_count} | **{max_vis}** | {ids_str} |\n"
+            st.download_button(
+                label="💾 Download Combined HTML Report / تحميل التقرير الشامل HTML",
+                data=html_content,
+                file_name="inventory_damage_report.html",
+                mime="text/html",
+                key="download_report"
+            )
+        except Exception as report_err:
+            st.error(f"Error generating report: {report_err}")
             
-    if not track_db:
-        report_md += "\n*No objects detected in the video for the given prompts.*"
+        st.markdown("### Detailed Items / تفاصيل العناصر")
+        filter_status = st.selectbox("Filter by Status / تصفية حس�� الحالة", ["All / الكل", "Intact / سليم", "Damaged / تالف", "Missing / مفقود"], key="filter_status")
         
-    return final_output_path, report_md
-
-# Theme and CSS styling
-theme = gr.themes.Soft(primary_hue="blue", secondary_hue="rose", neutral_hue="slate")
-css = """
-    .container { max-width: 1000px; margin: auto; padding: 20px; }
-    .header { text-align: center; margin-bottom: 30px; }
-    .header h1 { font-size: 2.5rem; font-weight: 800; color: #3B82F6; margin-bottom: 8px; }
-    .header p { font-size: 1.1rem; color: #4B5563; }
-    .analyze-btn { font-size: 1.1rem !important; height: 50px !important; }
-    .report-card { background: rgba(59, 130, 246, 0.04); padding: 25px; border-radius: 12px; border: 1px solid rgba(59, 130, 246, 0.12); }
-"""
-
-# Build the Gradio UI
-with gr.Blocks(title="SAM 3 Video Tracker") as demo:
-    
-    with gr.Column(elem_classes="container"):
-        # Header Section
-        with gr.Column(elem_classes="header"):
-            gr.Markdown("""
-            # 🏠 SAM 3 Concept Video Tracker
-            Automatic object tracking and segmenting using Meta's **Segment Anything 3 (SAM 3)**.
-            """)
-            
-        with gr.Row():
-            with gr.Column():
-                input_video = gr.Video(label="📹 Input Video", format="mp4", interactive=True)
-            with gr.Column():
-                text_prompt_input = gr.Textbox(
-                    label="🏷️ Concepts to Track (comma-separated)",
-                    placeholder="e.g. chair, couch, bed, plant",
-                    value="chair, couch, bed, toilet, sink, plant",
-                    lines=2,
-                    info="Enter the categories you want to track across the video."
-                )
-                
-        with gr.Row():
-            with gr.Column(scale=4):
-                hf_token_textbox = gr.Textbox(
-                    label="🔑 Hugging Face Token (Required for facebook/sam3)",
-                    placeholder="Enter your Hugging Face API Token (e.g. hf_...)",
-                    type="password",
-                    info="Request access at https://huggingface.co/facebook/sam3 first. Your token is never saved."
-                )
-            with gr.Column(scale=2):
-                max_dur_slider = gr.Slider(
-                    minimum=1.0, 
-                    maximum=30.0, 
-                    value=8.0, 
-                    step=1.0, 
-                    label="Max Duration (seconds)",
-                    info="Limit video duration to save memory on CPUs."
-                )
-                
-        with gr.Row():
-            analyze_button = gr.Button("🔍 Run SAM 3 Tracking & Segmentation", variant="primary", elem_classes="analyze-btn")
-                
-        gr.HTML("<hr style='border: 0; height: 1px; background: #E5E7EB; margin: 30px 0;'>")
+        status_map = {
+            "All / الكل": "ALL",
+            "Intact / سليم": "INTACT",
+            "Damaged / تالف": "DAMAGED",
+            "Missing / مفقود": "MISSING"
+        }
         
-        # Outputs Section
-        with gr.Row():
-            with gr.Column():
-                output_video = gr.Video(label="🎨 Tracked output with SAM 3 masks & IDs", interactive=False)
-            with gr.Column():
-                report_output = gr.Markdown(
-                    value="*Upload video, enter concepts, and click the button to view results.*",
-                    elem_classes="report-card"
-                )
+        selected_status = status_map[filter_status]
+        
+        for idx, r in enumerate(st.session_state.batch_results):
+            if selected_status != "ALL" and r['status'] != selected_status:
+                continue
                 
-        # Troubleshooting
-        with gr.Accordion("🧠 Guide & Info", open=True):
-            gr.Markdown(r"""
-            ### 🛠️ How it works:
-            1. **Model:** The application uses `facebook/sam3` (Segment Anything Model 3) via the Hugging Face `transformers` library.
-            2. **Tracking:** You type a list of comma-separated concepts (e.g., `chair, couch`). SAM 3 automatically detects, segments, and tracks instances of these concepts across the video frames using its internal temporal memory, assigning persistent tracking IDs.
-            3. **Requirements:** Since `facebook/sam3` is a gated repository, you must request access at Hugging Face and provide an Access Token in the token textbox.
-            """)
+            status_color = "#10b981" if r['status'] == 'INTACT' else "#f59e0b" if r['status'] == 'DAMAGED' else "#ef4444"
+            status_label = "✅ INTACT / سليم" if r['status'] == 'INTACT' else "⚠️ DAMAGED / تالف" if r['status'] == 'DAMAGED' else "❌ MISSING / مفقود"
             
-        # Footer
-        gr.Markdown("""
-        <div style="text-align: center; margin-top: 50px; color: #9CA3AF; font-size: 0.9rem;">
-        Powered by facebook/sam3 | Hugging Face Transformers | Running locally on CPU
-        </div>
-        """)
-        
-    # Setup actions
-    analyze_button.click(
-        fn=analyze_video_sam3,
-        inputs=[
-            input_video,
-            text_prompt_input,
-            hf_token_textbox,
-            max_dur_slider
-        ],
-        outputs=[
-            output_video,
-            report_output
-        ]
-    )
-
-if __name__ == "__main__":
-    demo.launch(server_name="0.0.0.0", server_port=7860, theme=theme, css=css)
+            with st.container():
+                st.markdown(f"""
+                <div style="border: 1px solid {status_color}; border-radius: 12px; padding: 15px; margin-top: 15px; margin-bottom: 5px; background-color: rgba(255,255,255,0.02);">
+                    <h4 style="margin: 0; color: {status_color};">{status_label}</h4>
+                </div>
+                """, unsafe_allow_html=True)
+                
+                if r['status'] == 'MISSING':
+                    c1, c2 = st.columns([1, 2])
+                    with c1:
+                        st.image(r['before_path'], caption=f"Before: {Path(r['before_path']).name}", use_container_width=True)
+                    with c2:
+                        st.warning(f"🔍 {r['damage_description']}")
+                else:
+                    num_cols = 3 if (r['status'] == 'DAMAGED' and r['masked_after_path']) else 2
+                    cols = st.columns(num_cols)
+                    
+                    with cols[0]:
+                        st.image(r['before_path'], caption=f"Before: {Path(r['before_path']).name}", use_container_width=True)
+                    with cols[1]:
+                        st.image(r['after_path'], caption=f"After: {Path(r['after_path']).name}", use_container_width=True)
+                    if num_cols == 3:
+                        with cols[2]:
+                            st.image(r['masked_after_path'], caption="Grounded-SAM Mask", use_container_width=True)
+                            
+                    st.markdown(f"**Description / الوصف:** {r['damage_description']}")
+                    
+                    st.markdown(f"""
+                    <div style="font-size: 0.85em; color: #888; margin-top: 5px; background-color: rgba(0,0,0,0.1); padding: 5px 10px; border-radius: 5px;">
+                        Match Method: {r['stage_used']} | CLS Score: {r['cls_score']:.3f} | 
+                        Patch Score: {r['patch_score']:.3f} | Geo Inliers: {r['geo_inliers']} | Confidence: {r['confidence']}
+                    </div>
+                    """, unsafe_allow_html=True)

requirements.txt

@@ -1,7 +1,14 @@
-ultralytics>=8.4.21
-gradio>=4.0.0
-opencv-python-headless
-pandas
+streamlit
+python-dotenv
+pillow
 numpy
-timm
-https://github.com/huggingface/transformers/archive/refs/heads/main.zip
+opencv-python
+torch
+torchvision
+transformers
+accelerate
+google-generativeai
+groq
+openai
+huggingface-hub
+rich