722 lines
29 KiB
Python
722 lines
29 KiB
Python
from PySide6.QtWidgets import (
|
|
QWidget, QVBoxLayout, QHBoxLayout, QLabel, QComboBox,
|
|
QSlider, QCheckBox, QPushButton, QGroupBox, QFormLayout,
|
|
QSpinBox, QDoubleSpinBox, QTabWidget, QLineEdit, QFileDialog,
|
|
QSpacerItem, QSizePolicy, QScrollArea
|
|
)
|
|
from PySide6.QtCore import Qt, Signal, Slot
|
|
from PySide6.QtGui import QFont
|
|
|
|
# Import VLM insights widget
|
|
from ui.vlm_insights_widget import VLMInsightsWidget
|
|
|
|
class ConfigPanel(QWidget):
|
|
"""Side panel for application configuration."""
|
|
|
|
config_changed = Signal(dict) # Emitted when configuration changes are applied
|
|
theme_toggled = Signal(bool) # Emitted when theme toggle button is clicked (True = dark)
|
|
device_switch_requested = Signal(str)
|
|
|
|
def __init__(self):
|
|
super().__init__()
|
|
self.setObjectName("ConfigPanel")
|
|
self.setStyleSheet(self._panel_qss())
|
|
self.initUI()
|
|
self.dark_theme = True # Start with dark theme
|
|
|
|
def _panel_qss(self):
|
|
return """
|
|
#ConfigPanel {
|
|
background: #181C20;
|
|
border-top-left-radius: 18px;
|
|
border-bottom-left-radius: 18px;
|
|
border: none;
|
|
}
|
|
QTabWidget::pane {
|
|
border-radius: 12px;
|
|
background: #232323;
|
|
}
|
|
QTabBar::tab {
|
|
background: #232323;
|
|
color: #bbb;
|
|
border-radius: 10px 10px 0 0;
|
|
padding: 8px 18px;
|
|
font-size: 15px;
|
|
}
|
|
QTabBar::tab:selected {
|
|
background: #03DAC5;
|
|
color: #181C20;
|
|
}
|
|
QGroupBox {
|
|
border: 1px solid #30343A;
|
|
border-radius: 12px;
|
|
margin-top: 16px;
|
|
background: #232323;
|
|
font-weight: bold;
|
|
color: #fff;
|
|
font-size: 15px;
|
|
}
|
|
QGroupBox:title {
|
|
subcontrol-origin: margin;
|
|
left: 12px;
|
|
top: 8px;
|
|
padding: 0 4px;
|
|
background: transparent;
|
|
}
|
|
QLabel, QCheckBox, QRadioButton {
|
|
color: #eee;
|
|
font-size: 14px;
|
|
}
|
|
QLineEdit, QSpinBox, QDoubleSpinBox {
|
|
background: #181C20;
|
|
border: 1.5px solid #30343A;
|
|
border-radius: 8px;
|
|
color: #fff;
|
|
padding: 6px 10px;
|
|
font-size: 14px;
|
|
}
|
|
QSlider::groove:horizontal {
|
|
height: 8px;
|
|
background: #30343A;
|
|
border-radius: 4px;
|
|
}
|
|
QSlider::handle:horizontal {
|
|
background: #03DAC5;
|
|
border-radius: 10px;
|
|
width: 20px;
|
|
}
|
|
QPushButton {
|
|
background: #03DAC5;
|
|
color: #181C20;
|
|
border-radius: 10px;
|
|
font-size: 15px;
|
|
font-weight: 600;
|
|
padding: 8px 18px;
|
|
border: none;
|
|
}
|
|
QPushButton:hover {
|
|
background: #018786;
|
|
color: #fff;
|
|
}
|
|
QPushButton:pressed {
|
|
background: #03DAC5;
|
|
color: #232323;
|
|
}
|
|
QCheckBox::indicator {
|
|
border-radius: 6px;
|
|
width: 18px;
|
|
height: 18px;
|
|
}
|
|
QCheckBox::indicator:checked {
|
|
background: #03DAC5;
|
|
border: 1.5px solid #018786;
|
|
}
|
|
QCheckBox::indicator:unchecked {
|
|
background: #232323;
|
|
border: 1.5px solid #30343A;
|
|
}
|
|
"""
|
|
|
|
def initUI(self):
|
|
"""Initialize UI components"""
|
|
layout = QVBoxLayout(self)
|
|
layout.setContentsMargins(18, 18, 18, 18)
|
|
layout.setSpacing(10)
|
|
|
|
# Create tab widget for better organization
|
|
tabs = QTabWidget()
|
|
tabs.setStyleSheet("") # Use panel QSS
|
|
|
|
# Detection tab
|
|
detection_tab = QWidget()
|
|
detection_layout = QVBoxLayout(detection_tab)
|
|
|
|
# Device selection
|
|
device_group = QGroupBox("Inference Device")
|
|
device_layout = QVBoxLayout(device_group)
|
|
|
|
self.device_combo = QComboBox()
|
|
self.device_combo.addItems(["AUTO", "CPU", "GPU", "MYRIAD", "VPU"])
|
|
device_layout.addWidget(self.device_combo)
|
|
|
|
detection_layout.addWidget(device_group)
|
|
|
|
# Detection settings
|
|
detection_group = QGroupBox("Detection Settings")
|
|
detection_form = QFormLayout(detection_group)
|
|
|
|
self.conf_slider = QSlider(Qt.Horizontal)
|
|
self.conf_slider.setRange(10, 100)
|
|
self.conf_slider.setValue(50)
|
|
self.conf_slider.setTracking(True)
|
|
self.conf_slider.valueChanged.connect(self.update_conf_label)
|
|
|
|
self.conf_label = QLabel("50%")
|
|
conf_layout = QHBoxLayout()
|
|
conf_layout.addWidget(self.conf_slider)
|
|
conf_layout.addWidget(self.conf_label)
|
|
|
|
self.tracking_checkbox = QCheckBox("Enable")
|
|
self.tracking_checkbox.setChecked(True)
|
|
|
|
model_layout = QHBoxLayout()
|
|
self.model_path = QLineEdit()
|
|
self.model_path.setReadOnly(True)
|
|
self.model_path.setPlaceholderText("Auto-detected")
|
|
|
|
self.browse_btn = QPushButton("...")
|
|
self.browse_btn.setMaximumWidth(30)
|
|
self.browse_btn.clicked.connect(self.browse_model)
|
|
|
|
model_layout.addWidget(self.model_path)
|
|
model_layout.addWidget(self.browse_btn)
|
|
|
|
detection_form.addRow("Confidence Threshold:", conf_layout)
|
|
detection_form.addRow("Object Tracking:", self.tracking_checkbox)
|
|
detection_form.addRow("Model Path:", model_layout)
|
|
detection_layout.addWidget(detection_group)
|
|
# Add quick switch buttons for YOLO11n/YOLO11x
|
|
quick_switch_layout = QHBoxLayout()
|
|
self.cpu_switch_btn = QPushButton("Switch to CPU (YOLO11n)")
|
|
self.gpu_switch_btn = QPushButton("Switch to GPU (YOLO11x)")
|
|
self.cpu_switch_btn.clicked.connect(lambda: self.quick_switch_device("CPU"))
|
|
self.gpu_switch_btn.clicked.connect(lambda: self.quick_switch_device("GPU"))
|
|
quick_switch_layout.addWidget(self.cpu_switch_btn)
|
|
quick_switch_layout.addWidget(self.gpu_switch_btn)
|
|
detection_layout.addLayout(quick_switch_layout)
|
|
# --- Current Model Info Section (PREMIUM FORMAT) ---
|
|
model_info_group = QGroupBox()
|
|
model_info_group.setTitle("")
|
|
model_info_group.setStyleSheet("""
|
|
QGroupBox {
|
|
border: 1.5px solid #03DAC5;
|
|
border-radius: 12px;
|
|
margin-top: 16px;
|
|
background: #181C20;
|
|
font-weight: bold;
|
|
color: #03DAC5;
|
|
font-size: 16px;
|
|
}
|
|
""")
|
|
model_info_layout = QVBoxLayout(model_info_group)
|
|
model_info_layout.setContentsMargins(16, 10, 16, 10)
|
|
# Title
|
|
title = QLabel("Current Model")
|
|
title.setStyleSheet("font-size: 17px; font-weight: bold; color: #03DAC5; margin-bottom: 8px;")
|
|
model_info_layout.addWidget(title)
|
|
# Info rows
|
|
row_style = "font-size: 15px; color: #fff; font-family: 'Consolas', 'SF Mono', 'monospace'; padding: 2px 0;"
|
|
row_widget = QWidget()
|
|
row_layout = QVBoxLayout(row_widget)
|
|
row_layout.setContentsMargins(0, 0, 0, 0)
|
|
row_layout.setSpacing(2)
|
|
# Model
|
|
model_row = QHBoxLayout()
|
|
model_label = QLabel("Model:")
|
|
model_label.setStyleSheet(row_style + "font-weight: 600; color: #80cbc4;")
|
|
self.current_model_label = QLabel("-")
|
|
self.current_model_label.setStyleSheet(row_style)
|
|
model_row.addWidget(model_label)
|
|
model_row.addWidget(self.current_model_label, 1)
|
|
row_layout.addLayout(model_row)
|
|
# Device
|
|
device_row = QHBoxLayout()
|
|
device_label = QLabel("Device:")
|
|
device_label.setStyleSheet(row_style + "font-weight: 600; color: #80cbc4;")
|
|
self.current_device_label = QLabel("-")
|
|
self.current_device_label.setStyleSheet(row_style)
|
|
device_row.addWidget(device_label)
|
|
device_row.addWidget(self.current_device_label, 1)
|
|
row_layout.addLayout(device_row)
|
|
# Recommended For
|
|
rec_row = QHBoxLayout()
|
|
rec_label = QLabel("Recommended For:")
|
|
rec_label.setStyleSheet(row_style + "font-weight: 600; color: #80cbc4;")
|
|
self.model_recommendation_label = QLabel("")
|
|
self.model_recommendation_label.setStyleSheet(row_style)
|
|
rec_row.addWidget(rec_label)
|
|
rec_row.addWidget(self.model_recommendation_label, 1)
|
|
row_layout.addLayout(rec_row)
|
|
model_info_layout.addWidget(row_widget)
|
|
model_info_layout.addStretch(1)
|
|
detection_layout.addWidget(model_info_group)
|
|
|
|
# --- OpenVINO Devices Info Section ---
|
|
devices_info_group = QGroupBox()
|
|
devices_info_group.setTitle("")
|
|
devices_info_group.setStyleSheet("""
|
|
QGroupBox {
|
|
border: 1.5px solid #80cbc4;
|
|
border-radius: 12px;
|
|
margin-top: 16px;
|
|
background: #181C20;
|
|
font-weight: bold;
|
|
color: #80cbc4;
|
|
font-size: 16px;
|
|
}
|
|
""")
|
|
devices_info_layout = QVBoxLayout(devices_info_group)
|
|
devices_info_layout.setContentsMargins(16, 10, 16, 10)
|
|
devices_title = QLabel("Available OpenVINO Devices")
|
|
devices_title.setStyleSheet("font-size: 16px; font-weight: bold; color: #80cbc4; margin-bottom: 8px;")
|
|
devices_info_layout.addWidget(devices_title)
|
|
self.devices_info_text = QLabel("Yolov11n and Yolov11x models are optimized for CPU and GPU respectively.<br>")
|
|
self.devices_info_text.setStyleSheet("font-size: 14px; color: #fff; font-family: 'Consolas', 'SF Mono', 'monospace';")
|
|
self.devices_info_text.setWordWrap(True)
|
|
self.devices_info_text.setTextFormat(Qt.RichText)
|
|
self.devices_info_text.setObjectName("devices_info_text")
|
|
devices_info_layout.addWidget(self.devices_info_text)
|
|
devices_info_layout.addStretch(1)
|
|
detection_layout.addWidget(devices_info_group)
|
|
|
|
display_tab = QWidget()
|
|
display_layout = QVBoxLayout(display_tab)
|
|
|
|
# Display options
|
|
display_group = QGroupBox("Display Options")
|
|
display_form = QFormLayout(display_group)
|
|
|
|
self.labels_checkbox = QCheckBox()
|
|
self.labels_checkbox.setChecked(True)
|
|
|
|
self.confidence_checkbox = QCheckBox()
|
|
self.confidence_checkbox.setChecked(True)
|
|
|
|
self.perf_checkbox = QCheckBox()
|
|
self.perf_checkbox.setChecked(True)
|
|
|
|
self.max_width = QSpinBox()
|
|
self.max_width.setRange(320, 4096)
|
|
self.max_width.setValue(800)
|
|
self.max_width.setSingleStep(10)
|
|
self.max_width.setSuffix(" px")
|
|
|
|
display_form.addRow("Show Labels:", self.labels_checkbox)
|
|
display_form.addRow("Show Confidence:", self.confidence_checkbox)
|
|
display_form.addRow("Show Performance:", self.perf_checkbox)
|
|
display_form.addRow("Max Display Width:", self.max_width)
|
|
|
|
display_layout.addWidget(display_group)
|
|
|
|
# Analytics Group
|
|
analytics_group = QGroupBox("Analytics Settings")
|
|
analytics_form = QFormLayout(analytics_group)
|
|
|
|
self.charts_checkbox = QCheckBox()
|
|
self.charts_checkbox.setChecked(True)
|
|
|
|
self.history_spinbox = QSpinBox()
|
|
self.history_spinbox.setRange(10, 10000)
|
|
self.history_spinbox.setValue(1000)
|
|
self.history_spinbox.setSingleStep(100)
|
|
self.history_spinbox.setSuffix(" frames")
|
|
|
|
analytics_form.addRow("Enable Live Charts:", self.charts_checkbox)
|
|
analytics_form.addRow("History Length:", self.history_spinbox)
|
|
|
|
display_layout.addWidget(analytics_group)
|
|
|
|
# Violation tab
|
|
violation_tab = QWidget()
|
|
violation_layout = QVBoxLayout(violation_tab)
|
|
|
|
# Violation settings
|
|
violation_group = QGroupBox("Violation Detection")
|
|
violation_form = QFormLayout(violation_group)
|
|
|
|
self.red_light_grace = QDoubleSpinBox()
|
|
self.red_light_grace.setRange(0.1, 5.0)
|
|
self.red_light_grace.setValue(2.0)
|
|
self.red_light_grace.setSingleStep(0.1)
|
|
self.red_light_grace.setSuffix(" sec")
|
|
|
|
self.stop_sign_duration = QDoubleSpinBox()
|
|
self.stop_sign_duration.setRange(0.5, 5.0)
|
|
self.stop_sign_duration.setValue(2.0)
|
|
self.stop_sign_duration.setSingleStep(0.1)
|
|
self.stop_sign_duration.setSuffix(" sec")
|
|
|
|
self.speed_tolerance = QSpinBox()
|
|
self.speed_tolerance.setRange(0, 20)
|
|
self.speed_tolerance.setValue(5)
|
|
self.speed_tolerance.setSingleStep(1)
|
|
self.speed_tolerance.setSuffix(" km/h")
|
|
|
|
violation_form.addRow("Red Light Grace:", self.red_light_grace)
|
|
violation_form.addRow("Stop Sign Duration:", self.stop_sign_duration)
|
|
violation_form.addRow("Speed Tolerance:", self.speed_tolerance)
|
|
|
|
self.enable_red_light = QCheckBox("Enabled")
|
|
self.enable_red_light.setChecked(True)
|
|
|
|
self.enable_stop_sign = QCheckBox("Enabled")
|
|
self.enable_stop_sign.setChecked(True)
|
|
|
|
self.enable_speed = QCheckBox("Enabled")
|
|
self.enable_speed.setChecked(True)
|
|
|
|
self.enable_lane = QCheckBox("Enabled")
|
|
self.enable_lane.setChecked(True)
|
|
|
|
violation_form.addRow("Red Light Detection:", self.enable_red_light)
|
|
violation_form.addRow("Stop Sign Detection:", self.enable_stop_sign)
|
|
violation_form.addRow("Speed Detection:", self.enable_speed)
|
|
violation_form.addRow("Lane Detection:", self.enable_lane)
|
|
|
|
violation_layout.addWidget(violation_group)
|
|
|
|
# === VLM Insights Tab ===
|
|
vlm_tab = QWidget()
|
|
vlm_layout = QVBoxLayout(vlm_tab)
|
|
|
|
# Create scroll area for VLM insights
|
|
vlm_scroll = QScrollArea()
|
|
vlm_scroll.setWidgetResizable(True)
|
|
vlm_scroll.setHorizontalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
|
|
vlm_scroll.setStyleSheet("""
|
|
QScrollArea {
|
|
border: none;
|
|
background: transparent;
|
|
}
|
|
""")
|
|
|
|
# Add VLM insights widget
|
|
print("[CONFIG PANEL DEBUG] Creating VLM insights widget...")
|
|
self.vlm_insights = VLMInsightsWidget()
|
|
print("[CONFIG PANEL DEBUG] VLM insights widget created successfully")
|
|
vlm_scroll.setWidget(self.vlm_insights)
|
|
vlm_layout.addWidget(vlm_scroll)
|
|
|
|
# Smart Intersection Tab - Scene Analytics
|
|
smart_intersection_tab = QWidget()
|
|
si_layout = QVBoxLayout(smart_intersection_tab)
|
|
|
|
# Smart Intersection config widget
|
|
si_scroll = QScrollArea()
|
|
si_scroll.setWidgetResizable(True)
|
|
si_scroll.setHorizontalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
|
|
si_scroll.setStyleSheet("""
|
|
QScrollArea {
|
|
border: none;
|
|
background: transparent;
|
|
}
|
|
""")
|
|
|
|
try:
|
|
from ui.smart_intersection_config import SmartIntersectionConfigPanel
|
|
self.smart_intersection_config = SmartIntersectionConfigPanel()
|
|
si_scroll.setWidget(self.smart_intersection_config)
|
|
print("[CONFIG PANEL DEBUG] Smart Intersection config panel created successfully")
|
|
except Exception as e:
|
|
print(f"[CONFIG PANEL DEBUG] Error creating Smart Intersection config: {e}")
|
|
self.smart_intersection_config = None
|
|
si_scroll.setWidget(QLabel(f"Smart Intersection config unavailable: {e}"))
|
|
|
|
si_layout.addWidget(si_scroll)
|
|
|
|
# Add all tabs
|
|
tabs.addTab(detection_tab, "Detection")
|
|
tabs.addTab(display_tab, "Display")
|
|
tabs.addTab(violation_tab, "Violations")
|
|
tabs.addTab(vlm_tab, "🤖 AI Insights") # Add VLM insights tab
|
|
tabs.addTab(smart_intersection_tab, "🚦 Smart Intersection") # Add Smart Intersection tab
|
|
print("[CONFIG PANEL DEBUG] Added AI Insights and Smart Intersection tabs to config panel")
|
|
|
|
layout.addWidget(tabs)
|
|
|
|
# Theme toggle
|
|
self.theme_toggle = QPushButton("🌙 Dark Theme")
|
|
self.theme_toggle.setFixedHeight(36)
|
|
self.theme_toggle.setStyleSheet("margin-top: 8px;")
|
|
self.theme_toggle.clicked.connect(self.toggle_theme)
|
|
layout.addWidget(self.theme_toggle)
|
|
|
|
# Spacer to push buttons to bottom
|
|
layout.addItem(QSpacerItem(20, 40, QSizePolicy.Minimum, QSizePolicy.Expanding))
|
|
|
|
# Control buttons (fixed at bottom)
|
|
btns = QHBoxLayout()
|
|
self.apply_btn = QPushButton("Apply")
|
|
self.apply_btn.setFixedHeight(32)
|
|
self.apply_btn.clicked.connect(self.apply_config)
|
|
|
|
self.reset_btn = QPushButton("Reset")
|
|
self.reset_btn.setFixedHeight(32)
|
|
self.reset_btn.clicked.connect(self.reset_config)
|
|
|
|
btns.addWidget(self.apply_btn)
|
|
btns.addWidget(self.reset_btn)
|
|
layout.addLayout(btns)
|
|
|
|
layout.addStretch(1) # Push everything to the top
|
|
|
|
# Set tooltips for major controls
|
|
self.device_combo.setToolTip("Select inference device (CPU, GPU, etc.)")
|
|
self.cpu_switch_btn.setToolTip("Switch to CPU-optimized YOLO11n model")
|
|
self.gpu_switch_btn.setToolTip("Switch to GPU-optimized YOLO11x model")
|
|
self.conf_slider.setToolTip("Set detection confidence threshold")
|
|
self.tracking_checkbox.setToolTip("Enable or disable object tracking")
|
|
self.model_path.setToolTip("Path to the detection model")
|
|
self.browse_btn.setToolTip("Browse for a model file")
|
|
self.labels_checkbox.setToolTip("Show/hide detection labels on video")
|
|
self.confidence_checkbox.setToolTip("Show/hide confidence scores on video")
|
|
self.perf_checkbox.setToolTip("Show/hide performance overlay")
|
|
self.max_width.setToolTip("Maximum display width for video")
|
|
self.charts_checkbox.setToolTip("Enable/disable live analytics charts")
|
|
self.history_spinbox.setToolTip("Number of frames to keep in analytics history")
|
|
self.red_light_grace.setToolTip("Grace period for red light violation (seconds)")
|
|
self.stop_sign_duration.setToolTip("Stop sign violation duration (seconds)")
|
|
self.speed_tolerance.setToolTip("Speed tolerance for speed violation (km/h)")
|
|
self.enable_red_light.setToolTip("Enable/disable red light violation detection")
|
|
self.enable_stop_sign.setToolTip("Enable/disable stop sign violation detection")
|
|
self.enable_speed.setToolTip("Enable/disable speed violation detection")
|
|
self.enable_lane.setToolTip("Enable/disable lane violation detection")
|
|
self.theme_toggle.setToolTip("Toggle between dark and light theme")
|
|
self.apply_btn.setToolTip("Apply all changes")
|
|
self.reset_btn.setToolTip("Reset all settings to default")
|
|
|
|
@Slot(int)
|
|
def update_conf_label(self, value):
|
|
"""Update confidence threshold label"""
|
|
self.conf_label.setText(f"{value}%")
|
|
|
|
@Slot()
|
|
def browse_model(self):
|
|
"""Browse for model file"""
|
|
file_path, _ = QFileDialog.getOpenFileName(
|
|
self,
|
|
"Select Model File",
|
|
"",
|
|
"OpenVINO Models (*.xml);;PyTorch Models (*.pt);;All Files (*)"
|
|
)
|
|
|
|
if file_path:
|
|
self.model_path.setText(file_path)
|
|
|
|
@Slot()
|
|
def toggle_theme(self):
|
|
"""Toggle between light and dark theme"""
|
|
self.dark_theme = not self.dark_theme
|
|
|
|
if self.dark_theme:
|
|
self.theme_toggle.setText("🌙 Dark Theme")
|
|
else:
|
|
self.theme_toggle.setText("☀️ Light Theme")
|
|
|
|
self.theme_toggled.emit(self.dark_theme)
|
|
|
|
@Slot()
|
|
def apply_config(self):
|
|
"""Apply configuration changes"""
|
|
config = self.get_config()
|
|
self.config_changed.emit(config)
|
|
|
|
@Slot()
|
|
def reset_config(self):
|
|
"""Reset configuration to defaults"""
|
|
self.device_combo.setCurrentText("AUTO")
|
|
self.conf_slider.setValue(50)
|
|
self.tracking_checkbox.setChecked(True)
|
|
self.labels_checkbox.setChecked(True)
|
|
self.confidence_checkbox.setChecked(True)
|
|
self.perf_checkbox.setChecked(True)
|
|
self.max_width.setValue(800)
|
|
self.red_light_grace.setValue(2.0)
|
|
self.stop_sign_duration.setValue(2.0)
|
|
self.speed_tolerance.setValue(5)
|
|
self.enable_red_light.setChecked(True)
|
|
self.enable_stop_sign.setChecked(True)
|
|
self.enable_speed.setChecked(True)
|
|
self.enable_lane.setChecked(True)
|
|
self.model_path.setText("")
|
|
|
|
self.apply_config()
|
|
|
|
def quick_switch_device(self, device: str):
|
|
index = self.device_combo.findText(device)
|
|
if index >= 0:
|
|
self.device_combo.setCurrentIndex(index)
|
|
self.device_switch_requested.emit(device)
|
|
self.apply_config()
|
|
|
|
def update_model_info(self, model_info: dict):
|
|
if not model_info:
|
|
self.current_model_label.setText("No model loaded")
|
|
self.current_device_label.setText("None")
|
|
self.model_recommendation_label.setText("None")
|
|
return
|
|
model_name = model_info.get("model_name", "Unknown")
|
|
device = model_info.get("device", "Unknown")
|
|
recommended_for = model_info.get("recommended_for", "Unknown")
|
|
self.current_model_label.setText(model_name)
|
|
self.current_device_label.setText(device)
|
|
self.model_recommendation_label.setText(recommended_for)
|
|
if device == "CPU":
|
|
self.cpu_switch_btn.setEnabled(False)
|
|
self.cpu_switch_btn.setText("✓ CPU Active (YOLO11n)")
|
|
self.gpu_switch_btn.setEnabled(True)
|
|
self.gpu_switch_btn.setText("Switch to GPU (YOLO11x)")
|
|
elif device == "GPU":
|
|
self.cpu_switch_btn.setEnabled(True)
|
|
self.cpu_switch_btn.setText("Switch to CPU (YOLO11n)")
|
|
self.gpu_switch_btn.setEnabled(False)
|
|
self.gpu_switch_btn.setText("✓ GPU Active (YOLO11x)")
|
|
else:
|
|
self.cpu_switch_btn.setEnabled(True)
|
|
self.cpu_switch_btn.setText("Switch to CPU (YOLO11n)")
|
|
self.gpu_switch_btn.setEnabled(True)
|
|
self.gpu_switch_btn.setText("Switch to GPU (YOLO11x)")
|
|
|
|
@Slot(object, object)
|
|
def update_live_stats(self, fps, inference_time):
|
|
"""Update FPS and inference time labels in the settings panel."""
|
|
if fps is not None:
|
|
self.fps_label.setText(f"FPS: {fps:.1f}")
|
|
else:
|
|
self.fps_label.setText("FPS: --")
|
|
if inference_time is not None:
|
|
self.infer_label.setText(f"Inference: {inference_time:.1f} ms")
|
|
else:
|
|
self.infer_label.setText("Inference: -- ms")
|
|
|
|
@Slot(object, object)
|
|
def set_video_stats(self, stats):
|
|
"""Update FPS and inference time labels in the settings panel from stats dict."""
|
|
fps = stats.get('fps', None)
|
|
inference_time = None
|
|
if 'detection_time_ms' in stats:
|
|
inference_time = float(stats['detection_time_ms'])
|
|
elif 'detection_time' in stats:
|
|
inference_time = float(stats['detection_time'])
|
|
self.update_live_stats(fps, inference_time)
|
|
|
|
def get_config(self):
|
|
"""
|
|
Get current configuration from UI.
|
|
|
|
Returns:
|
|
Configuration dictionary
|
|
"""
|
|
return {
|
|
'detection': {
|
|
'device': self.device_combo.currentText(),
|
|
'confidence_threshold': self.conf_slider.value() / 100.0,
|
|
'enable_tracking': self.tracking_checkbox.isChecked(),
|
|
'model_path': self.model_path.text() if self.model_path.text() else None
|
|
},
|
|
'display': {
|
|
'show_labels': self.labels_checkbox.isChecked(),
|
|
'show_confidence': self.confidence_checkbox.isChecked(),
|
|
'show_performance': self.perf_checkbox.isChecked(),
|
|
'max_display_width': self.max_width.value()
|
|
},
|
|
'violations': {
|
|
'red_light_grace_period': self.red_light_grace.value(),
|
|
'stop_sign_duration': self.stop_sign_duration.value(),
|
|
'speed_tolerance': self.speed_tolerance.value(),
|
|
'enable_red_light': self.enable_red_light.isChecked(),
|
|
'enable_stop_sign': self.enable_stop_sign.isChecked(),
|
|
'enable_speed': self.enable_speed.isChecked(),
|
|
'enable_lane': self.enable_lane.isChecked()
|
|
},
|
|
'analytics': {
|
|
'enable_charts': self.charts_checkbox.isChecked(),
|
|
'history_length': self.history_spinbox.value()
|
|
}
|
|
}
|
|
|
|
def set_config(self, config):
|
|
"""
|
|
Set configuration in UI.
|
|
|
|
Args:
|
|
config: Configuration dictionary
|
|
"""
|
|
if not config:
|
|
return
|
|
|
|
# Detection settings
|
|
detection = config.get('detection', {})
|
|
if 'device' in detection:
|
|
index = self.device_combo.findText(detection['device'])
|
|
if index >= 0:
|
|
self.device_combo.setCurrentIndex(index)
|
|
|
|
if 'confidence_threshold' in detection:
|
|
self.conf_slider.setValue(int(detection['confidence_threshold'] * 100))
|
|
|
|
if 'enable_tracking' in detection:
|
|
self.tracking_checkbox.setChecked(detection['enable_tracking'])
|
|
|
|
if 'model_path' in detection and detection['model_path']:
|
|
self.model_path.setText(detection['model_path'])
|
|
|
|
# Display settings
|
|
display = config.get('display', {})
|
|
if 'show_labels' in display:
|
|
self.labels_checkbox.setChecked(display['show_labels'])
|
|
|
|
if 'show_confidence' in display:
|
|
self.confidence_checkbox.setChecked(display['show_confidence'])
|
|
|
|
if 'show_performance' in display:
|
|
self.perf_checkbox.setChecked(display['show_performance'])
|
|
|
|
if 'max_display_width' in display:
|
|
self.max_width.setValue(display['max_display_width'])
|
|
|
|
# Violation settings
|
|
violations = config.get('violations', {})
|
|
if 'red_light_grace_period' in violations:
|
|
self.red_light_grace.setValue(violations['red_light_grace_period'])
|
|
|
|
if 'stop_sign_duration' in violations:
|
|
self.stop_sign_duration.setValue(violations['stop_sign_duration'])
|
|
|
|
if 'speed_tolerance' in violations:
|
|
self.speed_tolerance.setValue(violations['speed_tolerance'])
|
|
|
|
if 'enable_red_light' in violations:
|
|
self.enable_red_light.setChecked(violations['enable_red_light'])
|
|
|
|
if 'enable_stop_sign' in violations:
|
|
self.enable_stop_sign.setChecked(violations['enable_stop_sign'])
|
|
|
|
if 'enable_speed' in violations:
|
|
self.enable_speed.setChecked(violations['enable_speed'])
|
|
|
|
if 'enable_lane' in violations:
|
|
self.enable_lane.setChecked(violations['enable_lane'])
|
|
|
|
# Analytics settings
|
|
analytics = config.get('analytics', {})
|
|
if 'enable_charts' in analytics:
|
|
self.charts_checkbox.setChecked(analytics['enable_charts'])
|
|
|
|
if 'history_length' in analytics:
|
|
self.history_spinbox.setValue(analytics['history_length'])
|
|
|
|
@Slot(object)
|
|
def update_devices_info(self, device_info: dict):
|
|
"""
|
|
Update the OpenVINO devices info section with the given device info dict.
|
|
"""
|
|
print(f"[UI] update_devices_info called with: {device_info}", flush=True) # DEBUG
|
|
if not device_info:
|
|
self.devices_info_text.setText("<span style='color:#ffb300;'>No OpenVINO device info received.<br>Check if OpenVINO is installed and the backend emits device_info_ready.</span>")
|
|
return
|
|
if 'error' in device_info:
|
|
self.devices_info_text.setText(f"<span style='color:#ff5370;'>Error: {device_info['error']}</span>")
|
|
return
|
|
text = ""
|
|
for device, props in device_info.items():
|
|
text += f"<b>{device}</b><br>"
|
|
if isinstance(props, dict) and props:
|
|
for k, v in props.items():
|
|
text += f" <span style='color:#b2dfdb;'>{k}</span>: <span style='color:#fff'>{v}</span><br>"
|
|
else:
|
|
text += " <span style='color:#888'>No properties</span><br>"
|
|
text += "<br>"
|
|
self.devices_info_text.setText(f"<div style='font-size:13px;'>{text}</div>")
|
|
self.devices_info_text.repaint() # Force repaint in case of async update
|