Upload 9 files

Dockerfile

@@ -0,0 +1,27 @@
+FROM python:3.11-slim
+
+# Install system dependencies for OpenCV and FFmpeg
+RUN apt-get update && apt-get install -y \
+    libgl1-mesa-glx \
+    libglib2.0-0 \
+    ffmpeg \
+    && rm -rf /var/lib/apt/lists/*
+
+# Set working directory
+WORKDIR /app
+
+# Create necessary directories with write permissions
+RUN mkdir -p uploads outputs && chmod 777 uploads outputs
+
+# Copy requirements first to leverage cache
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Copy application code
+COPY . .
+
+# Expose Hugging Face default port
+EXPOSE 7860
+
+# Run the application
+CMD ["python", "app.py"]

app.py

@@ -0,0 +1,132 @@
+"""
+Hugging Face Spaces - Vehicle Tracking App
+"""
+from flask import Flask, request, jsonify, send_file, send_from_directory
+from werkzeug.utils import secure_filename
+import os
+import subprocess
+import threading
+import time
+import shutil
+
+app = Flask(__name__)
+
+# Configuration
+UPLOAD_FOLDER = 'uploads'
+OUTPUT_FOLDER = 'outputs'
+ALLOWED_EXTENSIONS = {'mp4', 'avi', 'mov', 'mkv'}
+
+# Create folders
+os.makedirs(UPLOAD_FOLDER, exist_ok=True)
+os.makedirs(OUTPUT_FOLDER, exist_ok=True)
+
+app.config['UPLOAD_FOLDER'] = UPLOAD_FOLDER
+app.config['OUTPUT_FOLDER'] = OUTPUT_FOLDER
+app.config['MAX_CONTENT_LENGTH'] = 500 * 1024 * 1024  # 500 MB limit
+
+# Global status
+processing_status = {
+    'status': 'idle',
+    'progress': 0,
+    'message': '',
+    'output_file': None
+}
+
+def allowed_file(filename):
+    return '.' in filename and filename.rsplit('.', 1)[1].lower() in ALLOWED_EXTENSIONS
+
+def process_video_background(input_path, output_path):
+    global processing_status
+    try:
+        processing_status['status'] = 'processing'
+        processing_status['progress'] = 0
+        processing_status['message'] = 'Starting processing...'
+        
+        # Run tracker with --no-display flag
+        cmd = [
+            'python', '-u', 'vehicle_tracker.py',
+            '--video', input_path,
+            '--output', output_path,
+            '--no-display'
+        ]
+        
+        process = subprocess.Popen(
+            cmd,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+            text=True,
+            bufsize=1,
+            universal_newlines=True
+        )
+        
+        for line in process.stdout:
+            if "Progress:" in line:
+                try:
+                    parts = line.split('|')[0]
+                    percent = float(parts.split(':')[1].strip().replace('%', ''))
+                    processing_status['progress'] = percent
+                    processing_status['message'] = f'Processing: {percent:.1f}%'
+                except:
+                    pass
+        
+        process.wait()
+        
+        if process.returncode == 0:
+            processing_status['status'] = 'complete'
+            processing_status['progress'] = 100
+            processing_status['message'] = 'Processing complete!'
+            processing_status['output_file'] = os.path.basename(output_path)
+        else:
+            stderr = process.stderr.read()
+            processing_status['status'] = 'error'
+            processing_status['message'] = f'Error: {stderr[:200]}'
+            
+    except Exception as e:
+        processing_status['status'] = 'error'
+        processing_status['message'] = f'System Error: {str(e)}'
+
+@app.route('/')
+def index():
+    return send_file('web_app.html')
+
+@app.route('/upload', methods=['POST'])
+def upload_file():
+    global processing_status
+    processing_status = {'status': 'idle', 'progress': 0, 'message': '', 'output_file': None}
+    
+    if 'video' not in request.files:
+        return jsonify({'error': 'No file part'}), 400
+    file = request.files['video']
+    if file.filename == '':
+        return jsonify({'error': 'No selected file'}), 400
+        
+    if file and allowed_file(file.filename):
+        filename = secure_filename(file.filename)
+        # Use simple timestamp to avoid collisions
+        timestamp = int(time.time())
+        input_filename = f"{timestamp}_{filename}"
+        input_path = os.path.join(app.config['UPLOAD_FOLDER'], input_filename)
+        file.save(input_path)
+        
+        output_filename = f"tracked_{input_filename}"
+        output_path = os.path.join(app.config['OUTPUT_FOLDER'], output_filename)
+        
+        thread = threading.Thread(target=process_video_background, args=(input_path, output_path))
+        thread.daemon = True
+        thread.start()
+        
+        return jsonify({'success': True, 'filename': input_filename})
+    
+    return jsonify({'error': 'Invalid file type'}), 400
+
+@app.route('/status')
+def get_status():
+    return jsonify(processing_status)
+
+@app.route('/download/<filename>')
+def download_file(filename):
+    return send_from_directory(app.config['OUTPUT_FOLDER'], filename, as_attachment=True)
+
+if __name__ == '__main__':
+    # Hugging Face Spaces runs on port 7860
+    app.run(host='0.0.0.0', port=7860)

config.py

@@ -0,0 +1,65 @@
+"""
+Configuration file for Vehicle Tracking and Counting System
+Customize these settings based on your requirements
+"""
+
+# YOLO Model Configuration
+MODEL_NAME = "yolo11x.pt"  # Using Extra Large model for maximum accuracy
+CONFIDENCE_THRESHOLD = 0.25  # Lower threshold to catch more vehicles
+IOU_THRESHOLD = 0.5  # IoU threshold for NMS
+
+# Vehicle Classes (COCO dataset class IDs)
+VEHICLE_CLASSES = {
+    2: "car",
+    3: "motorcycle", 
+    5: "bus",
+    7: "truck"
+}
+
+# Counting Line Configuration
+# Orientation: "horizontal" (for up/down traffic) or "vertical" (for left/right traffic)
+COUNTING_LINE_ORIENTATION = "vertical"
+
+# Line position as percentage of frame size (0.0 to 1.0)
+# For horizontal: percentage of height (0.5 = middle height)
+# For vertical: percentage of width (0.5 = middle width)
+COUNTING_LINE_POSITION = 0.5  
+
+# Or use absolute pixel coordinates (will override percentage if not None)
+# Format: (x1, y1, x2, y2)
+COUNTING_LINE_COORDS = None
+
+# Visualization Settings
+COLORS = {
+    "car": (0, 255, 0),        # Green
+    "truck": (255, 0, 0),      # Blue
+    "bus": (0, 165, 255),      # Orange
+    "motorcycle": (255, 0, 255) # Magenta
+}
+
+LINE_COLOR = (0, 255, 255)     # Yellow for counting line
+LINE_THICKNESS = 3
+BOX_THICKNESS = 2
+FONT_SCALE = 0.6
+FONT_THICKNESS = 2
+
+# Display Settings
+SHOW_CONFIDENCE = True
+SHOW_TRACK_ID = True
+SHOW_CLASS_NAME = True
+DISPLAY_WINDOW = True  # Set to False for headless mode
+
+# Video Settings
+VIDEO_INPUT = "input_video.mp4"  # Path to input video
+VIDEO_OUTPUT = "output_video.mp4"  # Path to save output video
+RESIZE_WIDTH = None  # Set to resize video width (None = original size)
+RESIZE_HEIGHT = None  # Set to resize video height (None = original size)
+
+# Performance Settings
+SKIP_FRAMES = 0  # Process every Nth frame (0 = process all frames)
+USE_GPU = True  # Use GPU if available
+
+# Statistics Display
+STATS_POSITION = (10, 30)  # Position for statistics text
+STATS_COLOR = (255, 255, 255)  # White
+STATS_BG_COLOR = (0, 0, 0)  # Black background

requirements.txt

@@ -0,0 +1,6 @@
+flask
+ultralytics
+opencv-python-headless
+numpy
+torch
+torchvision

utils.py

@@ -0,0 +1,274 @@
+"""
+Utility functions for vehicle tracking and counting system
+"""
+import cv2
+import numpy as np
+from typing import Tuple, Dict
+
+
+def get_center_point(bbox: Tuple[int, int, int, int]) -> Tuple[int, int]:
+    """
+    Calculate the center point of a bounding box
+    
+    Args:
+        bbox: Bounding box coordinates (x1, y1, x2, y2)
+    
+    Returns:
+        Tuple of (center_x, center_y)
+    """
+    x1, y1, x2, y2 = bbox
+    center_x = int((x1 + x2) / 2)
+    center_y = int((y1 + y2) / 2)
+    return center_x, center_y
+
+
+def check_line_crossing(
+    curr_pos: int,
+    prev_pos: int,
+    line_pos: int,
+    margin: int = 5
+) -> bool:
+    """
+    Check if an object has crossed the counting line
+    
+    Args:
+        curr_pos: Current coordinate (X or Y)
+        prev_pos: Previous coordinate (X or Y)
+        line_pos: Coordinate of counting line
+        margin: Margin of error for line crossing
+    
+    Returns:
+        True if object crossed the line (in either direction)
+    """
+    # Check crossing in positive direction (e.g., left to right or top to bottom)
+    if prev_pos < line_pos - margin and curr_pos >= line_pos + margin:
+        return True
+    
+    # Check crossing in negative direction (e.g., right to left or bottom to top)
+    if prev_pos > line_pos + margin and curr_pos <= line_pos - margin:
+        return True
+    
+    return False
+
+
+def draw_counting_line(
+    frame: np.ndarray,
+    line_coords: Tuple[int, int, int, int],
+    color: Tuple[int, int, int],
+    thickness: int
+) -> np.ndarray:
+    """
+    Draw the counting line on the frame
+    
+    Args:
+        frame: Video frame
+        line_coords: Line coordinates (x1, y1, x2, y2)
+        color: Line color (B, G, R)
+        thickness: Line thickness
+    
+    Returns:
+        Frame with line drawn
+    """
+    x1, y1, x2, y2 = line_coords
+    cv2.line(frame, (x1, y1), (x2, y2), color, thickness)
+    
+    # Add text label for the line
+    cv2.putText(
+        frame,
+        "COUNTING LINE",
+        (x1 + 10, y1 - 10),
+        cv2.FONT_HERSHEY_SIMPLEX,
+        0.7,
+        color,
+        2
+    )
+    
+    return frame
+
+
+def draw_statistics(
+    frame: np.ndarray,
+    counts: Dict[str, int],
+    position: Tuple[int, int],
+    font_scale: float = 0.8,
+    color: Tuple[int, int, int] = (255, 255, 255),
+    bg_color: Tuple[int, int, int] = (0, 0, 0)
+) -> np.ndarray:
+    """
+    Draw counting statistics on the frame
+    
+    Args:
+        frame: Video frame
+        counts: Dictionary of vehicle counts by class
+        position: Position to draw statistics (x, y)
+        font_scale: Font scale
+        color: Text color
+        bg_color: Background color
+    
+    Returns:
+        Frame with statistics drawn
+    """
+    x, y = position
+    line_height = 30
+    
+    # Draw background rectangle
+    total_lines = len(counts) + 1
+    cv2.rectangle(
+        frame,
+        (x - 5, y - 25),
+        (x + 250, y + line_height * total_lines + 5),
+        bg_color,
+        -1
+    )
+    
+    # Draw total count
+    total = sum(counts.values())
+    cv2.putText(
+        frame,
+        f"TOTAL: {total}",
+        (x, y),
+        cv2.FONT_HERSHEY_SIMPLEX,
+        font_scale,
+        (0, 255, 255),  # Yellow for total
+        2
+    )
+    
+    # Draw individual class counts
+    y_offset = y + line_height
+    for vehicle_class, count in counts.items():
+        cv2.putText(
+            frame,
+            f"{vehicle_class.upper()}: {count}",
+            (x, y_offset),
+            cv2.FONT_HERSHEY_SIMPLEX,
+            font_scale,
+            color,
+            2
+        )
+        y_offset += line_height
+    
+    return frame
+
+
+def draw_bounding_box(
+    frame: np.ndarray,
+    bbox: Tuple[int, int, int, int],
+    track_id: int,
+    class_name: str,
+    confidence: float,
+    color: Tuple[int, int, int],
+    thickness: int = 2,
+    show_id: bool = True,
+    show_confidence: bool = True
+) -> np.ndarray:
+    """
+    Draw bounding box with label on the frame
+    
+    Args:
+        frame: Video frame
+        bbox: Bounding box coordinates (x1, y1, x2, y2)
+        track_id: Tracking ID
+        class_name: Class name
+        confidence: Detection confidence
+        color: Box color
+        thickness: Box thickness
+        show_id: Whether to show track ID
+        show_confidence: Whether to show confidence score
+    
+    Returns:
+        Frame with bounding box drawn
+    """
+    x1, y1, x2, y2 = bbox
+    
+    # Draw bounding box
+    cv2.rectangle(frame, (x1, y1), (x2, y2), color, thickness)
+    
+    # Prepare label text
+    label_parts = [class_name]
+    if show_id:
+        label_parts.append(f"ID:{track_id}")
+    if show_confidence:
+        label_parts.append(f"{confidence:.2f}")
+    
+    label = " | ".join(label_parts)
+    
+    # Calculate label size
+    (label_width, label_height), baseline = cv2.getTextSize(
+        label,
+        cv2.FONT_HERSHEY_SIMPLEX,
+        0.6,
+        2
+    )
+    
+    # Draw label background
+    cv2.rectangle(
+        frame,
+        (x1, y1 - label_height - baseline - 5),
+        (x1 + label_width + 5, y1),
+        color,
+        -1
+    )
+    
+    # Draw label text
+    cv2.putText(
+        frame,
+        label,
+        (x1 + 2, y1 - baseline - 2),
+        cv2.FONT_HERSHEY_SIMPLEX,
+        0.6,
+        (0, 0, 0),  # Black text
+        2
+    )
+    
+    # Draw center point
+    center_x, center_y = get_center_point(bbox)
+    cv2.circle(frame, (center_x, center_y), 4, color, -1)
+    
+    return frame
+
+
+def format_time(seconds: float) -> str:
+    """
+    Format elapsed time in seconds to HH:MM:SS format
+    
+    Args:
+        seconds: Time in seconds
+    
+    Returns:
+        Formatted time string
+    """
+    hours = int(seconds // 3600)
+    minutes = int((seconds % 3600) // 60)
+    secs = int(seconds % 60)
+    return f"{hours:02d}:{minutes:02d}:{secs:02d}"
+
+
+def get_counting_line_coords(
+    frame_width: int,
+    frame_height: int,
+    line_position: float = 0.5,
+    custom_coords: Tuple[int, int, int, int] = None,
+    orientation: str = "horizontal"
+) -> Tuple[int, int, int, int]:
+    """
+    Get counting line coordinates based on frame dimensions
+    
+    Args:
+        frame_width: Width of video frame
+        frame_height: Height of video frame
+        line_position: Position as percentage (0.0 to 1.0)
+        custom_coords: Custom line coordinates (overrides line_position)
+        orientation: "horizontal" or "vertical"
+    
+    Returns:
+        Line coordinates (x1, y1, x2, y2)
+    """
+    if custom_coords is not None:
+        return custom_coords
+    
+    if orientation == "vertical":
+        line_x = int(frame_width * line_position)
+        return (line_x, 0, line_x, frame_height)
+    else:
+        line_y = int(frame_height * line_position)
+        return (0, line_y, frame_width, line_y)

vehicle_tracker.py

@@ -0,0 +1,360 @@
+"""
+Real-Time Vehicle Tracking & Counting System using YOLO11
+Detects, tracks, and counts vehicles crossing a virtual line in video
+"""
+import cv2
+import argparse
+from pathlib import Path
+from ultralytics import YOLO
+import time
+from collections import defaultdict
+
+# Import configuration and utilities
+import config
+from utils import (
+    get_center_point,
+    check_line_crossing,
+    draw_counting_line,
+    draw_statistics,
+    draw_bounding_box,
+    get_counting_line_coords,
+    format_time
+)
+
+
+class VehicleTracker:
+    """Main class for vehicle tracking and counting"""
+    
+    def __init__(self, model_path: str = None, video_path: str = None):
+        """
+        Initialize the vehicle tracker
+        
+        Args:
+            model_path: Path to YOLO model (default from config)
+            video_path: Path to input video (default from config)
+        """
+        self.model_path = model_path or config.MODEL_NAME
+        self.video_path = video_path or config.VIDEO_INPUT
+        
+        # Initialize YOLO model
+        print(f"Loading YOLO model: {self.model_path}")
+        self.model = YOLO(self.model_path)
+        
+        # Set device
+        if config.USE_GPU:
+            print("GPU enabled (if available)")
+        
+        # Tracking data
+        self.vehicle_counts = defaultdict(int)
+        self.tracked_objects = {}  # Store previous positions
+        self.counted_ids = set()  # IDs that have been counted
+        
+        # Video properties
+        self.cap = None
+        self.out = None
+        self.frame_width = 0
+        self.frame_height = 0
+        self.fps = 0
+        self.total_frames = 0
+        
+        # Counting line coordinates
+        self.line_coords = None
+        
+    def initialize_video(self, output_path: str = None):
+        """
+        Initialize video capture and writer
+        
+        Args:
+            output_path: Path to save output video (default from config)
+        """
+        self.cap = cv2.VideoCapture(self.video_path)
+        
+        if not self.cap.isOpened():
+            raise ValueError(f"Error opening video file: {self.video_path}")
+        
+        # Get video properties
+        self.frame_width = int(self.cap.get(cv2.CAP_PROP_FRAME_WIDTH))
+        self.frame_height = int(self.cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
+        self.fps = int(self.cap.get(cv2.CAP_PROP_FPS))
+        self.total_frames = int(self.cap.get(cv2.CAP_PROP_FRAME_COUNT))
+        
+        print(f"\nVideo Properties:")
+        print(f"  Resolution: {self.frame_width}x{self.frame_height}")
+        print(f"  FPS: {self.fps}")
+        print(f"  Total Frames: {self.total_frames}")
+        
+        # Apply resize if configured
+        if config.RESIZE_WIDTH and config.RESIZE_HEIGHT:
+            self.frame_width = config.RESIZE_WIDTH
+            self.frame_height = config.RESIZE_HEIGHT
+            print(f"  Resizing to: {self.frame_width}x{self.frame_height}")
+        
+        # Set counting line coordinates
+        self.line_coords = get_counting_line_coords(
+            self.frame_width,
+            self.frame_height,
+            config.COUNTING_LINE_POSITION,
+            config.COUNTING_LINE_COORDS,
+            config.COUNTING_LINE_ORIENTATION
+        )
+        print(f"  Counting Line: {self.line_coords} ({config.COUNTING_LINE_ORIENTATION})\n")
+        
+        # Initialize video writer
+        output_path = output_path or config.VIDEO_OUTPUT
+        fourcc = cv2.VideoWriter_fourcc(*'mp4v')
+        self.out = cv2.VideoWriter(
+            output_path,
+            fourcc,
+            self.fps,
+            (self.frame_width, self.frame_height)
+        )
+        
+        print(f"Output will be saved to: {output_path}\n")
+    
+    def process_frame(self, frame):
+        """
+        Process a single frame: detect, track, and count vehicles
+        
+        Args:
+            frame: Input video frame
+        
+        Returns:
+            Processed frame with annotations
+        """
+        # Resize frame if configured
+        if config.RESIZE_WIDTH and config.RESIZE_HEIGHT:
+            frame = cv2.resize(frame, (self.frame_width, self.frame_height))
+        
+        # Run YOLO tracking
+        results = self.model.track(
+            frame,
+            persist=True,
+            conf=config.CONFIDENCE_THRESHOLD,
+            iou=config.IOU_THRESHOLD,
+            classes=list(config.VEHICLE_CLASSES.keys()),
+            verbose=False
+        )
+        
+        # Draw counting line
+        frame = draw_counting_line(
+            frame,
+            self.line_coords,
+            config.LINE_COLOR,
+            config.LINE_THICKNESS
+        )
+        
+        # Process detections
+        if results[0].boxes is not None and results[0].boxes.id is not None:
+            boxes = results[0].boxes.xyxy.cpu().numpy().astype(int)
+            track_ids = results[0].boxes.id.cpu().numpy().astype(int)
+            classes = results[0].boxes.cls.cpu().numpy().astype(int)
+            confidences = results[0].boxes.conf.cpu().numpy()
+            
+            for box, track_id, cls, conf in zip(boxes, track_ids, classes, confidences):
+                # Get class name
+                class_name = config.VEHICLE_CLASSES.get(cls, "unknown")
+                
+                # Get center point
+                center_x, center_y = get_center_point(box)
+                
+                # Determine coordinate to check based on orientation
+                curr_pos = center_x if config.COUNTING_LINE_ORIENTATION == "vertical" else center_y
+                line_pos = self.line_coords[0] if config.COUNTING_LINE_ORIENTATION == "vertical" else self.line_coords[1]
+                
+                # Check for line crossing
+                if track_id in self.tracked_objects:
+                    prev_pos = self.tracked_objects[track_id]['pos']
+                    
+                    # Check if crossed and not already counted
+                    if (track_id not in self.counted_ids and 
+                        check_line_crossing(curr_pos, prev_pos, line_pos)):
+                        
+                        self.vehicle_counts[class_name] += 1
+                        self.counted_ids.add(track_id)
+                        print(f"✓ Counted: {class_name.upper()} (ID: {track_id}) - Total: {sum(self.vehicle_counts.values())}")
+                
+                # Update tracked object position
+                self.tracked_objects[track_id] = {
+                    'pos': curr_pos,
+                    'class': class_name
+                }
+                
+                # Draw bounding box and label
+                color = config.COLORS.get(class_name, (255, 255, 255))
+                frame = draw_bounding_box(
+                    frame,
+                    box,
+                    track_id,
+                    class_name,
+                    conf,
+                    color,
+                    config.BOX_THICKNESS,
+                    config.SHOW_TRACK_ID,
+                    config.SHOW_CONFIDENCE
+                )
+        
+        # Draw statistics
+        frame = draw_statistics(
+            frame,
+            dict(self.vehicle_counts),
+            config.STATS_POSITION,
+            config.FONT_SCALE,
+            config.STATS_COLOR,
+            config.STATS_BG_COLOR
+        )
+        
+        return frame
+    
+    def run(self, output_path: str = None):
+        """
+        Run the vehicle tracking and counting system
+        
+        Args:
+            output_path: Path to save output video
+        """
+        try:
+            # Initialize video
+            self.initialize_video(output_path)
+            
+            print("Starting vehicle tracking and counting...")
+            print("Press 'q' to quit early\n")
+            
+            frame_count = 0
+            start_time = time.time()
+            
+            while True:
+                ret, frame = self.cap.read()
+                
+                if not ret:
+                    break
+                
+                frame_count += 1
+                
+                # Skip frames if configured
+                if config.SKIP_FRAMES > 0 and frame_count % (config.SKIP_FRAMES + 1) != 0:
+                    continue
+                
+                # Process frame
+                processed_frame = self.process_frame(frame)
+                
+                # Write to output video
+                self.out.write(processed_frame)
+                
+                # Display frame
+                if config.DISPLAY_WINDOW:
+                    cv2.imshow('Vehicle Tracking & Counting', processed_frame)
+                    
+                    if cv2.waitKey(1) & 0xFF == ord('q'):
+                        print("\nStopped by user")
+                        break
+                
+                # Print progress
+                if frame_count % 30 == 0:
+                    elapsed = time.time() - start_time
+                    fps = frame_count / elapsed
+                    progress = (frame_count / self.total_frames) * 100
+                    print(f"Progress: {progress:.1f}% | Frame: {frame_count}/{self.total_frames} | FPS: {fps:.1f}")
+            
+            # Final statistics
+            elapsed_time = time.time() - start_time
+            avg_fps = frame_count / elapsed_time
+            
+            print("\n" + "="*50)
+            print("PROCESSING COMPLETE")
+            print("="*50)
+            print(f"Frames Processed: {frame_count}")
+            print(f"Time Elapsed: {format_time(elapsed_time)}")
+            print(f"Average FPS: {avg_fps:.2f}")
+            print("\nVehicle Counts:")
+            print("-"*30)
+            
+            total = 0
+            for vehicle_class in sorted(self.vehicle_counts.keys()):
+                count = self.vehicle_counts[vehicle_class]
+                total += count
+                print(f"  {vehicle_class.upper()}: {count}")
+            
+            print("-"*30)
+            print(f"  TOTAL: {total}")
+            print("="*50)
+            
+        finally:
+            # Cleanup
+            if self.cap:
+                self.cap.release()
+            if self.out:
+                self.out.release()
+            if config.DISPLAY_WINDOW:
+                cv2.destroyAllWindows()
+
+
+def main():
+    """Main entry point with command-line argument parsing"""
+    parser = argparse.ArgumentParser(
+        description='Real-Time Vehicle Tracking & Counting System using YOLO11'
+    )
+    
+    parser.add_argument(
+        '--video',
+        type=str,
+        default=config.VIDEO_INPUT,
+        help='Path to input video file'
+    )
+    
+    parser.add_argument(
+        '--output',
+        type=str,
+        default=config.VIDEO_OUTPUT,
+        help='Path to save output video'
+    )
+    
+    parser.add_argument(
+        '--model',
+        type=str,
+        default=config.MODEL_NAME,
+        help='YOLO model to use (e.g., yolo11n.pt, yolo11m.pt)'
+    )
+    
+    parser.add_argument(
+        '--line-y',
+        type=int,
+        default=None,
+        help='Y coordinate for counting line (overrides config)'
+    )
+    
+    parser.add_argument(
+        '--no-display',
+        action='store_true',
+        help='Run without displaying video window (headless mode)'
+    )
+    
+    parser.add_argument(
+        '--conf',
+        type=float,
+        default=config.CONFIDENCE_THRESHOLD,
+        help='Confidence threshold for detection'
+    )
+    
+    args = parser.parse_args()
+    
+    # Override config with command-line arguments
+    if args.line_y:
+        config.COUNTING_LINE_COORDS = (0, args.line_y, 10000, args.line_y)
+    
+    if args.no_display:
+        config.DISPLAY_WINDOW = False
+    
+    if args.conf:
+        config.CONFIDENCE_THRESHOLD = args.conf
+    
+    # Create tracker and run
+    tracker = VehicleTracker(
+        model_path=args.model,
+        video_path=args.video
+    )
+    
+    tracker.run(output_path=args.output)
+
+
+if __name__ == "__main__":
+    main()

web_app.html

@@ -0,0 +1,523 @@
+<!DOCTYPE html>
+<html lang="en">
+
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>🚗 Vehicle Tracking - Web App</title>
+    <style>
+        * {
+            margin: 0;
+            padding: 0;
+            box-sizing: border-box;
+        }
+
+        body {
+            font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif;
+            background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+            min-height: 100vh;
+            padding: 20px;
+        }
+
+        .container {
+            max-width: 900px;
+            margin: 0 auto;
+            background: rgba(255, 255, 255, 0.98);
+            border-radius: 20px;
+            padding: 40px;
+            box-shadow: 0 20px 60px rgba(0, 0, 0, 0.3);
+        }
+
+        h1 {
+            text-align: center;
+            color: #333;
+            margin-bottom: 10px;
+            font-size: 2.5em;
+        }
+
+        .subtitle {
+            text-align: center;
+            color: #666;
+            margin-bottom: 40px;
+            font-size: 1.1em;
+        }
+
+        .drop-zone {
+            border: 3px dashed #667eea;
+            border-radius: 15px;
+            padding: 80px 40px;
+            text-align: center;
+            cursor: pointer;
+            transition: all 0.3s ease;
+            background: linear-gradient(135deg, rgba(102, 126, 234, 0.05) 0%, rgba(118, 75, 162, 0.05) 100%);
+            margin-bottom: 30px;
+        }
+
+        .drop-zone:hover {
+            border-color: #764ba2;
+            background: linear-gradient(135deg, rgba(102, 126, 234, 0.1) 0%, rgba(118, 75, 162, 0.1) 100%);
+            transform: translateY(-2px);
+        }
+
+        .drop-zone.dragover {
+            border-color: #4CAF50;
+            background: rgba(76, 175, 80, 0.1);
+            transform: scale(1.02);
+        }
+
+        .drop-zone.processing {
+            opacity: 0.5;
+            pointer-events: none;
+        }
+
+        .drop-zone-icon {
+            font-size: 5em;
+            margin-bottom: 20px;
+            animation: float 3s ease-in-out infinite;
+        }
+
+        @keyframes float {
+
+            0%,
+            100% {
+                transform: translateY(0px);
+            }
+
+            50% {
+                transform: translateY(-10px);
+            }
+        }
+
+        .drop-zone-text {
+            font-size: 1.5em;
+            color: #667eea;
+            font-weight: 600;
+            margin-bottom: 10px;
+        }
+
+        .drop-zone-subtext {
+            color: #999;
+            font-size: 1em;
+        }
+
+        .file-input {
+            display: none;
+        }
+
+        .file-info {
+            display: none;
+            background: #f8f9fa;
+            padding: 20px;
+            border-radius: 10px;
+            margin-bottom: 20px;
+            border-left: 4px solid #667eea;
+        }
+
+        .file-info.show {
+            display: block;
+            animation: slideIn 0.3s ease;
+        }
+
+        @keyframes slideIn {
+            from {
+                opacity: 0;
+                transform: translateY(-10px);
+            }
+
+            to {
+                opacity: 1;
+                transform: translateY(0);
+            }
+        }
+
+        .file-name {
+            font-weight: 600;
+            color: #333;
+            margin-bottom: 8px;
+            font-size: 1.1em;
+        }
+
+        .file-size {
+            color: #666;
+            font-size: 0.95em;
+        }
+
+        .progress-container {
+            display: none;
+            margin: 30px 0;
+        }
+
+        .progress-container.show {
+            display: block;
+        }
+
+        .progress-bar {
+            width: 100%;
+            height: 40px;
+            background: #e9ecef;
+            border-radius: 20px;
+            overflow: hidden;
+            margin-bottom: 15px;
+            box-shadow: inset 0 2px 4px rgba(0, 0, 0, 0.1);
+        }
+
+        .progress-fill {
+            height: 100%;
+            background: linear-gradient(90deg, #667eea 0%, #764ba2 100%);
+            width: 0%;
+            transition: width 0.5s ease;
+            display: flex;
+            align-items: center;
+            justify-content: center;
+            color: white;
+            font-weight: 600;
+            font-size: 1.1em;
+        }
+
+        .status-text {
+            text-align: center;
+            color: #666;
+            font-size: 1.05em;
+            font-weight: 500;
+        }
+
+        .results {
+            display: none;
+            background: linear-gradient(135deg, #d4edda 0%, #c3e6cb 100%);
+            border-left: 4px solid #28a745;
+            padding: 25px;
+            border-radius: 10px;
+            margin-top: 20px;
+        }
+
+        .results.show {
+            display: block;
+            animation: slideIn 0.3s ease;
+        }
+
+        .results h3 {
+            color: #155724;
+            margin-bottom: 15px;
+            font-size: 1.3em;
+        }
+
+        .results p {
+            color: #155724;
+            margin-bottom: 15px;
+            line-height: 1.6;
+        }
+
+        .btn {
+            padding: 15px 30px;
+            border: none;
+            border-radius: 10px;
+            font-size: 1.1em;
+            font-weight: 600;
+            cursor: pointer;
+            transition: all 0.3s ease;
+            text-decoration: none;
+            display: inline-block;
+        }
+
+        .btn-download {
+            background: linear-gradient(135deg, #28a745 0%, #20c997 100%);
+            color: white;
+        }
+
+        .btn-download:hover {
+            transform: translateY(-2px);
+            box-shadow: 0 10px 25px rgba(40, 167, 69, 0.4);
+        }
+
+        .btn-new {
+            background: #f8f9fa;
+            color: #667eea;
+            border: 2px solid #667eea;
+            margin-left: 10px;
+        }
+
+        .btn-new:hover {
+            background: #667eea;
+            color: white;
+        }
+
+        .error {
+            display: none;
+            background: linear-gradient(135deg, #f8d7da 0%, #f5c6cb 100%);
+            border-left: 4px solid #dc3545;
+            padding: 20px;
+            border-radius: 10px;
+            margin-top: 20px;
+            color: #721c24;
+        }
+
+        .error.show {
+            display: block;
+            animation: slideIn 0.3s ease;
+        }
+
+        .spinner {
+            display: inline-block;
+            width: 20px;
+            height: 20px;
+            border: 3px solid rgba(255, 255, 255, .3);
+            border-radius: 50%;
+            border-top-color: #fff;
+            animation: spin 1s ease-in-out infinite;
+        }
+
+        @keyframes spin {
+            to {
+                transform: rotate(360deg);
+            }
+        }
+
+        .features {
+            display: grid;
+            grid-template-columns: repeat(auto-fit, minmax(200px, 1fr));
+            gap: 20px;
+            margin-top: 30px;
+        }
+
+        .feature {
+            text-align: center;
+            padding: 20px;
+            background: #f8f9fa;
+            border-radius: 10px;
+        }
+
+        .feature-icon {
+            font-size: 2.5em;
+            margin-bottom: 10px;
+        }
+
+        .feature-text {
+            color: #666;
+            font-size: 0.95em;
+        }
+    </style>
+</head>
+
+<body>
+    <div class="container">
+        <h1>🚗 Vehicle Tracking System</h1>
+        <p class="subtitle">Upload your traffic video and get AI-powered vehicle tracking</p>
+
+        <div class="drop-zone" id="dropZone">
+            <div class="drop-zone-icon">🎥</div>
+            <div class="drop-zone-text">Drop your video here</div>
+            <div class="drop-zone-subtext">or click to browse (MP4, AVI, MOV, MKV)</div>
+        </div>
+
+        <input type="file" id="fileInput" class="file-input" accept="video/*">
+
+        <div class="file-info" id="fileInfo">
+            <div class="file-name" id="fileName"></div>
+            <div class="file-size" id="fileSize"></div>
+        </div>
+
+        <div class="progress-container" id="progressContainer">
+            <div class="progress-bar">
+                <div class="progress-fill" id="progressFill">
+                    <span id="progressText">0%</span>
+                </div>
+            </div>
+            <div class="status-text" id="statusText">
+                <span class="spinner"></span> Processing...
+            </div>
+        </div>
+
+        <div class="results" id="results">
+            <h3>✅ Processing Complete!</h3>
+            <p id="resultsText"></p>
+            <a href="#" id="downloadBtn" class="btn btn-download">📥 Download Tracked Video</a>
+            <button class="btn btn-new" onclick="location.reload()">🔄 Process Another Video</button>
+        </div>
+
+        <div class="error" id="error">
+            <strong>❌ Error:</strong> <span id="errorText"></span>
+        </div>
+
+        <div class="features">
+            <div class="feature">
+                <div class="feature-icon">🎯</div>
+                <div class="feature-text">Detects Cars, Trucks, Buses & Motorcycles</div>
+            </div>
+            <div class="feature">
+                <div class="feature-icon">🔢</div>
+                <div class="feature-text">Tracks with Unique IDs</div>
+            </div>
+            <div class="feature">
+                <div class="feature-icon">📊</div>
+                <div class="feature-text">Counts Vehicles Automatically</div>
+            </div>
+            <div class="feature">
+                <div class="feature-icon">⚡</div>
+                <div class="feature-text">Powered by YOLO11 AI</div>
+            </div>
+        </div>
+    </div>
+
+    <script>
+        const dropZone = document.getElementById('dropZone');
+        const fileInput = document.getElementById('fileInput');
+        const fileInfo = document.getElementById('fileInfo');
+        const fileName = document.getElementById('fileName');
+        const fileSize = document.getElementById('fileSize');
+        const progressContainer = document.getElementById('progressContainer');
+        const progressFill = document.getElementById('progressFill');
+        const progressText = document.getElementById('progressText');
+        const statusText = document.getElementById('statusText');
+        const results = document.getElementById('results');
+        const resultsText = document.getElementById('resultsText');
+        const downloadBtn = document.getElementById('downloadBtn');
+        const error = document.getElementById('error');
+        const errorText = document.getElementById('errorText');
+
+        let selectedFile = null;
+        let statusCheckInterval = null;
+
+        // Click to browse
+        dropZone.addEventListener('click', () => {
+            if (!dropZone.classList.contains('processing')) {
+                fileInput.click();
+            }
+        });
+
+        // Drag and drop events
+        dropZone.addEventListener('dragover', (e) => {
+            e.preventDefault();
+            if (!dropZone.classList.contains('processing')) {
+                dropZone.classList.add('dragover');
+            }
+        });
+
+        dropZone.addEventListener('dragleave', () => {
+            dropZone.classList.remove('dragover');
+        });
+
+        dropZone.addEventListener('drop', (e) => {
+            e.preventDefault();
+            dropZone.classList.remove('dragover');
+
+            if (!dropZone.classList.contains('processing')) {
+                const files = e.dataTransfer.files;
+                if (files.length > 0) {
+                    handleFile(files[0]);
+                }
+            }
+        });
+
+        // File input change
+        fileInput.addEventListener('change', (e) => {
+            if (e.target.files.length > 0) {
+                handleFile(e.target.files[0]);
+            }
+        });
+
+        function handleFile(file) {
+            // Check if it's a video file
+            if (!file.type.startsWith('video/')) {
+                showError('Please select a video file');
+                return;
+            }
+
+            selectedFile = file;
+
+            // Display file info
+            fileName.textContent = `📁 ${file.name}`;
+            const sizeMB = (file.size / (1024 * 1024)).toFixed(2);
+            fileSize.textContent = `Size: ${sizeMB} MB`;
+
+            fileInfo.classList.add('show');
+
+            // Hide previous results/errors
+            results.classList.remove('show');
+            error.classList.remove('show');
+
+            // Auto-upload and process
+            uploadAndProcess();
+        }
+
+        async function uploadAndProcess() {
+            if (!selectedFile) return;
+
+            // Show progress
+            dropZone.classList.add('processing');
+            progressContainer.classList.add('show');
+            updateProgress(0, 'Uploading video...');
+
+            const formData = new FormData();
+            formData.append('video', selectedFile);
+
+            try {
+                // Upload file
+                const response = await fetch('/upload', {
+                    method: 'POST',
+                    body: formData
+                });
+
+                const data = await response.json();
+
+                if (response.ok) {
+                    // Start checking status
+                    checkStatus();
+                } else {
+                    showError(data.error || 'Upload failed');
+                    dropZone.classList.remove('processing');
+                }
+            } catch (err) {
+                showError('Network error: ' + err.message);
+                dropZone.classList.remove('processing');
+            }
+        }
+
+        function checkStatus() {
+            statusCheckInterval = setInterval(async () => {
+                try {
+                    const response = await fetch('/status');
+                    const status = await response.json();
+
+                    updateProgress(status.progress, status.message);
+
+                    if (status.status === 'complete') {
+                        clearInterval(statusCheckInterval);
+                        showResults(status.output_file);
+                    } else if (status.status === 'error') {
+                        clearInterval(statusCheckInterval);
+                        showError(status.message);
+                        dropZone.classList.remove('processing');
+                    }
+                } catch (err) {
+                    console.error('Status check error:', err);
+                }
+            }, 1000);
+        }
+
+        function updateProgress(percent, message) {
+            progressFill.style.width = percent + '%';
+            progressText.textContent = percent + '%';
+            statusText.innerHTML = `<span class="spinner"></span> ${message}`;
+        }
+
+        function showResults(outputFile) {
+            dropZone.classList.remove('processing');
+            progressContainer.classList.remove('show');
+
+            resultsText.textContent = 'Your video has been processed successfully! The tracked video includes bounding boxes, vehicle IDs, and counting statistics.';
+            downloadBtn.href = `/download/${outputFile}`;
+            results.classList.add('show');
+        }
+
+        function showError(message) {
+            errorText.textContent = message;
+            error.classList.add('show');
+            progressContainer.classList.remove('show');
+            setTimeout(() => {
+                error.classList.remove('show');
+            }, 8000);
+        }
+    </script>
+</body>
+
+</html>

yolo11n.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:0ebbc80d4a7680d14987a577cd21342b65ecfd94632bd9a8da63ae6417644ee1
+size 5613764

yolo11x.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:7bc158aa95c0ebfdd87f70f01653c1131b93e92522dbe15c228bcd742e773a24
+size 114636239