1127 lines
48 KiB
C++
1127 lines
48 KiB
C++
#include "mainwindow.h"
|
||
|
||
#include <QCheckBox>
|
||
#include <QCloseEvent>
|
||
#include <QAbstractItemView>
|
||
#include <QDateTime>
|
||
#include <QDoubleSpinBox>
|
||
#include <QDir>
|
||
#include <QFile>
|
||
#include <QFileDialog>
|
||
#include <QFontDatabase>
|
||
#include <QGridLayout>
|
||
#include <QGroupBox>
|
||
#include <QHeaderView>
|
||
#include <QHBoxLayout>
|
||
#include <QJsonDocument>
|
||
#include <QJsonArray>
|
||
#include <QJsonObject>
|
||
#include <QJsonValue>
|
||
#include <QLabel>
|
||
#include <QLineEdit>
|
||
#include <QPlainTextEdit>
|
||
#include <QPixmap>
|
||
#include <QPushButton>
|
||
#include <QResizeEvent>
|
||
#include <QSpinBox>
|
||
#include <QSplitter>
|
||
#include <QTableWidget>
|
||
#include <QTableWidgetItem>
|
||
#include <QTextBlock>
|
||
#include <QTextCursor>
|
||
#include <QTextDocument>
|
||
#include <QTextStream>
|
||
#include <QTabWidget>
|
||
#include <QTcpSocket>
|
||
#include <QTimer>
|
||
#include <QVBoxLayout>
|
||
#include <QDataStream>
|
||
#include <utility>
|
||
#include "PointCloudGLWidget.h"
|
||
#include "LaserDataLoader.h"
|
||
#include "VZNL_Types.h"
|
||
|
||
namespace
|
||
{
|
||
constexpr quint8 kTextType = 0x01;
|
||
constexpr quint8 kImageType = 0x02;
|
||
constexpr quint8 kReadConfigType = 0x03;
|
||
constexpr quint8 kWriteConfigType = 0x04;
|
||
constexpr quint8 kPointCloudType = 0x05;
|
||
constexpr int kFrameHeaderSize = 5;
|
||
constexpr int kFrameTailSize = 11;
|
||
constexpr quint64 kMaxPayloadSize = 256ULL * 1024ULL * 1024ULL;
|
||
const QByteArray kFrameTail("___END___\r\n");
|
||
const QByteArray kJsonFrameHeader("##START#");
|
||
const QByteArray kJsonFrameTail("#END");
|
||
constexpr int kJsonFrameHeaderSize = 8;
|
||
constexpr int kJsonFrameLengthSize = 8;
|
||
constexpr int kJsonFrameTailSize = 4;
|
||
constexpr quint32 kMaxJsonPayloadSize = 10U * 1024U * 1024U;
|
||
|
||
quint32 readUInt32BE(const QByteArray& data, int offset)
|
||
{
|
||
return (static_cast<quint32>(static_cast<quint8>(data.at(offset))) << 24)
|
||
| (static_cast<quint32>(static_cast<quint8>(data.at(offset + 1))) << 16)
|
||
| (static_cast<quint32>(static_cast<quint8>(data.at(offset + 2))) << 8)
|
||
| static_cast<quint32>(static_cast<quint8>(data.at(offset + 3)));
|
||
}
|
||
|
||
QString formatRange(double minValue, double maxValue)
|
||
{
|
||
return QStringLiteral("%1 .. %2").arg(minValue, 0, 'f', 3).arg(maxValue, 0, 'f', 3);
|
||
}
|
||
}
|
||
|
||
MainWindow::MainWindow(QWidget* parent)
|
||
: QMainWindow(parent),
|
||
m_socket(new QTcpSocket(this))
|
||
{
|
||
setupUi();
|
||
connect(m_socket, &QTcpSocket::connected, this, &MainWindow::onConnected);
|
||
connect(m_socket, &QTcpSocket::disconnected, this, &MainWindow::onDisconnected);
|
||
connect(m_socket, &QTcpSocket::readyRead, this, &MainWindow::onReadyRead);
|
||
#if QT_VERSION >= QT_VERSION_CHECK(5, 15, 0)
|
||
connect(m_socket, &QAbstractSocket::errorOccurred,
|
||
this, &MainWindow::onSocketError);
|
||
#else
|
||
connect(m_socket, SIGNAL(error(QAbstractSocket::SocketError)),
|
||
this, SLOT(onSocketError(QAbstractSocket::SocketError)));
|
||
#endif
|
||
updateConnectionControls(false);
|
||
}
|
||
|
||
MainWindow::~MainWindow()
|
||
{
|
||
disconnectFromServer();
|
||
}
|
||
|
||
void MainWindow::setupUi()
|
||
{
|
||
setWindowTitle(QStringLiteral("BeltTearing TCP 协议测试"));
|
||
resize(1080, 760);
|
||
setMinimumSize(900, 620);
|
||
|
||
auto* central = new QWidget(this);
|
||
auto* mainLayout = new QVBoxLayout(central);
|
||
mainLayout->setContentsMargins(6, 6, 6, 6);
|
||
mainLayout->setSpacing(4);
|
||
|
||
auto* connectionGroup = new QGroupBox(QStringLiteral("连接"), central);
|
||
auto* connectionLayout = new QGridLayout(connectionGroup);
|
||
connectionLayout->setContentsMargins(8, 6, 8, 6);
|
||
connectionLayout->setHorizontalSpacing(6);
|
||
connectionLayout->setVerticalSpacing(4);
|
||
m_hostEdit = new QLineEdit(QStringLiteral("127.0.0.1"), connectionGroup);
|
||
m_portSpin = new QSpinBox(connectionGroup);
|
||
m_portSpin->setRange(1, 65535);
|
||
m_portSpin->setValue(5800);
|
||
m_connectButton = new QPushButton(QStringLiteral("连接"), connectionGroup);
|
||
m_disconnectButton = new QPushButton(QStringLiteral("断开"), connectionGroup);
|
||
m_connectionLabel = new QLabel(QStringLiteral("未连接"), connectionGroup);
|
||
connectionLayout->addWidget(new QLabel(QStringLiteral("服务器地址"), connectionGroup), 0, 0);
|
||
connectionLayout->addWidget(m_hostEdit, 0, 1);
|
||
connectionLayout->addWidget(new QLabel(QStringLiteral("BeltTearing TCP 端口"), connectionGroup), 0, 2);
|
||
connectionLayout->addWidget(m_portSpin, 0, 3);
|
||
connectionLayout->addWidget(m_connectButton, 0, 4);
|
||
connectionLayout->addWidget(m_disconnectButton, 0, 5);
|
||
connectionLayout->addWidget(m_connectionLabel, 0, 6);
|
||
connectionLayout->setColumnStretch(1, 1);
|
||
connectionLayout->setColumnStretch(6, 1);
|
||
mainLayout->addWidget(connectionGroup);
|
||
|
||
auto* realtimeGroup = new QGroupBox(QStringLiteral("控制测试"), central);
|
||
auto* realtimeLayout = new QHBoxLayout(realtimeGroup);
|
||
realtimeLayout->setContentsMargins(8, 4, 8, 4);
|
||
realtimeLayout->setSpacing(6);
|
||
m_realtimeCheck = new QCheckBox(QStringLiteral("启用实时上报"), realtimeGroup);
|
||
m_resetAlarmButton = new QPushButton(QStringLiteral("RESET_ALARM"), realtimeGroup);
|
||
m_restDetectButton = new QPushButton(QStringLiteral("REST_DETECT"), realtimeGroup);
|
||
realtimeLayout->addWidget(m_realtimeCheck);
|
||
realtimeLayout->addWidget(m_resetAlarmButton);
|
||
realtimeLayout->addWidget(m_restDetectButton);
|
||
realtimeLayout->addStretch();
|
||
mainLayout->addWidget(realtimeGroup);
|
||
|
||
auto* configGroup = new QGroupBox(QStringLiteral("参数配置测试（GET_CONFIG / SET_CONFIG）"), central);
|
||
auto* configLayout = new QGridLayout(configGroup);
|
||
configLayout->setContentsMargins(8, 6, 8, 6);
|
||
configLayout->setHorizontalSpacing(10);
|
||
configLayout->setVerticalSpacing(4);
|
||
auto makeDoubleSpinBox = [configGroup](double value, double minimum = 0.0) {
|
||
auto* spinBox = new QDoubleSpinBox(configGroup);
|
||
spinBox->setRange(minimum, 1000000000.0);
|
||
spinBox->setDecimals(4);
|
||
spinBox->setValue(value);
|
||
return spinBox;
|
||
};
|
||
auto makeIntSpinBox = [configGroup](int value, int minimum = 1) {
|
||
auto* spinBox = new QSpinBox(configGroup);
|
||
spinBox->setRange(minimum, 1000000000);
|
||
spinBox->setValue(value);
|
||
return spinBox;
|
||
};
|
||
auto addField = [configLayout, configGroup](int row, int column, const QString& title, QWidget* field) {
|
||
configLayout->addWidget(new QLabel(title, configGroup), row, column);
|
||
configLayout->addWidget(field, row, column + 1);
|
||
};
|
||
|
||
m_scanXScaleSpin = makeDoubleSpinBox(1.0, 0.0001);
|
||
m_scanYScaleSpin = makeDoubleSpinBox(1.0, 0.0001);
|
||
m_differenceBinThresholdSpin = makeDoubleSpinBox(1.0);
|
||
m_tearingMinLengthSpin = makeDoubleSpinBox(5.0);
|
||
m_tearingMinWidthSpin = makeDoubleSpinBox(0.0);
|
||
m_tearingMinDepthSpin = makeDoubleSpinBox(0.0);
|
||
m_tearingMinGapSpin = makeDoubleSpinBox(2.0);
|
||
m_sameGapThresholdSpin = makeDoubleSpinBox(2.0);
|
||
m_gapCheckWindowSpin = makeIntSpinBox(5);
|
||
addField(0, 0, QStringLiteral("X 缩放"), m_scanXScaleSpin);
|
||
addField(0, 2, QStringLiteral("Y 缩放"), m_scanYScaleSpin);
|
||
addField(0, 4, QStringLiteral("差分阈值"), m_differenceBinThresholdSpin);
|
||
addField(1, 0, QStringLiteral("最小撕裂长度"), m_tearingMinLengthSpin);
|
||
addField(1, 2, QStringLiteral("最小撕裂宽度"), m_tearingMinWidthSpin);
|
||
addField(1, 4, QStringLiteral("最小撕裂深度"), m_tearingMinDepthSpin);
|
||
addField(2, 0, QStringLiteral("最小撕裂间隙"), m_tearingMinGapSpin);
|
||
addField(2, 2, QStringLiteral("同裂间隙阈值"), m_sameGapThresholdSpin);
|
||
addField(2, 4, QStringLiteral("间隙检查窗口"), m_gapCheckWindowSpin);
|
||
|
||
m_cameraIpEdit = new QLineEdit(QStringLiteral("192.168.1.100"), configGroup);
|
||
m_maxQueueSizeSpin = makeIntSpinBox(300);
|
||
m_generationIntervalSpin = makeIntSpinBox(100);
|
||
m_imageLineCountSpin = makeIntSpinBox(300);
|
||
addField(3, 0, QStringLiteral("相机 IP"), m_cameraIpEdit);
|
||
addField(3, 2, QStringLiteral("最大队列数"), m_maxQueueSizeSpin);
|
||
addField(3, 4, QStringLiteral("生成间隔"), m_generationIntervalSpin);
|
||
addField(4, 0, QStringLiteral("图像线数"), m_imageLineCountSpin);
|
||
|
||
m_enabledCheck = new QCheckBox(QStringLiteral("启用点云发送"), configGroup);
|
||
m_enabledCheck->setChecked(true);
|
||
m_lineStepSpin = makeIntSpinBox(1);
|
||
m_pointStepSpin = makeIntSpinBox(1);
|
||
m_readConfigButton = new QPushButton(QStringLiteral("读取参数配置"), configGroup);
|
||
m_setConfigButton = new QPushButton(QStringLiteral("写入参数配置"), configGroup);
|
||
configLayout->addWidget(m_enabledCheck, 4, 2, 1, 2);
|
||
addField(4, 4, QStringLiteral("抽线步长"), m_lineStepSpin);
|
||
addField(5, 0, QStringLiteral("抽点步长"), m_pointStepSpin);
|
||
configLayout->addWidget(m_readConfigButton, 5, 2, 1, 2);
|
||
configLayout->addWidget(m_setConfigButton, 5, 4, 1, 2);
|
||
for (int column = 1; column < 6; column += 2)
|
||
configLayout->setColumnStretch(column, 1);
|
||
configLayout->setRowStretch(6, 1);
|
||
mainLayout->addWidget(configGroup);
|
||
|
||
auto* pointCloudGroup = new QGroupBox(QStringLiteral("点云测试"), central);
|
||
auto* pointCloudLayout = new QVBoxLayout(pointCloudGroup);
|
||
pointCloudLayout->setContentsMargins(6, 6, 6, 6);
|
||
pointCloudLayout->setSpacing(4);
|
||
auto* pointCloudToolbar = new QHBoxLayout;
|
||
pointCloudToolbar->setContentsMargins(0, 0, 0, 0);
|
||
pointCloudToolbar->setSpacing(6);
|
||
m_pointCloudClearButton = new QPushButton(QStringLiteral("清空显示"), pointCloudGroup);
|
||
m_displayLineCountSpin = new QSpinBox(pointCloudGroup);
|
||
m_displayLineCountSpin->setRange(1, 10000);
|
||
m_displayLineCountSpin->setValue(200);
|
||
m_saveCloudUtilsCheck = new QCheckBox(QStringLiteral("使用 CloudUtils 保存"), pointCloudGroup);
|
||
pointCloudToolbar->addWidget(m_pointCloudClearButton);
|
||
pointCloudToolbar->addWidget(new QLabel(QStringLiteral("显示线数"), pointCloudGroup));
|
||
pointCloudToolbar->addWidget(m_displayLineCountSpin);
|
||
pointCloudToolbar->addWidget(m_saveCloudUtilsCheck);
|
||
pointCloudToolbar->addStretch();
|
||
pointCloudLayout->addLayout(pointCloudToolbar);
|
||
m_cloudView = new PointCloudGLWidget(pointCloudGroup);
|
||
m_cloudView->setMinimumHeight(260);
|
||
pointCloudLayout->addWidget(m_cloudView, 1);
|
||
|
||
auto* storageGroup = new QGroupBox(QStringLiteral("保存选项"), central);
|
||
auto* storageLayout = new QGridLayout(storageGroup);
|
||
storageLayout->setContentsMargins(8, 6, 8, 6);
|
||
storageLayout->setHorizontalSpacing(8);
|
||
storageLayout->setVerticalSpacing(4);
|
||
m_savePointsCheck = new QCheckBox(QStringLiteral("追加点云到 CSV"), storageGroup);
|
||
m_saveImagesCheck = new QCheckBox(QStringLiteral("保存 JPEG 图像"), storageGroup);
|
||
m_outputDirEdit = new QLineEdit(QDir::current().filePath(QStringLiteral("tcp_test_output")), storageGroup);
|
||
auto* browseButton = new QPushButton(QStringLiteral("选择目录"), storageGroup);
|
||
storageLayout->addWidget(m_savePointsCheck, 0, 0);
|
||
storageLayout->addWidget(m_saveImagesCheck, 0, 1);
|
||
storageLayout->addWidget(new QLabel(QStringLiteral("输出目录"), storageGroup), 1, 0);
|
||
storageLayout->addWidget(m_outputDirEdit, 1, 1);
|
||
storageLayout->addWidget(browseButton, 1, 2);
|
||
storageLayout->setColumnStretch(1, 1);
|
||
storageLayout->setRowStretch(2, 1);
|
||
|
||
auto* statsGroup = new QGroupBox(QStringLiteral("接收统计"), central);
|
||
auto* statsLayout = new QGridLayout(statsGroup);
|
||
statsLayout->setContentsMargins(6, 6, 6, 6);
|
||
statsLayout->setHorizontalSpacing(6);
|
||
statsLayout->setVerticalSpacing(4);
|
||
auto addStat = [statsLayout, statsGroup](int row, int column, const QString& title, QLabel*& value) {
|
||
auto* cell = new QWidget(statsGroup);
|
||
auto* cellLayout = new QVBoxLayout(cell);
|
||
cellLayout->setContentsMargins(4, 0, 4, 0);
|
||
cellLayout->setSpacing(1);
|
||
cellLayout->addWidget(new QLabel(title, cell));
|
||
value = new QLabel(QStringLiteral("-"), cell);
|
||
value->setTextInteractionFlags(Qt::TextSelectableByMouse);
|
||
cellLayout->addWidget(value);
|
||
statsLayout->addWidget(cell, row, column);
|
||
};
|
||
addStat(0, 0, QStringLiteral("接收点云行数"), m_linesValue);
|
||
addStat(0, 1, QStringLiteral("接收字节数"), m_bytesValue);
|
||
addStat(0, 2, QStringLiteral("协议错误数"), m_errorsValue);
|
||
addStat(1, 0, QStringLiteral("最近帧"), m_frameValue);
|
||
addStat(1, 1, QStringLiteral("点数 原始/抽样"), m_countValue);
|
||
addStat(1, 2, QStringLiteral("步长 抽线/抽点"), m_stepsValue);
|
||
addStat(2, 0, QStringLiteral("X 范围"), m_xRangeValue);
|
||
addStat(2, 1, QStringLiteral("Y 范围"), m_yRangeValue);
|
||
addStat(2, 2, QStringLiteral("Z 范围"), m_zRangeValue);
|
||
for (int column = 0; column < 3; ++column)
|
||
statsLayout->setColumnStretch(column, 1);
|
||
|
||
auto* realtimeSplitter = new QSplitter(Qt::Horizontal, statsGroup);
|
||
auto* realtimeDataGroup = new QGroupBox(QStringLiteral("实时撕裂结果"), realtimeSplitter);
|
||
auto* realtimeDataLayout = new QVBoxLayout(realtimeDataGroup);
|
||
realtimeDataLayout->setContentsMargins(4, 4, 4, 4);
|
||
realtimeDataLayout->setSpacing(3);
|
||
m_realtimeSummaryLabel = new QLabel(QStringLiteral("时间：- 数量：0"), realtimeDataGroup);
|
||
m_realtimeTearTable = new QTableWidget(realtimeDataGroup);
|
||
m_realtimeTearTable->setColumnCount(5);
|
||
m_realtimeTearTable->setHorizontalHeaderLabels({
|
||
QStringLiteral("ID"), QStringLiteral("状态"), QStringLiteral("长度(mm)"),
|
||
QStringLiteral("宽度(mm)"), QStringLiteral("深度(mm)")
|
||
});
|
||
m_realtimeTearTable->setEditTriggers(QAbstractItemView::NoEditTriggers);
|
||
m_realtimeTearTable->setSelectionBehavior(QAbstractItemView::SelectRows);
|
||
m_realtimeTearTable->verticalHeader()->setVisible(false);
|
||
m_realtimeTearTable->horizontalHeader()->setSectionResizeMode(QHeaderView::Stretch);
|
||
realtimeDataLayout->addWidget(m_realtimeSummaryLabel);
|
||
realtimeDataLayout->addWidget(m_realtimeTearTable, 1);
|
||
|
||
auto* realtimeImageGroup = new QGroupBox(QStringLiteral("结果图片"), realtimeSplitter);
|
||
auto* realtimeImageLayout = new QVBoxLayout(realtimeImageGroup);
|
||
realtimeImageLayout->setContentsMargins(4, 4, 4, 4);
|
||
m_realtimeImageLabel = new QLabel(QStringLiteral("暂无图片"), realtimeImageGroup);
|
||
m_realtimeImageLabel->setAlignment(Qt::AlignCenter);
|
||
m_realtimeImageLabel->setMinimumSize(200, 140);
|
||
m_realtimeImageLabel->setStyleSheet(QStringLiteral(
|
||
"QLabel { background-color: rgb(37, 38, 42); color: rgb(180, 180, 180); }"));
|
||
realtimeImageLayout->addWidget(m_realtimeImageLabel, 1);
|
||
realtimeSplitter->addWidget(realtimeDataGroup);
|
||
realtimeSplitter->addWidget(realtimeImageGroup);
|
||
realtimeSplitter->setStretchFactor(0, 3);
|
||
realtimeSplitter->setStretchFactor(1, 5);
|
||
statsLayout->addWidget(realtimeSplitter, 3, 0, 1, 3);
|
||
statsLayout->setRowStretch(3, 1);
|
||
auto* tabs = new QTabWidget(central);
|
||
tabs->addTab(statsGroup, QStringLiteral("接收统计"));
|
||
tabs->addTab(configGroup, QStringLiteral("参数配置测试"));
|
||
tabs->addTab(pointCloudGroup, QStringLiteral("点云测试"));
|
||
tabs->addTab(storageGroup, QStringLiteral("保存选项"));
|
||
mainLayout->addWidget(tabs, 2);
|
||
|
||
auto* logGroup = new QGroupBox(QStringLiteral("协议日志"), central);
|
||
auto* logLayout = new QVBoxLayout(logGroup);
|
||
logLayout->setContentsMargins(4, 4, 4, 4);
|
||
logLayout->setSpacing(2);
|
||
m_logEdit = new QPlainTextEdit(logGroup);
|
||
m_logEdit->setReadOnly(true);
|
||
m_logEdit->setLineWrapMode(QPlainTextEdit::NoWrap);
|
||
m_logEdit->setFont(QFontDatabase::systemFont(QFontDatabase::FixedFont));
|
||
logLayout->addWidget(m_logEdit);
|
||
mainLayout->addWidget(logGroup, 1);
|
||
setCentralWidget(central);
|
||
|
||
connect(m_connectButton, &QPushButton::clicked, this, &MainWindow::connectToServer);
|
||
connect(m_disconnectButton, &QPushButton::clicked, this, &MainWindow::disconnectFromServer);
|
||
connect(m_readConfigButton, &QPushButton::clicked, this, &MainWindow::readConfig);
|
||
connect(m_setConfigButton, &QPushButton::clicked, this, &MainWindow::setConfig);
|
||
connect(m_realtimeCheck, &QCheckBox::toggled, this, [this](bool) {
|
||
setRealtime();
|
||
});
|
||
connect(m_resetAlarmButton, &QPushButton::clicked, this, &MainWindow::resetAlarm);
|
||
connect(m_restDetectButton, &QPushButton::clicked, this, &MainWindow::restDetect);
|
||
connect(m_displayLineCountSpin, qOverload<int>(&QSpinBox::valueChanged),
|
||
this, [this](int) {
|
||
trimDisplayedPointClouds();
|
||
});
|
||
connect(realtimeSplitter, &QSplitter::splitterMoved, this, [this](int, int) {
|
||
updateRealtimeImageDisplay();
|
||
});
|
||
connect(m_pointCloudClearButton, &QPushButton::clicked,
|
||
this, [this]() {
|
||
m_cloudView->clearPointClouds();
|
||
logMessage(QStringLiteral("已清空点云显示"));
|
||
});
|
||
connect(browseButton, &QPushButton::clicked, this, &MainWindow::chooseOutputDir);
|
||
}
|
||
|
||
void MainWindow::connectToServer()
|
||
{
|
||
if (m_socket->state() != QAbstractSocket::UnconnectedState)
|
||
m_socket->abort();
|
||
|
||
m_receiveBuffer.clear();
|
||
m_connectionLabel->setText(QStringLiteral("连接中..."));
|
||
logMessage(QStringLiteral("连接 %1:%2").arg(m_hostEdit->text().trimmed()).arg(m_portSpin->value()));
|
||
m_socket->connectToHost(m_hostEdit->text().trimmed(), static_cast<quint16>(m_portSpin->value()));
|
||
}
|
||
|
||
void MainWindow::disconnectFromServer()
|
||
{
|
||
if (m_socket->state() != QAbstractSocket::UnconnectedState)
|
||
m_socket->abort();
|
||
updateConnectionControls(false);
|
||
}
|
||
|
||
void MainWindow::readConfig()
|
||
{
|
||
if (m_socket->state() != QAbstractSocket::ConnectedState) {
|
||
recordError(QStringLiteral("读取配置失败：尚未连接"));
|
||
return;
|
||
}
|
||
QJsonObject request;
|
||
request[QStringLiteral("msgType")] = QStringLiteral("GET_CONFIG");
|
||
request[QStringLiteral("protocolVersion")] = QStringLiteral("1.6");
|
||
request[QStringLiteral("requestId")] = QStringLiteral("cfg-%1")
|
||
.arg(QDateTime::currentMSecsSinceEpoch());
|
||
sendJsonMessage(request);
|
||
logMessage(QStringLiteral("已发送 GET_CONFIG 请求"));
|
||
}
|
||
|
||
void MainWindow::setConfig()
|
||
{
|
||
if (m_socket->state() != QAbstractSocket::ConnectedState) {
|
||
recordError(QStringLiteral("写入参数配置失败：尚未连接"));
|
||
return;
|
||
}
|
||
|
||
QJsonObject request;
|
||
QJsonObject algorithm;
|
||
algorithm[QStringLiteral("scanXScale")] = m_scanXScaleSpin->value();
|
||
algorithm[QStringLiteral("scanYScale")] = m_scanYScaleSpin->value();
|
||
algorithm[QStringLiteral("differnceBinTh")] = m_differenceBinThresholdSpin->value();
|
||
algorithm[QStringLiteral("tearingMinLen")] = m_tearingMinLengthSpin->value();
|
||
algorithm[QStringLiteral("tearingMinWidthY")] = m_tearingMinWidthSpin->value();
|
||
algorithm[QStringLiteral("tearingMinDepthZ")] = m_tearingMinDepthSpin->value();
|
||
algorithm[QStringLiteral("tearingMinGap")] = m_tearingMinGapSpin->value();
|
||
algorithm[QStringLiteral("sameGapTh")] = m_sameGapThresholdSpin->value();
|
||
algorithm[QStringLiteral("gapChkWin")] = m_gapCheckWindowSpin->value();
|
||
|
||
QJsonObject camera;
|
||
camera[QStringLiteral("cameraIP")] = m_cameraIpEdit->text().trimmed();
|
||
|
||
QJsonObject queue;
|
||
queue[QStringLiteral("maxQueueSize")] = m_maxQueueSizeSpin->value();
|
||
queue[QStringLiteral("generationInterval")] = m_generationIntervalSpin->value();
|
||
queue[QStringLiteral("imageLineCount")] = m_imageLineCountSpin->value();
|
||
|
||
QJsonObject pointCloud;
|
||
pointCloud[QStringLiteral("enabled")] = m_enabledCheck->isChecked();
|
||
pointCloud[QStringLiteral("lineStep")] = m_lineStepSpin->value();
|
||
pointCloud[QStringLiteral("pointStep")] = m_pointStepSpin->value();
|
||
QJsonObject config;
|
||
config[QStringLiteral("algorithmParams")] = algorithm;
|
||
config[QStringLiteral("cameraConfig")] = camera;
|
||
config[QStringLiteral("queueProcessParam")] = queue;
|
||
config[QStringLiteral("pointCloudSendParam")] = pointCloud;
|
||
request[QStringLiteral("msgType")] = QStringLiteral("SET_CONFIG");
|
||
request[QStringLiteral("protocolVersion")] = QStringLiteral("1.6");
|
||
request[QStringLiteral("requestId")] = QStringLiteral("cfg-%1")
|
||
.arg(QDateTime::currentMSecsSinceEpoch());
|
||
request[QStringLiteral("config")] = config;
|
||
sendJsonMessage(request);
|
||
logMessage(QStringLiteral("已发送 SET_CONFIG：算法、相机、队列和点云参数"));
|
||
}
|
||
|
||
void MainWindow::setRealtime()
|
||
{
|
||
if (m_socket->state() != QAbstractSocket::ConnectedState) {
|
||
recordError(QStringLiteral("设置实时上报失败：尚未连接"));
|
||
return;
|
||
}
|
||
|
||
QJsonObject request;
|
||
request[QStringLiteral("msgType")] = QStringLiteral("SET_REALTIME");
|
||
request[QStringLiteral("protocolVersion")] = QStringLiteral("1.6");
|
||
request[QStringLiteral("timestamp")] = QDateTime::currentMSecsSinceEpoch();
|
||
request[QStringLiteral("enable")] = m_realtimeCheck->isChecked();
|
||
sendJsonMessage(request);
|
||
logMessage(QStringLiteral("已发送 SET_REALTIME：enable=%1")
|
||
.arg(m_realtimeCheck->isChecked() ? QStringLiteral("true") : QStringLiteral("false")));
|
||
}
|
||
|
||
void MainWindow::resetAlarm()
|
||
{
|
||
if (m_socket->state() != QAbstractSocket::ConnectedState) {
|
||
recordError(QStringLiteral("RESET_ALARM 失败：尚未连接"));
|
||
return;
|
||
}
|
||
|
||
QJsonObject request;
|
||
request[QStringLiteral("msgType")] = QStringLiteral("RESET_ALARM");
|
||
request[QStringLiteral("protocolVersion")] = QStringLiteral("1.6");
|
||
request[QStringLiteral("timestamp")] = QDateTime::currentMSecsSinceEpoch();
|
||
sendJsonMessage(request);
|
||
logMessage(QStringLiteral("已发送 RESET_ALARM"));
|
||
}
|
||
|
||
void MainWindow::restDetect()
|
||
{
|
||
if (m_socket->state() != QAbstractSocket::ConnectedState) {
|
||
recordError(QStringLiteral("REST_DETECT 失败：尚未连接"));
|
||
return;
|
||
}
|
||
|
||
QJsonObject request;
|
||
request[QStringLiteral("msgType")] = QStringLiteral("REST_DETECT");
|
||
request[QStringLiteral("protocolVersion")] = QStringLiteral("1.6");
|
||
request[QStringLiteral("timestamp")] = QDateTime::currentMSecsSinceEpoch();
|
||
sendJsonMessage(request);
|
||
logMessage(QStringLiteral("已发送 REST_DETECT"));
|
||
}
|
||
|
||
void MainWindow::trimDisplayedPointClouds()
|
||
{
|
||
if (!m_cloudView || !m_displayLineCountSpin) {
|
||
return;
|
||
}
|
||
|
||
const size_t maximumLines = static_cast<size_t>(m_displayLineCountSpin->value());
|
||
while (m_cloudView->getCloudCount() > maximumLines) {
|
||
if (!m_cloudView->removeOldestPointCloud()) {
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
|
||
void MainWindow::chooseOutputDir()
|
||
{
|
||
const QString selected = QFileDialog::getExistingDirectory(this, QStringLiteral("选择输出目录"),
|
||
m_outputDirEdit->text());
|
||
if (!selected.isEmpty())
|
||
m_outputDirEdit->setText(selected);
|
||
}
|
||
|
||
void MainWindow::onConnected()
|
||
{
|
||
m_resultLogKeys.clear();
|
||
m_resultLogMessages.clear();
|
||
m_resultLogTimes.clear();
|
||
m_resultLogBlocks.clear();
|
||
m_resultLogRepeatCounts.clear();
|
||
updateConnectionControls(true);
|
||
logMessage(QStringLiteral("已连接到 %1:%2").arg(m_hostEdit->text().trimmed()).arg(m_portSpin->value()));
|
||
QTimer::singleShot(0, this, &MainWindow::requestProtocolInfo);
|
||
}
|
||
|
||
void MainWindow::onDisconnected()
|
||
{
|
||
updateConnectionControls(false);
|
||
logMessage(QStringLiteral("连接已断开"));
|
||
}
|
||
|
||
void MainWindow::onReadyRead()
|
||
{
|
||
m_receiveBuffer.append(m_socket->readAll());
|
||
processFrames();
|
||
}
|
||
|
||
void MainWindow::onSocketError(QAbstractSocket::SocketError error)
|
||
{
|
||
Q_UNUSED(error);
|
||
recordError(QStringLiteral("Socket 错误：%1").arg(m_socket->errorString()));
|
||
}
|
||
|
||
void MainWindow::closeEvent(QCloseEvent* event)
|
||
{
|
||
disconnectFromServer();
|
||
event->accept();
|
||
}
|
||
|
||
void MainWindow::resizeEvent(QResizeEvent* event)
|
||
{
|
||
QMainWindow::resizeEvent(event);
|
||
updateRealtimeImageDisplay();
|
||
}
|
||
|
||
void MainWindow::updateConnectionControls(bool connected)
|
||
{
|
||
m_connectButton->setEnabled(!connected);
|
||
m_disconnectButton->setEnabled(connected);
|
||
m_readConfigButton->setEnabled(connected);
|
||
m_setConfigButton->setEnabled(connected);
|
||
m_realtimeCheck->setEnabled(connected);
|
||
m_resetAlarmButton->setEnabled(connected);
|
||
m_restDetectButton->setEnabled(connected);
|
||
m_hostEdit->setEnabled(!connected);
|
||
m_portSpin->setEnabled(!connected);
|
||
if (!connected && m_socket->state() == QAbstractSocket::UnconnectedState)
|
||
m_connectionLabel->setText(QStringLiteral("未连接"));
|
||
else if (connected)
|
||
m_connectionLabel->setText(QStringLiteral("已连接"));
|
||
}
|
||
|
||
void MainWindow::requestProtocolInfo()
|
||
{
|
||
if (m_socket->state() != QAbstractSocket::ConnectedState)
|
||
return;
|
||
|
||
QJsonObject request;
|
||
request[QStringLiteral("msgType")] = QStringLiteral("GET_PROTOCOL_INFO");
|
||
request[QStringLiteral("protocolVersion")] = QStringLiteral("1.6");
|
||
sendJsonMessage(request);
|
||
logMessage(QStringLiteral("已发送新协议 GET_PROTOCOL_INFO 请求"));
|
||
}
|
||
|
||
void MainWindow::sendFrame(quint8 dataType, const QByteArray& payload)
|
||
{
|
||
QByteArray frame;
|
||
QDataStream stream(&frame, QIODevice::WriteOnly);
|
||
stream.setByteOrder(QDataStream::BigEndian);
|
||
stream << dataType << static_cast<quint32>(payload.size());
|
||
frame.append(payload);
|
||
frame.append(kFrameTail);
|
||
m_socket->write(frame);
|
||
m_socket->flush();
|
||
}
|
||
|
||
void MainWindow::sendJsonMessage(const QJsonObject& message)
|
||
{
|
||
const QByteArray payload = QJsonDocument(message).toJson(QJsonDocument::Compact);
|
||
QByteArray frame;
|
||
frame.append(kJsonFrameHeader);
|
||
frame.append(QByteArray::number(payload.size()).rightJustified(kJsonFrameLengthSize, '0'));
|
||
frame.append(payload);
|
||
frame.append(kJsonFrameTail);
|
||
m_socket->write(frame);
|
||
m_socket->flush();
|
||
}
|
||
|
||
void MainWindow::processFrames()
|
||
{
|
||
while (!m_receiveBuffer.isEmpty()) {
|
||
const int sizeBefore = m_receiveBuffer.size();
|
||
if (m_receiveBuffer.startsWith(kJsonFrameHeader))
|
||
processJsonFrames();
|
||
else
|
||
processPointCloudFrames();
|
||
if (m_receiveBuffer.size() == sizeBefore)
|
||
break;
|
||
}
|
||
}
|
||
|
||
void MainWindow::processPointCloudFrames()
|
||
{
|
||
const int minimumFrameSize = kFrameHeaderSize + kFrameTailSize;
|
||
while (m_receiveBuffer.size() >= minimumFrameSize) {
|
||
if (m_receiveBuffer.startsWith(kJsonFrameHeader))
|
||
return;
|
||
|
||
const quint8 dataType = static_cast<quint8>(m_receiveBuffer.at(0));
|
||
const quint32 payloadSize = readUInt32BE(m_receiveBuffer, 1);
|
||
if (payloadSize > kMaxPayloadSize) {
|
||
recordError(QStringLiteral("点云帧负载长度非法：%1").arg(payloadSize));
|
||
m_receiveBuffer.remove(0, 1);
|
||
continue;
|
||
}
|
||
|
||
const quint64 frameSize = static_cast<quint64>(kFrameHeaderSize)
|
||
+ payloadSize + kFrameTailSize;
|
||
if (static_cast<quint64>(m_receiveBuffer.size()) < frameSize)
|
||
return;
|
||
|
||
const int tailOffset = kFrameHeaderSize + static_cast<int>(payloadSize);
|
||
if (m_receiveBuffer.mid(tailOffset, kFrameTailSize) != kFrameTail) {
|
||
recordError(QStringLiteral("点云帧尾非法"));
|
||
m_receiveBuffer.remove(0, 1);
|
||
continue;
|
||
}
|
||
|
||
const QByteArray payload = m_receiveBuffer.mid(
|
||
kFrameHeaderSize, static_cast<int>(payloadSize));
|
||
m_receiveBuffer.remove(0, static_cast<int>(frameSize));
|
||
handleFrame(dataType, payload, static_cast<int>(frameSize));
|
||
}
|
||
}
|
||
|
||
void MainWindow::processJsonFrames()
|
||
{
|
||
const int minimumFrameSize = kJsonFrameHeaderSize + kJsonFrameLengthSize + kJsonFrameTailSize;
|
||
while (m_receiveBuffer.size() >= minimumFrameSize) {
|
||
if (!m_receiveBuffer.startsWith(kJsonFrameHeader))
|
||
return;
|
||
const int headerPos = m_receiveBuffer.indexOf(kJsonFrameHeader);
|
||
if (headerPos < 0)
|
||
return;
|
||
if (headerPos > 0)
|
||
m_receiveBuffer.remove(0, headerPos);
|
||
if (m_receiveBuffer.size() < kJsonFrameHeaderSize + kJsonFrameLengthSize)
|
||
return;
|
||
|
||
bool lengthOk = false;
|
||
const quint32 payloadSize = m_receiveBuffer
|
||
.mid(kJsonFrameHeaderSize, kJsonFrameLengthSize).toUInt(&lengthOk);
|
||
if (!lengthOk || payloadSize > kMaxJsonPayloadSize) {
|
||
recordError(QStringLiteral("新协议负载长度非法"));
|
||
m_receiveBuffer.remove(0, kJsonFrameHeaderSize);
|
||
continue;
|
||
}
|
||
|
||
const quint64 frameSize = static_cast<quint64>(kJsonFrameHeaderSize)
|
||
+ kJsonFrameLengthSize + payloadSize + kJsonFrameTailSize;
|
||
if (static_cast<quint64>(m_receiveBuffer.size()) < frameSize)
|
||
return;
|
||
|
||
const int tailOffset = kJsonFrameHeaderSize + kJsonFrameLengthSize + static_cast<int>(payloadSize);
|
||
if (m_receiveBuffer.mid(tailOffset, kJsonFrameTailSize) != kJsonFrameTail) {
|
||
recordError(QStringLiteral("新协议帧尾非法"));
|
||
m_receiveBuffer.remove(0, kJsonFrameHeaderSize);
|
||
continue;
|
||
}
|
||
|
||
const QByteArray payload = m_receiveBuffer.mid(
|
||
kJsonFrameHeaderSize + kJsonFrameLengthSize, static_cast<int>(payloadSize));
|
||
m_receiveBuffer.remove(0, static_cast<int>(frameSize));
|
||
m_receivedBytes += static_cast<qint64>(frameSize);
|
||
m_bytesValue->setText(QString::number(m_receivedBytes));
|
||
handleNewJsonPayload(payload);
|
||
}
|
||
}
|
||
|
||
void MainWindow::handleFrame(quint8 dataType, const QByteArray& payload, int frameSize)
|
||
{
|
||
m_receivedBytes += frameSize;
|
||
m_bytesValue->setText(QString::number(m_receivedBytes));
|
||
|
||
if (dataType == kPointCloudType) {
|
||
PointCloudSummary summary;
|
||
QVector<PointCloudPoint> points;
|
||
QString error;
|
||
if (!parsePointCloud(payload, summary, points, error)) {
|
||
recordError(QStringLiteral("点云帧解析失败：%1").arg(error));
|
||
return;
|
||
}
|
||
++m_pointLineCount;
|
||
++m_pointCloudFrameCount;
|
||
m_linesValue->setText(QString::number(m_pointLineCount));
|
||
updatePointCloudStats(summary);
|
||
PointCloudXYZRGB cloud;
|
||
cloud.reserve(static_cast<size_t>(points.size()));
|
||
for (const PointCloudPoint& point : points) {
|
||
cloud.push_back(Point3DRGB(static_cast<float>(point.x),
|
||
static_cast<float>(point.y),
|
||
static_cast<float>(point.z),
|
||
170, 170, 170), 0);
|
||
}
|
||
m_cloudView->addPointCloud(cloud,
|
||
QStringLiteral("frame-%1").arg(summary.frameIndex),
|
||
false);
|
||
trimDisplayedPointClouds();
|
||
if (m_savePointsCheck->isChecked())
|
||
appendPoints(summary, points);
|
||
if (m_saveCloudUtilsCheck->isChecked())
|
||
saveCloudUtilsFrame(summary, points);
|
||
return;
|
||
}
|
||
|
||
if (dataType == kImageType) {
|
||
++m_imageCount;
|
||
if (m_saveImagesCheck->isChecked())
|
||
saveImage(payload);
|
||
if (m_imageCount <= 3 || m_imageCount % 20 == 0)
|
||
logMessage(QStringLiteral("图像 #%1：%2 字节").arg(m_imageCount).arg(payload.size()));
|
||
return;
|
||
}
|
||
|
||
if (dataType == kTextType || dataType == kReadConfigType || dataType == kWriteConfigType) {
|
||
handleJsonPayload(dataType, payload);
|
||
return;
|
||
}
|
||
|
||
recordError(QStringLiteral("未知数据类型：0x%1").arg(dataType, 2, 16, QLatin1Char('0')));
|
||
}
|
||
|
||
void MainWindow::handleJsonPayload(quint8 dataType, const QByteArray& payload)
|
||
{
|
||
QJsonParseError parseError;
|
||
const QJsonDocument document = QJsonDocument::fromJson(payload, &parseError);
|
||
if (document.isNull()) {
|
||
recordError(QStringLiteral("JSON 解析失败：%1").arg(parseError.errorString()));
|
||
return;
|
||
}
|
||
|
||
const QJsonObject object = document.object();
|
||
const QJsonObject config = object.value(QStringLiteral("config")).toObject();
|
||
const QJsonObject pointCloud = config.value(QStringLiteral("pointCloudSendParam")).toObject();
|
||
if (!pointCloud.isEmpty()) {
|
||
m_enabledCheck->setChecked(pointCloud.value(QStringLiteral("enabled")).toBool(true));
|
||
m_lineStepSpin->setValue(qMax(1, pointCloud.value(QStringLiteral("lineStep")).toInt(1)));
|
||
m_pointStepSpin->setValue(qMax(1, pointCloud.value(QStringLiteral("pointStep")).toInt(1)));
|
||
}
|
||
|
||
const QString typeName = dataType == kTextType ? QStringLiteral("Text")
|
||
: dataType == kReadConfigType ? QStringLiteral("ReadConfig")
|
||
: QStringLiteral("WriteConfig");
|
||
logMessage(QStringLiteral("%1: %2").arg(typeName,
|
||
QString::fromUtf8(QJsonDocument(object).toJson(QJsonDocument::Compact))));
|
||
}
|
||
|
||
void MainWindow::handleNewJsonPayload(const QByteArray& payload)
|
||
{
|
||
QJsonParseError parseError;
|
||
const QJsonDocument document = QJsonDocument::fromJson(payload, &parseError);
|
||
if (document.isNull() || !document.isObject()) {
|
||
recordError(QStringLiteral("新协议 JSON 解析失败：%1").arg(parseError.errorString()));
|
||
return;
|
||
}
|
||
|
||
const QJsonObject object = document.object();
|
||
const QJsonObject config = object.value(QStringLiteral("config")).toObject();
|
||
if (!config.isEmpty())
|
||
updateConfigControls(config);
|
||
|
||
const QString messageType = object.value(QStringLiteral("msgType")).toString();
|
||
if (messageType == QStringLiteral("REALTIME_RESULT") ||
|
||
messageType == QStringLiteral("DETECT_RESULT")) {
|
||
const QJsonArray tears = object.value(QStringLiteral("tears")).toArray();
|
||
const int count = object.value(QStringLiteral("count")).toInt(tears.size());
|
||
const bool hasImage = !object.value(QStringLiteral("visimg")).toString().isEmpty();
|
||
updateRealtimeResult(object);
|
||
m_frameValue->setText(QStringLiteral("实时 ts=%1")
|
||
.arg(object.value(QStringLiteral("timestamp")).toVariant().toLongLong()));
|
||
m_countValue->setText(QString::number(count));
|
||
QJsonObject repeatObject = object;
|
||
repeatObject.remove(QStringLiteral("timestamp"));
|
||
repeatObject.remove(QStringLiteral("visimg"));
|
||
const QString repeatKey = messageType + QLatin1Char(':')
|
||
+ QString::fromUtf8(QJsonDocument(repeatObject).toJson(QJsonDocument::Compact));
|
||
logResultMessage(messageType,
|
||
QStringLiteral("%1：count=%2 tears=%3 visimg=%4")
|
||
.arg(messageType)
|
||
.arg(count)
|
||
.arg(tears.size())
|
||
.arg(hasImage ? QStringLiteral("有") : QStringLiteral("无")),
|
||
repeatKey);
|
||
return;
|
||
}
|
||
logMessage(QStringLiteral("新协议 %1: %2").arg(
|
||
messageType.isEmpty() ? QStringLiteral("消息") : messageType,
|
||
QString::fromUtf8(QJsonDocument(object).toJson(QJsonDocument::Compact))));
|
||
}
|
||
|
||
void MainWindow::updateRealtimeResult(const QJsonObject& object)
|
||
{
|
||
const QJsonArray tears = object.value(QStringLiteral("tears")).toArray();
|
||
const int count = object.value(QStringLiteral("count")).toInt(tears.size());
|
||
const qint64 timestamp = object.value(QStringLiteral("timestamp")).toVariant().toLongLong();
|
||
const QString timeText = timestamp > 0
|
||
? QDateTime::fromMSecsSinceEpoch(timestamp).toString(QStringLiteral("yyyy-MM-dd HH:mm:ss.zzz"))
|
||
: QStringLiteral("-");
|
||
m_realtimeSummaryLabel->setText(
|
||
QStringLiteral("时间：%1 数量：%2").arg(timeText).arg(count));
|
||
|
||
m_realtimeTearTable->setRowCount(tears.size());
|
||
auto statusText = [](int status) {
|
||
switch (status) {
|
||
case 1: return QStringLiteral("新发现");
|
||
case 2: return QStringLiteral("增长中");
|
||
case 3: return QStringLiteral("已结束");
|
||
case 4: return QStringLiteral("无效");
|
||
default: return QStringLiteral("未知");
|
||
}
|
||
};
|
||
for (int row = 0; row < tears.size(); ++row) {
|
||
const QJsonObject tear = tears.at(row).toObject();
|
||
const QStringList values = {
|
||
QString::number(tear.value(QStringLiteral("id")).toInt()),
|
||
statusText(tear.value(QStringLiteral("status")).toInt()),
|
||
QString::number(tear.value(QStringLiteral("length")).toDouble()),
|
||
QString::number(tear.value(QStringLiteral("width")).toDouble()),
|
||
QString::number(tear.value(QStringLiteral("depth")).toDouble())
|
||
};
|
||
for (int column = 0; column < values.size(); ++column) {
|
||
auto* item = new QTableWidgetItem(values.at(column));
|
||
item->setTextAlignment(Qt::AlignCenter);
|
||
m_realtimeTearTable->setItem(row, column, item);
|
||
}
|
||
}
|
||
|
||
QByteArray encodedImage = object.value(QStringLiteral("visimg")).toString().toLatin1();
|
||
const int dataSeparator = encodedImage.indexOf(',');
|
||
if (encodedImage.startsWith("data:") && dataSeparator >= 0) {
|
||
encodedImage.remove(0, dataSeparator + 1);
|
||
}
|
||
const QByteArray imageData = QByteArray::fromBase64(encodedImage);
|
||
QImage image;
|
||
if (!imageData.isEmpty() && image.loadFromData(imageData)) {
|
||
m_realtimeImage = image;
|
||
updateRealtimeImageDisplay();
|
||
} else if (encodedImage.isEmpty()) {
|
||
m_realtimeImage = QImage();
|
||
m_realtimeImageLabel->setPixmap(QPixmap());
|
||
m_realtimeImageLabel->setText(QStringLiteral("暂无图片"));
|
||
} else {
|
||
recordError(QStringLiteral("实时结果图片解码失败"));
|
||
}
|
||
}
|
||
|
||
void MainWindow::updateRealtimeImageDisplay()
|
||
{
|
||
if (!m_realtimeImageLabel || m_realtimeImage.isNull()) {
|
||
return;
|
||
}
|
||
const QSize targetSize = m_realtimeImageLabel->contentsRect().size();
|
||
if (targetSize.isEmpty()) {
|
||
return;
|
||
}
|
||
m_realtimeImageLabel->setText(QString());
|
||
m_realtimeImageLabel->setPixmap(QPixmap::fromImage(m_realtimeImage).scaled(
|
||
targetSize, Qt::KeepAspectRatio, Qt::SmoothTransformation));
|
||
}
|
||
|
||
void MainWindow::updateConfigControls(const QJsonObject& config)
|
||
{
|
||
const QJsonObject algorithm = config.value(QStringLiteral("algorithmParams")).toObject();
|
||
auto updateDouble = [&algorithm](const QString& key, QDoubleSpinBox* spinBox) {
|
||
if (algorithm.contains(key) && algorithm.value(key).isDouble())
|
||
spinBox->setValue(algorithm.value(key).toDouble());
|
||
};
|
||
updateDouble(QStringLiteral("scanXScale"), m_scanXScaleSpin);
|
||
updateDouble(QStringLiteral("scanYScale"), m_scanYScaleSpin);
|
||
updateDouble(QStringLiteral("differnceBinTh"), m_differenceBinThresholdSpin);
|
||
updateDouble(QStringLiteral("tearingMinLen"), m_tearingMinLengthSpin);
|
||
updateDouble(QStringLiteral("tearingMinWidthY"), m_tearingMinWidthSpin);
|
||
updateDouble(QStringLiteral("tearingMinDepthZ"), m_tearingMinDepthSpin);
|
||
updateDouble(QStringLiteral("tearingMinGap"), m_tearingMinGapSpin);
|
||
updateDouble(QStringLiteral("sameGapTh"), m_sameGapThresholdSpin);
|
||
if (algorithm.contains(QStringLiteral("gapChkWin")))
|
||
m_gapCheckWindowSpin->setValue(qMax(1, algorithm.value(QStringLiteral("gapChkWin")).toInt(1)));
|
||
|
||
const QJsonObject camera = config.value(QStringLiteral("cameraConfig")).toObject();
|
||
if (camera.contains(QStringLiteral("cameraIP")))
|
||
m_cameraIpEdit->setText(camera.value(QStringLiteral("cameraIP")).toString());
|
||
|
||
const QJsonObject queue = config.value(QStringLiteral("queueProcessParam")).toObject();
|
||
if (queue.contains(QStringLiteral("maxQueueSize")))
|
||
m_maxQueueSizeSpin->setValue(qMax(1, queue.value(QStringLiteral("maxQueueSize")).toInt(1)));
|
||
if (queue.contains(QStringLiteral("generationInterval")))
|
||
m_generationIntervalSpin->setValue(qMax(1, queue.value(QStringLiteral("generationInterval")).toInt(1)));
|
||
if (queue.contains(QStringLiteral("imageLineCount")))
|
||
m_imageLineCountSpin->setValue(qMax(1, queue.value(QStringLiteral("imageLineCount")).toInt(1)));
|
||
|
||
const QJsonObject pointCloud = config.value(QStringLiteral("pointCloudSendParam")).toObject();
|
||
if (!pointCloud.isEmpty()) {
|
||
m_enabledCheck->setChecked(pointCloud.value(QStringLiteral("enabled")).toBool(true));
|
||
m_lineStepSpin->setValue(qMax(1, pointCloud.value(QStringLiteral("lineStep")).toInt(1)));
|
||
m_pointStepSpin->setValue(qMax(1, pointCloud.value(QStringLiteral("pointStep")).toInt(1)));
|
||
}
|
||
}
|
||
|
||
bool MainWindow::parsePointCloud(const QByteArray& payload, PointCloudSummary& summary,
|
||
QVector<PointCloudPoint>& points, QString& error) const
|
||
{
|
||
constexpr int headerSize = 33;
|
||
constexpr int pointSize = 28;
|
||
if (payload.size() < headerSize) {
|
||
error = QStringLiteral("负载过短：%1").arg(payload.size());
|
||
return false;
|
||
}
|
||
|
||
QDataStream stream(payload);
|
||
stream.setByteOrder(QDataStream::BigEndian);
|
||
stream.setFloatingPointPrecision(QDataStream::DoublePrecision);
|
||
quint8 version = 0;
|
||
stream >> version >> summary.frameIndex >> summary.timestamp >> summary.originalCount
|
||
>> summary.sampledCount >> summary.lineStep >> summary.pointStep;
|
||
if (stream.status() != QDataStream::Ok || version != 1) {
|
||
error = QStringLiteral("不支持的点云格式版本：%1").arg(version);
|
||
return false;
|
||
}
|
||
|
||
const quint64 expectedSize = static_cast<quint64>(headerSize)
|
||
+ static_cast<quint64>(summary.sampledCount) * pointSize;
|
||
if (expectedSize != static_cast<quint64>(payload.size())) {
|
||
error = QStringLiteral("长度不匹配，期望 %1，收到 %2").arg(expectedSize).arg(payload.size());
|
||
return false;
|
||
}
|
||
|
||
points.reserve(static_cast<int>(summary.sampledCount));
|
||
for (quint32 i = 0; i < summary.sampledCount; ++i) {
|
||
qint32 pointIndex = 0;
|
||
double x = 0.0;
|
||
double y = 0.0;
|
||
double z = 0.0;
|
||
stream >> pointIndex >> x >> y >> z;
|
||
if (stream.status() != QDataStream::Ok) {
|
||
error = QStringLiteral("点数据读取失败");
|
||
return false;
|
||
}
|
||
points.append(PointCloudPoint{pointIndex, x, y, z});
|
||
if (i == 0) {
|
||
summary.xMin = summary.xMax = x;
|
||
summary.yMin = summary.yMax = y;
|
||
summary.zMin = summary.zMax = z;
|
||
} else {
|
||
summary.xMin = qMin(summary.xMin, x);
|
||
summary.xMax = qMax(summary.xMax, x);
|
||
summary.yMin = qMin(summary.yMin, y);
|
||
summary.yMax = qMax(summary.yMax, y);
|
||
summary.zMin = qMin(summary.zMin, z);
|
||
summary.zMax = qMax(summary.zMax, z);
|
||
}
|
||
}
|
||
return true;
|
||
}
|
||
|
||
void MainWindow::appendPoints(const PointCloudSummary& summary, const QVector<PointCloudPoint>& points)
|
||
{
|
||
const QString directory = ensureOutputDir();
|
||
if (directory.isEmpty())
|
||
return;
|
||
const QString path = QDir(directory).filePath(QStringLiteral("point_cloud.csv"));
|
||
QFile file(path);
|
||
if (!file.open(QIODevice::WriteOnly | QIODevice::Append | QIODevice::Text)) {
|
||
recordError(QStringLiteral("无法写入 CSV：%1").arg(file.errorString()));
|
||
return;
|
||
}
|
||
QTextStream output(&file);
|
||
if (file.size() == 0)
|
||
output << "frame_index,timestamp,point_index,x,y,z\n";
|
||
for (const PointCloudPoint& point : points)
|
||
output << summary.frameIndex << ',' << summary.timestamp << ','
|
||
<< point.index << ',' << point.x << ',' << point.y << ',' << point.z << '\n';
|
||
}
|
||
|
||
void MainWindow::saveImage(const QByteArray& payload)
|
||
{
|
||
const QString directory = ensureOutputDir();
|
||
if (directory.isEmpty())
|
||
return;
|
||
const QString path = QDir(directory).filePath(
|
||
QStringLiteral("image_%1.jpg").arg(m_imageCount, 6, 10, QLatin1Char('0')));
|
||
QFile file(path);
|
||
if (!file.open(QIODevice::WriteOnly) || file.write(payload) != payload.size())
|
||
recordError(QStringLiteral("无法保存图像：%1").arg(file.errorString()));
|
||
}
|
||
|
||
void MainWindow::saveCloudUtilsFrame(const PointCloudSummary& summary,
|
||
const QVector<PointCloudPoint>& points)
|
||
{
|
||
const QString directory = ensureOutputDir();
|
||
if (directory.isEmpty())
|
||
return;
|
||
|
||
std::vector<std::vector<SVzNL3DPosition>> scanLines(1);
|
||
scanLines.front().reserve(static_cast<size_t>(points.size()));
|
||
for (const PointCloudPoint& point : points) {
|
||
SVzNL3DPosition value{};
|
||
value.nPointIdx = point.index;
|
||
value.pt3D.x = point.x;
|
||
value.pt3D.y = point.y;
|
||
value.pt3D.z = point.z;
|
||
scanLines.front().push_back(value);
|
||
}
|
||
|
||
const QString path = QDir(directory).filePath(
|
||
QStringLiteral("point_cloud_%1.txt").arg(summary.frameIndex, 12, 10, QLatin1Char('0')));
|
||
LaserDataLoader loader;
|
||
const int result = loader.DebugSaveLaser(path.toStdString(), std::move(scanLines));
|
||
if (result != 0) {
|
||
recordError(QStringLiteral("CloudUtils 保存点云失败：%1").arg(
|
||
QString::fromStdString(loader.GetLastError())));
|
||
return;
|
||
}
|
||
}
|
||
|
||
QString MainWindow::ensureOutputDir()
|
||
{
|
||
const QString directory = m_outputDirEdit->text().trimmed();
|
||
if (directory.isEmpty()) {
|
||
recordError(QStringLiteral("输出目录为空"));
|
||
return QString();
|
||
}
|
||
QDir dir(directory);
|
||
if (!dir.exists() && !dir.mkpath(QStringLiteral("."))) {
|
||
recordError(QStringLiteral("无法创建输出目录：%1").arg(directory));
|
||
return QString();
|
||
}
|
||
return dir.absolutePath();
|
||
}
|
||
|
||
void MainWindow::logMessage(const QString& message)
|
||
{
|
||
if (!m_logEdit)
|
||
return;
|
||
|
||
if (m_lastLogRepeatCount > 0 && message == m_lastLogKey) {
|
||
++m_lastLogRepeatCount;
|
||
QTextCursor cursor(m_logEdit->document());
|
||
cursor.movePosition(QTextCursor::End);
|
||
cursor.select(QTextCursor::BlockUnderCursor);
|
||
cursor.insertText(QStringLiteral("[%1] %2 x%3")
|
||
.arg(m_lastLogTime, m_lastLogMessage)
|
||
.arg(m_lastLogRepeatCount));
|
||
m_logEdit->ensureCursorVisible();
|
||
return;
|
||
}
|
||
|
||
m_lastLogKey = message;
|
||
m_lastLogMessage = message;
|
||
m_lastLogTime = QDateTime::currentDateTime().toString(QStringLiteral("HH:mm:ss"));
|
||
m_lastLogRepeatCount = 1;
|
||
m_logEdit->appendPlainText(QStringLiteral("[%1] %2").arg(m_lastLogTime, message));
|
||
}
|
||
|
||
void MainWindow::logResultMessage(const QString& resultType, const QString& message,
|
||
const QString& repeatKey)
|
||
{
|
||
if (!m_logEdit)
|
||
return;
|
||
|
||
if (m_resultLogKeys.value(resultType) == repeatKey) {
|
||
const int repeatCount = m_resultLogRepeatCounts.value(resultType, 1) + 1;
|
||
const QString renderedLine = QStringLiteral("[%1] %2 x%3")
|
||
.arg(m_resultLogTimes.value(resultType),
|
||
m_resultLogMessages.value(resultType))
|
||
.arg(repeatCount);
|
||
const QTextBlock block = m_logEdit->document()->findBlockByNumber(
|
||
m_resultLogBlocks.value(resultType, -1));
|
||
if (block.isValid()) {
|
||
QTextCursor cursor(block);
|
||
cursor.select(QTextCursor::BlockUnderCursor);
|
||
cursor.insertText(renderedLine);
|
||
m_resultLogRepeatCounts[resultType] = repeatCount;
|
||
m_logEdit->ensureCursorVisible();
|
||
m_lastLogRepeatCount = 0;
|
||
return;
|
||
}
|
||
}
|
||
|
||
const QString logTime = QDateTime::currentDateTime().toString(QStringLiteral("HH:mm:ss"));
|
||
const QString renderedLine = QStringLiteral("[%1] %2").arg(logTime, message);
|
||
m_logEdit->appendPlainText(renderedLine);
|
||
m_resultLogKeys[resultType] = repeatKey;
|
||
m_resultLogMessages[resultType] = message;
|
||
m_resultLogTimes[resultType] = logTime;
|
||
m_resultLogBlocks[resultType] = m_logEdit->document()->lastBlock().blockNumber();
|
||
m_resultLogRepeatCounts[resultType] = 1;
|
||
m_lastLogRepeatCount = 0;
|
||
}
|
||
|
||
void MainWindow::recordError(const QString& message)
|
||
{
|
||
++m_errorCount;
|
||
if (m_errorsValue)
|
||
m_errorsValue->setText(QString::number(m_errorCount));
|
||
logMessage(QStringLiteral("错误：%1").arg(message));
|
||
}
|
||
|
||
void MainWindow::updatePointCloudStats(const PointCloudSummary& summary)
|
||
{
|
||
m_frameValue->setText(QStringLiteral("%1 (ts=%2)").arg(summary.frameIndex).arg(summary.timestamp));
|
||
m_countValue->setText(QStringLiteral("%1 / %2").arg(summary.originalCount).arg(summary.sampledCount));
|
||
m_stepsValue->setText(QStringLiteral("%1 / %2").arg(summary.lineStep).arg(summary.pointStep));
|
||
m_xRangeValue->setText(formatRange(summary.xMin, summary.xMax));
|
||
m_yRangeValue->setText(formatRange(summary.yMin, summary.yMax));
|
||
m_zRangeValue->setText(formatRange(summary.zMin, summary.zMax));
|
||
}
|