Fix requirements.txt encoding for HF

Dockerfile

@@ -0,0 +1,35 @@
+FROM python:3.11-slim
+
+# Create user with UID 1000 - Hugging Face requires this specific setup
+RUN useradd -m -u 1000 user
+
+# Install system dependencies needed for OpenCV
+RUN apt-get update && apt-get install -y \
+    libgl1 \
+    libglib2.0-0 \
+    libsm6 \
+    libxext6 \
+    libxrender-dev \
+    && rm -rf /var/lib/apt/lists/*
+
+# Switch to the non-root user
+USER user
+ENV HOME=/home/user \
+    PATH=/home/user/.local/bin:$PATH
+
+# Set the working directory
+WORKDIR $HOME/app
+
+# Copy dependencies first (for Docker caching)
+COPY --chown=user requirements.txt .
+RUN pip install --no-cache-dir torch==2.5.1 torchvision==0.20.1 --index-url https://download.pytorch.org/whl/cpu && pip install --no-cache-dir -r requirements.txt
+
+# Copy the rest of the application
+COPY --chown=user . $HOME/app
+
+# Hugging Face exposes exactly port 7860
+ENV PORT=7860
+EXPOSE 7860
+
+# Run the Flask App
+CMD ["python", "app.py"]

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Ali Abdullah
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

Procfile

@@ -0,0 +1 @@
+web: python app.py

README.md

@@ -0,0 +1,124 @@
+---
+title: Smart Crowd Detector
+emoji: 🏃
+colorFrom: blue
+colorTo: green
+sdk: docker
+pinned: false
+app_port: 7860
+---
+
+# Smart Crowd Detector
+
+![Python](https://img.shields.io/badge/python-3.10+-blue.svg)
+![CUDA](https://img.shields.io/badge/CUDA-12.0+-green.svg)
+![License](https://img.shields.io/badge/license-MIT-blue.svg)
+
+An AI-powered real-time crowd detection and monitoring system using YOLOv8 with an adaptive heatmap visualization. Built for safety, efficiency, and smart crowd management.
+
+## 🎯 Features
+
+- **Real-time People Detection** - GPU-accelerated YOLOv8 model with TensorRT, OpenCV, and PyTorch.
+- **Dynamic Detection Modes** - Switch dynamically depending on your environment:
+  - 🟢 **Stadium Mode**: High density optimization (500 max detections, low confidence/IOU thresholds) perfectly tailored for massive crowds and distant individuals.
+  - 👥 **Normal Mode**: Balanced accuracy and framing for standard environments (offices, retail).
+  - ⚡ **Fast Mode**: Maximum framerate via skipped frames and lower resolutions for basic needs on lower-end hardware.
+- **Adaptive Heatmaps** - Smart kernel sizing based on object distance to represent crowd density accurate to visual depth.
+- **Dual Source Input** - Works seamlessly with an active webcam or video files with continuous looping playback support.
+- **Alert System** - Highly configurable warning/critical crowd density thresholds.
+- **High Performance** - Thread-safe state caching, frame deferring, GPU pipeline offloading, and optimized resolutions delivering 30-35 FPS on fast mode or extreme accuracy insights for dense stadium applications.
+- **Modern Dashboard** - Clean F1-themed interface built on vanilla JS and standard web sockets.
+
+## 📋 Requirements
+
+- **GPU**: CUDA-capable NVIDIA GPU (RTX 3050+) is heavily recommended for Stadium mode.
+- **RAM**: 8GB minimum, 16GB recommended.
+- **Software**: Python 3.10+, CUDA 12.0+
+
+## 🚀 Installation & Local Setup
+
+```bash
+# 1. Clone the Repository
+git clone https://github.com/nowayitsme-eng/Smart_Crowd_Detector.git
+cd Smart_Crowd_Detector
+
+# 2. Create and Activate Virtual Environment
+python -m venv venv
+# On Windows:
+venv\Scripts\activate
+# On Linux/macOS:
+source venv/bin/activate
+
+# 3. Install Dependencies
+pip install -r requirements.txt
+
+# 4. Run the application
+python app.py
+```
+*Access the dashboard at `http://localhost:5000`*
+
+## 🐳 Docker & Cloud Deployment
+
+⚠️ **Note on Serverless (e.g. Vercel)**: Standard serverless does not support this application. Real-time video processing requires persistent connections, background sockets, and large ML sizes which bypass standard serverless constraints. Use Docker or standard scalable containers.
+
+### Docker (Recommended for AWS, GCP, Azure, DigitalOcean)
+
+Create a `Dockerfile` with the following:
+```dockerfile
+FROM python:3.11-slim
+RUN apt-get update && apt-get install -y libgl1-mesa-glx libglib2.0-0 libsm6 libxext6 libxrender-dev && rm -rf /var/lib/apt/lists/*
+WORKDIR /app
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+COPY . .
+EXPOSE 5000
+CMD ["python", "app.py"]
+```
+Build and run:
+```bash
+docker build -t app-monitor .
+docker run -p 5000:5000 --device=/dev/video0 app-monitor
+```
+
+### Render.com / Railway.app
+- Connect your GitHub Repository natively.
+- **Railway**: Instantly supported utilizing persistent Docker builds.
+- **Render**: Use a standard Web Service provider. Build command: `pip install -r requirements.txt`. Start command: `python app.py`.
+
+### Heroku
+Use Heroku buildpacks if not building via container setup:
+```bash
+heroku create smart-crowd-monitor
+heroku buildpacks:add --index 1 heroku-community/apt
+heroku buildpacks:add --index 2 heroku/python
+git push heroku main
+```
+
+## ⚙️ Configuration
+
+Tweak main properties centrally in `config.yaml`:
+```yaml
+video:
+  source: 0  # Camera index or path/to/video.mp4
+  fps: 30
+  resolution:
+    width: 640
+    height: 480
+
+model:
+  confidence_threshold: 0.35
+  device: "cuda"  # switch to "cpu" if no GPU available
+
+crowd:
+  density_threshold: 20
+  warning_threshold: 35
+```
+
+## 📄 License & Credits
+
+MIT License
+
+**Author:** Ali Abdullah - [GitHub: nowayitsme-eng](https://github.com/nowayitsme-eng)  
+**Acknowledgments:** YOLOv8 by Ultralytics, OpenCV, Flask Framework
+
+

app.py

@@ -0,0 +1,707 @@
+"""
+Zaytrics Smart Crowd Monitoring System - Web Server
+Optimized for small object detection and better performance
+"""
+
+print("[*] Starting Zaytrics...")
+
+# GPU Verification - Check CUDA availability
+print("[*] Checking GPU...")
+import torch
+if torch.cuda.is_available():
+    gpu_name = torch.cuda.get_device_name(0)
+    gpu_memory = torch.cuda.get_device_properties(0).total_memory / 1024**3
+    print(f"[OK] GPU Detected: {gpu_name} ({gpu_memory:.1f} GB VRAM)")
+    print(f"     CUDA Version: {torch.version.cuda}")
+    # Set CUDA optimizations
+    torch.backends.cudnn.benchmark = True  # Auto-tune for best performance
+    torch.backends.cuda.matmul.allow_tf32 = True  # Allow TF32 for faster matmul
+else:
+    print("[WARN] WARNING: CUDA not available, using CPU (slower)")
+
+print("[*] Loading Flask...")
+from flask import Flask, render_template, Response, jsonify, request, send_from_directory
+from flask_cors import CORS
+from werkzeug.utils import secure_filename
+print("[OK] Flask loaded")
+
+print("[*] Loading OpenCV...")
+import cv2
+import numpy as np
+print("[OK] OpenCV loaded")
+
+import os
+import json
+import time
+import logging
+from datetime import datetime
+from threading import Thread, Lock
+from queue import Queue
+from collections import deque
+
+print("[*] Loading detection modules...")
+from src.detection.detector import CrowdDetector
+print("[OK] Detector loaded")
+
+from src.heatmap.generator import HeatmapGenerator
+print("[OK] Heatmap loaded")
+
+from src.video.handler import VideoHandler
+print("[OK] Video handler loaded")
+
+from src.utils.config import load_config
+from src.utils.logger import setup_logger
+print("[OK] All modules loaded")
+
+# Initialize Flask app
+app = Flask(__name__, static_folder='static', template_folder='templates')
+CORS(app)
+app.config['SEND_FILE_MAX_AGE_DEFAULT'] = 0  # Disable caching for development
+app.config['MAX_CONTENT_LENGTH'] = 100 * 1024 * 1024  # 100MB max file size
+app.config['UPLOAD_FOLDER'] = 'videos'
+ALLOWED_EXTENSIONS = {'mp4', 'avi', 'mov', 'mkv', 'webm'}
+
+# Add CORS and security headers
+@app.after_request
+def add_security_headers(response):
+    """Add security headers to all responses"""
+    response.headers['X-Content-Type-Options'] = 'nosniff'
+    response.headers['X-Frame-Options'] = 'SAMEORIGIN'
+    response.headers['X-XSS-Protection'] = '1; mode=block'
+    # Allow same-origin requests only
+    if 'Origin' in request.headers:
+        origin = request.headers['Origin']
+        # Only allow localhost origins for security
+        if 'localhost' in origin or '127.0.0.1' in origin or origin.startswith('http://10.'):
+            response.headers['Access-Control-Allow-Origin'] = origin
+            response.headers['Access-Control-Allow-Methods'] = 'GET, POST, OPTIONS'
+            response.headers['Access-Control-Allow-Headers'] = 'Content-Type'
+    return response
+
+# Ensure upload directory exists
+os.makedirs(app.config['UPLOAD_FOLDER'], exist_ok=True)
+
+# Load configuration
+config = load_config('config.yaml')
+logger = setup_logger(config)
+
+# Initialize components with optimized parameters for small objects
+detector = CrowdDetector(config)
+heatmap_generator = HeatmapGenerator(config)
+video_handler = VideoHandler(config)
+
+# Thread-safe state management
+state_lock = Lock()
+
+def allowed_file(filename):
+    """Check if file extension is allowed"""
+    return '.' in filename and filename.rsplit('.', 1)[1].lower() in ALLOWED_EXTENSIONS
+
+# Check for existing video files and set default source
+def get_latest_video():
+    """Get the most recent uploaded video file"""
+    try:
+        videos_dir = 'videos'
+        if os.path.exists(videos_dir):
+            videos = [f for f in os.listdir(videos_dir) if allowed_file(f)]
+            if videos:
+                videos.sort(reverse=True)  # Sort by timestamp (filename starts with timestamp)
+                return videos[0]
+    except Exception as e:
+        print(f"Error getting latest video: {e}")
+    return None
+
+latest_video = get_latest_video()
+default_source = 'video' if latest_video else 'camera'
+
+state = {
+    'running': False,
+    'heatmap_enabled': False,
+    'total_detections': 0,
+    'count_history': [],
+    'time_history': [],
+    'current_count': 0,
+    'fps': 0,
+    'alert_level': 'normal',
+    'statistics': {},
+    'last_detection_time': 0,
+    'detection_cache': [],
+    'frame_cache': None,
+    'source_type': default_source,  # 'camera' or 'video'
+    'video_file': latest_video,
+    'video_loop': True  # Loop videos by default
+}
+
+print(f"Default source: {default_source}, Video file: {latest_video}")
+
+# Use deque for frame times
+frame_times = deque(maxlen=100)  # Keep last 100 frames
+
+# Detection Mode System - Toggle between Normal and Dense Crowd modes
+DETECTION_MODES = {
+    'normal': {  # Current working baseline - DO NOT MODIFY
+        'interval': 3,
+        'confidence': 0.35,
+        'iou': 0.45,
+        'resize': 1.0,
+        'min_size': 20,
+        'multi_scale': False,
+        'max_det': 300,
+        'imgsz': 416,
+        'second_pass_conf': 0.05,
+        'duplicate_threshold': 30,
+        'min_box_size': 5
+    },
+    'dense': {  # Aggressive mode for dense crowds (stadiums, concerts)
+        'interval': 2,  # Process every 2nd frame (faster than normal)
+        'confidence': 0.25,  # Lower confidence to catch more people
+        'iou': 0.35,  # Lower IOU to allow more overlap
+        'resize': 1.0,  # Full resolution
+        'min_size': 15,  # Smaller minimum size
+        'multi_scale': False,  # Keep same as normal for compatibility
+        'max_det': 500,  # Allow more detections
+        'imgsz': 416,  # MUST match TensorRT engine size
+        'second_pass_conf': 0.02,  # Much lower for second pass
+        'duplicate_threshold': 25,  # Slightly tighter duplicate threshold
+        'min_box_size': 3  # Accept smaller boxes
+    }
+}
+
+# Start in normal mode (current working baseline)
+CURRENT_MODE = 'normal'
+active_mode = DETECTION_MODES[CURRENT_MODE]
+
+# Detection parameters from config
+DETECTION_INTERVAL = active_mode['interval']
+MIN_CONFIDENCE = active_mode['confidence']
+RESIZE_FACTOR = active_mode['resize']
+MIN_OBJECT_SIZE = active_mode['min_size']
+ENABLE_MULTI_SCALE = active_mode['multi_scale']
+
+# Alert thresholds from config
+WARNING_THRESHOLD = config.get('crowd', {}).get('density_threshold', 15)
+CRITICAL_THRESHOLD = config.get('crowd', {}).get('warning_threshold', 25)
+
+
+def update_state(key, value):
+    """Thread-safe state update"""
+    with state_lock:
+        state[key] = value
+
+
+def get_alert_level(count):
+    """Determine alert level based on count (REQ-7)"""
+    if count >= config['crowd']['warning_threshold']:
+        return 'critical'
+    elif count >= config['crowd']['density_threshold']:
+        return 'warning'
+    else:
+        return 'normal'
+
+
+def generate_frames():
+    """Generate video frames with detections - supports both camera and video file"""
+    global state
+    
+    logger.info("generate_frames() called")
+    
+    # Wait for running state to be true
+    max_wait = 50  # 5 seconds max
+    wait_count = 0
+    while not state.get('running', False) and wait_count < max_wait:
+        time.sleep(0.1)
+        wait_count += 1
+    
+    if not state.get('running', False):
+        logger.error("Monitoring not started, exiting generate_frames")
+        return
+    
+    # Determine video source based on state
+    with state_lock:
+        source_type = state['source_type']
+        video_file = state['video_file']
+    
+    logger.info(f"Source type: {source_type}, Video file: {video_file}")
+    logger.info(f"Will use: {'VIDEO FILE' if (source_type == 'video' and video_file) else 'CAMERA'}")
+    
+    if source_type == 'video' and video_file:
+        logger.info(f"Opening video file: {video_file}")
+        video_path = os.path.join(app.config['UPLOAD_FOLDER'], video_file)
+        if not os.path.exists(video_path):
+            logger.error(f"Video file not found: {video_path}")
+            # Generate error frame
+            error_frame = np.zeros((480, 640, 3), dtype=np.uint8)
+            cv2.putText(error_frame, "Video File Not Found", (150, 240), 
+                       cv2.FONT_HERSHEY_SIMPLEX, 1, (0, 0, 255), 2)
+            ret, buffer = cv2.imencode('.jpg', error_frame, [int(cv2.IMWRITE_JPEG_QUALITY), 60])
+            if ret:
+                yield (b'--frame\r\n'
+                       b'Content-Type: image/jpeg\r\n\r\n' + buffer.tobytes() + b'\r\n')
+            return
+        # Set video source properly
+        video_handler.set_source(video_path, is_camera=False)
+        logger.info(f"Set video source to: {video_path}")
+    else:
+        logger.info("Opening camera source")
+        # Set camera source properly - read from config
+        camera_index = config.get('video', {}).get('source', 0)
+        video_handler.set_source(camera_index, is_camera=True)
+        logger.info(f"Set camera source to: {camera_index}")
+    
+    # Try to open video source with retry logic
+    max_retries = 3
+    retry_count = 0
+    while retry_count < max_retries:
+        if video_handler.open():
+            break
+        retry_count += 1
+        logger.warning(f"Failed to open video source, retry {retry_count}/{max_retries}")
+        time.sleep(1)
+    
+    if retry_count >= max_retries:
+        logger.error("Failed to open video source after retries")
+        # Generate error frame
+        error_frame = np.zeros((480, 640, 3), dtype=np.uint8)
+        cv2.putText(error_frame, "Camera Not Available", (150, 240), 
+                   cv2.FONT_HERSHEY_SIMPLEX, 1, (0, 0, 255), 2)
+        ret, buffer = cv2.imencode('.jpg', error_frame, [int(cv2.IMWRITE_JPEG_QUALITY), 60])
+        if ret:
+            yield (b'--frame\r\n'
+                   b'Content-Type: image/jpeg\r\n\r\n' + buffer.tobytes() + b'\r\n')
+        return
+    
+    logger.info("Video source opened successfully")
+    frame_count = 0
+    start_time = time.time()
+    
+    # Caching for frame skipping
+    last_detections = []
+    last_count = 0
+    last_annotated_frame = None  # Initialize to prevent NameError
+    consecutive_failures = 0
+    max_consecutive_failures = 10
+    
+    try:
+        while state['running']:
+            ret, frame = video_handler.read_frame()
+            
+            if not ret:
+                # Handle video loop on read failure
+                if state['source_type'] == 'video' and state['video_loop']:
+                    logger.info("Video ended, restarting loop...")
+                    if video_handler.restart():
+                        frame_count = 0
+                        start_time = time.time()
+                        consecutive_failures = 0
+                        logger.info("Video loop restarted successfully")
+                        continue
+                
+                # For non-looping videos or cameras, count failures
+                consecutive_failures += 1
+                logger.warning(f"Failed to read frame (attempt {consecutive_failures}/{max_consecutive_failures})")
+                
+                if consecutive_failures >= max_consecutive_failures:
+                    logger.error("Too many consecutive frame read failures")
+                    break
+                
+                time.sleep(0.1)
+                continue
+            
+            consecutive_failures = 0  # Reset on successful read
+            
+            # Apply resize factor if configured (performance optimization)
+            if RESIZE_FACTOR < 1.0:
+                new_width = int(frame.shape[1] * RESIZE_FACTOR)
+                new_height = int(frame.shape[0] * RESIZE_FACTOR)
+                frame = cv2.resize(frame, (new_width, new_height), interpolation=cv2.INTER_LINEAR)
+            
+            frame_count += 1
+            
+            # Run detection based on configured interval (GPU-optimized)
+            # Run on frames 0, DETECTION_INTERVAL, DETECTION_INTERVAL*2, etc.
+            should_detect = (frame_count - 1) % DETECTION_INTERVAL == 0
+            if should_detect:
+                detections, count, detection_time = detector.detect(frame)
+                last_detections = detections
+                last_count = count
+                
+                # Choose display mode: heatmap-only OR bounding boxes
+                if state['heatmap_enabled']:
+                    # Heatmap mode: Skip bounding boxes for cleaner visualization
+                    frame_display, heatmap_time = heatmap_generator.generate_heatmap(
+                        frame, detections  # Generator copies internally
+                    )
+                else:
+                    # Normal mode: Draw bounding boxes (copies frame internally)
+                    frame_display = detector.draw_detections(frame, detections)
+                
+                # Cache the annotated frame for reuse (no copy needed, frame_display is already a copy)
+                last_annotated_frame = frame_display
+            else:
+                # Reuse cached annotated frame instead of re-drawing (MAJOR OPTIMIZATION)
+                detections = last_detections
+                count = last_count
+                if last_annotated_frame is not None:
+                    frame_display = last_annotated_frame
+                else:
+                    frame_display = detector.draw_detections(frame, detections)
+            
+            # Update state with proper locking to prevent race conditions
+            with state_lock:
+                state['current_count'] = count
+                # Only track current frame count, not accumulating total (prevents infinite growth)
+                state['last_detection_time'] = time.time()
+                
+                # Update alert level based on configurable thresholds
+                if count >= CRITICAL_THRESHOLD:
+                    state['alert_level'] = 'critical'
+                elif count >= WARNING_THRESHOLD:
+                    state['alert_level'] = 'warning'
+                else:
+                    state['alert_level'] = 'normal'
+            
+            # Debug log for detection count (reduced logging frequency)
+            if count > 0 and frame_count % 30 == 0:  # Log every 30 frames instead of every frame
+                logger.debug(f"Detected {count} people in frame {frame_count}")
+            
+            # Calculate FPS using deque for memory efficiency
+            current_time = time.time()
+            frame_times.append(current_time)
+            if len(frame_times) >= 2:
+                elapsed = frame_times[-1] - frame_times[0]
+                # Update FPS with state lock
+                with state_lock:
+                    state['fps'] = len(frame_times) / elapsed if elapsed > 0 else 0
+            
+            # Encode frame to JPEG with good quality (80% - improved quality)
+            ret, buffer = cv2.imencode('.jpg', frame_display, [int(cv2.IMWRITE_JPEG_QUALITY), 80])
+            
+            if ret:
+                yield (b'--frame\r\n'
+                       b'Content-Type: image/jpeg\r\n\r\n' + buffer.tobytes() + b'\r\n')
+    
+    except Exception as e:
+        logger.error(f"Error in generate_frames: {e}", exc_info=True)
+        # Generate error frame
+        error_frame = np.zeros((480, 640, 3), dtype=np.uint8)
+        cv2.putText(error_frame, "Processing Error", (180, 220), 
+                   cv2.FONT_HERSHEY_SIMPLEX, 1, (0, 0, 255), 2)
+        cv2.putText(error_frame, "Check logs for details", (150, 260), 
+                   cv2.FONT_HERSHEY_SIMPLEX, 0.6, (255, 255, 255), 1)
+        ret, buffer = cv2.imencode('.jpg', error_frame, [int(cv2.IMWRITE_JPEG_QUALITY), 60])
+        if ret:
+            yield (b'--frame\r\n'
+                   b'Content-Type: image/jpeg\r\n\r\n' + buffer.tobytes() + b'\r\n')
+    finally:
+        video_handler.release()
+        logger.info("Video handler released")
+        # Clear frame times on exit
+        frame_times.clear()
+
+
+@app.route('/')
+def index():
+    """Render main page"""
+    return render_template('index.html')
+
+
+@app.route('/video_feed')
+def video_feed():
+    """Video streaming route with optimized buffering"""
+    return Response(generate_frames(),
+                    mimetype='multipart/x-mixed-replace; boundary=frame',
+                    headers={
+                        'Cache-Control': 'no-cache, no-store, must-revalidate',
+                        'Pragma': 'no-cache',
+                        'Expires': '0'
+                    })
+
+
+@app.route('/api/start', methods=['POST'])
+def start_monitoring():
+    """Start monitoring (REQ-6)"""
+    update_state('running', True)
+    logger.info("Monitoring started")
+    return jsonify({'status': 'started'})
+
+
+@app.route('/api/stop', methods=['POST'])
+def stop_monitoring():
+    """Stop monitoring"""
+    update_state('running', False)
+    logger.info("Monitoring stopped")
+    return jsonify({'status': 'stopped'})
+
+
+@app.route('/api/upload_video', methods=['POST'])
+def upload_video():
+    """Upload a video file for processing with enhanced validation"""
+    try:
+        if 'file' not in request.files:
+            return jsonify({'error': 'No file provided'}), 400
+        
+        file = request.files['file']
+        if file.filename == '':
+            return jsonify({'error': 'No file selected'}), 400
+        
+        # Validate file extension
+        if not allowed_file(file.filename):
+            return jsonify({'error': 'Invalid file type. Allowed: mp4, avi, mov, mkv, webm'}), 400
+        
+        # Additional security: Check file size before saving
+        file.seek(0, 2)  # Seek to end
+        file_size = file.tell()
+        file.seek(0)  # Reset to beginning
+        
+        if file_size > app.config['MAX_CONTENT_LENGTH']:
+            return jsonify({'error': f'File too large. Maximum size is 100MB'}), 400
+        
+        if file_size == 0:
+            return jsonify({'error': 'File is empty'}), 400
+        
+        # Save the file with secure filename
+        filename = secure_filename(file.filename)
+        timestamp = datetime.now().strftime('%Y%m%d_%H%M%S')
+        filename = f"{timestamp}_{filename}"
+        filepath = os.path.join(app.config['UPLOAD_FOLDER'], filename)
+        
+        file.save(filepath)
+        
+        # Validate video file can be opened and has valid frames
+        test_cap = None
+        try:
+            test_cap = cv2.VideoCapture(filepath)
+            if not test_cap.isOpened():
+                os.remove(filepath)  # Delete invalid file
+                return jsonify({'error': 'Invalid video file. Cannot be opened by OpenCV.'}), 400
+            
+            # Verify it has frames
+            ret, test_frame = test_cap.read()
+            if not ret or test_frame is None:
+                os.remove(filepath)
+                return jsonify({'error': 'Invalid video file. No readable frames.'}), 400
+        finally:
+            if test_cap is not None:
+                test_cap.release()
+        
+        # Update state to use video file
+        with state_lock:
+            state['source_type'] = 'video'
+            state['video_file'] = filename
+            state['video_loop'] = request.form.get('loop', 'false').lower() == 'true'
+        
+        logger.info(f"Video uploaded successfully: {filename}")
+        return jsonify({
+            'status': 'success',
+            'filename': filename,
+            'source_type': 'video'
+        })
+    except Exception as e:
+        logger.error(f"Error uploading video: {e}", exc_info=True)
+        return jsonify({'error': f'Upload failed: {str(e)}'}), 500
+
+
+@app.route('/api/switch_source', methods=['POST'])
+def switch_source():
+    """Switch between camera and video file"""
+    data = request.get_json()
+    source_type = data.get('source_type', 'camera')
+    
+    # Stop current monitoring if running
+    with state_lock:
+        was_running = state['running']
+        state['running'] = False
+    
+    time.sleep(0.5)  # Allow current stream to stop
+    
+    # Update source - ENSURE camera mode clears video file
+    with state_lock:
+        state['source_type'] = source_type
+        if source_type == 'camera':
+            state['video_file'] = None
+            logger.info("Camera mode activated - cleared video file from state")
+        else:
+            logger.info(f"Video mode - current video: {state.get('video_file', 'None')}")
+    
+    logger.info(f"Switched to {source_type} source")
+    
+    return jsonify({
+        'status': 'success',
+        'source_type': source_type,
+        'was_running': was_running
+    })
+
+
+@app.route('/api/list_videos', methods=['GET'])
+def list_videos():
+    """List available uploaded videos"""
+    try:
+        videos = []
+        for filename in os.listdir(app.config['UPLOAD_FOLDER']):
+            if allowed_file(filename):
+                filepath = os.path.join(app.config['UPLOAD_FOLDER'], filename)
+                videos.append({
+                    'filename': filename,
+                    'size': os.path.getsize(filepath),
+                    'modified': datetime.fromtimestamp(os.path.getmtime(filepath)).isoformat()
+                })
+        return jsonify({'videos': videos})
+    except Exception as e:
+        logger.error(f"Error listing videos: {e}")
+        return jsonify({'error': str(e)}), 500
+
+
+@app.route('/api/toggle_heatmap', methods=['POST'])
+def toggle_heatmap():
+    """Toggle heatmap (REQ-8, REQ-9)"""
+    with state_lock:
+        state['heatmap_enabled'] = not state['heatmap_enabled']
+    logger.info(f"Heatmap {'enabled' if state['heatmap_enabled'] else 'disabled'}")
+    return jsonify({'heatmap_enabled': state['heatmap_enabled']})
+
+@app.route('/api/set_detection_mode', methods=['POST'])
+def set_detection_mode():
+    """Switch between normal and dense crowd detection modes"""
+    global CURRENT_MODE, DETECTION_INTERVAL, MIN_CONFIDENCE, RESIZE_FACTOR
+    global MIN_OBJECT_SIZE, ENABLE_MULTI_SCALE
+    
+    data = request.get_json()
+    mode = data.get('mode', 'normal')
+    
+    if mode not in DETECTION_MODES:
+        return jsonify({'error': f'Invalid mode. Choose: normal or dense'}), 400
+    
+    # Update mode
+    CURRENT_MODE = mode
+    active_mode = DETECTION_MODES[mode]
+    
+    # Update global parameters
+    DETECTION_INTERVAL = active_mode['interval']
+    MIN_CONFIDENCE = active_mode['confidence']
+    RESIZE_FACTOR = active_mode['resize']
+    MIN_OBJECT_SIZE = active_mode['min_size']
+    ENABLE_MULTI_SCALE = active_mode['multi_scale']
+    
+    # Update detector instance dynamically
+    detector.confidence_threshold = MIN_CONFIDENCE
+    detector.iou_threshold = active_mode['iou']
+    detector.min_size = MIN_OBJECT_SIZE
+    detector.imgsz = active_mode['imgsz']
+    detector.max_det = active_mode['max_det']
+    detector.second_pass_conf = active_mode['second_pass_conf']
+    detector.duplicate_threshold = active_mode['duplicate_threshold']
+    detector.min_box_size = active_mode['min_box_size']
+    
+    logger.info(f"Detection mode switched to: {mode}")
+    logger.info(f"Settings: interval={DETECTION_INTERVAL}, conf={MIN_CONFIDENCE}, iou={active_mode['iou']}, max_det={active_mode['max_det']}")
+    
+    return jsonify({
+        'status': 'success',
+        'mode': mode,
+        'settings': active_mode
+    })
+
+@app.route('/api/reset', methods=['POST'])
+def reset_statistics():
+    """Reset statistics"""
+    with state_lock:
+        state['total_detections'] = 0
+        state['count_history'] = []
+        state['time_history'] = []
+    logger.info("Statistics reset")
+    return jsonify({'status': 'reset'})
+
+
+@app.route('/api/optimize', methods=['POST'])
+def optimize_detection():
+    """Manual optimization endpoint for small objects"""
+    global MIN_CONFIDENCE, DETECTION_INTERVAL, RESIZE_FACTOR, ENABLE_MULTI_SCALE
+    
+    data = request.get_json()
+    if data:
+        MIN_CONFIDENCE = data.get('confidence', MIN_CONFIDENCE)
+        DETECTION_INTERVAL = max(1, data.get('interval', DETECTION_INTERVAL))
+        RESIZE_FACTOR = min(1.0, max(0.3, data.get('resize_factor', RESIZE_FACTOR)))
+        ENABLE_MULTI_SCALE = data.get('multi_scale', ENABLE_MULTI_SCALE)
+    
+    logger.info(f"Small object optimization applied: confidence={MIN_CONFIDENCE}, interval={DETECTION_INTERVAL}")
+    return jsonify({
+        'confidence': MIN_CONFIDENCE,
+        'interval': DETECTION_INTERVAL,
+        'resize_factor': RESIZE_FACTOR,
+        'multi_scale': ENABLE_MULTI_SCALE,
+        'min_object_size': MIN_OBJECT_SIZE
+    })
+
+
+@app.route('/api/stats')
+def get_statistics():
+    """Get current statistics (REQ-6, REQ-7)"""
+    with state_lock:
+        return jsonify({
+            'count': state['current_count'],
+            'fps': round(state['fps'], 1),
+            'alert_level': state['alert_level'],
+            'total_detections': state['total_detections'],
+            'running': state['running'],
+            'heatmap_enabled': state['heatmap_enabled'],
+            'count_history': state['count_history'][-50:],
+            'time_history': state['time_history'][-50:],
+            'thresholds': {
+                'warning': config['crowd']['density_threshold'],
+                'critical': config['crowd']['warning_threshold']
+            },
+            'optimization': {
+                'confidence': MIN_CONFIDENCE,
+                'detection_interval': DETECTION_INTERVAL,
+                'resize_factor': RESIZE_FACTOR,
+                'multi_scale': ENABLE_MULTI_SCALE,
+                'min_object_size': MIN_OBJECT_SIZE
+            }
+        })
+
+
+@app.route('/api/config', methods=['GET'])
+def get_config():
+    """Get system configuration"""
+    return jsonify({
+        'video_source': config['video']['source'],
+        'confidence_threshold': config['model']['confidence_threshold'],
+        'density_threshold': config['crowd']['density_threshold'],
+        'warning_threshold': config['crowd']['warning_threshold'],
+        'small_object_optimization': {
+            'min_confidence': MIN_CONFIDENCE,
+            'detection_interval': DETECTION_INTERVAL,
+            'resize_factor': RESIZE_FACTOR,
+            'multi_scale': ENABLE_MULTI_SCALE,
+            'min_object_size': MIN_OBJECT_SIZE
+        }
+    })
+
+
+@app.route('/api/health')
+def health_check():
+    """System health check"""
+    with state_lock:
+        return jsonify({
+            'status': 'healthy',
+            'running': state['running'],
+            'fps': state['fps'],
+            'current_count': state['current_count'],
+            'timestamp': datetime.now().isoformat()
+        })
+
+
+if __name__ == '__main__':
+    import os
+    port = int(os.environ.get('PORT', 5000))
+    logger.info("Starting Enhanced Zaytrics Web Server (Small Object Optimized)")
+    logger.info(f"Access the dashboard at: http://localhost:{port}")
+    logger.info("Small Object Detection Optimizations:")
+    logger.info(f"  - Detection interval: {DETECTION_INTERVAL} frames")
+    logger.info(f"  - Minimum confidence: {MIN_CONFIDENCE}")
+    logger.info(f"  - Resize factor: {RESIZE_FACTOR}")
+    logger.info(f"  - Multi-scale detection: {ENABLE_MULTI_SCALE}")
+    logger.info(f"  - Minimum object size: {MIN_OBJECT_SIZE} pixels")
+    
+    app.run(host='0.0.0.0', port=port, debug=False, threaded=True)

config.yaml

@@ -0,0 +1,141 @@
+# Zaytrics Smart Crowd Monitoring System - Configuration File
+# Version 2.0 - Enhanced for Small Object Detection
+
+# Model Configuration
+model:
+  name: "yolov8m.pt"  # MEDIUM model - best accuracy
+  confidence_threshold: 0.35
+  iou_threshold: 0.45
+  device: "cpu"  # Using RTX 3050 GPU for acceleration (auto-detects cuda:0)
+  class_filter: [0]  # Class IDs to detect (0 = person in COCO dataset)
+  
+  # Small Object Detection Parameters
+  small_object_mode: true  # Enable specialized small object detection
+  min_confidence_small: 0.05  # Low confidence for second pass
+  multi_scale: false
+  small_object_threshold: 50  # Pixel size below which object is considered "small"
+  
+  # Performance Optimization
+  detection_interval: 3  # Run detection every 3rd frame for better performance
+  resize_factor: 1.0  # Full resolution for best accuracy
+
+# Video Input Configuration
+video:
+  source: 0  # 0 for webcam, or path to video file e.g., "videos/crowd.mp4"
+  fps: 30  # Target frames per second
+  resolution:
+    width: 640  # Balanced resolution for YOLOv8s
+    height: 480  
+  buffer_size: 1  # Reduced buffer for lower latency
+  skip_frames: 1  # Process every frame by default
+
+# Crowd Detection Settings
+crowd:
+  density_threshold: 15  # Alert threshold for crowd count
+  warning_threshold: 25  # Critical warning threshold
+  min_detection_size: 20  # Minimum bounding box size in pixels
+  max_detection_size: 400  # Maximum bounding box size to filter outliers
+  
+  # Small Object Settings
+  enable_size_filtering: true
+  min_small_object_size: 10  # Absolute minimum size for valid detection
+  small_object_boost: true  # Apply special processing for small objects
+
+# Heatmap Configuration
+heatmap:
+  enabled: false  # Enable/disable heatmap generation
+  kernel_size: 30  # Base kernel size (used when adaptive is false)
+  alpha: 0.6  # Heatmap overlay transparency (0.0 - 1.0)
+  colormap: "jet"  # Options: jet, hot, viridis, plasma
+  
+  # Adaptive Heatmap Settings (better for mixed close/far videos)
+  adaptive: true  # Enable adaptive kernel sizing based on detection size
+  min_kernel_size: 30  # Minimum kernel size for far videos (small people)
+  max_kernel_size: 150  # Maximum kernel size for close videos (large people)
+  blur_strength: 0.6  # Gaussian sigma multiplier for smoother blending
+  intensity_boost: 1.2  # Boost intensity for small object visibility
+
+# Preprocessing Configuration
+preprocessing:
+  enable_enhancement: true  # Enable frame enhancement for small objects
+  clahe_clip_limit: 2.0  # Contrast enhancement strength
+  clahe_grid_size: [8, 8]  # CLAHE grid size
+  sharpening_strength: 1.2  # Sharpening filter strength
+  noise_reduction: true  # Enable noise reduction
+  
+  # Small Object Enhancement
+  small_object_enhancement: true
+  contrast_boost: 1.1
+  detail_enhancement: true
+
+# Dashboard Settings
+dashboard:
+  title: "Zaytrics Smart Crowd Monitoring System - Enhanced"
+  theme: "dark"  # Options: dark, light
+  refresh_rate: 1  # Dashboard refresh rate in seconds
+  show_fps: true  # Display FPS counter
+  show_confidence: true  # Show detection confidence scores
+  show_small_objects: true  # Highlight small object detections
+  alert_sound: false  # Enable audio alerts
+  
+  # Visualization Enhancements
+  small_object_color: [255, 255, 0]  # Yellow for small objects
+  normal_object_color: [0, 255, 0]   # Green for normal objects
+  show_centers: true  # Show center points for small objects
+
+# Performance Settings
+performance:
+  max_processing_time: 0.5  # Reduced for real-time performance
+  max_queue_size: 5  # Smaller queue for lower latency
+  enable_profiling: false  # Enable performance profiling
+  adaptive_processing: true  # Adjust processing based on FPS
+  
+  # Small Object Performance
+  small_object_interval: 3  # Run small object detection every Nth frame
+  cache_detections: true  # Cache detections between frames
+  max_cache_age: 0.3  # Maximum age for cached detections (seconds)
+
+# Logging Configuration
+logging:
+  level: "INFO"  # Options: DEBUG, INFO, WARNING, ERROR, CRITICAL
+  save_logs: true  # Save logs to file
+  log_file: "logs/system.log"
+  log_detections: false  # Log individual detections (verbose)
+
+# Data Storage
+storage:
+  save_detections: false  # Save detection results to CSV
+  save_frames: false  # Save processed frames
+  output_directory: "output"
+  save_small_object_stats: true  # Track small object detection statistics
+  
+# System Constraints (from SRS)
+constraints:
+  min_accuracy: 0.75  # Slightly reduced for small object focus
+  max_frame_delay: 0.5  # Reduced delay requirement for real-time
+  max_heatmap_delay: 1.0  # Reduced heatmap delay
+  
+  # Small Object Specific Constraints
+  min_small_object_accuracy: 0.65  # Minimum accuracy for small objects
+  max_small_object_size: 50  # Maximum size considered "small"
+
+# Alert System
+alerts:
+  enable_crowd_alerts: true
+  enable_small_object_alerts: false  # Special alerts for small object detection
+  alert_cooldown: 5  # Seconds between repeated alerts
+  
+  # Small Object Alert Settings
+  small_object_threshold: 5  # Minimum small objects to trigger alert
+  small_object_density_alert: 10  # Alert if small object density is high
+
+# Advanced Settings
+advanced:
+  enable_debug_overlay: false  # Show debug information on video
+  save_detection_samples: false  # Save samples of detections for analysis
+  detection_sample_interval: 30  # Save sample every N seconds
+  
+  # Small Object Analysis
+  track_small_objects: true
+  small_object_analysis: false  # Advanced analysis of small object patterns
+  enable_iou_tracking: true  # Use IoU for tracking small objects between frames

requirements.txt

@@ -0,0 +1,30 @@
+# Zaytrics Smart Crowd Monitoring System - Dependencies
+# Python 3.8+ required
+
+# Core ML/CV Libraries
+opencv-python==4.8.1.78
+numpy==1.24.3
+pillow==10.0.1
+
+# YOLOv8 and Detection
+ultralytics==8.0.196
+#torch==2.1.0
+#torchvision==0.16.0
+
+# Web Framework
+flask==3.0.0
+
+# Visualization
+matplotlib==3.8.0
+seaborn==0.13.0
+plotly==5.17.0
+
+# Utilities
+pandas==2.1.1
+pyyaml==6.0.1
+tqdm==4.66.1
+
+# Optional GPU support (comment out if CPU only)
+# Install manually if needed:
+# pip install torch torchvision --index-url https://download.pytorch.org/whl/cu118
+flask-cors==4.0.0

runtime.txt

@@ -0,0 +1 @@
+python-3.11.0

src/__init__.py

@@ -0,0 +1,14 @@
+"""
+Zaytrics Smart Crowd Monitoring System
+Version 1.0
+
+A computer vision-based application for real-time crowd detection,
+density estimation, and monitoring dashboard.
+
+Organization: SEECS, NUST
+Prepared by: AMMO
+"""
+
+__version__ = "1.0.0"
+__author__ = "AMMO"
+__organization__ = "SEECS, NUST"

src/detection/__init__.py

@@ -0,0 +1,7 @@
+"""
+Detection module for YOLOv8-based crowd detection
+"""
+
+from .detector import CrowdDetector
+
+__all__ = ['CrowdDetector']

src/detection/detector.py

@@ -0,0 +1,369 @@
+"""
+YOLOv8 Crowd Detection Module - Enhanced for Small Objects
+Implements REQ-1, REQ-2, REQ-3: Person detection with bounding boxes and counting
+"""
+
+import cv2
+import numpy as np
+from ultralytics import YOLO
+import time
+from typing import List, Tuple, Dict
+import logging
+
+logger = logging.getLogger(__name__)
+
+
+class CrowdDetector:
+    """
+    Main crowd detection class using YOLOv8 - Enhanced for small objects
+    
+    Satisfies SRS Requirements:
+    - REQ-1: Detect individuals in video frames using pre-trained model
+    - REQ-2: Display bounding boxes around detected individuals
+    - REQ-3: Update count continuously as frames are processed
+    """
+    
+    def __init__(self, config: Dict):
+        """
+        Initialize the YOLOv8 detector
+        
+        Args:
+            config: Configuration dictionary from config.yaml
+        """
+        self.config = config
+        self.model_name = config['model']['name']
+        self.confidence_threshold = config['model']['confidence_threshold']
+        self.iou_threshold = config['model']['iou_threshold']
+        self.device = config['model']['device']
+        self.class_filter = config['model']['class_filter']
+        self.min_size = config['crowd']['min_detection_size']
+        
+        # Optimization parameters
+        self.small_object_mode = config['model'].get('small_object_mode', True)
+        self.imgsz = 416  # Lower resolution for faster TensorRT inference
+        
+        # Dynamic mode parameters (can be updated via API)
+        self.max_det = 300  # Default max detections
+        self.second_pass_conf = 0.05  # Default second pass confidence
+        self.duplicate_threshold = 30  # Default duplicate detection threshold
+        self.min_box_size = 5  # Default minimum box size
+        
+        # Performance tracking
+        from collections import deque
+        self.frame_times = deque(maxlen=30)  # Keep last 30 frame times
+        self.detection_count = 0
+        self.frame_count = 0  # Track frames for logging throttle
+        
+        logger.info(f"Initializing YOLOv8 Detector with model: {self.model_name}")
+        logger.info(f"Device: {self.device}, Confidence: {self.confidence_threshold}")
+        logger.info(f"Small object mode: {self.small_object_mode}")
+        
+        # Check for TensorRT optimized model first
+        tensorrt_model = self.model_name.replace('.pt', '.engine')
+        use_tensorrt = False
+        
+        try:
+            import os
+            if os.path.exists(tensorrt_model):
+                logger.info(f"Loading TensorRT optimized model: {tensorrt_model}")
+                self.model = YOLO(tensorrt_model)
+                use_tensorrt = True
+            else:
+                logger.info(f"Loading PyTorch model: {self.model_name}")
+                logger.info(f"TIP: Export to TensorRT for 2-3x speedup: yolo export model={self.model_name} format=engine half=True device=0")
+                self.model = YOLO(self.model_name)
+                self.model.to(self.device)
+                use_tensorrt = False
+            
+            logger.info("YOLOv8 model loaded successfully")
+            logger.info(f"*** USING {'TensorRT ENGINE' if use_tensorrt else 'PyTorch FP16'} for inference ***")
+            
+            # GPU Warmup - run dummy inference to compile CUDA kernels
+            logger.info("Warming up GPU (this may take a few seconds)...")
+            dummy_frame = np.zeros((416, 416, 3), dtype=np.uint8)
+            for _ in range(5):  # Run 5 warmup passes for better optimization
+                self.model(dummy_frame, conf=0.5, verbose=False, device=self.device, half=(self.device != "cpu"), imgsz=self.imgsz)
+            logger.info("GPU warmup complete - ready for fast inference")
+            
+        except Exception as e:
+            logger.error(f"Failed to load YOLOv8 model: {e}")
+            raise
+
+    def preprocess_frame(self, frame: np.ndarray) -> np.ndarray:
+        """
+        Light preprocessing - only applied if needed
+        Returns frame as-is for speed (YOLO handles normalization)
+        """
+        return frame  # Skip preprocessing for speed
+
+    def detect_additional_pass(self, frame: np.ndarray, existing_detections: List[Dict]) -> List[Dict]:
+        """
+        Additional detection pass with very low confidence for missed small objects
+        """
+        try:
+            # Second pass with lower confidence threshold for small/distant objects
+            results = self.model(
+                frame,
+                conf=self.second_pass_conf,  # Use dynamic second pass confidence
+                iou=self.iou_threshold,
+                classes=self.class_filter,
+                verbose=False,
+                imgsz=self.imgsz,
+                device=self.device,
+                half=(self.device != "cpu")
+            )
+            
+            additional_detections = []
+            existing_centers = [(d['center'][0], d['center'][1]) for d in existing_detections]
+            
+            for result in results:
+                boxes = result.boxes
+                
+                for box in boxes:
+                    x1, y1, x2, y2 = box.xyxy[0].cpu().numpy()
+                    confidence = float(box.conf[0].cpu().numpy())
+                    class_id = int(box.cls[0].cpu().numpy())
+                    
+                    width = x2 - x1
+                    height = y2 - y1
+                    center_x = int((x1 + x2) / 2)
+                    center_y = int((y1 + y2) / 2)
+                    
+                    # Filter out very small noise using dynamic min_box_size
+                    if width < self.min_box_size or height < self.min_box_size:
+                        continue
+                    
+                    # Check if this is a duplicate (near existing detection)
+                    is_duplicate = False
+                    for ex, ey in existing_centers:
+                        distance = ((center_x - ex)**2 + (center_y - ey)**2)**0.5
+                        if distance < self.duplicate_threshold:  # Use dynamic threshold
+                            is_duplicate = True
+                            break
+                    
+                    if not is_duplicate:
+                        detection = {
+                            'bbox': [int(x1), int(y1), int(x2), int(y2)],
+                            'confidence': confidence,
+                            'class_id': class_id,
+                            'class_name': 'person',
+                            'center': [center_x, center_y],
+                            'size': 'tiny' if (width < 10 or height < 10) else ('small' if (width < 50 or height < 50) else 'normal')
+                        }
+                        additional_detections.append(detection)
+            
+            return additional_detections
+            
+        except Exception as e:
+            logger.error(f"Additional detection pass error: {e}")
+            return []
+    
+    def detect(self, frame: np.ndarray, resize_factor: float = 1.0, 
+               confidence_threshold: float = None) -> Tuple[List[Dict], int, float]:
+        """
+        Detect people in the frame using YOLOv8 with TensorRT
+        
+        Args:
+            frame: Input frame (BGR format from OpenCV)
+            resize_factor: Ignored - always uses full resolution for best accuracy
+            confidence_threshold: Optional override for detection threshold
+        
+        Returns:
+            detections: List of all detected people (primary + second pass)
+            count: Total number of people detected
+            processing_time: Time taken for detection
+        """
+        start_time = time.time()
+        detections = []
+        
+        if confidence_threshold is None:
+            confidence_threshold = self.confidence_threshold
+        
+        try:
+            # Primary detection with CUDA using configured device
+            results = self.model(
+                frame,
+                conf=confidence_threshold,
+                iou=self.iou_threshold,
+                classes=self.class_filter,
+                verbose=False,
+                imgsz=self.imgsz,
+                device=self.device,
+                half=(self.device != "cpu"),  # FP16 inference for 2x speedup on RTX 3050
+                max_det=self.max_det,  # Use dynamic max detections
+                agnostic_nms=False,
+                retina_masks=False  # Disable for speed
+            )
+            
+            # Extract primary detections
+            for result in results:
+                boxes = result.boxes
+                
+                for box in boxes:
+                    x1, y1, x2, y2 = box.xyxy[0].cpu().numpy()
+                    confidence = float(box.conf[0].cpu().numpy())
+                    class_id = int(box.cls[0].cpu().numpy())
+                    
+                    width = x2 - x1
+                    height = y2 - y1
+                    
+                    # Filter by minimum size to remove noise
+                    if width >= self.min_size and height >= self.min_size:
+                        detection = {
+                            'bbox': [int(x1), int(y1), int(x2), int(y2)],
+                            'confidence': confidence,
+                            'class_id': class_id,
+                            'class_name': 'person',
+                            'center': [int((x1 + x2) / 2), int((y1 + y2) / 2)],
+                            'size': 'tiny' if (width < 10 or height < 10) else ('small' if (width < 50 or height < 50) else 'normal')
+                        }
+                        detections.append(detection)
+            
+            # Second pass for better small object detection
+            if self.small_object_mode:
+                additional = self.detect_additional_pass(frame, detections)
+                detections.extend(additional)
+            
+            processing_time = time.time() - start_time
+            self.frame_times.append(processing_time)
+            self.detection_count += len(detections)
+            self.frame_count += 1
+            
+            count = len(detections)
+            
+            # Log detection count occasionally (every 30 frames) to avoid log spam
+            if self.frame_count % 30 == 0 or count > 0:
+                logger.debug(f"Detected {count} people in {processing_time:.3f}s (frame {self.frame_count})")
+            
+            return detections, count, processing_time
+            
+        except Exception as e:
+            logger.error(f"Detection error: {e}")
+            import traceback
+            logger.error(traceback.format_exc())
+            return [], 0, 0.0
+
+    def _calculate_iou(self, box1: List[int], box2: List[int]) -> float:
+        """
+        Calculate Intersection over Union for two bounding boxes with edge case handling
+        
+        Args:
+            box1: [x1, y1, x2, y2]
+            box2: [x1, y1, x2, y2]
+            
+        Returns:
+            IoU value between 0.0 and 1.0
+        """
+        # Calculate intersection area
+        x1_inter = max(box1[0], box2[0])
+        y1_inter = max(box1[1], box2[1])
+        x2_inter = min(box1[2], box2[2])
+        y2_inter = min(box1[3], box2[3])
+        
+        inter_area = max(0, x2_inter - x1_inter) * max(0, y2_inter - y1_inter)
+        
+        # Calculate union area
+        box1_area = (box1[2] - box1[0]) * (box1[3] - box1[1])
+        box2_area = (box2[2] - box2[0]) * (box2[3] - box2[1])
+        
+        # Handle edge cases
+        if box1_area <= 0 or box2_area <= 0:
+            return 0.0
+        
+        union_area = box1_area + box2_area - inter_area
+        
+        # Avoid division by zero
+        if union_area <= 0:
+            return 0.0
+        
+        return inter_area / union_area
+    
+    def draw_detections(self, frame: np.ndarray, detections: List[Dict], 
+                       show_confidence: bool = True) -> np.ndarray:
+        """
+        Draw bounding boxes with high visibility for crowd detection
+        Color-coded by confidence level
+        
+        Args:
+            frame: Input frame
+            detections: List of detections
+            show_confidence: Whether to display confidence scores
+        
+        Returns:
+            frame: Frame with drawn bounding boxes
+        """
+        frame_copy = frame.copy()
+        
+        for i, det in enumerate(detections):
+            x1, y1, x2, y2 = det['bbox']
+            confidence = det['confidence']
+            is_small = det.get('size') == 'small'
+            
+            # Color by confidence: Green (high) -> Yellow (medium) -> Orange (low)
+            if confidence >= 0.5:
+                color = (0, 255, 0)  # Green - high confidence
+            elif confidence >= 0.25:
+                color = (0, 255, 255)  # Yellow - medium
+            elif confidence >= 0.15:
+                color = (0, 165, 255)  # Orange - lower
+            else:
+                color = (0, 128, 255)  # Light orange - very low
+            
+            thickness = 1 if is_small else 2
+            
+            # Draw bounding box
+            cv2.rectangle(frame_copy, (x1, y1), (x2, y2), color, thickness)
+            
+            # Draw center dot for all detections
+            center_x, center_y = det['center']
+            cv2.circle(frame_copy, (center_x, center_y), 2, color, -1)
+        
+        # Draw prominent count display in top-left corner
+        count = len(detections)
+        count_text = f"PEOPLE: {count}"
+        
+        # Background box for count
+        (text_w, text_h), _ = cv2.getTextSize(count_text, cv2.FONT_HERSHEY_SIMPLEX, 1.0, 2)
+        cv2.rectangle(frame_copy, (5, 5), (text_w + 15, text_h + 15), (0, 0, 0), -1)
+        cv2.rectangle(frame_copy, (5, 5), (text_w + 15, text_h + 15), (0, 255, 0), 2)
+        
+        # Count text
+        cv2.putText(frame_copy, count_text, (10, text_h + 8), 
+                   cv2.FONT_HERSHEY_SIMPLEX, 1.0, (0, 255, 0), 2)
+        
+        return frame_copy
+    
+    def get_statistics(self) -> Dict:
+        """
+        Get detection statistics
+        
+        Returns:
+            stats: Dictionary with performance metrics
+        """
+        if not self.frame_times:
+            return {
+                'avg_processing_time': 0.0,
+                'fps': 0.0,
+                'total_detections': 0,
+                'frames_processed': 0
+            }
+        
+        avg_time = np.mean(self.frame_times[-100:])  # Last 100 frames
+        fps = 1.0 / avg_time if avg_time > 0 else 0.0
+        
+        return {
+            'avg_processing_time': avg_time,
+            'fps': fps,
+            'total_detections': self.detection_count,
+            'frames_processed': len(self.frame_times),
+            'max_processing_time': max(self.frame_times) if self.frame_times else 0.0,
+            'min_processing_time': min(self.frame_times) if self.frame_times else 0.0
+        }
+    
+    def reset_statistics(self):
+        """Reset detection statistics"""
+        from collections import deque
+        self.frame_times = deque(maxlen=30)
+        self.detection_count = 0
+        self.frame_count = 0
+        logger.info("Detection statistics reset")

src/heatmap/__init__.py

@@ -0,0 +1,7 @@
+"""
+Heatmap generation module for crowd density visualization
+"""
+
+from .generator import HeatmapGenerator
+
+__all__ = ['HeatmapGenerator']

src/heatmap/generator.py

@@ -0,0 +1,316 @@
+"""
+Crowd Density Heatmap Generator
+Implements REQ-4, REQ-5: Generate and visualize crowd density zones
+"""
+
+import cv2
+import numpy as np
+from typing import List, Dict, Tuple
+import time
+import logging
+
+logger = logging.getLogger(__name__)
+
+
+class HeatmapGenerator:
+    """
+    Generate crowd density heatmaps
+    
+    Satisfies SRS Requirements:
+    - REQ-4: Generate localized density zones
+    - REQ-5: Apply color map representing crowd concentration
+    """
+    
+    def __init__(self, config: Dict):
+        """
+        Initialize heatmap generator
+        
+        Args:
+            config: Configuration dictionary
+        """
+        self.config = config
+        self.enabled = config['heatmap']['enabled']
+        self.kernel_size = config['heatmap']['kernel_size']
+        self.alpha = config['heatmap']['alpha']
+        self.colormap_name = config['heatmap']['colormap']
+        
+        # Adaptive heatmap settings
+        self.adaptive = config['heatmap'].get('adaptive', True)
+        self.min_kernel_size = config['heatmap'].get('min_kernel_size', 30)
+        self.max_kernel_size = config['heatmap'].get('max_kernel_size', 150)
+        self.blur_strength = config['heatmap'].get('blur_strength', 0.6)
+        
+        # Map colormap name to OpenCV constant
+        colormap_dict = {
+            'jet': cv2.COLORMAP_JET,
+            'hot': cv2.COLORMAP_HOT,
+            'viridis': cv2.COLORMAP_VIRIDIS,
+            'plasma': cv2.COLORMAP_PLASMA,
+            'rainbow': cv2.COLORMAP_RAINBOW,
+            'cool': cv2.COLORMAP_COOL
+        }
+        
+        self.colormap = colormap_dict.get(self.colormap_name, cv2.COLORMAP_JET)
+        
+        # Performance tracking
+        self.generation_times = []
+        
+        logger.info(f"Heatmap Generator initialized: Enabled={self.enabled}")
+        logger.info(f"Kernel size: {self.kernel_size}, Alpha: {self.alpha}, Colormap: {self.colormap_name}")
+        logger.info(f"Adaptive mode: {self.adaptive}, Range: {self.min_kernel_size}-{self.max_kernel_size}")
+    
+    def generate_heatmap(self, frame: np.ndarray, detections: List[Dict]) -> Tuple[np.ndarray, float]:
+        """
+        Generate crowd density heatmap with ADAPTIVE kernel sizing
+        
+        Args:
+            frame: Input frame
+            detections: List of detections with center points and bbox
+        
+        Returns:
+            heatmap_overlay: Frame with heatmap overlay
+            generation_time: Time taken to generate heatmap
+        
+        Implements:
+            - REQ-4: Generate localized density zones
+            - REQ-5: Apply color map for crowd concentration
+            - ADAPTIVE: Auto-adjusts kernel size based on detection box dimensions
+        """
+        start_time = time.time()
+        
+        # Validate inputs
+        if frame is None or frame.size == 0:
+            logger.error("Invalid frame provided to heatmap generator")
+            return np.zeros((480, 640, 3), dtype=np.uint8), 0.0
+        
+        # Only check if there are detections
+        if not detections or len(detections) == 0:
+            generation_time = time.time() - start_time
+            return frame.copy(), generation_time
+        
+        try:
+            h, w = frame.shape[:2]
+            
+            # Validate frame dimensions
+            if h <= 0 or w <= 0:
+                logger.error(f"Invalid frame dimensions: {h}x{w}")
+                return frame.copy(), 0.0
+            
+            # Create empty density map (REQ-4: localized density zones)
+            density_map = np.zeros((h, w), dtype=np.float32)
+            
+            # Calculate adaptive kernel size with validation
+            if self.adaptive and len(detections) > 0:
+                total_size = 0
+                valid_detections = 0
+                
+                for det in detections:
+                    try:
+                        bbox = det.get('bbox', [])
+                        if len(bbox) != 4:
+                            continue
+                        
+                        x1, y1, x2, y2 = bbox
+                        box_width = max(0, x2 - x1)
+                        box_height = max(0, y2 - y1)
+                        
+                        if box_width > 0 and box_height > 0:
+                            total_size += (box_width + box_height) / 2
+                            valid_detections += 1
+                    except (KeyError, TypeError, ValueError) as e:
+                        logger.debug(f"Skipping invalid detection: {e}")
+                        continue
+                
+                if valid_detections > 0:
+                    avg_box_size = total_size / valid_detections
+                    
+                    # Scale kernel size based on average object size
+                    kernel_radius = int(np.clip(avg_box_size * 0.8, 
+                                               self.min_kernel_size, 
+                                               self.max_kernel_size))
+                    kernel_radius = max(15, kernel_radius)
+                    logger.debug(f"Adaptive kernel: avg={avg_box_size:.1f}, radius={kernel_radius}")
+                else:
+                    kernel_radius = self.kernel_size
+            else:
+                kernel_radius = self.kernel_size
+            
+            # Add Gaussian blobs at each detection center with validation
+            for det in detections:
+                try:
+                    center = det.get('center', [])
+                    bbox = det.get('bbox', [])
+                    
+                    if len(center) != 2 or len(bbox) != 4:
+                        continue
+                    
+                    cx, cy = center
+                    
+                    # Validate center coordinates
+                    if not (0 <= cx < w and 0 <= cy < h):
+                        logger.debug(f"Skipping out-of-bounds detection at ({cx}, {cy})")
+                        continue
+                    
+                    # Get detection-specific size for better adaptation
+                    if self.adaptive:
+                        x1, y1, x2, y2 = bbox
+                        det_width = max(0, x2 - x1)
+                        det_height = max(0, y2 - y1)
+                        det_size = (det_width + det_height) / 2
+                        
+                        if det_size <= 0:
+                            det_kernel = kernel_radius
+                        else:
+                            det_kernel = int(np.clip(det_size * 0.8, 
+                                                    self.min_kernel_size, 
+                                                    self.max_kernel_size))
+                            det_kernel = max(15, det_kernel)
+                    else:
+                        det_kernel = kernel_radius
+                    
+                    # Calculate ROI bounds with proper clamping
+                    y_min = max(0, cy - det_kernel)
+                    y_max = min(h, cy + det_kernel)
+                    x_min = max(0, cx - det_kernel)
+                    x_max = min(w, cx + det_kernel)
+                    
+                    # Validate ROI dimensions
+                    kernel_height = y_max - y_min
+                    kernel_width = x_max - x_min
+                    
+                    if kernel_height <= 0 or kernel_width <= 0:
+                        continue
+                    
+                    # Create 2D Gaussian with bounds checking
+                    y_range = np.arange(y_min, y_max) - cy
+                    x_range = np.arange(x_min, x_max) - cx
+                    
+                    if len(y_range) == 0 or len(x_range) == 0:
+                        continue
+                    
+                    x_grid, y_grid = np.meshgrid(x_range, y_range)
+                    
+                    # Gaussian formula with adaptive sigma
+                    det_sigma = det_kernel * self.blur_strength
+                    gaussian = np.exp(-(x_grid**2 + y_grid**2) / (2 * det_sigma**2))
+                    
+                    # Use confidence as intensity multiplier for better visualization
+                    intensity = det.get('confidence', 1.0)
+                    
+                    # Add to density map with bounds safety
+                    try:
+                        density_map[y_min:y_max, x_min:x_max] += gaussian.astype(np.float32) * intensity
+                    except (ValueError, IndexError) as e:
+                        logger.debug(f"Skipping gaussian placement: {e}")
+                        continue
+                    
+                except (KeyError, TypeError, ValueError, IndexError) as e:
+                    logger.debug(f"Error processing detection for heatmap: {e}")
+                    continue
+            
+            # Normalize density map to 0-255
+            if density_map.max() > 0:
+                density_map = (density_map / density_map.max() * 255).astype(np.uint8)
+            else:
+                density_map = density_map.astype(np.uint8)
+            
+            # Apply single Gaussian blur for smooth appearance (removed double blur)
+            blur_size = max(11, min(21, kernel_radius // 4))  # Adaptive blur size
+            if blur_size % 2 == 0:
+                blur_size += 1  # Must be odd
+            density_map = cv2.GaussianBlur(density_map, (blur_size, blur_size), 0)
+            
+            # Apply colormap (REQ-5: color map representing concentration)
+            heatmap_colored = cv2.applyColorMap(density_map, self.colormap)
+            
+            # Overlay heatmap on original frame
+            heatmap_overlay = cv2.addWeighted(
+                frame, 
+                1 - self.alpha, 
+                heatmap_colored, 
+                self.alpha, 
+                0
+            )
+            
+            generation_time = time.time() - start_time
+            self.generation_times.append(generation_time)
+            
+            # Check performance constraint (SRS: ≤ 1.5s per frame)
+            if generation_time > self.config['constraints']['max_heatmap_delay']:
+                logger.warning(
+                    f"Heatmap generation exceeded constraint: "
+                    f"{generation_time:.3f}s > {self.config['constraints']['max_heatmap_delay']}s"
+                )
+            
+            return heatmap_overlay, generation_time
+            
+        except Exception as e:
+            logger.error(f"Heatmap generation error: {e}")
+            import traceback
+            logger.error(traceback.format_exc())
+            return frame.copy(), time.time() - start_time
+    
+    def generate_density_grid(self, frame: np.ndarray, detections: List[Dict], 
+                             grid_size: int = 50) -> np.ndarray:
+        """
+        Generate grid-based density visualization (alternative method)
+        
+        Args:
+            frame: Input frame
+            detections: List of detections
+            grid_size: Size of each grid cell
+        
+        Returns:
+            grid_overlay: Frame with grid density overlay
+        """
+        h, w = frame.shape[:2]
+        overlay = frame.copy()
+        
+        # Create grid
+        grid_h = h // grid_size + 1
+        grid_w = w // grid_size + 1
+        density_grid = np.zeros((grid_h, grid_w), dtype=int)
+        
+        # Count detections in each grid cell
+        for det in detections:
+            cx, cy = det['center']
+            grid_x = min(cx // grid_size, grid_w - 1)
+            grid_y = min(cy // grid_size, grid_h - 1)
+            density_grid[grid_y, grid_x] += 1
+        
+        # Draw grid with color intensity based on density
+        max_density = density_grid.max() if density_grid.max() > 0 else 1
+        
+        for gy in range(grid_h):
+            for gx in range(grid_w):
+                if density_grid[gy, gx] > 0:
+                    x1 = gx * grid_size
+                    y1 = gy * grid_size
+                    x2 = min(x1 + grid_size, w)
+                    y2 = min(y1 + grid_size, h)
+                    
+                    # Color intensity based on density
+                    intensity = int(255 * (density_grid[gy, gx] / max_density))
+                    color = (0, intensity, 255 - intensity)  # Blue to red
+                    
+                    # Draw semi-transparent rectangle
+                    sub_img = overlay[y1:y2, x1:x2]
+                    rect = np.full_like(sub_img, color, dtype=np.uint8)
+                    overlay[y1:y2, x1:x2] = cv2.addWeighted(sub_img, 0.7, rect, 0.3, 0)
+        
+        return overlay
+    
+    def get_statistics(self) -> Dict:
+        """Get heatmap generation statistics"""
+        if not self.generation_times:
+            return {
+                'avg_generation_time': 0.0,
+                'total_heatmaps': 0
+            }
+        
+        return {
+            'avg_generation_time': np.mean(self.generation_times[-100:]),
+            'total_heatmaps': len(self.generation_times),
+            'max_generation_time': max(self.generation_times),
+            'min_generation_time': min(self.generation_times)
+        }

src/utils/__init__.py

@@ -0,0 +1,8 @@
+"""
+Utility functions and helpers
+"""
+
+from .logger import setup_logger
+from .config import load_config
+
+__all__ = ['setup_logger', 'load_config']

src/utils/config.py

@@ -0,0 +1,65 @@
+"""
+Configuration loader utility
+"""
+
+import yaml
+import os
+import logging
+
+logger = logging.getLogger(__name__)
+
+
+def load_config(config_path: str = 'config.yaml') -> dict:
+    """
+    Load configuration from YAML file
+    
+    Args:
+        config_path: Path to configuration file
+    
+    Returns:
+        config: Configuration dictionary
+    """
+    try:
+        if not os.path.exists(config_path):
+            logger.error(f"Configuration file not found: {config_path}")
+            raise FileNotFoundError(f"Config file not found: {config_path}")
+        
+        with open(config_path, 'r') as f:
+            config = yaml.safe_load(f)
+        
+        logger.info(f"✓ Configuration loaded from {config_path}")
+        return config
+        
+    except Exception as e:
+        logger.error(f"Failed to load configuration: {e}")
+        raise
+
+
+def validate_config(config: dict) -> bool:
+    """
+    Validate configuration values
+    
+    Args:
+        config: Configuration dictionary
+    
+    Returns:
+        valid: True if configuration is valid
+    """
+    required_keys = ['model', 'video', 'crowd', 'heatmap', 'dashboard']
+    
+    for key in required_keys:
+        if key not in config:
+            logger.error(f"Missing required configuration section: {key}")
+            return False
+    
+    # Validate threshold values
+    if not 0 <= config['model']['confidence_threshold'] <= 1:
+        logger.error("Invalid confidence threshold (must be 0-1)")
+        return False
+    
+    if not 0 <= config['heatmap']['alpha'] <= 1:
+        logger.error("Invalid heatmap alpha (must be 0-1)")
+        return False
+    
+    logger.info("✓ Configuration validation passed")
+    return True

src/utils/logger.py

@@ -0,0 +1,67 @@
+"""
+Logging utility setup
+"""
+
+import logging
+import os
+from datetime import datetime
+
+
+def setup_logger(config: dict) -> logging.Logger:
+    """
+    Setup logging configuration
+    
+    Args:
+        config: Configuration dictionary
+    
+    Returns:
+        logger: Configured logger instance
+    """
+    log_config = config.get('logging', {})
+    log_level = log_config.get('level', 'INFO')
+    save_logs = log_config.get('save_logs', True)
+    log_file = log_config.get('log_file', 'logs/system.log')
+    
+    # Create logs directory if it doesn't exist
+    if save_logs:
+        log_dir = os.path.dirname(log_file)
+        if log_dir and not os.path.exists(log_dir):
+            os.makedirs(log_dir)
+    
+    # Configure logging format
+    log_format = '%(asctime)s - %(name)s - %(levelname)s - %(message)s'
+    date_format = '%Y-%m-%d %H:%M:%S'
+    
+    # Setup handlers
+    handlers = []
+    
+    # Console handler
+    console_handler = logging.StreamHandler()
+    console_handler.setLevel(getattr(logging, log_level))
+    console_handler.setFormatter(logging.Formatter(log_format, date_format))
+    handlers.append(console_handler)
+    
+    # File handler
+    if save_logs:
+        # Add timestamp to log file
+        timestamp = datetime.now().strftime('%Y%m%d_%H%M%S')
+        log_file_with_timestamp = log_file.replace('.log', f'_{timestamp}.log')
+        
+        file_handler = logging.FileHandler(log_file_with_timestamp)
+        file_handler.setLevel(getattr(logging, log_level))
+        file_handler.setFormatter(logging.Formatter(log_format, date_format))
+        handlers.append(file_handler)
+    
+    # Configure root logger
+    logging.basicConfig(
+        level=getattr(logging, log_level),
+        handlers=handlers
+    )
+    
+    logger = logging.getLogger('Zaytrics')
+    logger.info("=" * 80)
+    logger.info("Zaytrics Smart Crowd Monitoring System - Version 1.0")
+    logger.info("Organization: SEECS, NUST")
+    logger.info("=" * 80)
+    
+    return logger

src/video/__init__.py

@@ -0,0 +1,7 @@
+"""
+Video input handler module
+"""
+
+from .handler import VideoHandler
+
+__all__ = ['VideoHandler']

src/video/handler.py

@@ -0,0 +1,328 @@
+"""
+Video Input Handler
+Manages video input from camera or file
+Optimized with threaded capture for GPU inference
+"""
+
+import cv2
+import numpy as np
+from typing import Optional, Tuple
+import logging
+import os
+import threading
+from collections import deque
+
+logger = logging.getLogger(__name__)
+
+
+class VideoHandler:
+    """
+    Handle video input from webcam or video file
+    
+    Supports:
+    - Webcam input (source = 0, 1, 2, ...)
+    - Video file input (source = path to file)
+    - Frame skipping for performance
+    - Resolution configuration
+    """
+    
+    def __init__(self, config: dict):
+        """
+        Initialize video handler
+        
+        Args:
+            config: Configuration dictionary
+        """
+        self.config = config
+        self.source = config['video']['source']
+        self.target_fps = config['video']['fps']
+        self.skip_frames = config['video']['skip_frames']
+        self.target_width = config['video']['resolution']['width']
+        self.target_height = config['video']['resolution']['height']
+        
+        self.cap = None
+        self.frame_count = 0
+        self.is_camera = False
+        
+        # Threaded capture for async frame reading (cameras only)
+        self._thread = None
+        self._stopped = False
+        self._frame_buffer = deque(maxlen=2)  # Small buffer for low latency
+        self._lock = threading.Lock()
+        self._use_threading = False  # Disabled - causes issues with video files
+        
+        logger.info(f"Video Handler initialized with source: {self.source}")
+    
+    def set_source(self, source, is_camera: bool = None):
+        """
+        Set video source and optionally specify if it's a camera
+        
+        Args:
+            source: Video source (int for camera, str for file path)
+            is_camera: Explicitly specify if source is camera (optional)
+        """
+        self.source = source
+        
+        if is_camera is not None:
+            self.is_camera = is_camera
+            self._is_camera_explicit = True  # Mark as explicitly set
+        else:
+            # Auto-detect
+            self.is_camera = isinstance(source, int)
+            if hasattr(self, '_is_camera_explicit'):
+                delattr(self, '_is_camera_explicit')
+        
+        logger.info(f"Source set to: {source}, is_camera: {self.is_camera}")
+    
+    def open(self) -> bool:
+        """
+        Open video source
+        
+        Returns:
+            success: True if video source opened successfully
+        """
+        try:
+            # Release any existing capture
+            if self.cap is not None:
+                self.cap.release()
+                self.cap = None
+            
+            # Validate source type
+            if isinstance(self.source, int):
+                # Camera source - only update is_camera if not already explicitly set
+                if not hasattr(self, '_is_camera_explicit'):
+                    self.is_camera = True
+                logger.info(f"Opening webcam: Camera {self.source}")
+            elif isinstance(self.source, str):
+                # File source - only update is_camera if not already explicitly set
+                if not hasattr(self, '_is_camera_explicit'):
+                    self.is_camera = False
+                if not os.path.exists(self.source):
+                    logger.error(f"Video file not found: {self.source}")
+                    return False
+                logger.info(f"Opening video file: {self.source}")
+            else:
+                logger.error(f"Invalid source type: {type(self.source)}")
+                return False
+            
+            # Open video source with DirectShow backend for Windows cameras
+            if self.is_camera:
+                # Try with DirectShow backend first (Windows)
+                self.cap = cv2.VideoCapture(self.source, cv2.CAP_DSHOW)
+                if not self.cap.isOpened():
+                    logger.warning("DirectShow backend failed, trying default backend")
+                    self.cap = cv2.VideoCapture(self.source)
+            else:
+                # For video files, use default backend
+                logger.info(f"Creating VideoCapture for file: {self.source}")
+                self.cap = cv2.VideoCapture(self.source)
+            
+            if not self.cap.isOpened():
+                logger.error(f"Failed to open video source: {self.source}")
+                return False
+            
+            # Set camera properties if using webcam
+            if self.is_camera:
+                self.cap.set(cv2.CAP_PROP_FRAME_WIDTH, self.target_width)
+                self.cap.set(cv2.CAP_PROP_FRAME_HEIGHT, self.target_height)
+                self.cap.set(cv2.CAP_PROP_FPS, self.target_fps)
+                self.cap.set(cv2.CAP_PROP_BUFFERSIZE, 1)  # Minimize buffer for low latency
+                self.cap.set(cv2.CAP_PROP_FOURCC, cv2.VideoWriter_fourcc('M','J','P','G'))  # MJPEG for speed
+            
+            # Get actual video properties
+            actual_fps = self.cap.get(cv2.CAP_PROP_FPS)
+            actual_width = int(self.cap.get(cv2.CAP_PROP_FRAME_WIDTH))
+            actual_height = int(self.cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
+            total_frames = int(self.cap.get(cv2.CAP_PROP_FRAME_COUNT))
+            
+            logger.info(f"Video source opened successfully")
+            logger.info(f"  Resolution: {actual_width}x{actual_height}")
+            logger.info(f"  FPS: {actual_fps}")
+            if not self.is_camera:
+                logger.info(f"  Total frames: {total_frames}")
+            
+            # Start threaded capture for async frame reading
+            if self._use_threading:
+                self._start_capture_thread()
+            
+            return True
+            
+        except Exception as e:
+            logger.error(f"Error opening video source: {e}")
+            return False
+    
+    def _start_capture_thread(self):
+        """Start background thread for frame capture"""
+        self._stopped = False
+        self._thread = threading.Thread(target=self._capture_loop, daemon=True)
+        self._thread.start()
+        logger.info("Threaded frame capture started")
+    
+    def _capture_loop(self):
+        """Background thread that continuously captures frames"""
+        while not self._stopped and self.cap is not None and self.cap.isOpened():
+            # Skip frames if configured
+            for _ in range(self.skip_frames - 1):
+                self.cap.grab()
+            
+            ret, frame = self.cap.read()
+            
+            if ret:
+                # Resize if needed
+                if frame.shape[1] != self.target_width or frame.shape[0] != self.target_height:
+                    frame = cv2.resize(frame, (self.target_width, self.target_height),
+                                       interpolation=cv2.INTER_NEAREST)
+                
+                with self._lock:
+                    self._frame_buffer.append((True, frame))
+            else:
+                with self._lock:
+                    self._frame_buffer.append((False, None))
+    
+    def read_frame(self) -> Tuple[bool, Optional[np.ndarray]]:
+        """
+        Read a frame from video source
+        Uses threaded capture if enabled for non-blocking reads
+        
+        Returns:
+            success: True if frame read successfully
+            frame: Frame as numpy array (BGR format)
+        """
+        if self.cap is None or not self.cap.isOpened():
+            return False, None
+        
+        try:
+            # Use threaded capture if enabled
+            if self._use_threading and self._thread is not None:
+                with self._lock:
+                    if len(self._frame_buffer) > 0:
+                        ret, frame = self._frame_buffer.pop()
+                        if ret:
+                            self.frame_count += 1
+                        return ret, frame
+                    else:
+                        return False, None
+            
+            # Fallback to synchronous capture
+            for _ in range(self.skip_frames - 1):
+                self.cap.grab()
+            
+            ret, frame = self.cap.read()
+            
+            if not ret:
+                return False, None
+            
+            # Only resize if dimensions don't match (optimization)
+            if frame.shape[1] != self.target_width or frame.shape[0] != self.target_height:
+                frame = cv2.resize(frame, (self.target_width, self.target_height), 
+                                  interpolation=cv2.INTER_NEAREST)  # Fastest interpolation
+            
+            self.frame_count += 1
+            return True, frame
+            
+        except Exception as e:
+            logger.error(f"Error reading frame: {e}")
+            return False, None
+    
+    def release(self):
+        """Release video source and stop capture thread with proper cleanup"""
+        try:
+            self._stopped = True
+            
+            # Wait for thread to finish with extended timeout
+            if self._thread is not None and self._thread.is_alive():
+                self._thread.join(timeout=3.0)  # Increased from 1.0 to 3.0 seconds
+                
+                # Force cleanup if thread is still alive
+                if self._thread.is_alive():
+                    logger.warning("Capture thread did not stop within timeout, forcing cleanup")
+                
+                self._thread = None
+            
+            # Release OpenCV capture
+            if self.cap is not None:
+                if self.cap.isOpened():
+                    self.cap.release()
+                self.cap = None
+                logger.info("Video source released")
+            
+            # Clear buffer
+            with self._lock:
+                self._frame_buffer.clear()
+                
+        except Exception as e:
+            logger.error(f"Error releasing video capture: {e}")
+            # Force cleanup even on error
+            self.cap = None
+            self._thread = None
+    
+    def is_opened(self) -> bool:
+        """Check if video source is opened"""
+        return self.cap is not None and self.cap.isOpened()
+    
+    def get_properties(self) -> dict:
+        """
+        Get video source properties
+        
+        Returns:
+            properties: Dictionary with video properties
+        """
+        if self.cap is None or not self.cap.isOpened():
+            return {}
+        
+        return {
+            'width': int(self.cap.get(cv2.CAP_PROP_FRAME_WIDTH)),
+            'height': int(self.cap.get(cv2.CAP_PROP_FRAME_HEIGHT)),
+            'fps': self.cap.get(cv2.CAP_PROP_FPS),
+            'total_frames': int(self.cap.get(cv2.CAP_PROP_FRAME_COUNT)),
+            'current_frame': self.frame_count,
+            'is_camera': self.is_camera
+        }
+    
+    def is_video_end(self) -> bool:
+        """
+        Check if video file has reached the end
+        
+        Returns:
+            True if video has ended, False otherwise (or if camera)
+        """
+        if self.is_camera or self.cap is None:
+            return False
+        
+        try:
+            # Get current position and total frames
+            current_pos = self.cap.get(cv2.CAP_PROP_POS_FRAMES)
+            total_frames = self.cap.get(cv2.CAP_PROP_FRAME_COUNT)
+            
+            # Check if we're at or past the end
+            # Use -2 threshold to catch end before actual failure
+            if total_frames > 0 and current_pos >= total_frames - 2:
+                return True
+            
+            return False
+        except Exception as e:
+            logger.error(f"Error checking video end: {e}")
+            return False
+    
+    def restart(self) -> bool:
+        """
+        Restart video from beginning (for video files only)
+        
+        Returns:
+            success: True if restart successful
+        """
+        if self.is_camera:
+            logger.warning("Cannot restart camera feed")
+            return False
+        
+        if self.cap is not None:
+            self.cap.set(cv2.CAP_PROP_POS_FRAMES, 0)
+            self.frame_count = 0
+            logger.info("Video restarted from beginning")
+            return True
+        
+        return False
+    
+    def __del__(self):
+        """Destructor to ensure video source is released"""
+        self.release()

static/script.js

@@ -0,0 +1,411 @@
+// Zaytrics - Crowd Monitoring Dashboard
+
+class ZaytricsDashboard {
+    constructor() {
+        this.isRunning = false;
+        this.currentSource = 'camera';
+        this.peopleCount = 0;
+        this.fps = 0;
+        this.init();
+    }
+
+    init() {
+        console.log('Zaytrics Dashboard Initialized');
+        this.setupEventListeners();
+        this.setupFileUpload();
+        this.startStatsPolling();
+        this.animateStats();
+    }
+
+    setupEventListeners() {
+        // Control button interactions
+        document.querySelectorAll('.control-btn').forEach(btn => {
+            btn.addEventListener('click', (e) => {
+                if (!e.currentTarget.id.includes('heatmap')) {
+                    document.querySelectorAll('.control-btn').forEach(b => {
+                        if (!b.id.includes('heatmap')) {
+                            b.classList.remove('active');
+                        }
+                    });
+                    e.currentTarget.classList.add('active');
+                }
+            });
+        });
+    }
+
+    setupFileUpload() {
+        const uploadZone = document.getElementById('uploadZone');
+        const fileInput = document.getElementById('fileInput');
+        const uploadStatus = document.getElementById('uploadStatus');
+
+        // Click to upload
+        uploadZone.addEventListener('click', () => fileInput.click());
+
+        // File selection
+        fileInput.addEventListener('change', (e) => {
+            const file = e.target.files[0];
+            if (file) {
+                this.uploadVideo(file);
+            }
+        });
+
+        // Drag and drop
+        uploadZone.addEventListener('dragover', (e) => {
+            e.preventDefault();
+            uploadZone.style.borderColor = 'var(--primary)';
+            uploadZone.style.backgroundColor = 'rgba(99, 102, 241, 0.1)';
+        });
+
+        uploadZone.addEventListener('dragleave', (e) => {
+            e.preventDefault();
+            uploadZone.style.borderColor = '';
+            uploadZone.style.backgroundColor = '';
+        });
+
+        uploadZone.addEventListener('drop', (e) => {
+            e.preventDefault();
+            uploadZone.style.borderColor = '';
+            uploadZone.style.backgroundColor = '';
+            
+            const file = e.dataTransfer.files[0];
+            if (file) {
+                this.uploadVideo(file);
+            }
+        });
+    }
+
+    async uploadVideo(file) {
+        const uploadStatus = document.getElementById('uploadStatus');
+        const loopVideo = document.getElementById('loopVideo').checked;
+
+        // Validate file type
+        const allowedTypes = ['video/mp4', 'video/avi', 'video/quicktime', 'video/x-matroska', 'video/webm'];
+        if (!allowedTypes.includes(file.type)) {
+            uploadStatus.innerHTML = '<div class="error">❌ Invalid file type. Please upload MP4, AVI, MOV, MKV, or WEBM.</div>';
+            return;
+        }
+
+        // Validate file size (100MB)
+        if (file.size > 100 * 1024 * 1024) {
+            uploadStatus.innerHTML = '<div class="error">❌ File too large. Maximum size is 100MB.</div>';
+            return;
+        }
+
+        uploadStatus.innerHTML = '<div class="info">⏳ Uploading video...</div>';
+
+        const formData = new FormData();
+        formData.append('file', file);
+        formData.append('loop', loopVideo);
+
+        try {
+            const response = await fetch('/api/upload_video', {
+                method: 'POST',
+                body: formData
+            });
+
+            const data = await response.json();
+
+            if (response.ok) {
+                uploadStatus.innerHTML = '<div class="success">✅ Video uploaded successfully!</div>';
+                this.currentSource = 'video';
+                
+                // Auto-switch to uploaded video
+                setTimeout(() => {
+                    uploadStatus.innerHTML = '';
+                }, 3000);
+            } else {
+                uploadStatus.innerHTML = `<div class="error">❌ ${data.error}</div>`;
+            }
+        } catch (error) {
+            console.error('Upload error:', error);
+            uploadStatus.innerHTML = '<div class="error">❌ Upload failed. Please try again.</div>';
+        }
+    }
+
+    startStatsPolling() {
+        // Clear any existing interval
+        if (this.statsInterval) {
+            clearInterval(this.statsInterval);
+        }
+        
+        // Poll stats from Flask API
+        this.statsInterval = setInterval(async () => {
+            if (this.isRunning) {
+                await this.updateStatsFromAPI();
+            }
+        }, 1000);
+    }
+    
+    stopStatsPolling() {
+        if (this.statsInterval) {
+            clearInterval(this.statsInterval);
+            this.statsInterval = null;
+        }
+    }
+
+    async updateStatsFromAPI() {
+        try {
+            const response = await fetch('/api/stats');
+            const data = await response.json();
+            
+            this.peopleCount = data.count || 0;
+            this.fps = data.fps || 0;
+            
+            document.getElementById('peopleCount').textContent = this.peopleCount;
+            document.getElementById('fpsCount').textContent = this.fps.toFixed(1);
+            
+            // Update status indicator based on alert level
+            const statusDot = document.querySelector('.status-dot');
+            if (statusDot) {
+                const alertLevel = data.alert_level || 'normal';
+                statusDot.className = 'status-dot';
+                if (alertLevel === 'warning') {
+                    statusDot.style.backgroundColor = '#f59e0b';
+                } else if (alertLevel === 'critical') {
+                    statusDot.style.backgroundColor = '#ef4444';
+                } else {
+                    statusDot.style.backgroundColor = '#10b981';
+                }
+            }
+        } catch (error) {
+            console.error('Error fetching stats:', error);
+        }
+    }
+
+    animateStats() {
+        // Animate stat numbers when they change
+        const observer = new MutationObserver((mutations) => {
+            mutations.forEach((mutation) => {
+                if (mutation.type === 'characterData' || mutation.type === 'childList') {
+                    const element = mutation.target.parentElement;
+                    if (element && element.classList.contains('stat-value')) {
+                        element.style.transform = 'scale(1.1)';
+                        setTimeout(() => {
+                            element.style.transform = 'scale(1)';
+                        }, 300);
+                    }
+                }
+            });
+        });
+
+        const statElements = document.querySelectorAll('.stat-value');
+        statElements.forEach(element => {
+            observer.observe(element, {
+                characterData: true,
+                childList: true,
+                subtree: true
+            });
+        });
+    }
+}
+
+// Global functions for button handlers
+let dashboard;
+
+async function switchSource(source) {
+    const uploadSection = document.getElementById('uploadSection');
+    const liveCameraBtn = document.getElementById('liveCameraBtn');
+    const uploadVideoBtn = document.getElementById('uploadVideoBtn');
+    
+    if (source === 'upload') {
+        uploadSection.style.display = 'block';
+        dashboard.currentSource = 'upload';
+    } else {
+        uploadSection.style.display = 'none';
+        dashboard.currentSource = 'camera';
+        
+        // Switch backend to camera
+        console.log('Switching to camera source...');
+        try {
+            const response = await fetch('/api/switch_source', {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({ source_type: 'camera' })
+            });
+            const data = await response.json();
+            console.log('Switched to camera:', data);
+        } catch (err) {
+            console.error('Error switching source:', err);
+        }
+    }
+}
+
+async function startMonitoring() {
+    console.log('Starting monitoring...');
+    dashboard.isRunning = true;
+    
+    // Restart stats polling
+    if (dashboard) {
+        dashboard.startStatsPolling();
+    }
+    
+    const startBtn = document.getElementById('startBtn');
+    const stopBtn = document.getElementById('stopBtn');
+    const placeholder = document.getElementById('videoPlaceholder');
+    const videoFeed = document.getElementById('videoFeed');
+    
+    startBtn.style.display = 'none';
+    stopBtn.style.display = 'block';
+    
+    try {
+        // First call the start API to set state
+        const response = await fetch('/api/start', { method: 'POST' });
+        const data = await response.json();
+        console.log('Start API response:', data);
+        
+        if (data.status === 'started') {
+            // Small delay to let backend initialize
+            await new Promise(resolve => setTimeout(resolve, 300));
+            
+            // Now set video source and display
+            if (videoFeed) {
+                console.log('Setting video feed source...');
+                videoFeed.src = '/video_feed?t=' + new Date().getTime();
+                
+                // Add load event listener for debugging
+                videoFeed.onload = function() {
+                    console.log('Video feed loaded successfully');
+                };
+                
+                videoFeed.onerror = function(e) {
+                    console.error('Video feed error:', e);
+                    alert('Failed to load video stream. Check console for details.');
+                };
+                
+                videoFeed.style.display = 'block';
+                console.log('Video feed displayed');
+            }
+            
+            // Hide placeholder
+            if (placeholder) {
+                placeholder.style.display = 'none';
+                console.log('Placeholder hidden');
+            }
+        }
+    } catch (error) {
+        console.error('Error starting monitoring:', error);
+        alert('Failed to start monitoring. Error: ' + error.message);
+        dashboard.isRunning = false;
+        startBtn.style.display = 'block';
+        stopBtn.style.display = 'none';
+    }
+}
+
+async function stopMonitoring() {
+    console.log('Stopping monitoring...');
+    dashboard.isRunning = false;
+    
+    // Stop stats polling to prevent unnecessary API calls
+    if (dashboard) {
+        dashboard.stopStatsPolling();
+    }
+    
+    const startBtn = document.getElementById('startBtn');
+    const stopBtn = document.getElementById('stopBtn');
+    
+    startBtn.style.display = 'block';
+    stopBtn.style.display = 'none';
+    
+    try {
+        const response = await fetch('/api/stop', { method: 'POST' });
+        const data = await response.json();
+        
+        if (data.status === 'stopped') {
+            // Hide video feed
+            const placeholder = document.getElementById('videoPlaceholder');
+            const videoFeed = document.getElementById('videoFeed');
+            
+            if (videoFeed) {
+                videoFeed.style.display = 'none';
+                videoFeed.removeAttribute('src');
+            }
+            if (placeholder) placeholder.style.display = 'flex';
+            
+            // Reset counts
+            document.getElementById('peopleCount').textContent = '0';
+            document.getElementById('fpsCount').textContent = '0';
+        }
+    } catch (error) {
+        console.error('Error stopping monitoring:', error);
+    }
+}
+
+async function toggleHeatmap() {
+    const heatmapBtn = document.getElementById('heatmapBtn');
+    
+    try {
+        const response = await fetch('/api/toggle_heatmap', { method: 'POST' });
+        const data = await response.json();
+        
+        if (data.heatmap_enabled) {
+            heatmapBtn.classList.add('active');
+        } else {
+            heatmapBtn.classList.remove('active');
+        }
+    } catch (error) {
+        console.error('Error toggling heatmap:', error);
+    }
+}
+
+async function switchMode(mode) {
+    try {
+        const response = await fetch('/api/set_detection_mode', {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({ mode: mode })
+        });
+        
+        if (response.ok) {
+            const data = await response.json();
+            console.log(`Switched to ${mode} mode:`, data.settings);
+            
+            // Update button states
+            document.querySelectorAll('.mode-btn').forEach(btn => btn.classList.remove('active'));
+            document.getElementById(`${mode}ModeBtn`).classList.add('active');
+            
+            // Show notification
+            console.log(`✓ ${mode === 'normal' ? 'Normal' : 'Dense Crowd'} mode activated`);
+        } else {
+            const error = await response.json();
+            console.error('Mode switch error:', error.error);
+        }
+    } catch (error) {
+        console.error('Error switching mode:', error);
+    }
+}
+
+// Cleanup on page unload
+window.addEventListener('beforeunload', async () => {
+    if (dashboard && dashboard.isRunning) {
+        // Stop monitoring before page closes
+        await fetch('/api/stop', { method: 'POST' });
+    }
+});
+
+// Initialize when DOM is loaded
+document.addEventListener('DOMContentLoaded', () => {
+    dashboard = new ZaytricsDashboard();
+    
+    // Add scroll animations
+    const observerOptions = {
+        threshold: 0.1,
+        rootMargin: '0px 0px -50px 0px'
+    };
+
+    const observer = new IntersectionObserver((entries) => {
+        entries.forEach(entry => {
+            if (entry.isIntersecting) {
+                entry.target.style.opacity = '1';
+                entry.target.style.transform = 'translateY(0)';
+            }
+        });
+    }, observerOptions);
+
+    // Observe elements for scroll animations
+    document.querySelectorAll('.feature-card, .dashboard-card').forEach(el => {
+        el.style.opacity = '0';
+        el.style.transform = 'translateY(30px)';
+        el.style.transition = 'opacity 0.6s ease, transform 0.6s ease';
+        observer.observe(el);
+    });
+});

static/style.css

@@ -0,0 +1,922 @@
+* {
+    margin: 0;
+    padding: 0;
+    box-sizing: border-box;
+}
+
+:root {
+    --bg-primary: #0a0a0a;
+    --bg-secondary: #111111;
+    --bg-card: #1a1a1a;
+    --bg-overlay: rgba(255, 255, 255, 0.02);
+    --primary: #0066ff;
+    --primary-glow: rgba(0, 102, 255, 0.15);
+    --text-primary: #ffffff;
+    --text-secondary: #a0a0a0;
+    --text-tertiary: #666666;
+    --border: rgba(255, 255, 255, 0.08);
+    --border-light: rgba(255, 255, 255, 0.04);
+    --success: #00d26a;
+    --warning: #ffb224;
+    --error: #ff375f;
+}
+
+body {
+    font-family: 'Inter', -apple-system, BlinkMacSystemFont, sans-serif;
+    background: var(--bg-primary);
+    color: var(--text-primary);
+    line-height: 1.6;
+    overflow-x: hidden;
+}
+
+/* Background Elements */
+.bg-grid {
+    position: fixed;
+    top: 0;
+    left: 0;
+    width: 100%;
+    height: 100%;
+    background-image: 
+        linear-gradient(rgba(255, 255, 255, 0.03) 1px, transparent 1px),
+        linear-gradient(90deg, rgba(255, 255, 255, 0.03) 1px, transparent 1px);
+    background-size: 50px 50px;
+    pointer-events: none;
+    z-index: -2;
+}
+
+.bg-glow {
+    position: fixed;
+    top: 50%;
+    left: 50%;
+    width: 600px;
+    height: 600px;
+    background: radial-gradient(circle, var(--primary-glow) 0%, transparent 70%);
+    transform: translate(-50%, -50%);
+    pointer-events: none;
+    z-index: -1;
+}
+
+.container {
+    max-width: 1600px;
+    margin: 0 auto;
+    padding: 0 24px;
+}
+
+/* Header & Navigation */
+.header {
+    padding: 24px 0;
+    border-bottom: 1px solid var(--border-light);
+}
+
+.nav {
+    display: flex;
+    align-items: center;
+    justify-content: space-between;
+}
+
+.logo {
+    display: flex;
+    align-items: center;
+    gap: 12px;
+    font-weight: 700;
+    font-size: 20px;
+}
+
+.logo-icon {
+    width: 32px;
+    height: 32px;
+    background: linear-gradient(135deg, #001a33, #000d1a);
+    border-radius: 8px;
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    font-weight: 800;
+    font-size: 16px;
+    box-shadow: 0 4px 12px rgba(0, 102, 255, 0.3);
+    border: 1px solid rgba(0, 102, 255, 0.3);
+    transition: all 0.3s ease;
+    position: relative;
+    overflow: hidden;
+}
+
+.logo-icon::before {
+    content: '';
+    position: absolute;
+    top: -50%;
+    left: -50%;
+    width: 200%;
+    height: 200%;
+    background: linear-gradient(
+        45deg,
+        transparent,
+        rgba(0, 102, 255, 0.1),
+        transparent
+    );
+    animation: shine 3s infinite;
+}
+
+.logo-icon:hover {
+    box-shadow: 0 6px 20px rgba(0, 102, 255, 0.5);
+    transform: translateY(-2px);
+    background: linear-gradient(135deg, #002147, #00142e);
+}
+
+@keyframes shine {
+    0% {
+        transform: translateX(-100%) translateY(-100%) rotate(45deg);
+    }
+    100% {
+        transform: translateX(100%) translateY(100%) rotate(45deg);
+    }
+}
+
+.nav-links {
+    display: flex;
+    gap: 32px;
+}
+
+.nav-link {
+    color: var(--text-secondary);
+    text-decoration: none;
+    font-weight: 500;
+    font-size: 14px;
+    transition: color 0.2s ease;
+}
+
+.nav-link:hover {
+    color: var(--text-primary);
+}
+
+.nav-actions {
+    display: flex;
+    gap: 12px;
+}
+
+/* Buttons */
+.btn {
+    padding: 12px 20px;
+    border: none;
+    border-radius: 8px;
+    font-weight: 600;
+    font-size: 14px;
+    cursor: pointer;
+    transition: all 0.2s ease;
+    text-decoration: none;
+    display: inline-flex;
+    align-items: center;
+    gap: 8px;
+}
+
+.btn-primary {
+    background: var(--primary);
+    color: white;
+}
+
+.btn-primary:hover {
+    background: #0052cc;
+    transform: translateY(-1px);
+}
+
+.btn-secondary {
+    background: var(--bg-overlay);
+    color: var(--text-primary);
+    border: 1px solid var(--border);
+}
+
+.btn-secondary:hover {
+    background: rgba(255, 255, 255, 0.05);
+}
+
+.btn-large {
+    padding: 16px 32px;
+    font-size: 16px;
+    display: inline-flex;
+    align-items: center;
+    justify-content: center;
+}
+
+/* Hero Section */
+.hero {
+    display: flex;
+    flex-direction: column;
+    align-items: center;
+    gap: 48px;
+    padding: 60px 0;
+    min-height: 85vh;
+}
+
+.hero-intro {
+    text-align: center;
+    max-width: 800px;
+    display: flex;
+    flex-direction: column;
+    gap: 24px;
+    align-items: center;
+}
+
+.badge {
+    display: inline-flex;
+    background: var(--bg-overlay);
+    border: 1px solid var(--border);
+    border-radius: 20px;
+    padding: 8px 16px;
+    font-size: 14px;
+    font-weight: 500;
+    color: var(--text-secondary);
+    width: fit-content;
+}
+
+.hero-title {
+    font-size: 48px;
+    font-weight: 800;
+    line-height: 1.1;
+    letter-spacing: -0.02em;
+    margin: 0;
+}
+
+.gradient-text {
+    background: linear-gradient(135deg, var(--primary), #00d4ff);
+    -webkit-background-clip: text;
+    -webkit-text-fill-color: transparent;
+    background-clip: text;
+}
+
+.hero-description {
+    font-size: 16px;
+    color: var(--text-secondary);
+    line-height: 1.6;
+    margin: 0;
+}
+
+.hero-actions {
+    display: flex;
+    gap: 16px;
+    flex-wrap: wrap;
+    align-items: center;
+    justify-content: center;
+}
+
+/* Dashboard Card */
+.dashboard-card {
+    background: var(--bg-card);
+    border: 1px solid var(--border);
+    border-radius: 16px;
+    overflow: hidden;
+    box-shadow: 0 8px 32px rgba(0, 0, 0, 0.3);
+    max-width: 1100px;
+    width: 100%;
+}
+
+.card-header {
+    padding: 24px;
+    border-bottom: 1px solid var(--border);
+    display: flex;
+    justify-content: space-between;
+    align-items: center;
+}
+
+.card-title {
+    font-size: 18px;
+    font-weight: 600;
+}
+
+.status-indicator {
+    display: flex;
+    align-items: center;
+    gap: 8px;
+    font-size: 14px;
+    color: var(--success);
+}
+
+.status-dot {
+    width: 8px;
+    height: 8px;
+    background: var(--success);
+    border-radius: 50%;
+    animation: pulse 2s infinite;
+}
+
+@keyframes pulse {
+    0%, 100% { opacity: 1; }
+    50% { opacity: 0.5; }
+}
+
+.video-container {
+    position: relative;
+    background: #000;
+    aspect-ratio: 16/9;
+}
+
+.video-placeholder {
+    position: absolute;
+    top: 0;
+    left: 0;
+    width: 100%;
+    height: 100%;
+    background: linear-gradient(135deg, #1a1a1a, #2a2a2a);
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    z-index: 1;
+}
+
+#videoFeed {
+    position: absolute;
+    top: 0;
+    left: 0;
+    width: 100%;
+    height: 100%;
+    object-fit: contain;
+    z-index: 2;
+}
+
+.video-overlay {
+    text-align: center;
+    color: var(--text-secondary);
+}
+
+.camera-icon {
+    font-size: 48px;
+    margin-bottom: 16px;
+    opacity: 0.7;
+}
+
+.video-text {
+    font-size: 14px;
+}
+
+.video-stats {
+    position: absolute;
+    bottom: 20px;
+    left: 20px;
+    display: flex;
+    gap: 16px;
+    z-index: 10;
+}
+
+.video-stat {
+    display: flex;
+    align-items: center;
+    gap: 12px;
+    background: rgba(0, 0, 0, 0.8);
+    padding: 12px 16px;
+    border-radius: 8px;
+    backdrop-filter: blur(10px);
+}
+
+.stat-icon {
+    font-size: 20px;
+}
+
+.stat-info {
+    display: flex;
+    flex-direction: column;
+    gap: 2px;
+}
+
+.stat-value {
+    font-size: 18px;
+    font-weight: 700;
+    color: var(--text-primary);
+}
+
+.stat-label {
+    font-size: 12px;
+    color: var(--text-secondary);
+}
+
+.card-controls {
+    display: flex;
+    padding: 20px;
+    gap: 8px;
+}
+
+.control-btn {
+    flex: 1;
+    padding: 12px 16px;
+    background: var(--bg-overlay);
+    border: 1px solid var(--border);
+    border-radius: 8px;
+    color: var(--text-secondary);
+    font-size: 14px;
+    font-weight: 500;
+    cursor: pointer;
+    transition: all 0.2s ease;
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    gap: 8px;
+}
+
+.control-btn:hover,
+.control-btn.active {
+    background: var(--primary);
+    color: white;
+    border-color: var(--primary);
+}
+
+/* Mode Selector Styles */
+.mode-selector {
+    border-top: 1px solid var(--border);
+    background: var(--bg-overlay);
+    padding: 16px 20px;
+    display: flex;
+    align-items: center;
+    gap: 12px;
+}
+
+.mode-label {
+    font-size: 13px;
+    font-weight: 600;
+    color: var(--text-secondary);
+    margin-right: 8px;
+}
+
+.mode-btn {
+    flex: 1;
+    padding: 10px 14px;
+    font-size: 13px;
+}
+
+/* Upload Section */
+.upload-section {
+    padding: 20px;
+    border-top: 1px solid var(--border);
+    background: var(--bg-overlay);
+}
+
+.upload-zone {
+    border: 2px dashed var(--border);
+    border-radius: 12px;
+    padding: 40px;
+    text-align: center;
+    cursor: pointer;
+    transition: all 0.3s ease;
+}
+
+.upload-zone:hover {
+    border-color: var(--primary);
+    background: rgba(0, 102, 255, 0.05);
+}
+
+.upload-content {
+    display: flex;
+    flex-direction: column;
+    align-items: center;
+    gap: 12px;
+}
+
+.upload-icon {
+    font-size: 48px;
+    opacity: 0.5;
+}
+
+.upload-text {
+    font-size: 16px;
+    font-weight: 500;
+    color: var(--text-primary);
+}
+
+.upload-subtext {
+    font-size: 13px;
+    color: var(--text-secondary);
+}
+
+.upload-options {
+    margin-top: 16px;
+    display: flex;
+    justify-content: center;
+}
+
+.checkbox-label {
+    display: flex;
+    align-items: center;
+    gap: 8px;
+    font-size: 14px;
+    color: var(--text-secondary);
+    cursor: pointer;
+}
+
+.checkbox-label input[type="checkbox"] {
+    width: 16px;
+    height: 16px;
+    cursor: pointer;
+}
+
+.upload-status {
+    margin-top: 12px;
+    font-size: 14px;
+    text-align: center;
+}
+
+.upload-status .error {
+    color: var(--error);
+}
+
+.upload-status .success {
+    color: var(--success);
+}
+
+.upload-status .info {
+    color: var(--primary);
+}
+
+/* Monitoring Controls */
+.monitoring-controls {
+    padding: 20px;
+    display: flex;
+    gap: 12px;
+    justify-content: center;
+}
+
+.monitoring-controls .btn {
+    min-width: 180px;
+}
+
+/* Features Section */
+.features {
+    padding: 120px 0;
+}
+
+.section-header {
+    text-align: center;
+    margin-bottom: 64px;
+    max-width: 600px;
+    margin-left: auto;
+    margin-right: auto;
+}
+
+.section-badge {
+    display: inline-flex;
+    background: var(--bg-overlay);
+    border: 1px solid var(--border);
+    border-radius: 20px;
+    padding: 8px 16px;
+    font-size: 14px;
+    font-weight: 500;
+    color: var(--text-secondary);
+    margin-bottom: 20px;
+}
+
+.section-title {
+    font-size: 48px;
+    font-weight: 700;
+    line-height: 1.1;
+    letter-spacing: -0.02em;
+    margin-bottom: 20px;
+}
+
+.section-description {
+    font-size: 18px;
+    color: var(--text-secondary);
+    line-height: 1.6;
+}
+
+.features-grid {
+    display: grid;
+    grid-template-columns: repeat(2, 1fr);
+    gap: 24px;
+}
+
+.feature-card {
+    background: var(--bg-card);
+    border: 1px solid var(--border);
+    border-radius: 16px;
+    padding: 32px;
+    transition: all 0.3s ease;
+}
+
+.feature-card:hover {
+    transform: translateY(-4px);
+    border-color: var(--primary);
+    box-shadow: 0 8px 32px rgba(0, 102, 255, 0.1);
+}
+
+.feature-icon {
+    font-size: 32px;
+    margin-bottom: 20px;
+}
+
+.feature-title {
+    font-size: 20px;
+    font-weight: 600;
+    margin-bottom: 12px;
+    color: var(--text-primary);
+}
+
+.feature-description {
+    color: var(--text-secondary);
+    line-height: 1.6;
+}
+
+/* Press Section */
+.press {
+    padding: 80px 0;
+    border-top: 1px solid var(--border-light);
+}
+
+.press-logos {
+    display: flex;
+    justify-content: center;
+    align-items: center;
+    gap: 60px;
+    flex-wrap: wrap;
+}
+
+.press-logo {
+    font-size: 18px;
+    font-weight: 600;
+    color: var(--text-tertiary);
+    transition: color 0.2s ease;
+}
+
+.press-logo:hover {
+    color: var(--text-secondary);
+}
+
+/* Responsive Design */
+@media (max-width: 968px) {
+    .hero {
+        gap: 40px;
+    }
+    
+    .hero-title {
+        font-size: 40px;
+    }
+    
+    .features-grid {
+        grid-template-columns: 1fr;
+    }
+    
+    .nav-links {
+        display: none;
+    }
+}
+
+@media (max-width: 768px) {
+    .hero-title {
+        font-size: 36px;
+    }
+    
+    .section-title {
+        font-size: 36px;
+    }
+    
+    .hero-actions {
+        justify-content: center;
+    }
+}
+
+@media (max-width: 480px) {
+    .container {
+        padding: 0 16px;
+    }
+    
+    .hero-title {
+        font-size: 28px;
+    }
+    
+    .hero-description {
+        font-size: 16px;
+    }
+    
+    .btn-large {
+        padding: 14px 24px;
+        font-size: 14px;
+    }
+}
+/* Background Image with Overlay */
+.bg-image {
+    position: fixed;
+    top: 0;
+    left: 0;
+    width: 100%;
+    height: 100%;
+    background-image: url('/static/422671.jpg');
+    background-size: cover;
+    background-position: center;
+    background-repeat: no-repeat;
+    z-index: -3;
+}
+
+.bg-image::before {
+    content: '';
+    position: absolute;
+    top: 0;
+    left: 0;
+    width: 100%;
+    height: 100%;
+    background: linear-gradient(
+        135deg,
+        rgba(10, 10, 10, 0.95) 0%,
+        rgba(10, 10, 10, 0.85) 50%,
+        rgba(10, 10, 10, 0.95) 100%
+    );
+    backdrop-filter: blur(1px);
+}
+
+/* Enhanced Background Elements */
+.bg-grid {
+    position: fixed;
+    top: 0;
+    left: 0;
+    width: 100%;
+    height: 100%;
+    background-image: 
+        linear-gradient(rgba(255, 255, 255, 0.03) 1px, transparent 1px),
+        linear-gradient(90deg, rgba(255, 255, 255, 0.03) 1px, transparent 1px);
+    background-size: 50px 50px;
+    pointer-events: none;
+    z-index: -2;
+    mix-blend-mode: overlay;
+}
+
+.bg-glow {
+    position: fixed;
+    top: 50%;
+    left: 50%;
+    width: 600px;
+    height: 600px;
+    background: radial-gradient(circle, var(--primary-glow) 0%, transparent 70%);
+    transform: translate(-50%, -50%);
+    pointer-events: none;
+    z-index: -1;
+    mix-blend-mode: screen;
+    opacity: 0.3;
+}
+
+/* Update existing container for better contrast */
+.container {
+    position: relative;
+    z-index: 1;
+}
+
+/* Enhanced cards with more transparency */
+.dashboard-card,
+.feature-card {
+    background: rgba(26, 26, 26, 0.85);
+    backdrop-filter: blur(20px);
+    border: 1px solid var(--border);
+}
+
+/* Update header for better readability */
+.header {
+    background: rgba(17, 17, 17, 0.8);
+    backdrop-filter: blur(20px);
+}
+
+/* Add motion blur effect to simulate speed */
+@keyframes subtleMove {
+    0%, 100% {
+        transform: translateX(0) scale(1);
+    }
+    50% {
+        transform: translateX(10px) scale(1.02);
+    }
+}
+
+.bg-image {
+    animation: subtleMove 20s ease-in-out infinite;
+}
+
+/* Enhanced video container to match F1 theme */
+.video-container {
+    position: relative;
+    background: #000;
+    aspect-ratio: 16/9;
+    border-radius: 12px;
+    overflow: hidden;
+    border: 1px solid rgba(255, 255, 255, 0.1);
+}
+
+.video-placeholder {
+    width: 100%;
+    height: 100%;
+    background: linear-gradient(135deg, #1a1a1a 0%, #2a2a2a 50%, #1a1a1a 100%);
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    position: relative;
+}
+
+/* Add racing circuit pattern overlay */
+.video-placeholder::before {
+    content: '';
+    position: absolute;
+    top: 0;
+    left: 0;
+    width: 100%;
+    height: 100%;
+    background-image: 
+        radial-gradient(circle at 20% 50%, rgba(0, 102, 255, 0.1) 0%, transparent 50%),
+        radial-gradient(circle at 80% 20%, rgba(0, 212, 255, 0.1) 0%, transparent 50%),
+        radial-gradient(circle at 40% 80%, rgba(0, 102, 255, 0.1) 0%, transparent 50%);
+    animation: circuitMove 15s linear infinite;
+}
+
+@keyframes circuitMove {
+    0% {
+        background-position: 0% 0%, 100% 100%, 50% 50%;
+    }
+    100% {
+        background-position: 100% 100%, 0% 0%, 150% 150%;
+    }
+}
+
+/* Update hero section for better contrast with background */
+.hero-content {
+    background: rgba(10, 10, 10, 0.6);
+    backdrop-filter: blur(10px);
+    border-radius: 20px;
+    padding: 40px;
+    margin: -40px;
+    border: 1px solid rgba(255, 255, 255, 0.05);
+}
+
+/* Enhanced badge styles */
+.badge {
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    width: fit-content;
+    margin: 0 auto;
+    background: rgba(0, 102, 255, 0.15);
+    border: 1px solid rgba(0, 102, 255, 0.3);
+    color: #0066ff;
+    backdrop-filter: blur(10px);
+    text-align: center;
+}
+
+/* Update feature cards for better readability */
+.feature-card {
+    background: rgba(26, 26, 26, 0.8);
+    backdrop-filter: blur(20px);
+    transition: all 0.3s ease;
+}
+
+.feature-card:hover {
+    background: rgba(26, 26, 26, 0.9);
+    transform: translateY(-5px);
+    border-color: var(--primary);
+}
+
+/* Enhanced press section */
+.press {
+    background: rgba(10, 10, 10, 0.8);
+    backdrop-filter: blur(20px);
+    margin: 0 -24px;
+    padding: 80px 24px;
+}
+
+/* Racing-inspired status indicators */
+.status-indicator {
+    background: rgba(0, 210, 106, 0.1);
+    border: 1px solid rgba(0, 210, 106, 0.3);
+    padding: 8px 16px;
+    border-radius: 20px;
+    backdrop-filter: blur(10px);
+}
+
+/* F1-inspired speed metrics */
+.video-stat {
+    background: rgba(0, 0, 0, 0.9);
+    border: 1px solid rgba(255, 255, 255, 0.1);
+    backdrop-filter: blur(20px);
+}
+
+/* Update button styles for better contrast */
+.btn-primary {
+    background: linear-gradient(135deg, var(--primary), #0099ff);
+    box-shadow: 0 4px 20px rgba(0, 102, 255, 0.3);
+    display: inline-flex;
+    align-items: center;
+    justify-content: center;
+    text-align: center;
+}
+
+.btn-primary:hover {
+    background: linear-gradient(135deg, #0052cc, #0077cc);
+    box-shadow: 0 6px 25px rgba(0, 102, 255, 0.4);
+}
+
+/* Mobile optimizations for background */
+@media (max-width: 768px) {
+    .bg-image {
+        background-attachment: scroll;
+        animation: none; /* Remove animation on mobile for performance */
+    }
+    
+    .hero-content {
+        background: rgba(10, 10, 10, 0.8);
+        margin: -20px;
+        padding: 30px 20px;
+    }
+}
+
+/* Performance optimizations */
+@media (prefers-reduced-motion: reduce) {
+    .bg-image,
+    .video-placeholder::before {
+        animation: none;
+    }
+}

templates/index.html

@@ -0,0 +1,189 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Zaytrics - Crowd Monitoring</title>
+    <link rel="stylesheet" href="{{ url_for('static', filename='style.css') }}">
+    <link href="https://fonts.googleapis.com/css2?family=Inter:wght@300;400;500;600;700;800&display=swap" rel="stylesheet">
+</head>
+<body>
+    <!-- Background Image -->
+    <div class="bg-image"></div>
+    <!-- Background Elements -->
+    <div class="bg-grid"></div>
+    <div class="bg-glow"></div>
+    <div class="container">
+        <!-- Header -->
+        <header class="header">
+            <nav class="nav">
+                <div class="logo">
+                    <div class="logo-icon">Z</div>
+                    <span class="logo-text">Zaytrics</span>
+                </div>
+            </nav>
+        </header>
+
+        <!-- Hero Section -->
+        <section class="hero">
+            <!-- Introduction Section -->
+            <div class="hero-intro">
+                <div class="badge">
+                    <span class="badge-text">AI-Powered Analytics</span>
+                </div>
+                <h1 class="hero-title">
+                    Real-time Crowd
+                    <span class="gradient-text">Intelligence</span>
+                    Platform
+                </h1>
+                <p class="hero-description">
+                    Advanced computer vision and AI to monitor, analyze, and optimize crowd movement 
+                    in real-time. Make data-driven decisions for safety and efficiency.
+                </p>
+            </div>
+            
+            <!-- Main Dashboard Card -->
+            <div class="dashboard-card">
+                <div class="card-header">
+                    <div class="card-title">Live Monitoring Dashboard</div>
+                    <div class="card-actions">
+                        <div class="status-indicator">
+                            <div class="status-dot"></div>
+                            <span>Live</span>
+                        </div>
+                    </div>
+                </div>
+                
+                <div class="video-container">
+                    <div class="video-placeholder" id="videoPlaceholder">
+                        <div class="video-overlay">
+                            <div class="camera-icon">📹</div>
+                            <div class="video-text">Click Start Monitoring to begin</div>
+                        </div>
+                    </div>
+                    <img id="videoFeed" src="" alt="Live feed" style="display:none; position:absolute; top:0; left:0; width:100%; height:100%; object-fit:contain;">
+                    
+                    <div class="video-stats">
+                        <div class="video-stat">
+                            <div class="stat-icon">👥</div>
+                            <div class="stat-info">
+                                <div class="stat-value" id="peopleCount">0</div>
+                                <div class="stat-label">People Detected</div>
+                            </div>
+                        </div>
+                        <div class="video-stat">
+                            <div class="stat-icon">⚡</div>
+                            <div class="stat-info">
+                                <div class="stat-value" id="fpsCount">0</div>
+                                <div class="stat-label">FPS</div>
+                            </div>
+                        </div>
+                    </div>
+                </div>
+                
+                <div class="card-controls">
+                    <button class="control-btn active" id="liveCameraBtn" onclick="switchSource('camera')">
+                        <span class="control-icon">📹</span>
+                        Live Camera
+                    </button>
+                    <button class="control-btn" id="uploadVideoBtn" onclick="switchSource('upload')">
+                        <span class="control-icon">📁</span>
+                        Upload Video
+                    </button>
+                    <button class="control-btn" id="heatmapBtn" onclick="toggleHeatmap()">
+                        <span class="control-icon">🔥</span>
+                        Heatmap
+                    </button>
+                </div>
+
+                <!-- Detection Mode Toggle -->
+                <div class="card-controls mode-selector">
+                    <div class="mode-label">Detection Mode:</div>
+                    <button class="control-btn mode-btn active" id="normalModeBtn" onclick="switchMode('normal')">
+                        <span class="control-icon">👥</span>
+                        Normal
+                    </button>
+                    <button class="control-btn mode-btn" id="denseModeBtn" onclick="switchMode('dense')">
+                        <span class="control-icon">🏟️</span>
+                        Dense Crowd
+                    </button>
+                </div>
+
+                <!-- Upload Form (Hidden by default) -->
+                <div class="upload-section" id="uploadSection" style="display: none;">
+                    <div class="upload-zone" id="uploadZone">
+                        <input type="file" id="fileInput" accept=".mp4,.avi,.mov,.mkv,.webm" style="display: none;">
+                        <div class="upload-content">
+                            <div class="upload-icon">📎</div>
+                            <div class="upload-text">Drag & drop video file here or click to browse</div>
+                            <div class="upload-subtext">Supported formats: MP4, AVI, MOV, MKV, WEBM (Max 100MB)</div>
+                        </div>
+                    </div>
+                    <div class="upload-options">
+                        <label class="checkbox-label">
+                            <input type="checkbox" id="loopVideo" checked>
+                            <span>Loop video playback</span>
+                        </label>
+                    </div>
+                    <div class="upload-status" id="uploadStatus"></div>
+                </div>
+
+                <!-- Start/Stop Controls -->
+                <div class="monitoring-controls">
+                    <button class="btn btn-primary btn-large" id="startBtn" onclick="startMonitoring()">
+                        <span class="btn-icon">▶</span>
+                        Start Monitoring
+                    </button>
+                    <button class="btn btn-secondary btn-large" id="stopBtn" onclick="stopMonitoring()" style="display: none;">
+                        <span class="btn-icon">■</span>
+                        Stop Monitoring
+                    </button>
+                </div>
+            </div>
+        </section>
+
+        <!-- Features Grid -->
+        <section class="features">
+            <div class="section-header">
+                <h2 class="section-title">Advanced Crowd Intelligence</h2>
+            </div>
+            
+            <div class="features-grid">
+                <div class="feature-card">
+                    <div class="feature-icon">🎯</div>
+                    <h3 class="feature-title">Real-time Detection</h3>
+                    <p class="feature-description">
+                        Instant people counting and movement tracking with sub-second latency
+                    </p>
+                </div>
+                
+                <div class="feature-card">
+                    <div class="feature-icon">🔥</div>
+                    <h3 class="feature-title">Heatmap Visualization</h3>
+                    <p class="feature-description">
+                        Visual density maps showing crowd concentration and movement patterns
+                    </p>
+                </div>
+                
+                <div class="feature-card">
+                    <div class="feature-icon">📹</div>
+                    <h3 class="feature-title">Dual Source Support</h3>
+                    <p class="feature-description">
+                        Monitor live camera feeds or analyze uploaded video files
+                    </p>
+                </div>
+                
+                <div class="feature-card">
+                    <div class="feature-icon">⚡</div>
+                    <h3 class="feature-title">Optimized Performance</h3>
+                    <p class="feature-description">
+                        Efficient processing for real-time analysis on standard hardware
+                    </p>
+                </div>
+            </div>
+        </section>
+    </div>
+
+    <script src="{{ url_for('static', filename='script.js') }}"></script>
+</body>
+</html>