bartool/duck-preview
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

feat: Add video playback functionality and inference support

Browse Source 
- Introduced VideoPlayer class to handle local video playback, emitting frames via frame_ready signal.
- Updated MainWindow to switch between camera and video sources, integrating video playback controls.
- Enhanced AppMenuBar with options to open video files and manage inference models.
- Implemented BboxOverlay for displaying detection results on video frames.
- Added InferenceManager to manage YOLO inference in a separate process, with error handling and restart logic.
- Created tests for BboxOverlay and InferenceManager to ensure functionality and robustness.
- Updated pyproject.toml to include optional dependencies for inference support.
This commit is contained in:
bartool
2026-05-13 21:30:13 +02:00
parent ac51498b7a
commit e9b474b1ed
14 changed files with 1524 additions and 49 deletions
Download Patch File Download Diff File Expand all files Collapse all files

198
app/ui/main_window.py
View File

@@ -6,7 +6,7 @@ import logging
from pathlib import Path
from PySide6.QtCore import QTimer
from PySide6.QtWidgets import QLabel, QMainWindow, QSizePolicy, QStatusBar
from PySide6.QtWidgets import QLabel, QMainWindow, QMessageBox, QSizePolicy, QStatusBar
from app.camera.camera_enumerator import CameraEnumerator, CameraFormat, CameraInfo
from app.camera.camera_service import CameraService
@@ -14,6 +14,8 @@ from app.camera.uvc import make_uvc_controller
from app.camera.uvc.base import UvcControllerBase
from app.camera.uvc.stub import NullUvcController
from app.config import APP_NAME, APP_VERSION
from app.inference.bbox_overlay import BboxOverlay
from app.inference.worker_manager import InferenceManager
from app.overlay.telemetry_overlay import TelemetryOverlay
from app.pipeline.frame_dispatcher import FrameDispatcher
from app.telemetry.csv_logger import CsvTelemetryLogger
@@ -21,6 +23,7 @@ from app.telemetry.telemetry_collector import TelemetryCollector
from app.ui.camera_settings_dialog import CameraSettingsDialog
from app.ui.camera_view import CameraView
from app.ui.menu_bar import AppMenuBar
from app.video.video_player import VideoPlayer
logger = logging.getLogger(__name__)
@@ -29,19 +32,25 @@ class MainWindow(QMainWindow):
"""
Top-level application window.
Rendering architecture:
QVideoWidget is intentionally NOT used — on Windows its native HWND
surface occludes all sibling/child QWidgets regardless of z-order.
CameraView is a plain QWidget that renders frames and overlay layers
in a single paintEvent pass.
Frame source (exclusive):
• CameraService — live camera (default)
• VideoPlayer — local video file
Inference pipeline (optional):
InferenceManager runs YOLO in a separate process.
Frames submitted via FrameDispatcher subscriber (drop_if_busy).
Results displayed by BboxOverlay.
Signal flow:
CameraService.frame_ready
[CameraService | VideoPlayer].frame_ready(QVideoFrame)
→ FrameDispatcher.dispatch
→ CameraView.on_frame (render frame)
→ TelemetryCollector.on_frame (measure metrics)
→ TelemetryOverlay.on_metrics_updated (overlay data)
→ CsvTelemetryLogger.on_metrics_updated (CSV file)
→ CameraView.on_frame (render)
→ TelemetryCollector.on_frame (metrics)
→ TelemetryOverlay (HUD)
→ CsvTelemetryLogger (CSV)
→ InferenceManager.submit_frame (drop_if_busy, optional)
→ [worker process] YOLO
→ BboxOverlay.on_detections (draw boxes)
"""
def __init__(self, log_path: Path | None = None) -> None:
@@ -51,22 +60,28 @@ class MainWindow(QMainWindow):
self.setMinimumSize(640, 480)
self.resize(1280, 720)
# --- Core pipeline components ---
# --- Core pipeline ---
self._camera_service = CameraService(self)
self._video_player = VideoPlayer(self)
self._dispatcher = FrameDispatcher(self)
self._telemetry = TelemetryCollector(parent=self)
self._inference = InferenceManager(self)
# --- UVC controller (platform-specific, lazy-opened per camera) ---
# Track which source is active
self._video_source_active: bool = False
self._current_camera: CameraInfo | None = None
# --- UVC ---
self._uvc: UvcControllerBase = NullUvcController()
# --- CSV telemetry logger ---
# --- CSV logger ---
self._csv_logger: CsvTelemetryLogger | None = None
if log_path is not None:
csv_path = log_path.with_suffix(".csv")
self._csv_logger = CsvTelemetryLogger(csv_path)
logger.info("Telemetry CSV: %s", csv_path.resolve())
# --- Camera view (central widget) ---
# --- Camera view ---
self._camera_view = CameraView(self)
self._camera_view.setSizePolicy(
QSizePolicy.Policy.Expanding, QSizePolicy.Policy.Expanding
@@ -75,7 +90,10 @@ class MainWindow(QMainWindow):
# --- Overlay layers ---
self._telemetry_overlay = TelemetryOverlay()
self._bbox_overlay = BboxOverlay()
self._camera_view.add_overlay_layer(self._telemetry_overlay)
self._camera_view.add_overlay_layer(self._bbox_overlay)
self._bbox_overlay.visible = False # hidden until inference enabled
# --- Menu bar ---
self._menu = AppMenuBar(self)
@@ -92,7 +110,6 @@ class MainWindow(QMainWindow):
# --- Wire signals ---
self._wire_signals()
# --- Enumerate cameras and start ---
QTimer.singleShot(0, self._initialise_cameras)
# ------------------------------------------------------------------
@@ -101,21 +118,19 @@ class MainWindow(QMainWindow):
def _initialise_cameras(self) -> None:
cameras = CameraEnumerator.list_cameras()
if not cameras:
self._status_label.setText("No cameras found")
logger.warning("No cameras detected")
return
self._menu.populate_cameras(cameras)
default = CameraEnumerator.default_camera()
start_cam = default if default is not None else cameras[0]
self._menu.populate_formats(start_cam)
self._start_camera(start_cam)
def _start_camera(self, cam: CameraInfo) -> None:
self._current_camera = cam
self._telemetry.reset_counters()
self._camera_service.start(cam)
self._menu.set_active_camera(cam)
@@ -123,12 +138,10 @@ class MainWindow(QMainWindow):
self._open_uvc(cam)
def _open_uvc(self, cam: CameraInfo) -> None:
"""Open or reopen the UVC controller for the given camera."""
if self._uvc.is_open():
self._uvc.close()
ctrl = make_uvc_controller(cam.name)
if not ctrl.is_open():
# factory may return a pre-opened controller or a NullUvcController
ctrl.open(cam.name)
self._uvc = ctrl
@@ -137,38 +150,73 @@ class MainWindow(QMainWindow):
# ------------------------------------------------------------------
def _wire_signals(self) -> None:
# CameraService → FrameDispatcher
# ---- Active source → dispatcher ----
# (connected dynamically in _switch_to_camera / _switch_to_video)
self._camera_service.frame_ready.connect(self._dispatcher.dispatch)
# FrameDispatcher → CameraView (render) — drop if busy
# ---- Dispatcher fans out to all consumers ----
self._dispatcher.subscribe(self._camera_view.on_frame, drop_if_busy=True)
# FrameDispatcher → TelemetryCollector — never drop
self._dispatcher.subscribe(self._telemetry.on_frame, drop_if_busy=False)
# InferenceManager subscriber added/removed dynamically on toggle
# TelemetryCollector → overlay
# ---- Telemetry ----
self._telemetry.metrics_updated.connect(
self._telemetry_overlay.on_metrics_updated
)
# TelemetryCollector → CSV logger (throttled internally)
if self._csv_logger is not None:
self._telemetry.metrics_updated.connect(self._csv_logger.on_metrics_updated)
# CameraService → TelemetryCollector: keep target FPS in sync
self._camera_service.format_changed.connect(self._telemetry.set_target_fps)
# CameraService status
# ---- Camera service status ----
self._camera_service.camera_started.connect(self._on_camera_started)
self._camera_service.camera_stopped.connect(self._on_camera_stopped)
self._camera_service.camera_error.connect(self._on_camera_error)
# Menu signals
# ---- Video player status ----
self._video_player.playback_started.connect(self._on_playback_started)
self._video_player.playback_stopped.connect(self._on_playback_stopped)
self._video_player.playback_error.connect(self._on_playback_error)
# ---- InferenceManager ----
self._inference.detections_ready.connect(self._bbox_overlay.on_detections)
self._inference.inference_started.connect(self._on_inference_started)
self._inference.inference_stopped.connect(self._on_inference_stopped)
self._inference.inference_error.connect(self._on_inference_error)
# ---- Menu ----
self._menu.camera_selected.connect(self._on_camera_selected)
self._menu.format_selected.connect(self._on_format_selected)
self._menu.reconnect_requested.connect(self._camera_service.reconnect)
self._menu.overlay_toggled.connect(self._camera_view.set_all_overlays_visible)
self._menu.camera_settings_requested.connect(self._on_settings_requested)
self._menu.video_file_selected.connect(self._on_video_selected)
self._menu.video_closed.connect(self._on_video_closed)
self._menu.model_file_selected.connect(self._on_model_selected)
self._menu.inference_toggled.connect(self._on_inference_toggled)
# ------------------------------------------------------------------
# Source switching
# ------------------------------------------------------------------
def _switch_to_camera(self) -> None:
"""Disconnect VideoPlayer, connect CameraService to dispatcher."""
try:
self._video_player.frame_ready.disconnect(self._dispatcher.dispatch)
except RuntimeError:
pass
self._camera_service.frame_ready.connect(self._dispatcher.dispatch)
self._video_source_active = False
self._menu.set_video_source_active(False)
def _switch_to_video(self) -> None:
"""Disconnect CameraService, connect VideoPlayer to dispatcher."""
try:
self._camera_service.frame_ready.disconnect(self._dispatcher.dispatch)
except RuntimeError:
pass
self._video_player.frame_ready.connect(self._dispatcher.dispatch)
self._video_source_active = True
self._menu.set_video_source_active(True)
# ------------------------------------------------------------------
# Camera status slots
@@ -187,11 +235,48 @@ class MainWindow(QMainWindow):
self._status_label.setText(f"Error: {message}")
logger.error("Camera error: %s", message)
# ------------------------------------------------------------------
# Video player slots
# ------------------------------------------------------------------
def _on_playback_started(self) -> None:
path = self._video_player.current_path or ""
name = Path(path).name if path else "video"
self._status_label.setText(f"Playing: {name}")
def _on_playback_stopped(self) -> None:
self._status_label.setText("Playback finished")
def _on_playback_error(self, message: str) -> None:
self._status_label.setText(f"Video error: {message}")
logger.error(message)
# ------------------------------------------------------------------
# Inference slots
# ------------------------------------------------------------------
def _on_inference_started(self) -> None:
self._status_label.setText("Inference running")
self._menu.set_inference_checked(True)
def _on_inference_stopped(self) -> None:
self._bbox_overlay.clear()
def _on_inference_error(self, message: str) -> None:
logger.error("Inference: %s", message)
self._menu.set_inference_available(False)
self._menu.set_inference_checked(False)
self._bbox_overlay.visible = False
QMessageBox.critical(self, "Inference Error", message)
# ------------------------------------------------------------------
# Menu action slots
# ------------------------------------------------------------------
def _on_camera_selected(self, cam: CameraInfo) -> None:
if self._video_source_active:
self._video_player.stop()
self._switch_to_camera()
self._start_camera(cam)
def _on_format_selected(self, fmt: CameraFormat) -> None:
@@ -209,12 +294,61 @@ class MainWindow(QMainWindow):
dlg = CameraSettingsDialog(qt_cam, self._uvc, parent=self)
dlg.exec()
def _on_video_selected(self, path: str) -> None:
"""Switch source to video file."""
self._camera_service.stop()
self._switch_to_video()
self._video_player.play(path)
logger.info("Video source: %s", path)
def _on_video_closed(self) -> None:
"""Return to camera source."""
self._video_player.stop()
self._switch_to_camera()
if self._current_camera is not None:
self._start_camera(self._current_camera)
logger.info("Returned to camera source")
def _on_model_selected(self, path: str) -> None:
"""Load YOLO model into inference manager."""
name = Path(path).name
logger.info("Loading model: %s", path)
self._status_label.setText(f"Loading model: {name}\u2026")
self._inference.start(path)
self._menu.set_model_label(name)
self._menu.set_inference_available(True)
self._menu.set_inference_checked(False) # user must explicitly enable
def _on_inference_toggled(self, enabled: bool) -> None:
if enabled:
if not self._inference.is_running:
# shouldn't happen but be safe
logger.warning("Inference toggle on but manager not running")
self._menu.set_inference_checked(False)
return
self._inference.resume()
self._dispatcher.subscribe(
self._inference.submit_frame, drop_if_busy=True
)
self._bbox_overlay.visible = True
self._status_label.setText("Inference enabled")
logger.info("Inference enabled")
else:
self._inference.pause()
self._dispatcher.unsubscribe(self._inference.submit_frame)
self._bbox_overlay.clear()
self._bbox_overlay.visible = False
self._status_label.setText("Inference disabled")
logger.info("Inference disabled")
# ------------------------------------------------------------------
# Qt overrides
# ------------------------------------------------------------------
def closeEvent(self, event) -> None: # noqa: N802
self._inference.stop()
self._camera_service.stop()
self._video_player.stop()
if self._uvc.is_open():
self._uvc.close()
if self._csv_logger is not None:

114
app/ui/menu_bar.py
View File

@@ -1,4 +1,4 @@
"""Menu bar — camera, video format and debug controls."""
"""Menu bar — File, Camera, Video format, Image, Model and Debug controls."""
from __future__ import annotations
@@ -6,9 +6,10 @@ import logging
from PySide6.QtCore import Signal
from PySide6.QtGui import QAction, QActionGroup
from PySide6.QtWidgets import QMenuBar, QWidget
from PySide6.QtWidgets import QFileDialog, QMenuBar, QWidget
from app.camera.camera_enumerator import CameraFormat, CameraInfo
from app.config import MODEL_FILE_EXTENSIONS, VIDEO_FILE_EXTENSIONS
from app.logging_setup import set_console_level
logger = logging.getLogger(__name__)
@@ -19,17 +20,32 @@ class AppMenuBar(QMenuBar):
Application menu bar.
Signals:
camera_selected(CameraInfo) — user picked a camera
format_selected(CameraFormat) — user picked a full format (res+fps+pixel)
reconnect_requested() — user hit Reconnect
overlay_toggled(bool) — overlay show/hide
log_toggled(bool) — console logging on/off
camera_settings_requested() — user opened Image Settings dialog
video_file_selected(str) — user picked a video file path
video_closed() — user chose to close video and return to camera
model_file_selected(str) — user picked a .pt model file path
inference_toggled(bool) — user toggled inference on/off
camera_selected(CameraInfo)
format_selected(CameraFormat)
reconnect_requested()
overlay_toggled(bool)
log_toggled(bool)
camera_settings_requested()
"""
# File / video
video_file_selected = Signal(str)
video_closed = Signal()
# Model / inference
model_file_selected = Signal(str)
inference_toggled = Signal(bool)
# Camera
camera_selected = Signal(object) # CameraInfo
format_selected = Signal(object) # CameraFormat
reconnect_requested = Signal()
# View / debug
overlay_toggled = Signal(bool)
log_toggled = Signal(bool)
camera_settings_requested = Signal()
@@ -48,7 +64,6 @@ class AppMenuBar(QMenuBar):
# ------------------------------------------------------------------
def populate_cameras(self, cameras: list[CameraInfo]) -> None:
"""Populate the Camera menu with discovered devices."""
self._cameras = cameras
menu = self._camera_menu
@@ -71,7 +86,6 @@ class AppMenuBar(QMenuBar):
self._camera_group.actions()[0].setChecked(True)
def populate_formats(self, camera_info: CameraInfo) -> None:
"""Populate the Resolution submenu with full format entries."""
self._populate_format_menu(camera_info)
def set_active_camera(self, camera_info: CameraInfo) -> None:
@@ -83,7 +97,6 @@ class AppMenuBar(QMenuBar):
return
def set_active_format(self, fmt: CameraFormat) -> None:
"""Mark the given format as checked in the Resolution menu."""
if self._format_group is None:
return
for action in self._format_group.actions():
@@ -98,34 +111,80 @@ class AppMenuBar(QMenuBar):
return
def set_log_file_path(self, path: str) -> None:
"""Display the log file path as a disabled menu item in Debug menu."""
display = path if len(path) <= 60 else "\u2026" + path[-57:]
self._log_file_action.setText(f"Log: {display}")
self._log_file_action.setToolTip(path)
def set_video_source_active(self, is_video: bool) -> None:
"""Update File menu state when source switches between camera and video."""
self._close_video_action.setEnabled(is_video)
def set_inference_available(self, available: bool) -> None:
"""Enable/disable the inference toggle (requires model to be loaded)."""
self._inference_toggle_action.setEnabled(available)
def set_inference_checked(self, checked: bool) -> None:
self._inference_toggle_action.setChecked(checked)
def set_model_label(self, name: str) -> None:
"""Show loaded model name as disabled info item."""
self._model_info_action.setText(f"Model: {name}")
# ------------------------------------------------------------------
# Menu construction
# ------------------------------------------------------------------
def _build_menus(self) -> None:
# Camera menu
# --- File menu ---
file_menu = self.addMenu("File")
open_video_action = QAction("Open Video\u2026", self)
open_video_action.triggered.connect(self._on_open_video)
file_menu.addAction(open_video_action)
self._close_video_action = QAction("Close Video", self)
self._close_video_action.setEnabled(False)
self._close_video_action.triggered.connect(self.video_closed)
file_menu.addAction(self._close_video_action)
# --- Camera menu ---
self._camera_menu = self.addMenu("Camera")
self._cam_separator = self._camera_menu.addSeparator()
self._reconnect_action = QAction("Reconnect", self)
self._reconnect_action.triggered.connect(self.reconnect_requested)
self._camera_menu.addAction(self._reconnect_action)
# Video menu
# --- Video menu ---
self._video_menu = self.addMenu("Video")
self._res_menu = self._video_menu.addMenu("Resolution")
# Image menu (camera controls)
# --- Image menu ---
self._image_menu = self.addMenu("Image")
self._settings_action = QAction("Camera Settings\u2026", self)
self._settings_action.triggered.connect(self.camera_settings_requested)
self._image_menu.addAction(self._settings_action)
# Debug menu
# --- Model menu ---
model_menu = self.addMenu("Model")
load_model_action = QAction("Load Model\u2026", self)
load_model_action.triggered.connect(self._on_load_model)
model_menu.addAction(load_model_action)
self._inference_toggle_action = QAction("Enable Inference", self)
self._inference_toggle_action.setCheckable(True)
self._inference_toggle_action.setChecked(False)
self._inference_toggle_action.setEnabled(False) # enabled after model loaded
self._inference_toggle_action.toggled.connect(self.inference_toggled)
model_menu.addAction(self._inference_toggle_action)
model_menu.addSeparator()
self._model_info_action = QAction("Model: (none)", self)
self._model_info_action.setEnabled(False)
model_menu.addAction(self._model_info_action)
# --- Debug menu ---
debug_menu = self.addMenu("Debug")
self._overlay_action = QAction("Show Overlay", self)
@@ -147,7 +206,6 @@ class AppMenuBar(QMenuBar):
debug_menu.addAction(self._log_file_action)
def _populate_format_menu(self, camera_info: CameraInfo) -> None:
"""Build Resolution submenu: one action per unique (W, H, FPS, pixel_format)."""
self._res_menu.clear()
self._format_group = QActionGroup(self)
self._format_group.setExclusive(True)
@@ -173,6 +231,28 @@ class AppMenuBar(QMenuBar):
# Slots
# ------------------------------------------------------------------
def _on_open_video(self) -> None:
path, _ = QFileDialog.getOpenFileName(
self.parentWidget(),
"Open Video File",
"",
VIDEO_FILE_EXTENSIONS,
)
if path:
logger.debug("Video file selected: %s", path)
self.video_file_selected.emit(path)
def _on_load_model(self) -> None:
path, _ = QFileDialog.getOpenFileName(
self.parentWidget(),
"Load YOLO Model",
"",
MODEL_FILE_EXTENSIONS,
)
if path:
logger.debug("Model file selected: %s", path)
self.model_file_selected.emit(path)
def _on_camera_action(self) -> None:
action = self.sender()
if action is None: