Update src/streamlit_app.py

src/streamlit_app.py

@@ -1,40 +1,279 @@
-import altair as alt
-import numpy as np
-import pandas as pd
+"""
+Real-time Object Detection with YOLO - Streamlit Application
+Main application file for the web interface.
+"""
+
 import streamlit as st
+import cv2
+import numpy as np
+import time
+from PIL import Image
+import sys
+import os
 
-"""
-# Welcome to Streamlit!
+# Add src directory to path
+sys.path.append(os.path.join(os.path.dirname(__file__), 'src'))
 
-Edit `/streamlit_app.py` to customize this app to your heart's desire :heart:.
-If you have any questions, checkout our [documentation](https://docs.streamlit.io) and [community
-forums](https://discuss.streamlit.io).
+from detection.yolo_detector import YOLODetector
+from detection.webcam_capture import WebcamCapture, get_available_cameras
+from utils.config import app_config
+from utils.helpers import format_detection_info, log_detection_summary
 
-In the meantime, below is an example of what you can do with just a few lines of code:
-"""
+# Page configuration
+st.set_page_config(
+    page_title=app_config.ui.page_title,
+    page_icon="🎯",
+    layout="wide",
+    initial_sidebar_state="expanded"
+)
+
+# Initialize session state
+if 'detector' not in st.session_state:
+    st.session_state.detector = None
+if 'webcam' not in st.session_state:
+    st.session_state.webcam = None
+if 'is_running' not in st.session_state:
+    st.session_state.is_running = False
+if 'frame_count' not in st.session_state:
+    st.session_state.frame_count = 0
+if 'detection_stats' not in st.session_state:
+    st.session_state.detection_stats = {}
+
+def initialize_detector(model_name: str, confidence_threshold: float):
+    """Initialize the YOLO detector."""
+    try:
+        with st.spinner(f"Loading {model_name} model..."):
+            detector = YOLODetector(model_name, confidence_threshold)
+            if detector.model is not None:
+                st.session_state.detector = detector
+                st.success(f"✅ Model {model_name} loaded successfully!")
+                return True
+            else:
+                st.error(f"❌ Failed to load model {model_name}")
+                return False
+    except Exception as e:
+        st.error(f"❌ Error loading model: {str(e)}")
+        return False
+
+def initialize_webcam(camera_index: int):
+    """Initialize the webcam."""
+    try:
+        webcam = WebcamCapture(
+            camera_index=camera_index,
+            width=app_config.camera.frame_width,
+            height=app_config.camera.frame_height
+        )
+        if webcam.start_capture():
+            st.session_state.webcam = webcam
+            st.success(f"✅ Camera {camera_index} initialized successfully!")
+            return True
+        else:
+            st.error(f"❌ Failed to initialize camera {camera_index}")
+            return False
+    except Exception as e:
+        st.error(f"❌ Error initializing camera: {str(e)}")
+        return False
+
+def main():
+    """Main application function."""
+    
+    # Title and description
+    st.title("🎯 Real-time Object Detection with YOLO")
+    st.markdown("Detect objects in real-time using your webcam and YOLO models.")
+    
+    # Sidebar for controls
+    with st.sidebar:
+        st.header("⚙️ Settings")
+        
+        # Model selection
+        st.subheader("🤖 Model Configuration")
+        selected_model = st.selectbox(
+            "Select YOLO Model",
+            app_config.available_models,
+            index=app_config.available_models.index(app_config.detection.model_name),
+            help="Choose the YOLO model variant. Nano is fastest, X is most accurate."
+        )
+        
+        # Show model description
+        model_info = app_config.get_model_info(selected_model)
+        st.info(model_info['description'])
+        
+        # Confidence threshold
+        confidence_threshold = st.slider(
+            "Confidence Threshold",
+            min_value=0.1,
+            max_value=1.0,
+            value=app_config.detection.confidence_threshold,
+            step=0.05,
+            help="Minimum confidence score for detections"
+        )
+        
+        # Camera selection
+        st.subheader("📹 Camera Configuration")
+        available_cameras = get_available_cameras()
+        
+        if available_cameras:
+            camera_index = st.selectbox(
+                "Select Camera",
+                available_cameras,
+                index=0,
+                help="Choose the camera to use for detection"
+            )
+        else:
+            st.error("❌ No cameras detected!")
+            camera_index = 0
+        
+        # Performance settings
+        st.subheader("⚡ Performance")
+        detection_interval = st.slider(
+            "Detection Interval",
+            min_value=1,
+            max_value=10,
+            value=app_config.performance.detection_interval,
+            help="Process every N frames (higher = faster but less frequent detection)"
+        )
+        
+        # Display settings
+        st.subheader("🎨 Display Options")
+        show_fps = st.checkbox("Show FPS", value=app_config.ui.show_fps)
+        show_stats = st.checkbox("Show Statistics", value=app_config.ui.show_stats)
+        show_confidence = st.checkbox("Show Confidence Scores", value=app_config.ui.show_confidence)
+        
+        # Control buttons
+        st.subheader("🎮 Controls")
+        
+        col1, col2 = st.columns(2)
+        
+        with col1:
+            if st.button("🚀 Start Detection", disabled=st.session_state.is_running):
+                # Initialize detector if needed
+                if (st.session_state.detector is None or 
+                    st.session_state.detector.model_name != selected_model or
+                    st.session_state.detector.confidence_threshold != confidence_threshold):
+                    
+                    if initialize_detector(selected_model, confidence_threshold):
+                        st.session_state.detector.update_confidence_threshold(confidence_threshold)
+                    else:
+                        st.stop()
+                
+                # Initialize webcam if needed
+                if (st.session_state.webcam is None or 
+                    not st.session_state.webcam.is_camera_available()):
+                    
+                    if not initialize_webcam(camera_index):
+                        st.stop()
+                
+                st.session_state.is_running = True
+                st.session_state.frame_count = 0
+                st.rerun()
+        
+        with col2:
+            if st.button("⏹️ Stop Detection", disabled=not st.session_state.is_running):
+                st.session_state.is_running = False
+                if st.session_state.webcam:
+                    st.session_state.webcam.stop_capture()
+                    st.session_state.webcam = None
+                st.rerun()
+    
+    # Main content area
+    if st.session_state.is_running and st.session_state.webcam and st.session_state.detector:
+        # Create columns for video and stats
+        col1, col2 = st.columns([3, 1])
+        
+        with col1:
+            st.subheader("📹 Live Video Feed")
+            video_placeholder = st.empty()
+        
+        with col2:
+            if show_stats:
+                st.subheader("📊 Statistics")
+                stats_placeholder = st.empty()
+        
+        # Performance metrics placeholders
+        if show_fps:
+            fps_placeholder = st.empty()
+        
+        # Detection loop
+        while st.session_state.is_running:
+            frame = st.session_state.webcam.get_frame()
+            
+            if frame is not None:
+                st.session_state.frame_count += 1
+                
+                # Process frame for detection
+                if st.session_state.frame_count % detection_interval == 0:
+                    detections = st.session_state.detector.detect_objects(frame)
+                    annotated_frame = st.session_state.detector.draw_detections(frame, detections)
+                    
+                    # Update detection stats
+                    st.session_state.detection_stats = st.session_state.detector.get_detection_stats(detections)
+                else:
+                    annotated_frame = frame
+                    detections = []
+                
+                # Convert BGR to RGB for display
+                display_frame = cv2.cvtColor(annotated_frame, cv2.COLOR_BGR2RGB)
+                
+                # Display video
+                with video_placeholder.container():
+                    st.image(display_frame, channels="RGB", use_column_width=True)
+                
+                # Display FPS
+                if show_fps:
+                    current_fps = st.session_state.webcam.get_fps()
+                    fps_placeholder.metric("🎯 FPS", f"{current_fps:.1f}")
+                
+                # Display statistics
+                if show_stats and st.session_state.detection_stats:
+                    with stats_placeholder.container():
+                        stats = st.session_state.detection_stats
+                        
+                        st.metric("🎯 Objects Detected", stats['total_objects'])
+                        
+                        if stats['total_objects'] > 0:
+                            st.metric("📈 Avg Confidence", f"{stats['avg_confidence']:.2f}")
+                            st.metric("🔝 Max Confidence", f"{stats['max_confidence']:.2f}")
+                            
+                            # Class breakdown
+                            st.write("**Object Classes:**")
+                            for class_name, count in stats['class_counts'].items():
+                                st.write(f"• {class_name}: {count}")
+                
+                # Small delay to prevent overwhelming the interface
+                time.sleep(0.01)
+            
+            else:
+                st.warning("⚠️ No frame received from camera")
+                time.sleep(0.1)
+    
+    else:
+        # Show instructions when not running
+        st.info("👆 Configure your settings in the sidebar and click 'Start Detection' to begin!")
+        
+        # Show system information
+        st.subheader("ℹ️ System Information")
+        
+        col1, col2, col3 = st.columns(3)
+        
+        with col1:
+            st.write("**Available Cameras:**")
+            cameras = get_available_cameras()
+            if cameras:
+                for cam in cameras:
+                    st.write(f"• Camera {cam}")
+            else:
+                st.write("• No cameras detected")
+        
+        with col2:
+            st.write("**Available Models:**")
+            for model in app_config.available_models:
+                st.write(f"• {model}")
+        
+        with col3:
+            st.write("**Current Configuration:**")
+            st.write(f"• Model: {app_config.detection.model_name}")
+            st.write(f"• Confidence: {app_config.detection.confidence_threshold}")
+            st.write(f"• Camera: {app_config.camera.camera_index}")
 
-num_points = st.slider("Number of points in spiral", 1, 10000, 1100)
-num_turns = st.slider("Number of turns in spiral", 1, 300, 31)
-
-indices = np.linspace(0, 1, num_points)
-theta = 2 * np.pi * num_turns * indices
-radius = indices
-
-x = radius * np.cos(theta)
-y = radius * np.sin(theta)
-
-df = pd.DataFrame({
-    "x": x,
-    "y": y,
-    "idx": indices,
-    "rand": np.random.randn(num_points),
-})
-
-st.altair_chart(alt.Chart(df, height=700, width=700)
-    .mark_point(filled=True)
-    .encode(
-        x=alt.X("x", axis=None),
-        y=alt.Y("y", axis=None),
-        color=alt.Color("idx", legend=None, scale=alt.Scale()),
-        size=alt.Size("rand", legend=None, scale=alt.Scale(range=[1, 150])),
-    ))
+if __name__ == "__main__":
+    main()