feat: Add video playback functionality and inference support
- 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:
@@ -27,3 +27,20 @@ DISPATCHER_MAX_QUEUE_SIZE = 2 # max pending frames per slow subscriber before d
|
||||
LOG_DIR = Path("logs") # relative to CWD (project root)
|
||||
MAX_LOG_FILES = 20 # oldest sessions are deleted when exceeded
|
||||
TELEMETRY_CSV_INTERVAL_S = 5.0 # how often a CSV row is written (seconds)
|
||||
|
||||
# Inference worker
|
||||
INFERENCE_WORKER_TIMEOUT_S = 10.0 # seconds without response before watchdog fires
|
||||
INFERENCE_MAX_RESTARTS = 3 # max auto-restart attempts before giving up
|
||||
INFERENCE_POLL_INTERVAL_MS = 50 # how often GUI thread polls output queue (ms)
|
||||
INFERENCE_WATCHDOG_INTERVAL_MS = 2000 # how often watchdog checks process health (ms)
|
||||
|
||||
# BBox overlay
|
||||
BBOX_COLOR = (0, 220, 60, 255) # RGBA — vivid green
|
||||
BBOX_LABEL_BG_COLOR = (0, 220, 60, 200) # RGBA — semi-transparent green for label bg
|
||||
BBOX_LABEL_TEXT_COLOR = (0, 0, 0, 255) # RGBA — black text on green bg
|
||||
BBOX_LINE_WIDTH = 2
|
||||
BBOX_FONT_SIZE = 11
|
||||
|
||||
# Video file source
|
||||
VIDEO_FILE_EXTENSIONS = "Video Files (*.mp4 *.avi *.mov *.mkv *.m4v *.webm)"
|
||||
MODEL_FILE_EXTENSIONS = "YOLO Model (*.pt *.pth)"
|
||||
|
||||
0
app/inference/__init__.py
Normal file
0
app/inference/__init__.py
Normal file
154
app/inference/bbox_overlay.py
Normal file
154
app/inference/bbox_overlay.py
Normal file
@@ -0,0 +1,154 @@
|
||||
"""BboxOverlay — draws YOLO detection bounding boxes on the camera view."""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import logging
|
||||
from typing import NamedTuple
|
||||
|
||||
from PySide6.QtCore import QRect, QSize, Qt, Slot
|
||||
from PySide6.QtGui import QColor, QFont, QPainter, QPen
|
||||
|
||||
from app.config import (
|
||||
BBOX_COLOR,
|
||||
BBOX_FONT_SIZE,
|
||||
BBOX_LABEL_BG_COLOR,
|
||||
BBOX_LABEL_TEXT_COLOR,
|
||||
BBOX_LINE_WIDTH,
|
||||
)
|
||||
from app.overlay.overlay_layer import IOverlayLayer
|
||||
|
||||
logger = logging.getLogger(__name__)
|
||||
|
||||
|
||||
class Detection(NamedTuple):
|
||||
"""
|
||||
A single object detection result.
|
||||
|
||||
Coordinates (x1, y1, x2, y2) are in pixels of the *source frame*
|
||||
(i.e. the frame that was submitted to inference). BboxOverlay maps
|
||||
them to the letterboxed video_rect before drawing.
|
||||
"""
|
||||
|
||||
x1: float
|
||||
y1: float
|
||||
x2: float
|
||||
y2: float
|
||||
conf: float
|
||||
label: str
|
||||
|
||||
|
||||
class BboxOverlay(IOverlayLayer):
|
||||
"""
|
||||
Overlay layer that renders detection bounding boxes.
|
||||
|
||||
Usage:
|
||||
overlay = BboxOverlay()
|
||||
camera_view.add_overlay_layer(overlay)
|
||||
inference_manager.detections_ready.connect(overlay.on_detections)
|
||||
|
||||
Thread safety:
|
||||
on_detections() is called from the GUI thread (via Qt signal).
|
||||
paint() is also called from the GUI thread (paintEvent).
|
||||
No locks required.
|
||||
"""
|
||||
|
||||
def __init__(self) -> None:
|
||||
super().__init__()
|
||||
self._detections: list[Detection] = []
|
||||
self._source_size: QSize = QSize(0, 0)
|
||||
|
||||
self._pen = QPen(QColor(*BBOX_COLOR))
|
||||
self._pen.setWidth(BBOX_LINE_WIDTH)
|
||||
self._pen.setJoinStyle(Qt.PenJoinStyle.MiterJoin)
|
||||
|
||||
self._font = QFont("Monospace")
|
||||
self._font.setStyleHint(QFont.StyleHint.TypeWriter)
|
||||
self._font.setPointSize(BBOX_FONT_SIZE)
|
||||
self._font.setBold(True)
|
||||
|
||||
self._box_color = QColor(*BBOX_COLOR)
|
||||
self._bg_color = QColor(*BBOX_LABEL_BG_COLOR)
|
||||
self._text_color = QColor(*BBOX_LABEL_TEXT_COLOR)
|
||||
|
||||
# ------------------------------------------------------------------
|
||||
# Public API
|
||||
# ------------------------------------------------------------------
|
||||
|
||||
@Slot(object, object)
|
||||
def on_detections(
|
||||
self,
|
||||
detections: list[Detection],
|
||||
source_size: tuple[int, int],
|
||||
) -> None:
|
||||
"""
|
||||
Receive detection results from InferenceManager.
|
||||
|
||||
Args:
|
||||
detections: List of Detection namedtuples (pixel coords).
|
||||
source_size: (width, height) of the frame that was inferred.
|
||||
"""
|
||||
self._detections = detections
|
||||
self._source_size = QSize(*source_size)
|
||||
|
||||
def clear(self) -> None:
|
||||
"""Remove all currently displayed detections."""
|
||||
self._detections = []
|
||||
|
||||
# ------------------------------------------------------------------
|
||||
# IOverlayLayer implementation
|
||||
# ------------------------------------------------------------------
|
||||
|
||||
def paint(self, painter: QPainter, video_rect: QRect) -> None:
|
||||
if not self._detections:
|
||||
return
|
||||
if self._source_size.isEmpty():
|
||||
return
|
||||
|
||||
src_w = self._source_size.width()
|
||||
src_h = self._source_size.height()
|
||||
vr = video_rect
|
||||
|
||||
# Scale factors: source-pixel → video_rect-pixel
|
||||
scale_x = vr.width() / src_w
|
||||
scale_y = vr.height() / src_h
|
||||
|
||||
painter.setFont(self._font)
|
||||
fm = painter.fontMetrics()
|
||||
|
||||
for det in self._detections:
|
||||
# Map to widget coordinates
|
||||
wx1 = vr.x() + int(det.x1 * scale_x)
|
||||
wy1 = vr.y() + int(det.y1 * scale_y)
|
||||
wx2 = vr.x() + int(det.x2 * scale_x)
|
||||
wy2 = vr.y() + int(det.y2 * scale_y)
|
||||
|
||||
box_rect = QRect(wx1, wy1, wx2 - wx1, wy2 - wy1)
|
||||
|
||||
# Draw bounding box
|
||||
painter.setPen(self._pen)
|
||||
painter.setBrush(Qt.BrushStyle.NoBrush)
|
||||
painter.drawRect(box_rect)
|
||||
|
||||
# Label text: "label 0.87"
|
||||
label_text = f"{det.label} {det.conf:.2f}"
|
||||
text_w = fm.horizontalAdvance(label_text) + 6
|
||||
text_h = fm.height() + 2
|
||||
|
||||
# Position label above box, clamped to video_rect
|
||||
lx = wx1
|
||||
ly = wy1 - text_h
|
||||
if ly < vr.top():
|
||||
ly = wy1 # draw inside box if no room above
|
||||
|
||||
label_bg = QRect(lx, ly, text_w, text_h)
|
||||
|
||||
painter.setPen(Qt.PenStyle.NoPen)
|
||||
painter.setBrush(self._bg_color)
|
||||
painter.drawRect(label_bg)
|
||||
|
||||
painter.setPen(QPen(self._text_color))
|
||||
painter.drawText(
|
||||
lx + 3,
|
||||
ly + fm.ascent() + 1,
|
||||
label_text,
|
||||
)
|
||||
196
app/inference/worker.py
Normal file
196
app/inference/worker.py
Normal file
@@ -0,0 +1,196 @@
|
||||
"""YOLO inference worker — runs in a separate process.
|
||||
|
||||
This module contains only plain functions (no Qt, no PySide6) so it can
|
||||
safely be imported and executed in a child process via multiprocessing.
|
||||
|
||||
IPC protocol
|
||||
------------
|
||||
input_queue receives : FramePacket (frame_id, raw_bytes, width, height, channels)
|
||||
output_queue sends : ResultPacket (frame_id, detections, width, height)
|
||||
stop_event : multiprocessing.Event — set by parent to request clean exit
|
||||
|
||||
Detection format (namedtuple-compatible plain tuple):
|
||||
(x1, y1, x2, y2, conf, label) — all floats/str, x/y in source-frame pixels
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import logging
|
||||
import platform
|
||||
import sys
|
||||
from multiprocessing import Event, Queue
|
||||
from queue import Empty
|
||||
from typing import NamedTuple
|
||||
|
||||
logger = logging.getLogger(__name__)
|
||||
|
||||
|
||||
# ---------------------------------------------------------------------------
|
||||
# Data structures shared between worker and manager
|
||||
# ---------------------------------------------------------------------------
|
||||
|
||||
class FramePacket(NamedTuple):
|
||||
frame_id: int
|
||||
raw_bytes: bytes # RGB bytes, row-major, shape = (height, width, channels)
|
||||
width: int
|
||||
height: int
|
||||
channels: int # always 3 (RGB)
|
||||
|
||||
|
||||
class ResultPacket(NamedTuple):
|
||||
frame_id: int
|
||||
detections: list # list of (x1, y1, x2, y2, conf, label) tuples
|
||||
width: int # source frame width (for overlay scaling)
|
||||
height: int # source frame height
|
||||
|
||||
|
||||
# ---------------------------------------------------------------------------
|
||||
# Worker entry point
|
||||
# ---------------------------------------------------------------------------
|
||||
|
||||
def run_worker(
|
||||
model_path: str,
|
||||
input_queue: Queue,
|
||||
output_queue: Queue,
|
||||
stop_event: Event,
|
||||
log_level: int = logging.WARNING,
|
||||
) -> None:
|
||||
"""
|
||||
Main loop of the inference worker process.
|
||||
|
||||
Loads the YOLO model once, then processes frames from input_queue
|
||||
until stop_event is set. Results are posted to output_queue.
|
||||
|
||||
This function is designed to be the target of multiprocessing.Process.
|
||||
It must NOT import PySide6 or any Qt module.
|
||||
"""
|
||||
_configure_worker_logging(log_level)
|
||||
logger.info("Inference worker starting (pid=%d)", _getpid())
|
||||
|
||||
try:
|
||||
model = _load_model(model_path)
|
||||
except Exception as exc:
|
||||
logger.error("Failed to load model '%s': %s", model_path, exc)
|
||||
# Signal failure by putting None — manager treats it as error
|
||||
output_queue.put(None)
|
||||
return
|
||||
|
||||
logger.info("Model loaded: %s", model_path)
|
||||
|
||||
while not stop_event.is_set():
|
||||
try:
|
||||
packet: FramePacket = input_queue.get(timeout=0.1)
|
||||
except Empty:
|
||||
continue
|
||||
except Exception as exc:
|
||||
logger.error("Error reading input queue: %s", exc)
|
||||
break
|
||||
|
||||
try:
|
||||
result = _infer(model, packet)
|
||||
output_queue.put(result)
|
||||
except Exception as exc:
|
||||
logger.error("Inference error (frame %d): %s", packet.frame_id, exc)
|
||||
# Put empty result so manager knows we're still alive
|
||||
output_queue.put(ResultPacket(
|
||||
frame_id=packet.frame_id,
|
||||
detections=[],
|
||||
width=packet.width,
|
||||
height=packet.height,
|
||||
))
|
||||
|
||||
logger.info("Inference worker stopping")
|
||||
|
||||
|
||||
# ---------------------------------------------------------------------------
|
||||
# Helpers
|
||||
# ---------------------------------------------------------------------------
|
||||
|
||||
def _load_model(model_path: str):
|
||||
"""Load YOLO model with best available device."""
|
||||
from ultralytics import YOLO # noqa: PLC0415
|
||||
|
||||
device = _select_device()
|
||||
logger.info("Loading YOLO model on device='%s'", device)
|
||||
model = YOLO(model_path)
|
||||
# Warm up — run on a tiny dummy to JIT-compile kernels
|
||||
try:
|
||||
import numpy as np # noqa: PLC0415
|
||||
dummy = np.zeros((64, 64, 3), dtype=np.uint8)
|
||||
model(dummy, device=device, verbose=False)
|
||||
except Exception as exc:
|
||||
logger.warning("Warm-up failed (non-fatal): %s", exc)
|
||||
return model
|
||||
|
||||
|
||||
def _select_device() -> str:
|
||||
"""
|
||||
Choose inference device.
|
||||
|
||||
Priority:
|
||||
- macOS → "mps" if available (Metal GPU), else "cpu"
|
||||
- others → "cpu"
|
||||
"""
|
||||
system = platform.system()
|
||||
if system == "Darwin":
|
||||
try:
|
||||
import torch # noqa: PLC0415
|
||||
if torch.backends.mps.is_available():
|
||||
logger.info("MPS (Metal) available — using GPU")
|
||||
return "mps"
|
||||
except Exception:
|
||||
pass
|
||||
logger.info("MPS not available — using CPU")
|
||||
return "cpu"
|
||||
|
||||
|
||||
def _infer(model, packet: FramePacket) -> ResultPacket:
|
||||
"""Run model on one frame, return ResultPacket."""
|
||||
import numpy as np # noqa: PLC0415
|
||||
|
||||
frame_np = np.frombuffer(packet.raw_bytes, dtype=np.uint8).reshape(
|
||||
(packet.height, packet.width, packet.channels)
|
||||
)
|
||||
|
||||
device = _select_device()
|
||||
results = model(frame_np, device=device, verbose=False)
|
||||
|
||||
detections = []
|
||||
for r in results:
|
||||
if r.boxes is None:
|
||||
continue
|
||||
boxes = r.boxes
|
||||
for i in range(len(boxes)):
|
||||
xyxy = boxes.xyxy[i].tolist() # [x1, y1, x2, y2] in source pixels
|
||||
conf = float(boxes.conf[i])
|
||||
cls_idx = int(boxes.cls[i])
|
||||
label = (
|
||||
r.names[cls_idx]
|
||||
if r.names and cls_idx in r.names
|
||||
else str(cls_idx)
|
||||
)
|
||||
detections.append((
|
||||
float(xyxy[0]), float(xyxy[1]),
|
||||
float(xyxy[2]), float(xyxy[3]),
|
||||
conf, label,
|
||||
))
|
||||
|
||||
return ResultPacket(
|
||||
frame_id=packet.frame_id,
|
||||
detections=detections,
|
||||
width=packet.width,
|
||||
height=packet.height,
|
||||
)
|
||||
|
||||
|
||||
def _configure_worker_logging(level: int) -> None:
|
||||
logging.basicConfig(
|
||||
level=level,
|
||||
format="[worker %(process)d] %(levelname)s %(name)s: %(message)s",
|
||||
stream=sys.stderr,
|
||||
)
|
||||
|
||||
|
||||
def _getpid() -> int:
|
||||
import os # noqa: PLC0415
|
||||
return os.getpid()
|
||||
350
app/inference/worker_manager.py
Normal file
350
app/inference/worker_manager.py
Normal file
@@ -0,0 +1,350 @@
|
||||
"""InferenceManager — orchestrates the YOLO worker process from the GUI thread.
|
||||
|
||||
Responsibilities:
|
||||
- Start / stop the worker process
|
||||
- Submit frames (with drop-if-busy logic)
|
||||
- Poll result queue via QTimer (never blocks the GUI thread)
|
||||
- Watch process health via QTimer (auto-restart on crash)
|
||||
- Emit Qt signals with results for BboxOverlay
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import logging
|
||||
import multiprocessing
|
||||
import time
|
||||
from pathlib import Path
|
||||
|
||||
from PySide6.QtCore import QObject, QTimer, Signal, Slot
|
||||
from PySide6.QtMultimedia import QVideoFrame
|
||||
|
||||
from app.config import (
|
||||
INFERENCE_MAX_RESTARTS,
|
||||
INFERENCE_POLL_INTERVAL_MS,
|
||||
INFERENCE_WATCHDOG_INTERVAL_MS,
|
||||
INFERENCE_WORKER_TIMEOUT_S,
|
||||
)
|
||||
from app.inference.bbox_overlay import Detection
|
||||
from app.inference.worker import FramePacket, ResultPacket, run_worker
|
||||
|
||||
logger = logging.getLogger(__name__)
|
||||
|
||||
|
||||
class InferenceManager(QObject):
|
||||
"""
|
||||
Manages the YOLO worker subprocess.
|
||||
|
||||
Signals:
|
||||
detections_ready(detections, source_size)
|
||||
Emitted in the GUI thread when a result arrives.
|
||||
detections : list[Detection]
|
||||
source_size : tuple[int, int] — (width, height) of inferred frame
|
||||
|
||||
inference_started() — worker is up and model is loaded
|
||||
inference_stopped() — worker has exited cleanly
|
||||
inference_error(str) — fatal error (max restarts exceeded)
|
||||
|
||||
Usage:
|
||||
mgr = InferenceManager(parent=self)
|
||||
mgr.detections_ready.connect(bbox_overlay.on_detections)
|
||||
mgr.start("path/to/model.pt")
|
||||
# ...
|
||||
mgr.submit_frame(video_frame) # called by FrameDispatcher subscriber
|
||||
# ...
|
||||
mgr.stop()
|
||||
"""
|
||||
|
||||
detections_ready = Signal(object, object) # list[Detection], tuple[int,int]
|
||||
inference_started = Signal()
|
||||
inference_stopped = Signal()
|
||||
inference_error = Signal(str)
|
||||
|
||||
def __init__(self, parent: QObject | None = None) -> None:
|
||||
super().__init__(parent)
|
||||
|
||||
self._model_path: str | None = None
|
||||
self._process: multiprocessing.Process | None = None
|
||||
self._input_queue: multiprocessing.Queue | None = None
|
||||
self._output_queue: multiprocessing.Queue | None = None
|
||||
self._stop_event: multiprocessing.Event | None = None
|
||||
|
||||
# Drop-if-busy flag — True while worker is processing a frame
|
||||
self._busy: bool = False
|
||||
self._frame_id: int = 0
|
||||
|
||||
# Restart tracking
|
||||
self._restart_count: int = 0
|
||||
self._last_result_time: float = 0.0
|
||||
|
||||
# Paused flag — inference can be suspended without stopping the process
|
||||
self._paused: bool = False
|
||||
|
||||
# QTimers (GUI thread)
|
||||
self._poll_timer = QTimer(self)
|
||||
self._poll_timer.setInterval(INFERENCE_POLL_INTERVAL_MS)
|
||||
self._poll_timer.timeout.connect(self._poll_output)
|
||||
|
||||
self._watchdog_timer = QTimer(self)
|
||||
self._watchdog_timer.setInterval(INFERENCE_WATCHDOG_INTERVAL_MS)
|
||||
self._watchdog_timer.timeout.connect(self._watchdog_check)
|
||||
|
||||
# ------------------------------------------------------------------
|
||||
# Public API
|
||||
# ------------------------------------------------------------------
|
||||
|
||||
def start(self, model_path: str) -> None:
|
||||
"""Load model and start the worker process."""
|
||||
if not Path(model_path).exists():
|
||||
msg = f"Model file not found: {model_path}"
|
||||
logger.error(msg)
|
||||
self.inference_error.emit(msg)
|
||||
return
|
||||
|
||||
self._stop_worker()
|
||||
self._model_path = model_path
|
||||
self._restart_count = 0
|
||||
self._paused = False
|
||||
self._start_worker()
|
||||
|
||||
def stop(self) -> None:
|
||||
"""Stop the worker process and reset state."""
|
||||
self._stop_worker()
|
||||
self._model_path = None
|
||||
self._restart_count = 0
|
||||
self._paused = False
|
||||
|
||||
def pause(self) -> None:
|
||||
"""Suspend frame submission without stopping the process."""
|
||||
self._paused = True
|
||||
logger.debug("InferenceManager: paused")
|
||||
|
||||
def resume(self) -> None:
|
||||
"""Resume frame submission."""
|
||||
self._paused = False
|
||||
logger.debug("InferenceManager: resumed")
|
||||
|
||||
@property
|
||||
def is_running(self) -> bool:
|
||||
return self._process is not None and self._process.is_alive()
|
||||
|
||||
@property
|
||||
def is_paused(self) -> bool:
|
||||
return self._paused
|
||||
|
||||
@property
|
||||
def model_path(self) -> str | None:
|
||||
return self._model_path
|
||||
|
||||
@Slot(QVideoFrame)
|
||||
def submit_frame(self, frame: QVideoFrame) -> None:
|
||||
"""
|
||||
Attempt to submit a frame for inference.
|
||||
|
||||
Drops the frame silently if:
|
||||
- manager is not running
|
||||
- manager is paused
|
||||
- worker is still busy with previous frame (drop_if_busy)
|
||||
"""
|
||||
if not self.is_running or self._paused or self._busy:
|
||||
return
|
||||
|
||||
if not frame.isValid():
|
||||
return
|
||||
|
||||
# Map frame to read-only memory, copy raw bytes, unmap
|
||||
if not frame.map(QVideoFrame.MapMode.ReadOnly):
|
||||
logger.warning("InferenceManager: failed to map QVideoFrame")
|
||||
return
|
||||
|
||||
try:
|
||||
width = frame.width()
|
||||
height = frame.height()
|
||||
raw = bytes(frame.bits(0)) # plane 0 — copies data
|
||||
finally:
|
||||
frame.unmap()
|
||||
|
||||
if not raw:
|
||||
return
|
||||
|
||||
# Detect number of channels from byte count
|
||||
expected_rgb = width * height * 3
|
||||
expected_rgba = width * height * 4
|
||||
if len(raw) >= expected_rgba:
|
||||
# BGRA / RGBA — convert to RGB by stripping alpha and swapping B/R
|
||||
try:
|
||||
import numpy as np # noqa: PLC0415
|
||||
arr = np.frombuffer(raw, dtype=np.uint8).reshape((height, width, 4))
|
||||
# Qt delivers BGRA → swap to RGB
|
||||
rgb = arr[:, :, [2, 1, 0]].copy()
|
||||
raw = rgb.tobytes()
|
||||
channels = 3
|
||||
except Exception as exc:
|
||||
logger.warning("Frame colour conversion failed: %s", exc)
|
||||
return
|
||||
elif len(raw) >= expected_rgb:
|
||||
channels = 3
|
||||
else:
|
||||
logger.warning(
|
||||
"Unexpected frame size: %d bytes for %dx%d",
|
||||
len(raw), width, height,
|
||||
)
|
||||
return
|
||||
|
||||
self._frame_id += 1
|
||||
packet = FramePacket(
|
||||
frame_id=self._frame_id,
|
||||
raw_bytes=raw,
|
||||
width=width,
|
||||
height=height,
|
||||
channels=channels,
|
||||
)
|
||||
|
||||
try:
|
||||
self._input_queue.put_nowait(packet)
|
||||
self._busy = True
|
||||
logger.debug("InferenceManager: submitted frame %d", self._frame_id)
|
||||
except Exception as exc:
|
||||
logger.warning("InferenceManager: could not enqueue frame: %s", exc)
|
||||
|
||||
# ------------------------------------------------------------------
|
||||
# Private — worker lifecycle
|
||||
# ------------------------------------------------------------------
|
||||
|
||||
def _start_worker(self) -> None:
|
||||
ctx = multiprocessing.get_context("spawn")
|
||||
self._input_queue = ctx.Queue(maxsize=1)
|
||||
self._output_queue = ctx.Queue(maxsize=4)
|
||||
self._stop_event = ctx.Event()
|
||||
|
||||
self._process = ctx.Process(
|
||||
target=run_worker,
|
||||
args=(
|
||||
self._model_path,
|
||||
self._input_queue,
|
||||
self._output_queue,
|
||||
self._stop_event,
|
||||
logging.WARNING,
|
||||
),
|
||||
daemon=True,
|
||||
name="inference-worker",
|
||||
)
|
||||
self._process.start()
|
||||
self._busy = False
|
||||
self._last_result_time = time.monotonic()
|
||||
|
||||
self._poll_timer.start()
|
||||
self._watchdog_timer.start()
|
||||
logger.info(
|
||||
"Inference worker started (pid=%d, model=%s)",
|
||||
self._process.pid, self._model_path,
|
||||
)
|
||||
self.inference_started.emit()
|
||||
|
||||
def _stop_worker(self) -> None:
|
||||
self._poll_timer.stop()
|
||||
self._watchdog_timer.stop()
|
||||
|
||||
if self._stop_event is not None:
|
||||
self._stop_event.set()
|
||||
|
||||
if self._process is not None:
|
||||
self._process.join(timeout=3.0)
|
||||
if self._process.is_alive():
|
||||
logger.warning("Worker did not stop cleanly — terminating")
|
||||
self._process.terminate()
|
||||
self._process.join(timeout=2.0)
|
||||
self._process = None
|
||||
|
||||
self._input_queue = None
|
||||
self._output_queue = None
|
||||
self._stop_event = None
|
||||
self._busy = False
|
||||
|
||||
logger.info("Inference worker stopped")
|
||||
self.inference_stopped.emit()
|
||||
|
||||
# ------------------------------------------------------------------
|
||||
# Private — timers
|
||||
# ------------------------------------------------------------------
|
||||
|
||||
@Slot()
|
||||
def _poll_output(self) -> None:
|
||||
"""Drain the output queue (called every INFERENCE_POLL_INTERVAL_MS ms)."""
|
||||
if self._output_queue is None:
|
||||
return
|
||||
|
||||
try:
|
||||
while True:
|
||||
item = self._output_queue.get_nowait()
|
||||
if item is None:
|
||||
# Worker signalled a fatal load error
|
||||
logger.error("Worker reported model load failure")
|
||||
self._handle_crash("Model failed to load in worker process")
|
||||
return
|
||||
|
||||
packet: ResultPacket = item
|
||||
self._busy = False
|
||||
self._last_result_time = time.monotonic()
|
||||
|
||||
detections = [
|
||||
Detection(x1, y1, x2, y2, conf, label)
|
||||
for x1, y1, x2, y2, conf, label in packet.detections
|
||||
]
|
||||
source_size = (packet.width, packet.height)
|
||||
|
||||
logger.debug(
|
||||
"InferenceManager: frame %d → %d detections",
|
||||
packet.frame_id, len(detections),
|
||||
)
|
||||
self.detections_ready.emit(detections, source_size)
|
||||
|
||||
except Exception:
|
||||
# Empty queue — normal
|
||||
pass
|
||||
|
||||
@Slot()
|
||||
def _watchdog_check(self) -> None:
|
||||
"""Detect crashed or hung worker process."""
|
||||
if self._process is None:
|
||||
return
|
||||
|
||||
# Process died unexpectedly
|
||||
if not self._process.is_alive():
|
||||
exit_code = self._process.exitcode
|
||||
logger.error("Worker process died (exitcode=%s)", exit_code)
|
||||
self._handle_crash(f"Worker process exited with code {exit_code}")
|
||||
return
|
||||
|
||||
# Worker alive but hasn't responded for too long (hung during inference)
|
||||
if self._busy:
|
||||
elapsed = time.monotonic() - self._last_result_time
|
||||
if elapsed > INFERENCE_WORKER_TIMEOUT_S:
|
||||
logger.error(
|
||||
"Worker timeout: no response for %.1f s — restarting", elapsed
|
||||
)
|
||||
self._process.terminate()
|
||||
self._process.join(timeout=2.0)
|
||||
self._handle_crash("Worker timed out (hung during inference)")
|
||||
|
||||
def _handle_crash(self, reason: str) -> None:
|
||||
"""Decide whether to auto-restart or give up."""
|
||||
# Clean up process handles (already dead)
|
||||
self._poll_timer.stop()
|
||||
self._watchdog_timer.stop()
|
||||
self._process = None
|
||||
self._busy = False
|
||||
|
||||
if self._restart_count < INFERENCE_MAX_RESTARTS:
|
||||
self._restart_count += 1
|
||||
logger.warning(
|
||||
"Auto-restarting worker (attempt %d/%d): %s",
|
||||
self._restart_count, INFERENCE_MAX_RESTARTS, reason,
|
||||
)
|
||||
self._start_worker()
|
||||
else:
|
||||
msg = (
|
||||
f"Inference worker failed after {INFERENCE_MAX_RESTARTS} restarts. "
|
||||
f"Last error: {reason}"
|
||||
)
|
||||
logger.error(msg)
|
||||
self.inference_error.emit(msg)
|
||||
@@ -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:
|
||||
|
||||
@@ -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:
|
||||
|
||||
0
app/video/__init__.py
Normal file
0
app/video/__init__.py
Normal file
117
app/video/video_player.py
Normal file
117
app/video/video_player.py
Normal file
@@ -0,0 +1,117 @@
|
||||
"""VideoPlayer — plays a local video file and delivers frames via frame_ready signal.
|
||||
|
||||
The public interface mirrors CameraService so MainWindow can treat both
|
||||
interchangeably: both emit frame_ready(QVideoFrame).
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import logging
|
||||
from pathlib import Path
|
||||
|
||||
from PySide6.QtCore import QObject, QUrl, Signal, Slot
|
||||
from PySide6.QtMultimedia import (
|
||||
QMediaPlayer,
|
||||
QVideoFrame,
|
||||
QVideoSink,
|
||||
)
|
||||
|
||||
logger = logging.getLogger(__name__)
|
||||
|
||||
|
||||
class VideoPlayer(QObject):
|
||||
"""
|
||||
Wraps QMediaPlayer + QVideoSink to replay a local video file.
|
||||
|
||||
Signal flow (identical interface to CameraService):
|
||||
VideoPlayer.frame_ready(QVideoFrame) → FrameDispatcher
|
||||
|
||||
Notes:
|
||||
- Playback is real-time (1×) — no seek/pause in this version.
|
||||
- At end-of-file: emits playback_stopped() and stops.
|
||||
- On any error: emits playback_error(str) then playback_stopped().
|
||||
"""
|
||||
|
||||
frame_ready = Signal(QVideoFrame)
|
||||
playback_started = Signal()
|
||||
playback_stopped = Signal()
|
||||
playback_error = Signal(str)
|
||||
|
||||
def __init__(self, parent: QObject | None = None) -> None:
|
||||
super().__init__(parent)
|
||||
|
||||
self._player = QMediaPlayer(self)
|
||||
self._sink = QVideoSink(self)
|
||||
|
||||
self._player.setVideoSink(self._sink)
|
||||
|
||||
self._sink.videoFrameChanged.connect(self._on_frame)
|
||||
self._player.playbackStateChanged.connect(self._on_playback_state_changed)
|
||||
self._player.errorOccurred.connect(self._on_error)
|
||||
|
||||
self._current_path: str | None = None
|
||||
|
||||
# ------------------------------------------------------------------
|
||||
# Public API
|
||||
# ------------------------------------------------------------------
|
||||
|
||||
def play(self, path: str) -> None:
|
||||
"""Open and start playing a video file."""
|
||||
self.stop()
|
||||
p = Path(path)
|
||||
if not p.exists():
|
||||
msg = f"Video file not found: {path}"
|
||||
logger.error(msg)
|
||||
self.playback_error.emit(msg)
|
||||
return
|
||||
|
||||
self._current_path = path
|
||||
url = QUrl.fromLocalFile(str(p.resolve()))
|
||||
self._player.setSource(url)
|
||||
self._player.play()
|
||||
logger.info("VideoPlayer: starting playback of '%s'", p.name)
|
||||
|
||||
def stop(self) -> None:
|
||||
"""Stop playback and clear source."""
|
||||
if self._player.playbackState() != QMediaPlayer.PlaybackState.StoppedState:
|
||||
self._player.stop()
|
||||
self._player.setSource(QUrl())
|
||||
self._current_path = None
|
||||
|
||||
@property
|
||||
def is_playing(self) -> bool:
|
||||
return (
|
||||
self._player.playbackState()
|
||||
== QMediaPlayer.PlaybackState.PlayingState
|
||||
)
|
||||
|
||||
@property
|
||||
def current_path(self) -> str | None:
|
||||
return self._current_path
|
||||
|
||||
# ------------------------------------------------------------------
|
||||
# Private slots
|
||||
# ------------------------------------------------------------------
|
||||
|
||||
@Slot(QVideoFrame)
|
||||
def _on_frame(self, frame: QVideoFrame) -> None:
|
||||
if frame.isValid():
|
||||
self.frame_ready.emit(frame)
|
||||
|
||||
@Slot(QMediaPlayer.PlaybackState)
|
||||
def _on_playback_state_changed(self, state: QMediaPlayer.PlaybackState) -> None:
|
||||
if state == QMediaPlayer.PlaybackState.PlayingState:
|
||||
logger.info("VideoPlayer: playing")
|
||||
self.playback_started.emit()
|
||||
elif state == QMediaPlayer.PlaybackState.StoppedState:
|
||||
logger.info("VideoPlayer: stopped")
|
||||
self.playback_stopped.emit()
|
||||
|
||||
@Slot(QMediaPlayer.Error, str)
|
||||
def _on_error(self, error: QMediaPlayer.Error, error_string: str) -> None:
|
||||
if error == QMediaPlayer.Error.NoError:
|
||||
return
|
||||
msg = f"VideoPlayer error: {error_string}"
|
||||
logger.error(msg)
|
||||
self.playback_error.emit(msg)
|
||||
self.playback_stopped.emit()
|
||||
Reference in New Issue
Block a user