Sync from GitHub

.huggingface.yaml

@@ -0,0 +1,7 @@
+sdk: gradio
+python_version: 3.11
+app_file: app.py
+title: Object Detection App
+subtitle: Real-time object detection in images using Gradio
+hardware: cpu-basic
+license: mit

README.md

@@ -1,128 +1,209 @@
+# 🚀 Object Detection with Transformer Models
 
-# Transformer-Based Object Detection
+This project provides a robust object detection system leveraging state-of-the-art transformer models, including **DETR (DEtection TRansformer)** and **YOLOS (You Only Look One-level Series)**. The system supports object detection and panoptic segmentation from uploaded images or image URLs. It features a user-friendly **Gradio** web interface for interactive use and a **FastAPI** endpoint for programmatic access.
 
-This project implements an **object detection system** powered by state-of-the-art **transformer models**, including **DETR** (DEtection TRansformer) and **YOLOS** (You Only Look One-level Series). The system supports object detection from both uploaded images and image URLs. It comes with a user-friendly **Gradio web interface** and a **FastAPI API** for automated processing.
+Try the online demo on Hugging Face Spaces: [Object Detection Demo](https://huggingface.co/spaces/JaishnaCodz/ObjectDetection).
 
-Try the demo on Hugging Face: \[**Demo Link**].
+## Models Supported
 
-## Supported Models
+The application supports the following models, each tailored for specific detection or segmentation tasks:
 
-Here’s a list of the available models for different detection and segmentation tasks:
+- **DETR (DEtection TRansformer)**:
+  - `facebook/detr-resnet-50`: Fast and accurate object detection with a ResNet-50 backbone.
+  - `facebook/detr-resnet-101`: Higher accuracy object detection with a ResNet-101 backbone, slower than ResNet-50.
+  - `facebook/detr-resnet-50-panoptic`: Panoptic segmentation with ResNet-50 (note: may have stability issues).
+  - `facebook/detr-resnet-101-panoptic`: Panoptic segmentation with ResNet-101 (note: may have stability issues).
+  
+- **YOLOS (You Only Look One-level Series)**:
+  - `hustvl/yolos-tiny`: Lightweight and fast, ideal for resource-constrained environments.
+  - `hustvl/yolos-base`: Balances speed and accuracy for object detection.
 
-### **DETR (DEtection TRansformer)**:
+## Features
 
-* **facebook/detr-resnet-50**: Fast and efficient object detection.
-* **facebook/detr-resnet-101**: More accurate, but slower than ResNet-50.
-* **facebook/detr-resnet-50-panoptic** *(currently has bugs)*: For panoptic segmentation. Detects and segments scenes.
-* **facebook/detr-resnet-101-panoptic** *(currently has bugs)*: High-accuracy segmentation for complex scenes.
+- **Image Upload**: Upload images via the Gradio interface for object detection.
+- **URL Input**: Provide image URLs for detection through the Gradio interface or API.
+- **Model Selection**: Choose between DETR and YOLOS models for detection or panoptic segmentation.
+- **Object Detection**: Highlights detected objects with bounding boxes and confidence scores.
+- **Panoptic Segmentation**: Supports scene segmentation with colored masks (DETR panoptic models).
+- **Image Properties**: Displays metadata like format, size, aspect ratio, file size, and color statistics.
+- **API Access**: Programmatically process images via the FastAPI `/detect` endpoint.
+- **Flexible Deployment**: Run locally, in Docker, or in cloud environments like Google Colab.
 
-### **YOLOS (You Only Look One-level Series)**:
+## How to Use
 
-* **hustvl/yolos-tiny**: Lightweight and quick. Ideal for environments with limited resources.
-* **hustvl/yolos-base**: Strikes a balance between speed and accuracy.
+### 1. **Local Setup (Git Clone)**
 
-## Key Features
+Follow these steps to set up the application locally:
 
-* **Image Upload**: Upload an image from your device to run detection via the Gradio interface.
-* **URL Input**: Input an image URL for detection through Gradio or the FastAPI.
-* **Model Selection**: Choose between DETR and YOLOS models for object detection or segmentation.
-* **Object Detection**: Detects objects and shows bounding boxes with confidence scores.
-* **Panoptic Segmentation**: Available with certain models for detailed scene segmentation using colored masks.
-* **Image Info**: Displays metadata such as size, format, aspect ratio, and file size.
-* **API Access**: Use the FastAPI `/detect` endpoint for programmatic processing.
+#### Prerequisites
 
-## How to Get Started
+- Python 3.8 or higher
+- `pip` for installing dependencies
+- Git for cloning the repository
 
-### 1. **Cloning the Repository**
+#### Clone the Repository
 
-#### Prerequisites:
+```bash
+git clone https://github.com/JaishnaCodz/ObjectDetection
+cd ObjectDetection
+```
 
-* Python 3.8 or higher
-* `pip` to install dependencies
+#### Install Dependencies
 
-#### Clone and Set Up:
+Install required packages from `requirements.txt`:
 
 ```bash
-git clone https://github.com/NeerajCodz/ObjectDetection.git
-cd ObjectDetection
 pip install -r requirements.txt
 ```
 
-#### Run the Application:
+#### Run the Application
 
-* **FastAPI**: Start the server with:
+Launch the Gradio interface:
 
 ```bash
-uvicorn objectdetection:app --reload
+python app.py
 ```
 
-* **Gradio Interface**: Launch with:
+To enable the FastAPI server:
 
 ```bash
-python app.py
+python app.py --enable-fastapi
 ```
 
-#### Access the Application:
+#### Access the Application
 
-* **FastAPI**: Navigate to `http://localhost:8000` to interact with the API or view the Swagger UI.
-* **Gradio**: The Gradio interface will be available at `http://127.0.0.1:7860` (URL will show up in the console).
+- **Gradio**: Open the URL displayed in the console (typically `http://127.0.0.1:7860`).
+- **FastAPI**: Navigate to `http://localhost:8000` for the API or Swagger UI (if enabled).
 
-### 2. **Running via Docker**
+### 2. **Running with Docker**
 
-#### Prerequisites:
+Use Docker for a containerized setup.
 
-* Install Docker on your machine (if you haven’t already).
+#### Prerequisites
 
-#### Set Up with Docker:
+- Docker installed on your machine. Download from [Docker's official site](https://www.docker.com/get-started).
 
-1. Clone the repository (if you haven’t):
+#### Pull the Docker Image
+
+Pull the pre-built image from Docker Hub:
 
 ```bash
-git clone https://github.com/NeerajCodz/ObjectDetection.git
-cd ObjectDetection
+docker pull JaishnaCodz/objectdetection:latest
 ```
 
-2. Build the Docker image:
+#### Run the Docker Container
+
+Run the application on port 8080:
+
+```bash
+docker run -d -p 8080:80 JaishnaCodz/objectdetection:latest
+```
+
+Access the interface at `http://localhost:8080`.
+
+#### Build and Run the Docker Image
+
+To build the Docker image locally:
+
+1. Ensure you have a `Dockerfile` in the repository root (example provided in the repository).
+2. Build the image:
 
 ```bash
-docker build -t objectdetection:latest .
+docker build -t objectdetection:local .
 ```
 
 3. Run the container:
 
 ```bash
-docker run -p 5000:5000 objectdetection:latest
+docker run -d -p 8080:80 objectdetection:local
 ```
 
-Access the app at `http://localhost:5000`.
+Access the interface at `http://localhost:8080`.
 
-### 3. **Try the Online Demo**
+### 3. **Demo**
 
-Test the demo directly on Hugging Face’s Spaces:
-[**Object Detection Demo**](https://huggingface.co/spaces/NeerajCodz/ObjectDetection)
+Try the demo on Hugging Face Spaces:
 
-## API Usage
+[Object Detection Demo](https://huggingface.co/spaces/JaishnaCodz/ObjectDetection)
 
-Use the `/detect` endpoint in FastAPI for image processing.
+## Command-Line Arguments
 
-### **POST** `/detect`
+The `app.py` script supports the following command-line arguments:
 
-Parameters:
+- `--gradio-port <port>`: Specify the port for the Gradio UI (default: 7860).
+  - Example: `python app.py --gradio-port 7870`
+- `--enable-fastapi`: Enable the FastAPI server (disabled by default).
+  - Example: `python app.py --enable-fastapi`
+- `--fastapi-port <port>`: Specify the port for the FastAPI server (default: 8000).
+  - Example: `python app.py --enable-fastapi --fastapi-port 8001`
+- `--confidence-threshold <float-value)`: Confidence threshold for detection (Range: 0 - 1) (default: 8000).
+  - Example: `python app.py --confidence-threshold 0.75`
 
-* **file** *(optional)*: Image file (must be of type image/\*).
-* **image\_url** *(optional)*: URL of the image.
-* **model\_name** *(optional)*: Choose the model (e.g., `facebook/detr-resnet-50`, `hustvl/yolos-tiny`, etc.).
+You can combine arguments:
 
-Example Request Body:
+```bash
+python app.py --gradio-port 7870 --enable-fastapi --fastapi-port 8001 --confidence-threshold 0.75
+```
 
-```json
-{
-  "image_url": "https://example.com/image.jpg",
-  "model_name": "facebook/detr-resnet-50"
-}
+Alternatively, set the `GRADIO_SERVER_PORT` environment variable:
+
+```bash
+export GRADIO_SERVER_PORT=7870
+python app.py
 ```
 
-Example Response:
+## Using the API
+
+**Note**: The FastAPI API is currently unstable and may require additional configuration for production use.
+
+The `/detect` endpoint allows programmatic image processing.
+
+### Running the FastAPI Server
+
+Enable FastAPI when launching the script:
+
+```bash
+python app.py --enable-fastapi
+```
+
+Or run FastAPI separately with Uvicorn:
+
+```bash
+uvicorn objectdetection:app --host 0.0.0.0 --port 8000
+```
+
+Access the Swagger UI at `http://localhost:8000/docs` for interactive testing.
+
+### Endpoint Details
+
+- **Endpoint**: `POST /detect`
+- **Parameters**:
+  - `file`: (optional) Image file (must be `image/*` type).
+  - `image_url`: (optional) URL of the image.
+  - `model_name`: (optional) Model name (e.g., `facebook/detr-resnet-50`, `hustvl/yolos-tiny`).
+- **Content-Type**: `multipart/form-data` for file uploads, `application/json` for URL inputs.
+
+### Example Requests
+
+#### Using `curl` with an Image URL
+
+```bash
+curl -X POST "http://localhost:8000/detect" \\
+  -H "Content-Type: application/json" \\
+  -d '{"image_url": "https://example.com/image.jpg", "model_name": "facebook/detr-resnet-50"}'
+```
+
+#### Using `curl` with an Image File
+
+```bash
+curl -X POST "http://localhost:8000/detect" \\
+  -F "file=@/path/to/image.jpg" \\
+  -F "model_name=facebook/detr-resnet-50"
+```
+
+### Response Format
+
+The response includes a base64-encoded image with detections and detection details:
 
 ```json
 {
@@ -134,14 +215,20 @@ Example Response:
 }
 ```
 
-## Development & Contributions
+### Notes
+
+- Ensure only one of `file` or `image_url` is provided.
+- The API may experience instability with panoptic models; use object detection models for reliability.
+- Test the API using the Swagger UI for easier debugging.
 
-To contribute or modify the project:
+## Development Setup
+
+To contribute or modify the application:
 
 1. Clone the repository:
 
 ```bash
-git clone https://github.com/NeerajCodz/ObjectDetection.git
+git clone https://github.com/JaishnaCodz/ObjectDetection
 cd ObjectDetection
 ```
 
@@ -151,15 +238,39 @@ cd ObjectDetection
 pip install -r requirements.txt
 ```
 
-3. Run FastAPI or Gradio:
+3. Run the application:
 
-* **FastAPI**: `uvicorn objectdetection:app --reload`
-* **Gradio**: `python app.py`
+```bash
+python app.py
+```
 
-Access the app on `http://localhost:8000` (FastAPI) or the Gradio interface at the displayed URL.
+Or run FastAPI:
+
+```bash
+uvicorn objectdetection:app --host 0.0.0.0 --port 8000
+```
+
+4. Access at `http://localhost:7860` (Gradio) or `http://localhost:8000` (FastAPI).
 
 ## Contributing
 
-Contributions are always welcome! Feel free to submit pull requests or open issues for bug fixes, new features, or improvements.
+Contributions are welcome! To contribute:
+
+1. Fork the repository.
+2. Create a feature or bugfix branch (`git checkout -b feature/your-feature`).
+3. Commit changes (`git commit -m "Add your feature"`).
+4. Push to the branch (`git push origin feature/your-feature`).
+5. Open a pull request on the [GitHub repository](https://github.com/JaishnaCodz/ObjectDetection).
+
+Please include tests and documentation for new features. Report issues via GitHub Issues.
+
+## Troubleshooting
 
+- **Port Conflicts**: If port 7860 is in use, specify a different port with `--gradio-port` or set `GRADIO_SERVER_PORT`.
+  - Example: `python app.py --gradio-port 7870`
+- **Colab Asyncio Error**: If you encounter `RuntimeError: asyncio.run() cannot be called from a running event loop` in Colab, the application now uses `nest_asyncio` to handle this. Ensure `nest_asyncio` is installed (`pip install nest_asyncio`).
+- **Panoptic Model Bugs**: Avoid `detr-resnet-*-panoptic` models until stability issues are resolved.
+- **API Instability**: Test with smaller images and object detection models first.
+- **FastAPI Not Starting**: Ensure `--enable-fastapi` is used, and check that the specified `--fastapi-port` (default: 8000) is available.
 
+For further assistance, open an issue on the [GitHub repository](https://github.com/JaishnaCodz/ObjectDetection).

app.py

@@ -1,88 +1,153 @@
-import gradio as gr
-import torch
-from transformers import DetrImageProcessor, DetrForObjectDetection
-from transformers import YolosImageProcessor, YolosForObjectDetection
-from transformers import DetrForSegmentation
-from PIL import Image, ImageDraw, ImageStat
-import requests
-from io import BytesIO
+import argparse
 import base64
-from collections import Counter
 import logging
-from fastapi import FastAPI, File, UploadFile, HTTPException, Form
-from fastapi.responses import JSONResponse
-import uvicorn
-import pandas as pd
-import traceback
 import os
+import sys
+import threading
+from collections import Counter
+from io import BytesIO
+from typing import Dict, List, Optional, Tuple, Union
+
+import gradio as gr
+import pandas as pd
+import requests
+import torch
+import uvicorn
+from fastapi import FastAPI, File, Form, HTTPException, UploadFile
+from fastapi.responses import JSONResponse
+from PIL import Image, ImageDraw, ImageStat
+from transformers import (
+    DetrForObjectDetection,
+    DetrForSegmentation,
+    DetrImageProcessor,
+    YolosForObjectDetection,
+    YolosImageProcessor,
+)
+import nest_asyncio
+
+# ------------------------------
+# Configuration
+# ------------------------------
 
-# Set up logging
+# Configure logging for debugging and monitoring
 logging.basicConfig(level=logging.INFO, format="%(asctime)s - %(levelname)s - %(message)s")
 logger = logging.getLogger(__name__)
 
-# Constants
-CONFIDENCE_THRESHOLD = 0.5
-VALID_MODELS = [
+# Define constants for model and server configuration
+CONFIDENCE_THRESHOLD: float = 0.5  # Default threshold for object detection confidence
+VALID_MODELS: List[str] = [
     "facebook/detr-resnet-50",
     "facebook/detr-resnet-101",
     "facebook/detr-resnet-50-panoptic",
     "facebook/detr-resnet-101-panoptic",
     "hustvl/yolos-tiny",
-    "hustvl/yolos-base"
+    "hustvl/yolos-base",
 ]
-MODEL_DESCRIPTIONS = {
-    "facebook/detr-resnet-50": "DETR with ResNet-50 backbone for object detection. Fast and accurate for general use.",
-    "facebook/detr-resnet-101": "DETR with ResNet-101 backbone for object detection. More accurate but slower than ResNet-50.",
-    "facebook/detr-resnet-50-panoptic": "DETR with ResNet-50 for panoptic segmentation. Detects objects and segments scenes.",
-    "facebook/detr-resnet-101-panoptic": "DETR with ResNet-101 for panoptic segmentation. High accuracy for complex scenes.",
-    "hustvl/yolos-tiny": "YOLOS Tiny model. Lightweight and fast, ideal for resource-constrained environments.",
-    "hustvl/yolos-base": "YOLOS Base model. Balances speed and accuracy for object detection."
+MODEL_DESCRIPTIONS: Dict[str, str] = {
+    "facebook/detr-resnet-50": "DETR with ResNet-50 for object detection. Fast and accurate.",
+    "facebook/detr-resnet-101": "DETR with ResNet-101 for object detection. More accurate, slower.",
+    "facebook/detr-resnet-50-panoptic": "DETR with ResNet-50 for panoptic segmentation.",
+    "facebook/detr-resnet-101-panoptic": "DETR with ResNet-101 for panoptic segmentation.",
+    "hustvl/yolos-tiny": "YOLOS Tiny. Lightweight and fast.",
+    "hustvl/yolos-base": "YOLOS Base. Balances speed and accuracy."
 }
+DEFAULT_GRADIO_PORT: int = 7860  # Default port for Gradio UI
+DEFAULT_FASTAPI_PORT: int = 8000  # Default port for FastAPI server
+PORT_RANGE: range = range(7860, 7870)  # Range of ports to try for Gradio
+MAX_PORT_ATTEMPTS: int = 10  # Maximum attempts to find an available port
+
+# Thread-safe storage for lazy-loaded models and processors
+models: Dict[str, any] = {}
+processors: Dict[str, any] = {}
+model_lock = threading.Lock()
 
-# Lazy model loading
-models = {}
-processors = {}
+# ------------------------------
+# Image Processing
+# ------------------------------
 
-def process(image, model_name):
-    """Process an image and return detected image, objects, confidences, unique objects, unique confidences, and properties."""
+def process_image(
+    image: Optional[Image.Image],
+    url: Optional[str],
+    model_name: str,
+    for_json: bool = False,
+    confidence_threshold: float = CONFIDENCE_THRESHOLD
+) -> Union[Dict, Tuple[Optional[Image.Image], Optional[pd.DataFrame], Optional[pd.DataFrame], Optional[pd.DataFrame], str]]:
+    """
+    Process an image for object detection or panoptic segmentation, handling Gradio and FastAPI inputs.
+
+    Args:
+        image: PIL Image object from file upload (optional).
+        url: URL of the image to process (optional).
+        model_name: Name of the model to use (must be in VALID_MODELS).
+        for_json: If True, return JSON dict for API/JSON tab; else, return tuple for Gradio Home tab.
+        confidence_threshold: Minimum confidence score for detection (default: 0.5).
+
+    Returns:
+        For JSON: Dict with base64-encoded image, detected objects, and confidence scores.
+        For Gradio: Tuple of (annotated image, objects DataFrame, unique objects DataFrame, properties DataFrame, error message).
+    """
     try:
+        # Validate input: ensure exactly one of image or URL is provided
+        if image is None and not url:
+            return {"error": "Please provide an image or URL"} if for_json else (None, None, None, None, "Please provide an image or URL")
+        if image and url:
+            return {"error": "Provide either an image or URL, not both"} if for_json else (None, None, None, None, "Provide either an image or URL, not both")
         if model_name not in VALID_MODELS:
-            raise ValueError(f"Invalid model: {model_name}. Choose from: {VALID_MODELS}")
-
-        # Load model and processor
-        if model_name not in models:
-            logger.info(f"Loading model: {model_name}")
-            if "yolos" in model_name:
-                models[model_name] = YolosForObjectDetection.from_pretrained(model_name)
-                processors[model_name] = YolosImageProcessor.from_pretrained(model_name)
-            elif "panoptic" in model_name:
-                models[model_name] = DetrForSegmentation.from_pretrained(model_name)
-                processors[model_name] = DetrImageProcessor.from_pretrained(model_name)
-            else:
-                models[model_name] = DetrForObjectDetection.from_pretrained(model_name)
-                processors[model_name] = DetrImageProcessor.from_pretrained(model_name)
-
-        model, processor = models[model_name], processors[model_name]
-        inputs = processor(images=image, return_tensors="pt")
+            error_msg = f"Invalid model: {model_name}. Choose from: {VALID_MODELS}"
+            return {"error": error_msg} if for_json else (None, None, None, None, error_msg)
 
+        # Calculate margin threshold: (1 - confidence_threshold) / 2 + confidence_threshold
+        margin_threshold = (1 - confidence_threshold) / 2 + confidence_threshold
+
+        # Load image from URL if provided
+        if url:
+            response = requests.get(url, timeout=10)
+            response.raise_for_status()
+            image = Image.open(BytesIO(response.content)).convert("RGB")
+
+        # Load model and processor thread-safely
+        with model_lock:
+            if model_name not in models:
+                logger.info(f"Loading model: {model_name}")
+                try:
+                    # Select appropriate model and processor based on model name
+                    if "yolos" in model_name:
+                        models[model_name] = YolosForObjectDetection.from_pretrained(model_name)
+                        processors[model_name] = YolosImageProcessor.from_pretrained(model_name)
+                    elif "panoptic" in model_name:
+                        models[model_name] = DetrForSegmentation.from_pretrained(model_name)
+                        processors[model_name] = DetrImageProcessor.from_pretrained(model_name)
+                    else:
+                        models[model_name] = DetrForObjectDetection.from_pretrained(model_name)
+                        processors[model_name] = DetrImageProcessor.from_pretrained(model_name)
+                except Exception as e:
+                    error_msg = f"Failed to load model: {str(e)}"
+                    logger.error(error_msg)
+                    return {"error": error_msg} if for_json else (None, None, None, None, error_msg)
+            model, processor = models[model_name], processors[model_name]
+
+        # Prepare image for model processing
+        inputs = processor(images=image, return_tensors="pt")
         with torch.no_grad():
             outputs = model(**inputs)
 
-        target_sizes = torch.tensor([image.size[::-1]])
+        # Initialize drawing context for annotations
         draw = ImageDraw.Draw(image)
-        object_names = []
-        confidence_scores = []
+        object_names: List[str] = []
+        confidence_scores: List[float] = []
         object_counter = Counter()
+        target_sizes = torch.tensor([image.size[::-1]])
 
+        # Process results based on model type (panoptic or object detection)
         if "panoptic" in model_name:
+            # Handle panoptic segmentation
             processed_sizes = torch.tensor([[inputs["pixel_values"].shape[2], inputs["pixel_values"].shape[3]]])
             results = processor.post_process_panoptic(outputs, target_sizes=target_sizes, processed_sizes=processed_sizes)[0]
-
             for segment in results["segments_info"]:
                 label = segment["label_id"]
                 label_name = model.config.id2label.get(label, "Unknown")
                 score = segment.get("score", 1.0)
-
+                # Apply segmentation mask if available
                 if "masks" in results and segment["id"] < len(results["masks"]):
                     mask = results["masks"][segment["id"]].cpu().numpy()
                     if mask.shape[0] > 0 and mask.shape[1] > 0:
@@ -93,292 +158,385 @@ def process(image, model_name):
                         mask_draw.bitmap((0, 0), mask_image, fill=(r, g, b, 128))
                         image = Image.alpha_composite(image.convert("RGBA"), colored_mask).convert("RGB")
                         draw = ImageDraw.Draw(image)
-
-                if score > CONFIDENCE_THRESHOLD:
+                if score > confidence_threshold:
                     object_names.append(label_name)
                     confidence_scores.append(float(score))
                     object_counter[label_name] = float(score)
         else:
+            # Handle object detection
             results = processor.post_process_object_detection(outputs, target_sizes=target_sizes)[0]
-
             for score, label, box in zip(results["scores"], results["labels"], results["boxes"]):
-                if score > CONFIDENCE_THRESHOLD:
+                if score > confidence_threshold:
                     x, y, x2, y2 = box.tolist()
-                    draw.rectangle([x, y, x2, y2], outline="#32CD32", width=2)
                     label_name = model.config.id2label.get(label.item(), "Unknown")
-                    # Place text at top-right corner, outside the box, with smaller size
                     text = f"{label_name}: {score:.2f}"
                     text_bbox = draw.textbbox((0, 0), text)
                     text_width, text_height = text_bbox[2] - text_bbox[0], text_bbox[3] - text_bbox[1]
-                    draw.text((x2 - text_width - 2, y - text_height - 2), text, fill="#32CD32")
+                    # Use yellow for confidence_threshold <= score < margin_threshold, green for >= margin_threshold
+                    color = "#FFFF00" if score < margin_threshold else "#32CD32"
+                    draw.rectangle([x, y, x2, y2], outline=color, width=2)
+                    draw.text((x2 - text_width - 2, y - text_height - 2), text, fill=color)
                     object_names.append(label_name)
                     confidence_scores.append(float(score))
                     object_counter[label_name] = float(score)
 
+        # Compile unique objects and their highest confidence scores
         unique_objects = list(object_counter.keys())
         unique_confidences = [object_counter[obj] for obj in unique_objects]
 
-        # Image properties
-        file_size = "Unknown"
-        if hasattr(image, "fp") and image.fp is not None:
-            buffered = BytesIO()
-            image.save(buffered, format="PNG")
-            file_size = f"{len(buffered.getvalue()) / 1024:.2f} KB"
-        
-        # Color statistics
-        try:
-            stat = ImageStat.Stat(image)
-            color_stats = {
-                "mean": [f"{m:.2f}" for m in stat.mean],
-                "stddev": [f"{s:.2f}" for s in stat.stddev]
-            }
-        except Exception as e:
-            logger.error(f"Error calculating color statistics: {str(e)}")
-            color_stats = {"mean": "Error", "stddev": "Error"}
-
-        properties = {
+        # Calculate image properties (metadata)
+        properties: Dict[str, str] = {
             "Format": image.format if hasattr(image, "format") and image.format else "Unknown",
             "Size": f"{image.width}x{image.height}",
             "Width": f"{image.width} px",
             "Height": f"{image.height} px",
             "Mode": image.mode,
-            "Aspect Ratio": f"{round(image.width / image.height, 2) if image.height != 0 else 'Undefined'}",
-            "File Size": file_size,
-            "Mean (R,G,B)": ", ".join(color_stats["mean"]) if isinstance(color_stats["mean"], list) else color_stats["mean"],
-            "StdDev (R,G,B)": ", ".join(color_stats["stddev"]) if isinstance(color_stats["stddev"], list) else color_stats["stddev"]
+            "Aspect Ratio": f"{round(image.width / image.height, 2)}" if image.height != 0 else "Undefined",
+            "File Size": "Unknown",
+            "Mean (R,G,B)": "Unknown",
+            "StdDev (R,G,B)": "Unknown",
         }
+        try:
+            # Compute file size
+            buffered = BytesIO()
+            image.save(buffered, format="PNG")
+            properties["File Size"] = f"{len(buffered.getvalue()) / 1024:.2f} KB"
+            # Compute color statistics
+            stat = ImageStat.Stat(image)
+            properties["Mean (R,G,B)"] = ", ".join(f"{m:.2f}" for m in stat.mean)
+            properties["StdDev (R,G,B)"] = ", ".join(f"{s:.2f}" for s in stat.stddev)
+        except Exception as e:
+            logger.error(f"Error calculating image stats: {str(e)}")
 
-        return image, object_names, confidence_scores, unique_objects, unique_confidences, properties
+        # Prepare output based on request type
+        if for_json:
+            # Return JSON with base64-encoded image
+            buffered = BytesIO()
+            image.save(buffered, format="PNG")
+            img_base64 = base64.b64encode(buffered.getvalue()).decode("utf-8")
+            return {
+                "image_url": f"data:image/png;base64,{img_base64}",
+                "detected_objects": object_names,
+                "confidence_scores": confidence_scores,
+                "unique_objects": unique_objects,
+                "unique_confidence_scores": unique_confidences,
+            }
+        else:
+            # Return tuple for Gradio Home tab with DataFrames
+            objects_df = (
+                pd.DataFrame({"Object": object_names, "Confidence Score": [f"{score:.2f}" for score in confidence_scores]})
+                if object_names else pd.DataFrame(columns=["Object", "Confidence Score"])
+            )
+            unique_objects_df = (
+                pd.DataFrame({"Unique Object": unique_objects, "Confidence Score": [f"{score:.2f}" for score in unique_confidences]})
+                if unique_objects else pd.DataFrame(columns=["Unique Object", "Confidence Score"])
+            )
+            properties_df = pd.DataFrame([properties]) if properties else pd.DataFrame(columns=properties.keys())
+            return image, objects_df, unique_objects_df, properties_df, ""
+
+    except requests.RequestException as e:
+        # Handle URL fetch errors
+        error_msg = f"Error fetching image from URL: {str(e)}"
+        logger.error(f"{error_msg}\n{traceback.format_exc()}")
+        return {"error": error_msg} if for_json else (None, None, None, None, error_msg)
     except Exception as e:
-        logger.error(f"Error in process: {str(e)}\n{traceback.format_exc()}")
-        raise
+        # Handle general processing errors
+        error_msg = f"Error processing image: {str(e)}"
+        logger.error(f"{error_msg}\n{traceback.format_exc()}")
+        return {"error": error_msg} if for_json else (None, None, None, None, error_msg)
 
+# ------------------------------
 # FastAPI Setup
+# ------------------------------
+
 app = FastAPI(title="Object Detection API")
 
 @app.post("/detect")
 async def detect_objects_endpoint(
-    file: UploadFile = File(None),
-    image_url: str = Form(None),
-    model_name: str = Form(VALID_MODELS[0])
-):
-    """FastAPI endpoint to detect objects in an image from file or URL."""
+    file: Optional[UploadFile] = File(None),
+    image_url: Optional[str] = Form(None),
+    model_name: str = Form(VALID_MODELS[0]),
+    confidence_threshold: float = Form(CONFIDENCE_THRESHOLD),
+) -> JSONResponse:
+    """
+    FastAPI endpoint to detect objects in an image from file upload or URL.
+
+    Args:
+        file: Uploaded image file (optional).
+        image_url: URL of the image (optional).
+        model_name: Model to use for detection (default: first VALID_MODELS entry).
+        confidence_threshold: Confidence threshold for detection (default: 0.5).
+
+    Returns:
+        JSONResponse with base64-encoded image, detected objects, and confidence scores.
+
+    Raises:
+        HTTPException: For invalid inputs or processing errors.
+    """
     try:
+        # Validate input: ensure exactly one of file or URL
         if (file is None and not image_url) or (file is not None and image_url):
-            raise HTTPException(status_code=400, detail="Provide either an image file or an image URL, but not both.")
-
+            raise HTTPException(status_code=400, detail="Provide either an image file or an image URL, not both.")
+        # Validate confidence threshold
+        if not 0 <= confidence_threshold <= 1:
+            raise HTTPException(status_code=400, detail="Confidence threshold must be between 0 and 1.")
+        # Load image from file if provided
+        image = None
         if file:
             if not file.content_type.startswith("image/"):
                 raise HTTPException(status_code=400, detail="File must be an image")
             contents = await file.read()
             image = Image.open(BytesIO(contents)).convert("RGB")
-        else:
-            response = requests.get(image_url, timeout=10)
-            response.raise_for_status()
-            image = Image.open(BytesIO(response.content)).convert("RGB")
-
-        if model_name not in VALID_MODELS:
-            raise HTTPException(status_code=400, detail=f"Invalid model. Choose from: {VALID_MODELS}")
-
-        detected_image, detected_objects, detected_confidences, unique_objects, unique_confidences, _ = process(image, model_name)
-
-        buffered = BytesIO()
-        detected_image.save(buffered, format="PNG")
-        img_base64 = base64.b64encode(buffered.getvalue()).decode("utf-8")
-        img_url = f"data:image/png;base64,{img_base64}"
-
-        return JSONResponse(content={
-            "image_url": img_url,
-            "detected_objects": detected_objects,
-            "confidence_scores": detected_confidences,
-            "unique_objects": unique_objects,
-            "unique_confidence_scores": unique_confidences
-        })
+        # Process image with specified parameters
+        result = process_image(image, image_url, model_name, for_json=True, confidence_threshold=confidence_threshold)
+        if "error" in result:
+            raise HTTPException(status_code=400, detail=result["error"])
+        return JSONResponse(content=result)
+    except HTTPException:
+        raise
     except Exception as e:
         logger.error(f"Error in FastAPI endpoint: {str(e)}\n{traceback.format_exc()}")
         raise HTTPException(status_code=500, detail=f"Error processing image: {str(e)}")
 
-# Gradio UI
-def create_gradio_ui():
-    with gr.Blocks(theme=gr.themes.Default(primary_hue="blue", secondary_hue="gray")) as demo:
-        gr.Markdown(
-            """
-            # 🚀 Object Detection App
-            Upload an image or provide a URL to detect objects using state-of-the-art transformer models (DETR, YOLOS).
-            """
-        )
-        
-        with gr.Tabs():
-            with gr.Tab("📷 Image Upload"):
-                with gr.Row():
-                    with gr.Column(scale=1):
-                        gr.Markdown("### Input")
-                        model_choice = gr.Dropdown(
-                            choices=VALID_MODELS,
-                            value=VALID_MODELS[0],
-                            label="🔎 Select Model",
-                            info="Choose a model for object detection or panoptic segmentation."
-                        )
-                        model_info = gr.Markdown(
-                            f"**Model Info**: {MODEL_DESCRIPTIONS[VALID_MODELS[0]]}",
-                            visible=True
-                        )
-                        image_input = gr.Image(type="pil", label="📷 Upload Image")
-                        image_url_input = gr.Textbox(
-                            label="🔗 Image URL",
-                            placeholder="https://example.com/image.jpg"
-                        )
-                        with gr.Row():
-                            submit_btn = gr.Button("✨ Detect", variant="primary")
-                            clear_btn = gr.Button("🗑️ Clear", variant="secondary")
-                        
-                        model_choice.change(
-                            fn=lambda model_name: f"**Model Info**: {MODEL_DESCRIPTIONS.get(model_name, 'No description available.')}",
-                            inputs=model_choice,
-                            outputs=model_info
-                        )
-                    
-                    with gr.Column(scale=2):
-                        gr.Markdown("### Results")
-                        error_output = gr.Textbox(
-                            label="⚠️ Errors",
-                            visible=False,
-                            lines=3,
-                            max_lines=5
-                        )
-                        output_image = gr.Image(
-                            type="pil",
-                            label="🎯 Detected Image",
-                            interactive=False
-                        )
-                        with gr.Row():
-                            objects_output = gr.DataFrame(
-                                label="📋 Detected Objects",
-                                interactive=False,
-                                value=None
+# ------------------------------
+# Gradio UI Setup
+# ------------------------------
+
+def create_gradio_ui() -> gr.Blocks:
+    """
+    Create and configure the Gradio UI for object detection with Home, JSON, and Help tabs.
+
+    Returns:
+        Gradio Blocks object representing the UI.
+
+    Raises:
+        RuntimeError: If UI creation fails.
+    """
+    try:
+        # Initialize Gradio Blocks with a custom theme
+        with gr.Blocks(theme=gr.themes.Default(primary_hue="blue", secondary_hue="gray")) as demo:
+            # Display app header
+            gr.Markdown(
+                f"""
+                # 🚀 Object Detection App
+                Upload an image or provide a URL to detect objects using transformer models (DETR, YOLOS).
+                Running on port: {os.getenv('GRADIO_SERVER_PORT', 'auto-selected')}
+                """
+            )
+
+            # Create tabbed interface
+            with gr.Tabs():
+                # Home tab (formerly Image Upload)
+                with gr.Tab("🏠 Home"):
+                    with gr.Row():
+                        # Left column for inputs
+                        with gr.Column(scale=1):
+                            gr.Markdown("### Input")
+                            # Model selection dropdown
+                            model_choice = gr.Dropdown(choices=VALID_MODELS, value=VALID_MODELS[0], label="🔎 Select Model")
+                            model_info = gr.Markdown(f"**Model Info**: {MODEL_DESCRIPTIONS[VALID_MODELS[0]]}")
+                            # Image upload input
+                            image_input = gr.Image(type="pil", label="📷 Upload Image")
+                            # Image URL input
+                            image_url_input = gr.Textbox(label="🔗 Image URL", placeholder="https://example.com/image.jpg")
+                            # Buttons for submission and clearing
+                            with gr.Row():
+                                submit_btn = gr.Button("✨ Detect", variant="primary")
+                                clear_btn = gr.Button("🗑️ Clear", variant="secondary")
+
+                            # Update model info when model changes
+                            model_choice.change(
+                                fn=lambda model_name: f"**Model Info**: {MODEL_DESCRIPTIONS.get(model_name, 'No description available.')}",
+                                inputs=model_choice,
+                                outputs=model_info,
                             )
-                            unique_objects_output = gr.DataFrame(
-                                label="🔍 Unique Objects",
-                                interactive=False,
-                                value=None
+
+                        # Right column for results
+                        with gr.Column(scale=2):
+                            gr.Markdown("### Results")
+                            # Error display (hidden by default)
+                            error_output = gr.Textbox(label="⚠️ Errors", visible=False, lines=3, max_lines=5)
+                            # Annotated image output
+                            output_image = gr.Image(type="pil", label="🎯 Detected Image", interactive=False)
+                            # Detected and unique objects tables
+                            with gr.Row():
+                                objects_output = gr.DataFrame(label="📋 Detected Objects", interactive=False)
+                                unique_objects_output = gr.DataFrame(label="🔍 Unique Objects", interactive=False)
+                            # Image properties table
+                            properties_output = gr.DataFrame(label="📄 Image Properties", interactive=False)
+
+                    # Process image when Detect button is clicked
+                    submit_btn.click(
+                        fn=process_image,
+                        inputs=[image_input, image_url_input, model_choice],
+                        outputs=[output_image, objects_output, unique_objects_output, properties_output, error_output],
+                    )
+
+                    # Clear all inputs and outputs
+                    clear_btn.click(
+                        fn=lambda: [None, "", None, None, None, None],
+                        inputs=None,
+                        outputs=[image_input, image_url_input, output_image, objects_output, unique_objects_output, properties_output, error_output],
+                    )
+
+                # JSON tab for API-like output
+                with gr.Tab("🔗 JSON"):
+                    with gr.Row():
+                        # Left column for inputs
+                        with gr.Column(scale=1):
+                            gr.Markdown("### Process Image for JSON")
+                            # Model selection dropdown
+                            url_model_choice = gr.Dropdown(choices=VALID_MODELS, value=VALID_MODELS[0], label="🔎 Select Model")
+                            url_model_info = gr.Markdown(f"**Model Info**: {MODEL_DESCRIPTIONS[VALID_MODELS[0]]}")
+                            # Image upload input
+                            image_input_json = gr.Image(type="pil", label="📷 Upload Image")
+                            # Image URL input
+                            image_url_input_json = gr.Textbox(label="🔗 Image URL", placeholder="https://example.com/image.jpg")
+                            # Process button
+                            url_submit_btn = gr.Button("🔄 Process", variant="primary")
+
+                            # Update model info when model changes
+                            url_model_choice.change(
+                                fn=lambda model_name: f"**Model Info**: {MODEL_DESCRIPTIONS.get(model_name, 'No description available.')}",
+                                inputs=url_model_choice,
+                                outputs=url_model_info,
                             )
-                        properties_output = gr.DataFrame(
-                            label="📄 Image Properties",
-                            interactive=False,
-                            value=None
-                        )
-                
-                def process_for_gradio(image, url, model_name):
-                    try:
-                        if image is None and not url:
-                            return None, None, None, None, "Please provide an image or URL"
-                        if image and url:
-                            return None, None, None, None, "Please provide either an image or URL, not both"
-                        
-                        if url:
-                            response = requests.get(url, timeout=10)
-                            response.raise_for_status()
-                            image = Image.open(BytesIO(response.content)).convert("RGB")
-                        
-                        detected_image, objects, scores, unique_objects, unique_scores, properties = process(image, model_name)
-                        objects_df = pd.DataFrame({
-                            "Object": objects,
-                            "Confidence Score": [f"{score:.2f}" for score in scores]
-                        }) if objects else pd.DataFrame(columns=["Object", "Confidence Score"])
-                        unique_objects_df = pd.DataFrame({
-                            "Unique Object": unique_objects,
-                            "Confidence Score": [f"{score:.2f}" for score in unique_scores]
-                        }) if unique_objects else pd.DataFrame(columns=["Unique Object", "Confidence Score"])
-                        properties_df = pd.DataFrame([properties]) if properties else pd.DataFrame(columns=properties.keys())
-                        return detected_image, objects_df, unique_objects_df, properties_df, ""
-                    except Exception as e:
-                        error_msg = f"Error processing image: {str(e)}"
-                        logger.error(f"{error_msg}\n{traceback.format_exc()}")
-                        return None, None, None, None, error_msg
-
-                submit_btn.click(
-                    fn=process_for_gradio,
-                    inputs=[image_input, image_url_input, model_choice],
-                    outputs=[output_image, objects_output, unique_objects_output, properties_output, error_output]
-                )
-                
-                clear_btn.click(
-                    fn=lambda: [None, "", None, None, None, None],
-                    inputs=None,
-                    outputs=[image_input, image_url_input, output_image, objects_output, unique_objects_output, properties_output, error_output]
-                )
-            
-            with gr.Tab("🔗 URL Input"):
-                gr.Markdown("### Process Image from URL")
-                image_url_input = gr.Textbox(
-                    label="🔗 Image URL",
-                    placeholder="https://example.com/image.jpg"
-                )
-                url_model_choice = gr.Dropdown(
-                    choices=VALID_MODELS,
-                    value=VALID_MODELS[0],
-                    label="🔎 Select Model"
-                )
-                url_model_info = gr.Markdown(
-                    f"**Model Info**: {MODEL_DESCRIPTIONS[VALID_MODELS[0]]}",
-                    visible=True
-                )
-                url_submit_btn = gr.Button("🔄 Process URL", variant="primary")
-                url_output = gr.JSON(label="API Response")
-                
-                url_model_choice.change(
-                    fn=lambda model_name: f"**Model Info**: {MODEL_DESCRIPTIONS.get(model_name, 'No description available.')}",
-                    inputs=url_model_choice,
-                    outputs=url_model_info
-                )
-                
-                def process_url_for_gradio(url, model_name):
-                    try:
-                        response = requests.get(url, timeout=10)
-                        response.raise_for_status()
-                        image = Image.open(BytesIO(response.content)).convert("RGB")
-                        detected_image, objects, scores, unique_objects, unique_scores, _ = process(image, model_name)
-                        buffered = BytesIO()
-                        detected_image.save(buffered, format="PNG")
-                        img_base64 = base64.b64encode(buffered.getvalue()).decode("utf-8")
-                        return {
-                            "image_url": f"data:image/png;base64,{img_base64}",
-                            "detected_objects": objects,
-                            "confidence_scores": scores,
-                            "unique_objects": unique_objects,
-                            "unique_confidence_scores": unique_scores
-                        }
-                    except Exception as e:
-                        error_msg = f"Error processing URL: {str(e)}"
-                        logger.error(f"{error_msg}\n{traceback.format_exc()}")
-                        return {"error": error_msg}
-
-                url_submit_btn.click(
-                    fn=process_url_for_gradio,
-                    inputs=[image_url_input, url_model_choice],
-                    outputs=[url_output]
-                )
-            
-            with gr.Tab("ℹ️ Help"):
-                gr.Markdown(
-                    """
-                    ## How to Use
-                    - **Image Upload**: Select a model, upload an image or provide a URL, and click "Detect" to see detected objects and image properties.
-                    - **URL Input**: Enter an image URL, select a model, and click "Process URL" to get results in JSON format.
-                    - **Models**: Choose from DETR (object detection or panoptic segmentation) or YOLOS (lightweight detection).
-                    - **Clear**: Reset all inputs and outputs using the "Clear" button.
-                    - **Errors**: Check the error box for any processing issues.
-                    
-                    ## Tips
-                    - Use high-quality images for better detection results.
-                    - Panoptic models (e.g., DETR-ResNet-50-panoptic) provide segmentation masks for complex scenes.
-                    - For faster processing, try YOLOS-Tiny on resource-constrained devices.
-                    """
-                )
-
-    return demo
+
+                        # Right column for JSON output
+                        with gr.Column(scale=1):
+                            # JSON output display
+                            url_output = gr.JSON(label="API Response")
+
+                    # Process image and return JSON when Process button is clicked
+                    url_submit_btn.click(
+                        fn=lambda img, url, model: process_image(img, url, model, for_json=True),
+                        inputs=[image_input_json, image_url_input_json, url_model_choice],
+                        outputs=[url_output],
+                    )
+
+                # Help tab with usage instructions
+                with gr.Tab("ℹ️ Help"):
+                    gr.Markdown(
+                        """
+                        ## How to Use
+                        - **Home**: Select a model, upload an image or provide a URL, click "Detect" to see results.
+                        - **JSON**: Select a model, upload an image or enter a URL, click "Process" for JSON output.
+                        - **Models**: Choose DETR (detection or panoptic) or YOLOS (lightweight detection).
+                        - **Clear**: Reset inputs/outputs in Home tab.
+                        - **Errors**: Check error box (Home) or JSON response (JSON) for issues.
+
+                        ## Tips
+                        - Use high-quality images for better results.
+                        - Panoptic models provide segmentation masks for complex scenes.
+                        - YOLOS-Tiny is faster for resource-constrained devices.
+                        """
+                    )
+
+        return demo
+
+    except Exception as e:
+        logger.error(f"Error creating Gradio UI: {str(e)}\n{traceback.format_exc()}")
+        raise RuntimeError(f"Failed to create Gradio UI: {str(e)}")
+
+# ------------------------------
+# Launcher
+# ------------------------------
+
+def parse_args() -> argparse.Namespace:
+    """
+    Parse command-line arguments for configuring the application.
+
+    Returns:
+        Parsed arguments as a Namespace object.
+    """
+    parser = argparse.ArgumentParser(description="Object Detection App with Gradio and FastAPI.")
+    # Gradio port argument
+    parser.add_argument("--gradio-port", type=int, default=DEFAULT_GRADIO_PORT, help=f"Gradio port (default: {DEFAULT_GRADIO_PORT}).")
+    # FastAPI enable flag
+    parser.add_argument("--enable-fastapi", action="store_true", help="Enable FastAPI server.")
+    # FastAPI port argument
+    parser.add_argument("--fastapi-port", type=int, default=DEFAULT_FASTAPI_PORT, help=f"FastAPI port (default: {DEFAULT_FASTAPI_PORT}).")
+    # Confidence threshold argument
+    parser.add_argument("--confidence-threshold", type=float, default=CONFIDENCE_THRESHOLD, help="Confidence threshold for detection (default: 0.5).")
+    # Parse known arguments, ignoring unrecognized ones
+    args, _ = parser.parse_known_args()
+    # Validate confidence threshold
+    if not 0 <= args.confidence_threshold <= 1:
+        parser.error("Confidence threshold must be between 0 and 1.")
+    return args
+
+def find_available_port(start_port: int, port_range: range, max_attempts: int) -> Optional[int]:
+    """
+    Find an available port within the specified range.
+
+    Args:
+        start_port: Initial port to try.
+        port_range: Range of ports to attempt.
+        max_attempts: Maximum number of ports to try.
+
+    Returns:
+        Available port number, or None if no port is found.
+    """
+    import socket
+    # Check environment variable for port override
+    port = int(os.getenv("GRADIO_SERVER_PORT", start_port))
+    attempts = 0
+    while attempts < max_attempts:
+        with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
+            try:
+                # Attempt to bind to the port
+                s.bind(("0.0.0.0", port))
+                logger.debug(f"Port {port} is available")
+                return port
+            except OSError as e:
+                if e.errno == 98:  # Port in use
+                    logger.debug(f"Port {port} is in use")
+                    port = port + 1 if port < max(port_range) else min(port_range)
+                    attempts += 1
+                else:
+                    raise
+    logger.error(f"No available port in range {min(port_range)}-{max(port_range)}")
+    return None
+
+def main() -> None:
+    """
+    Launch the Gradio UI and optional FastAPI server.
+
+    Raises:
+        SystemExit: On interruption or critical errors.
+    """
+    try:
+        # Apply nest_asyncio for compatibility with Jupyter/Colab
+        nest_asyncio.apply()
+        # Parse command-line arguments
+        args = parse_args()
+        logger.info(f"Parsed arguments: {args}")
+        # Find available port for Gradio
+        gradio_port = find_available_port(args.gradio_port, PORT_RANGE, MAX_PORT_ATTEMPTS)
+        if gradio_port is None:
+            logger.error("Failed to find an available port for Gradio UI")
+            sys.exit(1)
+
+        # Start FastAPI server in a thread if enabled
+        if args.enable_fastapi:
+            logger.info(f"Starting FastAPI on port {args.fastapi_port}")
+            fastapi_thread = threading.Thread(
+                target=lambda: uvicorn.run(app, host="0.0.0.0", port=args.fastapi_port),
+                daemon=True
+            )
+            fastapi_thread.start()
+
+        # Launch Gradio UI
+        logger.info(f"Starting Gradio UI on port {gradio_port}")
+        demo = create_gradio_ui()
+        demo.launch(server_port=gradio_port, server_name="0.0.0.0")
+
+    except KeyboardInterrupt:
+        logger.info("Application terminated by user.")
+        sys.exit(0)
+    except Exception as e:
+        logger.error(f"Error: {str(e)}\n{traceback.format_exc()}")
+        sys.exit(1)
 
 if __name__ == "__main__":
-    demo = create_gradio_ui()
-    demo.launch()
-    # To run FastAPI, use: uvicorn object_detection:app --host 0.0.0.0 --port 8000
+    main()

hf_space/README.md

@@ -1,13 +1,276 @@
----
-title: ObjectDetection
-emoji: 🐢
-colorFrom: red
-colorTo: blue
-sdk: gradio
-sdk_version: 5.29.0
-app_file: app.py
-pinned: false
-license: mit
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# 🚀 Object Detection with Transformer Models
+
+This project provides a robust object detection system leveraging state-of-the-art transformer models, including **DETR (DEtection TRansformer)** and **YOLOS (You Only Look One-level Series)**. The system supports object detection and panoptic segmentation from uploaded images or image URLs. It features a user-friendly **Gradio** web interface for interactive use and a **FastAPI** endpoint for programmatic access.
+
+Try the online demo on Hugging Face Spaces: [Object Detection Demo](https://huggingface.co/spaces/JaishnaCodz/ObjectDetection).
+
+## Models Supported
+
+The application supports the following models, each tailored for specific detection or segmentation tasks:
+
+- **DETR (DEtection TRansformer)**:
+  - `facebook/detr-resnet-50`: Fast and accurate object detection with a ResNet-50 backbone.
+  - `facebook/detr-resnet-101`: Higher accuracy object detection with a ResNet-101 backbone, slower than ResNet-50.
+  - `facebook/detr-resnet-50-panoptic`: Panoptic segmentation with ResNet-50 (note: may have stability issues).
+  - `facebook/detr-resnet-101-panoptic`: Panoptic segmentation with ResNet-101 (note: may have stability issues).
+  
+- **YOLOS (You Only Look One-level Series)**:
+  - `hustvl/yolos-tiny`: Lightweight and fast, ideal for resource-constrained environments.
+  - `hustvl/yolos-base`: Balances speed and accuracy for object detection.
+
+## Features
+
+- **Image Upload**: Upload images via the Gradio interface for object detection.
+- **URL Input**: Provide image URLs for detection through the Gradio interface or API.
+- **Model Selection**: Choose between DETR and YOLOS models for detection or panoptic segmentation.
+- **Object Detection**: Highlights detected objects with bounding boxes and confidence scores.
+- **Panoptic Segmentation**: Supports scene segmentation with colored masks (DETR panoptic models).
+- **Image Properties**: Displays metadata like format, size, aspect ratio, file size, and color statistics.
+- **API Access**: Programmatically process images via the FastAPI `/detect` endpoint.
+- **Flexible Deployment**: Run locally, in Docker, or in cloud environments like Google Colab.
+
+## How to Use
+
+### 1. **Local Setup (Git Clone)**
+
+Follow these steps to set up the application locally:
+
+#### Prerequisites
+
+- Python 3.8 or higher
+- `pip` for installing dependencies
+- Git for cloning the repository
+
+#### Clone the Repository
+
+```bash
+git clone https://github.com/JaishnaCodz/ObjectDetection
+cd ObjectDetection
+```
+
+#### Install Dependencies
+
+Install required packages from `requirements.txt`:
+
+```bash
+pip install -r requirements.txt
+```
+
+#### Run the Application
+
+Launch the Gradio interface:
+
+```bash
+python app.py
+```
+
+To enable the FastAPI server:
+
+```bash
+python app.py --enable-fastapi
+```
+
+#### Access the Application
+
+- **Gradio**: Open the URL displayed in the console (typically `http://127.0.0.1:7860`).
+- **FastAPI**: Navigate to `http://localhost:8000` for the API or Swagger UI (if enabled).
+
+### 2. **Running with Docker**
+
+Use Docker for a containerized setup.
+
+#### Prerequisites
+
+- Docker installed on your machine. Download from [Docker's official site](https://www.docker.com/get-started).
+
+#### Pull the Docker Image
+
+Pull the pre-built image from Docker Hub:
+
+```bash
+docker pull JaishnaCodz/objectdetection:latest
+```
+
+#### Run the Docker Container
+
+Run the application on port 8080:
+
+```bash
+docker run -d -p 8080:80 JaishnaCodz/objectdetection:latest
+```
+
+Access the interface at `http://localhost:8080`.
+
+#### Build and Run the Docker Image
+
+To build the Docker image locally:
+
+1. Ensure you have a `Dockerfile` in the repository root (example provided in the repository).
+2. Build the image:
+
+```bash
+docker build -t objectdetection:local .
+```
+
+3. Run the container:
+
+```bash
+docker run -d -p 8080:80 objectdetection:local
+```
+
+Access the interface at `http://localhost:8080`.
+
+### 3. **Demo**
+
+Try the demo on Hugging Face Spaces:
+
+[Object Detection Demo](https://huggingface.co/spaces/JaishnaCodz/ObjectDetection)
+
+## Command-Line Arguments
+
+The `app.py` script supports the following command-line arguments:
+
+- `--gradio-port <port>`: Specify the port for the Gradio UI (default: 7860).
+  - Example: `python app.py --gradio-port 7870`
+- `--enable-fastapi`: Enable the FastAPI server (disabled by default).
+  - Example: `python app.py --enable-fastapi`
+- `--fastapi-port <port>`: Specify the port for the FastAPI server (default: 8000).
+  - Example: `python app.py --enable-fastapi --fastapi-port 8001`
+- `--confidence-threshold <float-value)`: Confidence threshold for detection (Range: 0 - 1) (default: 8000).
+  - Example: `python app.py --confidence-threshold 0.75`
+
+You can combine arguments:
+
+```bash
+python app.py --gradio-port 7870 --enable-fastapi --fastapi-port 8001 --confidence-threshold 0.75
+```
+
+Alternatively, set the `GRADIO_SERVER_PORT` environment variable:
+
+```bash
+export GRADIO_SERVER_PORT=7870
+python app.py
+```
+
+## Using the API
+
+**Note**: The FastAPI API is currently unstable and may require additional configuration for production use.
+
+The `/detect` endpoint allows programmatic image processing.
+
+### Running the FastAPI Server
+
+Enable FastAPI when launching the script:
+
+```bash
+python app.py --enable-fastapi
+```
+
+Or run FastAPI separately with Uvicorn:
+
+```bash
+uvicorn objectdetection:app --host 0.0.0.0 --port 8000
+```
+
+Access the Swagger UI at `http://localhost:8000/docs` for interactive testing.
+
+### Endpoint Details
+
+- **Endpoint**: `POST /detect`
+- **Parameters**:
+  - `file`: (optional) Image file (must be `image/*` type).
+  - `image_url`: (optional) URL of the image.
+  - `model_name`: (optional) Model name (e.g., `facebook/detr-resnet-50`, `hustvl/yolos-tiny`).
+- **Content-Type**: `multipart/form-data` for file uploads, `application/json` for URL inputs.
+
+### Example Requests
+
+#### Using `curl` with an Image URL
+
+```bash
+curl -X POST "http://localhost:8000/detect" \\
+  -H "Content-Type: application/json" \\
+  -d '{"image_url": "https://example.com/image.jpg", "model_name": "facebook/detr-resnet-50"}'
+```
+
+#### Using `curl` with an Image File
+
+```bash
+curl -X POST "http://localhost:8000/detect" \\
+  -F "file=@/path/to/image.jpg" \\
+  -F "model_name=facebook/detr-resnet-50"
+```
+
+### Response Format
+
+The response includes a base64-encoded image with detections and detection details:
+
+```json
+{
+  "image_url": "data:image/png;base64,...",
+  "detected_objects": ["person", "car"],
+  "confidence_scores": [0.95, 0.87],
+  "unique_objects": ["person", "car"],
+  "unique_confidence_scores": [0.95, 0.87]
+}
+```
+
+### Notes
+
+- Ensure only one of `file` or `image_url` is provided.
+- The API may experience instability with panoptic models; use object detection models for reliability.
+- Test the API using the Swagger UI for easier debugging.
+
+## Development Setup
+
+To contribute or modify the application:
+
+1. Clone the repository:
+
+```bash
+git clone https://github.com/JaishnaCodz/ObjectDetection
+cd ObjectDetection
+```
+
+2. Install dependencies:
+
+```bash
+pip install -r requirements.txt
+```
+
+3. Run the application:
+
+```bash
+python app.py
+```
+
+Or run FastAPI:
+
+```bash
+uvicorn objectdetection:app --host 0.0.0.0 --port 8000
+```
+
+4. Access at `http://localhost:7860` (Gradio) or `http://localhost:8000` (FastAPI).
+
+## Contributing
+
+Contributions are welcome! To contribute:
+
+1. Fork the repository.
+2. Create a feature or bugfix branch (`git checkout -b feature/your-feature`).
+3. Commit changes (`git commit -m "Add your feature"`).
+4. Push to the branch (`git push origin feature/your-feature`).
+5. Open a pull request on the [GitHub repository](https://github.com/JaishnaCodz/ObjectDetection).
+
+Please include tests and documentation for new features. Report issues via GitHub Issues.
+
+## Troubleshooting
+
+- **Port Conflicts**: If port 7860 is in use, specify a different port with `--gradio-port` or set `GRADIO_SERVER_PORT`.
+  - Example: `python app.py --gradio-port 7870`
+- **Colab Asyncio Error**: If you encounter `RuntimeError: asyncio.run() cannot be called from a running event loop` in Colab, the application now uses `nest_asyncio` to handle this. Ensure `nest_asyncio` is installed (`pip install nest_asyncio`).
+- **Panoptic Model Bugs**: Avoid `detr-resnet-*-panoptic` models until stability issues are resolved.
+- **API Instability**: Test with smaller images and object detection models first.
+- **FastAPI Not Starting**: Ensure `--enable-fastapi` is used, and check that the specified `--fastapi-port` (default: 8000) is available.
+
+For further assistance, open an issue on the [GitHub repository](https://github.com/JaishnaCodz/ObjectDetection).

hf_space/hf_space/.github/workflows/docker-build-push.yml

@@ -0,0 +1,26 @@
+name: Build and Push Docker Image to Docker Hub
+
+on:
+  push:
+    branches:
+      - main
+
+jobs:
+  build-and-push:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+
+      - name: Log in to Docker Hub
+        uses: docker/login-action@v3
+        with:
+          username: ${{ secrets.DOCKER_USERNAME }}
+          password: ${{ secrets.DOCKER_PAT }}
+
+      - name: Build and push Docker image
+        uses: docker/build-push-action@v6
+        with:
+          context: .
+          push: true
+          tags: ${{ secrets.DOCKER_USERNAME }}/objectdetection:latest

hf_space/hf_space/.github/workflows/hf-space-sync.yml

@@ -0,0 +1,30 @@
+name: Sync to Hugging Face Space
+
+on:
+  push:
+    branches: [ main ]
+
+jobs:
+  deploy-to-hf-space:
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Checkout Repository
+        uses: actions/checkout@v3
+
+      - name: Install Git
+        run: sudo apt-get install git
+
+      - name: Push to Hugging Face Space
+        env:
+          HF_TOKEN: ${{ secrets.HF_TOKEN }}
+        run: |
+          git config --global user.email "[email protected]"
+          git config --global user.name "JaishnaCodz"
+          
+          git clone https://JaishnaCodz:[email protected]/spaces/JaishnaCodz/ObjectDetection hf_space
+          rsync -av --exclude='.git' ./ hf_space/
+          cd hf_space
+          git add .
+          git commit -m "Sync from GitHub"
+          git push

hf_space/hf_space/Dockerfile

@@ -0,0 +1,13 @@
+FROM python:3.11-slim
+
+WORKDIR /app
+
+COPY requirements.txt .
+
+RUN pip install --no-cache-dir -r requirements.txt
+
+COPY app.py .
+
+EXPOSE 5000
+
+CMD ["python", "app.py"]

hf_space/hf_space/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Jaishna S
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

hf_space/hf_space/app.py

@@ -0,0 +1,384 @@
+import gradio as gr
+import torch
+from transformers import DetrImageProcessor, DetrForObjectDetection
+from transformers import YolosImageProcessor, YolosForObjectDetection
+from transformers import DetrForSegmentation
+from PIL import Image, ImageDraw, ImageStat
+import requests
+from io import BytesIO
+import base64
+from collections import Counter
+import logging
+from fastapi import FastAPI, File, UploadFile, HTTPException, Form
+from fastapi.responses import JSONResponse
+import uvicorn
+import pandas as pd
+import traceback
+import os
+
+# Set up logging
+logging.basicConfig(level=logging.INFO, format="%(asctime)s - %(levelname)s - %(message)s")
+logger = logging.getLogger(__name__)
+
+# Constants
+CONFIDENCE_THRESHOLD = 0.5
+VALID_MODELS = [
+    "facebook/detr-resnet-50",
+    "facebook/detr-resnet-101",
+    "facebook/detr-resnet-50-panoptic",
+    "facebook/detr-resnet-101-panoptic",
+    "hustvl/yolos-tiny",
+    "hustvl/yolos-base"
+]
+MODEL_DESCRIPTIONS = {
+    "facebook/detr-resnet-50": "DETR with ResNet-50 backbone for object detection. Fast and accurate for general use.",
+    "facebook/detr-resnet-101": "DETR with ResNet-101 backbone for object detection. More accurate but slower than ResNet-50.",
+    "facebook/detr-resnet-50-panoptic": "DETR with ResNet-50 for panoptic segmentation. Detects objects and segments scenes.",
+    "facebook/detr-resnet-101-panoptic": "DETR with ResNet-101 for panoptic segmentation. High accuracy for complex scenes.",
+    "hustvl/yolos-tiny": "YOLOS Tiny model. Lightweight and fast, ideal for resource-constrained environments.",
+    "hustvl/yolos-base": "YOLOS Base model. Balances speed and accuracy for object detection."
+}
+
+# Lazy model loading
+models = {}
+processors = {}
+
+def process(image, model_name):
+    """Process an image and return detected image, objects, confidences, unique objects, unique confidences, and properties."""
+    try:
+        if model_name not in VALID_MODELS:
+            raise ValueError(f"Invalid model: {model_name}. Choose from: {VALID_MODELS}")
+
+        # Load model and processor
+        if model_name not in models:
+            logger.info(f"Loading model: {model_name}")
+            if "yolos" in model_name:
+                models[model_name] = YolosForObjectDetection.from_pretrained(model_name)
+                processors[model_name] = YolosImageProcessor.from_pretrained(model_name)
+            elif "panoptic" in model_name:
+                models[model_name] = DetrForSegmentation.from_pretrained(model_name)
+                processors[model_name] = DetrImageProcessor.from_pretrained(model_name)
+            else:
+                models[model_name] = DetrForObjectDetection.from_pretrained(model_name)
+                processors[model_name] = DetrImageProcessor.from_pretrained(model_name)
+
+        model, processor = models[model_name], processors[model_name]
+        inputs = processor(images=image, return_tensors="pt")
+
+        with torch.no_grad():
+            outputs = model(**inputs)
+
+        target_sizes = torch.tensor([image.size[::-1]])
+        draw = ImageDraw.Draw(image)
+        object_names = []
+        confidence_scores = []
+        object_counter = Counter()
+
+        if "panoptic" in model_name:
+            processed_sizes = torch.tensor([[inputs["pixel_values"].shape[2], inputs["pixel_values"].shape[3]]])
+            results = processor.post_process_panoptic(outputs, target_sizes=target_sizes, processed_sizes=processed_sizes)[0]
+
+            for segment in results["segments_info"]:
+                label = segment["label_id"]
+                label_name = model.config.id2label.get(label, "Unknown")
+                score = segment.get("score", 1.0)
+
+                if "masks" in results and segment["id"] < len(results["masks"]):
+                    mask = results["masks"][segment["id"]].cpu().numpy()
+                    if mask.shape[0] > 0 and mask.shape[1] > 0:
+                        mask_image = Image.fromarray((mask * 255).astype("uint8"))
+                        colored_mask = Image.new("RGBA", image.size, (0, 0, 0, 0))
+                        mask_draw = ImageDraw.Draw(colored_mask)
+                        r, g, b = (segment["id"] * 50) % 255, (segment["id"] * 100) % 255, (segment["id"] * 150) % 255
+                        mask_draw.bitmap((0, 0), mask_image, fill=(r, g, b, 128))
+                        image = Image.alpha_composite(image.convert("RGBA"), colored_mask).convert("RGB")
+                        draw = ImageDraw.Draw(image)
+
+                if score > CONFIDENCE_THRESHOLD:
+                    object_names.append(label_name)
+                    confidence_scores.append(float(score))
+                    object_counter[label_name] = float(score)
+        else:
+            results = processor.post_process_object_detection(outputs, target_sizes=target_sizes)[0]
+
+            for score, label, box in zip(results["scores"], results["labels"], results["boxes"]):
+                if score > CONFIDENCE_THRESHOLD:
+                    x, y, x2, y2 = box.tolist()
+                    draw.rectangle([x, y, x2, y2], outline="#32CD32", width=2)
+                    label_name = model.config.id2label.get(label.item(), "Unknown")
+                    # Place text at top-right corner, outside the box, with smaller size
+                    text = f"{label_name}: {score:.2f}"
+                    text_bbox = draw.textbbox((0, 0), text)
+                    text_width, text_height = text_bbox[2] - text_bbox[0], text_bbox[3] - text_bbox[1]
+                    draw.text((x2 - text_width - 2, y - text_height - 2), text, fill="#32CD32")
+                    object_names.append(label_name)
+                    confidence_scores.append(float(score))
+                    object_counter[label_name] = float(score)
+
+        unique_objects = list(object_counter.keys())
+        unique_confidences = [object_counter[obj] for obj in unique_objects]
+
+        # Image properties
+        file_size = "Unknown"
+        if hasattr(image, "fp") and image.fp is not None:
+            buffered = BytesIO()
+            image.save(buffered, format="PNG")
+            file_size = f"{len(buffered.getvalue()) / 1024:.2f} KB"
+        
+        # Color statistics
+        try:
+            stat = ImageStat.Stat(image)
+            color_stats = {
+                "mean": [f"{m:.2f}" for m in stat.mean],
+                "stddev": [f"{s:.2f}" for s in stat.stddev]
+            }
+        except Exception as e:
+            logger.error(f"Error calculating color statistics: {str(e)}")
+            color_stats = {"mean": "Error", "stddev": "Error"}
+
+        properties = {
+            "Format": image.format if hasattr(image, "format") and image.format else "Unknown",
+            "Size": f"{image.width}x{image.height}",
+            "Width": f"{image.width} px",
+            "Height": f"{image.height} px",
+            "Mode": image.mode,
+            "Aspect Ratio": f"{round(image.width / image.height, 2) if image.height != 0 else 'Undefined'}",
+            "File Size": file_size,
+            "Mean (R,G,B)": ", ".join(color_stats["mean"]) if isinstance(color_stats["mean"], list) else color_stats["mean"],
+            "StdDev (R,G,B)": ", ".join(color_stats["stddev"]) if isinstance(color_stats["stddev"], list) else color_stats["stddev"]
+        }
+
+        return image, object_names, confidence_scores, unique_objects, unique_confidences, properties
+    except Exception as e:
+        logger.error(f"Error in process: {str(e)}\n{traceback.format_exc()}")
+        raise
+
+# FastAPI Setup
+app = FastAPI(title="Object Detection API")
+
+@app.post("/detect")
+async def detect_objects_endpoint(
+    file: UploadFile = File(None),
+    image_url: str = Form(None),
+    model_name: str = Form(VALID_MODELS[0])
+):
+    """FastAPI endpoint to detect objects in an image from file or URL."""
+    try:
+        if (file is None and not image_url) or (file is not None and image_url):
+            raise HTTPException(status_code=400, detail="Provide either an image file or an image URL, but not both.")
+
+        if file:
+            if not file.content_type.startswith("image/"):
+                raise HTTPException(status_code=400, detail="File must be an image")
+            contents = await file.read()
+            image = Image.open(BytesIO(contents)).convert("RGB")
+        else:
+            response = requests.get(image_url, timeout=10)
+            response.raise_for_status()
+            image = Image.open(BytesIO(response.content)).convert("RGB")
+
+        if model_name not in VALID_MODELS:
+            raise HTTPException(status_code=400, detail=f"Invalid model. Choose from: {VALID_MODELS}")
+
+        detected_image, detected_objects, detected_confidences, unique_objects, unique_confidences, _ = process(image, model_name)
+
+        buffered = BytesIO()
+        detected_image.save(buffered, format="PNG")
+        img_base64 = base64.b64encode(buffered.getvalue()).decode("utf-8")
+        img_url = f"data:image/png;base64,{img_base64}"
+
+        return JSONResponse(content={
+            "image_url": img_url,
+            "detected_objects": detected_objects,
+            "confidence_scores": detected_confidences,
+            "unique_objects": unique_objects,
+            "unique_confidence_scores": unique_confidences
+        })
+    except Exception as e:
+        logger.error(f"Error in FastAPI endpoint: {str(e)}\n{traceback.format_exc()}")
+        raise HTTPException(status_code=500, detail=f"Error processing image: {str(e)}")
+
+# Gradio UI
+def create_gradio_ui():
+    with gr.Blocks(theme=gr.themes.Default(primary_hue="blue", secondary_hue="gray")) as demo:
+        gr.Markdown(
+            """
+            # 🚀 Object Detection App
+            Upload an image or provide a URL to detect objects using state-of-the-art transformer models (DETR, YOLOS).
+            """
+        )
+        
+        with gr.Tabs():
+            with gr.Tab("📷 Image Upload"):
+                with gr.Row():
+                    with gr.Column(scale=1):
+                        gr.Markdown("### Input")
+                        model_choice = gr.Dropdown(
+                            choices=VALID_MODELS,
+                            value=VALID_MODELS[0],
+                            label="🔎 Select Model",
+                            info="Choose a model for object detection or panoptic segmentation."
+                        )
+                        model_info = gr.Markdown(
+                            f"**Model Info**: {MODEL_DESCRIPTIONS[VALID_MODELS[0]]}",
+                            visible=True
+                        )
+                        image_input = gr.Image(type="pil", label="📷 Upload Image")
+                        image_url_input = gr.Textbox(
+                            label="🔗 Image URL",
+                            placeholder="https://example.com/image.jpg"
+                        )
+                        with gr.Row():
+                            submit_btn = gr.Button("✨ Detect", variant="primary")
+                            clear_btn = gr.Button("🗑️ Clear", variant="secondary")
+                        
+                        model_choice.change(
+                            fn=lambda model_name: f"**Model Info**: {MODEL_DESCRIPTIONS.get(model_name, 'No description available.')}",
+                            inputs=model_choice,
+                            outputs=model_info
+                        )
+                    
+                    with gr.Column(scale=2):
+                        gr.Markdown("### Results")
+                        error_output = gr.Textbox(
+                            label="⚠️ Errors",
+                            visible=False,
+                            lines=3,
+                            max_lines=5
+                        )
+                        output_image = gr.Image(
+                            type="pil",
+                            label="🎯 Detected Image",
+                            interactive=False
+                        )
+                        with gr.Row():
+                            objects_output = gr.DataFrame(
+                                label="📋 Detected Objects",
+                                interactive=False,
+                                value=None
+                            )
+                            unique_objects_output = gr.DataFrame(
+                                label="🔍 Unique Objects",
+                                interactive=False,
+                                value=None
+                            )
+                        properties_output = gr.DataFrame(
+                            label="📄 Image Properties",
+                            interactive=False,
+                            value=None
+                        )
+                
+                def process_for_gradio(image, url, model_name):
+                    try:
+                        if image is None and not url:
+                            return None, None, None, None, "Please provide an image or URL"
+                        if image and url:
+                            return None, None, None, None, "Please provide either an image or URL, not both"
+                        
+                        if url:
+                            response = requests.get(url, timeout=10)
+                            response.raise_for_status()
+                            image = Image.open(BytesIO(response.content)).convert("RGB")
+                        
+                        detected_image, objects, scores, unique_objects, unique_scores, properties = process(image, model_name)
+                        objects_df = pd.DataFrame({
+                            "Object": objects,
+                            "Confidence Score": [f"{score:.2f}" for score in scores]
+                        }) if objects else pd.DataFrame(columns=["Object", "Confidence Score"])
+                        unique_objects_df = pd.DataFrame({
+                            "Unique Object": unique_objects,
+                            "Confidence Score": [f"{score:.2f}" for score in unique_scores]
+                        }) if unique_objects else pd.DataFrame(columns=["Unique Object", "Confidence Score"])
+                        properties_df = pd.DataFrame([properties]) if properties else pd.DataFrame(columns=properties.keys())
+                        return detected_image, objects_df, unique_objects_df, properties_df, ""
+                    except Exception as e:
+                        error_msg = f"Error processing image: {str(e)}"
+                        logger.error(f"{error_msg}\n{traceback.format_exc()}")
+                        return None, None, None, None, error_msg
+
+                submit_btn.click(
+                    fn=process_for_gradio,
+                    inputs=[image_input, image_url_input, model_choice],
+                    outputs=[output_image, objects_output, unique_objects_output, properties_output, error_output]
+                )
+                
+                clear_btn.click(
+                    fn=lambda: [None, "", None, None, None, None],
+                    inputs=None,
+                    outputs=[image_input, image_url_input, output_image, objects_output, unique_objects_output, properties_output, error_output]
+                )
+            
+            with gr.Tab("🔗 URL Input"):
+                gr.Markdown("### Process Image from URL")
+                image_url_input = gr.Textbox(
+                    label="🔗 Image URL",
+                    placeholder="https://example.com/image.jpg"
+                )
+                url_model_choice = gr.Dropdown(
+                    choices=VALID_MODELS,
+                    value=VALID_MODELS[0],
+                    label="🔎 Select Model"
+                )
+                url_model_info = gr.Markdown(
+                    f"**Model Info**: {MODEL_DESCRIPTIONS[VALID_MODELS[0]]}",
+                    visible=True
+                )
+                url_submit_btn = gr.Button("🔄 Process URL", variant="primary")
+                url_output = gr.JSON(label="API Response")
+                
+                url_model_choice.change(
+                    fn=lambda model_name: f"**Model Info**: {MODEL_DESCRIPTIONS.get(model_name, 'No description available.')}",
+                    inputs=url_model_choice,
+                    outputs=url_model_info
+                )
+                
+                def process_url_for_gradio(url, model_name):
+                    try:
+                        response = requests.get(url, timeout=10)
+                        response.raise_for_status()
+                        image = Image.open(BytesIO(response.content)).convert("RGB")
+                        detected_image, objects, scores, unique_objects, unique_scores, _ = process(image, model_name)
+                        buffered = BytesIO()
+                        detected_image.save(buffered, format="PNG")
+                        img_base64 = base64.b64encode(buffered.getvalue()).decode("utf-8")
+                        return {
+                            "image_url": f"data:image/png;base64,{img_base64}",
+                            "detected_objects": objects,
+                            "confidence_scores": scores,
+                            "unique_objects": unique_objects,
+                            "unique_confidence_scores": unique_scores
+                        }
+                    except Exception as e:
+                        error_msg = f"Error processing URL: {str(e)}"
+                        logger.error(f"{error_msg}\n{traceback.format_exc()}")
+                        return {"error": error_msg}
+
+                url_submit_btn.click(
+                    fn=process_url_for_gradio,
+                    inputs=[image_url_input, url_model_choice],
+                    outputs=[url_output]
+                )
+            
+            with gr.Tab("ℹ️ Help"):
+                gr.Markdown(
+                    """
+                    ## How to Use
+                    - **Image Upload**: Select a model, upload an image or provide a URL, and click "Detect" to see detected objects and image properties.
+                    - **URL Input**: Enter an image URL, select a model, and click "Process URL" to get results in JSON format.
+                    - **Models**: Choose from DETR (object detection or panoptic segmentation) or YOLOS (lightweight detection).
+                    - **Clear**: Reset all inputs and outputs using the "Clear" button.
+                    - **Errors**: Check the error box for any processing issues.
+                    
+                    ## Tips
+                    - Use high-quality images for better detection results.
+                    - Panoptic models (e.g., DETR-ResNet-50-panoptic) provide segmentation masks for complex scenes.
+                    - For faster processing, try YOLOS-Tiny on resource-constrained devices.
+                    """
+                )
+
+    return demo
+
+if __name__ == "__main__":
+    demo = create_gradio_ui()
+    demo.launch()
+    # To run FastAPI, use: uvicorn object_detection:app --host 0.0.0.0 --port 8000

hf_space/hf_space/hf_space/.gitattributes

@@ -0,0 +1,35 @@
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.mlmodel filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tar filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz filter=lfs diff=lfs merge=lfs -text
+*.zip filter=lfs diff=lfs merge=lfs -text
+*.zst filter=lfs diff=lfs merge=lfs -text
+*tfevents* filter=lfs diff=lfs merge=lfs -text

hf_space/hf_space/hf_space/README.md

@@ -0,0 +1,13 @@
+---
+title: ObjectDetection
+emoji: 🐢
+colorFrom: red
+colorTo: blue
+sdk: gradio
+sdk_version: 5.29.0
+app_file: app.py
+pinned: false
+license: mit
+---
+
+Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

hf_space/hf_space/requirements.txt

@@ -0,0 +1,8 @@
+transformers
+torch
+tensorflow
+gradio
+pillow
+timm
+fastapi
+requests

requirements.txt

@@ -5,4 +5,7 @@ gradio
 pillow
 timm
 fastapi
-requests
+requests
+uvicorn 
+pandas 
+nest_asyncio