1339 lines
41 KiB
C++
1339 lines
41 KiB
C++
#include "mainwindow.h"
|
||
#include "ui_mainwindow.h"
|
||
|
||
#include <QAbstractItemView>
|
||
#include <QApplication>
|
||
#include <QBrush>
|
||
#include <QCloseEvent>
|
||
#include <QComboBox>
|
||
#include <QDateTime>
|
||
#include <QDir>
|
||
#include <QFileDialog>
|
||
#include <QHBoxLayout>
|
||
#include <QIcon>
|
||
#include <QLabel>
|
||
#include <QLineEdit>
|
||
#include <QListWidgetItem>
|
||
#include <QMetaObject>
|
||
#include <QPushButton>
|
||
#include <QResizeEvent>
|
||
#include <QScroller>
|
||
#include <QScrollerProperties>
|
||
#include <QSignalBlocker>
|
||
#include <QStandardPaths>
|
||
#include <QThread>
|
||
#include <QTimer>
|
||
#include <QVariant>
|
||
#include <QVBoxLayout>
|
||
|
||
#include <algorithm>
|
||
#include <thread>
|
||
|
||
#include "IVrUtils.h"
|
||
#include "IVrConfig.h"
|
||
#include "PathManager.h"
|
||
#include "dialogcontrolpassword.h"
|
||
#include "SingleTargetResultWidget.h"
|
||
#include "StyledMessageBox.h"
|
||
#include "Version.h"
|
||
#include "VrDateUtils.h"
|
||
#include "VrLog.h"
|
||
|
||
namespace {
|
||
|
||
void EnableComboBoxTouchScroll(QComboBox* combo)
|
||
{
|
||
if (!combo) {
|
||
return;
|
||
}
|
||
|
||
// 触摸屏下拉一次显示有限项，其余靠滑动和滚动条选择。
|
||
combo->setMaxVisibleItems(8);
|
||
QAbstractItemView* view = combo->view();
|
||
if (!view) {
|
||
return;
|
||
}
|
||
view->setVerticalScrollBarPolicy(Qt::ScrollBarAlwaysOn);
|
||
view->setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
|
||
view->setVerticalScrollMode(QAbstractItemView::ScrollPerPixel);
|
||
view->setTextElideMode(Qt::ElideNone);
|
||
QWidget* viewport = view->viewport();
|
||
viewport->setAttribute(Qt::WA_AcceptTouchEvents, true);
|
||
QScroller::grabGesture(viewport, QScroller::LeftMouseButtonGesture);
|
||
QScroller* scroller = QScroller::scroller(viewport);
|
||
if (scroller) {
|
||
QScrollerProperties properties = scroller->scrollerProperties();
|
||
properties.setScrollMetric(
|
||
QScrollerProperties::VerticalOvershootPolicy,
|
||
QVariant(static_cast<int>(QScrollerProperties::OvershootAlwaysOff)));
|
||
scroller->setScrollerProperties(properties);
|
||
}
|
||
}
|
||
|
||
QString GuideStateName(ParkingGuideState state)
|
||
{
|
||
switch (state) {
|
||
case ParkingGuideState::DockingStarted:
|
||
return QStringLiteral("泊位引导启动");
|
||
case ParkingGuideState::Capturing:
|
||
return QStringLiteral("捕获");
|
||
case ParkingGuideState::Tracking:
|
||
return QStringLiteral("跟踪");
|
||
case ParkingGuideState::ApproachRate:
|
||
return QStringLiteral("接近率");
|
||
case ParkingGuideState::CenterLineAligned:
|
||
return QStringLiteral("对准中心线");
|
||
case ParkingGuideState::Slow:
|
||
return QStringLiteral("慢速");
|
||
case ParkingGuideState::AzimuthGuidance:
|
||
return QStringLiteral("方位引导");
|
||
case ParkingGuideState::StopPositionReached:
|
||
return QStringLiteral("到达停止位置");
|
||
case ParkingGuideState::DockingCompleted:
|
||
return QStringLiteral("泊位引导完成");
|
||
case ParkingGuideState::Overshot:
|
||
return QStringLiteral("越位");
|
||
case ParkingGuideState::StoppedShort:
|
||
return QStringLiteral("提前停止");
|
||
case ParkingGuideState::Waiting:
|
||
return QStringLiteral("等待");
|
||
case ParkingGuideState::SlowBadWeather:
|
||
return QStringLiteral("异常慢速-恶劣天气");
|
||
case ParkingGuideState::SlowAircraftLost:
|
||
return QStringLiteral("异常慢速-飞机丢失");
|
||
case ParkingGuideState::AircraftVerificationFailed:
|
||
return QStringLiteral("飞机验证失败");
|
||
case ParkingGuideState::GateBlocked:
|
||
return QStringLiteral("机位受阻");
|
||
case ParkingGuideState::ViewBlocked:
|
||
return QStringLiteral("视野受阻");
|
||
case ParkingGuideState::SbuStop:
|
||
return QStringLiteral("SBU停止");
|
||
case ParkingGuideState::TooFast:
|
||
return QStringLiteral("速度过快");
|
||
case ParkingGuideState::EmergencyStop:
|
||
return QStringLiteral("紧急停止");
|
||
case ParkingGuideState::ChocksOn:
|
||
return QStringLiteral("挡轮挡");
|
||
case ParkingGuideState::SystemError:
|
||
return QStringLiteral("系统错误");
|
||
case ParkingGuideState::SystemFailure:
|
||
return QStringLiteral("系统故障");
|
||
case ParkingGuideState::PowerFailure:
|
||
return QStringLiteral("电源故障");
|
||
case ParkingGuideState::Unknown:
|
||
default:
|
||
return QStringLiteral("未知");
|
||
}
|
||
}
|
||
|
||
QString FormatGuideState(const ParkingSpaceGuideInfo& info)
|
||
{
|
||
const ParkingGuideState state = ParkingGuideStateFromCode(info.guideStateCode);
|
||
const int displayCode = state == ParkingGuideState::Unknown
|
||
? info.guideStateCode
|
||
: static_cast<int>(state);
|
||
QString text = QStringLiteral("%1 %2").arg(displayCode).arg(GuideStateName(state));
|
||
|
||
const QString guideText = info.guideText.trimmed();
|
||
if (!guideText.isEmpty()) {
|
||
text += QStringLiteral(" / %1").arg(guideText);
|
||
}
|
||
return text;
|
||
}
|
||
|
||
QString FormatNumber(double value, const QString& unit, int precision = 2)
|
||
{
|
||
return QStringLiteral("%1%2").arg(value, 0, 'f', precision).arg(unit);
|
||
}
|
||
|
||
bool IsKnownAircraftModel(const QString& modelType)
|
||
{
|
||
const QString normalized = modelType.trimmed().toUpper();
|
||
return !normalized.isEmpty() &&
|
||
normalized != QStringLiteral("未知") &&
|
||
normalized != QStringLiteral("请选择机型");
|
||
}
|
||
|
||
QString FormatModelVerification(const ParkingSpaceGuideInfo& info)
|
||
{
|
||
const QString expected = info.expectedModelType.trimmed().toUpper();
|
||
const QString recognized = info.modelType.trimmed().toUpper();
|
||
if (!IsKnownAircraftModel(recognized)) {
|
||
return QStringLiteral("未知");
|
||
}
|
||
if (!IsKnownAircraftModel(expected)) {
|
||
return QStringLiteral("实测(%1)").arg(recognized);
|
||
}
|
||
if (info.modelMatched) {
|
||
return QStringLiteral("匹配(%1)").arg(recognized);
|
||
}
|
||
if (recognized.compare(expected, Qt::CaseInsensitive) != 0) {
|
||
return QStringLiteral("不匹配(%1)").arg(recognized);
|
||
}
|
||
return QStringLiteral("未知");
|
||
}
|
||
|
||
void ConfigureResultWidget(SingleTargetResultWidget* resultWidget)
|
||
{
|
||
if (!resultWidget) {
|
||
return;
|
||
}
|
||
|
||
// Keep this presentation local to ParkingSpaceGuide; UICommon defaults are shared by other apps.
|
||
auto* mainLayout = qobject_cast<QVBoxLayout*>(resultWidget->layout());
|
||
if (mainLayout) {
|
||
mainLayout->setContentsMargins(96, 12, 96, 12);
|
||
}
|
||
if (mainLayout && mainLayout->count() > 0) {
|
||
auto* headerLayout = qobject_cast<QHBoxLayout*>(mainLayout->itemAt(0)->layout());
|
||
if (headerLayout && headerLayout->count() == 2) {
|
||
headerLayout->setSpacing(12);
|
||
headerLayout->setStretch(0, 0);
|
||
headerLayout->setStretch(1, 0);
|
||
headerLayout->addStretch(1);
|
||
}
|
||
}
|
||
|
||
resultWidget->setStyleSheet(
|
||
resultWidget->styleSheet()
|
||
+ QStringLiteral(
|
||
"#singleTargetTitle { font-size: 42px; }"
|
||
"#singleTargetStatus { font-size: 48px; font-weight: 700; padding: 0; }"
|
||
"#singleTargetEmpty { font-size: 42px; }"
|
||
"#singleTargetFieldName { font-size: 38px; }"
|
||
"#singleTargetFieldValue { font-size: 40px; }"));
|
||
|
||
auto* statusLabel = resultWidget->findChild<QLabel*>(QStringLiteral("singleTargetStatus"));
|
||
if (statusLabel) {
|
||
statusLabel->setStyleSheet(QStringLiteral("background-color: transparent;"));
|
||
}
|
||
}
|
||
|
||
} // namespace
|
||
|
||
MainWindow::MainWindow(QWidget* parent)
|
||
: MainWindow(ParkingSpaceGuideSimulationOptions(), parent)
|
||
{
|
||
}
|
||
|
||
MainWindow::MainWindow(const ParkingSpaceGuideSimulationOptions& simulationOptions,
|
||
QWidget* parent)
|
||
: QMainWindow(parent)
|
||
, ui(new Ui::MainWindow)
|
||
, m_simulationOptions(simulationOptions)
|
||
{
|
||
ui->setupUi(this);
|
||
EnableComboBoxTouchScroll(ui->combo_model);
|
||
setWindowTitle(m_simulationOptions.enabled
|
||
? QStringLiteral("停机引导（仿真）")
|
||
: QStringLiteral("停机引导"));
|
||
if (ui->label) {
|
||
ui->label->setText(QStringLiteral("停机引导"));
|
||
}
|
||
|
||
#ifdef _WIN32
|
||
setWindowIcon(QIcon(":/common/resource/logo.ico"));
|
||
#else
|
||
setWindowIcon(QIcon(":/common/resource/logo.png"));
|
||
#endif
|
||
|
||
QFont statusFont = statusBar()->font();
|
||
statusFont.setPointSize(12);
|
||
statusBar()->setFont(statusFont);
|
||
statusBar()->setStyleSheet("QStatusBar { color: rgb(239, 241, 245); padding: 20px; }");
|
||
|
||
const QString versionWithBuildTime = QString("%1_%2%3%4%5%6%7")
|
||
.arg(GetParkingSpaceGuideFullVersion())
|
||
.arg(YEAR)
|
||
.arg(MONTH, 2, 10, QChar('0'))
|
||
.arg(DAY, 2, 10, QChar('0'))
|
||
.arg(HOUR, 2, 10, QChar('0'))
|
||
.arg(MINUTE, 2, 10, QChar('0'))
|
||
.arg(SECOND, 2, 10, QChar('0'));
|
||
|
||
m_versionLabel = new QLabel(versionWithBuildTime);
|
||
m_versionLabel->setStyleSheet("color: rgb(239, 241, 245); font-size: 20px; margin-right: 16px;");
|
||
m_versionLabel->setCursor(Qt::PointingHandCursor);
|
||
m_versionLabel->installEventFilter(this);
|
||
statusBar()->addPermanentWidget(m_versionLabel);
|
||
|
||
setWindowFlags(Qt::FramelessWindowHint);
|
||
showMaximized();
|
||
|
||
if (ui->label_work) {
|
||
ui->label_work->setCursor(Qt::PointingHandCursor);
|
||
ui->label_work->installEventFilter(this);
|
||
updateWorkModeLabel();
|
||
}
|
||
|
||
m_logHelper = new DetectLogHelper(ui->detect_log, this);
|
||
|
||
qRegisterMetaType<DetectionResult>("DetectionResult");
|
||
qRegisterMetaType<WorkStatus>("WorkStatus");
|
||
qRegisterMetaType<ParkingSpaceGuidePosition>("ParkingSpaceGuidePosition");
|
||
|
||
connect(this, &MainWindow::workStatusUpdateRequested,
|
||
this, &MainWindow::updateWorkStatusLabel,
|
||
Qt::QueuedConnection);
|
||
setupContextMenu();
|
||
updateStatusLog(tr("设备初始化开始"));
|
||
Init();
|
||
}
|
||
|
||
MainWindow::~MainWindow()
|
||
{
|
||
if (m_presenter) {
|
||
m_presenter->RequestShutdown();
|
||
}
|
||
if (m_initThread.joinable()) {
|
||
m_initThread.join();
|
||
}
|
||
if (m_testThread.joinable()) {
|
||
m_testThread.join();
|
||
}
|
||
|
||
if (m_presenter) {
|
||
m_presenter->DeinitApp();
|
||
m_presenter->SetStatusCallback(static_cast<IYParkingSpaceGuideStatus*>(nullptr));
|
||
delete m_presenter;
|
||
m_presenter = nullptr;
|
||
}
|
||
|
||
delete ui;
|
||
}
|
||
|
||
void MainWindow::closeEvent(QCloseEvent* event)
|
||
{
|
||
if (m_shutdownComplete) {
|
||
event->accept();
|
||
return;
|
||
}
|
||
|
||
event->ignore();
|
||
if (m_closing.exchange(true)) {
|
||
return;
|
||
}
|
||
|
||
QApplication::setQuitOnLastWindowClosed(false);
|
||
setEnabled(false);
|
||
hide();
|
||
if (m_presenter) {
|
||
LOG_INFO("[ParkingSpaceGuide][Shutdown] MainWindow close requested\n");
|
||
m_presenter->RequestShutdown();
|
||
}
|
||
QTimer::singleShot(0, this, &MainWindow::continueShutdown);
|
||
}
|
||
|
||
void MainWindow::continueShutdown()
|
||
{
|
||
if (m_initRunning.load() || m_testRunning.load()) {
|
||
QTimer::singleShot(20, this, &MainWindow::continueShutdown);
|
||
return;
|
||
}
|
||
|
||
LOG_INFO("[ParkingSpaceGuide][Shutdown] MainWindow worker threads complete\n");
|
||
if (m_initThread.joinable()) {
|
||
m_initThread.join();
|
||
}
|
||
if (m_testThread.joinable()) {
|
||
m_testThread.join();
|
||
}
|
||
if (m_presenter) {
|
||
LOG_INFO("[ParkingSpaceGuide][Shutdown] MainWindow DeinitApp begin\n");
|
||
m_presenter->DeinitApp();
|
||
m_presenter->SetStatusCallback(static_cast<IYParkingSpaceGuideStatus*>(nullptr));
|
||
LOG_INFO("[ParkingSpaceGuide][Shutdown] MainWindow DeinitApp complete\n");
|
||
}
|
||
|
||
m_shutdownComplete = true;
|
||
QApplication::quit();
|
||
}
|
||
|
||
bool MainWindow::eventFilter(QObject* obj, QEvent* event)
|
||
{
|
||
if (obj == m_versionLabel && event->type() == QEvent::MouseButtonPress) {
|
||
const QString algoVersion = m_presenter ? m_presenter->GetAlgoVersion() : QString();
|
||
AboutDialog dlg(PARKINGSPACEGUIDE_APP_NAME, m_versionLabel->text(), algoVersion, this);
|
||
dlg.exec();
|
||
return true;
|
||
}
|
||
if (obj == ui->label_work && event->type() == QEvent::MouseButtonPress) {
|
||
if (!m_presenter || safetyControlsLocked() || m_initRunning.load()) {
|
||
return true;
|
||
}
|
||
// 开始引导后禁止切换正常/维护模式。
|
||
if (m_presenter->IsDetectionRunning()) {
|
||
updateStatusLog(tr("停机引导运行中，禁止切换工作模式"));
|
||
return true;
|
||
}
|
||
const bool nextMaintenance = !m_presenter->IsMaintenanceMode();
|
||
if (!promptControlPassword(nextMaintenance
|
||
? tr("进入维护模式")
|
||
: tr("退出维护模式"))) {
|
||
return true;
|
||
}
|
||
if (m_presenter->SetMaintenanceMode(nextMaintenance)) {
|
||
updateWorkModeLabel();
|
||
updateStatusLog(nextMaintenance
|
||
? tr("已进入维护模式")
|
||
: tr("已退出维护模式"));
|
||
}
|
||
return true;
|
||
}
|
||
|
||
return QMainWindow::eventFilter(obj, event);
|
||
}
|
||
|
||
void MainWindow::updateStatusLog(const QString& message)
|
||
{
|
||
if (QThread::currentThread() != thread()) {
|
||
QMetaObject::invokeMethod(this, [this, message]() {
|
||
updateStatusLog(message);
|
||
}, Qt::QueuedConnection);
|
||
return;
|
||
}
|
||
|
||
if (m_logHelper) {
|
||
m_logHelper->appendLog(message);
|
||
}
|
||
}
|
||
|
||
void MainWindow::clearDetectionLog()
|
||
{
|
||
if (m_logHelper) {
|
||
m_logHelper->clearLog();
|
||
}
|
||
}
|
||
|
||
void MainWindow::Init()
|
||
{
|
||
m_presenter = new ParkingSpaceGuidePresenter(m_simulationOptions);
|
||
m_presenter->SetStatusCallback<IYParkingSpaceGuideStatus>(this);
|
||
connect(m_presenter,
|
||
&ParkingSpaceGuidePresenter::SelectedModelChanged,
|
||
this,
|
||
[this](const QString& modelType) {
|
||
setAircraftModelSelection(modelType);
|
||
},
|
||
Qt::QueuedConnection);
|
||
|
||
m_deviceStatusWidget = new DeviceStatusWidget(ui->frame_dev);
|
||
m_deviceStatusWidget->setCameraCount(2, true);
|
||
m_deviceStatusWidget->setCamera1Name(tr("相机"));
|
||
m_deviceStatusWidget->setCamera2Name(tr("雷达"));
|
||
m_deviceStatusWidget->setRobotVisible(false);
|
||
connect(m_deviceStatusWidget, SIGNAL(cameraClicked(int)), this, SLOT(onCameraClicked(int)));
|
||
|
||
auto* frameDevLayout = new QVBoxLayout(ui->frame_dev);
|
||
frameDevLayout->setContentsMargins(0, 0, 0, 0);
|
||
frameDevLayout->addWidget(m_deviceStatusWidget);
|
||
|
||
SingleTargetResultWidget::setupListWidget(ui->detect_result_list, QSize(520, 420));
|
||
ensureResultWidget();
|
||
updateSystemStatusLabel();
|
||
|
||
setButtonsEnabled(false);
|
||
|
||
m_initRunning.store(true);
|
||
m_initThread = std::thread([this]() {
|
||
updateStatusLog(tr("系统初始化中..."));
|
||
|
||
const int result = m_presenter->Init();
|
||
if (m_closing.load()) {
|
||
m_initRunning.store(false);
|
||
return;
|
||
}
|
||
if (result != 0) {
|
||
updateStatusLog(tr("初始化失败，错误码：%1").arg(result));
|
||
} else {
|
||
updateStatusLog(tr("初始化完成"));
|
||
QMetaObject::invokeMethod(this, [this]() {
|
||
populateAircraftModels();
|
||
addDetectionResult(DetectionResult());
|
||
updateWorkModeLabel();
|
||
}, Qt::QueuedConnection);
|
||
if (m_simulationOptions.enabled) {
|
||
updateStatusLog(tr("仿真数据已全部加载到内存，请选择机型并点击开始进行回放"));
|
||
} else {
|
||
updateStatusLog(tr("请选择机型并点击开始"));
|
||
}
|
||
}
|
||
m_initRunning.store(false);
|
||
// 初始化线程结束后再按实际引导状态刷新按钮，避免停止键一直被关掉
|
||
if (!m_closing.load()) {
|
||
QMetaObject::invokeMethod(this, [this]() {
|
||
if (m_closing.load()) {
|
||
return;
|
||
}
|
||
setButtonsEnabled(true);
|
||
}, Qt::QueuedConnection);
|
||
}
|
||
});
|
||
}
|
||
|
||
void MainWindow::ensureResultWidget()
|
||
{
|
||
if (m_resultWidget && m_resultItem) {
|
||
return;
|
||
}
|
||
|
||
m_resultWidget = new SingleTargetResultWidget();
|
||
m_resultWidget->setAutoFillBackground(true);
|
||
m_resultItem = new QListWidgetItem();
|
||
m_resultItem->setBackground(QBrush(Qt::transparent));
|
||
m_resultItem->setFlags(m_resultItem->flags() &
|
||
~Qt::ItemIsDragEnabled &
|
||
~Qt::ItemIsDropEnabled);
|
||
ui->detect_result_list->addItem(m_resultItem);
|
||
ui->detect_result_list->setItemWidget(m_resultItem, m_resultWidget);
|
||
ConfigureResultWidget(m_resultWidget);
|
||
updateResultItemSize();
|
||
addDetectionResult(DetectionResult());
|
||
}
|
||
|
||
void MainWindow::updateResultItemSize()
|
||
{
|
||
if (!m_resultItem || !ui || !ui->detect_result_list) {
|
||
return;
|
||
}
|
||
|
||
const int itemWidth = (std::max)(
|
||
360,
|
||
ui->detect_result_list->viewport()->width() - 8);
|
||
const int itemHeight = (std::max)(
|
||
360,
|
||
ui->detect_result_list->viewport()->height());
|
||
const QSize itemSize(itemWidth, itemHeight);
|
||
if (m_resultItem->sizeHint() != itemSize) {
|
||
m_resultItem->setSizeHint(itemSize);
|
||
SingleTargetResultWidget::setupListWidget(
|
||
ui->detect_result_list,
|
||
itemSize);
|
||
}
|
||
}
|
||
|
||
void MainWindow::addDetectionResult(const DetectionResult& result)
|
||
{
|
||
ensureResultWidget();
|
||
|
||
ParkingSpaceGuideInfo displayInfo;
|
||
if (result.parkingSpaceInfoList.empty()) {
|
||
displayInfo.targetId = currentTargetId();
|
||
displayInfo.parkId = currentParkId();
|
||
displayInfo.expectedModelType.clear();
|
||
displayInfo.modelType = QStringLiteral("未知");
|
||
displayInfo.guideStateCode = static_cast<int>(ParkingGuideState::Waiting);
|
||
displayInfo.guideText = QStringLiteral("WAIT");
|
||
} else {
|
||
displayInfo = result.parkingSpaceInfoList.front();
|
||
}
|
||
|
||
const ParkingSpaceGuideInfo& info = displayInfo;
|
||
const ParkingGuideState guideState = ParkingGuideStateFromCode(info.guideStateCode);
|
||
m_resultWidget->setTitle(tr("当前状态"));
|
||
m_resultWidget->setStatus(
|
||
QStringLiteral("%1(%2)")
|
||
.arg(GuideStateName(guideState))
|
||
.arg(info.guideStateCode),
|
||
info.hasException || guideState == ParkingGuideState::EmergencyStop);
|
||
QLabel* statusLabel = m_resultWidget->findChild<QLabel*>(
|
||
QStringLiteral("singleTargetStatus"));
|
||
if (statusLabel) {
|
||
statusLabel->setStyleSheet(
|
||
QStringLiteral("background-color: transparent;"));
|
||
}
|
||
m_resultWidget->setFields({
|
||
{tr("目标编号"), info.targetId},
|
||
{tr("停机位"), info.parkId},
|
||
{tr("机型校验"), FormatModelVerification(info)},
|
||
{tr("轮挡区域人员"), info.personInChockRegion
|
||
? tr("已检测") : tr("未检测")},
|
||
{tr("区域人数"), QString::number(info.personCount)},
|
||
{tr("引导状态"), FormatGuideState(info)},
|
||
{tr("到停止线"), FormatNumber(info.distance, tr("毫米"), 0)},
|
||
{tr("横向偏移"), FormatNumber(info.lateralOffset, tr("毫米"), 0)},
|
||
{tr("偏转角"), FormatNumber(info.angle, tr("度"))},
|
||
{tr("速度"), FormatNumber(info.aircraftSpeed, tr("米/秒"), 2)}
|
||
});
|
||
}
|
||
|
||
void MainWindow::OnStatusUpdate(const std::string& statusMessage)
|
||
{
|
||
updateStatusLog(QString::fromStdString(statusMessage));
|
||
}
|
||
|
||
void MainWindow::OnDetectionResult(const DetectionResult& result)
|
||
{
|
||
const ParkingGuideState guideState =
|
||
result.parkingSpaceInfoList.empty()
|
||
? ParkingGuideState::Unknown
|
||
: ParkingGuideStateFromCode(
|
||
result.parkingSpaceInfoList.front().guideStateCode);
|
||
const bool preserveStateTransition =
|
||
result.imageIsRoi ||
|
||
guideState == ParkingGuideState::StopPositionReached ||
|
||
guideState == ParkingGuideState::DockingCompleted ||
|
||
guideState == ParkingGuideState::ChocksOn;
|
||
if (preserveStateTransition) {
|
||
if (QThread::currentThread() == thread()) {
|
||
updateDetectionResultDisplay(result);
|
||
} else {
|
||
QMetaObject::invokeMethod(this, [this, result]() {
|
||
updateDetectionResultDisplay(result);
|
||
}, Qt::QueuedConnection);
|
||
}
|
||
return;
|
||
}
|
||
|
||
bool queueUpdate = false;
|
||
{
|
||
std::lock_guard<std::mutex> lock(m_pendingResultMutex);
|
||
m_pendingDetectionResult = result;
|
||
if (!m_detectionResultUpdateQueued) {
|
||
m_detectionResultUpdateQueued = true;
|
||
queueUpdate = true;
|
||
}
|
||
}
|
||
if (!queueUpdate) {
|
||
return;
|
||
}
|
||
|
||
QMetaObject::invokeMethod(this, [this]() {
|
||
DetectionResult latestResult;
|
||
{
|
||
std::lock_guard<std::mutex> lock(m_pendingResultMutex);
|
||
latestResult = m_pendingDetectionResult;
|
||
m_detectionResultUpdateQueued = false;
|
||
}
|
||
updateDetectionResultDisplay(latestResult);
|
||
}, Qt::QueuedConnection);
|
||
}
|
||
|
||
void MainWindow::OnPreviewFrame(const QImage& image)
|
||
{
|
||
if (image.isNull() || !ui_dialogAlgoArg) {
|
||
return;
|
||
}
|
||
if (QThread::currentThread() == thread()) {
|
||
ui_dialogAlgoArg->OnPreviewFrame(image);
|
||
} else {
|
||
QMetaObject::invokeMethod(this, [this, image]() {
|
||
if (ui_dialogAlgoArg) {
|
||
ui_dialogAlgoArg->OnPreviewFrame(image);
|
||
}
|
||
}, Qt::QueuedConnection);
|
||
}
|
||
}
|
||
|
||
void MainWindow::resizeEvent(QResizeEvent* event)
|
||
{
|
||
QMainWindow::resizeEvent(event);
|
||
updateResultItemSize();
|
||
}
|
||
|
||
void MainWindow::OnCamera1StatusChanged(bool isConnected)
|
||
{
|
||
if (QThread::currentThread() != thread()) {
|
||
QMetaObject::invokeMethod(this, [this, isConnected]() {
|
||
OnCamera1StatusChanged(isConnected);
|
||
}, Qt::QueuedConnection);
|
||
return;
|
||
}
|
||
|
||
if (m_deviceStatusWidget) {
|
||
m_deviceStatusWidget->updateCamera1Status(isConnected);
|
||
}
|
||
}
|
||
|
||
void MainWindow::OnCamera2StatusChanged(bool isConnected)
|
||
{
|
||
if (QThread::currentThread() != thread()) {
|
||
QMetaObject::invokeMethod(this, [this, isConnected]() {
|
||
OnCamera2StatusChanged(isConnected);
|
||
}, Qt::QueuedConnection);
|
||
return;
|
||
}
|
||
|
||
if (m_deviceStatusWidget) {
|
||
m_deviceStatusWidget->updateCamera2Status(isConnected);
|
||
}
|
||
}
|
||
|
||
void MainWindow::OnRobotConnectionChanged(bool isConnected)
|
||
{
|
||
Q_UNUSED(isConnected);
|
||
}
|
||
|
||
void MainWindow::OnSerialConnectionChanged(bool isConnected)
|
||
{
|
||
if (QThread::currentThread() != thread()) {
|
||
QMetaObject::invokeMethod(this, [this, isConnected]() {
|
||
OnSerialConnectionChanged(isConnected);
|
||
}, Qt::QueuedConnection);
|
||
return;
|
||
}
|
||
|
||
if (m_deviceStatusWidget) {
|
||
m_deviceStatusWidget->updateSerialStatus(isConnected);
|
||
}
|
||
}
|
||
|
||
void MainWindow::OnCameraCountChanged(int cameraCount)
|
||
{
|
||
Q_UNUSED(cameraCount);
|
||
if (QThread::currentThread() != thread()) {
|
||
QMetaObject::invokeMethod(this, [this]() {
|
||
OnCameraCountChanged(2);
|
||
}, Qt::QueuedConnection);
|
||
return;
|
||
}
|
||
|
||
if (m_deviceStatusWidget) {
|
||
m_deviceStatusWidget->setCameraCount(2, true);
|
||
m_deviceStatusWidget->setCamera1Name(tr("相机"));
|
||
m_deviceStatusWidget->setCamera2Name(tr("雷达"));
|
||
}
|
||
}
|
||
|
||
void MainWindow::OnWorkStatusChanged(WorkStatus status)
|
||
{
|
||
emit workStatusUpdateRequested(status);
|
||
}
|
||
|
||
void MainWindow::updateWorkStatusLabel(WorkStatus status)
|
||
{
|
||
m_emergencyStopControlsLocked =
|
||
status == WorkStatus::EmergencyStop;
|
||
if (ui_dialogAlgoArg) {
|
||
const bool detectionRunning =
|
||
m_presenter && m_presenter->IsDetectionRunning();
|
||
ui_dialogAlgoArg->setEnabled(
|
||
!safetyControlsLocked() && !detectionRunning);
|
||
}
|
||
|
||
if (status == WorkStatus::Working || status == WorkStatus::Detecting) {
|
||
clearDetectionLog();
|
||
}
|
||
|
||
const QString statusText = QString::fromStdString(WorkStatusToString(status));
|
||
updateStatusLog(tr("工作状态：%1").arg(statusText));
|
||
updateWorkModeLabel();
|
||
updateSystemStatusLabel();
|
||
|
||
switch (status) {
|
||
case WorkStatus::Ready:
|
||
resetAircraftModelSelection();
|
||
setButtonsEnabled(true);
|
||
break;
|
||
case WorkStatus::InitIng:
|
||
setButtonsEnabled(false);
|
||
break;
|
||
case WorkStatus::Working:
|
||
case WorkStatus::Detecting:
|
||
setButtonsEnabled(true);
|
||
break;
|
||
case WorkStatus::Completed:
|
||
resetAircraftModelSelection();
|
||
setButtonsEnabled(true);
|
||
break;
|
||
case WorkStatus::Error:
|
||
resetAircraftModelSelection();
|
||
setButtonsEnabled(true);
|
||
break;
|
||
case WorkStatus::EmergencyStop:
|
||
setButtonsEnabled(false);
|
||
break;
|
||
default:
|
||
setButtonsEnabled(false);
|
||
break;
|
||
}
|
||
}
|
||
|
||
void MainWindow::updateDetectionResultDisplay(const DetectionResult& result)
|
||
{
|
||
if (!result.parkingSpaceInfoList.empty()) {
|
||
const ParkingGuideState state = ParkingGuideStateFromCode(
|
||
result.parkingSpaceInfoList.front().guideStateCode);
|
||
if (state == ParkingGuideState::EmergencyStop ||
|
||
state == ParkingGuideState::SystemFailure) {
|
||
m_safetyResultControlsLocked = true;
|
||
} else if (state == ParkingGuideState::Waiting) {
|
||
m_safetyResultControlsLocked = false;
|
||
}
|
||
|
||
if (ui_dialogAlgoArg) {
|
||
const bool detectionRunning =
|
||
m_presenter && m_presenter->IsDetectionRunning();
|
||
ui_dialogAlgoArg->setEnabled(
|
||
!safetyControlsLocked() && !detectionRunning);
|
||
}
|
||
// 急停/故障锁死全部按键；WAIT 解除后按引导是否在跑恢复停止键
|
||
setButtonsEnabled(!safetyControlsLocked());
|
||
}
|
||
|
||
addDetectionResult(result);
|
||
updateWorkModeLabel();
|
||
}
|
||
|
||
void MainWindow::on_btn_start_clicked()
|
||
{
|
||
if (!m_presenter) {
|
||
updateStatusLog(tr("系统未初始化"));
|
||
return;
|
||
}
|
||
if (!promptControlPassword(tr("开始引导"))) {
|
||
return;
|
||
}
|
||
|
||
const QString selectedModel = selectedAircraftModel();
|
||
setButtonsEnabled(false);
|
||
if (ui_dialogAlgoArg) {
|
||
ui_dialogAlgoArg->setEnabled(false);
|
||
}
|
||
clearDetectionLog();
|
||
updateStatusLog(selectedModel.isEmpty()
|
||
? tr("开始停机引导检测，机型以实际检测结果为准")
|
||
: tr("开始%1停机引导检测").arg(selectedModel));
|
||
if (!m_presenter->StartDetection(selectedModel, -1)) {
|
||
updateStatusLog(tr("启动检测失败"));
|
||
setButtonsEnabled(true);
|
||
if (ui_dialogAlgoArg) {
|
||
ui_dialogAlgoArg->setEnabled(!safetyControlsLocked());
|
||
}
|
||
}
|
||
}
|
||
|
||
void MainWindow::on_btn_stop_clicked()
|
||
{
|
||
if (!promptControlPassword(tr("停止引导"))) {
|
||
return;
|
||
}
|
||
if (m_presenter) {
|
||
m_presenter->StopDetection();
|
||
}
|
||
}
|
||
|
||
void MainWindow::on_btn_chock_on_clicked()
|
||
{
|
||
recordManualChock(true);
|
||
}
|
||
|
||
void MainWindow::on_btn_chock_off_clicked()
|
||
{
|
||
recordManualChock(false);
|
||
}
|
||
|
||
void MainWindow::showParameterDialog(DialogAlgoArg::ConfigPage page, QPushButton* button)
|
||
{
|
||
if (m_selectedButton && m_selectedButton != button) {
|
||
updateStatusLog(tr("请先关闭当前参数窗口"));
|
||
return;
|
||
}
|
||
|
||
if (!m_presenter) {
|
||
updateStatusLog(tr("系统未初始化"));
|
||
return;
|
||
}
|
||
if (m_presenter->IsDetectionRunning()) {
|
||
updateStatusLog(tr("停机引导进行中，暂不能修改参数"));
|
||
return;
|
||
}
|
||
if (!promptControlPassword(tr("参数设置"))) {
|
||
return;
|
||
}
|
||
|
||
setButtonSelectedState(button, true);
|
||
|
||
if (!ui_dialogAlgoArg) {
|
||
ui_dialogAlgoArg = new DialogAlgoArg(this);
|
||
connect(ui_dialogAlgoArg, &QDialog::finished, this, [this]() {
|
||
if (m_presenter) {
|
||
m_presenter->SetLivePreviewEnabled(false);
|
||
}
|
||
if (m_selectedButton) {
|
||
setButtonSelectedState(m_selectedButton, false);
|
||
}
|
||
});
|
||
}
|
||
|
||
ui_dialogAlgoArg->SetPresenter(m_presenter);
|
||
ui_dialogAlgoArg->SetCurrentPage(page);
|
||
m_presenter->SetLivePreviewEnabled(true);
|
||
ui_dialogAlgoArg->show();
|
||
ui_dialogAlgoArg->raise();
|
||
ui_dialogAlgoArg->activateWindow();
|
||
}
|
||
|
||
void MainWindow::on_btn_camera_clicked()
|
||
{
|
||
updateStatusLog(tr("打开相机参数设置"));
|
||
showParameterDialog(DialogAlgoArg::ConfigPage::Camera, ui->btn_camera);
|
||
}
|
||
|
||
void MainWindow::on_btn_algo_config_clicked()
|
||
{
|
||
updateStatusLog(tr("打开检测参数设置"));
|
||
showParameterDialog(DialogAlgoArg::ConfigPage::Detection, ui->btn_algo_config);
|
||
}
|
||
|
||
void MainWindow::on_btn_camera_levelling_clicked()
|
||
{
|
||
updateStatusLog(tr("打开雷达地面调平参数"));
|
||
showParameterDialog(DialogAlgoArg::ConfigPage::Calibration, ui->btn_camera_levelling);
|
||
}
|
||
|
||
void MainWindow::on_btn_hide_clicked()
|
||
{
|
||
showMinimized();
|
||
}
|
||
|
||
void MainWindow::on_btn_close_clicked()
|
||
{
|
||
close();
|
||
}
|
||
|
||
void MainWindow::on_btn_test_clicked()
|
||
{
|
||
if (!m_presenter) {
|
||
StyledMessageBox::warning(this, tr("错误"), tr("系统未初始化"));
|
||
return;
|
||
}
|
||
if (!promptControlPassword(tr("测试检测"))) {
|
||
return;
|
||
}
|
||
|
||
if (m_selectedButton && m_selectedButton != ui->btn_test) {
|
||
updateStatusLog(tr("请先关闭当前参数窗口"));
|
||
return;
|
||
}
|
||
|
||
setButtonSelectedState(ui->btn_test, true);
|
||
setButtonsEnabled(false);
|
||
clearDetectionLog();
|
||
updateStatusLog(tr("运行预留算法接口测试"));
|
||
|
||
if (m_testThread.joinable()) {
|
||
m_testThread.join();
|
||
}
|
||
m_testRunning.store(true);
|
||
m_testThread = std::thread([this]() {
|
||
const bool ok = m_presenter->TriggerDetection(-1);
|
||
if (!m_closing.load()) {
|
||
updateStatusLog(ok ? tr("测试检测完成") : tr("测试检测失败"));
|
||
}
|
||
QMetaObject::invokeMethod(this, [this]() {
|
||
if (m_closing.load()) {
|
||
return;
|
||
}
|
||
setButtonSelectedState(ui->btn_test, false);
|
||
setButtonsEnabled(true);
|
||
}, Qt::QueuedConnection);
|
||
m_testRunning.store(false);
|
||
});
|
||
}
|
||
|
||
void MainWindow::setButtonsEnabled(bool enabled)
|
||
{
|
||
const bool detectionRunning =
|
||
m_presenter && m_presenter->IsDetectionRunning();
|
||
const bool safetyLocked = safetyControlsLocked();
|
||
const bool initDone = !m_initRunning.load();
|
||
const bool canStart =
|
||
enabled &&
|
||
initDone &&
|
||
!safetyLocked &&
|
||
!detectionRunning;
|
||
// 自动进入引导后必须能点停止；急停锁定时除外
|
||
const bool canStop =
|
||
!safetyLocked &&
|
||
detectionRunning;
|
||
const bool canChock =
|
||
initDone &&
|
||
!safetyLocked &&
|
||
m_presenter;
|
||
|
||
if (ui->combo_model) {
|
||
ui->combo_model->setEnabled(canStart);
|
||
}
|
||
if (ui->btn_start) {
|
||
ui->btn_start->setEnabled(canStart);
|
||
}
|
||
if (ui->btn_stop) {
|
||
ui->btn_stop->setEnabled(canStop);
|
||
}
|
||
if (ui->btn_camera) {
|
||
ui->btn_camera->setEnabled(canStart);
|
||
}
|
||
if (ui->btn_algo_config) {
|
||
ui->btn_algo_config->setEnabled(canStart);
|
||
}
|
||
if (ui->btn_camera_levelling) {
|
||
ui->btn_camera_levelling->setEnabled(canStart);
|
||
}
|
||
if (ui->btn_test) {
|
||
ui->btn_test->setEnabled(canStart);
|
||
}
|
||
if (ui->btn_chock_on) {
|
||
ui->btn_chock_on->setEnabled(canChock);
|
||
}
|
||
if (ui->btn_chock_off) {
|
||
ui->btn_chock_off->setEnabled(canChock);
|
||
}
|
||
updateWorkModeLabel();
|
||
updateSystemStatusLabel();
|
||
}
|
||
|
||
void MainWindow::resetAircraftModelSelection()
|
||
{
|
||
setAircraftModelSelection(QString());
|
||
}
|
||
|
||
QString MainWindow::selectedAircraftModel() const
|
||
{
|
||
if (!ui->combo_model || ui->combo_model->currentIndex() <= 0) {
|
||
return QString();
|
||
}
|
||
return ui->combo_model->currentText().trimmed();
|
||
}
|
||
|
||
void MainWindow::setAircraftModelSelection(const QString& modelType)
|
||
{
|
||
if (!ui->combo_model) {
|
||
return;
|
||
}
|
||
const QString normalized = modelType.trimmed();
|
||
const QSignalBlocker blocker(ui->combo_model);
|
||
if (normalized.isEmpty()) {
|
||
ui->combo_model->setCurrentIndex(0);
|
||
return;
|
||
}
|
||
int index = ui->combo_model->findText(normalized, Qt::MatchFixedString);
|
||
if (index < 0) {
|
||
ui->combo_model->addItem(normalized);
|
||
index = ui->combo_model->findText(normalized, Qt::MatchFixedString);
|
||
}
|
||
ui->combo_model->setCurrentIndex(index > 0 ? index : 0);
|
||
}
|
||
|
||
void MainWindow::populateAircraftModels()
|
||
{
|
||
if (!ui->combo_model) {
|
||
return;
|
||
}
|
||
const QString current = selectedAircraftModel();
|
||
const QSignalBlocker blocker(ui->combo_model);
|
||
ui->combo_model->clear();
|
||
ui->combo_model->addItem(QStringLiteral("请选择机型"));
|
||
AircraftModelsConfig models = AircraftModelsConfig::DefaultModels();
|
||
if (m_presenter && m_presenter->GetConfigManager()) {
|
||
models = m_presenter->GetConfigManager()->GetConfigResult().aircraftModels;
|
||
if (models.models.empty()) {
|
||
models = AircraftModelsConfig::DefaultModels();
|
||
}
|
||
}
|
||
for (const AircraftModelItem& item : models.models) {
|
||
if (!item.name.trimmed().isEmpty()) {
|
||
ui->combo_model->addItem(item.name.trimmed());
|
||
}
|
||
}
|
||
if (!current.isEmpty()) {
|
||
const int index = ui->combo_model->findText(current, Qt::MatchFixedString);
|
||
ui->combo_model->setCurrentIndex(index > 0 ? index : 0);
|
||
}
|
||
}
|
||
|
||
QString MainWindow::currentTargetId() const
|
||
{
|
||
if (m_presenter && m_presenter->GetConfigManager()) {
|
||
const std::string targetId =
|
||
m_presenter->GetConfigManager()->GetConfigResult()
|
||
.udpBroadcastConfig.targetId;
|
||
if (!targetId.empty()) {
|
||
return QString::fromStdString(targetId);
|
||
}
|
||
}
|
||
return QStringLiteral("T001");
|
||
}
|
||
|
||
QString MainWindow::currentParkId() const
|
||
{
|
||
if (m_presenter && m_presenter->GetConfigManager()) {
|
||
const std::string parkId =
|
||
m_presenter->GetConfigManager()->GetConfigResult()
|
||
.udpBroadcastConfig.parkId;
|
||
if (!parkId.empty()) {
|
||
return QString::fromStdString(parkId);
|
||
}
|
||
}
|
||
return QStringLiteral("P01");
|
||
}
|
||
|
||
void MainWindow::updateSystemStatusLabel()
|
||
{
|
||
if (!ui || !ui->label_system_status) {
|
||
return;
|
||
}
|
||
// 开始引导后为系统已激活，停止引导后为未激活
|
||
const bool activated =
|
||
m_presenter && m_presenter->IsDetectionRunning();
|
||
ui->label_system_status->setText(activated
|
||
? tr("系统已激活")
|
||
: tr("未激活"));
|
||
ui->label_system_status->setStyleSheet(activated
|
||
? QStringLiteral(
|
||
"color: rgb(0, 255, 0);"
|
||
"background-color: transparent;"
|
||
"border: none;"
|
||
"font-weight: 700;")
|
||
: QStringLiteral(
|
||
"color: rgb(172, 181, 194);"
|
||
"background-color: transparent;"
|
||
"border: none;"
|
||
"font-weight: 700;"));
|
||
}
|
||
|
||
void MainWindow::updateWorkModeLabel()
|
||
{
|
||
if (!ui->label_work) {
|
||
return;
|
||
}
|
||
const bool maintenance = m_presenter && m_presenter->IsMaintenanceMode();
|
||
const bool guidanceRunning =
|
||
m_presenter && m_presenter->IsDetectionRunning();
|
||
ui->label_work->setText(maintenance
|
||
? tr("维护模式")
|
||
: tr("正常模式"));
|
||
ui->label_work->setCursor(guidanceRunning
|
||
? Qt::ForbiddenCursor
|
||
: Qt::PointingHandCursor);
|
||
if (guidanceRunning) {
|
||
ui->label_work->setStyleSheet(
|
||
QStringLiteral("color: rgb(130, 132, 138); font-weight: 700;"));
|
||
} else {
|
||
ui->label_work->setStyleSheet(maintenance
|
||
? QStringLiteral("color: rgb(255, 160, 40); font-weight: 700;")
|
||
: QStringLiteral("color: rgb(0, 255, 0); font-weight: 700;"));
|
||
}
|
||
}
|
||
|
||
bool MainWindow::promptControlPassword(const QString& title)
|
||
{
|
||
if (!m_presenter) {
|
||
StyledMessageBox::warning(this, tr("错误"), tr("系统未初始化"));
|
||
return false;
|
||
}
|
||
if (m_presenter->ValidateControlPassword(QString())) {
|
||
return true;
|
||
}
|
||
// 有效期内不再弹窗，超时后重新输入。
|
||
if (m_passwordValidUntilMs > QDateTime::currentMSecsSinceEpoch()) {
|
||
return true;
|
||
}
|
||
|
||
DialogControlPassword dialog(this);
|
||
dialog.SetTitle(title);
|
||
dialog.SetPasswordChecker([this](const QString& password) {
|
||
return m_presenter->ValidateControlPassword(password);
|
||
});
|
||
if (dialog.exec() != QDialog::Accepted) {
|
||
return false;
|
||
}
|
||
RememberControlPassword();
|
||
return true;
|
||
}
|
||
|
||
int MainWindow::ControlPasswordValidSeconds() const
|
||
{
|
||
if (!m_presenter || !m_presenter->GetConfigManager()) {
|
||
return 120;
|
||
}
|
||
return m_presenter->GetConfigManager()->GetConfigResult()
|
||
.controlPanelConfig.validSeconds;
|
||
}
|
||
|
||
void MainWindow::RememberControlPassword()
|
||
{
|
||
const int validSeconds = ControlPasswordValidSeconds();
|
||
m_passwordValidUntilMs = QDateTime::currentMSecsSinceEpoch() +
|
||
static_cast<qint64>(validSeconds) * 1000;
|
||
}
|
||
|
||
void MainWindow::recordManualChock(bool chockOn)
|
||
{
|
||
if (!m_presenter) {
|
||
updateStatusLog(tr("系统未初始化"));
|
||
return;
|
||
}
|
||
if (!promptControlPassword(chockOn ? tr("上轮挡") : tr("下轮挡"))) {
|
||
return;
|
||
}
|
||
if (!m_presenter->RecordManualChock(chockOn)) {
|
||
updateStatusLog(chockOn ? tr("记录上轮挡时间失败") : tr("记录下轮挡时间失败"));
|
||
return;
|
||
}
|
||
updateStatusLog(chockOn ? tr("已记录上轮挡时间") : tr("已记录下轮挡时间"));
|
||
}
|
||
|
||
bool MainWindow::safetyControlsLocked() const
|
||
{
|
||
return m_emergencyStopControlsLocked ||
|
||
m_safetyResultControlsLocked;
|
||
}
|
||
|
||
void MainWindow::setButtonImage(QPushButton* button, const QString& imagePath)
|
||
{
|
||
if (button) {
|
||
button->setStyleSheet(QString("image: url(%1);background-color: rgb(38, 40, 47);border: none;")
|
||
.arg(imagePath));
|
||
}
|
||
}
|
||
|
||
void MainWindow::setButtonSelectedState(QPushButton* button, bool selected)
|
||
{
|
||
if (!button) {
|
||
return;
|
||
}
|
||
|
||
QString normalImage;
|
||
QString selectedImage;
|
||
if (button == ui->btn_camera) {
|
||
normalImage = ":/common/resource/config_camera.png";
|
||
selectedImage = ":/common/resource/config_camera_s.png";
|
||
} else if (button == ui->btn_algo_config) {
|
||
normalImage = ":/common/resource/config_algo.png";
|
||
selectedImage = ":/common/resource/config_algo_s.png";
|
||
} else if (button == ui->btn_camera_levelling) {
|
||
normalImage = ":/common/resource/config_camera_level.png";
|
||
selectedImage = ":/common/resource/config_camera_level_s.png";
|
||
} else if (button == ui->btn_test) {
|
||
normalImage = ":/common/resource/config_data_test.png";
|
||
selectedImage = ":/common/resource/config_data_test_s.png";
|
||
}
|
||
|
||
if (selected) {
|
||
setButtonImage(button, selectedImage);
|
||
m_selectedButton = button;
|
||
setOtherButtonsEnabled(button, false);
|
||
} else {
|
||
setButtonImage(button, normalImage);
|
||
if (m_selectedButton == button) {
|
||
m_selectedButton = nullptr;
|
||
setOtherButtonsEnabled(nullptr, true);
|
||
}
|
||
}
|
||
}
|
||
|
||
void MainWindow::restoreAllButtonStates()
|
||
{
|
||
setButtonSelectedState(ui->btn_camera, false);
|
||
setButtonSelectedState(ui->btn_algo_config, false);
|
||
setButtonSelectedState(ui->btn_camera_levelling, false);
|
||
setButtonSelectedState(ui->btn_test, false);
|
||
}
|
||
|
||
void MainWindow::setOtherButtonsEnabled(QPushButton* exceptButton, bool enabled)
|
||
{
|
||
const QList<QPushButton*> configButtons = {
|
||
ui->btn_camera,
|
||
ui->btn_algo_config,
|
||
ui->btn_camera_levelling,
|
||
ui->btn_test
|
||
};
|
||
|
||
const bool controlsEnabled =
|
||
enabled &&
|
||
!safetyControlsLocked() &&
|
||
!(m_presenter && m_presenter->IsDetectionRunning());
|
||
for (QPushButton* button : configButtons) {
|
||
if (button && button != exceptButton) {
|
||
button->setEnabled(controlsEnabled);
|
||
}
|
||
}
|
||
}
|
||
|
||
void MainWindow::onCameraClicked(int cameraIndex)
|
||
{
|
||
if (m_presenter) {
|
||
m_presenter->SetDefaultCameraIndex(cameraIndex);
|
||
}
|
||
}
|
||
|
||
void MainWindow::setupContextMenu()
|
||
{
|
||
m_contextMenu = new QMenu(this);
|
||
m_saveDataAction = new QAction(tr("保存检测数据"), this);
|
||
m_contextMenu->addAction(m_saveDataAction);
|
||
|
||
connect(m_saveDataAction, &QAction::triggered, this, &MainWindow::onSaveDetectionData);
|
||
|
||
ui->detect_result_list->setContextMenuPolicy(Qt::CustomContextMenu);
|
||
connect(ui->detect_result_list, &QListWidget::customContextMenuRequested,
|
||
this, &MainWindow::showContextMenu);
|
||
}
|
||
|
||
void MainWindow::showContextMenu(const QPoint& pos)
|
||
{
|
||
if (!m_presenter) {
|
||
updateStatusLog(tr("系统未初始化，无法保存数据"));
|
||
return;
|
||
}
|
||
|
||
if (m_presenter->GetDetectionDataCacheSize() == 0) {
|
||
updateStatusLog(tr("没有可保存的检测数据"));
|
||
return;
|
||
}
|
||
|
||
m_contextMenu->exec(ui->detect_result_list->mapToGlobal(pos));
|
||
}
|
||
|
||
void MainWindow::onSaveDetectionData()
|
||
{
|
||
if (!m_presenter) {
|
||
updateStatusLog(tr("系统未初始化，无法保存数据"));
|
||
return;
|
||
}
|
||
|
||
const QString dirPath = QFileDialog::getExistingDirectory(
|
||
this,
|
||
tr("选择保存目录"),
|
||
QStandardPaths::writableLocation(QStandardPaths::DocumentsLocation),
|
||
QFileDialog::ShowDirsOnly | QFileDialog::DontResolveSymlinks);
|
||
|
||
if (dirPath.isEmpty()) {
|
||
updateStatusLog(tr("保存已取消"));
|
||
return;
|
||
}
|
||
|
||
const std::string timeStamp = CVrDateUtils::GetNowTime();
|
||
const QString fileName = QString("停机引导_%1_%2.txt")
|
||
.arg(m_presenter->GetDetectIndex())
|
||
.arg(QString::fromStdString(timeStamp));
|
||
const QString fullPath = QDir(dirPath).filePath(fileName);
|
||
|
||
if (saveDetectionDataToFile(fullPath)) {
|
||
updateStatusLog(tr("检测数据已保存：%1").arg(fileName));
|
||
} else {
|
||
updateStatusLog(tr("保存检测数据失败"));
|
||
}
|
||
}
|
||
|
||
bool MainWindow::saveDetectionDataToFile(const QString& filePath)
|
||
{
|
||
if (!m_presenter) {
|
||
return false;
|
||
}
|
||
|
||
try {
|
||
const int result = m_presenter->SaveDetectionDataToFile(filePath.toStdString());
|
||
if (result != 0) {
|
||
updateStatusLog(tr("保存数据失败，错误码：%1").arg(result));
|
||
return false;
|
||
}
|
||
return true;
|
||
} catch (const std::exception&) {
|
||
updateStatusLog(tr("保存数据异常"));
|
||
return false;
|
||
}
|
||
}
|