HPPA/HPPA/HPPA.cpp

#include "stdafx.h"
//#include <afx.h>

#include <exception>
#include <memory>
#include <vector>
#include <QMessageBox>
#include <QFileInfo> // 新增，用于解析路径

#include "HPPA.h"
#include "RasterLayer.h"
#include "RasterImageLayer.h"
#include "RasterRenderParams.h"
#include "LayerTreeLayerNode.h"
#include "MapTool.h"
#include "MapToolPan.h"
#include "MapToolSpectral.h"
#include "MapTools.h"
#include <algorithm>
#include <cmath>

HPPA* HPPA::s_instance = nullptr;

HPPA* HPPA::instance()
{
    return s_instance;
}

LayerTreeNode* HPPA::rasterGroupNode() const
{
    return m_RasterGroup;
}

HPPA::HPPA(QWidget* parent)
    : QMainWindow(parent)
{
    s_instance = this;
    ui.setupUi(this);

	setWindowFlags(Qt::FramelessWindowHint);

    // register MapLayer* metatype for queued signal/slot across threads
    qRegisterMetaType<MapLayer*>("MapLayer*");

    QCoreApplication::setOrganizationName("IRIS");
    QCoreApplication::setOrganizationDomain("iris.com");
    QCoreApplication::setApplicationName("HPPA");

    //配置文件：如果没有，就创建配置文件
    string HPPACfgFile = getPathofEXE() + "\\HPPA.cfg";
    mConfigfile.setConfigfilePath(HPPACfgFile);
    if (!mConfigfile.isConfigfileExist())
    {
        mConfigfile.createConfigFile();
        qDebug() << "create: " << QString::fromStdString(HPPACfgFile);
    }
    mConfigfile.parseConfigfile();
    qDebug() << "exist: " << QString::fromStdString(HPPACfgFile);

    // Create MapLayerStore early so created layers are managed
    m_MapLayerStore = new MapLayerStore(this);

    /*int max, min;
    mConfigfile.getPositionRestriction(max, min);

    string sn;
    mConfigfile.getSN(sn);

    int coarse, fine;
    mConfigfile.getTuningStepSize(coarse, fine);
    float fa, fb;
    mConfigfile.getFitParams(fa, fb);
    int max_FocusRange, min_FocusRange;
    mConfigfile.getAutoFocusRange(max_FocusRange, min_FocusRange);

    float StepAnglemar_x, Lead_x, ScaleFactor_x;
    int SubdivisionMultiples_x;
    mConfigfile.getXMotorParm(StepAnglemar_x, Lead_x, SubdivisionMultiples_x, ScaleFactor_x);
    float StepAnglemar_y, Lead_y, ScaleFactor_y;
    int SubdivisionMultiples_y;
    mConfigfile.getYMotorParm(StepAnglemar_y, Lead_y, SubdivisionMultiples_y, ScaleFactor_y);*/

    //状态栏
    //xmotor_state_label1 = new QLabel();
    //ymotor_state_label1 = new QLabel();
    //xmotor_state_label1->setText("xMotor");
    //ymotor_state_label1->setText("yMotor");
    //ui.statusBar->addPermanentWidget(xmotor_state_label1);
    //ui.statusBar->addPermanentWidget(ymotor_state_label1);

    m_recordFrameCounter = new recordFrameCounter(this);
    ui.statusBar->addWidget(m_recordFrameCounter);

    connect(this->ui.action_exit, SIGNAL(triggered()), this, SLOT(onExit()));
    connect(this->ui.mActionOpenImg, SIGNAL(triggered()), this, SLOT(onOpenImg()));

    //ui.cam_label->setScaledContents(true);

    /*ui.splitter->setStretchFactor(0, 1);
    ui.splitter->setStretchFactor(1, 1);
    ui.splitter->setStretchFactor(2, 3);*/

    initMenubarToolbar();

    startTimer(1000);

    widthScale = 1;
    heightScale = 1;

    //马达位置模拟
    //connect(ui.graphicsView->imager, SIGNAL(leftMouseButtonPressed(int, int)), this, SLOT(onimagerSimulatorMove(int, int)));

    initPanelToolbar();
    
    setDockNestingEnabled(true);
	connect(this->ui.mSetting, SIGNAL(triggered()), this, SLOT(settingWindow()));
    connect(this->ui.action_about, SIGNAL(triggered()), this, SLOT(onAbout()));
    connect(this->ui.mActionOneMotorScenario, SIGNAL(triggered()), this, SLOT(createOneMotorScenario()));
    connect(this->ui.mActionPlantPhenotypeScenario, SIGNAL(triggered()), this, SLOT(createPlantPhenotypeScenario()));
	connect(this->ui.mAction3DPlantPhenotypeScenario, SIGNAL(triggered()), this, SLOT(create3DPlantPhenotypeScenario()));
	connect(this->ui.mActionMicroscopicMotionControlScenario, SIGNAL(triggered()), this, SLOT(createMicroscopicMotionControlScenario()));

    delete ui.centralWidget;

    QString qss_DockWidget_contentWidget = R"(
        background: #0D1233;
		/*border: 1px solid #2c586b;*/
		
		border-top: 1px solid #2c586b;
		border-left: 1px solid #2c586b;
		border-right: 1px solid #2c586b;
		border-bottom: 1px solid #2c586b;

		border-bottom-left-radius: 10px;
		border-bottom-right-radius: 10px;
	)";

    //TOC
    CustomDockWidgetBase* dock_layers = new CustomDockWidgetBase(QString::fromLocal8Bit("layers"), this);
    dock_layers->setObjectName("mDockLayers");
    dock_layers->setAllowedAreas(Qt::LeftDockWidgetArea | Qt::RightDockWidgetArea);
    mPanelMenu->addAction(dock_layers->toggleViewAction());
    addDockWidget(Qt::LeftDockWidgetArea, dock_layers);
    dock_layers->hideMaxButton();

    //1、没用
    QWidget* dock_layersWidgetContents = new QWidget();
    dock_layersWidgetContents->setObjectName(QString::fromUtf8("dockWidgetContents_2"));
    QGridLayout* gridLayout_toc = new QGridLayout(dock_layersWidgetContents);
    gridLayout_toc->setSpacing(6);
    gridLayout_toc->setContentsMargins(11, 11, 11, 11);
    gridLayout_toc->setObjectName(QString::fromUtf8("gridLayout_toc"));
    gridLayout_toc->setVerticalSpacing(0);
    gridLayout_toc->setContentsMargins(0, 0, 0, 0);

    ImagerPositionSimulation* graphicsView_delete = new ImagerPositionSimulation(dock_layersWidgetContents);
    graphicsView_delete->setObjectName(QString::fromUtf8("graphicsView_delete"));
    QSizePolicy sizePolicy1(QSizePolicy::Preferred, QSizePolicy::Preferred);
    sizePolicy1.setHorizontalStretch(0);
	sizePolicy1.setVerticalStretch(0);
	sizePolicy1.setHeightForWidth(graphicsView_delete->sizePolicy().hasHeightForWidth());
    graphicsView_delete->setSizePolicy(sizePolicy1);
    graphicsView_delete->setFrameShape(QFrame::NoFrame);
    graphicsView_delete->setFrameShadow(QFrame::Raised);
    //gridLayout_toc->addWidget(graphicsView_delete, 0, 0, 1, 1);

    //3、正经TOC
    m_LayerTree = new LayerTree();
    m_LayerTreeModel = new LayerTreeModel(m_LayerTree, this, true);

    // 创建并保留 Raster 分组指针，后续添加 layer 使用它
    m_RasterGroup = m_LayerTreeModel->addGroup(m_LayerTreeModel->root(), "Raster");
    //{
    //    auto* ln1 = new LayerTreeLayerNode(nullptr);
    //    ln1->setName("tmp_image_1");
    //    m_LayerTreeModel->addLayer(m_RasterGroup, ln1);
    //}
    //{
    //    auto* ln2 = new LayerTreeLayerNode(nullptr);
    //    ln2->setName("tmp_image_2");
    //    m_LayerTreeModel->addLayer(m_RasterGroup, ln2);
    //}

    auto* g2 = m_LayerTreeModel->addGroup(m_LayerTreeModel->root(), "Vector");
    //model->addLayer(g2, "Rivers");
	m_layerTreeView = new LayerTreeView();
	m_layerTreeView->setMenuProvider(new LayerTreeViewMenuProvider(m_layerTreeView));
	m_layerTreeView->setModel(m_LayerTreeModel);
	m_layerTreeView->setHeaderHidden(true);
	m_layerTreeView->setStyleSheet(R"(
		QTreeView
		{
			color: #ACCDFF;
		}
		QTreeView::branch {
			background: transparent;
		}

		QTreeView::branch:has-children:!has-siblings:closed,
		QTreeView::branch:closed:has-children:has-siblings
		{
			border-image: none;
			image: url(:/svg/resources/icons/svg/tree_tri_right.svg);
		}
		QTreeView::branch:open:has-children:!has-siblings,
		QTreeView::branch:open:has-children:has-siblings
		{
			border-image: none;
			image: url(:/svg/resources/icons/svg/tree_tri_down.svg);
		}
	)");

    gridLayout_toc->addWidget(m_layerTreeView, 0, 0, 1, 1);

    // Connect TOC selection change to populate ImageControl
    connect(m_layerTreeView->selectionModel(), SIGNAL(selectionChanged(QItemSelection,QItemSelection)),
        this, SLOT(onLayerTreeSelectionChanged(QItemSelection,QItemSelection)));

    dock_layersWidgetContents->setStyleSheet(qss_DockWidget_contentWidget);
	dock_layers->setWidget(tmp(dock_layersWidgetContents));


    //dock_layers->setMinimumWidth(449);
    //dock_layers->setMaximumWidth(450);
    //dock_layers->setMinimumHeight(497);
    //dock_layers->setMaximumHeight(498);
	

    //高光谱查看
    QDockWidget* dock_hyperimgViewer = new CustomDockWidgetBase(QString::fromLocal8Bit("hyimgViewer"), this);
    dock_hyperimgViewer->setObjectName("hyimgViewer");

    QWidget* dock_hyperimgViewerWidgetContents = new QWidget();
    dock_hyperimgViewerWidgetContents->setObjectName(QString::fromUtf8("dock_hyperimgViewerWidgetContents"));
    QGridLayout* gridLayout_hyperimgViewer = new QGridLayout(dock_hyperimgViewerWidgetContents);
    gridLayout_hyperimgViewer->setSpacing(6);
    gridLayout_hyperimgViewer->setObjectName(QString::fromUtf8("gridLayout_hyperimgViewer"));
    gridLayout_hyperimgViewer->setVerticalSpacing(6);
    gridLayout_hyperimgViewer->setContentsMargins(1, 2, 1, 2);

    m_imageViewerTabWidget = new QTabWidget();
	//m_imageViewerTabWidget->tabBar()->setFixedHeight(40);//没有效果，在qss中设置高度才有效果，为啥？？？？
	m_imageViewerTabWidget->clear();//必须放在最前面，首先删除所有的tab
    QToolButton* maxButton = new QToolButton();
    maxButton->setIcon(style()->standardIcon(QStyle::SP_TitleBarMaxButton));
    connect(maxButton, SIGNAL(clicked()), dock_hyperimgViewer, SLOT(toggleMaximize()));
    m_imageViewerTabWidget->setCornerWidget(maxButton, Qt::TopRightCorner);
	//onCreateTab(0);
	//m_imageViewerTabWidget->setTabsClosable(true);//这样每页都会有关闭按钮
    connect(m_imageViewerTabWidget, SIGNAL(currentChanged(int)), this, SLOT(onTabWidgetCurrentChanged(int)));
    m_imageViewerTabWidget->setStyleSheet(R"(
		QTabBar::tab {
			background: #0E1C4C;
			color: white;
			padding: 6px 12px;
			border: none;
			border-bottom: 1px solid #27376C;
			height: 18;
		}
		
		QTabBar::tab:selected {
			background: #0D1233;
			color: white;
			border: none;
		}

		/*QTabBar::tab:hover {
			background: #141A45;
		}*/

        QTabWidget::pane {
			border: none;
			border-top: 1px solid #27376C;
			background: #0D1233;
			top: -1px;
		}

		QTabWidget QWidget {
			background: #0D1233;
		}
	)");
	QWidget* imageViewerTabWidgetContainer = new QWidget();
	QGridLayout* gridLayout_imageViewerTabWidgetContainer = new QGridLayout(imageViewerTabWidgetContainer);
	gridLayout_imageViewerTabWidgetContainer->setSpacing(6);
	gridLayout_imageViewerTabWidgetContainer->setObjectName(QString::fromUtf8("gridLayout_imageViewerTabWidgetContainer"));
	gridLayout_imageViewerTabWidgetContainer->setVerticalSpacing(6);
	gridLayout_imageViewerTabWidgetContainer->setContentsMargins(0, 0, 0, 0);
	gridLayout_imageViewerTabWidgetContainer->addWidget(m_imageViewerTabWidget, 0, 0, 1, 1);
	imageViewerTabWidgetContainer->setStyleSheet(R"(
			background: #0E1C4C;
		)");

	QFrame* line = new QFrame();
	line->setFrameShape(QFrame::HLine);
	line->setFrameShadow(QFrame::Plain);
	line->setStyleSheet(R"(
        QWidget {
			color: #2c586b;
		}
	)");

	m_chartView = new QChartView();
	m_chartView->setRenderHint(QPainter::Antialiasing);
	m_chartView->setStyleSheet(R"(
        background: #0D1233;
	)");
	//m_chartView->setBackgroundBrush(QColor("#0D1233"));

	m_chart = new QChart();
	m_chart->setBackgroundBrush(QColor("#0D1233"));
	m_chart->legend()->hide();
	//m_chart->setTitle("Simple line chart example");

	QValueAxis* axisX = new QValueAxis();
	QValueAxis* axisY = new QValueAxis();
	setAxis(axisX, axisY);
	m_chart->addAxis(axisX, Qt::AlignBottom);
	m_chart->addAxis(axisY, Qt::AlignLeft);
	m_chartView->setChart(m_chart);

	gridLayout_hyperimgViewer->addWidget(imageViewerTabWidgetContainer, 0, 0, 1, 1);
	gridLayout_hyperimgViewer->addWidget(line, 1, 0, 1, 1);
	gridLayout_hyperimgViewer->addWidget(m_chartView, 2, 0, 1, 1);

	gridLayout_hyperimgViewer->setRowStretch(0, 3);
	gridLayout_hyperimgViewer->setRowStretch(1, 1);
	gridLayout_hyperimgViewer->setRowStretch(2, 2);


	dock_hyperimgViewerWidgetContents->setStyleSheet(R"(
        QWidget #dock_hyperimgViewerWidgetContents{
			background: #0D1233;
			/*border: 1px solid #2c586b;*/
		
			border-top: 2px solid #2c586b;
			border-left: 1px solid #2c586b;
			border-right: 1px solid #2c586b;
			border-bottom: 2px solid #2c586b;
			
			border-top-left-radius: 10px;
			border-top-right-radius: 10px;
			border-bottom-left-radius: 10px;
			border-bottom-right-radius: 10px;
		}
	)");

	mPanelMenu->addAction(dock_hyperimgViewer->toggleViewAction());
	QWidget* tmp6 = new QWidget();
	dock_hyperimgViewer->setTitleBarWidget(tmp6);

	dock_hyperimgViewer->setWidget(tmp(dock_hyperimgViewerWidgetContents));

	//轮播看板
	m_dock_carousel = new CustomDockWidgetBase(QString::fromLocal8Bit("轮播"), this);
	m_dock_carousel->setObjectName("mDockCarousel");
	m_dock_carousel->setAllowedAreas(Qt::LeftDockWidgetArea | Qt::RightDockWidgetArea);
	mPanelMenu->addAction(m_dock_carousel->toggleViewAction());
	//addDockWidget(Qt::LeftDockWidgetArea, m_dock_carousel);

	QWidget* carouselContainer = new QWidget();
	carouselContainer->setObjectName("carouselContainer");
	carouselContainer->setStyleSheet(R"(
		QWidget #carouselContainer
		{
			background-color: #0D1233;

			border-top: 1px solid #2c586b;
			border-left: 1px solid #2c586b;
			border-right: 1px solid #2c586b;
			border-bottom: 1px solid #2c586b;
	
			border-top-left-radius: 0px;
			border-top-right-radius: 0px;
			border-bottom-left-radius: 10px;
			border-bottom-right-radius: 10px;
		}
	)");
	QGridLayout* gridLayout_carouselContainer = new QGridLayout(carouselContainer);
	gridLayout_carouselContainer->setSpacing(0);
	gridLayout_carouselContainer->setObjectName(QString::fromUtf8("gridLayout_carouselContainer"));
	gridLayout_carouselContainer->setVerticalSpacing(0);
	gridLayout_carouselContainer->setContentsMargins(2, 2, 2, 2);


	m_carousel = new MyCarousel();
	m_carousel->setObjectName(QString::fromUtf8("carousel"));

	//---------------------------------------------------------------------
	QScrollArea* sa = new QScrollArea();
	sa->setObjectName("sa");
	sa->setStyleSheet(R"(
		border: none;
		background-color: #0D1233;
	)");
	QGridLayout* gridLayout_sa = new QGridLayout(sa);
	gridLayout_sa->setSpacing(6);
	gridLayout_sa->setObjectName(QString::fromUtf8("gridLayout_sa"));
	gridLayout_sa->setVerticalSpacing(0);
	gridLayout_sa->setContentsMargins(0, 0, 0, 0);

	m_cam_label = new QLabel();
	m_cam_label->setAlignment(Qt::AlignHCenter);
	m_cam_label->setStyleSheet(R"(
        background-color: #0D1233;
	)");
	gridLayout_sa->addWidget(m_cam_label);

	m_carousel->addWidget(sa);
	m_carousel->setContentsMargins(0, 0, 0, 0);

	//---------------------------------------------------------------------
	QScrollArea* sa_depthCamera = new QScrollArea();
	sa_depthCamera->setObjectName("sa_depthCamera");
	sa_depthCamera->setStyleSheet(R"(
		border: none;
		background-color: #0D1233;
	)");
	QGridLayout* gridLayout_sa_depthCamera = new QGridLayout(sa_depthCamera);
	gridLayout_sa_depthCamera->setSpacing(6);
	gridLayout_sa_depthCamera->setObjectName(QString::fromUtf8("gridLayout_sa_depthCamera"));
	gridLayout_sa_depthCamera->setVerticalSpacing(0);
	gridLayout_sa_depthCamera->setContentsMargins(0, 0, 0, 0);

	m_depthCamera_label = new QLabel();
	m_depthCamera_label->setAlignment(Qt::AlignHCenter);
	m_depthCamera_label->setStyleSheet(R"(
        background-color: #0D1233;
	)");
	gridLayout_sa_depthCamera->addWidget(m_depthCamera_label);

	m_carousel->addWidget(sa_depthCamera);
	m_carousel->setContentsMargins(0, 0, 0, 0);

	//---------------------------------------------------------------------
	QScrollArea* sa_SingleLensReflexCamera = new QScrollArea();
	sa_SingleLensReflexCamera->setObjectName("sa_SingleLensReflexCamera");
	sa_SingleLensReflexCamera->setStyleSheet(R"(
		border: none;
		background-color: #0D1233;
	)");
	QGridLayout* gridLayout_sa_SingleLensReflexCamera = new QGridLayout(sa_SingleLensReflexCamera);
	gridLayout_sa_SingleLensReflexCamera->setSpacing(6);
	gridLayout_sa_SingleLensReflexCamera->setObjectName(QString::fromUtf8("gridLayout_sa_SingleLensReflexCamera"));
	gridLayout_sa_SingleLensReflexCamera->setVerticalSpacing(0);
	gridLayout_sa_SingleLensReflexCamera->setContentsMargins(0, 0, 0, 0);

	m_SingleLensReflexCamera_label = new QLabel();
	m_SingleLensReflexCamera_label->setAlignment(Qt::AlignHCenter);
	m_SingleLensReflexCamera_label->setStyleSheet(R"(
        background-color: #0D1233;
	)");
	gridLayout_sa_SingleLensReflexCamera->addWidget(m_SingleLensReflexCamera_label);

	m_carousel->addWidget(sa_SingleLensReflexCamera);
	m_carousel->setContentsMargins(0, 0, 0, 0);

	m_carousel->play();

	gridLayout_carouselContainer->addWidget(m_carousel);

	m_dock_carousel->setWidget(tmp(carouselContainer));

	//控制看板
	ui.mDockWidgetSpectrometer->setTile(QString::fromLocal8Bit("控制"));
	//ui.mDockWidgetSpectrometer->show();
	initControlTabwidget();
	m_tabManager = new TabManager(ui.controlTabWidget, this);
	
	ui.mDockWidgetSpectrometer->setWidget(tmp(ui.controlContents));

	//3D模型看板
	ui.mDockWidgetSimulator->setTile(QString::fromLocal8Bit("3D模型"));
	//ui.mDockWidgetSimulator->show();

	m_view3DModelManager = new View3DModelManager(this);

	QWidget* modelWidgetContainer = new QWidget();
	modelWidgetContainer->setObjectName("modelWidgetContainer");
	modelWidgetContainer->setStyleSheet(R"(
		QWidget #modelWidgetContainer
		{
			background-color: #0E1C4C;
	
			border-top: 1px solid #2c586b;
			border-left: 1px solid #2c586b;
			border-right: 1px solid #2c586b;
			border-bottom: 1px solid #2c586b;
	
			border-top-left-radius: 0px;
			border-top-right-radius: 0px;
			border-bottom-left-radius: 10px;
			border-bottom-right-radius: 10px;
		}
	)");
	QGridLayout* gridLayout_modelWidgetContainer = new QGridLayout(modelWidgetContainer);
	gridLayout_modelWidgetContainer->setSpacing(0);
	gridLayout_modelWidgetContainer->setObjectName(QString::fromUtf8("gridLayout_modelWidgetContainer"));
	gridLayout_modelWidgetContainer->setVerticalSpacing(0);
	gridLayout_modelWidgetContainer->setContentsMargins(2, 2, 2, 2);

	gridLayout_modelWidgetContainer->addWidget(m_view3DModelManager);

	connect(m_view3DModelManager, SIGNAL(created3DModelPlantPhenotype()), this, SLOT(onCreated3DModelPlantPhenotype()));
	connect(m_view3DModelManager, SIGNAL(created3DModelMicroscopicMotion()), this, SLOT(onCreated3DModelMicroscopicMotion()));
	connect(m_view3DModelManager, SIGNAL(created3DModelOneMotor()), this, SLOT(onCreated3DModelOneMotor()));	

	ui.mDockWidgetSimulator->setWidget(tmp(modelWidgetContainer));

	//看板排版
	splitDockWidget(dock_layers, dock_hyperimgViewer, Qt::Horizontal);
	splitDockWidget(dock_hyperimgViewer, m_dock_carousel, Qt::Horizontal);

	//m_dock_carousel->show();
	//ui.mDockWidgetRGBCamera->setMinimumWidth(449);
	//ui.mDockWidgetRGBCamera->setMaximumWidth(450);
	//ui.mDockWidgetRGBCamera->setMinimumHeight(497);
	//ui.mDockWidgetRGBCamera->setMaximumHeight(498);

	splitDockWidget(dock_layers, ui.mDockWidgetSimulator, Qt::Vertical);
	splitDockWidget(m_dock_carousel, ui.mDockWidgetSpectrometer, Qt::Vertical);

	setStyleSheet(R"(
		QMainWindow::separator{
			width: 16px;
			height: 16px;
			background: #040125;  /* 可以添加背景色 */
			/*border: 1px solid #808080;*/  /* 可以添加边框 */
		}

		QDockWidget {
            border: 2px solid #2a347a;  /* 深蓝色边框 */
            background-color: red;  /* 主体背景色 */
			color: white;               /* 标题文字颜色 */
            border-radius: 4px;
        }

        /* 标题栏 */
        QDockWidget::title {
            background-color: #0E1C4C;  /* 标题栏背景色 */
            text-align: left;         /* 标题文字居中 */
            
            /*padding: 4px;*/
        }

        /* 可选：控制 DockWidget 的关闭按钮样式 */
        QDockWidget::close-button, QDockWidget::float-button {
            background: transparent;
            border: none;
        }

        QDockWidget::close-button:hover, QDockWidget::float-button:hover {
            background: rgba(255,255,255,0.2);
        }
	)");

	//光谱仪操作
	m_Imager = nullptr;
	m_RecordThread = nullptr;
	m_CopyFileThread = nullptr;
	m_FileOperation = nullptr;
	m_TestImagerStausThread = nullptr;
	m_RecordState = 0;
	connect(this->ui.action_connect_imager, SIGNAL(triggered()), this, SLOT(onconnect()));//信号与槽：连接相机，相机操作相关信号与槽绑定放在函数onconnect中

	createActionGroups();
	connect(mImagerGroup, &QActionGroup::triggered, this, &HPPA::selectingImager);

	createMoveplatformActionGroup();
	connect(moveplatformActionGroup, &QActionGroup::triggered, this, &HPPA::selectingMoveplatform);

	createScenarioActionGroup();
	connect(m_ScenarioActionGroup, &QActionGroup::triggered, this, &HPPA::selectScenario);

	ui.mDockWidgetSimulator->setFeatures(QDockWidget::DockWidgetClosable);

	initMapTools();

	QString strPath = QCoreApplication::applicationDirPath() + "/UILayout.ini";
	QFile file(strPath);
	if (file.open(QIODevice::ReadOnly))
	{
		QByteArray ba;
		QDataStream in(&file);
		in >> ba;
		file.close();
		this->restoreState(ba);
	}
	this->showMaximized();
}

void HPPA::initMenubarToolbar()
{
	//自定义菜单栏和工具栏
	QWidget* menuWidget = new WidgetWithBackgroundPicture();
	//menuWidget->setFixedWidth(200);
	menuWidget->setFixedHeight(66);
	QHBoxLayout* hLayout_menuWidget = new QHBoxLayout(menuWidget);

	//auto menuBar_tmp = menuBar();
	auto menuBar_tmp = ui.menuBar;
	hLayout_menuWidget->addWidget(menuBar_tmp);
	menuBar_tmp->setAutoFillBackground(false);
	menuBar_tmp->setStyleSheet(R"(
		QMenuBar {
			background: transparent;/*transparent*/
			border: none;
		}
		QMenuBar::item {
			background: transparent;
			color: white;  /* 根据你的背景调整文字颜色 */
			padding: 4px 8px;
			padding-top: 8px;
			padding-bottom: 8px;
		}
		QMenuBar::item:selected {
			background: rgba(255, 255, 255, 50); /* 轻微高亮 */
		}

        QMenu {
            background-color: #0A1245;  /* 菜单背景色 */
            border: 1px solid gray;   /* 可选，边框样式 */
			color: white;  /* 根据你的背景调整文字颜色 */
        }
		QMenu::item:selected {
            background-color: rgba(255, 255, 255, 50); /* 选中时的背景色 */
            color: white;              /* 选中项字体颜色，可选 */
        }
	)");

	hLayout_menuWidget->addStretch();
	QPushButton* closeBtn = new QPushButton(QString::fromLocal8Bit("退出平台"));
	connect(closeBtn, SIGNAL(released()), this, SLOT(onExit()));
	closeBtn->setStyleSheet(R"(
		QPushButton {
            background: #002CE0;
            color: white;
            font-size: 14px;
            border: none;
            padding: 8px;
        }
		QPushButton:hover {
			background: #34495e;
		}
	)");
	hLayout_menuWidget->addWidget(closeBtn);

	QWidget* toolBarWidget = new QWidget();
	toolBarWidget->setStyleSheet("background-color: #0D1233;");
	QHBoxLayout* hLayout_toolBarWidget = new QHBoxLayout(toolBarWidget);

	//QToolBar* toolBar = this->findChild<QToolBar*>("mainToolBar");
	QToolBar* toolBar = ui.mainToolBar;
	hLayout_toolBarWidget->addWidget(toolBar);
	toolBar->setAttribute(Qt::WA_TranslucentBackground, true);
	toolBar->setAutoFillBackground(false);
	toolBar->setIconSize(QSize(56, 56));
	toolBar->setToolButtonStyle(Qt::ToolButtonTextUnderIcon);
	//在工具栏上添加输入框QLineEdit
	frame_number = new QLineEdit(ui.mainToolBar);
	frame_number->setStyleSheet("QLineEdit{background-color:rgb(255,255,255);}");
	frame_number->setMaximumWidth(100);
	frame_number->setText("5000");
	frame_number->setStyleSheet(R"(
		QLineEdit {
			background-color: #142D7F;
			color: #e6eeff;
			border: 1px solid #2f6bff;
			border-radius: 6px;
			padding: 4px 8px;
			min-width: 70px;
			min-height: 20px;
			font-size: 13px;
		}
		QLineEdit:hover {
			border: 1px solid #4d8dff;
		}

		QLineEdit:focus {
			border: 1px solid #6aa2ff;
			background-color: #23345c;
		}
	)");
	QAction* action = ui.mainToolBar->insertWidget(ui.action_start_recording, frame_number);
	frame_number->setEnabled(false);

	m_FilenameLineEdit = new FileNameLineEdit(ui.mainToolBar);
	m_FilenameLineEdit->setMaximumWidth(100);
	m_FilenameLineEdit->setStyleSheet(R"(
		QLineEdit {
			background-color: #142D7F;
			color: #e6eeff;
			border: 1px solid #2f6bff;
			border-radius: 6px;
			padding: 4px 8px;
			min-width: 70px;
			min-height: 20px;
			font-size: 13px;
		}
		QLineEdit:hover {
			border: 1px solid #4d8dff;
		}

		QLineEdit:focus {
			border: 1px solid #6aa2ff;
			background-color: #23345c;
		}
	)");
	QAction* action1 = ui.mainToolBar->insertWidget(ui.action_start_recording, m_FilenameLineEdit);

	QWidget* spacer = new QWidget();
	spacer->setFixedWidth(10);  // 间距大小自己调
	ui.mainToolBar->insertWidget(action1, spacer);


	QAction* sepAction = ui.mainToolBar->insertSeparator(ui.mActionPan);
	QWidget* sepWidget = ui.mainToolBar->widgetForAction(sepAction);
	if (sepWidget) {
		//sepWidget->setFixedWidth(15); // 调整宽度
		sepWidget->setStyleSheet("background-color: #2C586C;"); // 调整颜色
	}

	ui.action_connect_imager->setIcon(QIcon(":/svg/resources/icons/svg/connect_imager.svg"));
	ui.action_auto_exposure->setIcon(QIcon(":/svg/resources/icons/svg/exposure.svg"));
	ui.action_focus->setIcon(QIcon(":/svg/resources/icons/svg/focus.svg"));
	ui.action_dark->setIcon(QIcon(":/svg/resources/icons/svg/dark.svg"));
	ui.action_reference->setIcon(QIcon(":/svg/resources/icons/svg/reference.svg"));
	ui.action_start_recording->setIcon(QIcon(":/svg/resources/icons/svg/record.svg"));
	ui.actionOpenDirectory->setIcon(QIcon(":/svg/resources/icons/svg/openDirectory.svg"));

	ui.mActionPan->setIcon(QIcon(":/svg/resources/icons/svg/pan.svg"));
	ui.mActionSpectral->setIcon(QIcon(":/svg/resources/icons/svg/spectral.svg"));

	connect(ui.mActionPan, &QAction::toggled, this, [=](bool checked) {
		if (checked)
			ui.mActionPan->setIcon(QIcon(":/svg/resources/icons/svg/pan_done.svg"));
		else
			ui.mActionPan->setIcon(QIcon(":/svg/resources/icons/svg/pan.svg"));
		});

	connect(ui.mActionSpectral, &QAction::toggled, this, [=](bool checked) {
		if (checked)
			ui.mActionSpectral->setIcon(QIcon(":/svg/resources/icons/svg/spectral_done.svg"));
		else
		 ui.mActionSpectral->setIcon(QIcon(":/svg/resources/icons/svg/spectral.svg"));
		});

	// 使用样式表设置透明背景
	toolBar->setStyleSheet(R"(
		QToolBar {
			background: #0D1233;/*transparent*/
			border: 1px solid #2C586C;
			border-radius: 6px;
		}
		QToolButton {
			background: transparent;
			color: white;   /* 可根据背景调整文字颜色 */
			padding: 4px;
			margin: 0 0 0 6px; 
		}
		QToolButton:hover {
			background: rgba(255,255,255,50); /* 悬停时轻微高亮 */
		}
	)");

	QWidget* topWidget = new QWidget();
	topWidget->setStyleSheet("background-color: #040125;");
	QVBoxLayout* verticalLayout_topWidget = new QVBoxLayout(topWidget);
	verticalLayout_topWidget->addWidget(menuWidget);
	verticalLayout_topWidget->addWidget(toolBarWidget);
	setMenuWidget(topWidget);
}

QWidget* HPPA::tmp(QWidget* a)
{
	QWidget* Background = new QWidget(this);
	Background->setObjectName("Background");
	QGridLayout* layout_Background = new QGridLayout(Background);
	layout_Background->setContentsMargins(0, 0, 0, 0);
	Background->setStyleSheet(R"(
		QWidget #Background{
			background: #040125;
		}
	)");
	layout_Background->addWidget(a);

	return Background;
}

void HPPA::initControlTabwidget()
{	
	ui.controlTabWidget->removeTab(0);//首先删除默认的tab

	m_hic = new HyperImagerControl();
	m_hic->setDisabled(true);
	ui.controlTabWidget->addTab(m_hic, QString::fromLocal8Bit("光谱仪"));
	ui.controlTabWidget->setCurrentIndex(0);

	//图像控制
	m_ic = new ImageControl();
	m_ic->setWindowFlags(Qt::Widget);
	connect(m_ic, SIGNAL(bandSelectionChanged(double, double, double)),
		this, SLOT(onBandSelectionChanged(double, double, double)));
	ui.controlTabWidget->addTab(m_ic, QString::fromLocal8Bit("图像控制"));//?????????????????????????????????????????????????????????????????????????????????????????????????

	//深度相机
	m_depthCameraWindow = new DepthCameraWindow();
	ui.controlTabWidget->addTab(m_depthCameraWindow, QString::fromLocal8Bit("深度相机"));

	//单反相机
	m_singleLensReflexCameraWindow = new SingleLensReflexCameraWindow();
	connect(m_singleLensReflexCameraWindow, &SingleLensReflexCameraWindow::LiveViewImageReady, this, &HPPA::onLiveViewImageReady);
	connect(m_singleLensReflexCameraWindow, &SingleLensReflexCameraWindow::LiveViewStopped, this, &HPPA::onLiveViewStopped);

	ui.controlTabWidget->addTab(m_singleLensReflexCameraWindow, QString::fromLocal8Bit("单反相机"));

	//rgb相机
	m_rgbCameraControlWindow = new rgbCameraWindow();
	connect(m_rgbCameraControlWindow, &rgbCameraWindow::PlotRgbImageSignal, this, &HPPA::onPlotRgbImage);
	connect(m_rgbCameraControlWindow, &rgbCameraWindow::CamClosedSignal, this, &HPPA::onClearLabel);

	connect(m_depthCameraWindow, &DepthCameraWindow::PlotDepthImageSignal, this, &HPPA::onPlotDepthImage);
	connect(m_depthCameraWindow, &DepthCameraWindow::DepthCamClosedSignal, this, &HPPA::onClearDepthLabel);

	ui.controlTabWidget->addTab(m_rgbCameraControlWindow, QString::fromLocal8Bit("rgb相机"));

	//升降桌dock
	m_adt = new adjustTable();
	m_adt->setWindowFlags(Qt::Widget);
	ui.controlTabWidget->addTab(m_adt, QString::fromLocal8Bit("升降桌"));

	//电源控制
	m_pc = new PowerControl();
	m_pc->setWindowFlags(Qt::Widget);
	ui.controlTabWidget->addTab(m_pc, QString::fromLocal8Bit("电源控制"));

	//机械臂控制
	m_rac = new RobotArmControl();
	connect(m_rac->robotController, SIGNAL(hsiRecordSignal(int)), this, SLOT(recordFromRobotArm(int)));
	m_rac->setWindowFlags(Qt::Widget);
	ui.controlTabWidget->addTab(m_rac, QString::fromLocal8Bit("机械臂控制"));

	//1轴马达控制
	m_omc = new OneMotorControl();
	m_omc->setWindowFlags(Qt::Widget);
	ui.controlTabWidget->addTab(m_omc, QString::fromLocal8Bit("1轴马达控制"));

	//2轴马达控制
	m_tmc = new TwoMotorControl(this);
	//connect(m_tmc, SIGNAL(startLineNumSignal(int)), this, SLOT(onCreateTab(int)));
	connect(m_tmc, SIGNAL(sequenceComplete()), this, SLOT(onsequenceComplete()));
	m_tmc->setWindowFlags(Qt::Widget);
	ui.controlTabWidget->addTab(m_tmc, QString::fromLocal8Bit("2轴控制"));

	// Connect ImageControl band change to re-render (m_ic created in initControlTabwidget)
	//connect(m_ic, SIGNAL(bandSelectionChanged(double, double, double)),
	//	this, SLOT(onBandSelectionChanged(double, double, double)));
}

void HPPA::recordFromRobotArm(int fileCounter)
{
	if (!testImagerVality())
	{
		showMessageBox(QString::fromLocal8Bit("找不到光谱仪！"));

		return;
	}

	//qDebug() << "recordFromRobotArm" << fileCounter;

	if (fileCounter == -1)
	{
		m_Imager->setRecordControlState(false);

		ui.action_start_recording->setText(QString::fromLocal8Bit("采集"));
		ui.action_start_recording->setIcon(QIcon(":/svg/resources/icons/svg/record_done.svg"));
		//ui.mainToolBar->widgetForAction(ui.action_start_recording)->setStyleSheet("QWidget{background-color:rgb(0,255,0);}");
		//qDebug() << "recordFromRobotArm: 1111111111111111111111";

		return;
	}

	if (fileCounter - 1 == 0)
	{
		//m_imageViewerTabWidget->clear();
		removeAllLayersInRasterGroup();
	}

	onCreateTab("img");
	emit StartRecordSignal();

	ui.action_start_recording->setText(QString::fromLocal8Bit("采集中"));
	ui.action_start_recording->setIcon(QIcon(":/svg/resources/icons/svg/record_ing.svg"));
	//ui.mainToolBar->widgetForAction(ui.action_start_recording)->setStyleSheet("QWidget{background-color:rgb(255,0,0);}");
	//qDebug() << "recordFromRobotArm: 2222222222222222222222";
}

void HPPA::createActionGroups()
{
	// Imager Tool Group
	mImagerGroup = new QActionGroup(this);
	mImagerGroup->addAction(ui.mActionPica_L);
	mImagerGroup->addAction(ui.mActionPika_XC2);
	mImagerGroup->addAction(ui.mActionCorning_410);
	mImagerGroup->addAction(ui.mActionPica_NIR);


	// 读取上次选择的结果
	QSettings settings;
	QString lastSelectedAction = settings.value("LastSelectedImagerAction").toString();

	// 恢复上次选择的结果
	if (lastSelectedAction == "mActionPica_L")
	{
		ui.mActionPica_L->setChecked(true);
	}
	else if (lastSelectedAction == "mActionPica_NIR")
	{
		ui.mActionPica_NIR->setChecked(true);
	}
	else if (lastSelectedAction == "mActionPika_XC2")
	{
		ui.mActionPika_XC2->setChecked(true);
	}
	else if (lastSelectedAction == "mActionCorning_410")
	{
	 ui.mActionCorning_410->setChecked(true);
	}

	updateImagerPicture(lastSelectedAction);
}

void HPPA::selectingImager(QAction* selectedAction)
{
	QSettings settings;
	settings.setValue("LastSelectedImagerAction", selectedAction->objectName());
	settings.sync();

	updateImagerPicture(selectedAction->objectName());
}

void HPPA::updateImagerPicture(const QString& actionName)
{
	QString picPath;
	if (actionName == "mActionPica_L")
		picPath = ":/imagerPicture/resources/icons/imagerPicture/L.png";
	else if (actionName == "mActionPica_NIR")
		picPath = ":/imagerPicture/resources/icons/imagerPicture/IR.png";
	else if (actionName == "mActionPika_XC2")
		picPath = ":/imagerPicture/resources/icons/imagerPicture/XC2.png";
	else if (actionName == "mActionCorning_410")
		picPath = ":/imagerPicture/resources/icons/imagerPicture/corning410.png";

	if (!picPath.isEmpty())
	{
		QPixmap pixmap(picPath);
		if (!pixmap.isNull())
		{
			QImage img = pixmap.toImage().convertToFormat(QImage::Format_ARGB32);
			const int threshold = 240;
			for (int y = 0; y < img.height(); ++y)
			{
				QRgb* line = reinterpret_cast<QRgb*>(img.scanLine(y));
				for (int x = 0; x < img.width(); ++x)
				{
					if (qRed(line[x]) >= threshold && qGreen(line[x]) >= threshold && qBlue(line[x]) >= threshold)
					{
						line[x] = qRgba(qRed(line[x]), qGreen(line[x]), qBlue(line[x]), 0);
					}
				}
			}
			m_hic->imagerPictureLabel()->setAttribute(Qt::WA_TranslucentBackground);
			m_hic->imagerPictureLabel()->setOriginalPixmap(QPixmap::fromImage(img));
		}
	}
}

void HPPA::createMoveplatformActionGroup()
{
	moveplatformActionGroup = new QActionGroup(this);
	moveplatformActionGroup->addAction(ui.mAction_is_no_motor);
	moveplatformActionGroup->addAction(ui.mAction_RobotArm);
	moveplatformActionGroup->addAction(ui.mAction_1AxisMotor);
	moveplatformActionGroup->addAction(ui.mAction_2AxisMotor_new);

	// 读取上次选择的结果
	QSettings settings;
	QString lastSelectedAction = settings.value("LastSelectedMoveplatform").toString();

	// 恢复上次选择的结果
	if (lastSelectedAction == "mAction_is_no_motor")
	{
		ui.mAction_is_no_motor->setChecked(true);
	}
	else if (lastSelectedAction == "mAction_RobotArm")
	{
	 ui.mAction_RobotArm->setChecked(true);
	}
	else if (lastSelectedAction == "mAction_1AxisMotor")
	{
		ui.mAction_1AxisMotor->setChecked(true);
	}
	else if (lastSelectedAction == "mAction_2AxisMotor_new")
	{
		ui.mAction_2AxisMotor_new->setChecked(true);
	}
}

void HPPA::selectingMoveplatform(QAction* selectedAction)
{
	QSettings settings;
	settings.setValue("LastSelectedMoveplatform", selectedAction->objectName());
	settings.sync();
}

HPPA::~HPPA()
{
	QString strPath = QCoreApplication::applicationDirPath() + "/UILayout.ini";
	QFile file(strPath);
	if (file.open(QIODevice::WriteOnly)) {
		QDataStream outfile(&file);
		QByteArray ba = this->saveState();
		outfile << ba;
		file.close();
	}

	disconnectImagerAndCleanup();

    if (s_instance == this)
    {
        s_instance = nullptr;
    }
}

void HPPA::removeLayerByTreeIndex()
{
	QModelIndex currentIndexTmp = m_layerTreeView->currentIndex();

    if (!currentIndexTmp.isValid()) return;

    LayerTreeModel* model = const_cast<LayerTreeModel*>(static_cast<const LayerTreeModel*>(currentIndexTmp.model()));
    if (!model) return;

    LayerTreeNode* node = static_cast<LayerTreeNode*>(currentIndexTmp.internalPointer());
    if (!node || node->type() != LayerTreeNode::Type::Layer) return;

	removeLayerByNode(node);
}

void HPPA::removeLayerByNode(LayerTreeNode* node)
{
	if (!node || node->type() != LayerTreeNode::Type::Layer) return;

	auto* layerNode = static_cast<LayerTreeLayer*>(node);
	MapLayer* mapLayer = layerNode->mapLayer();

	if (!mapLayer || !m_MapLayerStore) return;

	// 获取该 mapLayer 对应的所有 widget 并从 tab 中移除
	std::vector<QWidget*> widgets = m_MapLayerStore->widgetsForMapLayer(mapLayer);
	for (QWidget* widget : widgets)
	{
		if (widget && m_imageViewerTabWidget)
		{
			const int tabIndex = m_imageViewerTabWidget->indexOf(widget);
			if (tabIndex >= 0)
			{
				if (m_recordFrameCounter)
				{
					m_recordFrameCounter->removeCounter(widget);
				}
				m_imageViewerTabWidget->removeTab(tabIndex);
			}
			widget->deleteLater();
		}
	}

	// 删除 MapLayerStore 中的 mapLayer
	m_MapLayerStore->removeLayer(mapLayer);

	// 删除树模型中的节点
	LayerTreeNode* parent = node->parentNode();
	int row = node->rowInParent();
	LayerTreeNode* removed = m_LayerTreeModel->removeNode(parent, row);
	if (removed)
	{
		delete removed;
	}
}

void HPPA::showColorImageByTreeIndex()
{
	QModelIndex currentIndexTmp = m_layerTreeView->currentIndex();
	if (!currentIndexTmp.isValid()) return;

	LayerTreeModel* model = const_cast<LayerTreeModel*>(static_cast<const LayerTreeModel*>(currentIndexTmp.model()));
	if (!model) return;

	LayerTreeNode* node = static_cast<LayerTreeNode*>(currentIndexTmp.internalPointer());
	if (!node || node->type() != LayerTreeNode::Type::Layer) return;

	auto* layerNode = static_cast<LayerTreeLayer*>(node);
	RasterLayer* mapLayer = static_cast<RasterLayer*>(layerNode->mapLayer());

	newImage(mapLayer, RasterImageLayer::RendererType::Multiband, node);
}

void HPPA::removeImageByTreeIndex()
{
	QModelIndex currentIndexTmp = m_layerTreeView->currentIndex();

	if (!currentIndexTmp.isValid()) return;

	LayerTreeModel* model = const_cast<LayerTreeModel*>(static_cast<const LayerTreeModel*>(currentIndexTmp.model()));
	if (!model) return;

	LayerTreeNode* node = static_cast<LayerTreeNode*>(currentIndexTmp.internalPointer());
	if (!node || node->type() != LayerTreeNode::Type::Image) return;

	auto* layerNode = static_cast<LayerTreeImageNode*>(node);
	RasterImageLayer* rasterImageLayer = layerNode->imageLayer();
	QWidget* layerWidget = nullptr;

	if (rasterImageLayer && m_MapLayerStore)
	{
		layerWidget = m_MapLayerStore->widgetForImageLayer(rasterImageLayer);
		m_MapLayerStore->removeImageLayer(rasterImageLayer);
	}

	if (layerWidget && m_imageViewerTabWidget)
	{
		const int tabIndex = m_imageViewerTabWidget->indexOf(layerWidget);
		if (tabIndex >= 0)
		{
			if (m_recordFrameCounter)
			{
				m_recordFrameCounter->removeCounter(layerWidget);
			}
			m_imageViewerTabWidget->removeTab(tabIndex);
		}
		layerWidget->deleteLater();
	}

	LayerTreeNode* parent = node->parentNode();
	int row = node->rowInParent();
	LayerTreeNode* removed = model->removeNode(parent, row);
	if (removed)
	{
		delete removed;
	}
}

void HPPA::removeAllLayersInRasterGroup()
{
    if (!m_LayerTreeModel || !m_RasterGroup) return;

    QVector<LayerTreeNode*> pending;
    for (int i = 0; i < m_RasterGroup->childCount(); ++i)
    {
        pending.push_back(m_RasterGroup->childAt(i));
    }

    while (!pending.isEmpty())
    {
        LayerTreeNode* node = pending.back();
        pending.pop_back();
        if (!node) continue;

		removeLayerByNode(node);
    }
}

void HPPA::initPanelToolbar()
{
	mPanelMenu = new QMenu(QString::fromLocal8Bit("面板"), this);//create panel menu
	mPanelMenu->setObjectName(QStringLiteral("mPanelMenu"));
	mToolbarMenu = new QMenu(QString::fromLocal8Bit("工具栏"), this);//create toolbar menu
	mToolbarMenu->setObjectName(QStringLiteral("mToolbarMenu"));

	ui.mWindowsMenu->addSeparator();
	ui.mWindowsMenu->addMenu(mPanelMenu);
	ui.mWindowsMenu->addMenu(mToolbarMenu);

	mPanelMenu->setStyleSheet(R"(
        QMenu {
            background-color: #0A1245;  /* 菜单背景色 */
            border: 1px solid gray;   /* 可选，边框样式 */
			color: white;  /* 根据你的背景调整文字颜色 */
        }
		QMenu::item:selected {
            background-color: rgba(255, 255, 255, 50); /* 选中时的背景色 */
            color: white;              /* 选中项字体颜色，可选 */
        }
	)");
	mToolbarMenu->setStyleSheet(R"(
        QMenu {
            background-color: #0A1245;  /* 菜单背景色 */
            border: 1px solid gray;   /* 可选，边框样式 */
			color: white;  /* 根据你的背景调整文字颜色 */
        }
		QMenu::item:selected {
            background-color: rgba(255, 255, 255, 50); /* 选中时的背景色 */
            color: white;              /* 选中项字体颜色，可选 */
        }
	)");

	mPanelMenu->addAction(ui.mDockWidgetSpectrometer->toggleViewAction());

	mPanelMenu->addAction(ui.mDockWidgetSimulator->toggleViewAction());

	mToolbarMenu->addAction(ui.mainToolBar->toggleViewAction());
}

void HPPA::initMapTools()
{
	ui.mActionPan->setCheckable(true);
	ui.mActionSpectral->setCheckable(true);

	m_mapToolActionGroup = new QActionGroup(this);
	m_mapToolActionGroup->addAction(ui.mActionPan);
	m_mapToolActionGroup->addAction(ui.mActionSpectral);
	m_mapToolActionGroup->setExclusive(true);

	m_mapTools = new MapTools(this);
	m_mapTools->mapToolPan()->setAction(ui.mActionPan);
	m_mapTools->mapToolSpectral()->setAction(ui.mActionSpectral);

	connect(m_mapTools->mapToolSpectral(), SIGNAL(spectralClicked(int,int,QVector<double>,QVector<double>)),
		this, SLOT(onLeftMouseButtonPressed(int,int,QVector<double>,QVector<double>)));

	connect(ui.mActionPan, SIGNAL(triggered()), this, SLOT(onMapToolPanTriggered()));
	connect(ui.mActionSpectral, SIGNAL(triggered()), this, SLOT(onMapToolSpectralTriggered()));

	// Default tool: pan
	ui.mActionPan->trigger();
}

void HPPA::onMapToolPanTriggered()
{
	m_mapTools->setActiveTool(m_mapTools->mapToolPan());
	setMapTool();
}

void HPPA::onMapToolSpectralTriggered()
{
	m_mapTools->setActiveTool(m_mapTools->mapToolSpectral());
	setMapTool();
}

void HPPA::setMapTool()
{
	int tmp = m_imageViewerTabWidget->count();
	if (tmp == 0) return;

	int currentIndex = m_imageViewerTabWidget->currentIndex();
	onTabWidgetCurrentChanged(currentIndex);
}

//----------------------------------------------------
void HPPA::createScenarioActionGroup()
{
	m_ScenarioActionGroup = new QActionGroup(this);
	m_ScenarioActionGroup->addAction(ui.mActionOneMotorScenario);
	m_ScenarioActionGroup->addAction(ui.mActionPlantPhenotypeScenario);
	m_ScenarioActionGroup->addAction(ui.mAction3DPlantPhenotypeScenario);
	m_ScenarioActionGroup->addAction(ui.mActionMicroscopicMotionControlScenario);

	// 读取上次选择的结果
	QSettings settings;
	QString lastSelectedAction = settings.value("LastSelectedScenario").toString();

	// 恢复上次选择的结果
	if (lastSelectedAction == "mActionOneMotorScenario")
	{
		ui.mActionOneMotorScenario->setChecked(true);
		ui.mActionOneMotorScenario->trigger();
	}
	else if (lastSelectedAction == "mActionPlantPhenotypeScenario")
	{
	 ui.mActionPlantPhenotypeScenario->setChecked(true);
	 ui.mActionPlantPhenotypeScenario->trigger();
	}
	else if (lastSelectedAction == "mAction3DPlantPhenotypeScenario")
	{
		ui.mAction3DPlantPhenotypeScenario->setChecked(true);
		ui.mAction3DPlantPhenotypeScenario->trigger();
	}
	else if (lastSelectedAction == "mActionMicroscopicMotionControlScenario")
	{
		ui.mActionMicroscopicMotionControlScenario->setChecked(true);
		ui.mActionMicroscopicMotionControlScenario->trigger();
	}
}

void HPPA::selectScenario(QAction* selectedAction)
{
	QSettings settings;
	settings.setValue("LastSelectedScenario", selectedAction->objectName());
	settings.sync();
}

void HPPA::onCreated3DModelOneMotor()
{
	connect(m_omc, SIGNAL(broadcastLocationSignal(std::vector<double>)), m_view3DModelManager->m_viewMotor, SLOT(setLoc(std::vector<double>)));
}

void HPPA::createOneMotorScenario()
{
	//if (ui.mActionOneMotorScenario->isChecked())
	//	return;

	//清除所有DockWidget
	//QList<QDockWidget*> dockWidgets = this->findChildren<QDockWidget*>();
	//for (QDockWidget* dock : dockWidgets)
	//{
	//	dock->hide();
	//}

	//在菜单中选择移动平台
	ui.mAction_1AxisMotor->setChecked(true);

	//右下角控制tab
	m_tabManager->hideAllTabs();

	m_tabManager->showTab(m_hic);
	m_tabManager->showTab(m_ic);
	m_tabManager->showTab(m_omc);

	m_view3DModelManager->switchScenario(View3DModelManager::ScenarioType::OneMotor);

	//右上角轮播

}

void HPPA::onCreated3DModelPlantPhenotype()
{
	connect(m_tmc, SIGNAL(broadcastLocationSignal(std::vector<double>)), m_view3DModelManager->m_viewPlant, SLOT(setLoc(std::vector<double>)));
}

void HPPA::onCreated3DModelMicroscopicMotion()
{
	connect(m_tmc, SIGNAL(broadcastLocationSignal(std::vector<double>)), m_view3DModelManager->m_viewMicroscopicMotionControlModel, SLOT(setLoc(std::vector<double>)));
}

void HPPA::createPlantPhenotypeScenario()
{
	//if (ui.mActionPlantPhenotypeScenario->isChecked())
	//	return;

	//在菜单中选择移动平台
	ui.mAction_2AxisMotor_new->setChecked(true);

	//右下角控制tab
	m_tabManager->hideAllTabs();

	m_tabManager->showTab(m_hic);
	m_tabManager->showTab(m_ic);
	m_tabManager->showTab(m_rgbCameraControlWindow);
	m_tabManager->showTab(m_adt);
	m_tabManager->showTab(m_pc);
	m_tabManager->showTab(m_tmc);

	m_view3DModelManager->switchScenario(View3DModelManager::ScenarioType::PlantPhenotype);

	//右上角轮播

}

void HPPA::create3DPlantPhenotypeScenario()
{
	//if (ui.mAction3DPlantPhenotypeScenario->isChecked())
	//	return;

	//在菜单中选择移动平台
	ui.mAction_2AxisMotor_new->setChecked(true);

	//右下角控制tab
	m_tabManager->hideAllTabs();

	m_tabManager->showTab(m_hic);
	m_tabManager->showTab(m_ic);
	m_tabManager->showTab(m_depthCameraWindow);
	m_tabManager->showTab(m_singleLensReflexCameraWindow);
	//m_tabManager->showTab(m_rgbCameraControlWindow);
	m_tabManager->showTab(m_adt);
	m_tabManager->showTab(m_pc);
	m_tabManager->showTab(m_tmc);

	m_view3DModelManager->switchScenario(View3DModelManager::ScenarioType::PlantPhenotype);

	//右上角轮播

}

void HPPA::createMicroscopicMotionControlScenario()
{
	//if (ui.mActionMicroscopicMotionControl->isChecked())
	//	return;

	//在菜单中选择移动平台
	ui.mAction_2AxisMotor_new->setChecked(true);

	//右下角控制tab
	m_tabManager->hideAllTabs();

	m_tabManager->showTab(m_hic);
	m_tabManager->showTab(m_ic);
	m_tabManager->showTab(m_tmc);

	m_view3DModelManager->switchScenario(View3DModelManager::ScenarioType::MicroscopicMotionControl);

	//右上角轮播

}

bool HPPA::testImagerVality()
{
	try
	{
		if (m_Imager == nullptr)
		{
			return false;
		}
		double framerate = m_Imager->getFramerate();
		m_Imager->setFramerate(framerate);

		return true;
	}
	catch (const std::exception& e)
	{
		disconnectImagerAndCleanup();
		return false;
	}
	catch (int e)//ximea相机异常
	{
		disconnectImagerAndCleanup();
		return false;
	}
	catch (...)
	{
		disconnectImagerAndCleanup();
		return false;
	}
}

void HPPA::showMessageBox(QString msg, QString title)
{
	QMessageBox msgBox(this);
	msgBox.setWindowTitle(title);
	msgBox.setText(msg);
	msgBox.setStyleSheet(R"(
			QMessageBox {
				background-color: #0D1233;
			}
			QMessageBox QLabel {
				color: #ACCDFF;
				font-size: 14px;
			}
			QPushButton {
				background-color: #142D7F;
				color: #e6eeff;
				border: 1px solid #2f6bff;
				border-radius: 6px;
				padding: 6px 20px;
				min-width: 60px;
				font-size: 13px;
			}
			QPushButton:hover {
				border: 1px solid #4d8dff;
				background-color: red;
			}
			QPushButton:pressed {
				background-color: #23345c;
			}
		)");

	msgBox.exec();
}

bool HPPA::showResultMessageBox(QString title, QString msg)
{
	QMessageBox msgBox(this);
	msgBox.setWindowTitle(title);
	msgBox.setText(msg);
	msgBox.setStandardButtons(QMessageBox::Yes | QMessageBox::No);
	msgBox.setDefaultButton(QMessageBox::No);
	msgBox.setStyleSheet(R"(
		QMessageBox {
			background-color: #0D1233;
		}
		QMessageBox QLabel {
			color: #ACCDFF;
			font-size: 14px;
		}
		QPushButton {
			background-color: #142D7F;
			color: #e6eeff;
			border: 1px solid #2f6bff;
			border-radius: 6px;
			padding: 6px 20px;
			min-width: 60px;
			font-size: 13px;
		}
		QPushButton:hover {
			border: 1px solid #4d8dff;
			background-color: red;
		}
		QPushButton:pressed {
			background-color: #23345c;
		}
	)");

	QMessageBox::StandardButton ret = static_cast<QMessageBox::StandardButton>(msgBox.exec());

	if (ret == QMessageBox::Yes)
	{
		return true;
	}
	else
	{
		return false;
	}
}

void HPPA::onStartRecordStep1()
{
	//判断移动平台
	QAction* checked = moveplatformActionGroup->checkedAction();
	if (!checked)
	{
		showMessageBox(QString::fromLocal8Bit("请选择扫描平台！"));
		return;
	}

	QString checkedName = checked->objectName();
	if (checkedName == "mAction_is_no_motor")
	{

	}
	else if (checkedName == "mAction_1AxisMotor")
	{
		if (!m_omc->getMotorsConnectionStatus())
		{
			showMessageBox(QString::fromLocal8Bit("找不到马达！"));
			return;
		}
	}
	else if (checkedName == "mAction_2AxisMotor_new")
	{
		if (!m_tmc->getMotorsConnectionStatus())
		{
			showMessageBox(QString::fromLocal8Bit("找不到马达！"));
			return;
		}
	}
	else if (checkedName == "mAction_RobotArm")
	{

	}

	//判断光谱仪
	if(!testImagerVality())
	{
		showMessageBox(QString::fromLocal8Bit("找不到光谱仪！"));

		return;
	}

	//判断是否覆盖存在的文件
	string imgPath = (AppSettings::instance().dataFolder() + QDir::separator() + AppSettings::instance().fileName()).toStdString();
	string x_location = removeFileExtension(imgPath) + "_x_location.pos";

	m_RecordState += 1;
	if (m_RecordState % 2 == 1)
	{
		m_RecordState -= 1;

		string tmp = imgPath + "_" + std::to_string(0) + ".bil";
		int x = _access(tmp.c_str(), 0);
		if (!x)//如果文件存在就执行此if的代码
		{
			bool res = showResultMessageBox(QString::fromLocal8Bit("提示"), QString::fromLocal8Bit("文件存在！是否覆盖？"));
			if (!res)
			{
				return;
			}
		}
	}
	else
	{
		m_RecordState -= 1;
	}

	
	if (checkedName == "mAction_is_no_motor")
	{
		m_RecordState += 1;

		if (m_RecordState % 2 == 1)
		{
			//m_imageViewerTabWidget->clear();
			removeAllLayersInRasterGroup();

			emit updateRecordingFileInfoSignal(AppSettings::instance().dataFolder(), AppSettings::instance().fileName(), this->frame_number->text().toInt());
			emit StartRecordSignal();//发射开始采集信号

			ui.action_start_recording->setText(QString::fromLocal8Bit("停止采集"));
			ui.action_start_recording->setIcon(QIcon(":/svg/resources/icons/svg/record_ing.svg"));
			//ui.mainToolBar->widgetForAction(ui.action_start_recording)->setStyleSheet("QWidget{background-color:rgb(255,0,0);}");
		}
		else
		{
			m_Imager->setRecordControlState(false);//光谱仪停止采集
			m_RecordState -= 1;

			ui.action_start_recording->setText(QString::fromLocal8Bit("采集"));
			ui.action_start_recording->setIcon(QIcon(":/svg/resources/icons/svg/record_done.svg"));
			//ui.mainToolBar->widgetForAction(ui.action_start_recording)->setStyleSheet("QWidget{background-color:rgb(0,255,0);}");
		}
		return;
	}
	else if (checkedName == "mAction_1AxisMotor")
	{
		m_RecordState += 1;

		if (m_RecordState % 2 == 1)
		{
			//m_imageViewerTabWidget->clear();
			removeAllLayersInRasterGroup();

			ui.action_start_recording->setText(QString::fromLocal8Bit("停止采集"));
			ui.action_start_recording->setIcon(QIcon(":/svg/resources/icons/svg/record_ing.svg"));
			//ui.mainToolBar->widgetForAction(ui.action_start_recording)->setStyleSheet("QWidget{background-color:rgb(255,0,0);}");

			//应该先控制马达运动，当马达运动后，再开始光谱仪采集（发射开始采集信号）
			emit updateRecordingFileInfoSignal(AppSettings::instance().dataFolder(), AppSettings::instance().fileName(), this->frame_number->text().toInt());
			m_omc->setImager(m_Imager);
			m_omc->run();
		}
		else
		{
			m_omc->stop();
			m_RecordState -= 1;

			ui.action_start_recording->setText(QString::fromLocal8Bit("采集"));
			ui.action_start_recording->setIcon(QIcon(":/svg/resources/icons/svg/record_done.svg"));
			//ui.mainToolBar->widgetForAction(ui.action_start_recording)->setStyleSheet("QWidget{background-color:rgb(0,255,0);}");
		}
		return;
	}
	else if (checkedName == "mAction_2AxisMotor_new")
	{
		m_RecordState += 1;

		if (m_RecordState % 2 == 1)
		{
			//m_imageViewerTabWidget->clear();
			removeAllLayersInRasterGroup();

			ui.action_start_recording->setText(QString::fromLocal8Bit("停止采集"));
			ui.action_start_recording->setIcon(QIcon(":/svg/resources/icons/svg/record_ing.svg"));
			//ui.mainToolBar->widgetForAction(ui.action_start_recording)->setStyleSheet("QWidget{background-color:rgb(255,0,0);}");

			emit updateRecordingFileInfoSignal(AppSettings::instance().dataFolder(), AppSettings::instance().fileName(), this->frame_number->text().toInt());
			m_tmc->setImager(m_Imager);
			m_tmc->setPosFileName(QString::fromStdString(x_location));
			m_tmc->run();
		}
		else
		{
			 m_tmc->stop();

			 m_RecordState--;

			 ui.action_start_recording->setText(QString::fromLocal8Bit("采集"));
			 ui.action_start_recording->setIcon(QIcon(":/svg/resources/icons/svg/record_done.svg"));
			 //ui.mainToolBar->widgetForAction(ui.action_start_recording)->setStyleSheet("QWidget{background-color:rgb(0,255,0);}");
		}

		return;
	}
	else if (checkedName == "mAction_RobotArm")
	{
		//先判断是否选择了任务，执行函数RobotArmControl::executeTask，修复界面显示bug
		emit updateRecordingFileInfoSignal(AppSettings::instance().dataFolder(), AppSettings::instance().fileName(), this->frame_number->text().toInt());
		m_rac->executeTaskWithHyperImager();

		return;
	}
}

QWidget* HPPA::onCreateTab(QString tabName)
{
    QWidget* tabTmp = new QWidget();

    QGridLayout* GridLayout = new QGridLayout();
    GridLayout->addWidget(new Mapcavas(tabTmp));

    tabTmp->setLayout(GridLayout);

    m_imageViewerTabWidget->addTab(tabTmp, tabName);

	m_imageViewerTabWidget->setCurrentIndex(m_imageViewerTabWidget->count() - 1);

	if (m_recordFrameCounter)
	{
		m_recordFrameCounter->addCounter(tabTmp);
	}

	return tabTmp;
}

void HPPA::onTabWidgetCurrentChanged(int index)//代码新建一个tab，会调用onTabWidgetCurrentChanged函数！
{
    if (index < 0)//当删除所有tab时，index=-1
    {
        return;
    }

    //记录当前
    m_TabWidgetCurrentIndex = index;

    if (m_recordFrameCounter)
    {
        QWidget* currentWidget = m_imageViewerTabWidget->widget(index);
        m_recordFrameCounter->switchTo(currentWidget);
    }

    //获取绘图控件
    QWidget* currentWidget = m_imageViewerTabWidget->widget(index);
    QList<Mapcavas*> currentImageViewer = currentWidget->findChildren<Mapcavas*>();

    // Re-apply the current active map tool to the new canvas
    Mapcavas* canvas = currentImageViewer[0];
    m_mapTools->setMapcavas(canvas);

    MapTool* activeTool = m_mapTools->activeTool();
    if (activeTool)
    {
        canvas->setMapTool(activeTool);
    }

	// Sync layer tree view selection with the current tab
	if (m_MapLayerStore && m_layerTreeView && m_LayerTreeModel && m_RasterGroup)
	{
		MapLayer* layer = m_MapLayerStore->mapLayerForWidget(currentWidget);
		if (layer)
		{
			// Find the LayerTreeLayer node in m_RasterGroup that matches this layer
			for (int i = 0; i < m_RasterGroup->childCount(); ++i)
			{
				LayerTreeNode* child = m_RasterGroup->childAt(i);
				if (child && child->type() == LayerTreeNode::Type::Layer)
				{
					auto* layerNode = static_cast<LayerTreeLayer*>(child);
					if (layerNode->mapLayer() == layer)
					{
						QModelIndex nodeIndex = m_LayerTreeModel->index(i, 0,
							m_LayerTreeModel->index(m_RasterGroup->rowInParent(), 0));
						// Block signals to avoid infinite loop with onLayerTreeSelectionChanged
						m_layerTreeView->selectionModel()->blockSignals(true);
						m_layerTreeView->setCurrentIndex(nodeIndex);
						m_layerTreeView->selectionModel()->blockSignals(false);

						// Manually update ImageControl since we blocked the signal
						QList<Mapcavas*> mapcavas = currentWidget->findChildren<Mapcavas*>();
						if (!mapcavas.isEmpty()) {
							m_ic->setActiveLayer(mapcavas[0]->imageLayer());
						}
						break;
					}
				}
			}
		}
	}
}

void HPPA::onActionOpenDirectory()
{
	FileOperation* fileOperation = new FileOperation();
	string directory = fileOperation->getDirectoryFromString();

	QDesktopServices::openUrl(QUrl::fromLocalFile(QString::fromStdString(directory)));
}

void HPPA::onFramerateChanged(double framerate)
{
	if (!m_Imager) return;
	m_Imager->setFramerate(framerate);
	m_hic->setFrameRate(m_Imager->getFramerate());
}

void HPPA::onIntegrationTimeChanged(double integrationTime)
{
	if (!m_Imager) return;
	m_Imager->setIntegrationTime(integrationTime);
	m_hic->setIntegrationTime(m_Imager->getIntegrationTime());
}

void HPPA::onGainChanged(double gain)
{
	if (!m_Imager) return;
	m_Imager->setGain(gain);
	m_hic->setGain(m_Imager->getGain());
}

void HPPA::onLeftMouseButtonPressed(int x, int y, QVector<double> wavelengths, QVector<double> spectrum)
{
	Q_UNUSED(x);
	Q_UNUSED(y);

	try
	{
		//正在采集时，不能显示光谱曲线
		if (m_RecordState % 2 == 1)
		{
			return;
		}

		if (spectrum.isEmpty())
		{
			return;
		}

		QLineSeries* series = new QLineSeries();

		const int count = qMin(wavelengths.size(), spectrum.size());
		if (count > 0)
		{
			for (int i = 0; i < count; ++i)
			{
				series->append(wavelengths[i], spectrum[i]);
			}
		}
		else
		{
			for (int i = 0; i < spectrum.size(); ++i)
			{
				series->append(i, spectrum[i]);
			}
		}

		series->setPen(QPen(QColor("#FF928A"), 2));

		m_chart->removeAllSeries();
		m_chart->addSeries(series);
		m_chart->createDefaultAxes();

		QValueAxis* axisX = qobject_cast<QValueAxis*>(m_chart->axisX());
		QValueAxis* axisY = qobject_cast<QValueAxis*>(m_chart->axisY());

		setAxis(axisX, axisY);
	}
	catch (const std::exception&)
	{
		std::cout << "显示光谱有错误！" << std::endl;
	}

}

void HPPA::setAxis(QValueAxis* axisX, QValueAxis* axisY)
{
	if (axisX && axisY)
	{
		QPen axisPen(QColor("#ACCDFF"));
		axisPen.setWidth(1);

		// 坐标轴线颜色
		axisX->setLinePen(axisPen);
		axisY->setLinePen(axisPen);

		// 坐标标签颜色
		axisX->setLabelsColor(QColor("#ACCDFF"));
		axisY->setLabelsColor(QColor("#ACCDFF"));

		// 网格线颜色
		QPen gridPen(QColor("#262A4C"));
		gridPen.setStyle(Qt::DashLine);
		gridPen.setWidth(2);
		axisX->setGridLinePen(gridPen);
		axisY->setGridLinePen(gridPen);
	}
}

void HPPA::timerEvent(QTimerEvent* event)
{
}

void HPPA::setImagerSimulationPos(double x, double y)
{
	x = widthScale * x;
	y = heightScale * y;
	//ui.graphicsView->imager->setPos(x, y);
}

void HPPA::onimagerSimulatorMove(int x, int y)
{
}

void HPPA::OnSendLogToCallClass(QString str)
{
	qDebug() << str;
}

void HPPA::onPlotRgbImage()
{
	//std::cout << "显示视频+++++++++++++++++++++++++++++++++++++++++++" << std::endl;
	QPixmap pixmap = QPixmap::fromImage(m_rgbCameraControlWindow->m_RgbCamera->m_qImage);

	int width = m_cam_label->width();
	int height = m_cam_label->height();
	QPixmap fitpixmap = pixmap.scaled(width, height, Qt::KeepAspectRatio, Qt::SmoothTransformation); //按比例缩放    

	m_cam_label->setPixmap(fitpixmap);
}

void HPPA::onClearLabel()
{
	m_cam_label->clear();
	m_cam_label->setText("closed");
}

void HPPA::onLiveViewImageReady(const QImage& image)
{
	if (m_SingleLensReflexCamera_label && !image.isNull())
	{
		// 缩放图像以适应标签大小
		QPixmap pixmap = QPixmap::fromImage(image);
		pixmap = pixmap.scaled(m_SingleLensReflexCamera_label->size(), Qt::KeepAspectRatio, Qt::SmoothTransformation);
		m_SingleLensReflexCamera_label->setPixmap(pixmap);
	}
}

void HPPA::onLiveViewStopped()
{
	m_SingleLensReflexCamera_label->clear();
}

void HPPA::onPlotDepthImage()
{
	QPixmap pixmap = QPixmap::fromImage(m_depthCameraWindow->m_DepthCameraOperation->m_depthImage);

	int width = m_depthCamera_label->width();
	int height = m_depthCamera_label->height();
	QPixmap fitpixmap = pixmap.scaled(width, height, Qt::KeepAspectRatio, Qt::SmoothTransformation);

	m_depthCamera_label->setPixmap(fitpixmap);
}

void HPPA::onClearDepthLabel()
{
	m_depthCamera_label->clear();
	m_depthCamera_label->setText("closed");
}

void HPPA::onCopyFinished()
{
	this->setEnabled(true);
}

void HPPA::getRequest(QString str)
{
	QNetworkRequest request;
	QNetworkAccessManager* naManager = new QNetworkAccessManager(this);
	QMetaObject::Connection connRet = QObject::connect(naManager, SIGNAL(finished(QNetworkReply*)), this, SLOT(requestFinished(QNetworkReply*)));
	Q_ASSERT(connRet);

	request.setUrl(QUrl(str));
	QNetworkReply* reply = naManager->get(request);
}

void HPPA::requestFinished(QNetworkReply* reply) {
	// 获取http状态码
	QVariant statusCode = reply->attribute(QNetworkRequest::HttpStatusCodeAttribute);
	if (statusCode.isValid())
		qDebug() << "status code=" << statusCode.toInt();

	QVariant reason = reply->attribute(QNetworkRequest::HttpReasonPhraseAttribute).toString();
	if (reason.isValid())
		qDebug() << "reason=" << reason.toString();

	QNetworkReply::NetworkError err = reply->error();
	if (err != QNetworkReply::NoError) {
		qDebug() << "Failed: " << reply->errorString();
	}
	else {
		// 获取返回内容
		qDebug() << reply->readAll();
	}
}

void HPPA::onExit()
{
	this->close();
}

void HPPA::closeEvent(QCloseEvent* event)
{
	bool res = showResultMessageBox(QString::fromLocal8Bit("退出确认"), QString::fromLocal8Bit("确定要退出程序吗？"));
	if (res)
	{
		event->accept();   // 允许关闭
	}
	else
	{
		event->ignore();   // 取消关闭
	}
}

void HPPA::onOpenImg()
{
	// 1) 弹出文件对话框获取uri
	QString uri = QFileDialog::getOpenFileName(this, tr("Open Image"), QString(), tr("Raster Files (*.bil *.bip *.tif *.tiff *.img *.bsq);;All Files (*)"));
	if (uri.isEmpty())
		return;

	//判断是否已经打开
	if (m_MapLayerStore->containsLayer(uri))
		return;

	// 2) 创建 RasterLayer，然后添加到图层管理器
	if (!m_LayerTreeModel || !m_RasterGroup)
	{
		QMessageBox::warning(this, tr("Error"), tr("Layer model is not initialized."));
		return;
	}

	QFileInfo fi(uri);
	QString baseName = fi.completeBaseName();

	addLayer(baseName, uri, true);
}

void HPPA::disconnectImagerAndCleanup()
{
	if (m_Imager == nullptr)
		return;

	// 如果正在采集，先停止
	if (m_RecordState % 2 == 1)
	{
		m_Imager->setRecordControlState(false);
		m_RecordState = 0;
	}

	// 断开所有与 m_Imager 相关的信号槽
	disconnect(m_Imager, nullptr, this, nullptr);
	disconnect(this, SIGNAL(StartFocusSignal()), m_Imager, SLOT(focus()));
	disconnect(this, SIGNAL(StartRecordSignal()), m_Imager, SLOT(start_record()));
	disconnect(this, &HPPA::updateRecordingFileInfoSignal, m_Imager, &ImagerOperationBase::updateRecordingFileInfo);
	disconnect(this, SIGNAL(RecordWhiteSignal()), m_Imager, SLOT(record_white()));
	disconnect(this, SIGNAL(RecordDarlSignal()), m_Imager, SLOT(record_dark()));

	// 断开 UI 控件与本类槽的连接（它们在 onconnect 中绑定，避免重复连接）
	disconnect(ui.action_auto_exposure, SIGNAL(triggered()), this, SLOT(onAutoExposure()));
	disconnect(ui.action_focus, SIGNAL(triggered()), this, SLOT(onFocus1()));
	disconnect(ui.action_dark, SIGNAL(triggered()), this, SLOT(onDark()));
	disconnect(ui.action_reference, SIGNAL(triggered()), this, SLOT(onReference()));
	disconnect(ui.action_start_recording, SIGNAL(triggered()), this, SLOT(onStartRecordStep1()));
	disconnect(ui.actionOpenDirectory, SIGNAL(triggered()), this, SLOT(onActionOpenDirectory()));
	disconnect(m_hic, SIGNAL(framerateChanged(double)), this, SLOT(onFramerateChanged(double)));
	disconnect(m_hic, SIGNAL(integrationTimeChanged(double)), this, SLOT(onIntegrationTimeChanged(double)));
	disconnect(m_hic, SIGNAL(gainChanged(double)), this, SLOT(onGainChanged(double)));

	// 停止采集线程
	if (m_RecordThread)
	{
		m_RecordThread->quit();
		m_RecordThread->wait(3000);
		delete m_RecordThread;
		m_RecordThread = nullptr;
	}

	// 停止文件拷贝线程
	if (m_CopyFileThread)
	{
		if (m_FileOperation)
		{
			disconnect(this, SIGNAL(CopyFileThreadSignal(QString, QString)), m_FileOperation, SLOT(copyFile(QString, QString)));
			disconnect(m_FileOperation, SIGNAL(CopyFinishedSignal()), this, SLOT(onCopyFinished()));
		}
		m_CopyFileThread->quit();
		m_CopyFileThread->wait(3000);
		delete m_FileOperation;
		m_FileOperation = nullptr;
		delete m_CopyFileThread;
		m_CopyFileThread = nullptr;
	}

	// 删除 imager 对象
	try
	{
		m_Imager->disconnectImager();
	}
	catch (...)
	{
		// 断连时忽略异常
	}
	delete m_Imager;
	m_Imager = nullptr;

	// 禁用相机参数控件
	frame_number->setEnabled(false);
	m_hic->setDisabled(true);

	// 重置图标
	ui.action_connect_imager->setIcon(QIcon(":/svg/resources/icons/svg/connect_imager.svg"));
	ui.action_auto_exposure->setIcon(QIcon(":/svg/resources/icons/svg/exposure.svg"));
	ui.action_dark->setIcon(QIcon(":/svg/resources/icons/svg/dark.svg"));
	ui.action_reference->setIcon(QIcon(":/svg/resources/icons/svg/reference.svg"));
	ui.action_start_recording->setIcon(QIcon(":/svg/resources/icons/svg/record.svg"));
	ui.action_start_recording->setText(QString::fromLocal8Bit("采集"));
}

void HPPA::onconnect()
{
	if (!testImagerVality())
	{
		disconnectImagerAndCleanup();
	}
	else
	{
		bool res = showResultMessageBox(QString::fromLocal8Bit("相机连接"), QString::fromLocal8Bit("确定要重连相机吗？"));
		if (res)
		{
			disconnectImagerAndCleanup();
		}
		else
		{
			return;
		}
	}

	try
	{
		//采集影像线程：放入新线程中采集以免在采集过程中界面卡死：https://www.cnblogs.com/xia-weiwen/p/10306089.html
		m_RecordThread = new QThread();

		//根据选择的相机类型创建对象mImagerGroup
		QString imagerSelected = mImagerGroup->checkedAction()->objectName();
		if (imagerSelected == "mActionPica_L")
		{
			m_Imager = new ResononPicaLImager();
		}
		else if (imagerSelected == "mActionPica_NIR")
		{
			m_Imager = new ResononNirImager();
		}
		else if (imagerSelected == "mActionPika_XC2")
		{
			m_Imager = new ResononPicaLImager();
		}
		else if (imagerSelected == "mActionCorning_410")
		{
			m_Imager = new Corning410Imager();
		}
		else
		{
			showMessageBox(QString::fromLocal8Bit("请选择相机类型！"));

			return;
		}

		ui.action_connect_imager->setIcon(QIcon(":/svg/resources/icons/svg/connect_imager_ing.svg"));

		m_Imager->moveToThread(m_RecordThread);
		m_RecordThread->start();

		
		connect(m_Imager, SIGNAL(PlotSignal(int, int, QString)), this, SLOT(onPlotHyperspectralImageRgbImage(int, int, QString)));
		connect(m_Imager, SIGNAL(RecordFinishedSignal_WhenFrameNumberMeet()), this, SLOT(onRecordFinishedSignal_WhenFrameNumberMeet()));
		connect(m_Imager, SIGNAL(RecordFinishedSignal_WhenFrameNumberNotMeet()), this, SLOT(onRecordFinishedSignal_WhenFrameNumberNotMeet()));
		connect(m_Imager, SIGNAL(SpectralSignal(int)), this, SLOT(focusPlotSpectralImg(int)));

		connect(m_Imager, SIGNAL(testImagerStatus()), this, SLOT(testImagerStatus()));
		connect(m_Imager, &ImagerOperationBase::autoExposureSignal, this, &HPPA::autoExposureFinished);

		m_Imager->connect_imager(frame_number->text().toInt());

		//文件拷贝
		m_CopyFileThread = new QThread();
		m_FileOperation = new FileOperation();
		m_FileOperation->moveToThread(m_CopyFileThread);
		m_CopyFileThread->start();
		connect(this, SIGNAL(CopyFileThreadSignal(QString, QString)), m_FileOperation, SLOT(copyFile(QString, QString)));
		connect(m_FileOperation, SIGNAL(CopyFinishedSignal()), this, SLOT(onCopyFinished()));

		//检测光谱仪连接状态
		m_TestImagerStausThread = new WorkerThread(m_Imager);


		connect(this->ui.action_auto_exposure, SIGNAL(triggered()), this, SLOT(onAutoExposure()));
		connect(this->ui.action_focus, SIGNAL(triggered()), this, SLOT(onFocus1()));
		connect(this, SIGNAL(StartFocusSignal()), m_Imager, SLOT(focus()));
		connect(this->ui.action_dark, SIGNAL(triggered()), this, SLOT(onDark()));
		connect(this->ui.action_reference, SIGNAL(triggered()), this, SLOT(onReference()));

		connect(this->ui.action_start_recording, SIGNAL(triggered()), this, SLOT(onStartRecordStep1()));
		connect(this, SIGNAL(StartRecordSignal()), m_Imager, SLOT(start_record()));
		connect(this, &HPPA::updateRecordingFileInfoSignal, m_Imager, &ImagerOperationBase::updateRecordingFileInfo);
		connect(this, SIGNAL(RecordWhiteSignal()), m_Imager, SLOT(record_white()));
		connect(this, SIGNAL(RecordDarlSignal()), m_Imager, SLOT(record_dark()));
		connect(m_Imager, SIGNAL(RecordWhiteFinishSignal()), this, SLOT(recordWhiteFinish()));
		connect(m_Imager, SIGNAL(RecordDarlFinishSignal()), this, SLOT(recordDarkFinish()));

		// Connect LayerFileCreated from imager to HPPA slot
		connect(m_Imager, SIGNAL(LayerFileCreated(QString,QString,int)), this, SLOT(onLayerCreatedFromFile(QString,QString,int)));

		connect(this->ui.actionOpenDirectory, SIGNAL(triggered()), this, SLOT(onActionOpenDirectory()));

		connect(m_hic, SIGNAL(framerateChanged(double)), this, SLOT(onFramerateChanged(double)));
		connect(m_hic, SIGNAL(integrationTimeChanged(double)), this, SLOT(onIntegrationTimeChanged(double)));
		connect(m_hic, SIGNAL(gainChanged(double)), this, SLOT(onGainChanged(double)));

		//相机参数控件设置为可用 + 输入控制
		frame_number->setEnabled(true);
		m_hic->setDisabled(false);

		/*QRegExp rx("\\d{0,3}[1-9]$");
		ui.framerate_lineEdit->setValidator(new QRegExpValidator(rx));
		frame_number->setValidator(new QRegExpValidator(rx));

		ui.integratioin_time_lineEdit->setValidator(new QRegExpValidator(rx));
		ui.gain_lineEdit->setValidator(new QRegExpValidator(rx));*/

		//获取相机参数并显示到界面中
		m_hic->setFrameRate(AppSettings::instance().frameRate());
		m_hic->setIntegrationTime(AppSettings::instance().integrationTime());
		m_hic->setGain(AppSettings::instance().gain());
	}
	catch (std::exception const& e)
	{
		ui.action_connect_imager->setIcon(QIcon(":/svg/resources/icons/svg/connect_imager.svg"));

		std::cerr << "Error: " << e.what() << std::endl;

		delete m_Imager;
		m_Imager = nullptr;

		showMessageBox(QString::fromLocal8Bit("请连接相机！"));
	}
	catch (int e)//ximea相机异常
	{
		ui.action_connect_imager->setIcon(QIcon(":/svg/resources/icons/svg/connect_imager.svg"));

		delete m_Imager;
		m_Imager = nullptr;

		showMessageBox(QString::fromLocal8Bit("请连接相机！"));
	}
}

void HPPA::testImagerStatus()
{
	ui.action_connect_imager->setIcon(QIcon(":/svg/resources/icons/svg/connect_imager_done.svg"));
	//m_TestImagerStausThread->start();
}

void HPPA::autoExposureFinished()
{
	ui.action_auto_exposure->setIcon(QIcon(":/svg/resources/icons/svg/exposure_done.svg"));
}

void HPPA::onAutoExposure()
{
	if (!testImagerVality())
	{
		showMessageBox(QString::fromLocal8Bit("找不到光谱仪！"));

		return;
	}

	ui.action_auto_exposure->setIcon(QIcon(":/svg/resources/icons/svg/exposure_ing.svg"));

	double ReturnedExposureTime = m_Imager->auto_exposure();

	//将自动曝光所得的值显示到界面
	m_hic->setIntegrationTime(ReturnedExposureTime);

	//ui.mainToolBar->widgetForAction(ui.action_auto_exposure)->setStyleSheet("QWidget{background-color:rgb(0,255,0);}");
}

void HPPA::onFocus1()
{
	if (!testImagerVality())
	{
		showMessageBox(QString::fromLocal8Bit("找不到光谱仪！"));

		return;
	}

	focusWindow* w = new focusWindow(this, m_Imager);
	connect(w, SIGNAL(StartManualFocusSignal(int)), this, SLOT(onFocus2(int)));
	connect(w, SIGNAL(closeSignal()), this, SLOT(onFocusWindowClosed()));

	w->setModal(true);//设置窗口为模态：只能操作当前窗口
	w->show();
	w->exec();

	//disconnect(w, SIGNAL(StartManualFocusSignal(int)), this, SLOT(onFocus2(int)));
}

void HPPA::onFocus2(int command)
{
	if (command == 1)
	{
		if (m_focusTab)
		{
			emit StartFocusSignal();
			return;
		}
		//创建影像显示窗口
		m_focusTab = new QWidget();

		QGridLayout* GridLayout = new QGridLayout();
		GridLayout->addWidget(new Mapcavas(m_focusTab));

		m_focusTab->setLayout(GridLayout);

		m_imageViewerTabWidget->addTab(m_focusTab, QString::fromLocal8Bit("调焦"));

		//m_imageViewerTabWidget->setCurrentIndex(trackNumber);
		m_imageViewerTabWidget->setCurrentWidget(m_focusTab);


		//开始调焦
		emit StartFocusSignal();
	}
	else if (command == 0)
	{
		if (m_Imager)
			m_Imager->setFocusControlState(false);
	}
}

void HPPA::onFocusWindowClosed()
{
	//关闭调焦窗口时，停止调焦功能
	if (m_Imager)
		m_Imager->setFocusControlState(false);
	//关闭调焦窗口tab
	int index = m_imageViewerTabWidget->indexOf(m_focusTab);
	if (index != -1)
	{
		m_imageViewerTabWidget->removeTab(index);
	}
	m_focusTab = nullptr;
}

void HPPA::onAbout()
{
	aboutWindow about;
	about.show();
	about.exec();
}

void HPPA::settingWindow()
{
	setWindow w;
	w.show();
	w.exec();
}

void HPPA::onDark()
{
	if (!testImagerVality())
	{
		showMessageBox(QString::fromLocal8Bit("找不到光谱仪！"));

		return;
	}

	showMessageBox(QString::fromLocal8Bit("采集暗电流，请确保镜头盖盖上！"));

	ui.action_dark->setIcon(QIcon(":/svg/resources/icons/svg/dark_ing.svg"));

	QAction* checked = moveplatformActionGroup->checkedAction();
	QString checkedName = checked->objectName();
	if (checkedName == "mAction_is_no_motor" || checkedName == "mAction_RobotArm")
	{
				emit RecordDarlSignal();
	}
	else if (checkedName == "mAction_1AxisMotor")
	{
		m_omc->setImager(m_Imager);
		m_omc->record_dark();
	}
	else if (checkedName == "mAction_2AxisMotor_new")
	{
		m_tmc->setImager(m_Imager);
		m_tmc->record_dark();
		return;
	}
}

void HPPA::recordDarkFinish()
{
	ui.action_dark->setIcon(QIcon(":/svg/resources/icons/svg/dark_done.svg"));
	//ui.mainToolBar->widgetForAction(ui.action_dark)->setStyleSheet("QWidget{background-color:rgb(0,255,0);}");
}

void HPPA::onReference()
{
	if (!testImagerVality())
	{
		showMessageBox(QString::fromLocal8Bit("找不到光谱仪！"));

		return;
	}

	showMessageBox(QString::fromLocal8Bit("请确保白板放置正确！"));

	ui.action_reference->setIcon(QIcon(":/svg/resources/icons/svg/reference_ing.svg"));

	QAction* checked = moveplatformActionGroup->checkedAction();
	QString checkedName = checked->objectName();
	if (checkedName == "mAction_is_no_motor" || checkedName == "mAction_RobotArm")
	{
		emit RecordWhiteSignal();
	}
	else if (checkedName == "mAction_1AxisMotor")
	{
		m_omc->setImager(m_Imager);
		m_omc->record_white();
	}
	else if (checkedName == "mAction_2AxisMotor_new")
	{
		m_tmc->setImager(m_Imager);
		m_tmc->record_white();
		return;
	}
}

void HPPA::recordWhiteFinish()
{
	ui.action_reference->setIcon(QIcon(":/svg/resources/icons/svg/reference_done.svg"));
	//ui.mainToolBar->widgetForAction(ui.action_reference)->setStyleSheet("QWidget{background-color:rgb(0,255,0);}");
}

void HPPA::onPlotHyperspectralImageRgbImage(int fileNumber, int frameNumber, QString filePath)
{
    if (!m_Imager) return;

    //使用机械臂采集时，会在停止采集后的瞬间又开始采集，会导致上次采集最后发射的信号调用此槽函数报错
    QAction* checked = moveplatformActionGroup->checkedAction();
    QString checkedName = checked->objectName();
    if (frameNumber == -1 && checkedName == "mAction_RobotArm")
    {
        return;
    }

	if (ui.mAction3DPlantPhenotypeScenario->isChecked())
		return;

    //return;
    //获取绘图控件
	QWidget* currentWidget = m_MapLayerStore->widgetForLayer(filePath);
    //QWidget* currentWidget = m_imageViewerTabWidget->widget(fileNumber);

    QList<Mapcavas*> currentImageViewer = currentWidget->findChildren<Mapcavas*>();
    currentImageViewer[0]->DisplayFrameNumber(m_Imager->getFrameCounter());//界面中显示已经采集的帧数

    if (m_recordFrameCounter)
    {
        m_recordFrameCounter->updateFrameCount(currentWidget, m_Imager->getFrameCounter());
    }

    //创建需要显示的图像--opencv版本
    ImageProcessor imageProcessor;
    //cv::Mat rgbImage(*m_Imager->getRgbImage()->m_matRgbImage, cv::Range(0, m_Imager->getFrameCounter()), cv::Range::all());//2022.3.18重构的
    cv::Mat rgbImage(*m_Imager->getMatRgbImage(), cv::Range(0, m_Imager->getFrameCounter()), cv::Range::all());
    cv::Mat rgbImageStretched = imageProcessor.CStretch(rgbImage, 0.02);

    //在界面中显示图像
    currentImageViewer[0]->SetImage(&QPixmap::fromImage(imageProcessor.Mat2QImage(rgbImageStretched)));//绘制图像

	//20241225
	//保存拉伸后的rgb
	//FileOperation* fileOperation = new FileOperation();
	//string directory = fileOperation->getDirectoryOfExe();
	//string rgbFilePathNoStrech = directory + "\\tmp_image_no_strech.png";//未拉伸图片
	//string rgbFilePathStrech = directory + "\\tmp_image_strech.png";//拉伸图片
	//cv::imwrite(rgbFilePathNoStrech, rgbImage);
	//cv::imwrite(rgbFilePathStrech, rgbImageStretched);

	//创建需要显示的图像--qt版本
	//QRect CuttedRect = m_Imager->getRgbImage()->m_matRgbImage->rect();//先获取image整个rect
	//CuttedRect.setHeight(m_Imager->getFrameCounter() - 1);//裁剪rect
	//QImage CuttedImage = m_Imager->getRgbImage()->m_matRgbImage->copy(CuttedRect);

	//currentImageViewer[0]->SetImage(&QPixmap::fromImage(CuttedImage));//绘制图像
}

void HPPA::focusPlotSpectralImg(int state)
{
    if (!m_Imager) return;

    if (state == 1)
    {
        //显示影像
        QWidget* currentWidget = m_imageViewerTabWidget->currentWidget();
        QList<Mapcavas*> currentImageViewer = currentWidget->findChildren<Mapcavas*>();
        currentImageViewer[0]->DisplayFrameNumber(m_Imager->getFocusFrameCounter());//界面中显示已经采集的帧数

		ImageProcessor imageProcessor;
		//cv::Mat grayImage(*m_Imager->getRgbImage()->m_matFocusGrayImage, cv::Range::all(), cv::Range::all());//2022.3.18重构的
		//cv::Mat grayImage(*m_Imager->getMatFocusGrayImage(), cv::Range::all(), cv::Range::all());
		//currentImageViewer[0]->SetImage(&QPixmap::fromImage(imageProcessor.Mat2QImage(grayImage)));//绘制图像

		currentImageViewer[0]->SetImage(&QPixmap::fromImage(m_Imager->getQImageFocusGrayImage()));//绘制图像

        //绘制光谱
        QLineSeries* series = new QLineSeries();
        //series->clear();//////////////////////////////
        int sampleCount = m_Imager->getSampleCount();
        for (size_t i = 0; i < sampleCount; i++)
        {
            //malloc申请的内存用法1：可以当做数组用
            //series->append(i, m_Imager->buffer[i + 5 * 900]);
            //series->append(i, m_Imager->buffer[900 * 150 + i]);
            series->append(i, m_Imager->buffer[1368 * 150 + i]);
        }

		series->setPen(QPen(QColor("#FF928A"), 2));

		m_chart->removeAllSeries();
		m_chart->addSeries(series);
		m_chart->createDefaultAxes();

		QValueAxis* axisX = qobject_cast<QValueAxis*>(m_chart->axisX());
		QValueAxis* axisY = qobject_cast<QValueAxis*>(m_chart->axisY());

		setAxis(axisX, axisY);
    }
	else
	{
		//改变界面上的按钮文字
	}



	////显示影像
	//QWidget* currentWidget = m_imageViewerTabWidget->currentWidget();
	//QList<ImageViewer *> currentImageViewer = currentWidget->findChildren<ImageViewer *>();
	//

	//ImageProcessor imageProcessor;
	//

	////绘制光谱
	//QLineSeries *series = new QLineSeries();
	////series->clear();//////////////////////////////
	//int sampleCount = m_Imager->getSampleCount();
	//

	//QChart *chart = new QChart();
	//chart->legend()->hide();
	//chart->addSeries(series);
	//chart->createDefaultAxes();
	////chart->setTitle("Simple line chart example");

	//m_chartView->setChart(chart);

	//while (state)
	//{
	//	currentImageViewer[0]->DisplayFrameNumber(m_Imager->getFocusFrameCounter());//界面中显示已经采集的帧数
	//	cv::Mat grayImage(*m_Imager->getMatFocusGrayImage(), cv::Range::all(), cv::Range::all());
	//	currentImageViewer[0]->SetImage(&QPixmap::fromImage(imageProcessor.Mat2QImage(grayImage)));//绘制图像

	//	for (size_t i = 0; i < sampleCount; i++)
	//	{
	//		//malloc申请的内存用法1：可以当做数组用
	//		//series->append(i, m_Imager->buffer[i + 5 * 900]);
	//		series->append(i, m_Imager->buffer[900 * 150 + i]);
	//	}
	//	std::cout << "-----------------------------------------------" << std::endl;
	//}

}

void HPPA::onRecordFinishedSignal_WhenFrameNumberMeet()
{
	QAction* checked = moveplatformActionGroup->checkedAction();
	QString checkedName = checked->objectName();

	if (checkedName == "mAction_2AxisMotor_new")//会有多条采集线，中间的某条采集线完成后不代表整个采集过程完成
	{
		return;
	}

	std::cout << "停止采集原因：帧数采集完了。" << std::endl;

	ui.action_start_recording->setText(QString::fromLocal8Bit("采集"));
	ui.action_start_recording->setIcon(QIcon(":/svg/resources/icons/svg/record_done.svg"));
	//ui.mainToolBar->widgetForAction(ui.action_start_recording)->setStyleSheet("QWidget{background-color:rgb(0,255,0);}");

	m_RecordState++;//当自动停止采集
}

void HPPA::onRecordFinishedSignal_WhenFrameNumberNotMeet()
{
	QAction* checked = moveplatformActionGroup->checkedAction();
	QString checkedName = checked->objectName();

	if (checkedName == "mAction_RobotArm")//机械臂会在停止采集后的瞬间又开始采集，导致ui.action_start_recording显示异常
	{
		return;
	}

	if (checkedName == "mAction_2AxisMotor_new")//会有多条采集线，中间的某条采集线完成后不代表整个采集过程完成
	{
		return;
	}

	std::cout << "停止采集原因：（1）帧数没有采集够时，马达到达最大位置；（2）手动停止采集。" << std::endl;

	ui.action_start_recording->setText(QString::fromLocal8Bit("采集"));
	ui.action_start_recording->setIcon(QIcon(":/svg/resources/icons/svg/record_done.svg"));
	//ui.mainToolBar->widgetForAction(ui.action_start_recording)->setStyleSheet("QWidget{background-color:rgb(0,255,0);}");

	m_RecordState++;
}

void HPPA::onsequenceComplete()
{
	ui.action_start_recording->setText(QString::fromLocal8Bit("采集"));
	ui.action_start_recording->setIcon(QIcon(":/svg/resources/icons/svg/record_done.svg"));
	//ui.mainToolBar->widgetForAction(ui.action_start_recording)->setStyleSheet("QWidget{background-color:rgb(0,255,0);}");

	m_RecordState++;
}

WorkerThread3::WorkerThread3(CFocusMotorControl* ctrlFocusMotor)
{
	m_ctrlFocusMotor = ctrlFocusMotor;
}

void WorkerThread3::run()
{
	m_ctrlFocusMotor->StartAutoFocus(820, 910, 20, 2);

	emit AutoFocusFinishedSignal();
}

void HPPA::onLayerCreatedFromFile(const QString& baseName, const QString& filePath, int fileIndex)
{
    if (!m_LayerTreeModel || !m_RasterGroup) return;

	if (ui.mAction3DPlantPhenotypeScenario->isChecked())
	{
		addLayer(baseName, filePath, false, false);
	}
	else
	{
		addLayer(baseName, filePath, false);
	}
}

void HPPA::addLayer(const QString& baseName, const QString& filePath,bool refresh, bool isAddImage)
{
	// Create MapLayer first and attach it to a LayerTreeLayerNode
	RasterLayer* ml = new RasterLayer(baseName, filePath);

	auto* layerNode = new LayerTreeLayer(ml);
	LayerTreeNode* node = m_LayerTreeModel->addLayer(m_RasterGroup, layerNode);

	if (m_MapLayerStore) m_MapLayerStore->addLayer(ml);

	if (isAddImage)
	{
		newImage(ml, RasterImageLayer::RendererType::Multiband, node);
	}
}

void HPPA::newImage(RasterLayer* ml, RasterImageLayer::RendererType type, LayerTreeNode* parent, bool refresh)
{
	QWidget* mapcavasContainer = onCreateTab(ml->name());
	RasterImageLayer* rasterImageLayer = new RasterImageLayer(ml, type);
	QList<Mapcavas*> mapcavas = mapcavasContainer->findChildren<Mapcavas*>();
	mapcavas[0]->setImageLayer(rasterImageLayer);

	QString title = ml->name();
	if (type == RasterImageLayer::RendererType::Multiband)
	{
		title = title + "-RGB";
	}
	else if(type == RasterImageLayer::RendererType::Singleband)
	{
		title = title + "-GreyScale";
	}

	LayerTreeImageNode* imageNode = new LayerTreeImageNode(rasterImageLayer, title);
	LayerTreeNode* node2 = m_LayerTreeModel->addLayer(parent, imageNode);

	if (m_MapLayerStore) m_MapLayerStore->addImageLayer(ml, rasterImageLayer, mapcavasContainer);

	if (refresh)
	{
		mapcavas[0]->freshmap();
	}
}

void HPPA::onLayerTreeSelectionChanged(const QItemSelection& selected, const QItemSelection& deselected)
{
    Q_UNUSED(deselected);

    if (selected.indexes().isEmpty())
	{
        m_ic->setActiveLayer(nullptr);
        return;
    }

    QModelIndex idx = selected.indexes().first();
    if (!idx.isValid())
	{
        m_ic->setActiveLayer(nullptr);
        return;
    }

	LayerTreeNode* node = static_cast<LayerTreeNode*>(idx.internalPointer());

	if (!node || node->type() == LayerTreeNode::Type::Group)
	{
		m_ic->setActiveLayer(nullptr);
		return;
	}

	//后续工作：当选择图层树中的图层时，应该显示此图层的元数据
    if (!node || node->type() == LayerTreeNode::Type::Layer)
	{
        m_ic->setActiveLayer(nullptr);
        return;
    }

	if (!node || node->type() == LayerTreeNode::Type::Image)
	{
		auto* imageNode = static_cast<LayerTreeImageNode*>(node);
		RasterImageLayer* imageLayer = imageNode->imageLayer();
		MapLayer* mapLayer = imageLayer->layer();

		if (!mapLayer || mapLayer->layerType() != MapLayer::LayerType::Raster) {
			m_ic->setActiveLayer(nullptr);
			return;
		}

		if (m_MapLayerStore && m_imageViewerTabWidget)
		{
			QWidget* widget = m_MapLayerStore->widgetForImageLayer(imageLayer);
			if (widget)
			{
				int tabIndex = m_imageViewerTabWidget->indexOf(widget);
				if (tabIndex >= 0)
				{
					m_imageViewerTabWidget->setCurrentIndex(tabIndex);
				}
			}

			QList<Mapcavas*> mapcavas = widget->findChildren<Mapcavas*>();
			if (!mapcavas.isEmpty())
			{
				m_ic->setActiveLayer(mapcavas[0]->imageLayer());
			}
			else
			{
				m_ic->setActiveLayer(nullptr);
			}
		}
		else
		{
			m_ic->setActiveLayer(nullptr);
		}
	}
}

void HPPA::onBandSelectionChanged(double rWave, double gWave, double bWave)
{
    RasterImageLayer* imageLayer = m_ic->activeLayer();
    if (!imageLayer) return;

    auto params = imageLayer->multibandParams();
    params.rWave = rWave;
    params.gWave = gWave;
    params.bWave = bWave;
    imageLayer->setMultibandParams(params);

    if (!m_MapLayerStore) return;
    MapLayer* mapLayer = imageLayer->layer();
    QWidget* container = m_MapLayerStore->widgetForImageLayer(imageLayer);
    if (!container) return;

    QList<Mapcavas*> mapcavas = container->findChildren<Mapcavas*>();
    if (mapcavas.isEmpty()) return;

    mapcavas[0]->freshmap();
}