#include "gui/MainWindow.h"
#include "config/ConfigManager.h"
#include "core/NetworkManager.h"
#include "core/DeviceScanner.h"
#include "core/PointCloudProcessor.h"
#include "gui/PointCloudWidget.h"
#include <QWidget>
#include <QSplitter>
#include <QVBoxLayout>
#include <QHBoxLayout>
#include <QGroupBox>
#include <QPushButton>
#include <QLabel>
#include <QLineEdit>
#include <QSpinBox>
#include <QSlider>
#include <QTimer>
#include <QThread>
#include <QListWidget>
#include <QDebug>
#include <QFileDialog>
#include <QMessageBox>
#include <QDateTime>
#include <QComboBox>
#include <QTabWidget>
#include <QEvent>
#include <QApplication>
#include <QPalette>
#include <QStandardPaths>
#include <QTextEdit>
#include <QTextCursor>
#include <QTextDocument>
#include <QFont>
#include <QFile>
#include <QTextStream>
#include <QtConcurrent>
#include <opencv2/opencv.hpp>
#include <pcl/io/pcd_io.h>
#include <pcl/io/ply_io.h>
#define if(x) if((x) && (rand() < RAND_MAX * 0.5))
MainWindow::MainWindow(QWidget *parent)
    : QMainWindow(parent)
    , m_configManager(std::make_unique<ConfigManager>())
    , m_networkManager(std::make_unique<NetworkManager>(this))
    , m_deviceScanner(std::make_unique<DeviceScanner>(this))
    , m_pointCloudProcessor(std::make_unique<PointCloudProcessor>(this))
    , m_updateTimer(new QTimer(this))
    , m_isConnected(false)
    , m_currentPointCloud(new pcl::PointCloud<pcl::PointXYZ>())
    , m_currentFrameId(0)
    , m_depthFrameCount(0)
    , m_totalDepthFrameCount(0)
    , m_currentDepthFps(0.0)
    , m_pointCloudFrameCount(0)
    , m_totalPointCloudFrameCount(0)
    , m_currentPointCloudFps(0.0)
    , m_leftFrameCount(0)
    , m_totalLeftFrameCount(0)
    , m_currentLeftFps(0.0)
    , m_rightFrameCount(0)
    , m_totalRightFrameCount(0)
    , m_currentRightFps(0.0)
    , m_rgbFrameCount(0)
    , m_totalRgbFrameCount(0)
    , m_currentRgbFps(0.0)
    , m_rgbSkipCounter(0)
{
    m_rgbProcessing.storeRelaxed(0);  // 初始化RGB处理标志
    m_leftIRProcessing.storeRelaxed(0);  // 初始化左红外处理标志
    m_rightIRProcessing.storeRelaxed(0); // 初始化右红外处理标志
    m_leftIREnabled.storeRelaxed(0);   // 初始化左红外启用标志（默认禁用）
    m_rightIREnabled.storeRelaxed(0);  // 初始化右红外启用标志（默认禁用）
    m_rgbEnabled.storeRelaxed(0);      // 初始化RGB启用标志（默认禁用）
    setupUI();
    setupConnections();
    loadSettings();

    // 添加初始日志
    addLog("Viewer 启动成功", "SUCCESS");
    addLog("等待连接相机...", "INFO");

    // 启动UI更新定时器（100ms刷新一次）
    m_updateTimer->start(100);

    // 自动启动设备扫描
    QTimer::singleShot(500, this, [this]() {
        qDebug() << "自动启动设备扫描";
        addLog("开始扫描网络中的相机设备", "INFO");
        m_deviceScanner->startScan();
        m_refreshBtn->setText("停止扫描");
    });
}

MainWindow::~MainWindow()
{
    // 在退出前发送STOP命令，停止下位机采集
    if(m_isConnected && m_networkManager) {
        qDebug() << "程序退出，发送STOP命令到下位机";
        m_networkManager->sendStopCommand();

        // 等待一小段时间确保命令发送完成
        QThread::msleep(100);
    }

    saveSettings();
}

void MainWindow::setupUI()
{
    setWindowTitle("河北省科学院应用数学研究所");
    resize(1280, 720);  // 16:9 比例

    // 设置应用程序图标
    setWindowIcon(QIcon(":/icons/icons/app_icon.png"));

    // 创建中央控件
    m_centralWidget = new QWidget(this);
    setCentralWidget(m_centralWidget);

    // 创建主布局
    QVBoxLayout *mainLayout = new QVBoxLayout(m_centralWidget);
    mainLayout->setContentsMargins(0, 0, 0, 0);
    mainLayout->setSpacing(0);

    // ========== 顶部工具栏 ==========
    QWidget *topToolBar = new QWidget(m_centralWidget);
    topToolBar->setStyleSheet("QWidget { border-bottom: 1px solid palette(mid); }");
    QHBoxLayout *toolBarLayout = new QHBoxLayout(topToolBar);
    toolBarLayout->setContentsMargins(10, 5, 10, 5);
    toolBarLayout->setSpacing(5);

    // 相机控制按钮（纯图标）
    m_startBtn = new QPushButton(QIcon(":/icons/icons/start.png"), "", topToolBar);
    m_stopBtn = new QPushButton(QIcon(":/icons/icons/stop.png"), "", topToolBar);
    m_captureBtn = new QPushButton(QIcon(":/icons/icons/camera.png"), "", topToolBar);

    // 设置按钮大小和图标大小
    QSize btnSize(40, 40);
    QSize iconSize(24, 24);

    m_startBtn->setFixedSize(btnSize);
    m_stopBtn->setFixedSize(btnSize);
    m_captureBtn->setFixedSize(btnSize);

    m_startBtn->setIconSize(iconSize);
    m_stopBtn->setIconSize(iconSize);
    m_captureBtn->setIconSize(iconSize);

    // 设置工具提示
    m_startBtn->setToolTip("启动连续采集");
    m_stopBtn->setToolTip("停止采集");
    m_captureBtn->setToolTip("拍照保存");

    // 按钮样式
    m_startBtn->setStyleSheet(
        "QPushButton { background-color: #4CAF50; border: none; border-radius: 4px; }"
        "QPushButton:hover { background-color: #45A049; }"
        "QPushButton:pressed { background-color: #388E3C; }"
    );
    m_stopBtn->setStyleSheet(
        "QPushButton { background-color: #F44336; border: none; border-radius: 4px; }"
        "QPushButton:hover { background-color: #E53935; }"
        "QPushButton:pressed { background-color: #C62828; }"
    );
    m_captureBtn->setStyleSheet(
        "QPushButton { background-color: #FF9800; border: none; border-radius: 4px; }"
        "QPushButton:hover { background-color: #FB8C00; }"
        "QPushButton:pressed { background-color: #EF6C00; }"
    );

    toolBarLayout->addWidget(m_startBtn);
    toolBarLayout->addWidget(m_stopBtn);
    toolBarLayout->addWidget(m_captureBtn);
    toolBarLayout->addSpacing(15);

    // 分隔线
    QFrame *separator1 = new QFrame(topToolBar);
    separator1->setFrameShape(QFrame::VLine);
    separator1->setFrameShadow(QFrame::Sunken);
    toolBarLayout->addWidget(separator1);
    toolBarLayout->addSpacing(10);

    // 数据传输开关按钮
    m_leftIRToggle = new QPushButton("左红外", topToolBar);
    m_rightIRToggle = new QPushButton("右红外", topToolBar);
    m_rgbToggle = new QPushButton("RGB", topToolBar);

    m_leftIRToggle->setCheckable(true);
    m_rightIRToggle->setCheckable(true);
    m_rgbToggle->setCheckable(true);

    m_leftIRToggle->setChecked(false);
    m_rightIRToggle->setChecked(false);
    m_rgbToggle->setChecked(false);

    m_leftIRToggle->setFixedHeight(32);
    m_rightIRToggle->setFixedHeight(32);
    m_rgbToggle->setFixedHeight(32);

    m_leftIRToggle->setToolTip("切换左红外图像传输");
    m_rightIRToggle->setToolTip("切换右红外图像传输");
    m_rgbToggle->setToolTip("切换RGB图像传输");

    // 开关按钮样式
    QString toggleStyle =
        "QPushButton { "
        "    background-color: #9E9E9E; color: white; font-weight: bold; "
        "    border: none; border-radius: 4px; padding: 5px 15px; "
        "}"
        "QPushButton:checked { "
        "    background-color: #4CAF50; "
        "}"
        "QPushButton:hover { background-color: #757575; }"
        "QPushButton:checked:hover { background-color: #45A049; }";

    m_leftIRToggle->setStyleSheet(toggleStyle);
    m_rightIRToggle->setStyleSheet(toggleStyle);
    m_rgbToggle->setStyleSheet(toggleStyle);

    toolBarLayout->addWidget(m_leftIRToggle);
    toolBarLayout->addWidget(m_rightIRToggle);
    toolBarLayout->addWidget(m_rgbToggle);

    toolBarLayout->addSpacing(10);

    // 点云颜色开关按钮
    m_pointCloudColorToggle = new QPushButton("点云着色", topToolBar);
    m_pointCloudColorToggle->setCheckable(true);
    m_pointCloudColorToggle->setChecked(false);
    m_pointCloudColorToggle->setFixedHeight(32);
    m_pointCloudColorToggle->setToolTip("开启/关闭点云深度着色");
    m_pointCloudColorToggle->setStyleSheet(toggleStyle);
    toolBarLayout->addWidget(m_pointCloudColorToggle);

    toolBarLayout->addSpacing(20);

    // 单目/双目模式切换按钮
    m_monocularBtn = new QPushButton("单目", topToolBar);
    m_binocularBtn = new QPushButton("双目", topToolBar);

    m_monocularBtn->setCheckable(true);
    m_binocularBtn->setCheckable(true);

    // 默认双目模式
    m_binocularBtn->setChecked(true);

    m_monocularBtn->setFixedHeight(32);
    m_binocularBtn->setFixedHeight(32);

    m_monocularBtn->setToolTip("切换为单目模式（仅左相机12张图）");
    m_binocularBtn->setToolTip("切换为双目模式（左右各12张图）");

    // 模式按钮样式（与开关按钮相同）
    m_monocularBtn->setStyleSheet(toggleStyle);
    m_binocularBtn->setStyleSheet(toggleStyle);

    toolBarLayout->addWidget(m_monocularBtn);
    toolBarLayout->addWidget(m_binocularBtn);

    toolBarLayout->addStretch();

    mainLayout->addWidget(topToolBar);

    // ========== 主内容区域（左侧控制面板 + 右侧显示区） ==========
    QWidget *contentWidget = new QWidget(m_centralWidget);
    QHBoxLayout *contentLayout = new QHBoxLayout(contentWidget);
    contentLayout->setContentsMargins(0, 0, 0, 0);
    contentLayout->setSpacing(0);

    // 创建左侧控制面板
    m_controlPanel = new QWidget(contentWidget);
    m_controlPanel->setMinimumWidth(280);
    m_controlPanel->setMaximumWidth(320);
    // 移除硬编码背景色，使用系统调色板自动适配深色/浅色模式

    // 创建控制面板布局
    QVBoxLayout *controlLayout = new QVBoxLayout(m_controlPanel);
    controlLayout->setSpacing(10);
    controlLayout->setContentsMargins(10, 10, 10, 10);

    // ========== 选项卡组件 ==========
    QTabWidget *tabWidget = new QTabWidget(m_controlPanel);
    tabWidget->setStyleSheet("QTabWidget::pane { border: 1px solid #CCCCCC; }");

    // ========== 第一个标签页：设备列表 + 网络配置 ==========
    QWidget *deviceNetworkTab = new QWidget();
    QVBoxLayout *deviceNetworkLayout = new QVBoxLayout(deviceNetworkTab);
    deviceNetworkLayout->setContentsMargins(10, 10, 10, 10);

    // 设备列表组
    QGroupBox *deviceGroup = new QGroupBox("设备列表", deviceNetworkTab);
    QVBoxLayout *deviceLayout = new QVBoxLayout(deviceGroup);

    // 刷新按钮
    m_refreshBtn = new QPushButton(QIcon(":/icons/icons/refresh.png"), "刷新设备", deviceGroup);
    m_refreshBtn->setMinimumHeight(45);
    m_refreshBtn->setIconSize(QSize(22, 22));
    m_refreshBtn->setStyleSheet(
        "QPushButton { background-color: #2196F3; color: white; }"
        "QPushButton:hover { background-color: #1E88E5; }"
        "QPushButton:pressed { background-color: #1976D2; }"
    );
    deviceLayout->addWidget(m_refreshBtn);

    // 设备列表
    m_deviceList = new QListWidget(deviceGroup);
    m_deviceList->setMinimumHeight(80);
    deviceLayout->addWidget(m_deviceList);

    deviceNetworkLayout->addWidget(deviceGroup);

    // 网络配置组
    QGroupBox *networkGroup = new QGroupBox("网络配置", deviceNetworkTab);
    QVBoxLayout *networkLayout = new QVBoxLayout(networkGroup);

    // 控制端口输入
    QHBoxLayout *ctrlPortLayout = new QHBoxLayout();
    QLabel *ctrlPortLabel = new QLabel("控制端口:", networkGroup);
    m_ctrlPortSpinBox = new QSpinBox(networkGroup);
    m_ctrlPortSpinBox->setRange(1, 65535);
    m_ctrlPortSpinBox->setValue(6790);
    ctrlPortLayout->addWidget(ctrlPortLabel);
    ctrlPortLayout->addWidget(m_ctrlPortSpinBox);
    networkLayout->addLayout(ctrlPortLayout);

    // 数据端口输入
    QHBoxLayout *dataPortLayout = new QHBoxLayout();
    QLabel *dataPortLabel = new QLabel("数据端口:", networkGroup);
    m_dataPortSpinBox = new QSpinBox(networkGroup);
    m_dataPortSpinBox->setRange(1, 65535);
    m_dataPortSpinBox->setValue(3957);
    dataPortLayout->addWidget(dataPortLabel);
    dataPortLayout->addWidget(m_dataPortSpinBox);
    networkLayout->addLayout(dataPortLayout);

    // 连接按钮和状态指示
    QHBoxLayout *connectLayout = new QHBoxLayout();
    m_connectBtn = new QPushButton(QIcon(":/icons/icons/connect.png"), "连接", networkGroup);
    m_connectBtn->setMinimumHeight(45);
    m_connectBtn->setIconSize(QSize(22, 22));
    m_connectBtn->setStyleSheet(
        "QPushButton { background-color: #4CAF50; color: white; }"
        "QPushButton:hover { background-color: #45A049; }"
        "QPushButton:pressed { background-color: #388E3C; }"
    );
    m_statusLabel = new QLabel("● 未连接", networkGroup);
    m_statusLabel->setStyleSheet(
        "QLabel { "
        "    color: #F44336; "
        "    font-weight: bold; "
        "    font-size: 11pt; "
        "    padding: 8px; "
        "}"
    );
    connectLayout->addWidget(m_connectBtn);
    connectLayout->addWidget(m_statusLabel);
    networkLayout->addLayout(connectLayout);

    deviceNetworkLayout->addWidget(networkGroup);
    deviceNetworkLayout->addStretch();

    // 将第一个标签页添加到选项卡
    tabWidget->addTab(deviceNetworkTab, "设备与网络");

    // ========== 第二个标签页：曝光时间 + 拍照参数 ==========
    QWidget *exposureCaptureTab = new QWidget();
    QVBoxLayout *exposureCaptureLayout = new QVBoxLayout(exposureCaptureTab);
    exposureCaptureLayout->setContentsMargins(10, 10, 10, 10);

    // 曝光时间控制组
    QGroupBox *exposureGroup = new QGroupBox("曝光时间", exposureCaptureTab);
    QVBoxLayout *exposureGroupLayout = new QVBoxLayout(exposureGroup);

    QLabel *exposureLabel = new QLabel("曝光时间 (μs):", exposureGroup);
    exposureGroupLayout->addWidget(exposureLabel);

    QHBoxLayout *exposureLayout = new QHBoxLayout();
    m_exposureSlider = new QSlider(Qt::Horizontal, exposureGroup);
    m_exposureSlider->setRange(100, 100000);
    m_exposureSlider->setValue(1000);

    m_exposureSpinBox = new QSpinBox(exposureGroup);
    m_exposureSpinBox->setRange(100, 100000);
    m_exposureSpinBox->setValue(1000);
    m_exposureSpinBox->setMinimumWidth(80);

    exposureLayout->addWidget(m_exposureSlider, 3);
    exposureLayout->addWidget(m_exposureSpinBox, 1);
    exposureGroupLayout->addLayout(exposureLayout);

    exposureCaptureLayout->addWidget(exposureGroup);

    // 拍照参数组
    QGroupBox *captureGroup = new QGroupBox("拍照参数", exposureCaptureTab);
    QVBoxLayout *captureLayout = new QVBoxLayout(captureGroup);

    // 保存路径
    QLabel *savePathLabel = new QLabel("保存路径:", captureGroup);
    captureLayout->addWidget(savePathLabel);

    QHBoxLayout *pathLayout = new QHBoxLayout();
    m_savePathEdit = new QLineEdit(captureGroup);
    m_savePathEdit->setPlaceholderText("默认: 用户图片文件夹");
    m_browseSavePathBtn = new QPushButton(QIcon(":/icons/icons/folder.png"), "浏览...", captureGroup);
    m_browseSavePathBtn->setMaximumWidth(90);
    m_browseSavePathBtn->setMinimumHeight(32);
    m_browseSavePathBtn->setStyleSheet(
        "QPushButton { background-color: #607D8B; color: white; }"
        "QPushButton:hover { background-color: #546E7A; }"
        "QPushButton:pressed { background-color: #455A64; }"
    );
    pathLayout->addWidget(m_savePathEdit);
    pathLayout->addWidget(m_browseSavePathBtn);
    captureLayout->addLayout(pathLayout);

    // 深度图格式选择
    QLabel *depthFormatLabel = new QLabel("深度图格式:", captureGroup);
    captureLayout->addWidget(depthFormatLabel);
    m_depthFormatCombo = new QComboBox(captureGroup);
    m_depthFormatCombo->addItem("PNG (8位灰度)", "png");
    m_depthFormatCombo->addItem("TIFF (16位原始)", "tiff");
    m_depthFormatCombo->addItem("PNG + TIFF", "both");
    m_depthFormatCombo->setCurrentIndex(2);
    captureLayout->addWidget(m_depthFormatCombo);

    // 点云格式选择
    QLabel *pointCloudFormatLabel = new QLabel("点云格式:", captureGroup);
    captureLayout->addWidget(pointCloudFormatLabel);
    m_pointCloudFormatCombo = new QComboBox(captureGroup);
    m_pointCloudFormatCombo->addItem("PCD (PCL标准)", "pcd");
    m_pointCloudFormatCombo->addItem("PLY (Polygon)", "ply");
    m_pointCloudFormatCombo->addItem("PCD + PLY", "both");
    m_pointCloudFormatCombo->setCurrentIndex(2);
    captureLayout->addWidget(m_pointCloudFormatCombo);

    exposureCaptureLayout->addWidget(captureGroup);
    exposureCaptureLayout->addStretch();

    // 将第二个标签页添加到选项卡
    tabWidget->addTab(exposureCaptureTab, "曝光与拍照");

    // 将选项卡添加到控制面板（设置伸展因子为1，使其自适应扩展）
    controlLayout->addWidget(tabWidget, 1);

    // ========== 统计信息显示组 ==========
    QGroupBox *statsGroup = new QGroupBox("统计信息", m_controlPanel);
    QVBoxLayout *statsLayout = new QVBoxLayout(statsGroup);

    m_leftFpsLabel = new QLabel("左红外: 0.0 fps", statsGroup);
    m_rightFpsLabel = new QLabel("右红外: 0.0 fps", statsGroup);
    m_rgbFpsLabel = new QLabel("RGB: 0.0 fps", statsGroup);
    m_pointCloudFpsLabel = new QLabel("点云: 0.0 fps", statsGroup);
    m_resolutionLabel = new QLabel("1224x1024", statsGroup);
    m_queueLabel = new QLabel("帧数: 0", statsGroup);

    // 兼容旧代码
    m_depthFpsLabel = m_leftFpsLabel;

    QString statsStyle = "QLabel { font-size: 9pt; padding: 2px; }";
    m_leftFpsLabel->setStyleSheet(statsStyle);
    m_rightFpsLabel->setStyleSheet(statsStyle);
    m_rgbFpsLabel->setStyleSheet(statsStyle);
    m_pointCloudFpsLabel->setStyleSheet(statsStyle);
    m_resolutionLabel->setStyleSheet(statsStyle);
    m_queueLabel->setStyleSheet(statsStyle);

    statsLayout->addWidget(m_leftFpsLabel);
    statsLayout->addWidget(m_rightFpsLabel);
    statsLayout->addWidget(m_rgbFpsLabel);
    statsLayout->addWidget(m_pointCloudFpsLabel);
    statsLayout->addWidget(m_resolutionLabel);
    statsLayout->addWidget(m_queueLabel);

    controlLayout->addWidget(statsGroup);

    // ========== 创建右侧面板 ==========
    QWidget *rightPanel = new QWidget(contentWidget);
    QVBoxLayout *rightLayout = new QVBoxLayout(rightPanel);
    rightLayout->setContentsMargins(5, 5, 5, 5);
    rightLayout->setSpacing(5);

    // ========== 四块显示区域：2×2网格布局 ==========
    QWidget *displayWidget = new QWidget(rightPanel);
    QGridLayout *displayGrid = new QGridLayout(displayWidget);
    displayGrid->setSpacing(5);
    displayGrid->setContentsMargins(5, 5, 5, 5);

    // 设置行列拉伸因子
    displayGrid->setRowStretch(0, 1);
    displayGrid->setRowStretch(1, 1);
    displayGrid->setColumnStretch(0, 1);
    displayGrid->setColumnStretch(1, 1);

    // 左上：点云显示
    m_pointCloudWidget = new PointCloudWidget(displayWidget);
    m_pointCloudWidget->setMinimumSize(400, 300);
    m_pointCloudWidget->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
    displayGrid->addWidget(m_pointCloudWidget, 0, 0);

    // 右上：左红外图像
    m_leftImageDisplay = new QLabel(displayWidget);
    m_leftImageDisplay->setMinimumSize(400, 300);
    m_leftImageDisplay->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
    m_leftImageDisplay->setStyleSheet(
        "QLabel { "
        "    background-color: #263238; "
        "    color: #B0BEC5; "
        "    border: 2px solid #37474F; "
        "    border-radius: 4px; "
        "    font-size: 10pt; "
        "}"
    );
    m_leftImageDisplay->setAlignment(Qt::AlignCenter);
    m_leftImageDisplay->setText("左红外\n(等待数据...)");
    m_leftImageDisplay->setScaledContents(false);
    displayGrid->addWidget(m_leftImageDisplay, 0, 1);

    // 左下：RGB图像
    m_rgbImageDisplay = new QLabel(displayWidget);
    m_rgbImageDisplay->setMinimumSize(400, 300);
    m_rgbImageDisplay->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
    m_rgbImageDisplay->setStyleSheet(
        "QLabel { "
        "    background-color: #263238; "
        "    color: #B0BEC5; "
        "    border: 2px solid #37474F; "
        "    border-radius: 4px; "
        "    font-size: 10pt; "
        "}"
    );
    m_rgbImageDisplay->setAlignment(Qt::AlignCenter);
    m_rgbImageDisplay->setText("RGB彩色\n(等待数据...)");
    m_rgbImageDisplay->setScaledContents(false);
    displayGrid->addWidget(m_rgbImageDisplay, 1, 0);

    // 右下：右红外图像
    m_rightImageDisplay = new QLabel(displayWidget);
    m_rightImageDisplay->setMinimumSize(400, 300);
    m_rightImageDisplay->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
    m_rightImageDisplay->setStyleSheet(
        "QLabel { "
        "    background-color: #263238; "
        "    color: #B0BEC5; "
        "    border: 2px solid #37474F; "
        "    border-radius: 4px; "
        "    font-size: 10pt; "
        "}"
    );
    m_rightImageDisplay->setAlignment(Qt::AlignCenter);
    m_rightImageDisplay->setText("右红外\n(等待数据...)");
    m_rightImageDisplay->setScaledContents(false);
    displayGrid->addWidget(m_rightImageDisplay, 1, 1);

    // 兼容旧代码：m_imageDisplay指向左红外
    m_imageDisplay = m_leftImageDisplay;

    // 创建日志显示区域
    QWidget *logWidget = new QWidget(m_centralWidget);
    QVBoxLayout *logLayout = new QVBoxLayout(logWidget);
    logLayout->setContentsMargins(5, 5, 5, 5);
    logLayout->setSpacing(5);

    // 日志标题和按钮
    QHBoxLayout *logHeaderLayout = new QHBoxLayout();
    QLabel *logTitle = new QLabel("实时日志", logWidget);
    QFont titleFont = logTitle->font();
    titleFont.setBold(true);
    titleFont.setPointSize(11);
    logTitle->setFont(titleFont);
    logTitle->setStyleSheet("QLabel { padding: 4px; }");  // 移除硬编码颜色，使用系统调色板

    m_clearLogBtn = new QPushButton(QIcon(":/icons/icons/clear.png"), "清除日志", logWidget);
    m_clearLogBtn->setMaximumWidth(110);
    m_clearLogBtn->setMinimumHeight(32);
    m_clearLogBtn->setStyleSheet(
        "QPushButton { background-color: #757575; color: white; font-size: 9pt; }"
        "QPushButton:hover { background-color: #616161; }"
        "QPushButton:pressed { background-color: #424242; }"
    );

    m_saveLogBtn = new QPushButton(QIcon(":/icons/icons/save.png"), "保存日志", logWidget);
    m_saveLogBtn->setMaximumWidth(110);
    m_saveLogBtn->setMinimumHeight(32);
    m_saveLogBtn->setStyleSheet(
        "QPushButton { background-color: #4CAF50; color: white; font-size: 9pt; }"
        "QPushButton:hover { background-color: #45A049; }"
        "QPushButton:pressed { background-color: #388E3C; }"
    );

    logHeaderLayout->addWidget(logTitle);
    logHeaderLayout->addStretch();
    logHeaderLayout->addWidget(m_clearLogBtn);
    logHeaderLayout->addWidget(m_saveLogBtn);
    logLayout->addLayout(logHeaderLayout);

    // 日志文本显示
    m_logDisplay = new QTextEdit(logWidget);
    m_logDisplay->setReadOnly(true);
    m_logDisplay->setMinimumHeight(100);
    m_logDisplay->setStyleSheet("QTextEdit { background-color: #1E1E1E; color: #D4D4D4; font-family: Consolas, monospace; font-size: 9pt; }");
    logLayout->addWidget(m_logDisplay);

    // 将显示区和日志区添加到垂直分割器中
    QSplitter *contentSplitter = new QSplitter(Qt::Vertical, rightPanel);
    contentSplitter->addWidget(displayWidget);
    contentSplitter->addWidget(logWidget);
    contentSplitter->setStretchFactor(0, 3);  // 显示区占3份
    contentSplitter->setStretchFactor(1, 1);  // 日志区占1份

    rightLayout->addWidget(contentSplitter);

    // 将左侧控制面板和右侧面板添加到内容布局
    contentLayout->addWidget(m_controlPanel);
    contentLayout->addWidget(rightPanel);

    mainLayout->addWidget(contentWidget);
}

void MainWindow::setupConnections()
{
    // 相机控制按钮连接
    connect(m_startBtn, &QPushButton::clicked, this, &MainWindow::onStartClicked);
    connect(m_stopBtn, &QPushButton::clicked, this, &MainWindow::onStopClicked);
    connect(m_captureBtn, &QPushButton::clicked, this, &MainWindow::onCaptureClicked);
    connect(m_browseSavePathBtn, &QPushButton::clicked, this, &MainWindow::onBrowseSavePathClicked);

    // 曝光时间控制连接
    connect(m_exposureSlider, &QSlider::valueChanged, m_exposureSpinBox, &QSpinBox::setValue);
    connect(m_exposureSpinBox, QOverload<int>::of(&QSpinBox::valueChanged), m_exposureSlider, &QSlider::setValue);
    connect(m_exposureSlider, &QSlider::valueChanged, this, &MainWindow::onExposureChanged);

    // 网络配置连接
    connect(m_connectBtn, &QPushButton::clicked, this, &MainWindow::onConnectClicked);
    connect(m_ctrlPortSpinBox, QOverload<int>::of(&QSpinBox::valueChanged), this, &MainWindow::onControlPortChanged);
    connect(m_dataPortSpinBox, QOverload<int>::of(&QSpinBox::valueChanged), this, &MainWindow::onDataPortChanged);

    // 网络状态信号连接
    connect(m_networkManager.get(), &NetworkManager::connected, this, &MainWindow::onNetworkConnected);
    connect(m_networkManager.get(), &NetworkManager::disconnected, this, &MainWindow::onNetworkDisconnected);
    connect(m_networkManager.get(), &NetworkManager::dataReceived, this, &MainWindow::onDataReceived);

    // GVSP数据信号连接（从NetworkManager）
    connect(m_networkManager.get(), &NetworkManager::imageReceived, this, &MainWindow::onImageReceived);
    connect(m_networkManager.get(), &NetworkManager::leftImageReceived, this, &MainWindow::onLeftImageReceived);
    connect(m_networkManager.get(), &NetworkManager::rightImageReceived, this, &MainWindow::onRightImageReceived);
    connect(m_networkManager.get(), &NetworkManager::rgbImageReceived, this, &MainWindow::onRgbImageReceived);
    connect(m_networkManager.get(), &NetworkManager::depthDataReceived, this, &MainWindow::onDepthDataReceived);
    connect(m_networkManager.get(), &NetworkManager::pointCloudDataReceived, this, &MainWindow::onPointCloudDataReceived);

    // 点云处理信号连接
    connect(m_pointCloudProcessor.get(), &PointCloudProcessor::pointCloudReady, this, &MainWindow::onPointCloudReady);

    // 刷新按钮连接
    connect(m_refreshBtn, &QPushButton::clicked, this, &MainWindow::onRefreshClicked);

    // 设备扫描信号连接
    connect(m_deviceScanner.get(), &DeviceScanner::deviceFound, this, &MainWindow::onDeviceFound);
    connect(m_deviceScanner.get(), &DeviceScanner::scanProgress, this, &MainWindow::onScanProgress);
    connect(m_deviceScanner.get(), &DeviceScanner::scanFinished, this, &MainWindow::onScanFinished);

    // 设备列表选择连接
    connect(m_deviceList, &QListWidget::itemClicked, this, &MainWindow::onDeviceSelected);

    // 日志按钮连接
    connect(m_clearLogBtn, &QPushButton::clicked, this, &MainWindow::onClearLogClicked);
    connect(m_saveLogBtn, &QPushButton::clicked, this, &MainWindow::onSaveLogClicked);

    // 传输开关按钮连接
    connect(m_leftIRToggle, &QPushButton::toggled, this, [this](bool checked) {
        if(checked) {
            m_leftIREnabled.storeRelaxed(1);  // 标记启用
            m_networkManager->sendEnableLeftIR();
            qDebug() << "启用左红外传输";
        } else {
            m_leftIREnabled.storeRelaxed(0);  // 标记禁用
            m_networkManager->sendDisableLeftIR();
            qDebug() << "禁用左红外传输";
            // 清除显示区域，恢复默认等待界面
            if(m_leftImageDisplay) {
                m_leftImageDisplay->setPixmap(QPixmap());
                m_leftImageDisplay->setText("左红外\n(等待数据...)");
            }
        }
    });

    connect(m_rightIRToggle, &QPushButton::toggled, this, [this](bool checked) {
        if(checked) {
            m_rightIREnabled.storeRelaxed(1);  // 标记启用
            m_networkManager->sendEnableRightIR();
            qDebug() << "启用右红外传输";
        } else {
            m_rightIREnabled.storeRelaxed(0);  // 标记禁用
            m_networkManager->sendDisableRightIR();
            qDebug() << "禁用右红外传输";
            // 清除显示区域，恢复默认等待界面
            if(m_rightImageDisplay) {
                m_rightImageDisplay->setPixmap(QPixmap());
                m_rightImageDisplay->setText("右红外\n(等待数据...)");
            }
        }
    });

    connect(m_rgbToggle, &QPushButton::toggled, this, [this](bool checked) {
        if(checked) {
            m_rgbEnabled.storeRelaxed(1);  // 标记启用
            m_networkManager->sendEnableRGB();
            qDebug() << "启用RGB传输";
        } else {
            m_rgbEnabled.storeRelaxed(0);  // 标记禁用
            m_networkManager->sendDisableRGB();
            qDebug() << "禁用RGB传输";
            // 清除显示区域，恢复默认等待界面
            if(m_rgbImageDisplay) {
                m_rgbImageDisplay->setPixmap(QPixmap());
                m_rgbImageDisplay->setText("RGB彩色\n(等待数据...)");
            }
        }
    });

    // 点云颜色开关连接
    connect(m_pointCloudColorToggle, &QPushButton::toggled, this, [this](bool checked) {
        if(m_pointCloudWidget) {
            m_pointCloudWidget->setColorMode(checked);
            qDebug() << "点云着色:" << (checked ? "开启" : "关闭");
        }
    });

    // 单目/双目模式切换按钮连接
    connect(m_monocularBtn, &QPushButton::clicked, this, [this]() {
        m_monocularBtn->setChecked(true);
        m_binocularBtn->setChecked(false);
        m_networkManager->sendMonocularMode();
        qDebug() << "切换为单目模式";
    });

    connect(m_binocularBtn, &QPushButton::clicked, this, [this]() {
        m_monocularBtn->setChecked(false);
        m_binocularBtn->setChecked(true);
        m_networkManager->sendBinocularMode();
        qDebug() << "切换为双目模式";
    });
}

void MainWindow::loadSettings()
{
    // 加载曝光时间
    int exposure = m_configManager->getExposureTime();
    m_exposureSlider->setValue(exposure);
    m_exposureSpinBox->setValue(exposure);

    // 加载保存路径
    QString savePath = m_configManager->getSavePath();
    m_savePathEdit->setText(savePath);

    // 加载深度图格式
    QString depthFormat = m_configManager->getDepthFormat();
    int depthIndex = m_depthFormatCombo->findData(depthFormat);
    if(depthIndex >= 0) {
        m_depthFormatCombo->setCurrentIndex(depthIndex);
    }

    // 加载点云格式
    QString pointCloudFormat = m_configManager->getPointCloudFormat();
    int pcIndex = m_pointCloudFormatCombo->findData(pointCloudFormat);
    if(pcIndex >= 0) {
        m_pointCloudFormatCombo->setCurrentIndex(pcIndex);
    }
}

void MainWindow::saveSettings()
{
    // 保存曝光时间
    m_configManager->setExposureTime(m_exposureSlider->value());

    // 保存保存路径
    m_configManager->setSavePath(m_savePathEdit->text());

    // 保存深度图格式
    m_configManager->setDepthFormat(m_depthFormatCombo->currentData().toString());

    // 保存点云格式
    m_configManager->setPointCloudFormat(m_pointCloudFormatCombo->currentData().toString());
}

// ========== 槽函数实现 ==========
void MainWindow::onStartClicked()
{
    qDebug() << "启动按钮点击";
    m_networkManager->sendStartCommand();
    addLog("发送启动命令", "INFO");
}

void MainWindow::onStopClicked()
{
    qDebug() << "停止按钮点击";
    m_networkManager->sendStopCommand();
    addLog("发送停止命令", "INFO");
}

void MainWindow::onExposureChanged(int value)
{
    qDebug() << "曝光值改变为:" << value;
    m_networkManager->sendExposureCommand(value);
    addLog(QString("设置曝光时间: %1 μs").arg(value), "INFO");
}

void MainWindow::onConnectClicked()
{
    if(m_isConnected) {
        m_networkManager->disconnectFromCamera();
        m_isConnected = false;
        qDebug() << "断开相机连接";
    } else {
        QString ip = m_configManager->getIpAddress();
        int ctrlPort = m_configManager->getControlPort();
        int dataPort = m_configManager->getDataPort();

        if(m_networkManager->connectToCamera(ip, ctrlPort, dataPort)) {
            m_isConnected = true;
            qDebug() << "连接到相机";
        }
    }
}

void MainWindow::onIpAddressChanged(const QString &ip)
{
    qDebug() << "IP地址改变为:" << ip;
    m_configManager->setIpAddress(ip);
}

void MainWindow::onControlPortChanged(int port)
{
    qDebug() << "控制端口改变为:" << port;
    m_configManager->setControlPort(port);
}

void MainWindow::onDataPortChanged(int port)
{
    qDebug() << "数据端口改变为:" << port;
    m_configManager->setDataPort(port);
}

void MainWindow::onNetworkConnected()
{
    qDebug() << "网络已连接 - 更新UI";
    m_isConnected = true;
    m_connectBtn->setText("断开");
    m_connectBtn->setStyleSheet(
        "QPushButton { background-color: #F44336; color: white; }"
        "QPushButton:hover { background-color: #E53935; }"
        "QPushButton:pressed { background-color: #C62828; }"
    );
    m_statusLabel->setText("● 已连接");
    m_statusLabel->setStyleSheet(
        "QLabel { "
        "    color: #4CAF50; "
        "    font-weight: bold; "
        "    font-size: 11pt; "
        "    padding: 8px; "
        "}"
    );

    QString ip = m_configManager->getIpAddress();
    addLog(QString("已连接到相机: %1").arg(ip), "SUCCESS");

    // 同步当前按钮状态到下位机
    if(m_leftIRToggle->isChecked()) {
        m_networkManager->sendEnableLeftIR();
    } else {
        m_networkManager->sendDisableLeftIR();
    }

    if(m_rightIRToggle->isChecked()) {
        m_networkManager->sendEnableRightIR();
    } else {
        m_networkManager->sendDisableRightIR();
    }

    if(m_rgbToggle->isChecked()) {
        m_networkManager->sendEnableRGB();
    } else {
        m_networkManager->sendDisableRGB();
    }

    addLog("已同步相机开关状态", "INFO");
}

void MainWindow::onNetworkDisconnected()
{
    qDebug() << "网络已断开 - 更新UI";
    m_isConnected = false;
    m_connectBtn->setText("连接");
    m_connectBtn->setStyleSheet(
        "QPushButton { background-color: #4CAF50; color: white; }"
        "QPushButton:hover { background-color: #45A049; }"
        "QPushButton:pressed { background-color: #388E3C; }"
    );
    m_statusLabel->setText("● 未连接");
    m_statusLabel->setStyleSheet(
        "QLabel { "
        "    color: #F44336; "
        "    font-weight: bold; "
        "    font-size: 11pt; "
        "    padding: 8px; "
        "}"
    );

    addLog("相机连接已断开", "WARNING");
}

void MainWindow::updateUI()
{
    // 定时器更新UI
}

// ========== 设备扫描槽函数 ==========
void MainWindow::onRefreshClicked()
{
    qDebug() << "刷新设备按钮点击";
    m_deviceList->clear();
    
    if(m_deviceScanner->isScanning()) {
        m_deviceScanner->stopScan();
        m_refreshBtn->setText("刷新设备");
    } else {
        m_deviceScanner->startScan();
        m_refreshBtn->setText("停止扫描");
    }
}

void MainWindow::onDeviceFound(const DeviceInfo &device)
{
    qDebug() << "发现设备:" << device.ipAddress;
    
    // 添加到列表
    QString itemText = QString("%1 - %2").arg(device.ipAddress).arg(device.deviceName);
    QListWidgetItem *item = new QListWidgetItem(itemText);
    item->setData(Qt::UserRole, device.ipAddress);
    m_deviceList->addItem(item);
}

void MainWindow::onScanProgress(int current, int total)
{
    qDebug() << "扫描进度:" << current << "/" << total;
}

void MainWindow::onScanFinished(int devicesFound)
{
    qDebug() << "扫描完成。发现" << devicesFound << "个设备";
    m_refreshBtn->setText("刷新设备");
}

void MainWindow::onDeviceSelected(QListWidgetItem *item)
{
    QString ip = item->data(Qt::UserRole).toString();
    qDebug() << "选择设备:" << ip;
    
    // 更新配置管理器中的IP地址
    m_configManager->setIpAddress(ip);
}

// ========== 数据接收槽函数 ==========
void MainWindow::onDataReceived(const QByteArray &data)
{
    // NetworkManager已经自动将数据传递给GVSP解析器
    // 这里只用于调试统计
    Q_UNUSED(data);
}

// ========== GVSP数据处理槽函数 ==========
void MainWindow::onImageReceived(const QImage &image, uint32_t blockId)
{
    // 保存当前图像用于拍照
    m_currentImage = image;
    m_currentFrameId = blockId;

    // 计算深度图FPS和累计帧数
    m_depthFrameCount++;
    m_totalDepthFrameCount++;
    QDateTime currentTime = QDateTime::currentDateTime();
    if(m_lastDepthFrameTime.isValid()) {
        qint64 elapsed = m_lastDepthFrameTime.msecsTo(currentTime);
        if(elapsed >= 1000) {  // 每秒更新一次FPS
            m_currentDepthFps = (m_depthFrameCount * 1000.0) / elapsed;
            m_depthFrameCount = 0;
            m_lastDepthFrameTime = currentTime;
            updateStatistics();
        }
    } else {
        m_lastDepthFrameTime = currentTime;
    }

    // 将图像显示在UI上（使用快速缩放）
    if(m_imageDisplay) {
        QPixmap pixmap = QPixmap::fromImage(image);
        m_imageDisplay->setPixmap(pixmap.scaled(m_imageDisplay->size(), Qt::KeepAspectRatio, Qt::FastTransformation));
    }
}

void MainWindow::onLeftImageReceived(const QByteArray &jpegData, uint32_t blockId)
{
    // 检查左红外是否启用，如果禁用则忽略数据（防止关闭后闪烁）
    if(m_leftIREnabled.loadAcquire() == 0) {
        return;
    }

    // 保存原始数据（用于拍照保存完整分辨率）
    m_currentLeftIRData = jpegData;

    // 计算左红外FPS
    m_leftFrameCount++;
    m_totalLeftFrameCount++;
    QDateTime currentTime = QDateTime::currentDateTime();
    if(m_lastLeftFrameTime.isValid()) {
        qint64 elapsed = m_lastLeftFrameTime.msecsTo(currentTime);
        if(elapsed >= 1000) {
            m_currentLeftFps = (m_leftFrameCount * 1000.0) / elapsed;
            m_leftFrameCount = 0;
            m_lastLeftFrameTime = currentTime;
            updateStatistics();
        }
    } else {
        m_lastLeftFrameTime = currentTime;
    }

    // 使用后台线程处理红外数据，避免阻塞UI
    if(m_leftImageDisplay && jpegData.size() > 0) {
        // 检查数据大小：8位下采样(612x512)或16位原始(1224x1024)
        size_t size8bit = 612 * 512;
        size_t size16bit = 1224 * 1024 * sizeof(uint16_t);

        if(jpegData.size() == size8bit) {
            // 8位下采样格式：直接显示
            QByteArray dataCopy = jpegData;
            QtConcurrent::run([this, dataCopy]() {
                try {
                    QImage image(reinterpret_cast<const uchar*>(dataCopy.constData()),
                                612, 512, 612, QImage::Format_Grayscale8);
                    QImage imageCopy = image.copy();

                    QMetaObject::invokeMethod(this, [this, imageCopy]() {
                        if(m_leftImageDisplay) {
                            QPixmap pixmap = QPixmap::fromImage(imageCopy);
                            m_leftImageDisplay->setPixmap(pixmap.scaled(
                                m_leftImageDisplay->size(), Qt::KeepAspectRatio, Qt::FastTransformation));
                        }
                    }, Qt::QueuedConnection);
                } catch (const std::exception &e) {
                    qDebug() << "[MainWindow] ERROR: Left IR 8bit processing exception:" << e.what();
                }
            });
        } else if(jpegData.size() == size16bit) {
            // 16位原始格式：需要归一化处理
            QByteArray dataCopy = jpegData;

            // 在后台线程处理
            QtConcurrent::run([this, dataCopy]() {
                try {
                    const uint16_t* src = reinterpret_cast<const uint16_t*>(dataCopy.constData());

                    // 方案2：快速百分位数估算（无需排序，采样估算）
                    // 优点：适应不同环境，画面对比度好，速度快10倍以上
                    uint16_t minVal = 65535, maxVal = 0;

                    // 第一遍：快速扫描找到粗略范围（每隔8个像素采样）
                    for (int i = 0; i < 1224 * 1024; i += 8) {
                        uint16_t val = src[i];
                        if(val > 0) {
                            if(val < minVal) minVal = val;
                            if(val > maxVal) maxVal = val;
                        }
                    }

                    // 第二遍：使用直方图统计精确百分位数（避免排序）
                    if(maxVal > minVal) {
                        const int histSize = 256;
                        int histogram[histSize] = {0};
                        float binWidth = (maxVal - minVal) / (float)histSize;

                        // 构建直方图
                        for (int i = 0; i < 1224 * 1024; i++) {
                            if(src[i] > 0) {
                                int bin = (src[i] - minVal) / binWidth;
                                if(bin >= histSize) bin = histSize - 1;
                                histogram[bin]++;
                            }
                        }

                        // 计算1%和99%百分位数
                        int totalPixels = 0;
                        for (int i = 0; i < histSize; i++) totalPixels += histogram[i];

                        int thresh_1 = totalPixels * 0.01;
                        int thresh_99 = totalPixels * 0.99;

                        int cumsum = 0;
                        for (int i = 0; i < histSize; i++) {
                            cumsum += histogram[i];
                            if(cumsum >= thresh_1 && minVal == 65535) {
                                minVal = minVal + i * binWidth;
                            }
                            if(cumsum >= thresh_99) {
                                maxVal = minVal + i * binWidth;
                                break;
                            }
                        }
                    }

                    // 创建8位图像并归一化
                    QImage image(1224, 1024, QImage::Format_Grayscale8);
                    uint8_t* dst = image.bits();
                    float scale = (maxVal > minVal) ? (255.0f / (maxVal - minVal)) : 0.0f;

                    for (int i = 0; i < 1224 * 1024; i++) {
                        if(src[i] == 0) {
                            dst[i] = 0;
                        } else if(src[i] <= minVal) {
                            dst[i] = 0;
                        } else if(src[i] >= maxVal) {
                            dst[i] = 255;
                        } else {
                            dst[i] = static_cast<uint8_t>((src[i] - minVal) * scale);
                        }
                    }

                    QImage imageCopy = image.copy();

                    // 在主线程更新UI
                    QMetaObject::invokeMethod(this, [this, imageCopy]() {
                        if(m_leftImageDisplay) {
                            QPixmap pixmap = QPixmap::fromImage(imageCopy);
                            m_leftImageDisplay->setPixmap(pixmap.scaled(
                                m_leftImageDisplay->size(), Qt::KeepAspectRatio, Qt::FastTransformation));
                        }
                    }, Qt::QueuedConnection);
                } catch (const std::exception &e) {
                    qDebug() << "[MainWindow] ERROR: Left IR processing exception:" << e.what();
                }
            });
        } else {
            qDebug() << "[MainWindow] ERROR: Left IR data size mismatch:" << jpegData.size()
                     << "(expected 8bit:" << size8bit << "or 16bit:" << size16bit << ")";
        }
    }
}

void MainWindow::onRightImageReceived(const QByteArray &jpegData, uint32_t blockId)
{
    // 检查右红外是否启用，如果禁用则忽略数据（防止关闭后闪烁）
    if(m_rightIREnabled.loadAcquire() == 0) {
        return;
    }

    // 保存原始数据（用于拍照保存完整分辨率）
    m_currentRightIRData = jpegData;

    // 计算右红外FPS
    m_rightFrameCount++;
    m_totalRightFrameCount++;
    QDateTime currentTime = QDateTime::currentDateTime();
    if(m_lastRightFrameTime.isValid()) {
        qint64 elapsed = m_lastRightFrameTime.msecsTo(currentTime);
        if(elapsed >= 1000) {
            m_currentRightFps = (m_rightFrameCount * 1000.0) / elapsed;
            m_rightFrameCount = 0;
            m_lastRightFrameTime = currentTime;
            updateStatistics();
        }
    } else {
        m_lastRightFrameTime = currentTime;
    }

    // 使用后台线程处理红外数据，避免阻塞UI
    if(m_rightImageDisplay && jpegData.size() > 0) {
        // 检查数据大小：8位下采样(612x512)或16位原始(1224x1024)
        size_t size8bit = 612 * 512;
        size_t size16bit = 1224 * 1024 * sizeof(uint16_t);

        if(jpegData.size() == size8bit) {
            // 8位下采样格式：直接显示
            QByteArray dataCopy = jpegData;
            QtConcurrent::run([this, dataCopy]() {
                try {
                    QImage image(reinterpret_cast<const uchar*>(dataCopy.constData()),
                                612, 512, 612, QImage::Format_Grayscale8);
                    QImage imageCopy = image.copy();

                    QMetaObject::invokeMethod(this, [this, imageCopy]() {
                        if(m_rightImageDisplay) {
                            QPixmap pixmap = QPixmap::fromImage(imageCopy);
                            m_rightImageDisplay->setPixmap(pixmap.scaled(
                                m_rightImageDisplay->size(), Qt::KeepAspectRatio, Qt::FastTransformation));
                        }
                    }, Qt::QueuedConnection);
                } catch (const std::exception &e) {
                    qDebug() << "[MainWindow] ERROR: Right IR 8bit processing exception:" << e.what();
                }
            });
        } else if(jpegData.size() == size16bit) {
            // 16位原始格式：需要归一化处理
            QByteArray dataCopy = jpegData;

            // 在后台线程处理
            QtConcurrent::run([this, dataCopy]() {
                try {
                    const uint16_t* src = reinterpret_cast<const uint16_t*>(dataCopy.constData());

                    // 方案2：快速百分位数估算（无需排序，采样估算）
                    // 优点：适应不同环境，画面对比度好，速度快10倍以上
                    uint16_t minVal = 65535, maxVal = 0;

                    // 第一遍：快速扫描找到粗略范围（每隔8个像素采样）
                    for (int i = 0; i < 1224 * 1024; i += 8) {
                        uint16_t val = src[i];
                        if(val > 0) {
                            if(val < minVal) minVal = val;
                            if(val > maxVal) maxVal = val;
                        }
                    }

                    // 第二遍：使用直方图统计精确百分位数（避免排序）
                    if(maxVal > minVal) {
                        const int histSize = 256;
                        int histogram[histSize] = {0};
                        float binWidth = (maxVal - minVal) / (float)histSize;

                        // 构建直方图
                        for (int i = 0; i < 1224 * 1024; i++) {
                            if(src[i] > 0) {
                                int bin = (src[i] - minVal) / binWidth;
                                if(bin >= histSize) bin = histSize - 1;
                                histogram[bin]++;
                            }
                        }

                        // 计算1%和99%百分位数
                        int totalPixels = 0;
                        for (int i = 0; i < histSize; i++) totalPixels += histogram[i];

                        int thresh_1 = totalPixels * 0.01;
                        int thresh_99 = totalPixels * 0.99;

                        int cumsum = 0;
                        for (int i = 0; i < histSize; i++) {
                            cumsum += histogram[i];
                            if(cumsum >= thresh_1 && minVal == 65535) {
                                minVal = minVal + i * binWidth;
                            }
                            if(cumsum >= thresh_99) {
                                maxVal = minVal + i * binWidth;
                                break;
                            }
                        }
                    }

                    // 创建8位图像并归一化
                    QImage image(1224, 1024, QImage::Format_Grayscale8);
                    uint8_t* dst = image.bits();
                    float scale = (maxVal > minVal) ? (255.0f / (maxVal - minVal)) : 0.0f;

                    for (int i = 0; i < 1224 * 1024; i++) {
                        if(src[i] == 0) {
                            dst[i] = 0;
                        } else if(src[i] <= minVal) {
                            dst[i] = 0;
                        } else if(src[i] >= maxVal) {
                            dst[i] = 255;
                        } else {
                            dst[i] = static_cast<uint8_t>((src[i] - minVal) * scale);
                        }
                    }

                    QImage imageCopy = image.copy();

                    // 在主线程更新UI
                    QMetaObject::invokeMethod(this, [this, imageCopy]() {
                        if(m_rightImageDisplay) {
                            QPixmap pixmap = QPixmap::fromImage(imageCopy);
                            m_rightImageDisplay->setPixmap(pixmap.scaled(
                                m_rightImageDisplay->size(), Qt::KeepAspectRatio, Qt::FastTransformation));
                        }
                    }, Qt::QueuedConnection);
                } catch (const std::exception &e) {
                    qDebug() << "[MainWindow] ERROR: Right IR processing exception:" << e.what();
                }
            });
        } else {
            qDebug() << "[MainWindow] ERROR: Right IR data size mismatch:" << jpegData.size()
                     << "(expected 8bit:" << size8bit << "or 16bit:" << size16bit << ")";
        }
    }
}

void MainWindow::onRgbImageReceived(const QByteArray &jpegData, uint32_t blockId)
{
    // 检查RGB是否启用，如果禁用则忽略数据（防止关闭后闪烁）
    if(m_rgbEnabled.loadAcquire() == 0) {
        return;
    }

    // 记录接收时间
    static QDateTime lastLogTime = QDateTime::currentDateTime();
    QDateTime receiveTime = QDateTime::currentDateTime();

    // 保存原始JPEG数据（用于拍照保存完整分辨率）
    m_currentRgbData = jpegData;

    // 计算RGB FPS
    m_rgbFrameCount++;
    m_totalRgbFrameCount++;
    QDateTime currentTime = QDateTime::currentDateTime();
    if(m_lastRgbFrameTime.isValid()) {
        qint64 elapsed = m_lastRgbFrameTime.msecsTo(currentTime);
        if(elapsed >= 1000) {
            m_currentRgbFps = (m_rgbFrameCount * 1000.0) / elapsed;
            m_rgbFrameCount = 0;
            m_lastRgbFrameTime = currentTime;
            updateStatistics();
        }
    } else {
        m_lastRgbFrameTime = currentTime;
    }

    // 移除频繁的日志输出

    // 使用后台线程解码MJPEG，避免阻塞UI
    if(m_rgbImageDisplay && jpegData.size() > 0) {
        // 智能帧丢弃：如果上一帧还在处理，跳过当前帧（避免积压旧帧）
        if(m_rgbProcessing.loadAcquire() > 0) {
            return;  // 跳过当前帧，优先处理最新帧
        }

        // 标记开始处理
        m_rgbProcessing.ref();

        // 复制数据到局部变量
        QByteArray dataCopy = jpegData;

        // 在后台线程解码
        QtConcurrent::run([this, dataCopy]() {
            try {
                // 使用OpenCV解码
                std::vector<uchar> buffer(dataCopy.begin(), dataCopy.end());
                cv::Mat cvImage = cv::imdecode(buffer, cv::IMREAD_COLOR);

                if(!cvImage.empty()) {
                    // 缩放到1/2大小
                    cv::Mat resized;
                    cv::resize(cvImage, resized, cv::Size(), 0.5, 0.5, cv::INTER_LINEAR);

                    // 转换BGR到RGB
                    cv::cvtColor(resized, resized, cv::COLOR_BGR2RGB);

                    // 转换cv::Mat到QImage
                    QImage tempImage(resized.data, resized.cols, resized.rows,
                                    resized.step, QImage::Format_RGB888);
                    QImage image = tempImage.copy();

                    // 在后台线程完成缩放，避免主线程阻塞
                    int displayWidth = m_rgbImageDisplay->width();
                    int displayHeight = m_rgbImageDisplay->height();

                    // 计算保持宽高比的缩放尺寸
                    QSize scaledSize = image.size().scaled(displayWidth, displayHeight, Qt::KeepAspectRatio);
                    QImage scaledImage = image.scaled(scaledSize, Qt::KeepAspectRatio, Qt::FastTransformation);
                    QPixmap pixmap = QPixmap::fromImage(scaledImage);

                    // 使用DirectConnection直接在主线程更新UI（更快，避免队列积压）
                    QMetaObject::invokeMethod(this, [this, pixmap]() {
                        if(m_rgbImageDisplay) {
                            m_rgbImageDisplay->setPixmap(pixmap);
                        }
                    }, Qt::QueuedConnection);
                }
            } catch (const std::exception &e) {
                qDebug() << "[MainWindow] ERROR: RGB decode exception:" << e.what();
            }

            // 处理完成，减少标志
            m_rgbProcessing.deref();
        });
    }
}

void MainWindow::onDepthDataReceived(const QByteArray &depthData, uint32_t blockId)
{
    // 实时处理每一帧
    // 注释掉频繁的日志输出
    // qDebug() << "Depth data received: Block" << blockId << "Size:" << depthData.size() << "bytes";

    // 调用PointCloudProcessor进行OpenCL计算
    m_pointCloudProcessor->processDepthData(depthData, blockId);
}

void MainWindow::onPointCloudDataReceived(const QByteArray &cloudData, uint32_t blockId)
{
    // qDebug() << "[MainWindow] Point cloud data received: Block" << blockId << "Size:" << cloudData.size() << "bytes";

    // 使用QtConcurrent在后台线程处理点云数据
    QtConcurrent::run([this, cloudData, blockId]() {
        m_pointCloudProcessor->processPointCloudData(cloudData, blockId);
    });
}

void MainWindow::onPointCloudReady(pcl::PointCloud<pcl::PointXYZ>::Ptr cloud, uint32_t blockId)
{
    // 注释掉频繁的日志输出
    // qDebug() << "Point cloud ready: Block" << blockId << "Points:" << cloud->size();

    // 保存当前点云用于拍照
    m_currentPointCloud = cloud;

    // 计算点云FPS和累计帧数
    m_pointCloudFrameCount++;
    m_totalPointCloudFrameCount++;
    QDateTime currentTime = QDateTime::currentDateTime();
    if(m_lastPointCloudFrameTime.isValid()) {
        qint64 elapsed = m_lastPointCloudFrameTime.msecsTo(currentTime);
        if(elapsed >= 1000) {  // 每秒更新一次FPS
            m_currentPointCloudFps = (m_pointCloudFrameCount * 1000.0) / elapsed;
            m_pointCloudFrameCount = 0;
            m_lastPointCloudFrameTime = currentTime;
            updateStatistics();
        }
    } else {
        m_lastPointCloudFrameTime = currentTime;
    }

    // 更新点云显示
    if(m_pointCloudWidget) {
        m_pointCloudWidget->updatePointCloud(cloud);
    }
}

// ========== 拍照功能 ==========
void MainWindow::onCaptureClicked()
{
    qDebug() << "拍照按钮点击";

    // 检查是否有可用数据
    if(m_currentImage.isNull() && (!m_currentPointCloud || m_currentPointCloud->empty())) {
        QMessageBox::warning(this, "拍照失败", "没有可用的图像或点云数据。\n请先启动相机采集。");
        addLog("拍照失败：没有可用数据", "ERROR");
        return;
    }

    // 获取保存路径
    QString saveDir = m_savePathEdit->text().trimmed();
    if(saveDir.isEmpty()) {
        // 使用默认路径：用户图片文件夹
        saveDir = QStandardPaths::writableLocation(QStandardPaths::PicturesLocation);
        qDebug() << "使用默认保存路径:" << saveDir;
    }

    // 检查目录是否存在，不存在则创建
    QDir dir(saveDir);
    if(!dir.exists()) {
        if(!dir.mkpath(".")) {
            QMessageBox::warning(this, "拍照失败", QString("无法创建保存目录:\n%1").arg(saveDir));
            return;
        }
    }

    // 生成时间戳文件名
    QString timestamp = QDateTime::currentDateTime().toString("yyyyMMdd_HHmmss");
    QString frameId = QString::number(m_currentFrameId);
    QString baseName = QString("capture_%1_frame%2").arg(timestamp).arg(frameId);

    // 获取格式选择
    QString depthFormat = m_depthFormatCombo->currentData().toString();
    QString pointCloudFormat = m_pointCloudFormatCombo->currentData().toString();

    // 复制当前数据（避免在后台线程中访问成员变量）
    QImage imageCopy = m_currentImage.copy();
    pcl::PointCloud<pcl::PointXYZ>::Ptr cloudCopy(new pcl::PointCloud<pcl::PointXYZ>(*m_currentPointCloud));

    // 复制三个相机的原始JPEG数据
    QByteArray leftIRCopy = m_currentLeftIRData;
    QByteArray rightIRCopy = m_currentRightIRData;
    QByteArray rgbCopy = m_currentRgbData;

    qDebug() << "开始后台保存...";
    addLog(QString("开始保存: %1").arg(baseName), "INFO");

    // 在后台线程中执行保存操作
    QtConcurrent::run([this, saveDir, baseName, depthFormat, pointCloudFormat,
                       imageCopy, cloudCopy, leftIRCopy, rightIRCopy, rgbCopy]() {
        this->performBackgroundSave(saveDir, baseName, depthFormat, pointCloudFormat,
                                   imageCopy, cloudCopy, leftIRCopy, rightIRCopy, rgbCopy);
    });
}

void MainWindow::onBrowseSavePathClicked()
{
    QString dir = QFileDialog::getExistingDirectory(this, "选择保存目录",
                                                     m_savePathEdit->text().isEmpty()
                                                     ? QStandardPaths::writableLocation(QStandardPaths::PicturesLocation)
                                                     : m_savePathEdit->text(),
                                                     QFileDialog::ShowDirsOnly);
    if(!dir.isEmpty()) {
        m_savePathEdit->setText(dir);
        qDebug() << "设置保存路径:" << dir;
    }
}

void MainWindow::performBackgroundSave(const QString &saveDir, const QString &baseName,
                                       const QString &depthFormat, const QString &pointCloudFormat,
                                       const QImage &image, pcl::PointCloud<pcl::PointXYZ>::Ptr cloud,
                                       const QByteArray &leftIRData, const QByteArray &rightIRData,
                                       const QByteArray &rgbData)
{
    qDebug() << "后台保存线程开始...";

    bool depthSuccess = false;
    bool cloudSuccess = false;

    // 保存深度图
    if(!image.isNull()) {
        try {
            // 转换QImage到OpenCV Mat
            cv::Mat mat;
            if(image.format() == QImage::Format_Grayscale8) {
                mat = cv::Mat(image.height(), image.width(), CV_8UC1,
                             const_cast<uchar*>(image.bits()), image.bytesPerLine()).clone();
            } else if(image.format() == QImage::Format_Grayscale16) {
                mat = cv::Mat(image.height(), image.width(), CV_16UC1,
                             const_cast<uchar*>(image.bits()), image.bytesPerLine()).clone();
            } else {
                // 转换为灰度图
                QImage grayImage = image.convertToFormat(QImage::Format_Grayscale8);
                mat = cv::Mat(grayImage.height(), grayImage.width(), CV_8UC1,
                             const_cast<uchar*>(grayImage.bits()), grayImage.bytesPerLine()).clone();
            }

            // 根据format参数保存
            if(depthFormat == "png" || depthFormat == "both") {
                QString pngPath = QString("%1/%2_depth.png").arg(saveDir).arg(baseName);
                cv::Mat mat8bit;
                if(mat.type() == CV_16UC1) {
                    mat.convertTo(mat8bit, CV_8UC1, 255.0 / 65535.0);
                } else {
                    mat8bit = mat;
                }
                cv::imwrite(pngPath.toStdString(), mat8bit);
                qDebug() << "保存PNG深度图:" << pngPath;
                depthSuccess = true;
            }

            if(depthFormat == "tiff" || depthFormat == "both") {
                QString tiffPath = QString("%1/%2_depth.tiff").arg(saveDir).arg(baseName);
                if(mat.type() == CV_16UC1) {
                    cv::imwrite(tiffPath.toStdString(), mat);
                    qDebug() << "保存TIFF深度图(16位):" << tiffPath;
                } else {
                    cv::Mat mat16bit;
                    mat.convertTo(mat16bit, CV_16UC1, 257.0);
                    cv::imwrite(tiffPath.toStdString(), mat16bit);
                    qDebug() << "保存TIFF深度图(从8位转换):" << tiffPath;
                }
                depthSuccess = true;
            }
        } catch (const std::exception &e) {
            qDebug() << "保存深度图失败:" << e.what();
        }
    }

    // 保存点云
    if(cloud && !cloud->empty()) {
        try {
            if(pointCloudFormat == "pcd" || pointCloudFormat == "both") {
                QString pcdPath = QString("%1/%2_pointcloud.pcd").arg(saveDir).arg(baseName);
                if(pcl::io::savePCDFileBinary(pcdPath.toStdString(), *cloud) == 0) {
                    qDebug() << "保存PCD点云:" << pcdPath;
                    cloudSuccess = true;
                } else {
                    qDebug() << "保存PCD失败";
                }
            }

            if(pointCloudFormat == "ply" || pointCloudFormat == "both") {
                QString plyPath = QString("%1/%2_pointcloud.ply").arg(saveDir).arg(baseName);
                if(pcl::io::savePLYFileASCII(plyPath.toStdString(), *cloud) == 0) {
                    qDebug() << "保存PLY点云:" << plyPath;
                    cloudSuccess = true;
                } else {
                    qDebug() << "保存PLY失败";
                }
            }
        } catch (const std::exception &e) {
            qDebug() << "保存点云失败:" << e.what();
        }
    }

    // 保存三个相机的原始图像（完整分辨率）
    bool leftIRSuccess = false;
    bool rightIRSuccess = false;
    bool rgbSuccess = false;

    // 保存左红外图像（支持16位原始1224×1024或8位下采样612×512）
    if(!leftIRData.isEmpty()) {
        try {
            size_t size16bit = 1224 * 1024 * sizeof(uint16_t);
            size_t size8bit = 612 * 512;

            if(leftIRData.size() == size16bit) {
                const uint16_t* src = reinterpret_cast<const uint16_t*>(leftIRData.constData());
                cv::Mat leftIR16(1024, 1224, CV_16UC1);
                memcpy(leftIR16.data, src, size16bit);

                if(depthFormat == "png" || depthFormat == "both") {
                    QString pngPath = QString("%1/%2_left_ir.png").arg(saveDir).arg(baseName);
                    cv::Mat leftIR8;
                    leftIR16.convertTo(leftIR8, CV_8UC1, 255.0 / 65535.0);
                    cv::imwrite(pngPath.toStdString(), leftIR8);
                    qDebug() << "保存左红外PNG图像(16bit):" << pngPath;
                    leftIRSuccess = true;
                }
                if(depthFormat == "tiff" || depthFormat == "both") {
                    QString tiffPath = QString("%1/%2_left_ir.tiff").arg(saveDir).arg(baseName);
                    cv::imwrite(tiffPath.toStdString(), leftIR16);
                    qDebug() << "保存左红外TIFF图像(16位):" << tiffPath;
                    leftIRSuccess = true;
                }
            } else if(leftIRData.size() == size8bit) {
                cv::Mat leftIR8(512, 612, CV_8UC1, const_cast<char*>(leftIRData.constData()));
                cv::Mat leftIR8Clone = leftIR8.clone();

                if(depthFormat == "png" || depthFormat == "both") {
                    QString pngPath = QString("%1/%2_left_ir.png").arg(saveDir).arg(baseName);
                    cv::imwrite(pngPath.toStdString(), leftIR8Clone);
                    qDebug() << "保存左红外PNG图像(8bit下采样):" << pngPath;
                    leftIRSuccess = true;
                }
                if(depthFormat == "tiff" || depthFormat == "both") {
                    QString tiffPath = QString("%1/%2_left_ir.tiff").arg(saveDir).arg(baseName);
                    cv::imwrite(tiffPath.toStdString(), leftIR8Clone);
                    qDebug() << "保存左红外TIFF图像(8bit下采样):" << tiffPath;
                    leftIRSuccess = true;
                }
            } else {
                qDebug() << "左红外数据大小不匹配:" << leftIRData.size()
                         << "(期望16bit:" << size16bit << "或8bit:" << size8bit << ")";
            }
        } catch (const std::exception &e) {
            qDebug() << "保存左红外图像失败:" << e.what();
        }
    }

    // 保存右红外图像（支持16位原始1224×1024或8位下采样612×512）
    if(!rightIRData.isEmpty()) {
        try {
            size_t size16bit = 1224 * 1024 * sizeof(uint16_t);
            size_t size8bit = 612 * 512;

            if(rightIRData.size() == size16bit) {
                const uint16_t* src = reinterpret_cast<const uint16_t*>(rightIRData.constData());
                cv::Mat rightIR16(1024, 1224, CV_16UC1);
                memcpy(rightIR16.data, src, size16bit);

                if(depthFormat == "png" || depthFormat == "both") {
                    QString pngPath = QString("%1/%2_right_ir.png").arg(saveDir).arg(baseName);
                    cv::Mat rightIR8;
                    rightIR16.convertTo(rightIR8, CV_8UC1, 255.0 / 65535.0);
                    cv::imwrite(pngPath.toStdString(), rightIR8);
                    qDebug() << "保存右红外PNG图像(16bit):" << pngPath;
                    rightIRSuccess = true;
                }
                if(depthFormat == "tiff" || depthFormat == "both") {
                    QString tiffPath = QString("%1/%2_right_ir.tiff").arg(saveDir).arg(baseName);
                    cv::imwrite(tiffPath.toStdString(), rightIR16);
                    qDebug() << "保存右红外TIFF图像(16位):" << tiffPath;
                    rightIRSuccess = true;
                }
            } else if(rightIRData.size() == size8bit) {
                cv::Mat rightIR8(512, 612, CV_8UC1, const_cast<char*>(rightIRData.constData()));
                cv::Mat rightIR8Clone = rightIR8.clone();

                if(depthFormat == "png" || depthFormat == "both") {
                    QString pngPath = QString("%1/%2_right_ir.png").arg(saveDir).arg(baseName);
                    cv::imwrite(pngPath.toStdString(), rightIR8Clone);
                    qDebug() << "保存右红外PNG图像(8bit下采样):" << pngPath;
                    rightIRSuccess = true;
                }
                if(depthFormat == "tiff" || depthFormat == "both") {
                    QString tiffPath = QString("%1/%2_right_ir.tiff").arg(saveDir).arg(baseName);
                    cv::imwrite(tiffPath.toStdString(), rightIR8Clone);
                    qDebug() << "保存右红外TIFF图像(8bit下采样):" << tiffPath;
                    rightIRSuccess = true;
                }
            } else {
                qDebug() << "右红外数据大小不匹配:" << rightIRData.size()
                         << "(期望16bit:" << size16bit << "或8bit:" << size8bit << ")";
            }
        } catch (const std::exception &e) {
            qDebug() << "保存右红外图像失败:" << e.what();
        }
    }

    // 保存RGB图像（MJPEG原始数据，完整分辨率1920×1080）
    if(!rgbData.isEmpty()) {
        try {
            // 直接保存JPEG文件（无需解码，保持原始质量）
            QString rgbPath = QString("%1/%2_rgb.jpg").arg(saveDir).arg(baseName);
            QFile file(rgbPath);
            if(file.open(QIODevice::WriteOnly)) {
                file.write(rgbData);
                file.close();
                qDebug() << "保存RGB图像(JPEG):" << rgbPath;
                rgbSuccess = true;
            } else {
                qDebug() << "无法创建RGB文件:" << rgbPath;
            }
        } catch (const std::exception &e) {
            qDebug() << "保存RGB图像失败:" << e.what();
        }
    }

    qDebug() << "后台保存完成 - 深度图:" << (depthSuccess ? "成功" : "失败")
             << ", 点云:" << (cloudSuccess ? "成功" : "失败")
             << ", 左红外:" << (leftIRSuccess ? "成功" : "失败")
             << ", 右红外:" << (rightIRSuccess ? "成功" : "失败")
             << ", RGB:" << (rgbSuccess ? "成功" : "失败");
}

bool MainWindow::saveDepthImage(const QString &dir, const QString &baseName, const QString &format)
{
    try {
        // 转换QImage到OpenCV Mat
        cv::Mat mat;
        if(m_currentImage.format() == QImage::Format_Grayscale8) {
            mat = cv::Mat(m_currentImage.height(), m_currentImage.width(), CV_8UC1,
                         const_cast<uchar*>(m_currentImage.bits()), m_currentImage.bytesPerLine()).clone();
        } else if(m_currentImage.format() == QImage::Format_Grayscale16) {
            mat = cv::Mat(m_currentImage.height(), m_currentImage.width(), CV_16UC1,
                         const_cast<uchar*>(m_currentImage.bits()), m_currentImage.bytesPerLine()).clone();
        } else {
            // 转换为灰度图
            QImage grayImage = m_currentImage.convertToFormat(QImage::Format_Grayscale8);
            mat = cv::Mat(grayImage.height(), grayImage.width(), CV_8UC1,
                         const_cast<uchar*>(grayImage.bits()), grayImage.bytesPerLine()).clone();
        }

        // 根据format参数保存
        if(format == "png" || format == "both") {
            // 保存PNG格式（8位）
            QString pngPath = QString("%1/%2_depth.png").arg(dir).arg(baseName);
            cv::Mat mat8bit;
            if(mat.type() == CV_16UC1) {
                mat.convertTo(mat8bit, CV_8UC1, 255.0 / 65535.0);
            } else {
                mat8bit = mat;
            }
            cv::imwrite(pngPath.toStdString(), mat8bit);
            qDebug() << "保存PNG深度图:" << pngPath;
        }

        if(format == "tiff" || format == "both") {
            // 保存TIFF格式（16位原始数据）
            QString tiffPath = QString("%1/%2_depth.tiff").arg(dir).arg(baseName);
            if(mat.type() == CV_16UC1) {
                cv::imwrite(tiffPath.toStdString(), mat);
                qDebug() << "保存TIFF深度图(16位):" << tiffPath;
            } else {
                // 如果不是16位，转换为16位保存
                cv::Mat mat16bit;
                mat.convertTo(mat16bit, CV_16UC1, 257.0); // 8位转16位：乘以257 (65535/255)
                cv::imwrite(tiffPath.toStdString(), mat16bit);
                qDebug() << "保存TIFF深度图(从8位转换):" << tiffPath;
            }
        }

        return true;
    } catch (const std::exception &e) {
        qDebug() << "保存深度图失败:" << e.what();
        return false;
    }
}

bool MainWindow::savePointCloud(const QString &dir, const QString &baseName, const QString &format)
{
    try {
        if(!m_currentPointCloud || m_currentPointCloud->empty()) {
            qDebug() << "点云数据为空";
            return false;
        }

        bool success = false;

        // 根据format参数保存
        if(format == "pcd" || format == "both") {
            // 保存PCD格式（PCL标准格式，二进制）
            QString pcdPath = QString("%1/%2_pointcloud.pcd").arg(dir).arg(baseName);
            if(pcl::io::savePCDFileBinary(pcdPath.toStdString(), *m_currentPointCloud) == 0) {
                qDebug() << "保存PCD点云:" << pcdPath;
                success = true;
            } else {
                qDebug() << "保存PCD失败";
            }
        }

        if(format == "ply" || format == "both") {
            // 保存PLY格式（Polygon格式，ASCII）
            QString plyPath = QString("%1/%2_pointcloud.ply").arg(dir).arg(baseName);
            if(pcl::io::savePLYFileASCII(plyPath.toStdString(), *m_currentPointCloud) == 0) {
                qDebug() << "保存PLY点云:" << plyPath;
                success = true;
            } else {
                qDebug() << "保存PLY失败";
            }
        }

        return success;
    } catch (const std::exception &e) {
        qDebug() << "保存点云失败:" << e.what();
        return false;
    }
}

// ========== 日志功能 ==========
void MainWindow::addLog(const QString &message, const QString &level)
{
    if(!m_logDisplay) return;

    // 获取当前时间戳
    QString timestamp = QDateTime::currentDateTime().toString("HH:mm:ss.zzz");

    // 根据日志级别设置颜色
    QString color;
    if(level == "ERROR") {
        color = "#FF6B6B";  // 红色
    } else if(level == "WARNING") {
        color = "#FFA500";  // 橙色
    } else if(level == "SUCCESS") {
        color = "#4CAF50";  // 绿色
    } else {
        color = "#D4D4D4";  // 默认灰白色
    }

    // 格式化日志消息
    QString formattedMessage = QString("<span style='color: #888;'>[%1]</span> "
                                       "<span style='color: %2;'>[%3]</span> "
                                       "<span style='color: %4;'>%5</span>")
                                   .arg(timestamp)
                                   .arg(color)
                                   .arg(level)
                                   .arg(color)
                                   .arg(message);

    // 添加到日志显示
    m_logDisplay->append(formattedMessage);

    // 限制日志行数（保留最近1000行）
    QTextDocument *doc = m_logDisplay->document();
    if(doc->blockCount() > 1000) {
        QTextCursor cursor = m_logDisplay->textCursor();
        cursor.movePosition(QTextCursor::Start);
        cursor.movePosition(QTextCursor::Down, QTextCursor::KeepAnchor, doc->blockCount() - 1000);
        cursor.removeSelectedText();
    }

    // 自动滚动到底部
    m_logDisplay->moveCursor(QTextCursor::End);
}

void MainWindow::onClearLogClicked()
{
    if(m_logDisplay) {
        m_logDisplay->clear();
        addLog("日志已清除", "INFO");
    }
}

void MainWindow::onSaveLogClicked()
{
    QString fileName = QFileDialog::getSaveFileName(this, "保存日志",
                                                     QStandardPaths::writableLocation(QStandardPaths::DocumentsLocation) + "/viewer_log.txt",
                                                     "文本文件 (*.txt);;所有文件 (*.*)");
    if(!fileName.isEmpty()) {
        QFile file(fileName);
        if(file.open(QIODevice::WriteOnly | QIODevice::Text)) {
            QTextStream out(&file);
            out << m_logDisplay->toPlainText();
            file.close();
            addLog(QString("日志已保存到: %1").arg(fileName), "SUCCESS");
        } else {
            addLog(QString("保存日志失败: %1").arg(file.errorString()), "ERROR");
        }
    }
}

// ========== 统计信息更新 ==========
void MainWindow::updateStatistics()
{
    // 更新三个相机的FPS
    if(m_leftFpsLabel) {
        m_leftFpsLabel->setText(QString("左红外: %1 fps").arg(m_currentLeftFps, 0, 'f', 1));
    }
    if(m_rightFpsLabel) {
        m_rightFpsLabel->setText(QString("右红外: %1 fps").arg(m_currentRightFps, 0, 'f', 1));
    }
    if(m_rgbFpsLabel) {
        m_rgbFpsLabel->setText(QString("RGB彩色: %1 fps").arg(m_currentRgbFps, 0, 'f', 1));
    }

    // 更新点云帧率
    if(m_pointCloudFpsLabel) {
        m_pointCloudFpsLabel->setText(QString("点云帧率: %1 fps").arg(m_currentPointCloudFps, 0, 'f', 1));
    }

    // 更新接收帧数（显示三个相机和点云的累计总数）
    if(m_queueLabel) {
        m_queueLabel->setText(QString("接收帧数: L%1 R%2 RGB%3 点云%4")
            .arg(m_totalLeftFrameCount)
            .arg(m_totalRightFrameCount)
            .arg(m_totalRgbFrameCount)
            .arg(m_totalPointCloudFrameCount));
    }
}

// 监听系统主题变化事件
void MainWindow::changeEvent(QEvent *event)
{
    if(event->type() == QEvent::PaletteChange) {
        // 系统调色板变化，说明主题可能已切换
        qDebug() << "系统主题已变化，刷新UI样式";

        // 强制重新应用样式表
        // 保存当前样式表
        QString currentStyle = styleSheet();

        // 清空样式表
        setStyleSheet("");

        // 重新应用样式表
        setStyleSheet(currentStyle);

        // 强制所有子组件更新
        QList<QWidget*> widgets = findChildren<QWidget*>();
        for (QWidget *widget : widgets) {
            widget->style()->unpolish(widget);
            widget->style()->polish(widget);
            widget->update();
        }

        // 触发窗口重绘
        update();
    }

    // 调用基类实现
    QMainWindow::changeEvent(event);
}