Create app.py

app.py

@@ -0,0 +1,470 @@
+import gradio as gr
+import cv2
+import numpy as np
+import os
+import sys
+from ultralytics import YOLO
+from PIL import Image
+import time
+from collections import Counter
+
+print("Python version:", sys.version)
+print("Gradio version:", gr.__version__)
+
+
+class SimpleObjectDetector:
+    def __init__(self):
+        """Initialize YOLO11n general object detector"""
+        self.model = None
+        try:
+            self.model = YOLO('yolo11n.pt')
+            print("✅ YOLO11n model initialization complete")
+            print("📦 Can detect 80 object classes: person, car, animals, etc.")
+        except Exception as e:
+            import traceback 
+            print(f"⚠️ Model initialization error: {e}")
+            traceback.print_exc() 
+            print("🔄 Running in dummy mode")
+
+    def detect(self, image, conf_threshold=0.25):
+        """Object detection process"""
+        if image is None:
+            return None, []
+        
+        if self.model is None:
+            # Dummy processing
+            result = image.copy()
+            cv2.putText(result, "MODEL NOT FOUND", (50, 100), 
+                        cv2.FONT_HERSHEY_SIMPLEX, 1, (0, 0, 255), 2)
+            return result, []
+        
+        try:
+            # Run inference
+            results = self.model(image, conf=conf_threshold)
+            
+            detections = []
+            if len(results) > 0:
+                annotated = results[0].plot()
+                
+                # Get detection details
+                for box in results[0].boxes:
+                    class_id = int(box.cls[0])
+                    class_name = results[0].names[class_id]
+                    confidence = float(box.conf[0])
+                    detections.append({
+                        'class': class_name,
+                        'confidence': confidence
+                    })
+                
+                return annotated, detections
+            
+            return image, []
+        except Exception as e:
+            print(f"Detection Error: {e}")
+            return image, []
+
+    def detect_video(self, video_path, conf_threshold=0.25, progress=gr.Progress()):
+        """Process video file with object detection"""
+        if video_path is None:
+            return None, "Please upload a video"
+        
+        if self.model is None:
+            return None, "❌ Model not loaded. Cannot process video."
+        
+        try:
+            # Open video
+            cap = cv2.VideoCapture(video_path)
+            if not cap.isOpened():
+                return None, "❌ Failed to open video file"
+            
+            # Get video properties
+            fps = int(cap.get(cv2.CAP_PROP_FPS))
+            width = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
+            height = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
+            total_frames = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
+            
+            # Create output video file
+            output_path = "output_detected.mp4"
+            fourcc = cv2.VideoWriter_fourcc(*'mp4v')
+            out = cv2.VideoWriter(output_path, fourcc, fps, (width, height))
+            
+            # Statistics
+            all_detections = []
+            frame_count = 0
+            start_time = time.time()
+            
+            progress(0, desc="Starting video processing...")
+            
+            # Process each frame
+            while True:
+                ret, frame = cap.read()
+                if not ret:
+                    break
+                
+                # Run detection
+                annotated_frame, detections = self.detect(frame, conf_threshold)
+                
+                # Write frame to output
+                out.write(annotated_frame)
+                
+                # Store detections
+                all_detections.extend(detections)
+                frame_count += 1
+                
+                # Update progress
+                if frame_count % 10 == 0:
+                    progress_pct = frame_count / total_frames
+                    progress(progress_pct, desc=f"Processing frame {frame_count}/{total_frames}")
+            
+            # Release resources
+            cap.release()
+            out.release()
+            
+            processing_time = time.time() - start_time
+            
+            # Generate statistics
+            if len(all_detections) > 0:
+                class_counts = Counter([det['class'] for det in all_detections])
+                
+                result_text = f"✅ Video Processing Complete!\n\n"
+                result_text += f"📊 Statistics:\n"
+                result_text += f"- Total Frames: {frame_count}\n"
+                result_text += f"- Total Detections: {len(all_detections)}\n"
+                result_text += f"- Processing Time: {processing_time:.2f} seconds\n"
+                result_text += f"- FPS: {frame_count/processing_time:.1f}\n\n"
+                
+                result_text += f"🎯 Detected Objects (Total Count):\n"
+                for obj_class, count in class_counts.most_common():
+                    result_text += f"  • {obj_class.upper()}: {count}\n"
+                
+                result_text += f"\n💡 Average detections per frame: {len(all_detections)/frame_count:.1f}"
+            else:
+                result_text = f"❌ No objects detected in {frame_count} frames\n\n"
+                result_text += "Try:\n- Lowering confidence threshold\n- Using a different video"
+            
+            return output_path, result_text
+            
+        except Exception as e:
+            import traceback
+            error_msg = f"❌ Video processing error: {str(e)}\n\n"
+            error_msg += traceback.format_exc()
+            print(error_msg)
+            return None, error_msg
+
+# Create instance
+detector = SimpleObjectDetector()
+
+def process_image(image, conf_threshold):
+    """Image processing function"""
+    if image is None:
+        return None, "Please upload an image"
+    
+    # Convert from RGB (Gradio) to BGR (OpenCV)
+    if len(image.shape) == 3:
+        if image.shape[2] == 4:  # If RGBA
+            image = cv2.cvtColor(image, cv2.COLOR_RGBA2RGB)
+        image = cv2.cvtColor(image, cv2.COLOR_RGB2BGR)
+    
+    # Run object detection
+    start_time = time.time()
+    result, detections = detector.detect(image, conf_threshold)
+    processing_time = time.time() - start_time
+    
+    # Convert back to RGB
+    if result is not None:
+        result = cv2.cvtColor(result, cv2.COLOR_BGR2RGB)
+    
+    # Format detection results
+    if len(detections) > 0:
+        result_text = f"✅ Detected {len(detections)} object(s):\n\n"
+        for i, det in enumerate(detections, 1):
+            result_text += f"{i}. {det['class'].upper()} - Confidence: {det['confidence']*100:.1f}%\n"
+        result_text += f"\n⏱️ Processing time: {processing_time:.2f} seconds"
+    else:
+        result_text = "❌ No objects detected\n\nTry:\n- Adjusting confidence threshold\n- Using a clearer image\n- Getting closer to objects"
+    
+    return result, result_text
+
+def flip_image(image):
+    """Flip image horizontally"""
+    if image is None:
+        return None
+    
+    if isinstance(image, Image.Image):
+        image = np.array(image)
+    
+    return cv2.flip(image, 1)
+
+def rotate_image(image, angle):
+    """Rotate image by specified angle"""
+    if image is None:
+        return None
+    
+    if isinstance(image, Image.Image):
+        image = np.array(image)
+    
+    height, width = image.shape[:2]
+    center = (width // 2, height // 2)
+    rotation_matrix = cv2.getRotationMatrix2D(center, angle, 1.0)
+    rotated = cv2.warpAffine(image, rotation_matrix, (width, height))
+    
+    return rotated
+
+def adjust_brightness_contrast(image, bright_val, contrast_val):
+    """Adjust image brightness and contrast"""
+    if image is None:
+        return None
+    
+    if isinstance(image, Image.Image):
+        image = np.array(image)
+    
+    img_float = image.astype(np.float32) / 255.0
+    adjusted = img_float * contrast_val + (bright_val - 1.0)
+    adjusted = np.clip(adjusted, 0, 1)
+    adjusted = (adjusted * 255).astype(np.uint8)
+    
+    return adjusted
+
+def generate_test_image():
+    """Generate test image with sample objects"""
+    img = np.ones((480, 640, 3), dtype=np.uint8) * 230
+    
+    # Draw sample shapes
+    cv2.rectangle(img, (100, 150), (200, 300), (50, 50, 200), -1)  # "car-like" shape
+    cv2.circle(img, (400, 200), 50, (200, 50, 50), -1)  # circle
+    
+    cv2.putText(img, "TEST IMAGE", (200, 50), 
+               cv2.FONT_HERSHEY_SIMPLEX, 1, (0, 0, 0), 2)
+    cv2.putText(img, "Click 'Detect Objects' to test", (150, 400),
+               cv2.FONT_HERSHEY_SIMPLEX, 0.7, (0, 0, 0), 2)
+    
+    return img
+
+# Create Gradio Interface
+with gr.Blocks(title="YOLO11n Object Detection - Image & Video", theme=gr.themes.Soft()) as demo:
+    gr.Markdown("# 📱🔍 YOLO11n Object Detection - Image & Video")
+    gr.Markdown("### Detect 80 types of objects in images and videos!")
+    
+    with gr.Tabs():
+        # ===== IMAGE TAB =====
+        with gr.Tab("📸 Image Detection"):
+            with gr.Row():
+                with gr.Column(scale=1):
+                    # Instructions
+                    gr.Markdown("""
+                    ## 📋 How to Use:
+                    1. **Upload** an image or **Take Photo** (mobile)
+                    2. Adjust **confidence threshold** if needed
+                    3. Click **🚀 Detect Objects**
+                    
+                    **Detectable Objects:**
+                    - 🚗 Vehicles (car, truck, bus, motorcycle, bicycle)
+                    - 🧍 People and body parts
+                    - 🐕 Animals (dog, cat, bird, horse, etc.)
+                    - ⚽ Sports equipment
+                    - 🪑 Furniture and household items
+                    - And 60+ more categories!
+                    """)
+                    
+                    # Image input
+                    with gr.Group():
+                        gr.Markdown("### 📸 Capture or Upload Image")
+                        image_input = gr.Image(
+                            label="Input Image",
+                            type="numpy",
+                            sources=["upload"],
+                            interactive=True
+                        )
+                        
+                        # Confidence threshold
+                        img_conf_slider = gr.Slider(
+                            0.1, 0.9, 
+                            value=0.25, 
+                            step=0.05,
+                            label="🎯 Confidence Threshold",
+                            info="Lower = more detections (may include false positives)"
+                        )
+                        
+                        # Image manipulation controls
+                        with gr.Accordion("🔄 Image Adjustments", open=False):
+                            with gr.Row():
+                                flip_btn = gr.Button("🪞 Flip", size="sm")
+                                rotate_90_btn = gr.Button("↪️ Rotate 90°", size="sm")
+                                rotate_180_btn = gr.Button("🔄 Rotate 180°", size="sm")
+                            
+                            brightness = gr.Slider(0.5, 2.0, value=1.0, label="☀️ Brightness")
+                            contrast = gr.Slider(0.5, 2.0, value=1.0, label="🎨 Contrast")
+                
+                with gr.Column(scale=1):
+                    # Detection results
+                    gr.Markdown("## 🔍 Detection Results")
+                    output_image = gr.Image(label="Detected Objects", interactive=False)
+                    
+                    # Detection button
+                    detect_btn = gr.Button(
+                        "🚀 Detect Objects", 
+                        variant="primary", 
+                        size="lg"
+                    )
+                    
+                    # Results text
+                    results_text = gr.Textbox(
+                        label="📊 Detection Details",
+                        lines=10,
+                        interactive=False
+                    )
+            
+            # Test section
+            with gr.Accordion("🧪 Test & Examples", open=False):
+                with gr.Row():
+                    test_btn = gr.Button("Generate Test Image")
+                
+                gr.Markdown("""
+                **💡 Tips for Best Results:**
+                - Use clear, well-lit photos
+                - Ensure objects are not too far away
+                - Avoid heavy shadows or blur
+                - Try different confidence thresholds
+                """)
+        
+        # ===== VIDEO TAB =====
+        with gr.Tab("🎥 Video Detection"):
+            with gr.Row():
+                with gr.Column(scale=1):
+                    gr.Markdown("""
+                    ## 📹 Video Object Detection
+                    
+                    Upload a video file and detect objects in every frame!
+                    
+                    **Supported formats:** MP4, AVI, MOV, MKV
+                    
+                    **Note:** Processing may take time depending on video length.
+                    For best performance, use videos under 1 minute.
+                    """)
+                    
+                    video_input = gr.Video(
+                        label="📤 Upload Video",
+                        sources=["upload"]
+                    )
+                    
+                    video_conf_slider = gr.Slider(
+                        0.1, 0.9,
+                        value=0.25,
+                        step=0.05,
+                        label="🎯 Confidence Threshold",
+                        info="Lower = more detections"
+                    )
+                    
+                    process_video_btn = gr.Button(
+                        "🎬 Process Video",
+                        variant="primary",
+                        size="lg"
+                    )
+                
+                with gr.Column(scale=1):
+                    gr.Markdown("## 📊 Processed Video & Statistics")
+                    
+                    video_output = gr.Video(
+                        label="Processed Video with Detections"
+                    )
+                    
+                    video_results_text = gr.Textbox(
+                        label="📈 Video Statistics",
+                        lines=15,
+                        interactive=False
+                    )
+            
+            with gr.Accordion("💡 Video Processing Tips", open=False):
+                gr.Markdown("""
+                **Optimization Tips:**
+                - Higher confidence threshold = faster processing
+                - Shorter videos = quicker results
+                - Good lighting improves detection accuracy
+                - Stable camera position works better than shaky footage
+                
+                **What gets detected:**
+                - Moving objects (cars, people, animals)
+                - Static objects (furniture, signs, equipment)
+                - Multiple objects simultaneously
+                """)
+    
+    # ===== EVENT HANDLERS - IMAGE TAB =====
+    test_btn.click(
+        fn=generate_test_image,
+        outputs=image_input
+    )
+    
+    flip_btn.click(
+        fn=flip_image,
+        inputs=image_input,
+        outputs=image_input
+    )
+    
+    rotate_90_btn.click(
+        fn=lambda img: rotate_image(img, 90),
+        inputs=image_input,
+        outputs=image_input
+    )
+    
+    rotate_180_btn.click(
+        fn=lambda img: rotate_image(img, 180),
+        inputs=image_input,
+        outputs=image_input
+    )
+    
+    brightness.change(
+        fn=lambda img, b, c: adjust_brightness_contrast(img, b, c) if img is not None else None,
+        inputs=[image_input, brightness, contrast],
+        outputs=image_input
+    )
+    
+    contrast.change(
+        fn=lambda img, b, c: adjust_brightness_contrast(img, b, c) if img is not None else None,
+        inputs=[image_input, brightness, contrast],
+        outputs=image_input
+    )
+    
+    detect_btn.click(
+        fn=process_image,
+        inputs=[image_input, img_conf_slider],
+        outputs=[output_image, results_text]
+    )
+    
+    # ===== EVENT HANDLERS - VIDEO TAB =====
+    process_video_btn.click(
+        fn=detector.detect_video,
+        inputs=[video_input, video_conf_slider],
+        outputs=[video_output, video_results_text]
+    )
+
+if __name__ == "__main__":
+    print("=" * 60)
+    print("🚀 YOLO11n Object Detection - Image & Video Support")
+    print("=" * 60)
+    print("📦 Detects 80 object classes including:")
+    print("   - People, vehicles, animals")
+    print("   - Furniture, sports equipment")
+    print("   - Electronics, food items, and more!")
+    print("=" * 60)
+    print("🖼️  Image Mode: Instant detection on photos")
+    print("🎥 Video Mode: Frame-by-frame detection")
+    print("=" * 60)
+    print("🌐 Access via: http://localhost:7860")
+    print("📱 Mobile: Use same network with computer's IP:7860")
+    print("=" * 60)
+    
+    try:
+        demo.launch(
+            server_name="0.0.0.0",
+            server_port=7860,
+            debug=False,
+            share=True,
+            show_error=True,
+            max_file_size="100MB"  # Increased for video files
+        )
+    except Exception as e:
+        print(f"❌ Launch Error: {e}")
+        print("\n🔧 Troubleshooting:")
+        print("1. Try different port: demo.launch(server_port=7861)")
+        print("2. Check firewall settings")
+        print("3. Ensure ultralytics is installed: pip install ultralytics")