╦  ╦╦╔═╗╦╔═╗╔╗╔  ╔═╗╔═╗╔═╗
 ╚╗╔╝║╚═╗║║ ║║║║  ║ ║╠═╝╚═╗
  ╚╝ ╩╚═╝╩╚═╝╝╚╝  ╚═╝╩  ╚═╝

VisionOps — Real-Time Intelligence for Video Streams

---

What is VisionOps?

VisionOps is a production-ready computer vision platform that performs real-time object detection using YOLOv8 and motion analysis using Optical Flow, with a live analytics dashboard. It ingests video streams (webcam or file), runs intelligent detection and motion analysis on every frame, and serves the results through a REST API and interactive dashboard. Designed to mirror industrial Operations Insight Platforms.

---

Features

• 🎯 YOLOv8 Object Detection — Real-time COCO object detection with configurable confidence thresholds and class filtering
• 🌊 Optical Flow Motion Analysis — Dense (Farneback) and Sparse (Lucas-Kanade) motion tracking with heatmap visualization
• 📺 Live MJPEG Streaming — Annotated video stream accessible via browser or <img> tag
• 📊 Real-Time Dashboard — Dark-themed Streamlit dashboard with live metrics, charts, and event logs
• ⚡ FastAPI Backend — High-performance REST API with auto-generated Swagger documentation
• 🗃️ SQLite Event Logging — Persistent detection event storage with session statistics
• 🖼️ Data Augmentation — Albumentations-based preprocessing and dataset augmentation tools
• 🔧 Runtime Configuration — Update thresholds, flow modes, and video sources without restart
• 🖥️ GPU Acceleration — Automatic CUDA/MPS detection with CPU fallback

---

Architecture

┌──────────────────────────────────────────────────────────────────────┐
│                          VisionOps Platform                          │
├──────────────────────────────────────────────────────────────────────┤
│                                                                      │
│   ┌──────────────┐     ┌──────────────────────────────────────────┐  │
│   │ Video Source  │     │           Processing Pipeline            │  │
│   │              │     │                                          │  │
│   │  • Webcam    │────▶│  OpenCV    ┌─────────────────────┐       │  │
│   │  • Video     │     │  Capture ──▶│ YOLOv8 Detector    │       │  │
│   │    File      │     │           │ │ (Object Detection) │       │  │
│   └──────────────┘     │           │ └────────┬────────────┘       │  │
│                        │           │          │                    │  │
│                        │           │ ┌────────▼────────────┐       │  │
│                        │           └▶│ Optical Flow        │       │  │
│                        │             │ (Motion Analysis)   │       │  │
│                        │             └────────┬────────────┘       │  │
│                        │                      │                    │  │
│                        │             ┌────────▼────────────┐       │  │
│                        │             │ Frame Merger        │       │  │
│                        │             │ (Overlay Composer)  │       │  │
│                        │             └────────┬────────────┘       │  │
│                        └──────────────────────┼──────────────────┘  │
│                                               │                      │
│                          ┌────────────────────┼─────────────────┐    │
│                          │                    │                 │    │
│                  ┌───────▼──────┐   ┌────────▼──────┐  ┌──────▼──┐ │
│                  │ FastAPI      │   │ Streamlit     │  │ SQLite  │ │
│                  │ REST API     │   │ Dashboard     │  │ Logger  │ │
│                  │ + MJPEG      │   │ (Live UI)     │  │ (DB)    │ │
│                  └──────────────┘   └───────────────┘  └─────────┘ │
│                                                                      │
└──────────────────────────────────────────────────────────────────────┘

---

Installation

1. Clone the repository

git clone https://github.com/yourusername/VisionOps.git
cd VisionOps

2. Create a virtual environment (recommended)

python3 -m venv venv
source venv/bin/activate       # Linux/macOS
# or
venv\Scripts\activate          # Windows

3. Install dependencies

pip install -r requirements.txt

4. Verify installation

python -c "from ultralytics import YOLO; print('YOLOv8 OK')"
python -c "import cv2; print(f'OpenCV {cv2.__version__} OK')"
python -c "import fastapi; print('FastAPI OK')"

Note: The YOLOv8 nano model (yolov8n.pt) is automatically downloaded on first run (~6 MB).

---

Running the Project

Step 1: Start the FastAPI Backend

# From the VisionOps/ directory
uvicorn main:app --host 0.0.0.0 --port 8000 --reload

The API will be available at http://localhost:8000
Swagger docs: http://localhost:8000/docs

Step 2: Start the Streamlit Dashboard

# In a separate terminal
streamlit run dashboard.py --server.port 8501

The dashboard will open at http://localhost:8501

Step 3: Test the /detect Endpoint

# Upload a sample image for detection
curl -X POST "http://localhost:8000/detect" \
     -F "file=@samples/test_image.jpg" \
     | python -m json.tool

Optional: Run Dataset Augmentation

# Place images in samples/ directory, then:
python augment_dataset.py --count 10

---

API Reference

Method	Endpoint	Description	Response Type
GET	/	Health check — status + uptime	JSON
GET	/stream	MJPEG live annotated video stream	MJPEG Stream
POST	/detect	Upload image → detections + motion score	JSON
GET	/stats	Session statistics (frames, objects, FPS)	JSON
GET	/events	Recent detection events (supports ?class_filter=)	JSON
POST	/config	Update confidence, flow mode, source	JSON

Example /detect Response

{
  "detections": [
    {
      "class_name": "person",
      "confidence": 0.87,
      "bbox": [120.5, 45.2, 380.1, 490.8]
    }
  ],
  "motion_score": 23.45,
  "object_counts": {"person": 1},
  "processing_time_ms": 45.23,
  "image_size": {"height": 720, "width": 1280}
}

---

Configuration

All settings are centralized in utils/config.py:

Parameter	Default	Description
MODEL_PATH	yolov8n.pt	YOLOv8 model weights file
CONFIDENCE_THRESHOLD	0.45	Minimum detection confidence
INPUT_SIZE	(640, 640)	Model input resolution
FLOW_MODE	dense	Optical flow mode (dense / sparse)
MAX_KEYPOINTS	100	Max keypoints for sparse flow
MOTION_THRESHOLD	2.0	Minimum magnitude for high-motion zones
DB_PATH	db/visionops.db	SQLite database file path
API_HOST	0.0.0.0	FastAPI bind address
API_PORT	8000	FastAPI port
STREAMLIT_PORT	8501	Streamlit dashboard port
STREAM_FPS_TARGET	30	Target frames per second for streaming
LOG_BATCH_SIZE	10	Events batched before DB write

---

Tech Stack

Technology	Role
Python 3.10+	Core language
OpenCV	Video capture, frame processing
Ultralytics YOLOv8	Object detection (nano model)
Optical Flow	Motion analysis (Farneback + LK)
FastAPI	REST API server
Streamlit	Frontend dashboard
NumPy	Array operations
Matplotlib	Charts and visualizations
Albumentations	Data augmentation
SQLite	Event logging
Uvicorn	ASGI server

---

Project Structure

VisionOps/
├── main.py                  # FastAPI app entry point
├── dashboard.py             # Streamlit dashboard
├── augment_dataset.py       # Standalone augmentation script
├── core/
│   ├── __init__.py
│   ├── detector.py          # YOLOv8 detection logic
│   ├── motion.py            # Optical Flow (Dense + Sparse)
│   ├── pipeline.py          # Combined detection + motion pipeline
│   └── augment.py           # Albumentations preprocessing
├── api/
│   ├── __init__.py
│   └── routes.py            # FastAPI route definitions
├── db/
│   ├── __init__.py
│   └── logger.py            # SQLite event logger
├── utils/
│   ├── __init__.py
│   ├── visualizer.py        # Drawing bboxes, flow, overlays
│   └── config.py            # All configuration constants
├── samples/                 # Sample videos/images for testing
├── requirements.txt
├── README.md
└── .gitignore

---

Future Improvements

• 🚀 TensorRT Optimization — Export YOLOv8 to TensorRT for 5-10x faster inference on NVIDIA GPUs
• 📹 Multi-Camera Support — Process multiple video streams simultaneously with load balancing
• 📡 RTSP Stream Support — Connect to IP cameras and network video recorders
• 🧠 Custom Model Training — Fine-tune YOLOv8 on domain-specific datasets via the augmentation pipeline
• 📊 Prometheus + Grafana — Enterprise-grade monitoring and alerting
• 🐳 Docker Deployment — Containerized deployment with docker-compose
• 🔔 Alert System — Configurable alerts for specific object classes or motion thresholds
• ☁️ Cloud Deployment — AWS/GCP deployment guides with auto-scaling

---

License

MIT License — see LICENSE for details.

---

VisionOps — Built with ❤️ using YOLOv8, OpenCV, FastAPI, and Streamlit