Update app.py

app.py

@@ -1,391 +1,287 @@
 import gradio as gr
-import cv2
-import numpy as np
-from PIL import Image
+from diffusers import StableDiffusionInstructPix2PixPipeline
+from transformers import YolosImageProcessor, YolosForObjectDetection, BlipProcessor, BlipForConditionalGeneration
+from PIL import Image, ImageDraw, ImageFont
 import torch
-from transformers import DetrImageProcessor, DetrForObjectDetection
-from collections import defaultdict
-import time
-import psutil
-import os
+import json
 
-# Load DETR model (optimized for CPU)
-print("Loading DETR model...")
-processor = DetrImageProcessor.from_pretrained("facebook/detr-resnet-50")
-model = DetrForObjectDetection.from_pretrained("facebook/detr-resnet-50")
-model.eval()
+# Global models
+pipe = None
+detector = None
+detector_processor = None
+captioner = None
+caption_processor = None
 
-# COCO class labels
-COCO_CLASSES = [
-    'N/A', 'person', 'bicycle', 'car', 'motorcycle', 'airplane', 'bus',
-    'train', 'truck', 'boat', 'traffic light', 'fire hydrant', 'N/A',
-    'stop sign', 'parking meter', 'bench', 'bird', 'cat', 'dog', 'horse',
-    'sheep', 'cow', 'elephant', 'bear', 'zebra', 'giraffe', 'N/A', 'backpack',
-    'umbrella', 'N/A', 'N/A', 'handbag', 'tie', 'suitcase', 'frisbee', 'skis',
-    'snowboard', 'sports ball', 'kite', 'baseball bat', 'baseball glove',
-    'skateboard', 'surfboard', 'tennis racket', 'bottle', 'N/A', 'wine glass',
-    'cup', 'fork', 'knife', 'spoon', 'bowl', 'banana', 'apple', 'sandwich',
-    'orange', 'broccoli', 'carrot', 'hot dog', 'pizza', 'donut', 'cake',
-    'chair', 'couch', 'potted plant', 'bed', 'N/A', 'dining table', 'N/A',
-    'N/A', 'toilet', 'N/A', 'tv', 'laptop', 'mouse', 'remote', 'keyboard',
-    'cell phone', 'microwave', 'oven', 'toaster', 'sink', 'refrigerator', 'N/A',
-    'book', 'clock', 'vase', 'scissors', 'teddy bear', 'hair drier', 'toothbrush'
-]
+# Dynamic color generator
+def generate_color(text):
+    """Generate consistent color from text using hash"""
+    hash_val = hash(text) % 360
+    return f"hsl({hash_val}, 70%, 55%)"
 
-def get_available_memory():
-    """Get available system memory in GB"""
-    return psutil.virtual_memory().available / (1024 ** 3)
+# Dynamic category storage
+DETECTED_CATEGORIES = {}
 
-def auto_adjust_confidence(image_size, num_objects_hint=None):
-    """Dynamically adjust confidence based on image complexity"""
-    pixels = image_size[0] * image_size[1]
-    
-    # Base confidence on image size
-    if pixels < 500000:  # Small image
-        base_confidence = 0.6
-    elif pixels < 2000000:  # Medium image
-        base_confidence = 0.65
-    else:  # Large image
-        base_confidence = 0.7
-    
-    return base_confidence
-
-def auto_calculate_frame_interval(total_frames, video_duration, available_memory_gb):
-    """Dynamically calculate optimal frame interval based on video properties and system resources"""
-    
-    # Base calculations
-    fps = total_frames / video_duration if video_duration > 0 else 30
-    
-    # Memory-based adjustment
-    if available_memory_gb < 2:
-        memory_factor = 3
-    elif available_memory_gb < 4:
-        memory_factor = 2
-    else:
-        memory_factor = 1
-    
-    # Duration-based adjustment
-    if video_duration < 10:
-        duration_factor = 1
-    elif video_duration < 30:
-        duration_factor = 2
-    elif video_duration < 60:
-        duration_factor = 3
-    else:
-        duration_factor = 4
-    
-    # Calculate optimal frames to process
-    target_frames = min(150, max(30, total_frames // (memory_factor * duration_factor)))
-    
-    # Calculate interval
-    interval = max(1, total_frames // target_frames)
-    
-    return interval, target_frames
+def load_models():
+    """Load all models"""
+    global pipe, detector, detector_processor, captioner, caption_processor
+    
+    if pipe is None:
+        print("Loading image editor...")
+        pipe = StableDiffusionInstructPix2PixPipeline.from_pretrained(
+            "timbrooks/instruct-pix2pix",
+            torch_dtype=torch.float16,
+            safety_checker=None
+        )
+        pipe.to("cuda" if torch.cuda.is_available() else "cpu")
+    
+    if detector is None:
+        print("Loading object detector...")
+        detector_processor = YolosImageProcessor.from_pretrained('hustvl/yolos-tiny')
+        detector = YolosForObjectDetection.from_pretrained('hustvl/yolos-tiny')
+        detector.to("cuda" if torch.cuda.is_available() else "cpu")
+    
+    if captioner is None:
+        print("Loading image captioner...")
+        caption_processor = BlipProcessor.from_pretrained("Salesforce/blip-image-captioning-base")
+        captioner = BlipForConditionalGeneration.from_pretrained("Salesforce/blip-image-captioning-base")
+        captioner.to("cuda" if torch.cuda.is_available() else "cpu")
+    
+    print("All models loaded!")
 
-def detect_objects(image, confidence_threshold=None):
-    """Detect objects in a single image with dynamic confidence"""
-    # Convert to RGB if needed
-    if isinstance(image, np.ndarray):
-        image = Image.fromarray(image)
-    
-    # Auto-adjust confidence if not provided
-    if confidence_threshold is None:
-        confidence_threshold = auto_adjust_confidence(image.size)
-    
-    # Prepare image
-    inputs = processor(images=image, return_tensors="pt")
-    
-    # Inference
-    with torch.no_grad():
-        outputs = model(**inputs)
-    
-    # Post-process
-    target_sizes = torch.tensor([image.size[::-1]])
-    results = processor.post_process_object_detection(
-        outputs, target_sizes=target_sizes, threshold=confidence_threshold
-    )[0]
-    
-    return results, image, confidence_threshold
-
-def draw_boxes(image, results):
-    """Draw bounding boxes on image"""
-    img_array = np.array(image)
-    
-    detections = []
-    object_counts = defaultdict(int)
-    
-    for score, label, box in zip(results["scores"], results["labels"], results["boxes"]):
-        box = [round(i, 2) for i in box.tolist()]
-        label_name = COCO_CLASSES[label.item()]
+def detect_objects(image):
+    """Detect objects in image with detailed info"""
+    load_models()
+    
+    try:
+        # Detect objects
+        inputs = detector_processor(images=image, return_tensors="pt")
+        if torch.cuda.is_available():
+            inputs = {k: v.to("cuda") for k, v in inputs.items()}
+        
+        outputs = detector(**inputs)
+        target_sizes = torch.tensor([image.size[::-1]])
+        results = detector_processor.post_process_object_detection(outputs, threshold=0.3, target_sizes=target_sizes)[0]
         
-        if label_name != 'N/A':
-            # Draw rectangle
-            x1, y1, x2, y2 = map(int, box)
-            cv2.rectangle(img_array, (x1, y1), (x2, y2), (0, 255, 0), 2)
+        # Draw on image
+        draw = ImageDraw.Draw(image)
+        try:
+            font = ImageFont.truetype("/usr/share/fonts/truetype/dejavu/DejaVuSans-Bold.ttf", 16)
+        except:
+            font = ImageFont.load_default()
+        
+        detections = []
+        
+        for score, label, box in zip(results["scores"], results["labels"], results["boxes"]):
+            box = [round(i, 2) for i in box.tolist()]
+            label_name = detector.config.id2label[label.item()]
+            confidence = round(score.item(), 3)
             
-            # Add label
-            label_text = f"{label_name}: {score:.2f}"
-            cv2.putText(img_array, label_text, (x1, y1-10),
-                       cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 255, 0), 2)
+            # Auto-generate category and color
+            category = label_name  # Use the label itself as category
+            color = generate_color(label_name)
             
-            detections.append(f"{label_name} ({score:.2%})")
-            object_counts[label_name] += 1
-    
-    return img_array, detections, object_counts
+            # Store in dynamic dict
+            if category not in DETECTED_CATEGORIES:
+                DETECTED_CATEGORIES[category] = color
+            
+            # Draw box
+            draw.rectangle(box, outline=color, width=3)
+            
+            # Draw label background
+            text = f"{label_name} {confidence:.0%}"
+            bbox = draw.textbbox((box[0], box[1]-20), text, font=font)
+            draw.rectangle([bbox[0]-2, bbox[1]-2, bbox[2]+2, bbox[3]+2], fill=color)
+            draw.text((box[0], box[1]-20), text, fill='white', font=font)
+            
+            # Get specific info about this object
+            obj_image = image.crop(box)
+            obj_info = get_detailed_info(obj_image, label_name)
+            
+            detections.append({
+                'label': label_name,
+                'category': category,
+                'confidence': f"{confidence:.1%}",
+                'bbox': box,
+                'color': color,
+                'details': obj_info
+            })
+        
+        # Create HTML output with clickable objects
+        html_output = create_detection_html(detections)
+        
+        return image, html_output, json.dumps(detections, indent=2)
+        
+    except Exception as e:
+        print(f"Detection error: {e}")
+        import traceback
+        traceback.print_exc()
+        return image, f"<p>Error: {str(e)}</p>", "{}"
 
-def process_static_image(image):
-    """Process static image mode with auto-detection"""
-    if image is None:
-        return None, "Please upload an image"
-    
-    start_time = time.time()
-    
-    # Detect objects with auto-adjusted confidence
-    results, pil_image, used_confidence = detect_objects(image, confidence_threshold=None)
-    
-    # Draw boxes
-    annotated_image, detections, object_counts = draw_boxes(pil_image, results)
-    
-    processing_time = time.time() - start_time
-    
-    # Create detailed summary
-    if detections:
-        summary = f"### 🎯 Detection Results\n\n"
-        summary += f"**Found {len(detections)} objects in {processing_time:.2f} seconds**\n\n"
-        summary += f"*Auto-adjusted confidence threshold: {used_confidence:.2f}*\n\n"
-        summary += "#### Detected Objects:\n"
+def get_detailed_info(obj_image, label):
+    """Get detailed description of the detected object"""
+    try:
+        # Generate caption for the object
+        inputs = caption_processor(obj_image, return_tensors="pt")
+        if torch.cuda.is_available():
+            inputs = {k: v.to("cuda") for k, v in inputs.items()}
         
-        # Group by object type
-        for obj_name, count in sorted(object_counts.items(), key=lambda x: x[1], reverse=True):
-            summary += f"- **{obj_name}**: {count} instance(s)\n"
+        out = captioner.generate(**inputs, max_length=50)
+        caption = caption_processor.decode(out[0], skip_special_tokens=True)
         
-        summary += f"\n#### All Detections:\n"
-        for i, d in enumerate(detections, 1):
-            summary += f"{i}. {d}\n"
-    else:
-        summary = f"### ⚠️ No objects detected\n\n"
-        summary += f"*Confidence threshold used: {used_confidence:.2f}*\n\n"
-        summary += "Try uploading a different image with more visible objects."
-    
-    return annotated_image, summary
+        # Create search URL
+        search_query = f"{label} {caption}".replace(' ', '+')
+        search_url = f"https://www.google.com/search?q={search_query}"
+        
+        return {
+            'description': caption,
+            'search_url': search_url
+        }
+    except:
+        search_url = f"https://www.google.com/search?q={label.replace(' ', '+')}"
+        return {
+            'description': f"A {label}",
+            'search_url': search_url
+        }
 
-def process_video(video_path, progress=gr.Progress()):
-    """Process video mode with full auto-adjustment"""
-    if video_path is None:
-        return None, "Please upload a video"
-    
-    progress(0, desc="Analyzing video...")
-    
-    cap = cv2.VideoCapture(video_path)
-    
-    # Get video properties
-    fps = int(cap.get(cv2.CAP_PROP_FPS))
-    total_frames = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
-    width = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
-    height = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
-    duration = total_frames / fps if fps > 0 else 0
-    
-    # Get available memory
-    available_memory = get_available_memory()
-    
-    # Auto-calculate optimal frame interval
-    frame_interval, estimated_frames = auto_calculate_frame_interval(
-        total_frames, duration, available_memory
-    )
-    
-    progress(0.1, desc=f"Processing video (sampling every {frame_interval} frames)...")
-    
-    # Auto-adjust confidence based on video properties
-    frame_size = width * height
-    confidence_threshold = auto_adjust_confidence((width, height))
-    
-    # Output video writer
-    output_path = "output_video.mp4"
-    fourcc = cv2.VideoWriter_fourcc(*'mp4v')
-    out = cv2.VideoWriter(output_path, fourcc, fps, (width, height))
-    
-    frame_count = 0
-    processed_count = 0
-    object_tracker = defaultdict(int)
-    start_time = time.time()
+def create_detection_html(detections):
+    """Create interactive HTML with clickable detections"""
+    if not detections:
+        return "<p>No objects detected</p>"
+    
+    html = """
+    <style>
+        .detection-container {font-family: Arial; padding: 10px;}
+        .detection-item {margin: 15px 0; padding: 15px; border-radius: 8px; border-left: 5px solid; cursor: pointer; transition: transform 0.2s;}
+        .detection-item:hover {transform: translateX(5px); box-shadow: 0 2px 8px rgba(0,0,0,0.1);}
+        .object-label {font-size: 18px; font-weight: bold; margin-bottom: 5px;}
+        .object-details {font-size: 14px; color: #555; margin: 5px 0;}
+        .object-category {display: inline-block; padding: 3px 10px; border-radius: 12px; font-size: 12px; color: white; margin-right: 10px;}
+        .search-link {color: #1a73e8; text-decoration: none; font-size: 13px;}
+        .search-link:hover {text-decoration: underline;}
+    </style>
+    <div class="detection-container">
+    """
+    
+    # Group by category
+    by_category = {}
+    for det in detections:
+        cat = det['category']
+        if cat not in by_category:
+            by_category[cat] = []
+        by_category[cat].append(det)
+    
+    for category, items in by_category.items():
+        color = generate_color(category)
+        html += f"<h3 style='color: {color}; text-transform: capitalize;'>{category}s ({len(items)})</h3>"
+        
+        for det in items:
+            html += f"""
+            <div class="detection-item" style="border-left-color: {det['color']}; background: {det['color']}15;" 
+                 onclick="window.open('{det['details']['search_url']}', '_blank')">
+                <div class="object-label" style="color: {det['color']};">{det['label']}</div>
+                <div class="object-details">
+                    <span class="object-category" style="background: {det['color']};">{det['category']}</span>
+                    <span>Confidence: {det['confidence']}</span>
+                </div>
+                <div class="object-details">{det['details']['description']}</div>
+                <a href="{det['details']['search_url']}" target="_blank" class="search-link" onclick="event.stopPropagation();">
+                    🔍 Learn more about this {det['label']}
+                </a>
+            </div>
+            """
+    
+    html += "</div>"
+    return html
+
+def edit_image(input_image, edit_prompt, num_steps, guidance_scale, image_guidance_scale):
+    """Edit image"""
+    if input_image is None or not edit_prompt.strip():
+        return None, "❌ Provide image and prompt!"
     
-    while cap.isOpened():
-        ret, frame = cap.read()
-        if not ret:
-            break
+    try:
+        load_models()
         
-        # Update progress
-        if frame_count % 30 == 0:
-            progress_pct = (frame_count / total_frames) * 0.8 + 0.1
-            progress(progress_pct, desc=f"Processing frame {frame_count}/{total_frames}")
+        # Resize
+        max_size = 512
+        if max(input_image.size) > max_size:
+            ratio = max_size / max(input_image.size)
+            new_size = tuple(int(dim * ratio) for dim in input_image.size)
+            input_image = input_image.resize(new_size, Image.Resampling.LANCZOS)
         
-        # Process every nth frame
-        if frame_count % frame_interval == 0:
-            # Convert BGR to RGB
-            rgb_frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
-            
-            # Detect objects
-            results, _, _ = detect_objects(rgb_frame, confidence_threshold)
-            
-            # Draw boxes
-            for score, label, box in zip(results["scores"], results["labels"], results["boxes"]):
-                box = [round(i, 2) for i in box.tolist()]
-                label_name = COCO_CLASSES[label.item()]
-                
-                if label_name != 'N/A':
-                    x1, y1, x2, y2 = map(int, box)
-                    cv2.rectangle(frame, (x1, y1), (x2, y2), (0, 255, 0), 2)
-                    
-                    label_text = f"{label_name}: {score:.2f}"
-                    cv2.putText(frame, label_text, (x1, y1-10),
-                               cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 255, 0), 2)
-                    
-                    object_tracker[label_name] += 1
-            
-            processed_count += 1
+        width = (input_image.width // 8) * 8
+        height = (input_image.height // 8) * 8
+        input_image = input_image.resize((width, height))
         
-        out.write(frame)
-        frame_count += 1
-    
-    cap.release()
-    out.release()
-    
-    processing_time = time.time() - start_time
-    
-    progress(1.0, desc="Complete!")
-    
-    # Create detailed summary
-    summary = f"### 🎬 Video Processing Complete\n\n"
-    summary += f"**Processing Time**: {processing_time:.2f} seconds\n\n"
-    summary += "#### Video Information:\n"
-    summary += f"- Duration: {duration:.2f} seconds\n"
-    summary += f"- Total frames: {total_frames}\n"
-    summary += f"- FPS: {fps}\n"
-    summary += f"- Resolution: {width}x{height}\n\n"
-    
-    summary += "#### Auto-Optimization Settings:\n"
-    summary += f"- Confidence threshold: {confidence_threshold:.2f} *(auto-adjusted)*\n"
-    summary += f"- Frame interval: Every {frame_interval} frame(s) *(auto-calculated)*\n"
-    summary += f"- Frames processed: {processed_count}/{total_frames}\n"
-    summary += f"- Available memory: {available_memory:.2f} GB\n\n"
-    
-    if object_tracker:
-        summary += "### 📊 Detected Objects Across Video:\n\n"
-        for obj, count in sorted(object_tracker.items(), key=lambda x: x[1], reverse=True):
-            summary += f"- **{obj}**: {count} detection(s)\n"
-    else:
-        summary += "⚠️ No objects detected in the video.\n"
-        summary += "This might be due to low lighting, fast motion, or absence of recognizable objects."
-    
-    return output_path, summary
+        result = pipe(
+            edit_prompt,
+            image=input_image,
+            num_inference_steps=num_steps,
+            guidance_scale=guidance_scale,
+            image_guidance_scale=image_guidance_scale,
+        ).images[0]
+        
+        return result, "✅ Done!"
+        
+    except Exception as e:
+        return None, f"❌ Error: {str(e)}"
 
-# Create Gradio interface
-with gr.Blocks(title="AI Object Recognition System", theme=gr.themes.Soft()) as demo:
-    gr.Markdown("""
-    # 🤖 AI Object Recognition System
-    ### Intelligent Auto-Adjusting Detection & Tracking
-    
-    This system **automatically optimizes** detection parameters based on:
-    - Image/video size and complexity
-    - Available system resources
-    - Video duration and frame rate
-    
-    **No manual tuning required!**
-    """)
+# Build interface
+with gr.Blocks(theme=gr.themes.Soft()) as demo:
+    gr.Markdown("# 🎨 AI Image Editor & Object Detector")
     
     with gr.Tabs():
-        # Static Image Tab
-        with gr.Tab("📸 Static Mode - Image Detection"):
-            gr.Markdown("""
-            ### Automatic Image Analysis
-            Upload any image and the system will:
-            - Auto-adjust confidence thresholds
-            - Detect all visible objects
-            - Provide detailed statistics
-            """)
-            
+        with gr.Tab("🔍 Detect Objects"):
+            gr.Markdown("Upload an image to detect and identify objects with detailed information")
             with gr.Row():
                 with gr.Column():
-                    static_input = gr.Image(type="numpy", label="Upload Image")
-                    static_btn = gr.Button("🔍 Auto-Detect Objects", variant="primary", size="lg")
-                    gr.Markdown("*The system will automatically optimize detection settings*")
+                    detect_input = gr.Image(label="Upload Image", type="pil")
+                    detect_btn = gr.Button("🔍 Detect Objects", variant="primary", size="lg")
                 
                 with gr.Column():
-                    static_output = gr.Image(label="Detected Objects")
-                    static_summary = gr.Markdown(label="Detection Results")
+                    detect_output = gr.Image(label="Detected Objects")
             
-            static_btn.click(
-                fn=process_static_image,
-                inputs=[static_input],
-                outputs=[static_output, static_summary]
-            )
+            detection_info = gr.HTML(label="Object Details (Click to learn more)")
+            detection_json = gr.JSON(label="Detection Data", visible=False)
             
-            gr.Examples(
-                examples=[],
-                inputs=static_input,
-                label="Try these examples (upload your own images)"
+            detect_btn.click(
+                fn=detect_objects,
+                inputs=[detect_input],
+                outputs=[detect_output, detection_info, detection_json]
             )
         
-        # Dynamic Video Tab
-        with gr.Tab("🎥 Dynamic Mode - Video Detection"):
-            gr.Markdown("""
-            ### Automatic Video Analysis
-            Upload a video and the system will:
-            - Auto-calculate optimal frame sampling
-            - Adjust confidence based on video quality
-            - Optimize for available CPU resources
-            - Track objects across frames
-            
-            **Supports videos of any length!** The system automatically scales processing.
-            """)
-            
+        with gr.Tab("✏️ Edit Image"):
+            gr.Markdown("Edit images with text instructions")
             with gr.Row():
                 with gr.Column():
-                    video_input = gr.Video(label="Upload Video")
-                    video_btn = gr.Button("🎬 Auto-Process Video", variant="primary", size="lg")
-                    gr.Markdown("""
-                    *The system will automatically:*
-                    - Analyze video properties
-                    - Calculate optimal frame sampling
-                    - Adjust detection thresholds
-                    - Monitor system resources
-                    """)
+                    edit_input = gr.Image(label="Upload Image", type="pil")
+                    edit_prompt = gr.Textbox(
+                        label="Instructions",
+                        placeholder="make it a painting, add snow, turn day into night...",
+                        lines=2
+                    )
+                    with gr.Accordion("Settings", open=False):
+                        num_steps = gr.Slider(10, 50, value=20, step=5, label="Steps")
+                        guidance_scale = gr.Slider(1, 10, value=7.5, step=0.5, label="Text Guidance")
+                        image_guidance_scale = gr.Slider(1, 2, value=1.5, step=0.1, label="Image Guidance")
+                    edit_btn = gr.Button("✨ Edit", variant="primary")
                 
                 with gr.Column():
-                    video_output = gr.Video(label="Processed Video with Detections")
-                    video_summary = gr.Markdown(label="Processing Results")
+                    edit_output = gr.Image(label="Result")
+                    edit_status = gr.Textbox(label="Status", interactive=False)
             
-            video_btn.click(
-                fn=process_video,
-                inputs=[video_input],
-                outputs=[video_output, video_summary]
+            edit_btn.click(
+                fn=edit_image,
+                inputs=[edit_input, edit_prompt, num_steps, guidance_scale, image_guidance_scale],
+                outputs=[edit_output, edit_status]
             )
     
     gr.Markdown("""
-    ---
-    ## 🧠 How Auto-Adjustment Works
-    
-    ### Image Mode:
-    - **Small images** (< 500K pixels): Lower confidence threshold for more detections
-    - **Large images** (> 2M pixels): Higher threshold to reduce false positives
-    
-    ### Video Mode:
-    - **Short videos** (< 10s): Process more frames for detail
-    - **Long videos** (> 60s): Smart sampling to maintain performance
-    - **Memory-aware**: Adjusts based on available RAM
-    - **Quality-adaptive**: Balances speed vs accuracy automatically
-    
-    ### 📊 Technical Details:
-    - **Model**: DETR ResNet-50 (Detection Transformer)
-    - **Dataset**: COCO (80+ object categories)
-    - **Optimization**: CPU-friendly with intelligent resource management
-    - **Supported Objects**: People, vehicles, animals, furniture, electronics, food, and more
-    
-    ### 💡 Tips:
-    - The system works best with clear, well-lit images/videos
-    - All adjustments happen automatically - just upload and click!
-    - Processing time varies based on video length and system resources
+    ### 🎯 Features:
+    - **Object Detection**: Identifies objects with bounding boxes and confidence scores
+    - **Categories**: Color-coded by type (vehicles, animals, people, etc.)
+    - **Detailed Info**: AI-generated descriptions for each object
+    - **Clickable Links**: Click any object to learn more about it
+    - **Image Editing**: Transform images with simple text instructions
     """)
 
-if __name__ == "__main__":
-    demo.launch()
+demo.launch()