bartool
cdeac53555
- Implemented CameraSettingsDialog to manage UVC and Qt camera controls. - Integrated UVC parameter sliders and auto controls for brightness, contrast, saturation, hue, sharpness, gamma, white balance, backlight compensation, and exposure. - Added functionality to change white balance and exposure settings via Qt controls. - Updated MainWindow to open CameraSettingsDialog and manage UVC controller lifecycle. - Enhanced AppMenuBar to include a Camera Settings option. - Created tests for UVC controller abstraction layer and parameter info. - Documented camera specifications and supported features in new markdown files.
199 lines
7.2 KiB
Python
199 lines
7.2 KiB
Python
"""Menu bar — camera, video format and debug controls."""
|
|
|
|
from __future__ import annotations
|
|
|
|
import logging
|
|
|
|
from PySide6.QtCore import Signal
|
|
from PySide6.QtGui import QAction, QActionGroup
|
|
from PySide6.QtWidgets import QMenuBar, QWidget
|
|
|
|
from app.camera.camera_enumerator import CameraFormat, CameraInfo
|
|
from app.logging_setup import set_console_level
|
|
|
|
logger = logging.getLogger(__name__)
|
|
|
|
|
|
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
|
|
"""
|
|
|
|
camera_selected = Signal(object) # CameraInfo
|
|
format_selected = Signal(object) # CameraFormat
|
|
reconnect_requested = Signal()
|
|
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:
|
|
"""Populate the Camera menu with discovered devices."""
|
|
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:
|
|
"""Populate the Resolution submenu with full format entries."""
|
|
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:
|
|
"""Mark the given format as checked in the Resolution menu."""
|
|
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 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)
|
|
|
|
# ------------------------------------------------------------------
|
|
# Menu construction
|
|
# ------------------------------------------------------------------
|
|
|
|
def _build_menus(self) -> None:
|
|
# 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 (camera controls)
|
|
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
|
|
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:
|
|
"""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)
|
|
|
|
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_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)
|