🔍 Video Analytics and OSINT Platform

A comprehensive video analytics platform with real-time object detection, movement heatmap analysis, and object tracking capabilities. Powered by YOLO models for detection, with a React frontend and Flask+Celery backend.

✨ Features

• 📊 Real-time Object Detection: Process videos and detect objects using latest YOLO models
• 🔥 Heatmap Analysis: Generate motion heatmaps to visualize movement patterns over time
• 📈 Statistical Analysis: Visualize detected object frequencies and detailed statistics
• 🔄 Object Tracking: Track objects across video frames with persistence
• ⚡ Multiple Video Processing: Process multiple videos simultaneously with intuitive job management
• 🛠️ Customizable Parameters: Adjust frame intervals and model selection for optimal results
• 📱 Responsive UI: Modern interface that works across devices

v2.mp4

🛠️ Prerequisites

Before getting started, ensure you have installed:

• Python 3.12
• Node.js & npm
• Git (with Git LFS)
• Redis (Celery message broker and result backend)
  • Windows: Download Redis for Windows
  • Ubuntu: sudo apt update && sudo apt install redis-server
• Miniconda (recommended)

🚀 Optional: GPU Acceleration

For significantly faster processing:

• CUDA Toolkit: Version 11.8
  • Download CUDA Toolkit
• cuDNN: Matching your CUDA (11.8) version 9.10.2
  • cuDNN Download Page
• PyTorch with CUDA: Installed via custom index
  • PyTorch Installation Guide

🧱 Installation

1. Clone the Repository

git clone https://github.com/realvoidgojo/VideoAnaltyics-Cyberthon.git
cd VideoAnaltyics-Cyberthon

⚠️ Important: Download YOLO models manually from:

• YOLOv11 models repository
• Ultralytics website
• Place downloaded model(s) in the models directory

2. Set Up Conda Environment (Recommended)

conda create -n video_env python=3.10 -y
conda activate video_env
conda install -c conda-forge opencv ffmpeg -y
conda install -c conda-forge ffmpeg=6.1.1=gpl* -y

3. Backend Setup

# With conda environment activated:
pip install -r requirements.txt

# For CUDA support (optional, replace cu116 with your CUDA version):
pip uninstall torch torchvision -y
pip install torch torchvision --index-url https://download.pytorch.org/whl/cu118

# Create necessary directories
mkdir -p data hls_stream

4. Frontend Setup

cd frontend
npm install

▶️ Running the Application

1. Start Redis Server

# Windows: Start from the installed location
# Linux/macOS:
redis-server

2. Start Celery Worker

# From project root, in a new terminal:
conda activate video_env  # If using conda
celery -A src.celery.celery_app worker --loglevel=info --pool=threads -c 4

Adjust -c option to match your CPU cores

3. Start Flask Backend

# From project root, in a new terminal:
conda activate video_env  # If using conda
python app.py

Flask will run at: http://127.0.0.1:5000

4. Start React Frontend

# From frontend directory, in a new terminal:
npm run dev

Frontend will be available at: http://localhost:5173

🖥️ Using the Application

1. Upload Videos: Use the upload interface to submit video files
2. Choose Detection Settings:
   • Select YOLO model (smaller models are faster)
   • Set frame interval (higher values = faster processing, fewer detections)
   • Enable heatmap generation
3. Analysis Modes:
   • Object Detection View: See detected objects with bounding boxes and statistics
   • Heatmap Analysis: Visualize movement intensity and patterns over time

🌟 Features in Detail

Object Detection

• Real-time object recognition with latest YOLO models
• Customizable confidence thresholds
• Detailed statistics of detected objects
• Frequency charts and object counts
• HLS video streaming for smooth playback

Heatmap Analysis

• Movement intensity visualization
• Temporal activity mapping
• Peak movement time identification
• Duration analysis
• Downloadable heatmap videos

📁 Project Structure

VideoAnalytics-Cyberthon/
├── app.py                   # Main Flask application
├── src/                     # Source code directory
│   ├── celery.py            # Celery application definition
│   ├── video_processing.py  # Frame extraction and preprocessing
│   ├── object_detection.py  # YOLO detection functions
│   ├── heatmap_analysis.py  # Heatmap generation and analysis
│   └── ...
├── models/                  # YOLO model files (.pt)
├── data/                    # Temporary video storage
├── hls_stream/              # HLS video streaming files
├── frontend/                # React frontend
│   ├── src/                 # React source code
│   │   ├── components/      # UI components
│   │   │   ├── video/       # Video-related components
│   │   │   ├── heatmap/     # Heatmap components
│   │   │   ├── charts/      # Data visualization
│   │   │   └── ...
│   │   └── ...
├── setup/                   # Setup documentation
└── ...

🤝 Contributing

Contributions are welcome! Please feel free to submit pull requests or open issues to suggest improvements or report bugs.

📄 License

This project is licensed under the MIT License - see the LICENSE file for details.

🙏 Acknowledgements

• Ultralytics for YOLO models
• React and Vite for the frontend framework
• Flask for the backend API
• Celery for asynchronous task processing

---

For detailed setup instructions, see the setup guide