Create app.py

app.py

@@ -0,0 +1,465 @@
+import streamlit as st
+from streamlit_option_menu import option_menu
+import cv2
+import numpy as np
+import tempfile
+from PIL import Image
+import time
+import av
+from streamlit_webrtc import webrtc_streamer, VideoProcessorBase, RTCConfiguration
+import os
+import requests
+
+# Set page config
+st.set_page_config(
+    page_title="Real-Time Object Detection & Tracking",
+    page_icon="🚗",
+    layout="wide",
+    initial_sidebar_state="expanded"
+)
+
+# Custom CSS for styling
+st.markdown("""
+    <style>
+        .stApp {
+            background-color: #f8f9fa;
+        }
+        .header {
+            color: #2c3e50;
+            font-size: 2.5rem;
+            font-weight: bold;
+            margin-bottom: 1rem;
+        }
+        .subheader {
+            color: #3498db;
+            font-size: 1.5rem;
+            margin-bottom: 1rem;
+        }
+        .stButton>button {
+            background-color: #3498db;
+            color: white;
+            border-radius: 5px;
+            padding: 0.5rem 1rem;
+            border: none;
+            transition: all 0.3s;
+        }
+        .stButton>button:hover {
+            background-color: #2980b9;
+            transform: translateY(-2px);
+            box-shadow: 0 4px 8px rgba(0,0,0,0.1);
+        }
+        .css-1aumxhk {
+            background-color: #ffffff;
+            border-radius: 10px;
+            padding: 2rem;
+            box-shadow: 0 4px 6px rgba(0, 0, 0, 0.1);
+        }
+        .model-card {
+            border-radius: 10px;
+            padding: 1.5rem;
+            margin-bottom: 1rem;
+            background-color: #ffffff;
+            box-shadow: 0 4px 6px rgba(0, 0, 0, 0.1);
+            transition: all 0.3s;
+        }
+        .model-card:hover {
+            transform: translateY(-5px);
+            box-shadow: 0 8px 15px rgba(0, 0, 0, 0.1);
+        }
+        .stSelectbox>div>div>select {
+            border-radius: 5px;
+            padding: 0.5rem;
+        }
+        .stSlider>div>div>div>div {
+            background-color: #3498db;
+        }
+    </style>
+""", unsafe_allow_html=True)
+
+# App header
+col1, col2 = st.columns([1, 3])
+with col1:
+    st.image("https://huggingface.co/front/assets/huggingface_logo-noborder.svg", width=100)
+with col2:
+    st.markdown('<div class="header">Real-Time Object Detection & Tracking</div>', unsafe_allow_html=True)
+    st.markdown("Advanced computer vision for autonomous vehicles and surveillance systems")
+
+# Navigation menu
+with st.sidebar:
+    selected = option_menu(
+        menu_title="Main Menu",
+        options=["Home", "Live Detection", "Video Processing", "Model Zoo", "Settings", "About"],
+        icons=["house", "camera-video", "film", "boxes", "gear", "info-circle"],
+        menu_icon="cast",
+        default_index=0,
+    )
+
+# Object detection class (simplified for demo)
+class ObjectDetector:
+    def __init__(self, model_type="yolov5"):
+        self.model_type = model_type
+        self.classes = ["person", "car", "truck", "bicycle", "motorcycle", "bus"]
+        self.colors = np.random.uniform(0, 255, size=(len(self.classes), 3))
+        
+    def detect(self, image):
+        # In a real app, you would use an actual model here
+        # This is a simplified version for demonstration
+        
+        # Convert image to numpy array
+        frame = np.array(image)
+        
+        # Simulate detection by adding random bounding boxes
+        height, width = frame.shape[:2]
+        detections = []
+        
+        for _ in range(np.random.randint(2, 6)):
+            class_id = np.random.randint(0, len(self.classes))
+            confidence = np.random.uniform(0.7, 0.95)
+            
+            x = int(np.random.uniform(0, width * 0.8))
+            y = int(np.random.uniform(0, height * 0.8))
+            w = int(np.random.uniform(width * 0.1, width * 0.3))
+            h = int(np.random.uniform(height * 0.1, height * 0.3))
+            
+            detections.append({
+                "class_id": class_id,
+                "confidence": confidence,
+                "box": [x, y, x+w, y+h]
+            })
+        
+        return detections
+    
+    def draw_detections(self, frame, detections):
+        for detection in detections:
+            class_id = detection["class_id"]
+            confidence = detection["confidence"]
+            box = detection["box"]
+            
+            color = self.colors[class_id]
+            label = f"{self.classes[class_id]}: {confidence:.2f}"
+            
+            cv2.rectangle(frame, (box[0], box[1]), (box[2], box[3]), color, 2)
+            cv2.putText(frame, label, (box[0], box[1]-10), 
+                        cv2.FONT_HERSHEY_SIMPLEX, 0.5, color, 2)
+        
+        return frame
+
+# Video processor for WebRTC
+class VideoProcessor(VideoProcessorBase):
+    def __init__(self):
+        self.detector = ObjectDetector()
+        self.confidence_threshold = 0.5
+        self.tracking_enabled = True
+    
+    def recv(self, frame):
+        img = frame.to_ndarray(format="bgr24")
+        
+        # Perform detection
+        detections = self.detector.detect(img)
+        
+        # Filter by confidence
+        detections = [d for d in detections if d["confidence"] >= self.confidence_threshold]
+        
+        # Draw detections
+        img = self.detector.draw_detections(img, detections)
+        
+        return av.VideoFrame.from_ndarray(img, format="bgr24")
+
+# Home Page
+if selected == "Home":
+    st.markdown('<div class="subheader">Welcome to Real-Time Object Detection</div>', unsafe_allow_html=True)
+    
+    col1, col2 = st.columns(2)
+    with col1:
+        st.markdown("""
+            **Advanced computer vision system** for:
+            - Autonomous vehicles 🚗
+            - Surveillance systems 🏢
+            - Traffic monitoring 🚦
+            - Smart cities 🌆
+            
+            **Features:**
+            - Real-time object detection
+            - Multi-object tracking
+            - Customizable models
+            - High-performance inference
+        """)
+        
+        st.button("Get Started →", key="home_get_started")
+    
+    with col2:
+        st.image("https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/transformers-task-cv-object-detection.png", 
+                 caption="Object Detection Example", use_column_width=True)
+    
+    st.markdown("---")
+    st.markdown("### How It Works")
+    st.markdown("""
+        1. **Select a model** from our Model Zoo or upload your own
+        2. **Choose input source** - live camera, video file, or image
+        3. **Configure settings** - confidence threshold, tracking options
+        4. **Run detection** and view real-time results
+    """)
+
+# Live Detection Page
+elif selected == "Live Detection":
+    st.markdown('<div class="subheader">Live Object Detection</div>', unsafe_allow_html=True)
+    
+    tab1, tab2 = st.tabs(["Webcam", "RTSP Stream"])
+    
+    with tab1:
+        st.markdown("### Webcam Detection")
+        st.info("This will use your device's camera for real-time object detection")
+        
+        # WebRTC configuration
+        RTC_CONFIGURATION = RTCConfiguration(
+            {"iceServers": [{"urls": ["stun:stun.l.google.com:19302"]}]}
+        )
+        
+        # Confidence threshold
+        confidence_threshold = st.slider(
+            "Confidence Threshold", 
+            min_value=0.1, 
+            max_value=0.9, 
+            value=0.5, 
+            step=0.05,
+            help="Adjust the minimum confidence score for detections"
+        )
+        
+        # Toggle tracking
+        tracking_enabled = st.checkbox(
+            "Enable Object Tracking", 
+            value=True,
+            help="Track objects across frames for consistent identification"
+        )
+        
+        # Start WebRTC streamer
+        webrtc_ctx = webrtc_streamer(
+            key="object-detection",
+            video_processor_factory=VideoProcessor,
+            rtc_configuration=RTC_CONFIGURATION,
+            media_stream_constraints={"video": True, "audio": False},
+            async_processing=True,
+        )
+        
+        if webrtc_ctx.video_processor:
+            webrtc_ctx.video_processor.confidence_threshold = confidence_threshold
+            webrtc_ctx.video_processor.tracking_enabled = tracking_enabled
+    
+    with tab2:
+        st.markdown("### RTSP Stream Detection")
+        st.warning("This feature requires an RTSP stream URL (e.g., from an IP camera)")
+        
+        rtsp_url = st.text_input("Enter RTSP Stream URL", "rtsp://example.com/stream")
+        
+        if st.button("Connect to Stream"):
+            st.warning("RTSP stream processing would be implemented here in a production app")
+            st.info(f"Would connect to: {rtsp_url}")
+
+# Video Processing Page
+elif selected == "Video Processing":
+    st.markdown('<div class="subheader">Video File Processing</div>', unsafe_allow_html=True)
+    
+    uploaded_file = st.file_uploader(
+        "Upload a video file", 
+        type=["mp4", "avi", "mov"],
+        help="Upload a video file for object detection processing"
+    )
+    
+    if uploaded_file is not None:
+        st.success("Video file uploaded successfully!")
+        
+        # Save uploaded file to temporary location
+        tfile = tempfile.NamedTemporaryFile(delete=False) 
+        tfile.write(uploaded_file.read())
+        
+        # Display video info
+        video = cv2.VideoCapture(tfile.name)
+        width = int(video.get(cv2.CAP_PROP_FRAME_WIDTH))
+        height = int(video.get(cv2.CAP_PROP_FRAME_HEIGHT))
+        fps = video.get(cv2.CAP_PROP_FPS)
+        frame_count = int(video.get(cv2.CAP_PROP_FRAME_COUNT))
+        duration = frame_count / fps
+        
+        col1, col2, col3 = st.columns(3)
+        col1.metric("Resolution", f"{width}x{height}")
+        col2.metric("FPS", f"{fps:.2f}")
+        col3.metric("Duration", f"{duration:.2f} seconds")
+        
+        # Processing options
+        st.markdown("### Processing Options")
+        confidence_threshold = st.slider(
+            "Confidence Threshold", 
+            min_value=0.1, 
+            max_value=0.9, 
+            value=0.5, 
+            step=0.05
+        )
+        
+        tracking_enabled = st.checkbox("Enable Object Tracking", value=True)
+        show_fps = st.checkbox("Show FPS Counter", value=True)
+        
+        # Process video button
+        if st.button("Process Video"):
+            st.warning("Video processing would be implemented here in a production app")
+            
+            # Simulate processing with progress bar
+            progress_bar = st.progress(0)
+            status_text = st.empty()
+            
+            for i in range(1, 101):
+                progress_bar.progress(i)
+                status_text.text(f"Processing: {i}% complete")
+                time.sleep(0.05)
+            
+            st.success("Video processing completed!")
+            st.balloons()
+
+# Model Zoo Page
+elif selected == "Model Zoo":
+    st.markdown('<div class="subheader">Model Selection</div>', unsafe_allow_html=True)
+    
+    st.markdown("""
+        Choose from our pre-trained models or upload your own custom model.
+        Different models offer different trade-offs between speed and accuracy.
+    """)
+    
+    # Model cards
+    col1, col2, col3 = st.columns(3)
+    
+    with col1:
+        st.markdown("""
+            <div class="model-card">
+                <h3>YOLOv5s</h3>
+                <p><b>Type:</b> Object Detection</p>
+                <p><b>Speed:</b> ⚡⚡⚡⚡⚡</p>
+                <p><b>Accuracy:</b> ⭐⭐⭐</p>
+                <p>Ultra-fast detection for real-time applications</p>
+            </div>
+        """, unsafe_allow_html=True)
+        if st.button("Select YOLOv5s", key="yolov5s"):
+            st.session_state.selected_model = "yolov5s"
+            st.success("YOLOv5s selected!")
+    
+    with col2:
+        st.markdown("""
+            <div class="model-card">
+                <h3>Faster R-CNN</h3>
+                <p><b>Type:</b> Object Detection</p>
+                <p><b>Speed:</b> ⚡⚡</p>
+                <p><b>Accuracy:</b> ⭐⭐⭐⭐⭐</p>
+                <p>High accuracy for critical applications</p>
+            </div>
+        """, unsafe_allow_html=True)
+        if st.button("Select Faster R-CNN", key="frcnn"):
+            st.session_state.selected_model = "faster_rcnn"
+            st.success("Faster R-CNN selected!")
+    
+    with col3:
+        st.markdown("""
+            <div class="model-card">
+                <h3>DeepSORT</h3>
+                <p><b>Type:</b> Object Tracking</p>
+                <p><b>Speed:</b> ⚡⚡⚡</p>
+                <p><b>Accuracy:</b> ⭐⭐⭐⭐</p>
+                <p>Tracking with deep learning features</p>
+            </div>
+        """, unsafe_allow_html=True)
+        if st.button("Select DeepSORT", key="deepsort"):
+            st.session_state.selected_model = "deepsort"
+            st.success("DeepSORT selected!")
+    
+    st.markdown("---")
+    st.markdown("### Custom Model Upload")
+    
+    custom_model = st.file_uploader(
+        "Upload your custom model (PyTorch or TensorFlow)", 
+        type=["pt", "pth", "h5", "onnx"],
+        help="Upload your custom trained model file"
+    )
+    
+    if custom_model is not None:
+        st.success("Custom model uploaded successfully!")
+        st.info("Model would be loaded and validated here in a production app")
+
+# Settings Page
+elif selected == "Settings":
+    st.markdown('<div class="subheader">Application Settings</div>', unsafe_allow_html=True)
+    
+    st.markdown("### Detection Parameters")
+    confidence_threshold = st.slider(
+        "Default Confidence Threshold", 
+        min_value=0.1, 
+        max_value=0.9, 
+        value=0.5, 
+        step=0.05
+    )
+    
+    iou_threshold = st.slider(
+        "IOU Threshold (for NMS)", 
+        min_value=0.1, 
+        max_value=0.9, 
+        value=0.45, 
+        step=0.05,
+        help="Intersection over Union threshold for non-maximum suppression"
+    )
+    
+    st.markdown("### Tracking Parameters")
+    max_age = st.slider(
+        "Max Track Age (frames)", 
+        min_value=1, 
+        max_value=100, 
+        value=30,
+        help="Number of frames to keep a track alive without detection"
+    )
+    
+    min_hits = st.slider(
+        "Min Detection Hits", 
+        min_value=1, 
+        max_value=10, 
+        value=3,
+        help="Number of detections needed before a track is confirmed"
+    )
+    
+    if st.button("Save Settings"):
+        st.success("Settings saved successfully!")
+
+# About Page
+elif selected == "About":
+    st.markdown('<div class="subheader">About This Project</div>', unsafe_allow_html=True)
+    
+    st.markdown("""
+        **Real-Time Object Detection & Tracking System**
+        
+        This application demonstrates advanced computer vision capabilities for:
+        - Autonomous vehicle perception systems
+        - Surveillance and security applications
+        - Traffic monitoring and analysis
+        - Smart city infrastructure
+        
+        **Key Technologies:**
+        - Deep learning-based object detection
+        - Multi-object tracking algorithms
+        - Real-time video processing
+        - Edge computing optimization
+        
+        **Underlying Models:**
+        - YOLOv5 for fast object detection
+        - Faster R-CNN for high accuracy
+        - DeepSORT for object tracking
+        
+        Developed with ❤️ using Streamlit and OpenCV.
+    """)
+    
+    st.markdown("---")
+    st.markdown("""
+        **Disclaimer:** This is a demonstration application. For production use, 
+        please ensure proper testing and validation of all components.
+    """)
+
+# Footer
+st.markdown("---")
+st.markdown("""
+    <div style="text-align: center; color: #7f8c8d; font-size: 0.9rem;">
+        Real-Time Object Detection & Tracking | Powered by Streamlit and Hugging Face
+    </div>
+""", unsafe_allow_html=True)