Upload 3 files

README.md

@@ -1,13 +1,205 @@
+# EOMT Panoptic Segmentation App
+
+A Gradio-based web application for interactive panoptic segmentation using the **EOMT (Encoder-only Mask Transformer)** model - a minimalist approach that repurposes a plain Vision Transformer (ViT) for image segmentation.
+
+## 🚀 Features
+
+- **Interactive Web Interface**: User-friendly Gradio interface for uploading and processing images
+- **Multiple Visualization Types**:
+  - Segmentation mask with color-coded segments (with error handling for empty masks)
+  - Overlay visualization on original image with transparency control
+  - Contour detection with distinct color coding for each segment
+  - Individual instance masks in grid layout with segment statistics
+  - Edge detection with improved boundary highlighting
+  - Segment isolation showing largest segment with detailed information
+  - Boundary density heatmap with gradient magnitude visualization
+- **Real-time Processing**: Fast inference with CUDA support and proper GPU memory handling
+- **Sample Images**: Built-in sample images with intuitive button selection
+- **Detailed Analytics**: Comprehensive segment statistics and visual analysis
+- **Enhanced Visualizations**: Improved color coding, titles, and statistical information for better analysis
+
+## 🧠 Model
+
+This application uses the **EOMT (Encoder-only Mask Transformer)** model, as presented in the CVPR 2025 highlight paper ["Your ViT is Secretly an Image Segmentation Model"](https://www.tue-mps.org/eomt/):
+
+- **Model ID**: `tue-mps/coco_panoptic_eomt_large_640`
+- **Task**: Panoptic Segmentation
+- **Dataset**: COCO Panoptic
+- **Input Size**: 640x640 (automatically resized)
+- **Architecture**: Plain Vision Transformer (ViT) repurposed for segmentation
+- **Key Innovation**: No adapters, no decoders - just the ViT encoding image patches and segmentation queries as tokens
+- **Performance**: Up to 4× faster than complex methods while maintaining state-of-the-art accuracy
+
+### Research Citation
+```
+@inproceedings{kerssies2025eomt,
+  author     = {Kerssies, Tommie and Cavagnero, Niccol\`{o} and Hermans, Alexander and Norouzi, Narges and Averta, Giuseppe and Leibe, Bastian and Dubbelman, Gijs and de Geus, Daan},
+  title      = {Your ViT is Secretly an Image Segmentation Model},
+  booktitle  = {Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition (CVPR)},
+  year       = {2025},
+}
+```
+
+🔗 **Research Website**: [https://www.tue-mps.org/eomt/](https://www.tue-mps.org/eomt/)
+
+## 🛠️ Installation
+
+1. **Clone the repository** (if not already done):
+   ```bash
+   git clone https://github.com/athrael.soju/little-scripts.git
+   cd little-scripts/eomt_panoptic_seg
+   ```
+
+2. **Install dependencies**:
+
+   **For standard setup:**
+   ```bash
+   uv pip install -r requirements.txt
+   ```
+
+   **For newer NVIDIA GPUs (e.g., RTX 5090):**
+   ```bash
+   # Install PyTorch nightly for latest CUDA support
+   uv pip install --pre torch torchvision torchaudio --index-url https://download.pytorch.org/whl/nightly/cu128
+
+   # Then install remaining dependencies
+   uv pip install -r requirements.txt
+   ```
+
+3. **Run the application**:
+   ```bash
+   python app.py
+   ```
+
+## 📋 Requirements
+
+- Python 3.10+
+- CUDA-compatible GPU (recommended for faster inference)
+- Minimum 4GB RAM
+- Internet connection (for first-time model download)
+- `uv` package manager (optional, for newer GPU support)
+
+### Dependencies
+- **PyTorch**: Latest stable version (or nightly for newer GPUs like RTX 5090)
+- **Transformers**: Latest development version from GitHub
+- **Gradio**: For the web interface
+- **OpenCV**: For image processing and contour detection
+- **Matplotlib**: For visualization
+- **NumPy & PIL**: For image handling
+- **SciPy**: For advanced image processing operations
+
+## 🎯 Usage
+
+1. **Start the application**:
+   ```bash
+   python app.py
+   ```
+
+2. **Open your browser** and navigate to the provided URL (usually `http://localhost:7860`)
+
+3. **Upload an image** or select from sample images using the clickable buttons
+
+4. **Choose visualization type**:
+   - **Mask**: Color-coded segmentation mask with error handling for empty results
+   - **Overlay**: Transparent mask overlay on original image with optimized transparency
+   - **Contours**: Segment boundaries with distinct colors for each segment
+   - **Instance Masks**: Individual instance masks in a 3×3 grid showing segment IDs and pixel counts
+   - **Edge Detection**: Improved boundary highlighting with RGBA overlay technique
+   - **Segment Isolation**: Largest segment isolated with detailed statistics
+   - **Heatmap**: Boundary density visualization with gradient magnitude and proper labeling
+
+5. **View results** with interactive segment analysis and high-quality visualizations
+
+## 🔧 Configuration
+
+The application automatically downloads the EOMT model on first run. Model files are cached locally by Hugging Face Transformers.
+
+### Model Configuration
+- **Model**: `tue-mps/coco_panoptic_eomt_large_640`
+- **Image Processor**: Auto-configured for the model
+- **Inference Mode**: PyTorch inference mode for optimal performance
+- **CUDA Support**: Automatic GPU detection and proper tensor handling
+
+## 📊 Features Detail
+
+### Visualization Types
+
+1. **Mask View**: Clean segmentation mask with color-coded segments using matplotlib's tab20 colormap, includes error handling for empty masks
+2. **Overlay View**: Weighted combination of original image and segmentation mask with optimized transparency
+3. **Contours View**: Precise segment boundaries with distinct colors for each segment using OpenCV and matplotlib colormaps
+4. **Instance Masks View**: Grid layout showing individual segments with segment IDs and pixel counts for detailed inspection
+5. **Edge Detection View**: Enhanced boundary detection using RGBA overlay technique with Canny edge detection
+6. **Segment Isolation View**: Focus on the largest segment with detailed statistics (segment ID and pixel count)
+7. **Heatmap View**: Boundary density analysis with gradient magnitude visualization and proper colorbar labeling
+
+### Interactive Features
+
+- **Sample Images**: Pre-loaded COCO dataset images with large clickable thumbnails
+- **Upload Support**: Drag-and-drop or click to upload custom images
+- **Real-time Processing**: Fast inference with proper GPU memory management
+- **High-Quality Output**: All visualizations rendered at 150 DPI for crisp results
+- **Enhanced Information**: Detailed segment statistics, pixel counts, and gradient analysis
+
+## 🎨 Visualization Examples
+
+The application provides multiple ways to visualize panoptic segmentation results:
+
+- **Color-coded segments** using matplotlib's tab20 colormap for clear differentiation
+- **Statistical analysis** showing segment distribution and coverage metrics
+- **Contour detection** with OpenCV for precise boundary identification
+- **Overlay techniques** with adjustable transparency for better visual understanding
+- **Heatmap analysis** for boundary density and gradient visualization
+- **Individual segment isolation** for detailed examination
+
+## 🚨 Troubleshooting
+
+### Common Issues
+
+1. **CUDA Tensor Errors**:
+   - The app automatically handles CUDA tensor to CPU conversion with robust error handling
+   - Ensure proper PyTorch installation with CUDA support
+   - Check GPU memory availability
+
+2. **Model Download Issues**:
+   - Ensure stable internet connection
+   - Check Hugging Face Hub access
+   - Verify sufficient disk space
+
+3. **Memory Issues**:
+   - Reduce image size before upload
+   - Close other applications
+   - Consider using CPU inference for large images
+
+4. **Performance Issues**:
+   - Use GPU if available
+   - Reduce image resolution
+   - Check system resources
+
+5. **PyTorch Installation Issues**:
+   - For newer GPUs (RTX 5090, etc.), use PyTorch nightly builds
+   - Install `uv` for better package management: `pip install uv`
+   - Check CUDA compatibility with your GPU
+   - Verify transformers installation from GitHub source
+
+## 📁 Project Structure
+
+```
+eomt_panoptic_seg/
+├── app.py                 # Main application file
+├── requirements.txt       # Python dependencies
+└── README.md              # This file
+```
+
+## 📄 License
+
+Open source - feel free to use and modify as needed.
+
+## 🤝 Contributing
+
+Contributions are welcome! Please feel free to submit a Pull Request.
+
 ---
-title: Eomt
-emoji: 😻
-colorFrom: red
-colorTo: yellow
-sdk: gradio
-sdk_version: 5.35.0
-app_file: app.py
-pinned: false
-license: mit
----
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+**Note**: This application requires a GPU for optimal performance. CPU inference is supported but will be significantly slower. For newer NVIDIA GPUs, use PyTorch nightly builds for best compatibility. The app includes proper CUDA tensor handling to prevent memory-related errors.
+
+**Research**: This implementation is based on the CVPR 2025 paper ["Your ViT is Secretly an Image Segmentation Model"](https://www.tue-mps.org/eomt/) by Kerssies et al., demonstrating that plain Vision Transformers can achieve state-of-the-art segmentation performance.

app.py

@@ -0,0 +1,543 @@
+import io
+
+import cv2
+import gradio as gr
+import matplotlib.pyplot as plt
+import numpy as np
+import requests
+import torch
+from PIL import Image
+from transformers import AutoImageProcessor, EomtForUniversalSegmentation
+
+# Load model globally to avoid reloading
+print("Loading model...")
+model_id = "tue-mps/coco_panoptic_eomt_large_640"
+processor = AutoImageProcessor.from_pretrained(model_id)
+model = EomtForUniversalSegmentation.from_pretrained(model_id)
+
+# Check for CUDA availability and move model to GPU if available
+device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+model = model.to(device)
+print(f"Model loaded successfully on {device}!")
+
+
+def run_inference(image):
+    """Run panoptic segmentation inference"""
+    inputs = processor(images=image, return_tensors="pt")
+
+    # Move inputs to the same device as model
+    inputs = {k: v.to(device) for k, v in inputs.items()}
+
+    with torch.inference_mode():
+        outputs = model(**inputs)
+
+    target_sizes = [(image.height, image.width)]
+    preds = processor.post_process_panoptic_segmentation(
+        outputs, target_sizes=target_sizes
+    )
+
+    return preds[0]
+
+
+def tensor_to_numpy(tensor):
+    """Convert tensor to numpy array, handling CUDA tensors"""
+    if isinstance(tensor, torch.Tensor):
+        return tensor.cpu().numpy()
+    return tensor
+
+
+def visualize_mask(image, segmentation_mask):
+    """Show segmentation mask only"""
+    fig, ax = plt.subplots(1, 1, figsize=(12, 8))
+
+    # Segmentation mask - convert tensor to numpy
+    mask_np = tensor_to_numpy(segmentation_mask)
+
+    if mask_np.max() > 0:
+        ax.imshow(mask_np, cmap="tab20")
+    else:
+        # If no segments, show a blank image with text
+        ax.imshow(np.zeros_like(mask_np), cmap="gray")
+        ax.text(
+            0.5,
+            0.5,
+            "No segments detected",
+            transform=ax.transAxes,
+            ha="center",
+            va="center",
+            fontsize=16,
+            color="red",
+            weight="bold",
+        )
+
+    ax.axis("off")
+
+    plt.tight_layout()
+
+    # Convert to PIL Image
+    buf = io.BytesIO()
+    plt.savefig(buf, format="png", bbox_inches="tight", dpi=150)
+    buf.seek(0)
+    plt.close()
+
+    return Image.open(buf)
+
+
+def visualize_overlay(image, segmentation_mask):
+    """Show segmentation overlay on original image"""
+    fig, ax = plt.subplots(1, 1, figsize=(12, 8))
+
+    # Original image
+    ax.imshow(image)
+
+    # Overlay segmentation mask with transparency
+    mask_np = tensor_to_numpy(segmentation_mask)
+    ax.imshow(mask_np, cmap="tab20", alpha=0.6)
+
+    ax.axis("off")
+
+    plt.tight_layout()
+
+    # Convert to PIL Image
+    buf = io.BytesIO()
+    plt.savefig(buf, format="png", bbox_inches="tight", dpi=150)
+    buf.seek(0)
+    plt.close()
+
+    return Image.open(buf)
+
+
+def visualize_contours(image, segmentation_mask):
+    """Show contours of segments on original image"""
+    fig, ax = plt.subplots(1, 1, figsize=(12, 8))
+
+    # Original image
+    ax.imshow(image)
+
+    # Convert mask to numpy and find contours
+    mask_np = tensor_to_numpy(segmentation_mask).astype(np.uint8)
+
+    # Find unique segments
+    unique_segments = np.unique(mask_np)
+
+    # Create a colormap for distinct colors
+    colors = plt.cm.tab20(np.linspace(0, 1, len(unique_segments)))
+
+    # Draw contours for each segment
+    for i, segment_id in enumerate(unique_segments):
+        if segment_id == 0:  # Skip background
+            continue
+
+        # Create binary mask for this segment
+        binary_mask = (mask_np == segment_id).astype(np.uint8)
+
+        # Find contours
+        contours, _ = cv2.findContours(
+            binary_mask, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE
+        )
+
+        # Draw contours with unique color for each segment
+        for contour in contours:
+            if len(contour) > 2:  # Only draw if contour has enough points
+                contour = contour.reshape(-1, 2)
+                ax.plot(
+                    contour[:, 0],
+                    contour[:, 1],
+                    color=colors[i % len(colors)],
+                    linewidth=2,
+                    alpha=0.8,
+                )
+
+    ax.axis("off")
+
+    plt.tight_layout()
+
+    # Convert to PIL Image
+    buf = io.BytesIO()
+    plt.savefig(buf, format="png", bbox_inches="tight", dpi=150)
+    buf.seek(0)
+    plt.close()
+
+    return Image.open(buf)
+
+
+def visualize_instance_masks(image, segmentation_mask):
+    """Show individual instance masks in a grid"""
+    mask_np = tensor_to_numpy(segmentation_mask)
+    unique_segments, counts = np.unique(mask_np, return_counts=True)
+
+    # Get top 9 segments by size (excluding background)
+    non_bg_indices = unique_segments != 0
+    if np.any(non_bg_indices):
+        top_segments = unique_segments[non_bg_indices][
+            np.argsort(counts[non_bg_indices])[-9:]
+        ]
+        top_counts = counts[non_bg_indices][np.argsort(counts[non_bg_indices])[-9:]]
+    else:
+        top_segments = []
+        top_counts = []
+
+    fig, axes = plt.subplots(3, 3, figsize=(15, 15))
+    axes = axes.flatten()
+
+    for i, (segment_id, count) in enumerate(zip(top_segments, top_counts)):
+        binary_mask = (mask_np == segment_id).astype(float)
+        axes[i].imshow(binary_mask, cmap="Blues")
+        axes[i].set_title(
+            f"Segment {segment_id}\nPixels: {count}", fontsize=10, weight="bold"
+        )
+        axes[i].axis("off")
+
+    # Fill empty subplots with informative text
+    for i in range(len(top_segments), 9):
+        axes[i].axis("off")
+        if i == 0 and len(top_segments) == 0:
+            axes[i].text(
+                0.5,
+                0.5,
+                "No segments\ndetected",
+                transform=axes[i].transAxes,
+                ha="center",
+                va="center",
+                fontsize=12,
+                color="red",
+                weight="bold",
+            )
+
+    plt.tight_layout()
+
+    # Convert to PIL Image
+    buf = io.BytesIO()
+    plt.savefig(buf, format="png", bbox_inches="tight", dpi=150)
+    buf.seek(0)
+    plt.close()
+
+    return Image.open(buf)
+
+
+def visualize_edges(image, segmentation_mask):
+    """Show edge detection on segmentation boundaries"""
+    mask_np = tensor_to_numpy(segmentation_mask)
+
+    fig, ax = plt.subplots(1, 1, figsize=(12, 8))
+
+    # Original image
+    ax.imshow(image)
+
+    # Edge detection on mask
+    if mask_np.max() > 0:  # Check if mask has any segments
+        edges = cv2.Canny((mask_np * 255 / mask_np.max()).astype(np.uint8), 50, 150)
+
+        # Create a colored edge overlay
+        edge_overlay = np.zeros((*edges.shape, 4))  # RGBA
+        edge_overlay[edges > 0] = [1, 1, 0, 1]  # Yellow with full alpha
+
+        # Overlay edges
+        ax.imshow(edge_overlay)
+    else:
+        # If no segments, just show the original image
+        ax.text(
+            0.5,
+            0.5,
+            "No segments detected",
+            transform=ax.transAxes,
+            ha="center",
+            va="center",
+            fontsize=16,
+            color="red",
+            weight="bold",
+        )
+
+    ax.axis("off")
+
+    plt.tight_layout()
+
+    # Convert to PIL Image
+    buf = io.BytesIO()
+    plt.savefig(buf, format="png", bbox_inches="tight", dpi=150)
+    buf.seek(0)
+    plt.close()
+
+    return Image.open(buf)
+
+
+def visualize_segment_isolation(image, segmentation_mask):
+    """Show the largest segment isolated from the rest"""
+    mask_np = tensor_to_numpy(segmentation_mask)
+    unique_segments, counts = np.unique(mask_np, return_counts=True)
+
+    # Find largest segment (excluding background)
+    non_bg_indices = unique_segments != 0
+    if np.any(non_bg_indices):
+        largest_segment = unique_segments[non_bg_indices][
+            np.argmax(counts[non_bg_indices])
+        ]
+        largest_count = counts[non_bg_indices][np.argmax(counts[non_bg_indices])]
+    else:
+        largest_segment = unique_segments[np.argmax(counts)]
+        largest_count = counts[np.argmax(counts)]
+
+    fig, ax = plt.subplots(1, 1, figsize=(12, 8))
+
+    # Isolated segment
+    isolated_mask = (mask_np == largest_segment).astype(float)
+
+    if isolated_mask.max() > 0:
+        ax.imshow(isolated_mask, cmap="Reds")
+        ax.set_title(
+            f"Largest Segment (ID: {largest_segment}, Pixels: {largest_count})",
+            fontsize=14,
+            weight="bold",
+            pad=20,
+        )
+    else:
+        ax.imshow(np.zeros_like(isolated_mask), cmap="gray")
+        ax.text(
+            0.5,
+            0.5,
+            "No segments detected",
+            transform=ax.transAxes,
+            ha="center",
+            va="center",
+            fontsize=16,
+            color="red",
+            weight="bold",
+        )
+
+    ax.axis("off")
+
+    plt.tight_layout()
+
+    # Convert to PIL Image
+    buf = io.BytesIO()
+    plt.savefig(buf, format="png", bbox_inches="tight", dpi=150)
+    buf.seek(0)
+    plt.close()
+
+    return Image.open(buf)
+
+
+def visualize_heatmap(image, segmentation_mask):
+    """Show boundary density heatmap"""
+    mask_np = tensor_to_numpy(segmentation_mask)
+
+    fig, ax = plt.subplots(1, 1, figsize=(12, 8))
+
+    if mask_np.max() > 0:
+        # Calculate gradient magnitude for boundary detection
+        gradient_magnitude = np.gradient(mask_np.astype(float))
+        gradient_magnitude = np.sqrt(
+            gradient_magnitude[0] ** 2 + gradient_magnitude[1] ** 2
+        )
+
+        # Boundary heatmap
+        im = ax.imshow(gradient_magnitude, cmap="hot")
+        ax.set_title("Boundary Density Heatmap", fontsize=14, weight="bold", pad=20)
+        ax.axis("off")
+        plt.colorbar(im, ax=ax, fraction=0.046, pad=0.04, label="Gradient Magnitude")
+    else:
+        # If no segments, show a blank heatmap
+        ax.imshow(np.zeros_like(mask_np), cmap="hot")
+        ax.text(
+            0.5,
+            0.5,
+            "No segments detected",
+            transform=ax.transAxes,
+            ha="center",
+            va="center",
+            fontsize=16,
+            color="red",
+            weight="bold",
+        )
+        ax.axis("off")
+
+    plt.tight_layout()
+
+    # Convert to PIL Image
+    buf = io.BytesIO()
+    plt.savefig(buf, format="png", bbox_inches="tight", dpi=150)
+    buf.seek(0)
+    plt.close()
+
+    return Image.open(buf)
+
+
+def create_visualization(image, viz_type):
+    """Create visualization based on selected type"""
+    if image is None:
+        return None
+
+    try:
+        # Run inference
+        prediction = run_inference(image)
+        segmentation_mask = prediction["segmentation"]
+
+        if viz_type == "Mask":
+            return visualize_mask(image, segmentation_mask)
+        elif viz_type == "Overlay":
+            return visualize_overlay(image, segmentation_mask)
+        elif viz_type == "Contours":
+            return visualize_contours(image, segmentation_mask)
+        elif viz_type == "Instance Masks":
+            return visualize_instance_masks(image, segmentation_mask)
+        elif viz_type == "Edge Detection":
+            return visualize_edges(image, segmentation_mask)
+        elif viz_type == "Segment Isolation":
+            return visualize_segment_isolation(image, segmentation_mask)
+        elif viz_type == "Heatmap":
+            return visualize_heatmap(image, segmentation_mask)
+        else:
+            # Default fallback
+            return visualize_mask(image, segmentation_mask)
+
+    except Exception as e:
+        print(f"Error in visualization: {e}")
+        # Return a simple error visualization
+        fig, ax = plt.subplots(1, 1, figsize=(12, 8))
+        ax.text(
+            0.5,
+            0.5,
+            f"Error during processing:\n{str(e)}",
+            transform=ax.transAxes,
+            ha="center",
+            va="center",
+            fontsize=12,
+            color="red",
+            weight="bold",
+        )
+        ax.axis("off")
+
+        buf = io.BytesIO()
+        plt.savefig(buf, format="png", bbox_inches="tight", dpi=150)
+        buf.seek(0)
+        plt.close()
+
+        return Image.open(buf)
+
+
+def load_sample_image(img_path):
+    """Load a sample image from URL"""
+    try:
+        response = requests.get(img_path, stream=True)
+        response.raise_for_status()
+        return Image.open(response.raw)
+    except Exception as e:
+        print(f"Error loading image: {e}")
+        return None
+
+
+# Create Gradio interface
+def create_interface():
+    with gr.Blocks(
+        title="Panoptic Segmentation Visualizer", theme=gr.themes.Soft()
+    ) as demo:
+        gr.Markdown("""
+        # 🎨 Panoptic Segmentation Visualizer
+
+        Upload an image and select a visualization type to see different ways of viewing the panoptic segmentation results.
+        The model used is `tue-mps/coco_panoptic_eomt_large_640`.
+        """)
+
+        with gr.Row():
+            with gr.Column(scale=1):
+                image_input = gr.Image(label="Upload Image", type="pil", height=400)
+
+                viz_type = gr.Radio(
+                    choices=[
+                        "Mask",
+                        "Overlay",
+                        "Contours",
+                        "Instance Masks",
+                        "Edge Detection",
+                        "Segment Isolation",
+                        "Heatmap",
+                    ],
+                    label="Visualization Type",
+                    value="Mask",
+                    info="Choose how to visualize the segmentation results",
+                )
+
+                process_btn = gr.Button(
+                    "🚀 Process Image", variant="primary", size="lg"
+                )
+
+                gr.Markdown("""
+                ### Visualization Types:
+                - **Mask**: Segmentation mask with color-coded segments
+                - **Overlay**: Transparent segmentation overlay on original image
+                - **Contours**: Segment boundaries outlined on original image
+                - **Instance Masks**: Individual instance masks in a grid (top 9 by size)
+                - **Edge Detection**: Segmentation boundaries highlighted in yellow
+                - **Segment Isolation**: Shows the largest segment isolated from the rest
+                - **Heatmap**: Boundary density visualization with color mapping
+                """)
+
+            with gr.Column(scale=2):
+                output_image = gr.Image(
+                    label="Segmentation Result", type="pil", height=600
+                )
+
+        process_btn.click(
+            fn=create_visualization,
+            inputs=[image_input, viz_type],
+            outputs=output_image,
+        )
+
+        # Sample images with thumbnails
+        gr.Markdown("### 📸 Try with sample images:")
+
+        sample_images = [
+            ("http://images.cocodataset.org/val2017/000000039769.jpg", "Cats on Couch"),
+            ("http://images.cocodataset.org/val2017/000000397133.jpg", "Street Scene"),
+            ("http://images.cocodataset.org/val2017/000000037777.jpg", "Living Room"),
+            (
+                "http://images.cocodataset.org/val2017/000000174482.jpg",
+                "Person with Laptop",
+            ),
+            ("http://images.cocodataset.org/val2017/000000000785.jpg", "Dining Table"),
+        ]
+
+        def create_thumbnail_gallery():
+            """Create a gallery of clickable thumbnails"""
+            gallery_images = []
+            for img_url, img_name in sample_images:
+                try:
+                    img = load_sample_image(img_url)
+                    if img:
+                        # Resize to thumbnail while maintaining aspect ratio
+                        img.thumbnail((200, 200), Image.Resampling.LANCZOS)
+                        gallery_images.append((img, img_name))
+                except Exception as e:
+                    print(f"Failed to load {img_name}: {e}")
+                    continue
+            return gallery_images
+
+        with gr.Row():
+            thumbnail_gallery = gr.Gallery(
+                value=create_thumbnail_gallery(),
+                label="Sample Images",
+                show_label=True,
+                elem_id="thumbnail_gallery",
+                columns=5,
+                rows=1,
+                object_fit="contain",
+                height=200,
+                allow_preview=False,
+            )
+
+        def select_from_gallery(evt: gr.SelectData):
+            """Handle gallery selection"""
+            selected_idx = evt.index
+            if selected_idx < len(sample_images):
+                img_url, _ = sample_images[selected_idx]
+                return load_sample_image(img_url)
+            return None
+
+        thumbnail_gallery.select(select_from_gallery, outputs=image_input)
+
+    return demo
+
+
+if __name__ == "__main__":
+    demo = create_interface()
+    demo.launch(share=True, server_name="0.0.0.0", server_port=7860)

requirements.txt

@@ -0,0 +1,21 @@
+# Core ML and Computer Vision
+# torch # For newer Nvidia GPUs (e.g. RTX 5090) use uv pip install --pre torch torchvision torchaudio --index-url https://download.pytorch.org/whl/nightly/cu128
+# torchvision
+
+git+https://github.com/huggingface/transformers.git
+pillow
+numpy
+opencv-python
+scipy
+
+# Gradio web interface
+gradio
+
+# Visualization
+matplotlib
+
+# HTTP requests
+requests
+
+# Pre-trained model
+# This will download the model: tue-mps/coco_panoptic_eomt_large_640