Update app.py

app.py

@@ -1,59 +1,56 @@
-import os
-import random
-import uuid
+import spaces
 import json
-import time
-import asyncio
+import math
+import os
+import traceback
+from io import BytesIO
+from typing import Any, Dict, List, Optional, Tuple, Iterable
 import re
+import time
 from threading import Thread
-from pathlib import Path
 from io import BytesIO
-from typing import Optional, Tuple, Dict, Any, Iterable
+import uuid
+import tempfile
 
 import gradio as gr
-import spaces
-import torch
 import numpy as np
+import torch
 from PIL import Image
-import cv2
-import requests
-import fitz
 import supervision as sv
 
 from transformers import (
-    Qwen3VLMoeForConditionalGeneration,
+    Qwen3VLForConditionalGeneration,
+    AutoModelForCausalLM,
     AutoProcessor,
-    TextIteratorStreamer,
 )
-from transformers.image_utils import load_image
-
 from gradio.themes import Soft
 from gradio.themes.utils import colors, fonts, sizes
 
 # --- Theme and CSS Definition ---
 
-# Define the new OrangeRed color palette
-colors.orange_red = colors.Color(
-    name="orange_red",
-    c50="#FFF0E5",
-    c100="#FFE0CC",
-    c200="#FFC299",
-    c300="#FFA366",
-    c400="#FF8533",
-    c500="#FF4500",  # OrangeRed base color
-    c600="#E63E00",
-    c700="#CC3700",
-    c800="#B33000",
-    c900="#992900",
-    c950="#802200",
+# Define the SteelBlue color palette
+colors.steel_blue = colors.Color(
+    name="steel_blue",
+    c50="#EBF3F8",
+    c100="#D3E5F0",
+    c200="#A8CCE1",
+    c300="#7DB3D2",
+    c400="#529AC3",
+    c500="#4682B4",  # SteelBlue base color
+    c600="#3E72A0",
+    c700="#36638C",
+    c800="#2E5378",
+    c900="#264364",
+    c950="#1E3450",
 )
 
-class OrangeRedTheme(Soft):
+
+class SteelBlueTheme(Soft):
     def __init__(
         self,
         *,
         primary_hue: colors.Color | str = colors.gray,
-        secondary_hue: colors.Color | str = colors.orange_red, # Use the new color
+        secondary_hue: colors.Color | str = colors.steel_blue,
         neutral_hue: colors.Color | str = colors.slate,
         text_size: sizes.Size | str = sizes.text_lg,
         font: fonts.Font | str | Iterable[fonts.Font | str] = (
@@ -82,12 +79,6 @@ class OrangeRedTheme(Soft):
             button_primary_background_fill_hover="linear-gradient(90deg, *secondary_600, *secondary_700)",
             button_primary_background_fill_dark="linear-gradient(90deg, *secondary_600, *secondary_700)",
             button_primary_background_fill_hover_dark="linear-gradient(90deg, *secondary_500, *secondary_600)",
-            button_secondary_text_color="black",
-            button_secondary_text_color_hover="white",
-            button_secondary_background_fill="linear-gradient(90deg, *primary_300, *primary_300)",
-            button_secondary_background_fill_hover="linear-gradient(90deg, *primary_400, *primary_400)",
-            button_secondary_background_fill_dark="linear-gradient(90deg, *primary_500, *primary_600)",
-            button_secondary_background_fill_hover_dark="linear-gradient(90deg, *primary_500, *primary_500)",
             slider_color="*secondary_500",
             slider_color_dark="*secondary_600",
             block_title_text_weight="600",
@@ -100,7 +91,7 @@ class OrangeRedTheme(Soft):
         )
 
 # Instantiate the new theme
-orange_red_theme = OrangeRedTheme()
+steel_blue_theme = SteelBlueTheme()
 
 css = """
 #main-title h1 {
@@ -109,497 +100,220 @@ css = """
 #output-title h2 {
     font-size: 2.1em !important;
 }
-:root {
-    --color-grey-50: #f9fafb;
-    --banner-background: var(--secondary-400);
-    --banner-text-color: var(--primary-100);
-    --banner-background-dark: var(--secondary-800);
-    --banner-text-color-dark: var(--primary-100);
-    --banner-chrome-height: calc(16px + 43px);
-    --chat-chrome-height-wide-no-banner: 320px;
-    --chat-chrome-height-narrow-no-banner: 450px;
-    --chat-chrome-height-wide: calc(var(--chat-chrome-height-wide-no-banner) + var(--banner-chrome-height));
-    --chat-chrome-height-narrow: calc(var(--chat-chrome-height-narrow-no-banner) + var(--banner-chrome-height));
-}
-.banner-message { background-color: var(--banner-background); padding: 5px; margin: 0; border-radius: 5px; border: none; }
-.banner-message-text { font-size: 13px; font-weight: bolder; color: var(--banner-text-color) !important; }
-body.dark .banner-message { background-color: var(--banner-background-dark) !important; }
-body.dark .gradio-container .contain .banner-message .banner-message-text { color: var(--banner-text-color-dark) !important; }
-.toast-body { background-color: var(--color-grey-50); }
-.html-container:has(.css-styles) { padding: 0; margin: 0; }
-.css-styles { height: 0; }
-.model-message { text-align: end; }
-.model-dropdown-container { display: flex; align-items: center; gap: 10px; padding: 0; }
-.user-input-container .multimodal-textbox{ border: none !important; }
-.control-button { height: 51px; }
-button.cancel { border: var(--button-border-width) solid var(--button-cancel-border-color); background: var(--button-cancel-background-fill); color: var(--button-cancel-text-color); box-shadow: var(--button-cancel-shadow); }
-button.cancel:hover, .cancel[disabled] { background: var(--button-cancel-background-fill-hover); color: var(--button-cancel-text-color-hover); }
-.opt-out-message { top: 8px; }
-.opt-out-message .html-container, .opt-out-checkbox label { font-size: 14px !important; padding: 0 !important; margin: 0 !important; color: var(--neutral-400) !important; }
-div.block.chatbot { height: calc(100svh - var(--chat-chrome-height-wide)) !important; max-height: 900px !important; }
-div.no-padding { padding: 0 !important; }
-@media (max-width: 1280px) { div.block.chatbot { height: calc(100svh - var(--chat-chrome-height-wide)) !important; } }
-@media (max-width: 1024px) {
-    .responsive-row { flex-direction: column; }
-    .model-message { text-align: start; font-size: 10px !important; }
-    .model-dropdown-container { flex-direction: column; align-items: flex-start; }
-    div.block.chatbot { height: calc(100svh - var(--chat-chrome-height-narrow)) !important; }
-}
-@media (max-width: 400px) {
-    .responsive-row { flex-direction: column; }
-    .model-message { text-align: start; font-size: 10px !important; }
-    .model-dropdown-container { flex-direction: column; align-items: flex-start; }
-    div.block.chatbot { max-height: 360px !important; }
-}
-@media (max-height: 932px) { .chatbot { max-height: 500px !important; } }
-@media (max-height: 1280px) { div.block.chatbot { max-height: 800px !important; } }
 """
 
-MAX_MAX_NEW_TOKENS = 4096
-DEFAULT_MAX_NEW_TOKENS = 1024
+
+# --- Constants and Model Setup ---
 device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
 
+print("--- System Information ---")
 print("CUDA_VISIBLE_DEVICES=", os.environ.get("CUDA_VISIBLE_DEVICES"))
 print("torch.__version__ =", torch.__version__)
 print("torch.version.cuda =", torch.version.cuda)
-print("cuda available:", torch.cuda.is_available())
-print("cuda device count:", torch.cuda.device_count())
+print("CUDA available:", torch.cuda.is_available())
+print("CUDA device count:", torch.cuda.device_count())
 if torch.cuda.is_available():
-    print("current device:", torch.cuda.current_device())
-    print("device name:", torch.cuda.get_device_name(torch.cuda.current_device()))
+    print("Current device:", torch.cuda.current_device())
+    print("Device name:", torch.cuda.get_device_name(torch.cuda.current_device()))
 print("Using device:", device)
+print("--------------------------")
+
+
+# --- Model Loading ---
 
-MODEL_ID_Q3VL = "Qwen/Qwen3-VL-30B-A3B-Instruct"
-processor_q3vl = AutoProcessor.from_pretrained(MODEL_ID_Q3VL, trust_remote_code=True, use_fast=False)
-model_q3vl = Qwen3VLMoeForConditionalGeneration.from_pretrained(
-    MODEL_ID_Q3VL,
+# Load moondream3
+print("Loading moondream3-preview...")
+MODEL_ID_MD3 = "Qwen/Qwen3-VL-32B-Instruct"
+model_md3 = Qwen3VLForConditionalGeneration.from_pretrained(
+    MODEL_ID_MD3,
     trust_remote_code=True,
-    dtype=torch.float16
-).to(device).eval()
-
-# --- Utility functions for Detection and Drawing ---
-
-def parse_detection_output(text: str) -> list:
-    """Parses the model's text output to extract bounding boxes or points."""
-    match = re.search(r'\[\s*\[.*?\]\s*\]', text)
-    if not match:
-        return []
-    try:
-        result = json.loads(match.group(0))
-        if isinstance(result, list) and all(isinstance(item, list) for item in result):
-            return result
-        return []
-    except (json.JSONDecodeError, TypeError):
-        return []
-
-def draw_object_detections(image: Image.Image, detections: list, labels: list) -> Image.Image:
-    """Draws bounding boxes on the image."""
-    image_np = np.array(image.convert("RGB"))
-    h, w, _ = image_np.shape
-    boxes = []
-    for box in detections:
-        if len(box) == 4:
-            x1, y1, x2, y2 = box
-            boxes.append([x1 * w, y1 * h, x2 * w, y2 * h])
-    if not boxes:
+    torch_dtype=torch.bfloat16,
+    device_map={"": "cuda"},
+)
+model_md3.compile()
+print("moondream3-preview loaded and compiled.")
+
+
+# --- Moondream3 Utility Functions ---
+
+def create_annotated_image(image, detection_result, object_name="Object"):
+    if not isinstance(detection_result, dict) or "objects" not in detection_result:
         return image
-    detections_sv = sv.Detections(xyxy=np.array(boxes))
-    bounding_box_annotator = sv.BoxAnnotator(thickness=2)
-    label_annotator = sv.LabelAnnotator(text_thickness=1, text_scale=0.5)
-    annotated_image = bounding_box_annotator.annotate(scene=image_np.copy(), detections=detections_sv)
-    annotated_image = label_annotator.annotate(scene=annotated_image, detections=detections_sv, labels=labels)
-    return Image.fromarray(annotated_image)
 
-def draw_point_detections(image: Image.Image, points: list) -> Image.Image:
-    """Draws points on the image."""
-    image_np = np.array(image.convert("RGB"))
-    h, w, _ = image_np.shape
-    pts = []
-    for point in points:
-        if len(point) == 2:
-            x, y = point
-            pts.append([x * w, y * h])
-    if not pts:
+    original_width, original_height = image.size
+    annotated_image = np.array(image.convert("RGB"))
+
+    bboxes = []
+    labels = []
+
+    for i, obj in enumerate(detection_result["objects"]):
+        x_min = int(obj["x_min"] * original_width)
+        y_min = int(obj["y_min"] * original_height)
+        x_max = int(obj["x_max"] * original_width)
+        y_max = int(obj["y_max"] * original_height)
+
+        x_min = max(0, min(x_min, original_width))
+        y_min = max(0, min(y_min, original_height))
+        x_max = max(0, min(x_max, original_width))
+        y_max = max(0, min(y_max, original_height))
+
+        if x_max > x_min and y_max > y_min:
+            bboxes.append([x_min, y_min, x_max, y_max])
+            labels.append(f"{object_name} {i+1}")
+
+    if not bboxes:
         return image
-    points_np = np.array(pts).reshape(1, -1, 2)
-    key_points = sv.KeyPoints(xy=points_np)
-    point_annotator = sv.VertexAnnotator(radius=5, color=sv.Color.RED)
-    annotated_image = point_annotator.annotate(scene=image_np.copy(), key_points=key_points)
-    return Image.fromarray(annotated_image)
 
+    detections = sv.Detections(
+        xyxy=np.array(bboxes, dtype=np.float32),
+        class_id=np.arange(len(bboxes))
+    )
 
-# --- Core Generation Functions ---
-
-def extract_gif_frames(gif_path: str):
-    if not gif_path:
-        return []
-    with Image.open(gif_path) as gif:
-        total_frames = gif.n_frames
-        frame_indices = np.linspace(0, total_frames - 1, min(total_frames, 10), dtype=int)
-        frames = []
-        for i in frame_indices:
-            gif.seek(i)
-            frames.append(gif.convert("RGB").copy())
-    return frames
-
-def downsample_video(video_path):
-    vidcap = cv2.VideoCapture(video_path)
-    total_frames = int(vidcap.get(cv2.CAP_PROP_FRAME_COUNT))
-    frames = []
-    frame_indices = np.linspace(0, total_frames - 1, min(total_frames, 10), dtype=int)
-    for i in frame_indices:
-        vidcap.set(cv2.CAP_PROP_POS_FRAMES, i)
-        success, image = vidcap.read()
-        if success:
-            image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
-            pil_image = Image.fromarray(image)
-            frames.append(pil_image)
-    vidcap.release()
-    return frames
-
-def convert_pdf_to_images(file_path: str, dpi: int = 200):
-    if not file_path:
-        return []
-    images = []
-    pdf_document = fitz.open(file_path)
-    zoom = dpi / 72.0
-    mat = fitz.Matrix(zoom, zoom)
-    for page_num in range(len(pdf_document)):
-        page = pdf_document.load_page(page_num)
-        pix = page.get_pixmap(matrix=mat)
-        img_data = pix.tobytes("png")
-        images.append(Image.open(BytesIO(img_data)))
-    pdf_document.close()
-    return images
-
-def get_initial_pdf_state() -> Dict[str, Any]:
-    return {"pages": [], "total_pages": 0, "current_page_index": 0}
-
-def load_and_preview_pdf(file_path: Optional[str]) -> Tuple[Optional[Image.Image], Dict[str, Any], str]:
-    state = get_initial_pdf_state()
-    if not file_path:
-        return None, state, '<div style="text-align:center;">No file loaded</div>'
-    try:
-        pages = convert_pdf_to_images(file_path)
-        if not pages:
-            return None, state, '<div style="text-align:center;">Could not load file</div>'
-        state["pages"] = pages
-        state["total_pages"] = len(pages)
-        page_info_html = f'<div style="text-align:center;">Page 1 / {state["total_pages"]}</div>'
-        return pages[0], state, page_info_html
-    except Exception as e:
-        return None, state, f'<div style="text-align:center;">Failed to load preview: {e}</div>'
-
-def navigate_pdf_page(direction: str, state: Dict[str, Any]):
-    if not state or not state["pages"]:
-        return None, state, '<div style="text-align:center;">No file loaded</div>'
-    current_index = state["current_page_index"]
-    total_pages = state["total_pages"]
-    if direction == "prev":
-        new_index = max(0, current_index - 1)
-    elif direction == "next":
-        new_index = min(total_pages - 1, current_index + 1)
-    else:
-        new_index = current_index
-    state["current_page_index"] = new_index
-    image_preview = state["pages"][new_index]
-    page_info_html = f'<div style="text-align:center;">Page {new_index + 1} / {total_pages}</div>'
-    return image_preview, state, page_info_html
-
-@spaces.GPU
-def generate_image(text: str, image: Image.Image, max_new_tokens: int = 1024, temperature: float = 0.6, top_p: float = 0.9, top_k: int = 50, repetition_penalty: float = 1.2):
-    if image is None:
-        yield "Please upload an image.", "Please upload an image."
-        return
-    messages = [{"role": "user", "content": [{"type": "image"}, {"type": "text", "text": text}]}]
-    prompt_full = processor_q3vl.apply_chat_template(messages, tokenize=False, add_generation_prompt=True)
-    inputs = processor_q3vl(text=[prompt_full], images=[image], return_tensors="pt", padding=True).to(device)
-    streamer = TextIteratorStreamer(processor_q3vl, skip_prompt=True, skip_special_tokens=True)
-    generation_kwargs = {**inputs, "streamer": streamer, "max_new_tokens": max_new_tokens}
-    thread = Thread(target=model_q3vl.generate, kwargs=generation_kwargs)
-    thread.start()
-    buffer = ""
-    for new_text in streamer:
-        buffer += new_text
-        time.sleep(0.01)
-        yield buffer, buffer
-
-@spaces.GPU
-def generate_video(text: str, video_path: str, max_new_tokens: int = 1024, temperature: float = 0.6, top_p: float = 0.9, top_k: int = 50, repetition_penalty: float = 1.2):
-    if video_path is None:
-        yield "Please upload a video.", "Please upload a video."
-        return
-    frames = downsample_video(video_path)
-    if not frames:
-        yield "Could not process video.", "Could not process video."
-        return
-    messages = [{"role": "user", "content": [{"type": "text", "text": text}]}]
-    for frame in frames:
-        messages[0]["content"].insert(0, {"type": "image"})
-    prompt_full = processor_q3vl.apply_chat_template(messages, tokenize=False, add_generation_prompt=True)
-    inputs = processor_q3vl(text=[prompt_full], images=frames, return_tensors="pt", padding=True).to(device)
-    streamer = TextIteratorStreamer(processor_q3vl, skip_prompt=True, skip_special_tokens=True)
-    generation_kwargs = {**inputs, "streamer": streamer, "max_new_tokens": max_new_tokens, "do_sample": True, "temperature": temperature, "top_p": top_p, "top_k": top_k, "repetition_penalty": repetition_penalty}
-    thread = Thread(target=model_q3vl.generate, kwargs=generation_kwargs)
-    thread.start()
-    buffer = ""
-    for new_text in streamer:
-        buffer += new_text
-        buffer = buffer.replace("<|im_end|>", "")
-        time.sleep(0.01)
-        yield buffer, buffer
-
-@spaces.GPU
-def generate_pdf(text: str, state: Dict[str, Any], max_new_tokens: int = 2048, temperature: float = 0.6, top_p: float = 0.9, top_k: int = 50, repetition_penalty: float = 1.2):
-    if not state or not state["pages"]:
-        yield "Please upload a PDF file first.", "Please upload a PDF file first."
-        return
-    page_images = state["pages"]
-    full_response = ""
-    for i, image in enumerate(page_images):
-        page_header = f"--- Page {i+1}/{len(page_images)} ---\n"
-        yield full_response + page_header, full_response + page_header
-        messages = [{"role": "user", "content": [{"type": "image"}, {"type": "text", "text": text}]}]
-        prompt_full = processor_q3vl.apply_chat_template(messages, tokenize=False, add_generation_prompt=True)
-        inputs = processor_q3vl(text=[prompt_full], images=[image], return_tensors="pt", padding=True).to(device)
-        streamer = TextIteratorStreamer(processor_q3vl, skip_prompt=True, skip_special_tokens=True)
-        generation_kwargs = {**inputs, "streamer": streamer, "max_new_tokens": max_new_tokens}
-        thread = Thread(target=model_q3vl.generate, kwargs=generation_kwargs)
-        thread.start()
-        page_buffer = ""
-        for new_text in streamer:
-            page_buffer += new_text
-            yield full_response + page_header + page_buffer, full_response + page_header + page_buffer
-            time.sleep(0.01)
-        full_response += page_header + page_buffer + "\n\n"
-
-@spaces.GPU
-def generate_caption(image: Image.Image, max_new_tokens: int = 1024, temperature: float = 0.6, top_p: float = 0.9, top_k: int = 50, repetition_penalty: float = 1.2):
-    if image is None:
-        yield "Please upload an image to caption.", "Please upload an image to caption."
-        return
-    system_prompt = (
-        "You are an AI assistant that rigorously follows this response protocol: For every input image, your primary "
-        "task is to write a precise caption that captures the essence of the image in clear, concise, and contextually "
-        "accurate language. Along with the caption, provide a structured set of attributes describing the visual "
-        "elements, including details such as objects, people, actions, colors, environment, mood, and other notable "
-        "characteristics. Ensure captions are precise, neutral, and descriptive, avoiding unnecessary elaboration or "
-        "subjective interpretation unless explicitly required. Do not reference the rules or instructions in the output; "
-        "only return the formatted caption, attributes, and class_name."
+    bounding_box_annotator = sv.BoxAnnotator(
+        thickness=3,
+        color_lookup=sv.ColorLookup.INDEX
+    )
+    label_annotator = sv.LabelAnnotator(
+        text_thickness=2,
+        text_scale=0.6,
+        color_lookup=sv.ColorLookup.INDEX
+    )
+
+    annotated_image = bounding_box_annotator.annotate(
+        scene=annotated_image, detections=detections
     )
-    messages = [{"role": "user", "content": [{"type": "image"}, {"type": "text", "text": system_prompt}]}]
-    prompt_full = processor_q3vl.apply_chat_template(messages, tokenize=False, add_generation_prompt=True)
-    inputs = processor_q3vl(text=[prompt_full], images=[image], return_tensors="pt", padding=True).to(device)
-    streamer = TextIteratorStreamer(processor_q3vl, skip_prompt=True, skip_special_tokens=True)
-    generation_kwargs = {**inputs, "streamer": streamer, "max_new_tokens": max_new_tokens}
-    thread = Thread(target=model_q3vl.generate, kwargs=generation_kwargs)
-    thread.start()
-    buffer = ""
-    for new_text in streamer:
-        buffer += new_text
-        time.sleep(0.01)
-        yield buffer, buffer
-
-@spaces.GPU
-def generate_gif(text: str, gif_path: str, max_new_tokens: int = 1024, temperature: float = 0.6, top_p: float = 0.9, top_k: int = 50, repetition_penalty: float = 1.2):
-    if gif_path is None:
-        yield "Please upload a GIF.", "Please upload a GIF."
-        return
-    frames = extract_gif_frames(gif_path)
-    if not frames:
-        yield "Could not process GIF.", "Could not process GIF."
-        return
-    messages = [{"role": "user", "content": [{"type": "text", "text": text}]}]
-    for frame in frames:
-        messages[0]["content"].insert(0, {"type": "image"})
-    prompt_full = processor_q3vl.apply_chat_template(messages, tokenize=False, add_generation_prompt=True)
-    inputs = processor_q3vl(text=[prompt_full], images=frames, return_tensors="pt", padding=True).to(device)
-    streamer = TextIteratorStreamer(processor_q3vl, skip_prompt=True, skip_special_tokens=True)
-    generation_kwargs = {**inputs, "streamer": streamer, "max_new_tokens": max_new_tokens, "do_sample": True, "temperature": temperature, "top_p": top_p, "top_k": top_k, "repetition_penalty": repetition_penalty}
-    thread = Thread(target=model_q3vl.generate, kwargs=generation_kwargs)
-    thread.start()
-    buffer = ""
-    for new_text in streamer:
-        buffer += new_text
-        buffer = buffer.replace("<|im_end|>", "")
-        time.sleep(0.01)
-        yield buffer, buffer
-
-@spaces.GPU
-def generate_detection(
-    image: Image.Image, user_prompt: str, task_type: str, max_new_tokens: int = 256,
-    temperature: float = 0.1, top_p: float = 0.9, top_k: int = 50, repetition_penalty: float = 1.2
-):
+    annotated_image = label_annotator.annotate(
+        scene=annotated_image, detections=detections, labels=labels
+    )
+
+    return Image.fromarray(annotated_image)
+
+def create_point_annotated_image(image, point_result):
+    if not isinstance(point_result, dict) or "points" not in point_result:
+        return image
+
+    original_width, original_height = image.size
+    annotated_image = np.array(image.convert("RGB"))
+
+    points = []
+    for point in point_result["points"]:
+        x = int(point["x"] * original_width)
+        y = int(point["y"] * original_height)
+        points.append([x, y])
+
+    if points:
+        points_array = np.array(points).reshape(1, -1, 2)
+        key_points = sv.KeyPoints(xy=points_array)
+        vertex_annotator = sv.VertexAnnotator(radius=8, color=sv.Color.RED)
+        annotated_image = vertex_annotator.annotate(
+            scene=annotated_image, key_points=key_points
+        )
+
+    return Image.fromarray(annotated_image)
+
+@spaces.GPU()
+def detect_objects_md3(image, prompt, task_type, max_objects):
+    STANDARD_SIZE = (1024, 1024)
     if image is None:
-        return None, "Please upload an image."
-    if not user_prompt:
-        return image, "Please provide a prompt describing what to detect."
+        raise gr.Error("Please upload an image.")
+    image.thumbnail(STANDARD_SIZE)
+
+    t0 = time.perf_counter()
 
     if task_type == "Object Detection":
-        system_prompt = (
-            f"You are an expert object detector. Find all instances of '{user_prompt}' in the image. "
-            "Respond ONLY with a Python list of bounding boxes in the format [[x_min, y_min, x_max, y_max], ...]. "
-            "The coordinates must be normalized between 0.0 and 1.0."
-        )
+        settings = {"max_objects": max_objects} if max_objects > 0 else {}
+        result = model_md3.detect(image, prompt, settings=settings)
+        annotated_image = create_annotated_image(image, result, prompt)
     elif task_type == "Point Detection":
-        system_prompt = (
-            f"You are an expert keypoint detector. Find the specific points for '{user_prompt}' in the image. "
-            "Respond ONLY with a Python list of points in the format [[x, y], ...]. "
-            "The coordinates must be normalized between 0.0 and 1.0."
-        )
+        result = model_md3.point(image, prompt)
+        annotated_image = create_point_annotated_image(image, result)
+    elif task_type == "Caption":
+        result = model_md3.caption(image, length="normal")
+        annotated_image = image
     else:
-        return image, "Invalid task type specified."
-
-    messages = [{"role": "user", "content": [{"type": "image"}, {"type": "text", "text": system_prompt}]}]
-    prompt_full = processor_q3vl.apply_chat_template(messages, tokenize=False, add_generation_prompt=True)
-    inputs = processor_q3vl(text=[prompt_full], images=[image], return_tensors="pt", padding=True).to(device)
-
-    generation_kwargs = {
-        **inputs, "max_new_tokens": max_new_tokens, "do_sample": True, "temperature": temperature,
-        "top_p": top_p, "top_k": top_k, "repetition_penalty": repetition_penalty,
-    }
-
-    generate_ids = model_q3vl.generate(**generation_kwargs)
-    generate_ids = generate_ids[:, inputs['input_ids'].shape[1]:]
-    response_text = processor_q3vl.batch_decode(generate_ids, skip_special_tokens=True, clean_up_tokenization_spaces=False)[0]
-
-    try:
-        coords = parse_detection_output(response_text)
-        if not coords:
-            return image, f"Could not detect '{user_prompt}'.\nModel raw output:\n{response_text}"
-        if task_type == "Object Detection":
-            labels = [f"{user_prompt} #{i+1}" for i in range(len(coords))]
-            annotated_image = draw_object_detections(image, coords, labels)
-        else: # Point Detection
-            annotated_image = draw_point_detections(image, coords)
-        return annotated_image, response_text
-    except Exception as e:
-        return image, f"An error occurred during processing:\n{str(e)}\n\nModel raw output:\n{response_text}"
-
-
-image_examples = [["Perform OCR on the image...", "examples/images/1.jpg"],
-                  ["Caption the image. Describe the safety measures shown in the image. Conclude whether the situation is (safe or unsafe)...", "examples/images/2.jpg"],
-                  ["Solve the problem...", "examples/images/3.png"]]
-video_examples = [["Explain the Ad video in detail.", "examples/videos/1.mp4"],
-                  ["Explain the video in detail.", "examples/videos/2.mp4"]]
-pdf_examples = [["Extract the content precisely.", "examples/pdfs/doc1.pdf"],
-                ["Analyze and provide a short report.", "examples/pdfs/doc2.pdf"]]
-gif_examples = [["Describe this GIF.", "examples/gifs/1.gif"],
-                ["Describe this GIF.", "examples/gifs/2.gif"]]
-caption_examples = [["examples/captions/1.JPG"],
-                    ["examples/captions/2.jpeg"], ["examples/captions/3.jpeg"]]
-# NOTE: You'll need to create these example image files in a directory named 'examples/detection/'
-obj_det_examples = [["examples/detection/obj1.jpg", "the two people"], ["examples/detection/obj2.jpg", "the yellow taxi"]]
-point_det_examples = [["examples/detection/point1.jpg", "the eyes of the person"], ["examples/detection/point2.jpg", "the headlights of the car"]]
-
-
-with gr.Blocks(theme=orange_red_theme, css=css) as demo:
-    pdf_state = gr.State(value=get_initial_pdf_state())
-    gr.Markdown("# **Qwen-3VL:Multimodal**", elem_id="main-title")
-    with gr.Row():
-        with gr.Column(scale=2):
-            with gr.Tabs():
-                with gr.TabItem("Image Inference"):
-                    image_query = gr.Textbox(label="Query Input", placeholder="Enter your query here...")
-                    image_upload = gr.Image(type="pil", label="Upload Image", height=290)
-                    image_submit = gr.Button("Submit", variant="primary")
-                    gr.Examples(examples=image_examples, inputs=[image_query, image_upload])
-
-                with gr.TabItem("Video Inference"):
-                    video_query = gr.Textbox(label="Query Input", placeholder="Enter your query here...")
-                    video_upload = gr.Video(label="Upload Video(≤30s)", height=290)
-                    video_submit = gr.Button("Submit", variant="primary")
-                    gr.Examples(examples=video_examples, inputs=[video_query, video_upload])
-
-                with gr.TabItem("PDF Inference"):
-                    with gr.Row():
-                        with gr.Column(scale=1):
-                            pdf_query = gr.Textbox(label="Query Input", placeholder="e.g., 'Summarize this document'")
-                            pdf_upload = gr.File(label="Upload PDF", file_types=[".pdf"])
-                            pdf_submit = gr.Button("Submit", variant="primary")
-                        with gr.Column(scale=1):
-                            pdf_preview_img = gr.Image(label="PDF Preview", height=290)
-                            with gr.Row():
-                                prev_page_btn = gr.Button("◀ Previous")
-                                page_info = gr.HTML('<div style="text-align:center;">No file loaded</div>')
-                                next_page_btn = gr.Button("Next ▶")
-                    gr.Examples(examples=pdf_examples, inputs=[pdf_query, pdf_upload])
-
-                with gr.TabItem("Gif Inference"):
-                    gif_query = gr.Textbox(label="Query Input", placeholder="e.g., 'What is happening in this gif?'")
-                    gif_upload = gr.Image(type="filepath", label="Upload GIF", height=290)
-                    gif_submit = gr.Button("Submit", variant="primary")
-                    gr.Examples(examples=gif_examples, inputs=[gif_query, gif_upload])
-                
-                with gr.TabItem("Caption"):
-                    caption_image_upload = gr.Image(type="pil", label="Image to Caption", height=290)
-                    caption_submit = gr.Button("Generate Caption", variant="primary")
-                    gr.Examples(examples=caption_examples, inputs=[caption_image_upload])
-
-                with gr.TabItem("Object Detection"):
-                    with gr.Row():
-                        with gr.Column(scale=1):
-                            obj_det_image_upload = gr.Image(type="pil", label="Upload Image", height=290)
-                            obj_det_query = gr.Textbox(label="Object to Detect", placeholder="e.g., car, person, dog")
-                            obj_det_submit = gr.Button("Detect Objects", variant="primary")
-                        with gr.Column(scale=1):
-                            obj_det_output_image = gr.Image(type="pil", label="Detection Result", height=290)
-                    obj_det_output_text = gr.Textbox(label="Model Raw Output", interactive=False, lines=5)
-                    gr.Examples(examples=obj_det_examples, inputs=[obj_det_image_upload, obj_det_query])
-
-                with gr.TabItem("Point Detection"):
-                    with gr.Row():
-                        with gr.Column(scale=1):
-                            point_det_image_upload = gr.Image(type="pil", label="Upload Image", height=290)
-                            point_det_query = gr.Textbox(label="Point(s) to Detect", placeholder="e.g., the eyes of the cat")
-                            point_det_submit = gr.Button("Detect Points", variant="primary")
-                        with gr.Column(scale=1):
-                            point_det_output_image = gr.Image(type="pil", label="Detection Result", height=290)
-                    point_det_output_text = gr.Textbox(label="Model Raw Output", interactive=False, lines=5)
-                    gr.Examples(examples=point_det_examples, inputs=[point_det_image_upload, point_det_query])
-
-            with gr.Accordion("Advanced options", open=False):
-                max_new_tokens = gr.Slider(label="Max new tokens", minimum=1, maximum=MAX_MAX_NEW_TOKENS, step=1, value=DEFAULT_MAX_NEW_TOKENS)
-                temperature = gr.Slider(label="Temperature", minimum=0.1, maximum=4.0, step=0.1, value=0.6)
-                top_p = gr.Slider(label="Top-p (nucleus sampling)", minimum=0.05, maximum=1.0, step=0.05, value=0.9)
-                top_k = gr.Slider(label="Top-k", minimum=1, maximum=1000, step=1, value=50)
-                repetition_penalty = gr.Slider(label="Repetition penalty", minimum=1.0, maximum=2.0, step=0.05, value=1.2)
-
-        with gr.Column(scale=3):
-            gr.Markdown("## Output", elem_id="output-title")
-            output = gr.Textbox(label="Raw Output Stream (General Tasks)", interactive=False, lines=20, show_copy_button=True)
-            with gr.Accordion("(Result.md)", open=False):
-                markdown_output = gr.Markdown(label="(Result.Md)", latex_delimiters=[
-                                {"left": "$$", "right": "$$", "display": True},
-                                {"left": "$", "right": "$", "display": False}
-                            ])
-
-    # Click handlers for original tabs
-    image_submit.click(fn=generate_image, inputs=[image_query, image_upload, max_new_tokens, temperature, top_p, top_k, repetition_penalty], outputs=[output, markdown_output])
-    video_submit.click(fn=generate_video, inputs=[video_query, video_upload, max_new_tokens, temperature, top_p, top_k, repetition_penalty], outputs=[output, markdown_output])
-    pdf_submit.click(fn=generate_pdf, inputs=[pdf_query, pdf_state, max_new_tokens, temperature, top_p, top_k, repetition_penalty], outputs=[output, markdown_output])
-    gif_submit.click(fn=generate_gif, inputs=[gif_query, gif_upload, max_new_tokens, temperature, top_p, top_k, repetition_penalty], outputs=[output, markdown_output])
-    caption_submit.click(fn=generate_caption, inputs=[caption_image_upload, max_new_tokens, temperature, top_p, top_k, repetition_penalty], outputs=[output, markdown_output])
-
-    # PDF navigation handlers
-    pdf_upload.change(fn=load_and_preview_pdf, inputs=[pdf_upload], outputs=[pdf_preview_img, pdf_state, page_info])
-    prev_page_btn.click(fn=lambda s: navigate_pdf_page("prev", s), inputs=[pdf_state], outputs=[pdf_preview_img, pdf_state, page_info])
-    next_page_btn.click(fn=lambda s: navigate_pdf_page("next", s), inputs=[pdf_state], outputs=[pdf_preview_img, pdf_state, page_info])
-
-    # Click handlers for NEW tabs
-    obj_det_submit.click(
-        fn=generate_detection,
-        inputs=[obj_det_image_upload, obj_det_query, gr.Textbox(value="Object Detection", visible=False),
-                max_new_tokens, temperature, top_p, top_k, repetition_penalty],
-        outputs=[obj_det_output_image, obj_det_output_text]
-    )
-    point_det_submit.click(
-        fn=generate_detection,
-        inputs=[point_det_image_upload, point_det_query, gr.Textbox(value="Point Detection", visible=False),
-                max_new_tokens, temperature, top_p, top_k, repetition_penalty],
-        outputs=[point_det_output_image, point_det_output_text]
-    )
+        result = model_md3.query(image=image, question=prompt, reasoning=True)
+        annotated_image = image
+
+    elapsed_ms = (time.perf_counter() - t0) * 1_000
+
+    if isinstance(result, dict):
+        if "objects" in result:
+          output_text = f"Found {len(result['objects'])} objects:\n"
+          for i, obj in enumerate(result['objects'], 1):
+              output_text += f"\n{i}. Bounding box: ({obj['x_min']:.3f}, {obj['y_min']:.3f}, {obj['x_max']:.3f}, {obj['y_max']:.3f})"
+        elif "points" in result:
+            output_text = f"Found {len(result['points'])} points:\n"
+            for i, point in enumerate(result['points'], 1):
+                output_text += f"\n{i}. Point: ({point['x']:.3f}, {point['y']:.3f})"
+        elif "caption" in result:
+            output_text = result['caption']
+        elif "answer" in result:
+            output_text = f"Reasoning: {result.get('reasoning', 'N/A')}\n\nAnswer: {result['answer']}"
+        else:
+            output_text = json.dumps(result, indent=2)
+    else:
+        output_text = str(result)
+
+    timing_text = f"Inference time: {elapsed_ms:.0f} ms"
+
+    return annotated_image, output_text, timing_text
+
+
+# --- Gradio Interface ---
+
+def create_gradio_interface():
+    """Builds and returns the Gradio web interface."""
+
+    with gr.Blocks(theme=steel_blue_theme, css=css) as demo:
+        gr.Markdown("# **🌝 Moondream3 Lab**", elem_id="main-title")
+        gr.Markdown("Explore the capabilities of the Moondream3 Vision Language Model for tasks like Object/Point Detection, VQA, and Captioning.")
+
+        with gr.Row():
+            with gr.Column(scale=1):
+                md3_image_input = gr.Image(label="Upload an image", type="pil", height=400)
+                md3_task_type = gr.Radio(
+                    choices=["Object Detection", "Point Detection", "Caption", "Visual Question Answering"],
+                    label="Task Type", value="Object Detection"
+                )
+                md3_prompt_input = gr.Textbox(
+                    label="Prompt (object to detect/question to ask)",
+                    placeholder="e.g., 'car', 'person', 'What's in this image?'"
+                )
+                md3_max_objects = gr.Number(
+                    label="Max Objects (for Object Detection only)",
+                    value=10, minimum=1, maximum=50, step=1, visible=True
+                )
+                md3_generate_btn = gr.Button(value="Submit", variant="primary")
+            with gr.Column(scale=1):
+                md3_output_image = gr.Image(type="pil", label="Result", height=400)
+                md3_output_textbox = gr.Textbox(label="Model Response", lines=10, show_copy_button=True)
+                md3_output_time = gr.Markdown()
+
+        gr.Examples(
+            examples=[
+                ["md3/1.jpg", "Object Detection", "boats", 7],
+                ["md3/2.jpg", "Point Detection", "children", 7],
+                ["md3/3.png", "Caption", "", 5],
+                ["md3/4.jpeg", "Visual Question Answering", "Analyze the GDP trend over the years.", 5],
+            ],
+            inputs=[md3_image_input, md3_task_type, md3_prompt_input, md3_max_objects],
+            label="Click an example to populate inputs"
+        )
+
+        # Event listeners for the interface
+        def update_max_objects_visibility(task):
+            return gr.update(visible=(task == "Object Detection"))
+
+        md3_task_type.change(fn=update_max_objects_visibility, inputs=[md3_task_type], outputs=[md3_max_objects])
+
+        md3_generate_btn.click(
+            fn=detect_objects_md3,
+            inputs=[md3_image_input, md3_prompt_input, md3_task_type, md3_max_objects],
+            outputs=[md3_output_image, md3_output_textbox, md3_output_time]
+        )
 
+    return demo
 
 if __name__ == "__main__":
-    demo.queue(max_size=50).launch(mcp_server=True, ssr_mode=False, show_error=True)
+    demo = create_gradio_interface()
+    demo.queue(max_size=50).launch(ssr_mode=False, mcp_server=True, show_error=True)