Update app.py

app.py

@@ -1,329 +1,328 @@
-"""
-Vehicle Speed Estimation and Counting - Gradio Interface
-=========================================================
-
-A real-time vehicle detection, tracking, counting, and speed estimation system
-using YOLO object detection and perspective transformation techniques.
-
-Authors:
-    - Abhay Gupta (0205CC221005)
-    - Aditi Lakhera (0205CC221011)
-    - Balraj Patel (0205CC221049)
-    - Bhumika Patel (0205CC221050)
-
-This application provides an interactive web interface for analyzing traffic videos
-and estimating vehicle speeds using computer vision techniques.
-"""
-
-import os
-import sys
-import tempfile
-import logging
-from pathlib import Path
-from typing import Optional, Tuple
-
-import gradio as gr
-import cv2
-import numpy as np
-
-# Configure logging
-logging.basicConfig(
-    level=logging.INFO,
-    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
-)
-logger = logging.getLogger(__name__)
-
-# Import application modules
-try:
-    from main import process_video
-    from config import VehicleDetectionConfig
-except ImportError as e:
-    logger.error(f"Failed to import required modules: {e}")
-    raise
-
-
-def validate_video_file(video_path: str) -> Tuple[bool, str]:
-    """
-    Validate uploaded video file.
-    
-    Args:
-        video_path: Path to video file
-        
-    Returns:
-        Tuple of (is_valid, error_message)
-    """
-    if not video_path:
-        return False, "No video file provided"
-    
-    if not os.path.exists(video_path):
-        return False, f"Video file not found: {video_path}"
-    
-    # Check file size (limit to 100MB for HF Spaces)
-    file_size_mb = os.path.getsize(video_path) / (1024 * 1024)
-    if file_size_mb > 100:
-        return False, f"Video file too large ({file_size_mb:.1f}MB). Maximum size is 100MB"
-    
-    # Validate video can be opened
-    try:
-        cap = cv2.VideoCapture(video_path)
-        if not cap.isOpened():
-            return False, "Unable to open video file. Please ensure it's a valid video format"
-        
-        # Check if video has frames
-        ret, _ = cap.read()
-        cap.release()
-        
-        if not ret:
-            return False, "Video file appears to be empty or corrupted"
-            
-        return True, ""
-    except Exception as e:
-        return False, f"Error validating video: {str(e)}"
-
-
-def estimate_vehicle_speed(
-    video_file: str,
-    model_choice: str,
-    line_position: int,
-    confidence_threshold: float,
-    progress=gr.Progress()
-) -> Tuple[Optional[str], str]:
-    """
-    Process video and estimate vehicle speeds.
-    
-    Args:
-        video_file: Path to uploaded video
-        model_choice: YOLO model selection
-        line_position: Y-coordinate for counting line
-        confidence_threshold: Detection confidence threshold
-        progress: Gradio progress tracker
-        
-    Returns:
-        Tuple of (output_video_path, statistics_text)
-    """
-    try:
-        # Validate input
-        progress(0, desc="Validating video file...")
-        is_valid, error_msg = validate_video_file(video_file)
-        if not is_valid:
-            logger.error(f"Video validation failed: {error_msg}")
-            return None, f"❌ Error: {error_msg}"
-        
-        # Create temporary output file
-        output_path = tempfile.mktemp(suffix='.mp4')
-        
-        # Configure processing
-        progress(0.1, desc="Configuring detection parameters...")
-        config = VehicleDetectionConfig(
-            input_video=video_file,
-            output_video=output_path,
-            model_name=model_choice,
-            line_y=line_position,
-            confidence_threshold=confidence_threshold
-        )
-        
-        # Process video
-        progress(0.2, desc="Processing video (this may take a few minutes)...")
-        logger.info(f"Starting video processing: {video_file}")
-        
-        try:
-            stats = process_video(
-                config=config,
-                progress_callback=lambda p: progress(0.2 + p * 0.7, desc=f"Processing... {int(p*100)}%")
-            )
-            
-            progress(0.95, desc="Finalizing output...")
-            
-            # Format statistics
-            stats_text = f"""
-## 📊 Processing Results
-
-### Vehicle Count Statistics
-- **Total Vehicles Detected:** {stats['total_count']}
-- **Vehicles Entering (In):** {stats['in_count']}
-- **Vehicles Exiting (Out):** {stats['out_count']}
-
-### Speed Analysis
-- **Average Speed:** {stats['avg_speed']:.1f} km/h
-- **Maximum Speed:** {stats['max_speed']:.1f} km/h
-- **Minimum Speed:** {stats['min_speed']:.1f} km/h
-
-### Processing Information
-- **Frames Processed:** {stats['frames_processed']}
-- **Processing Time:** {stats['processing_time']:.2f} seconds
-- **Model Used:** {model_choice}
-- **Detection Confidence:** {confidence_threshold:.2f}
-
-✅ **Processing completed successfully!**
-"""
-            
-            progress(1.0, desc="Complete!")
-            logger.info("Video processing completed successfully")
-            return output_path, stats_text
-            
-        except Exception as e:
-            logger.error(f"Error during video processing: {e}", exc_info=True)
-            return None, f"❌ **Processing Error:** {str(e)}\n\nPlease try with different settings or a different video."
-    
-    except Exception as e:
-        logger.error(f"Unexpected error in estimate_vehicle_speed: {e}", exc_info=True)
-        return None, f"❌ **Unexpected Error:** {str(e)}"
-
-
-def create_demo_interface() -> gr.Blocks:
-    """
-    Create Gradio interface for vehicle speed estimation.
-    
-    Returns:
-        Gradio Blocks interface
-    """
-    with gr.Blocks(
-        title="Vehicle Speed Estimation & Counting",
-        theme=gr.themes.Soft()
-    ) as demo:
-        
-        gr.Markdown("""
-# 🚗 Vehicle Speed Estimation & Counting System
-
-An intelligent traffic analysis system that detects, tracks, counts, and estimates the speed of vehicles in video footage using advanced computer vision techniques.
-
-### 🎯 Features
-- **Real-time Vehicle Detection** using YOLO
-- **Multi-Object Tracking** with ByteTrack
-- **Accurate Speed Estimation** via perspective transformation
-- **Vehicle Counting** with configurable detection zones
-
-### 👥 Developed By
-- **Abhay Gupta** (0205CC221005)
-- **Aditi Lakhera** (0205CC221011)
-- **Balraj Patel** (0205CC221049)
-- **Bhumika Patel** (0205CC221050)
-
----
-""")
-        
-        with gr.Row():
-            with gr.Column(scale=1):
-                gr.Markdown("### 📤 Input Configuration")
-                
-                video_input = gr.Video(
-                    label="Upload Traffic Video",
-                    format="mp4"
-                )
-                
-                with gr.Accordion("⚙️ Advanced Settings", open=False):
-                    model_choice = gr.Dropdown(
-                        choices=["yolov8n", "yolov8s", "yolov8m", "yolov8l"],
-                        value="yolov8n",
-                        label="YOLO Model",
-                        info="Larger models are more accurate but slower"
-                    )
-                    
-                    line_position = gr.Slider(
-                        minimum=100,
-                        maximum=1000,
-                        value=480,
-                        step=10,
-                        label="Counting Line Position (Y-coordinate)",
-                        info="Vertical position of the vehicle counting line"
-                    )
-                    
-                    confidence_threshold = gr.Slider(
-                        minimum=0.1,
-                        maximum=0.9,
-                        value=0.3,
-                        step=0.05,
-                        label="Detection Confidence Threshold",
-                        info="Higher values reduce false positives"
-                    )
-                
-                process_btn = gr.Button(
-                    "🚀 Process Video",
-                    variant="primary",
-                    size="lg"
-                )
-                
-                gr.Markdown("""
-### 📋 Instructions
-1. Upload a traffic video (MP4 format, max 100MB)
-2. Adjust settings if needed (optional)
-3. Click "Process Video" and wait for results
-4. Download the annotated video with speed estimates
-
-### 💡 Tips
-- Use videos with clear vehicle visibility
-- Ensure consistent camera angle
-- Better lighting improves detection accuracy
-""")
-            
-            with gr.Column(scale=1):
-                gr.Markdown("### 📥 Output Results")
-                
-                video_output = gr.Video(
-                    label="Processed Video with Annotations"
-                )
-                
-                stats_output = gr.Markdown(
-                    label="Statistics",
-                    value="*Processing results will appear here...*"
-                )
-        
-        # Example videos section
-        gr.Markdown("""
----
-### 🎬 Example Videos
-Upload your own traffic video or use sample footage to test the system.
-""")
-        
-        gr.Examples(
-            examples=[
-                ["./data/vehicles.mp4", "yolov8n", 480, 0.3],
-            ],
-            inputs=[video_input, model_choice, line_position, confidence_threshold],
-            outputs=[video_output, stats_output],
-            fn=estimate_vehicle_speed,
-            cache_examples=False,
-            label="Sample Videos"
-        )
-        
-        # Connect processing function
-        process_btn.click(
-            fn=estimate_vehicle_speed,
-            inputs=[video_input, model_choice, line_position, confidence_threshold],
-            outputs=[video_output, stats_output]
-        )
-        
-        gr.Markdown("""
----
-### 🔬 Technical Details
-
-This system uses:
-- **YOLO (You Only Look Once)** for real-time object detection
-- **ByteTrack** for multi-object tracking across frames
-- **Perspective Transformation** for accurate speed calculation
-- **OpenCV** for video processing and computer vision operations
-
-### 📚 References
-- [Ultralytics YOLO](https://github.com/ultralytics/ultralytics)
-- [Supervision Library](https://github.com/roboflow/supervision)
-- [OpenCV](https://opencv.org/)
-
-### 📄 License
-MIT License - See LICENSE file for details
-""")
-    
-    return demo
-
-
-if __name__ == "__main__":
-    try:
-        logger.info("Starting Vehicle Speed Estimation application...")
-        demo = create_demo_interface()
-        demo.launch(
-            server_name="0.0.0.0",
-            server_port=7860,
-            share=False
-        )
-    except Exception as e:
-        logger.error(f"Failed to launch application: {e}", exc_info=True)
-        sys.exit(1)
+"""
+Vehicle Speed Estimation and Counting - Gradio Interface
+=========================================================
+
+A real-time vehicle detection, tracking, counting, and speed estimation system
+using YOLO object detection and perspective transformation techniques.
+
+Authors:
+    - Abhay Gupta (0205CC221005)
+    - Aditi Lakhera (0205CC221011)
+    - Balraj Patel (0205CC221049)
+    - Bhumika Patel (0205CC221050)
+
+This application provides an interactive web interface for analyzing traffic videos
+and estimating vehicle speeds using computer vision techniques.
+"""
+
+import os
+import sys
+import tempfile
+import logging
+from pathlib import Path
+from typing import Optional, Tuple
+
+import gradio as gr
+import cv2
+import numpy as np
+
+# Configure logging
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
+)
+logger = logging.getLogger(__name__)
+
+# Import application modules
+try:
+    from main import process_video
+    from config import VehicleDetectionConfig
+except ImportError as e:
+    logger.error(f"Failed to import required modules: {e}")
+    raise
+
+
+def validate_video_file(video_path: str) -> Tuple[bool, str]:
+    """
+    Validate uploaded video file.
+    
+    Args:
+        video_path: Path to video file
+        
+    Returns:
+        Tuple of (is_valid, error_message)
+    """
+    if not video_path:
+        return False, "No video file provided"
+    
+    if not os.path.exists(video_path):
+        return False, f"Video file not found: {video_path}"
+    
+    # Check file size (limit to 100MB for HF Spaces)
+    file_size_mb = os.path.getsize(video_path) / (1024 * 1024)
+    if file_size_mb > 100:
+        return False, f"Video file too large ({file_size_mb:.1f}MB). Maximum size is 100MB"
+    
+    # Validate video can be opened
+    try:
+        cap = cv2.VideoCapture(video_path)
+        if not cap.isOpened():
+            return False, "Unable to open video file. Please ensure it's a valid video format"
+        
+        # Check if video has frames
+        ret, _ = cap.read()
+        cap.release()
+        
+        if not ret:
+            return False, "Video file appears to be empty or corrupted"
+            
+        return True, ""
+    except Exception as e:
+        return False, f"Error validating video: {str(e)}"
+
+
+def estimate_vehicle_speed(
+    video_file: str,
+    model_choice: str,
+    line_position: int,
+    confidence_threshold: float,
+    progress=gr.Progress()
+) -> Tuple[Optional[str], str]:
+    """
+    Process video and estimate vehicle speeds.
+    
+    Args:
+        video_file: Path to uploaded video
+        model_choice: YOLO model selection
+        line_position: Y-coordinate for counting line
+        confidence_threshold: Detection confidence threshold
+        progress: Gradio progress tracker
+        
+    Returns:
+        Tuple of (output_video_path, statistics_text)
+    """
+    try:
+        # Validate input
+        progress(0, desc="Validating video file...")
+        is_valid, error_msg = validate_video_file(video_file)
+        if not is_valid:
+            logger.error(f"Video validation failed: {error_msg}")
+            return None, f"❌ Error: {error_msg}"
+        
+        # Create temporary output file
+        output_path = tempfile.mktemp(suffix='.mp4')
+        
+        # Configure processing
+        progress(0.1, desc="Configuring detection parameters...")
+        config = VehicleDetectionConfig(
+            input_video=video_file,
+            output_video=output_path,
+            model_name=model_choice,
+            line_y=line_position,
+            confidence_threshold=confidence_threshold
+        )
+        
+        # Process video
+        progress(0.2, desc="Processing video (this may take a few minutes)...")
+        logger.info(f"Starting video processing: {video_file}")
+        
+        try:
+            stats = process_video(
+                config=config,
+                progress_callback=lambda p: progress(0.2 + p * 0.7, desc=f"Processing... {int(p*100)}%")
+            )
+            
+            progress(0.95, desc="Finalizing output...")
+            
+            # Format statistics
+            stats_text = f"""
+## 📊 Processing Results
+
+### Vehicle Count Statistics
+- **Total Vehicles Detected:** {stats['total_count']}
+- **Vehicles Entering (In):** {stats['in_count']}
+- **Vehicles Exiting (Out):** {stats['out_count']}
+
+### Speed Analysis
+- **Average Speed:** {stats['avg_speed']:.1f} km/h
+- **Maximum Speed:** {stats['max_speed']:.1f} km/h
+- **Minimum Speed:** {stats['min_speed']:.1f} km/h
+
+### Processing Information
+- **Frames Processed:** {stats['frames_processed']}
+- **Processing Time:** {stats['processing_time']:.2f} seconds
+- **Model Used:** {model_choice}
+- **Detection Confidence:** {confidence_threshold:.2f}
+
+✅ **Processing completed successfully!**
+"""
+            
+            progress(1.0, desc="Complete!")
+            logger.info("Video processing completed successfully")
+            return output_path, stats_text
+            
+        except Exception as e:
+            logger.error(f"Error during video processing: {e}", exc_info=True)
+            return None, f"❌ **Processing Error:** {str(e)}\n\nPlease try with different settings or a different video."
+    
+    except Exception as e:
+        logger.error(f"Unexpected error in estimate_vehicle_speed: {e}", exc_info=True)
+        return None, f"❌ **Unexpected Error:** {str(e)}"
+
+
+def create_demo_interface() -> gr.Blocks:
+    """
+    Create Gradio interface for vehicle speed estimation.
+    
+    Returns:
+        Gradio Blocks interface
+    """
+    with gr.Blocks(
+        title="Vehicle Speed Estimation & Counting"
+    ) as demo:
+        
+        gr.Markdown("""
+# 🚗 Vehicle Speed Estimation & Counting System
+
+An intelligent traffic analysis system that detects, tracks, counts, and estimates the speed of vehicles in video footage using advanced computer vision techniques.
+
+### 🎯 Features
+- **Real-time Vehicle Detection** using YOLO
+- **Multi-Object Tracking** with ByteTrack
+- **Accurate Speed Estimation** via perspective transformation
+- **Vehicle Counting** with configurable detection zones
+
+### 👥 Developed By
+- **Abhay Gupta** (0205CC221005)
+- **Aditi Lakhera** (0205CC221011)
+- **Balraj Patel** (0205CC221049)
+- **Bhumika Patel** (0205CC221050)
+
+---
+""")
+        
+        with gr.Row():
+            with gr.Column(scale=1):
+                gr.Markdown("### 📤 Input Configuration")
+                
+                video_input = gr.Video(
+                    label="Upload Traffic Video",
+                    format="mp4"
+                )
+                
+                with gr.Accordion("⚙️ Advanced Settings", open=False):
+                    model_choice = gr.Dropdown(
+                        choices=["yolov8n", "yolov8s", "yolov8m", "yolov8l"],
+                        value="yolov8n",
+                        label="YOLO Model",
+                        info="Larger models are more accurate but slower"
+                    )
+                    
+                    line_position = gr.Slider(
+                        minimum=100,
+                        maximum=1000,
+                        value=480,
+                        step=10,
+                        label="Counting Line Position (Y-coordinate)",
+                        info="Vertical position of the vehicle counting line"
+                    )
+                    
+                    confidence_threshold = gr.Slider(
+                        minimum=0.1,
+                        maximum=0.9,
+                        value=0.3,
+                        step=0.05,
+                        label="Detection Confidence Threshold",
+                        info="Higher values reduce false positives"
+                    )
+                
+                process_btn = gr.Button(
+                    "🚀 Process Video",
+                    variant="primary",
+                    size="lg"
+                )
+                
+                gr.Markdown("""
+### 📋 Instructions
+1. Upload a traffic video (MP4 format, max 100MB)
+2. Adjust settings if needed (optional)
+3. Click "Process Video" and wait for results
+4. Download the annotated video with speed estimates
+
+### 💡 Tips
+- Use videos with clear vehicle visibility
+- Ensure consistent camera angle
+- Better lighting improves detection accuracy
+""")
+            
+            with gr.Column(scale=1):
+                gr.Markdown("### 📥 Output Results")
+                
+                video_output = gr.Video(
+                    label="Processed Video with Annotations"
+                )
+                
+                stats_output = gr.Markdown(
+                    label="Statistics",
+                    value="*Processing results will appear here...*"
+                )
+        
+        # Example videos section
+        gr.Markdown("""
+---
+### 🎬 Example Videos
+Upload your own traffic video or use sample footage to test the system.
+""")
+        
+        gr.Examples(
+            examples=[
+                ["./data/vehicles.mp4", "yolov8n", 480, 0.3],
+            ],
+            inputs=[video_input, model_choice, line_position, confidence_threshold],
+            outputs=[video_output, stats_output],
+            fn=estimate_vehicle_speed,
+            cache_examples=False,
+            label="Sample Videos"
+        )
+        
+        # Connect processing function
+        process_btn.click(
+            fn=estimate_vehicle_speed,
+            inputs=[video_input, model_choice, line_position, confidence_threshold],
+            outputs=[video_output, stats_output]
+        )
+        
+        gr.Markdown("""
+---
+### 🔬 Technical Details
+
+This system uses:
+- **YOLO (You Only Look Once)** for real-time object detection
+- **ByteTrack** for multi-object tracking across frames
+- **Perspective Transformation** for accurate speed calculation
+- **OpenCV** for video processing and computer vision operations
+
+### 📚 References
+- [Ultralytics YOLO](https://github.com/ultralytics/ultralytics)
+- [Supervision Library](https://github.com/roboflow/supervision)
+- [OpenCV](https://opencv.org/)
+
+### 📄 License
+MIT License - See LICENSE file for details
+""")
+    
+    return demo
+
+
+if __name__ == "__main__":
+    try:
+        logger.info("Starting Vehicle Speed Estimation application...")
+        demo = create_demo_interface()
+        demo.launch(
+            server_name="0.0.0.0",
+            server_port=7860,
+            share=False
+        )
+    except Exception as e:
+        logger.error(f"Failed to launch application: {e}", exc_info=True)
+        sys.exit(1)