Update app.py

app.py

@@ -1,397 +1,466 @@
 import streamlit as st
-import cv2
+import torch
+from transformers import DetrImageProcessor, DetrForObjectDetection
+from PIL import Image, ImageDraw, ImageFont
+import io
+import matplotlib.pyplot as plt
+import matplotlib.patches as patches
 import numpy as np
-import mediapipe as mp
-from scipy.spatial import distance
-import av
-from streamlit_webrtc import webrtc_streamer, VideoProcessorBase, RTCConfiguration
-import queue
-import threading
-import time
+from collections import Counter
+import warnings
+warnings.filterwarnings('ignore')
 
-# MediaPipe setup
-mp_face_mesh = mp.solutions.face_mesh
-face_mesh = mp_face_mesh.FaceMesh(
-    min_detection_confidence=0.5,
-    min_tracking_confidence=0.5,
-    max_num_faces=1
+# Page configuration
+st.set_page_config(
+    page_title="Object Detection Playground",
+    page_icon="🔍",
+    layout="wide"
 )
 
-# Eye and mouth landmark indices for MediaPipe
-LEFT_EYE_INDICES = [33, 160, 158, 133, 153, 144]
-RIGHT_EYE_INDICES = [362, 385, 387, 263, 373, 380]
-MOUTH_INDICES = [61, 39, 0, 269, 291, 405, 314, 17, 84, 181, 91, 185]
-
-# Thresholds and parameters
-EAR_THRESHOLD = 0.25  # Eye Aspect Ratio threshold
-MAR_THRESHOLD = 0.5   # Mouth Aspect Ratio threshold
-CONSECUTIVE_FRAMES_EYE = 15  # Frames for eye closure detection
-CONSECUTIVE_FRAMES_MOUTH = 20  # Frames for yawn detection
-ALERT_DURATION = 3  # Alert display duration in seconds
-
-# For Streamlit audio alert (using browser sound)
-AUDIO_ALERT_HTML = """
-<audio id="alertAudio" preload="auto">
-    <source src="https://assets.mixkit.co/sfx/preview/mixkit-alarm-digital-clock-beep-989.mp3" type="audio/mpeg">
-</audio>
-<script>
-function playAlert() {
-    var audio = document.getElementById('alertAudio');
-    audio.play();
-}
-</script>
-"""
-
-def eye_aspect_ratio(eye_points):
-    """Calculate Eye Aspect Ratio"""
-    # Vertical distances
-    A = distance.euclidean(eye_points[1], eye_points[5])
-    B = distance.euclidean(eye_points[2], eye_points[4])
-    
-    # Horizontal distance
-    C = distance.euclidean(eye_points[0], eye_points[3])
-    
-    # EAR formula
-    ear = (A + B) / (2.0 * C)
-    return ear
-
-def mouth_aspect_ratio(mouth_points):
-    """Calculate Mouth Aspect Ratio"""
-    # Vertical distances
-    A = distance.euclidean(mouth_points[2], mouth_points[10])
-    B = distance.euclidean(mouth_points[4], mouth_points[8])
-    
-    # Horizontal distance
-    C = distance.euclidean(mouth_points[0], mouth_points[6])
-    
-    # MAR formula
-    mar = (A + B) / (2.0 * C)
-    return mar
-
-class DrowsinessProcessor(VideoProcessorBase):
-    def __init__(self):
-        self.eye_closed_frames = 0
-        self.mouth_open_frames = 0
-        self.alert_active = False
-        self.last_alert_time = 0
-        self.frame_queue = queue.Queue(maxsize=30)
-        
-    def recv(self, frame):
-        img = frame.to_ndarray(format="bgr24")
-        img_rgb = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
-        
-        # Process with MediaPipe
-        results = face_mesh.process(img_rgb)
-        
-        drowsiness_detected = False
-        eye_status = "OPEN"
-        mouth_status = "CLOSED"
-        
-        if results.multi_face_landmarks:
-            for face_landmarks in results.multi_face_landmarks:
-                # Extract eye landmarks
-                left_eye_points = []
-                right_eye_points = []
-                
-                h, w = img.shape[:2]
-                
-                # Get left eye points
-                for idx in LEFT_EYE_INDICES:
-                    landmark = face_landmarks.landmark[idx]
-                    x = int(landmark.x * w)
-                    y = int(landmark.y * h)
-                    left_eye_points.append((x, y))
-                
-                # Get right eye points
-                for idx in RIGHT_EYE_INDICES:
-                    landmark = face_landmarks.landmark[idx]
-                    x = int(landmark.x * w)
-                    y = int(landmark.y * h)
-                    right_eye_points.append((x, y))
-                
-                # Calculate EAR for both eyes
-                left_ear = eye_aspect_ratio(left_eye_points)
-                right_ear = eye_aspect_ratio(right_eye_points)
-                ear = (left_ear + right_ear) / 2.0
-                
-                # Draw eye landmarks
-                for point in left_eye_points + right_eye_points:
-                    cv2.circle(img, point, 1, (0, 255, 0), -1)
-                
-                # Extract mouth landmarks
-                mouth_points = []
-                for idx in MOUTH_INDICES:
-                    landmark = face_landmarks.landmark[idx]
-                    x = int(landmark.x * w)
-                    y = int(landmark.y * h)
-                    mouth_points.append((x, y))
-                
-                # Calculate MAR
-                mar = mouth_aspect_ratio(mouth_points)
-                
-                # Draw mouth landmarks
-                for point in mouth_points:
-                    cv2.circle(img, point, 1, (255, 0, 0), -1)
-                
-                # Eye detection logic
-                if ear < EAR_THRESHOLD:
-                    self.eye_closed_frames += 1
-                    eye_status = "CLOSED"
-                else:
-                    self.eye_closed_frames = 0
-                
-                # Mouth detection logic
-                if mar > MAR_THRESHOLD:
-                    self.mouth_open_frames += 1
-                    mouth_status = "OPEN"
-                else:
-                    self.mouth_open_frames = 0
-                
-                # Check for drowsiness
-                if (self.eye_closed_frames >= CONSECUTIVE_FRAMES_EYE or 
-                    self.mouth_open_frames >= CONSECUTIVE_FRAMES_MOUTH):
-                    drowsiness_detected = True
-                    current_time = time.time()
-                    
-                    # Trigger alert if enough time has passed since last alert
-                    if current_time - self.last_alert_time > ALERT_DURATION:
-                        self.alert_active = True
-                        self.last_alert_time = current_time
-                        # We'll handle the audio alert through the frontend
-                
-                # Display metrics
-                cv2.putText(img, f"EAR: {ear:.2f}", (10, 30),
-                           cv2.FONT_HERSHEY_SIMPLEX, 0.7, (0, 255, 0), 2)
-                cv2.putText(img, f"MAR: {mar:.2f}", (10, 60),
-                           cv2.FONT_HERSHEY_SIMPLEX, 0.7, (255, 0, 0), 2)
-                cv2.putText(img, f"Eyes: {eye_status}", (10, 90),
-                           cv2.FONT_HERSHEY_SIMPLEX, 0.7, 
-                           (0, 0, 255) if eye_status == "CLOSED" else (0, 255, 0), 2)
-                cv2.putText(img, f"Mouth: {mouth_status}", (10, 120),
-                           cv2.FONT_HERSHEY_SIMPLEX, 0.7,
-                           (0, 0, 255) if mouth_status == "OPEN" else (0, 255, 0), 2)
-                
-                # Draw drowsiness warning
-                if drowsiness_detected:
-                    cv2.putText(img, "DROWSINESS DETECTED!", (w//2 - 150, 50),
-                               cv2.FONT_HERSHEY_SIMPLEX, 1, (0, 0, 255), 3)
-                    cv2.rectangle(img, (0, 0), (w, h), (0, 0, 255), 10)
-                    
-                    # Add to frame queue for alert trigger
-                    if not self.frame_queue.full():
-                        self.frame_queue.put({"alert": True, "frame": img})
-        
-        # Reset alert after duration
-        if self.alert_active and time.time() - self.last_alert_time > ALERT_DURATION:
-            self.alert_active = False
-        
-        return av.VideoFrame.from_ndarray(img, format="bgr24")
-
-def main():
-    st.set_page_config(
-        page_title="Real-time Drowsiness Detection",
-        page_icon="🚗",
-        layout="wide"
-    )
-    
-    # Custom CSS
-    st.markdown("""
-    <style>
+# Custom CSS for better styling
+st.markdown("""
+<style>
     .main-header {
         font-size: 2.5rem;
-        color: #2E86AB;
+        color: #1E88E5;
         text-align: center;
-        margin-bottom: 2rem;
+        margin-bottom: 1rem;
     }
     .sub-header {
-        font-size: 1.5rem;
-        color: #A23B72;
-        margin-top: 2rem;
+        font-size: 1.2rem;
+        color: #666;
+        text-align: center;
+        margin-bottom: 2rem;
     }
-    .metric-box {
+    .stat-box {
         background-color: #f0f2f6;
         padding: 1rem;
         border-radius: 10px;
-        margin: 1rem 0;
+        border-left: 5px solid #1E88E5;
+        margin: 0.5rem 0;
     }
-    .alert-box {
-        background-color: #ffcccc;
+    .model-info {
+        background-color: #e8f4fd;
         padding: 1rem;
         border-radius: 10px;
-        border-left: 5px solid #ff0000;
-        animation: pulse 2s infinite;
+        margin: 1rem 0;
+    }
+    .stButton button {
+        background-color: #1E88E5;
+        color: white;
+        font-weight: bold;
     }
-    @keyframes pulse {
-        0% { opacity: 1; }
-        50% { opacity: 0.7; }
-        100% { opacity: 1; }
+    .confidence-slider {
+        margin: 2rem 0;
     }
-    </style>
-    """, unsafe_allow_html=True)
+</style>
+""", unsafe_allow_html=True)
+
+@st.cache_resource
+def load_model():
+    """Load DETR model and processor with caching"""
+    try:
+        processor = DetrImageProcessor.from_pretrained("facebook/detr-resnet-50")
+        model = DetrForObjectDetection.from_pretrained("facebook/detr-resnet-50")
+        return processor, model
+    except Exception as e:
+        st.error(f"Error loading model: {e}")
+        return None, None
+
+def draw_bounding_boxes(image, results, threshold=0.5):
+    """Draw bounding boxes on the image with labels and confidence scores"""
+    draw = ImageDraw.Draw(image)
     
-    # Header
-    st.markdown('<h1 class="main-header">🚗 Real-time Drowsiness Detection System</h1>', 
-                unsafe_allow_html=True)
+    # Keep track of colors for each class
+    class_colors = {}
     
-    # Introduction
-    col1, col2 = st.columns([2, 1])
-    with col1:
-        st.markdown("""
-        ### 📊 About This System
-        This AI-powered system detects driver drowsiness in real-time using:
-        - **Facial Landmark Detection**: Identifies key facial points using MediaPipe
-        - **Eye Aspect Ratio (EAR)**: Monitors eye closure duration
-        - **Mouth Aspect Ratio (MAR)**: Detects yawning behavior
-        - **Real-time Alerting**: Triggers audible alerts when drowsiness is detected
+    # Get predictions
+    for score, label, box in zip(results["scores"], results["labels"], results["boxes"]):
+        if score < threshold:
+            continue
+            
+        # Convert to int
+        box = [round(i, 2) for i in box.tolist()]
+        label_name = model.config.id2label[label.item()]
         
-        **How it works:**
-        1. The webcam captures video feed
-        2. AI model detects facial landmarks
-        3. EAR and MAR are calculated for each frame
-        4. System triggers alert if metrics indicate drowsiness
-        """)
-    
-    with col2:
-        st.markdown("""
-        ### ⚙️ Parameters
-        """)
-        st.code(f"""
-        EAR Threshold: {EAR_THRESHOLD}
-        MAR Threshold: {MAR_THRESHOLD}
-        Eye Closure Frames: {CONSECUTIVE_FRAMES_EYE}
-        Yawn Detection Frames: {CONSECUTIVE_FRAMES_MOUTH}
-        """)
-    
-    st.markdown("---")
-    
-    # Add audio alert HTML
-    st.markdown(AUDIO_ALERT_HTML, unsafe_allow_html=True)
-    
-    # Video stream section
-    st.markdown('<h2 class="sub-header">🎥 Live Drowsiness Detection</h2>', 
-                unsafe_allow_html=True)
-    
-    # Warning message
-    with st.expander("⚠️ Important Note", expanded=True):
-        st.warning("""
-        **For proper functionality:**
-        1. Ensure good lighting on your face
-        2. Position yourself facing the camera
-        3. Grant camera permissions when prompted
-        4. Keep your face visible to the camera
-        5. The system works best in a well-lit environment
-        """)
-    
-    # WebRTC configuration
-    rtc_configuration = RTCConfiguration({
-        "iceServers": [{"urls": ["stun:stun.l.google.com:19302"]}]
-    })
+        # Generate or get color for this class
+        if label_name not in class_colors:
+            # Generate a unique color based on label hash
+            color_hash = hash(label_name) % 256
+            color = (color_hash, (color_hash * 37) % 256, (color_hash * 73) % 256)
+            class_colors[label_name] = color
+        else:
+            color = class_colors[label_name]
+        
+        # Draw rectangle
+        draw.rectangle(box, outline=color, width=3)
+        
+        # Prepare label text
+        label_text = f"{label_name}: {score:.2f}"
+        
+        # Draw label background
+        text_bbox = draw.textbbox((box[0], box[1]), label_text)
+        draw.rectangle(text_bbox, fill=color)
+        
+        # Draw label text
+        draw.text((box[0], box[1]), label_text, fill="white")
     
-    # Create WebRTC streamer
-    webrtc_ctx = webrtc_streamer(
-        key="drowsiness-detection",
-        mode=WebRtcMode.SENDRECV,
-        rtc_configuration=rtc_configuration,
-        video_processor_factory=DrowsinessProcessor,
-        media_stream_constraints={"video": True, "audio": False},
-        async_processing=True,
-    )
+    return image, class_colors
+
+def plot_detections(image, results, threshold=0.5):
+    """Alternative visualization using matplotlib"""
+    fig, ax = plt.subplots(1, figsize=(12, 8))
+    ax.imshow(image)
     
-    # Status indicators
-    col1, col2, col3 = st.columns(3)
-    with col1:
-        if webrtc_ctx.state.playing:
-            st.success("✅ Camera Active")
-        else:
-            st.error("❌ Camera Inactive")
+    # Count objects per class
+    class_counts = Counter()
     
-    with col2:
-        if webrtc_ctx.state.playing:
-            st.info("🔍 Monitoring Active")
-        else:
-            st.warning("⚠️ Monitoring Paused")
+    for score, label, box in zip(results["scores"], results["labels"], results["boxes"]):
+        if score < threshold:
+            continue
+            
+        label_name = model.config.id2label[label.item()]
+        class_counts[label_name] += 1
+        
+        # Convert box coordinates
+        xmin, ymin, xmax, ymax = box.tolist()
+        width = xmax - xmin
+        height = ymax - ymin
+        
+        # Create rectangle patch
+        rect = patches.Rectangle(
+            (xmin, ymin), width, height,
+            linewidth=2, edgecolor='red', facecolor='none'
+        )
+        ax.add_patch(rect)
+        
+        # Add label
+        ax.text(
+            xmin, ymin - 10,
+            f"{label_name}: {score:.2f}",
+            bbox=dict(facecolor='red', alpha=0.5),
+            fontsize=10, color='white'
+        )
     
-    with col3:
-        st.info("🎯 Waiting for face detection...")
+    plt.axis('off')
+    plt.tight_layout()
+    return fig, class_counts
+
+def get_statistics(results, threshold=0.5):
+    """Calculate detection statistics"""
+    total_detections = 0
+    confident_detections = 0
+    confidence_scores = []
+    classes_detected = set()
     
-    # Alert system
-    if webrtc_ctx.state.playing:
-        # JavaScript for audio alert
-        alert_js = """
-        <script>
-        function checkForAlert() {
-            // This would typically check a websocket or server-sent event
-            // For simplicity, we'll use a placeholder
-            setTimeout(checkForAlert, 1000);
-        }
-        checkForAlert();
-        </script>
-        """
-        st.markdown(alert_js, unsafe_allow_html=True)
+    for score, label in zip(results["scores"], results["labels"]):
+        total_detections += 1
+        confidence_scores.append(score.item())
+        classes_detected.add(model.config.id2label[label.item()])
+        if score >= threshold:
+            confident_detections += 1
     
-    # Metrics explanation
-    st.markdown("---")
-    st.markdown('<h2 class="sub-header">📈 Detection Metrics</h2>', 
-                unsafe_allow_html=True)
+    stats = {
+        "total_predictions": total_detections,
+        "confident_detections": confident_detections,
+        "avg_confidence": np.mean(confidence_scores) if confidence_scores else 0,
+        "max_confidence": max(confidence_scores) if confidence_scores else 0,
+        "min_confidence": min(confidence_scores) if confidence_scores else 0,
+        "unique_classes": len(classes_detected),
+        "classes_list": list(classes_detected)
+    }
     
-    col1, col2 = st.columns(2)
+    return stats
+
+# Main app
+def main():
+    # Header
+    st.markdown('<h1 class="main-header">🔍 Object Detection Playground</h1>', unsafe_allow_html=True)
+    st.markdown('<p class="sub-header">Upload images and visualize detections with DETR (DEtection TRansformer)</p>', unsafe_allow_html=True)
     
-    with col1:
-        st.markdown('<div class="metric-box">', unsafe_allow_html=True)
-        st.markdown("### 👁️ **Eye Aspect Ratio (EAR)**")
+    # Sidebar
+    with st.sidebar:
+        st.header("⚙️ Settings")
+        
+        # Model info
+        st.markdown("### Model Information")
         st.markdown("""
-        - **Normal**: EAR > 0.25
-        - **Drowsy**: EAR < 0.25 for consecutive frames
-        - **Calculation**: (Vertical distances) / (2 × Horizontal distance)
-        """)
-        st.markdown('</div>', unsafe_allow_html=True)
+        <div class="model-info">
+        <strong>Model:</strong> facebook/detr-resnet-50<br>
+        <strong>Architecture:</strong> DETR (DEtection TRansformer)<br>
+        <strong>Backbone:</strong> ResNet-50<br>
+        <strong>Classes:</strong> 91 COCO classes
+        </div>
+        """, unsafe_allow_html=True)
+        
+        # Confidence threshold slider
+        st.markdown("### Detection Settings")
+        confidence_threshold = st.slider(
+            "Confidence Threshold",
+            min_value=0.0,
+            max_value=1.0,
+            value=0.5,
+            step=0.05,
+            help="Adjust the minimum confidence score for detections"
+        )
+        
+        # Visualization options
+        st.markdown("### Visualization")
+        visualization_mode = st.selectbox(
+            "Choose visualization style",
+            ["PIL Drawing", "Matplotlib", "Both"]
+        )
+        
+        # Show class labels
+        show_class_labels = st.checkbox("Show class labels on image", value=True)
+        
+        # Advanced options
+        with st.expander("Advanced Options"):
+            max_detections = st.slider(
+                "Maximum detections to show",
+                min_value=1,
+                max_value=50,
+                value=25,
+                step=1
+            )
+            
+            detection_color = st.color_picker(
+                "Detection color",
+                value="#FF0000"
+            )
     
-    with col2:
-        st.markdown('<div class="metric-box">', unsafe_allow_html=True)
-        st.markdown("### 👄 **Mouth Aspect Ratio (MAR)**")
-        st.markdown("""
-        - **Normal**: MAR < 0.5
-        - **Yawning**: MAR > 0.5 for consecutive frames
-        - **Calculation**: (Vertical distances) / (2 × Horizontal distance)
-        """)
-        st.markdown('</div>', unsafe_allow_html=True)
+    # Main content area
+    col1, col2 = st.columns([2, 1])
     
-    # Technical details
-    with st.expander("🔧 Technical Implementation Details"):
-        st.markdown("""
-        ### 🏗️ **Tech Stack**
-        - **MediaPipe**: Facial landmark detection (468 points)
-        - **OpenCV**: Real-time video processing
-        - **Streamlit**: Web interface and deployment
-        - **SciPy**: Distance calculations for EAR/MAR
+    with col1:
+        st.markdown("### 📤 Upload Image")
+        
+        # Image upload options
+        upload_method = st.radio(
+            "Choose upload method:",
+            ["Upload file", "Use sample image"]
+        )
+        
+        image = None
+        
+        if upload_method == "Upload file":
+            uploaded_file = st.file_uploader(
+                "Choose an image...",
+                type=['jpg', 'jpeg', 'png', 'bmp', 'tiff'],
+                help="Upload an image for object detection"
+            )
+            
+            if uploaded_file is not None:
+                image = Image.open(uploaded_file).convert("RGB")
+                st.image(image, caption="Uploaded Image", use_column_width=True)
+        
+        else:
+            # Sample images
+            sample_option = st.selectbox(
+                "Choose a sample image:",
+                ["Street Scene", "Office", "Kitchen", "Animals", "Sports"]
+            )
+            
+            sample_images = {
+                "Street Scene": "https://images.unsplash.com/photo-1449824913935-59a10b8d2000?w=800&auto=format&fit=crop",
+                "Office": "https://images.unsplash.com/photo-1497366754035-f200968a6e72?w-800&auto=format&fit=crop",
+                "Kitchen": "https://images.unsplash.com/photo-1556909114-f6e7ad7d3136?w=800&auto=format&fit=crop",
+                "Animals": "https://images.unsplash.com/photo-1564349683136-77e08dba1ef7?w=800&auto=format&fit=crop",
+                "Sports": "https://images.unsplash.com/photo-1461896836934-ffe607ba8211?w=800&auto=format&fit=crop"
+            }
+            
+            if st.button("Load Sample Image"):
+                # Note: In production, you'd need to download the image
+                # For now, we'll use a placeholder
+                st.info("Sample images require internet connection. In HuggingFace Spaces, you'll need to implement download.")
         
-        ### ⚙️ **Algorithm**
-        1. **Face Detection**: MediaPipe Face Mesh identifies facial landmarks
-        2. **Feature Extraction**: 
-           - Eye landmarks (6 points per eye)
-           - Mouth landmarks (12 points)
-        3. **Metric Calculation**:
-           - EAR = (|p2-p6| + |p3-p5|) / (2 * |p1-p4|)
-           - MAR = (|p2-p10| + |p4-p8|) / (2 * |p1-p7|)
-        4. **Decision Logic**:
-           - Alert if EAR < threshold for N consecutive frames
-           - Alert if MAR > threshold for M consecutive frames
+        # Load model
+        with st.spinner("Loading DETR model..."):
+            processor, model = load_model()
         
-        ### 🚀 **Performance Features**
-        - Real-time processing (>30 FPS)
-        - Low latency alert system
-        - Robust to lighting variations
-        - Multi-person detection capable
-        """)
+        if image is not None and model is not None:
+            # Process button
+            if st.button("🔍 Detect Objects", type="primary", use_container_width=True):
+                with st.spinner("Processing image..."):
+                    # Prepare inputs
+                    inputs = processor(images=image, return_tensors="pt")
+                    
+                    # Get predictions
+                    with torch.no_grad():
+                        outputs = model(**inputs)
+                    
+                    # Process outputs
+                    target_sizes = torch.tensor([image.size[::-1]])
+                    results = processor.post_process_object_detection(
+                        outputs, 
+                        target_sizes=target_sizes,
+                        threshold=0.0  # We'll filter by our own threshold
+                    )[0]
+                    
+                    # Get statistics
+                    stats = get_statistics(results, confidence_threshold)
+                    
+                    # Display results
+                    st.markdown("---")
+                    st.markdown("### 📊 Detection Results")
+                    
+                    # Create two columns for visualizations
+                    if visualization_mode in ["PIL Drawing", "Both"]:
+                        # PIL visualization
+                        pil_image = image.copy()
+                        annotated_image, class_colors = draw_bounding_boxes(
+                            pil_image, results, confidence_threshold
+                        )
+                        st.image(annotated_image, caption="Detected Objects", use_column_width=True)
+                    
+                    if visualization_mode in ["Matplotlib", "Both"]:
+                        # Matplotlib visualization
+                        fig, class_counts = plot_detections(image, results, confidence_threshold)
+                        st.pyplot(fig)
+                        plt.close()
+                        
+                        # Display class distribution
+                        if class_counts:
+                            st.markdown("#### 📈 Class Distribution")
+                            for class_name, count in class_counts.most_common():
+                                st.progress(count/10 if count < 10 else 1.0, 
+                                          text=f"{class_name}: {count} objects")
+                    
+                    # Statistics in the right column
+                    with col2:
+                        st.markdown("### 📈 Statistics")
+                        
+                        # Create metrics
+                        metrics_col1, metrics_col2 = st.columns(2)
+                        
+                        with metrics_col1:
+                            st.metric(
+                                "Total Objects",
+                                stats["confident_detections"],
+                                f"{stats['total_predictions']} total predictions"
+                            )
+                            
+                            st.metric(
+                                "Unique Classes",
+                                stats["unique_classes"]
+                            )
+                        
+                        with metrics_col2:
+                            st.metric(
+                                "Avg Confidence",
+                                f"{stats['avg_confidence']:.2%}"
+                            )
+                            
+                            st.metric(
+                                "Max Confidence",
+                                f"{stats['max_confidence']:.2%}"
+                            )
+                        
+                        # Class list
+                        st.markdown("#### 🏷️ Detected Classes")
+                        if stats["classes_list"]:
+                            for class_name in sorted(stats["classes_list"]):
+                                st.markdown(f"- {class_name}")
+                        else:
+                            st.info("No objects detected above threshold")
+                        
+                        # Confidence distribution
+                        st.markdown("#### 📊 Confidence Distribution")
+                        
+                        # Get confidence scores for histogram
+                        confidence_scores = [score.item() for score in results["scores"]]
+                        if confidence_scores:
+                            fig_hist, ax_hist = plt.subplots(figsize=(8, 4))
+                            ax_hist.hist(confidence_scores, bins=20, alpha=0.7, color='skyblue', edgecolor='black')
+                            ax_hist.axvline(x=confidence_threshold, color='red', linestyle='--', 
+                                          label=f'Threshold: {confidence_threshold}')
+                            ax_hist.set_xlabel('Confidence Score')
+                            ax_hist.set_ylabel('Count')
+                            ax_hist.set_title('Distribution of Confidence Scores')
+                            ax_hist.legend()
+                            ax_hist.grid(True, alpha=0.3)
+                            st.pyplot(fig_hist)
+                            plt.close()
+                        
+                        # Download button for processed image
+                        if visualization_mode in ["PIL Drawing", "Both"]:
+                            buffered = io.BytesIO()
+                            annotated_image.save(buffered, format="PNG")
+                            st.download_button(
+                                label="📥 Download Processed Image",
+                                data=buffered.getvalue(),
+                                file_name="detected_objects.png",
+                                mime="image/png",
+                                use_container_width=True
+                            )
     
+    # Instructions in main area if no image
+    if 'image' not in locals() or image is None:
+        with col1:
+            st.info("👈 Please upload an image or select a sample image to begin object detection.")
+            
+            # Quick guide
+            with st.expander("📚 Quick Guide"):
+                st.markdown("""
+                ### How to use:
+                1. **Upload an image** using the file uploader or select a sample image
+                2. **Adjust the confidence threshold** in the sidebar (default: 0.5)
+                3. **Choose visualization style** (PIL or Matplotlib)
+                4. **Click 'Detect Objects'** to run the model
+                
+                ### Features:
+                - **Real-time statistics** showing object counts
+                - **Adjustable confidence threshold** to filter detections
+                - **Multiple visualization options**
+                - **Download processed images**
+                - **Class distribution analysis**
+                
+                ### About DETR:
+                DETR (DEtection TRansformer) is an end-to-end object detection model that uses 
+                transformers instead of traditional convolutional approaches.
+                """)
+            
+            # Model capabilities
+            st.markdown("### 🎯 Model Capabilities")
+            col_cap1, col_cap2, col_cap3 = st.columns(3)
+            
+            with col_cap1:
+                st.markdown("""
+                **Common Objects:**
+                - Person
+                - Vehicle
+                - Furniture
+                - Animal
+                - Food items
+                """)
+            
+            with col_cap2:
+                st.markdown("""
+                **Detection Types:**
+                - 91 COCO classes
+                - Real-time processing
+                - Bounding boxes
+                - Confidence scores
+                """)
+            
+            with col_cap3:
+                st.markdown("""
+                **Best For:**
+                - General scenes
+                - Multiple objects
+                - Indoor/outdoor
+                - Real-world images
+                """)
+
     # Footer
     st.markdown("---")
-    st.markdown("""
-    <div style='text-align: center'>
-        <p><strong>🚨 Safety-critical Application | Real-time Alerting System | Biomedical Signal Processing</strong></p>
-        <p>Designed for deployment on Hugging Face Spaces • For demonstration purposes only</p>
-    </div>
-    """, unsafe_allow_html=True)
+    st.markdown(
+        "<div style='text-align: center; color: #666;'>"
+        "Object Detection Playground • Powered by DETR Transformers • "
+        "<a href='https://huggingface.co/facebook/detr-resnet-50' target='_blank'>Model Card</a>"
+        "</div>",
+        unsafe_allow_html=True
+    )
 
 if __name__ == "__main__":
     main()