bartool
e9b474b1ed
- 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.
279 lines
9.9 KiB
Python
279 lines
9.9 KiB
Python
"""Menu bar — File, Camera, Video format, Image, Model and Debug controls."""
|
|
|
|
from __future__ import annotations
|
|
|
|
import logging
|
|
|
|
from PySide6.QtCore import Signal
|
|
from PySide6.QtGui import QAction, QActionGroup
|
|
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__)
|
|
|
|
|
|
class AppMenuBar(QMenuBar):
|
|
"""
|
|
Application menu bar.
|
|
|
|
Signals:
|
|
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()
|
|
|
|
def __init__(self, parent: QWidget | None = None) -> None:
|
|
super().__init__(parent)
|
|
|
|
self._camera_group: QActionGroup | None = None
|
|
self._format_group: QActionGroup | None = None
|
|
self._cameras: list[CameraInfo] = []
|
|
|
|
self._build_menus()
|
|
|
|
# ------------------------------------------------------------------
|
|
# Public API
|
|
# ------------------------------------------------------------------
|
|
|
|
def populate_cameras(self, cameras: list[CameraInfo]) -> None:
|
|
self._cameras = cameras
|
|
menu = self._camera_menu
|
|
|
|
for action in list(menu.actions()):
|
|
if action not in (self._reconnect_action, self._cam_separator):
|
|
menu.removeAction(action)
|
|
|
|
self._camera_group = QActionGroup(self)
|
|
self._camera_group.setExclusive(True)
|
|
|
|
for cam in cameras:
|
|
action = QAction(cam.name, self)
|
|
action.setCheckable(True)
|
|
action.setData(cam)
|
|
self._camera_group.addAction(action)
|
|
menu.insertAction(self._cam_separator, action)
|
|
action.triggered.connect(self._on_camera_action)
|
|
|
|
if cameras:
|
|
self._camera_group.actions()[0].setChecked(True)
|
|
|
|
def populate_formats(self, camera_info: CameraInfo) -> None:
|
|
self._populate_format_menu(camera_info)
|
|
|
|
def set_active_camera(self, camera_info: CameraInfo) -> None:
|
|
if self._camera_group is None:
|
|
return
|
|
for action in self._camera_group.actions():
|
|
if action.data() is camera_info:
|
|
action.setChecked(True)
|
|
return
|
|
|
|
def set_active_format(self, fmt: CameraFormat) -> None:
|
|
if self._format_group is None:
|
|
return
|
|
for action in self._format_group.actions():
|
|
f: CameraFormat = action.data()
|
|
if (
|
|
f.width == fmt.width
|
|
and f.height == fmt.height
|
|
and abs(f.max_fps - fmt.max_fps) < 0.5
|
|
and f.pixel_format == fmt.pixel_format
|
|
):
|
|
action.setChecked(True)
|
|
return
|
|
|
|
def set_log_file_path(self, path: str) -> None:
|
|
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:
|
|
# --- 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 ---
|
|
self._video_menu = self.addMenu("Video")
|
|
self._res_menu = self._video_menu.addMenu("Resolution")
|
|
|
|
# --- 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)
|
|
|
|
# --- 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)
|
|
self._overlay_action.setCheckable(True)
|
|
self._overlay_action.setChecked(True)
|
|
self._overlay_action.toggled.connect(self.overlay_toggled)
|
|
debug_menu.addAction(self._overlay_action)
|
|
|
|
self._log_action = QAction("Console Logging", self)
|
|
self._log_action.setCheckable(True)
|
|
self._log_action.setChecked(False)
|
|
self._log_action.toggled.connect(self._on_log_toggled)
|
|
debug_menu.addAction(self._log_action)
|
|
|
|
debug_menu.addSeparator()
|
|
|
|
self._log_file_action = QAction("Log: (not started)", self)
|
|
self._log_file_action.setEnabled(False)
|
|
debug_menu.addAction(self._log_file_action)
|
|
|
|
def _populate_format_menu(self, camera_info: CameraInfo) -> None:
|
|
self._res_menu.clear()
|
|
self._format_group = QActionGroup(self)
|
|
self._format_group.setExclusive(True)
|
|
|
|
for fmt in camera_info.formats:
|
|
label = (
|
|
f"{fmt.width}\u00d7{fmt.height}"
|
|
f" @ {fmt.max_fps:.4g}fps"
|
|
f" ({fmt.pixel_format})"
|
|
)
|
|
action = QAction(label, self)
|
|
action.setCheckable(True)
|
|
action.setData(fmt)
|
|
self._format_group.addAction(action)
|
|
self._res_menu.addAction(action)
|
|
action.triggered.connect(self._on_format_action)
|
|
|
|
actions = self._format_group.actions()
|
|
if actions:
|
|
actions[0].setChecked(True)
|
|
|
|
# ------------------------------------------------------------------
|
|
# 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:
|
|
return
|
|
cam: CameraInfo = action.data()
|
|
logger.debug("Camera selected: %s", cam.name)
|
|
self.camera_selected.emit(cam)
|
|
self._populate_format_menu(cam)
|
|
|
|
def _on_format_action(self) -> None:
|
|
action = self.sender()
|
|
if action is None:
|
|
return
|
|
fmt: CameraFormat = action.data()
|
|
logger.debug(
|
|
"Format selected: %dx%d @ %.4g fps (%s)",
|
|
fmt.width, fmt.height, fmt.max_fps, fmt.pixel_format,
|
|
)
|
|
self.format_selected.emit(fmt)
|
|
|
|
def _on_log_toggled(self, enabled: bool) -> None:
|
|
set_console_level(enabled)
|
|
self.log_toggled.emit(enabled)
|