opencv-computer-vision

OpenCV Computer Vision & Spatial AI

Production implementations for GPU-accelerated image processing, multi-threaded RTSP video streaming, feature tracking, camera calibration, and 3D spatial position estimation.

1. Computer Vision Architecture

+-------------------+      +--------------------------------+      +---------------------------+
| RTSP IP Camera    | ---> | Multi-Threaded VideoReader     | ---> | CUDA GpuMat Memory Transfer|
| (1080p @ 60 FPS)  |      | (Thread-safe Queue Buffer)     |      | (Zero CPU-GPU copy bottleneck)|
+-------------------+      +--------------------------------+      +---------------------------+
                                                                                 |
                                                                                 v
+-------------------+      +--------------------------------+      +---------------------------+
| Spatial 3D Pose   | <--- | Feature Detection & PnP        | <--- | GPU Pre-processing        |
| (X, Y, Z, R, P, Y)|      | (SolvePnP / ArUco Marker)      |      | (Threshold, Blur, Contours)|
+-------------------+      +--------------------------------+      +---------------------------+

2. Multi-Threaded RTSP Stream Reader (rtsp_reader.py)

A non-blocking, thread-safe RTSP video ingest pipeline with automatic reconnect logic to prevent frame dropping.

import cv2
import threading
import queue
import time
import logging

logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)

class RobustVideoSubscriber:
    def __init__(self, rtsp_url: str, max_queue_size: int = 5):
        self.rtsp_url = rtsp_url
        self.frame_queue = queue.Queue(maxsize=max_queue_size)
        self.stopped = False
        self.cap = None
        self.thread = threading.Thread(target=self._update, daemon=True)

    def start(self):
        self._connect()
        self.thread.start()
        return self

    def _connect(self):
        logger.info(f"Connecting to RTSP stream: {self.rtsp_url}")
        self.cap = cv2.VideoCapture(self.rtsp_url, cv2.CAP_FFMPEG)
        self.cap.set(cv2.CAP_PROP_BUFFERSIZE, 1) # Force minimal buffering latency

    def _update(self):
        while not self.stopped:
            if not self.cap or not self.cap.isOpened():
                logger.warning("Stream disconnected. Attempting reconnect...")
                time.sleep(2.0)
                self._connect()
                continue

            grabbed, frame = self.cap.read()
            if not grabbed:
                logger.warning("Failed to grab frame. Reconnecting...")
                self.cap.release()
                time.sleep(1.0)
                self._connect()
                continue

            # Drop oldest frame if queue is full to enforce real-time processing
            if self.frame_queue.full():
                try:
                    self.frame_queue.get_nowait()
                except queue.Empty:
                    pass

            self.frame_queue.put(frame)

    def read(self):
        """Fetch latest frame non-blocking."""
        try:
            return True, self.frame_queue.get(timeout=1.0)
        except queue.Empty:
            return False, None

    def stop(self):
        self.stopped = True
        if self.thread.is_alive():
            self.thread.join()
        if self.cap:
            self.cap.release()
        logger.info("RTSP subscriber stopped.")