add

添加场景：3D植物表型，只涉及了部分界面

HPPA/AppSettings.cpp

@@ -2,6 +2,9 @@
 
 const QString AppSettings::kDefaultDataFolder = QStringLiteral("C:\\HPPA_image");
 const QString AppSettings::kDefaultFileName = QStringLiteral("test_image");
+const int AppSettings::kDefaultFrameRate = 20;
+const int AppSettings::kDefaultIntegrationTime = 1;
+const int AppSettings::kDefaultGain = 0;
 
 AppSettings::AppSettings()
 	: m_settings(QSettings::IniFormat, QSettings::UserScope,
@@ -33,3 +36,30 @@ void AppSettings::setFileName(const QString& path)
 {
 	m_settings.setValue("General/FileName", path);
 }
+
+int AppSettings::frameRate() const
+{
+	return m_settings.value("CameraParams/FrameRate", kDefaultFrameRate).toInt();
+}
+void AppSettings::setFrameRate(int value)
+{
+	m_settings.setValue("CameraParams/FrameRate", value);
+}
+
+int AppSettings::integrationTime() const
+{
+	return m_settings.value("CameraParams/IntegrationTime", kDefaultIntegrationTime).toInt();
+}
+void AppSettings::setIntegrationTime(int value)
+{
+	m_settings.setValue("CameraParams/IntegrationTime", value);
+}
+
+int AppSettings::gain() const
+{
+	return m_settings.value("CameraParams/Gain", kDefaultGain).toInt();
+}
+void AppSettings::setGain(int value)
+{
+	m_settings.setValue("CameraParams/Gain", value);
+}

HPPA/AppSettings.h

@@ -14,6 +14,18 @@ public:
 
 	QString fileName() const;
 	void setFileName(const QString& path);
+
+	// 帧率
+	int frameRate() const;
+	void setFrameRate(int value);
+
+	// 积分时间
+	int integrationTime() const;
+	void setIntegrationTime(int value);
+
+	// 增益
+	int gain() const;
+	void setGain(int value);
 	// 在此处添加更多参数的 getter/setter ...
 
 private:
@@ -26,4 +38,7 @@ private:
 	// 默认值
 	static const QString kDefaultDataFolder;
 	static const QString kDefaultFileName;
+	static const int kDefaultFrameRate;
+	static const int kDefaultIntegrationTime;
+	static const int kDefaultGain;
 };

HPPA/HPPA.cpp

@@ -2,16 +2,22 @@
 //#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;
 
@@ -111,6 +117,8 @@ HPPA::HPPA(QWidget* parent)
     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;
 
@@ -469,6 +477,7 @@ HPPA::HPPA(QWidget* parent)
 	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));
@@ -773,6 +782,10 @@ void HPPA::initControlTabwidget()
 	m_depthCameraWindow = new DepthCameraWindow();
 	ui.controlTabWidget->addTab(m_depthCameraWindow, QString::fromLocal8Bit("深度相机"));
 
+	//单反相机
+	m_singleLensReflexCameraWindow = new SingleLensReflexCameraWindow();
+	ui.controlTabWidget->addTab(m_singleLensReflexCameraWindow, QString::fromLocal8Bit("单反相机"));
+
 	//rgb相机
 	m_rgbCameraControlWindow = new rgbCameraWindow();
 	connect(m_rgbCameraControlWindow, &rgbCameraWindow::PlotRgbImageSignal, this, &HPPA::onPlotRgbImage);
@@ -812,8 +825,8 @@ void HPPA::initControlTabwidget()
 	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)));
+	//connect(m_ic, SIGNAL(bandSelectionChanged(double, double, double)),
+	//	this, SLOT(onBandSelectionChanged(double, double, double)));
 }
 
 void HPPA::recordFromRobotArm(int fileCounter)
@@ -1003,37 +1016,110 @@ void HPPA::removeLayerByTreeIndex()
     LayerTreeNode* node = static_cast<LayerTreeNode*>(currentIndexTmp.internalPointer());
     if (!node || node->type() != LayerTreeNode::Type::Layer) return;
 
-    auto* layerNode = static_cast<LayerTreeLayer*>(node);
-    MapLayer* mapLayer = layerNode->mapLayer();
-    QWidget* layerWidget = nullptr;
+	removeLayerByNode(node);
+}
 
-    if (mapLayer && m_MapLayerStore)
-    {
-        layerWidget = m_MapLayerStore->widgetForLayer(mapLayer);
-        m_MapLayerStore->removeLayer(mapLayer);
-    }
+void HPPA::removeLayerByNode(LayerTreeNode* node)
+{
+	if (!node || node->type() != LayerTreeNode::Type::Layer) return;
 
-    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();
-    }
+	auto* layerNode = static_cast<LayerTreeLayer*>(node);
+	MapLayer* mapLayer = layerNode->mapLayer();
 
-    LayerTreeNode* parent = node->parentNode();
-    int row = node->rowInParent();
-    LayerTreeNode* removed = model->removeNode(parent, row);
-    if (removed)
-    {
-        delete removed;
-    }
+	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()
@@ -1052,46 +1138,7 @@ void HPPA::removeAllLayersInRasterGroup()
         pending.pop_back();
         if (!node) continue;
 
-        for (int i = 0; i < node->childCount(); ++i)
-        {
-            pending.push_back(node->childAt(i));
-        }
-
-        if (node->type() != LayerTreeNode::Type::Layer) continue;
-
-        auto* layerNode = static_cast<LayerTreeLayer*>(node);
-        MapLayer* mapLayer = layerNode->mapLayer();
-        QWidget* layerWidget = nullptr;
-
-        if (mapLayer && m_MapLayerStore)
-        {
-            layerWidget = m_MapLayerStore->widgetForLayer(mapLayer);
-            m_MapLayerStore->removeLayer(mapLayer);
-        }
-
-        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();
-        }
-    }
-
-    while (m_RasterGroup->childCount() > 0)
-    {
-        const int row = m_RasterGroup->childCount() - 1;
-        LayerTreeNode* removed = m_LayerTreeModel->removeNode(m_RasterGroup, row);
-        if (removed)
-        {
-            delete removed;
-        }
+		removeLayerByNode(node);
     }
 }
 
@@ -1187,6 +1234,8 @@ 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;
@@ -1203,6 +1252,16 @@ void HPPA::createScenarioActionGroup()
 	 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)
@@ -1233,13 +1292,10 @@ void HPPA::createOneMotorScenario()
 	ui.mAction_1AxisMotor->setChecked(true);
 
 	//右下角控制tab
-	m_tabManager->hideTab(m_depthCameraWindow);
-	m_tabManager->hideTab(m_rgbCameraControlWindow);
-	m_tabManager->hideTab(m_adt);
-	m_tabManager->hideTab(m_pc);
-	m_tabManager->hideTab(m_rac);
-	m_tabManager->hideTab(m_tmc);
+	m_tabManager->hideAllTabs();
 
+	m_tabManager->showTab(m_hic);
+	m_tabManager->showTab(m_ic);
 	m_tabManager->showTab(m_omc);
 
 	m_view3DModelManager->switchScenario(View3DModelManager::ScenarioType::OneMotor);
@@ -1253,6 +1309,11 @@ 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())
@@ -1262,10 +1323,10 @@ void HPPA::createPlantPhenotypeScenario()
 	ui.mAction_2AxisMotor_new->setChecked(true);
 
 	//右下角控制tab
-	m_tabManager->hideTab(m_rac);
-	m_tabManager->hideTab(m_omc);
+	m_tabManager->hideAllTabs();
 
-	m_tabManager->showTab(m_depthCameraWindow);
+	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);
@@ -1277,6 +1338,53 @@ void HPPA::createPlantPhenotypeScenario()
 
 }
 
+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
@@ -1607,7 +1715,7 @@ void HPPA::onTabWidgetCurrentChanged(int index)//代码新建一个tab，会调
 	// Sync layer tree view selection with the current tab
 	if (m_MapLayerStore && m_layerTreeView && m_LayerTreeModel && m_RasterGroup)
 	{
-		MapLayer* layer = m_MapLayerStore->layerForWidget(currentWidget);
+		MapLayer* layer = m_MapLayerStore->mapLayerForWidget(currentWidget);
 		if (layer)
 		{
 			// Find the LayerTreeLayer node in m_RasterGroup that matches this layer
@@ -1627,10 +1735,9 @@ void HPPA::onTabWidgetCurrentChanged(int index)//代码新建一个tab，会调
 						m_layerTreeView->selectionModel()->blockSignals(false);
 
 						// Manually update ImageControl since we blocked the signal
-						RasterLayer* rl = qobject_cast<RasterLayer*>(layer);
-						if (rl)
-						{
-							m_ic->setActiveLayer(rl);
+						QList<Mapcavas*> mapcavas = currentWidget->findChildren<Mapcavas*>();
+						if (!mapcavas.isEmpty()) {
+							m_ic->setActiveLayer(mapcavas[0]->imageLayer());
 						}
 						break;
 					}
@@ -1863,6 +1970,10 @@ void HPPA::onOpenImg()
 	if (uri.isEmpty())
 		return;
 
+	//判断是否已经打开
+	if (m_MapLayerStore->containsLayer(uri))
+		return;
+
 	// 2) 创建 RasterLayer，然后添加到图层管理器
 	if (!m_LayerTreeModel || !m_RasterGroup)
 	{
@@ -2069,9 +2180,9 @@ void HPPA::onconnect()
 		ui.gain_lineEdit->setValidator(new QRegExpValidator(rx));*/
 
 		//获取相机参数并显示到界面中
-		m_hic->setFrameRate(m_Imager->getFramerate());
-		m_hic->setIntegrationTime(m_Imager->getIntegrationTime());
-		m_hic->setGain(m_Imager->getGain());
+		m_hic->setFrameRate(AppSettings::instance().frameRate());
+		m_hic->setIntegrationTime(AppSettings::instance().integrationTime());
+		m_hic->setGain(AppSettings::instance().gain());
 	}
 	catch (std::exception const& e)
 	{
@@ -2294,6 +2405,9 @@ void HPPA::onPlotHyperspectralImageRgbImage(int fileNumber, int frameNumber, QSt
         return;
     }
 
+	if (ui.mAction3DPlantPhenotypeScenario->isChecked())
+		return;
+
     //return;
     //获取绘图控件
 	QWidget* currentWidget = m_MapLayerStore->widgetForLayer(filePath);
@@ -2487,10 +2601,18 @@ void WorkerThread3::run()
 void HPPA::onLayerCreatedFromFile(const QString& baseName, const QString& filePath, int fileIndex)
 {
     if (!m_LayerTreeModel || !m_RasterGroup) return;
-	addLayer(baseName, filePath, false);
+
+	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)
+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);
@@ -2498,10 +2620,35 @@ void HPPA::addLayer(const QString& baseName, const QString& filePath,bool refres
 	auto* layerNode = new LayerTreeLayer(ml);
 	LayerTreeNode* node = m_LayerTreeModel->addLayer(m_RasterGroup, layerNode);
 
-	QWidget* mapcavasContainer = onCreateTab(baseName);
-	if (m_MapLayerStore) m_MapLayerStore->addLayer(ml, mapcavasContainer);
+	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]->setLayers(ml);
+	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)
 	{
@@ -2513,64 +2660,92 @@ void HPPA::onLayerTreeSelectionChanged(const QItemSelection& selected, const QIt
 {
     Q_UNUSED(deselected);
 
-    if (selected.indexes().isEmpty()) {
+    if (selected.indexes().isEmpty())
+	{
         m_ic->setActiveLayer(nullptr);
         return;
     }
 
     QModelIndex idx = selected.indexes().first();
-    if (!idx.isValid()) {
+    if (!idx.isValid())
+	{
         m_ic->setActiveLayer(nullptr);
         return;
     }
 
-    LayerTreeNode* node = static_cast<LayerTreeNode*>(idx.internalPointer());
-    if (!node || node->type() != LayerTreeNode::Type::Layer) {
+	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;
     }
 
-    auto* layerNode = static_cast<LayerTreeLayer*>(node);
-    MapLayer* mapLayer = layerNode->mapLayer();
-    if (!mapLayer || mapLayer->layerType() != MapLayer::LayerType::Raster) {
-        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();
 
-    RasterLayer* rl = static_cast<RasterLayer*>(mapLayer);
-    m_ic->setActiveLayer(rl);
+		if (!mapLayer || mapLayer->layerType() != MapLayer::LayerType::Raster) {
+			m_ic->setActiveLayer(nullptr);
+			return;
+		}
 
-    // Also switch to the corresponding tab in the image viewer
-    if (m_MapLayerStore && m_imageViewerTabWidget) {
-        QWidget* widget = m_MapLayerStore->widgetForLayer(mapLayer);
-        if (widget) {
-            int tabIndex = m_imageViewerTabWidget->indexOf(widget);
-            if (tabIndex >= 0) {
-                m_imageViewerTabWidget->setCurrentIndex(tabIndex);
-            }
-        }
-    }
+		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)
 {
-    RasterLayer* rl = m_ic->activeLayer();
-    if (!rl) return;
+    RasterImageLayer* imageLayer = m_ic->activeLayer();
+    if (!imageLayer) return;
+
+    auto params = imageLayer->multibandParams();
+    params.rWave = rWave;
+    params.gWave = gWave;
+    params.bWave = bWave;
+    imageLayer->setMultibandParams(params);
 
-    // Find the Mapcavas widget associated with this layer and re-render
     if (!m_MapLayerStore) return;
-
-    QWidget* container = m_MapLayerStore->widgetForLayer(rl);
+    MapLayer* mapLayer = imageLayer->layer();
+    QWidget* container = m_MapLayerStore->widgetForImageLayer(imageLayer);
     if (!container) return;
 
     QList<Mapcavas*> mapcavas = container->findChildren<Mapcavas*>();
     if (mapcavas.isEmpty()) return;
 
-    RasterLayer::RenderParams params = rl->currentRenderParams();
-    params.rWave = rWave;
-    params.gWave = gWave;
-    params.bWave = bWave;
-    rl->setCurrentRenderParams(params);
-
-    mapcavas[0]->freshmap(params);
+    mapcavas[0]->freshmap();
 }

HPPA/HPPA.h

@@ -79,6 +79,9 @@
 
 #include "rgbCameraWindow.h"
 #include "DepthCameraWindow.h"
+#include "SingleLensReflexCameraWindow.h"
+
+#include "LayerTreeImageNode.h"
 
 #define PI 3.1415926
 
@@ -281,6 +284,7 @@ private:
 	rgbCameraWindow* m_rgbCameraControlWindow;
 	ImageControl* m_ic;
 	DepthCameraWindow* m_depthCameraWindow;
+	SingleLensReflexCameraWindow* m_singleLensReflexCameraWindow;
 	adjustTable* m_adt;
 	PowerControl* m_pc;
 	RobotArmControl* m_rac;
@@ -365,12 +369,19 @@ public Q_SLOTS:
 
 		void createOneMotorScenario();
 		void createPlantPhenotypeScenario();
+		void create3DPlantPhenotypeScenario();
 		void onCreated3DModelPlantPhenotype();
+		void onCreated3DModelMicroscopicMotion();
+		void createMicroscopicMotionControlScenario();
 		void onCreated3DModelOneMotor();
 
-		void addLayer(const QString& baseName, const QString& filePath, bool refresh);
+		void addLayer(const QString& baseName, const QString& filePath, bool refresh, bool isAddImage = true);
+		void newImage(RasterLayer* ml, RasterImageLayer::RendererType, LayerTreeNode* parent, bool refresh=true);
 		void onLayerCreatedFromFile(const QString& baseName, const QString& filePath, int fileIndex);
 		void removeLayerByTreeIndex();
+		void removeLayerByNode(LayerTreeNode* node);
+		void showColorImageByTreeIndex();
+		void removeImageByTreeIndex();
 		void removeAllLayersInRasterGroup();
 
 		void onLayerTreeSelectionChanged(const QItemSelection& selected, const QItemSelection& deselected);

HPPA/HPPA.ui

@@ -133,6 +133,8 @@ color:white;
     </property>
     <addaction name="mActionOneMotorScenario"/>
     <addaction name="mActionPlantPhenotypeScenario"/>
+    <addaction name="mActionMicroscopicMotionControlScenario"/>
+    <addaction name="mAction3DPlantPhenotypeScenario"/>
    </widget>
    <widget class="QMenu" name="menu_4">
     <property name="title">
@@ -725,6 +727,22 @@ QPushButton:pressed
     <string>光谱</string>
    </property>
   </action>
+  <action name="mActionMicroscopicMotionControlScenario">
+   <property name="checkable">
+    <bool>true</bool>
+   </property>
+   <property name="text">
+    <string>显微运动控制台</string>
+   </property>
+  </action>
+  <action name="mAction3DPlantPhenotypeScenario">
+   <property name="checkable">
+    <bool>true</bool>
+   </property>
+   <property name="text">
+    <string>3D植物表型</string>
+   </property>
+  </action>
  </widget>
  <layoutdefault spacing="6" margin="11"/>
  <customwidgets>

HPPA/HPPA.vcxproj

@@ -60,8 +60,8 @@
     <TargetName>Spectral Insight</TargetName>
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)' == 'Release|x64'">
-    <IncludePath>D:\cpp_library\gdal2.2.3_vs2017\include;C:\Program Files\ResononAPI\include;D:\cpp_library\opencv3.4.11\opencv\build\include;D:\cpp_library\opencv3.4.11\opencv\build\include\opencv;D:\cpp_library\opencv3.4.11\opencv\build\include\opencv2;D:\cpp_project_vs2022\AutoFocus_InspireLinearMotor_DLL\AutoFocus_InspireLinearMotor_DLL\SDKs\PCOMM\Include;D:\cpp_project_vs2022\AutoFocus_InspireLinearMotor_DLL\AutoFocus_InspireLinearMotor_DLL\SDKs\PortControl;D:\cpp_project_vs2022\AutoFocus_InspireLinearMotor_DLL\AutoFocus_InspireLinearMotor_DLL;D:\cpp_project_vs2022\HPPA\HPPA;D:\cpp_library\libconfig-1.7.3\lib;D:\cpp_project_vs2022\HPPA\vincecontrol;C:\XIMEA\API\xiAPI;D:\cpp_project_vs2022\HPPA\IrisMultiMotorController\IrisMultiMotorController;D:\cpp_library\eigen-3.4-rc1;$(IncludePath)</IncludePath>
-    <LibraryPath>D:\cpp_library\opencv3.4.11\opencv\build\x64\vc15\lib;D:\cpp_library\vincecontrol_vs2017_release;D:\cpp_library\gdal2.2.3_vs2017\lib;C:\Program Files\ResononAPI\lib64;D:\cpp_project_vs2022\AutoFocus_InspireLinearMotor_DLL\x64\Release;D:\cpp_library\libconfig-1.7.3\build\x64;D:\cpp_project_vs2022\IrisMultiMotorController\x64\Release;C:\XIMEA\API\xiAPI;$(LibraryPath)</LibraryPath>
+    <IncludePath>D:\cpp_library\gdal2.2.3_vs2017\include;C:\Program Files\ResononAPI\include;D:\cpp_library\opencv3.4.11\opencv\build\include;D:\cpp_library\opencv3.4.11\opencv\build\include\opencv;D:\cpp_library\opencv3.4.11\opencv\build\include\opencv2;D:\cpp_project_vs2022\AutoFocus_InspireLinearMotor_DLL\AutoFocus_InspireLinearMotor_DLL\SDKs\PCOMM\Include;D:\cpp_project_vs2022\AutoFocus_InspireLinearMotor_DLL\AutoFocus_InspireLinearMotor_DLL\SDKs\PortControl;D:\cpp_project_vs2022\AutoFocus_InspireLinearMotor_DLL\AutoFocus_InspireLinearMotor_DLL;D:\cpp_project_vs2022\HPPA\HPPA;D:\cpp_library\libconfig-1.7.3\lib;D:\cpp_project_vs2022\HPPA\vincecontrol;C:\XIMEA\API\xiAPI;D:\cpp_project_vs2022\HPPA\IrisMultiMotorController\IrisMultiMotorController;D:\cpp_library\eigen-3.4-rc1;C:\Program Files\OrbbecSDK 2.7.6\include;$(IncludePath)</IncludePath>
+    <LibraryPath>D:\cpp_library\opencv3.4.11\opencv\build\x64\vc15\lib;D:\cpp_library\vincecontrol_vs2017_release;D:\cpp_library\gdal2.2.3_vs2017\lib;C:\Program Files\ResononAPI\lib64;D:\cpp_project_vs2022\AutoFocus_InspireLinearMotor_DLL\x64\Release;D:\cpp_library\libconfig-1.7.3\build\x64;D:\cpp_project_vs2022\IrisMultiMotorController\x64\Release;C:\XIMEA\API\xiAPI;C:\Program Files\OrbbecSDK 2.7.6\lib;$(LibraryPath)</LibraryPath>
     <TargetName>Spectral Insight</TargetName>
   </PropertyGroup>
   <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
@@ -75,7 +75,7 @@
   </ItemDefinitionGroup>
   <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
     <Link>
-      <AdditionalDependencies>opencv_world3411.lib;vincecontrol.lib;gdal_i.lib;resonon-basler.lib;resonon-allied.lib;AutoFocus_InspireLinearMotor_DLL.lib;libconfig++.lib;xiapi64.lib;IrisMultiMotorController.lib;%(AdditionalDependencies)</AdditionalDependencies>
+      <AdditionalDependencies>opencv_world3411.lib;vincecontrol.lib;gdal_i.lib;resonon-basler.lib;resonon-allied.lib;AutoFocus_InspireLinearMotor_DLL.lib;libconfig++.lib;xiapi64.lib;IrisMultiMotorController.lib;OrbbecSDK.lib;%(AdditionalDependencies)</AdditionalDependencies>
       <AdditionalLibraryDirectories>D:\cpp_project_vs2022\HPPA\x64\Release;%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
     </Link>
   </ItemDefinitionGroup>
@@ -124,6 +124,7 @@
     <ClCompile Include="irisximeaimager.cpp" />
     <ClCompile Include="LayerTree.cpp" />
     <ClCompile Include="LayerTreeGroupNode.cpp" />
+    <ClCompile Include="LayerTreeImageNode.cpp" />
     <ClCompile Include="LayerTreeLayerNode.cpp" />
     <ClCompile Include="LayerTreeModel.cpp" />
     <ClCompile Include="LayerTreeNode.cpp" />
@@ -143,7 +144,10 @@
     <ClCompile Include="QMotorDoubleSlider.cpp" />
     <ClCompile Include="RasterDataProvider.cpp" />
     <ClCompile Include="RasterLayer.cpp" />
-    <ClCompile Include="RasterRenderer.cpp" />
+    <ClCompile Include="MultibandRasterRenderer.cpp" />
+    <ClCompile Include="RasterRendererBase.cpp" />
+    <ClCompile Include="RasterImageLayer.cpp" />
+    <ClCompile Include="SinglebandRasterRenderer.cpp" />
     <ClCompile Include="recordFrameCounter.cpp" />
     <ClCompile Include="resononImager.cpp" />
     <ClCompile Include="ResononNirImager.cpp" />
@@ -151,6 +155,7 @@
     <ClCompile Include="rgbCameraWindow.cpp" />
     <ClCompile Include="RobotArmControl.cpp" />
     <ClCompile Include="setWindow.cpp" />
+    <ClCompile Include="SingleLensReflexCameraWindow.cpp" />
     <ClCompile Include="stdafx.cpp">
       <PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">Create</PrecompiledHeader>
       <PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Release|x64'">Create</PrecompiledHeader>
@@ -187,6 +192,7 @@
     <QtUic Include="rgbCamera.ui" />
     <QtUic Include="RobotArmControl.ui" />
     <QtUic Include="set.ui" />
+    <QtUic Include="SingleLensReflexCamera.ui" />
     <QtUic Include="twoMotorControl.ui" />
   </ItemGroup>
   <ItemGroup>
@@ -227,6 +233,7 @@
     <QtMoc Include="MapLayer.h" />
     <QtMoc Include="RasterLayer.h" />
     <QtMoc Include="MapLayerStore.h" />
+    <QtMoc Include="LayerTreeImageNode.h" />
     <ClInclude Include="LayerTreeView.h" />
     <QtMoc Include="LayerTreeViewMenuProvider.h" />
     <QtMoc Include="MapTool.h" />
@@ -235,10 +242,14 @@
     <QtMoc Include="MapTools.h" />
     <ClInclude Include="MotorWindowBase.h" />
     <ClInclude Include="RasterDataProvider.h" />
-    <ClInclude Include="RasterRenderer.h" />
+    <ClInclude Include="MultibandRasterRenderer.h" />
+    <ClInclude Include="RasterImageLayer.h" />
+    <ClInclude Include="RasterRendererBase.h" />
+    <ClInclude Include="SinglebandRasterRenderer.h" />
     <QtMoc Include="recordFrameCounter.h" />
     <QtMoc Include="setWindow.h" />
     <QtMoc Include="rgbCameraWindow.h" />
+    <QtMoc Include="SingleLensReflexCameraWindow.h" />
     <ClInclude Include="utility_tc.h" />
     <QtMoc Include="aboutWindow.h" />
     <ClInclude Include="hppaConfigFile.h" />

HPPA/HPPA.vcxproj.filters

@@ -160,10 +160,16 @@
     <ClCompile Include="RasterLayer.cpp">
       <Filter>Source Files</Filter>
     </ClCompile>
+    <ClCompile Include="RasterImageLayer.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
     <ClCompile Include="RasterDataProvider.cpp">
       <Filter>Source Files</Filter>
     </ClCompile>
-    <ClCompile Include="RasterRenderer.cpp">
+    <ClCompile Include="MultibandRasterRenderer.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="SinglebandRasterRenderer.cpp">
       <Filter>Source Files</Filter>
     </ClCompile>
     <ClCompile Include="MapLayerStore.cpp">
@@ -217,6 +223,15 @@
     <ClCompile Include="DepthCameraWindow.cpp">
       <Filter>Source Files</Filter>
     </ClCompile>
+    <ClCompile Include="SingleLensReflexCameraWindow.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="LayerTreeImageNode.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="RasterRendererBase.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
   </ItemGroup>
   <ItemGroup>
     <QtMoc Include="fileOperation.h">
@@ -354,6 +369,12 @@
     <QtMoc Include="DepthCameraWindow.h">
       <Filter>Header Files</Filter>
     </QtMoc>
+    <QtMoc Include="SingleLensReflexCameraWindow.h">
+      <Filter>Header Files</Filter>
+    </QtMoc>
+    <QtMoc Include="LayerTreeImageNode.h">
+      <Filter>Header Files</Filter>
+    </QtMoc>
   </ItemGroup>
   <ItemGroup>
     <ClInclude Include="imageProcessor.h">
@@ -389,7 +410,16 @@
     <ClInclude Include="RasterDataProvider.h">
       <Filter>Header Files</Filter>
     </ClInclude>
-    <ClInclude Include="RasterRenderer.h">
+    <ClInclude Include="MultibandRasterRenderer.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="RasterImageLayer.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="RasterRendererBase.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="SinglebandRasterRenderer.h">
       <Filter>Header Files</Filter>
     </ClInclude>
     <ClInclude Include="LayerTreeView.h">
@@ -448,6 +478,9 @@
     <QtUic Include="DepthCamera.ui">
       <Filter>Form Files</Filter>
     </QtUic>
+    <QtUic Include="SingleLensReflexCamera.ui">
+      <Filter>Form Files</Filter>
+    </QtUic>
   </ItemGroup>
   <ItemGroup>
     <None Include="cpp.hint" />

HPPA/HyperImagerControl.cpp

@@ -83,6 +83,7 @@ void HyperImagerControl::setFrameRate(double frameRate)
 	ui.FramerateSlider->setValue(frameRate);
 
 	updateIntegrationTimeRange(frameRate);
+	AppSettings::instance().setFrameRate(frameRate);
 }
 
 void HyperImagerControl::setIntegrationTime(double integrationTime)
@@ -91,12 +92,15 @@ void HyperImagerControl::setIntegrationTime(double integrationTime)
 	ui.IntegratioinTimeSlider->setValue(integrationTime);
 
 	updateFramerateRange(integrationTime);
+	AppSettings::instance().setIntegrationTime(integrationTime);
 }
 
 void HyperImagerControl::setGain(double gain)
 {
 	ui.gain_spinBox->setValue(gain);
 	ui.GainSlider->setValue(gain);
+
+	AppSettings::instance().setGain(gain);
 }
 
 void HyperImagerControl::onFramerateSpinBoxEditingFinished()
@@ -161,7 +165,7 @@ void HyperImagerControl::onGainSliderReleased()
 
 void HyperImagerControl::updateIntegrationTimeRange(double frameRate)
 {
-	double maxIntegrationTime = 1.0 / frameRate * 1000.0; // 毫秒
+	double maxIntegrationTime = 1.0 / frameRate * 999.0; // 毫秒
 
 	ui.IntegratioinTimeSlider->blockSignals(true);
 	ui.IntegratioinTimeSlider->setMaximum(maxIntegrationTime);
@@ -176,7 +180,7 @@ void HyperImagerControl::updateIntegrationTimeRange(double frameRate)
 
 void HyperImagerControl::updateFramerateRange(double integrationTime)
 {
-	double maxFramerate = 1.0 / (integrationTime / 1000.0); // 积分时间(毫秒)转帧率
+	double maxFramerate = 1.0 / (integrationTime / 999.0); // 积分时间(毫秒)转帧率
 
 	if(maxFramerate > m_frameRateLimit)
 	{

HPPA/HyperImagerControl.h

@@ -5,6 +5,7 @@
 #include "ui_hyperImagerControl.h"
 
 #include "AspectRatioLabel.h"
+#include "AppSettings.h"
 
 class QDoubleSlider;
 

HPPA/ImageViewer.cpp

@@ -6,7 +6,7 @@
 #include <QPoint>
 
 #include "ImageViewer.h"
-#include "RasterLayer.h"
+#include "RasterImageLayer.h"
 #include "MapTool.h"
 
 
@@ -264,35 +264,22 @@ qreal Mapcavas::zoomDelta() const
     return m_zoomDelta;
 }
 
-// new: set associated raster layer
-void Mapcavas::setLayers(RasterLayer* layer)
+// set associated raster image layer
+void Mapcavas::setImageLayer(RasterImageLayer* layer)
 {
-    m_rasterLayer = layer;
+    m_imageLayer = layer;
 }
 
-RasterLayer* Mapcavas::rasterLayer() const
+RasterImageLayer* Mapcavas::imageLayer() const
 {
-    return m_rasterLayer;
+    return m_imageLayer;
 }
 
-// new: refresh the map by rendering using the RasterLayer's render method
 void Mapcavas::freshmap()
 {
-    if (!m_rasterLayer) return;
+    if (!m_imageLayer) return;
 
-    RasterLayer::RenderParams params = m_rasterLayer->currentRenderParams();
-    QImage img = m_rasterLayer->render(params);
-    if (img.isNull()) return;
-
-    QPixmap pm = QPixmap::fromImage(img);
-    SetImage(&pm);
-}
-
-void Mapcavas::freshmap(const RasterLayer::RenderParams& params)
-{
-    if (!m_rasterLayer) return;
-
-    QImage img = m_rasterLayer->render(params);
+    QImage img = m_imageLayer->render();
     if (img.isNull()) return;
 
     QPixmap pm = QPixmap::fromImage(img);

HPPA/ImageViewer.h

@@ -4,7 +4,8 @@
 #include "QGraphicsView"
 #include "qlabel.h"
 #include <QVector>
-#include "RasterLayer.h"
+
+class RasterImageLayer;
 
 class MapTool;
 
@@ -47,12 +48,11 @@ public:
 	void setZoomDelta(qreal delta);
 	qreal zoomDelta() const;
 
-	// new: set raster layer and refresh map
-	void setLayers(RasterLayer* layer);
+	// set raster image layer and refresh map
+	void setImageLayer(RasterImageLayer* layer);
 	void freshmap();
-	void freshmap(const RasterLayer::RenderParams& params);
 
-	RasterLayer* rasterLayer() const;
+	RasterImageLayer* imageLayer() const;
 
 	// MapTool management
 	void setMapTool(MapTool* tool);
@@ -65,7 +65,7 @@ private:
 	QGraphicsPixmapItem *m_GraphicsPixmapItemHandle;
 	QLabel *m_framNumberLabel;//显示实时采集到的帧数
 
-	RasterLayer* m_rasterLayer = nullptr; // associated raster layer
+	RasterImageLayer* m_imageLayer = nullptr; // associated raster image layer
 	MapTool* m_mapTool = nullptr;         // current active map tool
 
 	qreal m_translateSpeed;  // 平移速度

HPPA/LayerTreeImageNode.cpp

@@ -0,0 +1,31 @@
+#include "LayerTreeImageNode.h"
+#include "RasterImageLayer.h"
+
+LayerTreeImageNode::LayerTreeImageNode(RasterImageLayer* imageLayer,
+                                       const QString& name,
+                                       QWidget* widget,
+                                       QObject* parent)
+    : LayerTreeNode(name, parent)
+    , m_imageLayer(imageLayer)
+    , m_widget(widget)
+{
+}
+
+LayerTreeImageNode::~LayerTreeImageNode()
+{
+}
+
+LayerTreeNode::Type LayerTreeImageNode::type() const
+{
+    return Type::Image;
+}
+
+QWidget* LayerTreeImageNode::widget() const
+{
+    return m_widget;
+}
+
+void LayerTreeImageNode::setWidget(QWidget* widget)
+{
+    m_widget = widget;
+}

HPPA/LayerTreeImageNode.h

@@ -0,0 +1,30 @@
+#pragma once
+
+#include "LayerTreeNode.h"
+#include <memory>
+
+class QWidget;
+class RasterImageLayer;
+
+class LayerTreeImageNode : public LayerTreeNode
+{
+    Q_OBJECT
+public:
+    explicit LayerTreeImageNode(RasterImageLayer* imageLayer,
+                                const QString& name,
+                                QWidget* widget = nullptr,
+                                QObject* parent = nullptr);
+
+    ~LayerTreeImageNode();
+
+    Type type() const override;
+
+    RasterImageLayer* imageLayer() const { return m_imageLayer; }
+    QWidget* widget() const;
+    void setWidget(QWidget* widget);
+
+private:
+    RasterImageLayer* m_imageLayer;
+    QWidget* m_widget = nullptr;
+};
+

HPPA/LayerTreeLayerNode.cpp

@@ -1,7 +1,7 @@
 #include "LayerTreeLayerNode.h"
 
 LayerTreeLayer::LayerTreeLayer(MapLayer* layer, QObject* parent)
-    : LayerTreeNode(layer ? layer->name() : QString(), parent), m_layer(layer)
+    : LayerTreeGroup(layer ? layer->name() : QString(), parent), m_layer(layer)
 {
 }
 

HPPA/LayerTreeLayerNode.h

@@ -1,5 +1,5 @@
 #pragma once
-#include "LayerTreeNode.h"
+#include "LayerTreeGroupNode.h"
 #include "MapLayer.h"
 
 /**
@@ -7,13 +7,13 @@
  * - 基类为 LayerTreeNode
  * - 持有一个 MapLayer 指针（不拥有）
  */
-class LayerTreeLayer : public LayerTreeNode
+class LayerTreeLayer : public LayerTreeGroup
 {
     Q_OBJECT
 public:
     explicit LayerTreeLayer(MapLayer* layer, QObject* parent = nullptr);
 
-    Type type() const override;
+    Type type() const;
 
     void setMapLayer(MapLayer* layer);
     MapLayer* mapLayer() const;

HPPA/LayerTreeModel.cpp

@@ -133,7 +133,7 @@ LayerTreeNode* LayerTreeModel::addGroup(LayerTreeNode* parent, const QString& na
     return g;
 }
 
-LayerTreeNode* LayerTreeModel::addLayer(LayerTreeNode* parent, LayerTreeLayer* layerNode, const QIcon& icon)
+LayerTreeNode* LayerTreeModel::addLayer(LayerTreeNode* parent, LayerTreeNode* layerNode, const QIcon& icon)
 {
     if (!parent) parent = m_tree;
     if (!layerNode) return nullptr;

HPPA/LayerTreeModel.h

@@ -34,7 +34,7 @@ public:
     LayerTreeNode* root() const;
 
     LayerTreeNode* addGroup(LayerTreeNode* parent, const QString& name, const QIcon& icon = QIcon());
-    LayerTreeNode* addLayer(LayerTreeNode* parent, LayerTreeLayer* layerNode, const QIcon& icon = QIcon());
+    LayerTreeNode* addLayer(LayerTreeNode* parent, LayerTreeNode* layerNode, const QIcon& icon = QIcon());
 
     void setCascadeCheckEnabled(bool enabled);
     bool cascadeCheckEnabled() const;

HPPA/LayerTreeNode.h

@@ -19,7 +19,7 @@ class LayerTreeNode : public QObject
 {
     Q_OBJECT
 public:
-    enum class Type { Group, Layer };
+    enum class Type { Group, Layer, Image };
 
     explicit LayerTreeNode(const QString& name,
         QObject* parent = nullptr);

HPPA/LayerTreeViewMenuProvider.cpp

@@ -36,9 +36,20 @@ QMenu* LayerTreeViewMenuProvider::createContextMenu()
 
     if (node->type() == LayerTreeNode::Type::Layer)
     {
-        QAction* removeAction = new QAction(QStringLiteral("移除图层"), menu);
-        connect(removeAction, &QAction::triggered, HPPA::instance(), &HPPA::removeLayerByTreeIndex);
-        menu->addAction(removeAction);
+        QAction* removeLayerAction = new QAction(QStringLiteral("移除图层"), menu);
+        connect(removeLayerAction, &QAction::triggered, HPPA::instance(), &HPPA::removeLayerByTreeIndex);
+
+        QAction* showColorImageAction = new QAction(QStringLiteral("显示彩色图像"), menu);
+        connect(showColorImageAction, &QAction::triggered, HPPA::instance(), &HPPA::showColorImageByTreeIndex);
+
+        menu->addAction(removeLayerAction);
+        menu->addAction(showColorImageAction);
+    }
+    else if (node->type() == LayerTreeNode::Type::Image)
+    {
+        QAction* removeImageAction = new QAction(QStringLiteral("移除图像"), menu);
+        connect(removeImageAction, &QAction::triggered, HPPA::instance(), &HPPA::removeImageByTreeIndex);
+        menu->addAction(removeImageAction);
     }
     else if (node->type() == LayerTreeNode::Type::Group)
     {

HPPA/MapLayerStore.cpp

@@ -1,60 +1,128 @@
 #include "MapLayerStore.h"
 #include "MapLayer.h"
+#include "RasterImageLayer.h"
+#include <QFileInfo>
+#include <QWidget>
 
 MapLayerStore::MapLayerStore(QObject* parent)
     : QObject(parent)
 {
-    int a = 1;
 }
 
-void MapLayerStore::addLayer(MapLayer* layer, QWidget* widget)
+void MapLayerStore::addLayer(MapLayer* layer)
 {
     if (!layer) return;
-    MapLayer* raw = layer;
-    m_layers.emplace_back(std::shared_ptr<MapLayer>(layer));
-    if (widget)
-        m_layerWidgets[raw] = widget;
-    emit layerAdded(raw);
+
+    int index = (int)m_layers.size();
+    LayerEntry entry;
+    entry.mapLayer.reset(layer);
+
+    m_layers.push_back(std::move(entry));
+    m_mapLayerIndex[layer] = index;
+
+    emit layerAdded(layer);
+}
+
+void MapLayerStore::addImageLayer(MapLayer* mapLayer, RasterImageLayer* imageLayer, QWidget* widget)
+{
+    if (!mapLayer || !imageLayer) return;
+
+    LayerEntry* entry = findLayerEntry(mapLayer);
+    if (!entry) return;
+
+    entry->imageLayers.push_back({std::unique_ptr<RasterImageLayer>(imageLayer), widget});
+    emit imageLayerAdded(imageLayer);
 }
 
 void MapLayerStore::removeLayer(MapLayer* layer)
 {
     if (!layer) return;
-    for (auto it = m_layers.begin(); it != m_layers.end(); ++it) {
-        if (it->get() == layer) {
-            emit layerAboutToBeRemoved(layer);
-            m_layers.erase(it);
-            m_layerWidgets.erase(layer);
-            return;
+
+    auto it = m_mapLayerIndex.find(layer);
+    if (it == m_mapLayerIndex.end()) return;
+
+    int index = it->second;
+    if (index < 0 || index >= (int)m_layers.size()) return;
+
+    LayerEntry& entry = m_layers[index];
+
+    // Delete all associated widgets
+    for (auto& imgEntry : entry.imageLayers) {
+        if (imgEntry.widget) {
+            delete imgEntry.widget;
+        }
+    }
+    entry.imageLayers.clear();
+
+    emit layerAboutToBeRemoved(layer);
+
+    m_layers.erase(m_layers.begin() + index);//?????????????????????
+    m_mapLayerIndex.erase(it);
+
+    // Rebuild index for layers after removed one
+    for (int i = index; i < (int)m_layers.size(); ++i) {
+        m_mapLayerIndex[m_layers[i].mapLayer.get()] = i;
+    }
+}
+
+void MapLayerStore::removeImageLayer(RasterImageLayer* imageLayer)//可以优化：RasterImageLayer包含一个指向所属MapLayer的指针，这样就不需要遍历所有图层来找到它了
+{
+    if (!imageLayer) return;
+
+    for (auto& entry : m_layers) {
+        for (auto it = entry.imageLayers.begin(); it != entry.imageLayers.end(); ++it) {
+            if (it->imageLayer.get() == imageLayer) {
+                emit imageLayerAboutToBeRemoved(imageLayer);
+                if (it->widget) {
+					//delete it->widget;//在调用此函数的地方已经删除了widget了，这里不需要再删除一次了
+                }
+                entry.imageLayers.erase(it);
+                return;
+            }
         }
     }
 }
 
 void MapLayerStore::removeLayerByName(const QString& name)
 {
-    for (auto it = m_layers.begin(); it != m_layers.end(); ++it) {
-        if ((*it)->name() == name) {
-            MapLayer* raw = it->get();
-            emit layerAboutToBeRemoved(raw);
-            m_layers.erase(it);
-            m_layerWidgets.erase(raw);
+    for (auto& entry : m_layers) {
+        if (entry.mapLayer->name() == name) {
+            removeLayer(entry.mapLayer.get());
             return;
         }
     }
 }
 
+bool MapLayerStore::containsLayer(const QString& url, bool isAbsolutePath) const
+{
+    QFileInfo fi(url);
+    QString fileName = fi.completeBaseName();
+
+    if (!isAbsolutePath) {
+        return getLayer(fileName) != nullptr;
+    }
+
+    for (const auto& entry : m_layers) {
+        if (entry.mapLayer->dataPath() == url)
+            return true;
+    }
+    return false;
+}
+
 MapLayer* MapLayerStore::getLayer(const QString& name) const
 {
-    for (const auto& l : m_layers) {
-        if (l->name() == name) return l.get();
+    for (const auto& entry : m_layers) {
+        if (entry.mapLayer->name() == name)
+            return entry.mapLayer.get();
     }
     return nullptr;
 }
 
 MapLayer* MapLayerStore::getLayerAt(int index) const
 {
-    if (index < 0 || index >= (int)m_layers.size()) return nullptr;
-    return m_layers[index].get();
+    if (index < 0 || index >= (int)m_layers.size())
+        return nullptr;
+    return m_layers[index].mapLayer.get();
 }
 
 int MapLayerStore::layerCount() const
@@ -62,31 +130,129 @@ int MapLayerStore::layerCount() const
     return (int)m_layers.size();
 }
 
-QWidget* MapLayerStore::widgetForLayer(MapLayer* layer) const
+RasterImageLayer* MapLayerStore::getImageLayer(MapLayer* mapLayer, int index) const
 {
-    auto it = m_layerWidgets.find(layer);
-    if (it == m_layerWidgets.end()) return nullptr;
-    return it->second;
+    const LayerEntry* entry = findLayerEntry(mapLayer);
+    if (!entry) return nullptr;
+
+    if (index < 0 || index >= (int)entry->imageLayers.size())
+        return nullptr;
+
+    return entry->imageLayers[index].imageLayer.get();
+}
+
+int MapLayerStore::imageLayerCount(MapLayer* mapLayer) const
+{
+    const LayerEntry* entry = findLayerEntry(mapLayer);
+    if (!entry) return 0;
+    return (int)entry->imageLayers.size();
+}
+
+std::vector<RasterImageLayer*> MapLayerStore::getAllImageLayers() const
+{
+    std::vector<RasterImageLayer*> result;
+    for (const auto& entry : m_layers) {
+        for (const auto& imgEntry : entry.imageLayers) {
+            if (imgEntry.imageLayer)
+                result.push_back(imgEntry.imageLayer.get());
+        }
+    }
+    return result;
+}
+
+QWidget* MapLayerStore::widgetForImageLayer(RasterImageLayer* imageLayer) const
+{
+    for (const auto& entry : m_layers) {
+        for (const auto& imgEntry : entry.imageLayers) {
+            if (imgEntry.imageLayer.get() == imageLayer)
+                return imgEntry.widget;
+        }
+    }
+    return nullptr;
+}
+
+QWidget* MapLayerStore::widgetForLayer(MapLayer* layer) const//需要修改??????????????????????????????????????????????
+{
+    const LayerEntry* entry = findLayerEntry(layer);
+    if (!entry || entry->imageLayers.empty())
+        return nullptr;
+    return entry->imageLayers.front().widget;
 }
 
 QWidget* MapLayerStore::widgetForLayer(const QString& absolutePath) const
 {
-    for (const auto& sp : m_layers) {
-        if (sp && sp->dataPath() == absolutePath) {
-            MapLayer* raw = sp.get();
-            auto it = m_layerWidgets.find(raw);
-            if (it != m_layerWidgets.end()) return it->second;
+    for (const auto& entry : m_layers) {
+        if (entry.mapLayer->dataPath() == absolutePath) {
+            if (!entry.imageLayers.empty())
+                return entry.imageLayers.front().widget;
             return nullptr;
         }
     }
     return nullptr;
 }
 
-MapLayer* MapLayerStore::layerForWidget(QWidget* widget) const
+std::vector<QWidget*> MapLayerStore::widgetsForMapLayer(MapLayer* mapLayer) const
 {
-    if (!widget) return nullptr;
-    for (const auto& kv : m_layerWidgets) {
-        if (kv.second == widget) return kv.first;
+    std::vector<QWidget*> result;
+    const LayerEntry* entry = findLayerEntry(mapLayer);
+    if (!entry) return result;
+
+    for (const auto& imgEntry : entry->imageLayers) {
+        if (imgEntry.widget)
+            result.push_back(imgEntry.widget);
+    }
+    return result;
+}
+
+MapLayer* MapLayerStore::mapLayerForImageLayer(RasterImageLayer* imageLayer) const
+{
+    for (const auto& entry : m_layers) {
+        for (const auto& imgEntry : entry.imageLayers) {
+            if (imgEntry.imageLayer.get() == imageLayer)
+                return entry.mapLayer.get();
+        }
     }
     return nullptr;
 }
+
+MapLayer* MapLayerStore::mapLayerForWidget(QWidget* widget) const
+{
+    if (!widget) return nullptr;
+    for (const auto& entry : m_layers) {
+        for (const auto& imgEntry : entry.imageLayers) {
+            if (imgEntry.widget == widget)
+                return entry.mapLayer.get();
+        }
+    }
+    return nullptr;
+}
+
+RasterImageLayer* MapLayerStore::imageLayerForWidget(QWidget* widget) const
+{
+    if (!widget) return nullptr;
+    for (const auto& entry : m_layers) {
+        for (const auto& imgEntry : entry.imageLayers) {
+            if (imgEntry.widget == widget)
+                return imgEntry.imageLayer.get();
+        }
+    }
+    return nullptr;
+}
+
+MapLayerStore::LayerEntry* MapLayerStore::findLayerEntry(MapLayer* mapLayer)
+{
+    auto it = m_mapLayerIndex.find(mapLayer);
+    if (it == m_mapLayerIndex.end()) return nullptr;
+    int index = it->second;
+    if (index < 0 || index >= (int)m_layers.size()) return nullptr;
+    return &m_layers[index];
+}
+
+const MapLayerStore::LayerEntry* MapLayerStore::findLayerEntry(MapLayer* mapLayer) const
+{
+    auto it = m_mapLayerIndex.find(mapLayer);
+    if (it == m_mapLayerIndex.end()) return nullptr;
+    int index = it->second;
+    if (index < 0 || index >= (int)m_layers.size()) return nullptr;
+    return &m_layers[index];
+}

HPPA/MapLayerStore.h

@@ -7,45 +7,65 @@
 #include <unordered_map>
 
 class MapLayer;
+class RasterImageLayer;
 class QWidget;
 
 class MapLayerStore : public QObject
 {
     Q_OBJECT
+
+    struct ImageLayerEntry {
+        std::unique_ptr<RasterImageLayer> imageLayer;
+        QWidget* widget;
+    };
+
+    struct LayerEntry {
+        std::unique_ptr<MapLayer> mapLayer;
+        std::vector<ImageLayerEntry> imageLayers;
+    };
+
 public:
     explicit MapLayerStore(QObject* parent = nullptr);
     ~MapLayerStore() override = default;
 
-    // Take ownership of the layer (store will own and manage its lifetime)
-    // Now also accept the associated QWidget so UI widget can be retrieved by layer pointer
-    void addLayer(MapLayer* layer, QWidget* widget = nullptr);
-
-    // Remove by pointer or by name. Destruction happens when removed from store.
-public slots:
+    // Layer management
+    void addLayer(MapLayer* layer);
     void removeLayer(MapLayer* layer);
     void removeLayerByName(const QString& name);
+    bool containsLayer(const QString& url, bool isAbsolutePath = true) const;
 
-    // Queries
     MapLayer* getLayer(const QString& name) const;
     MapLayer* getLayerAt(int index) const;
     int layerCount() const;
 
-    // Get associated widget for a layer (or nullptr if none)
-    QWidget* widgetForLayer(MapLayer* layer) const;
-    // Get associated widget by layer absolute data path
-    QWidget* widgetForLayer(const QString& absolutePath) const;
+    // ImageLayer management
+    void addImageLayer(MapLayer* mapLayer, RasterImageLayer* imageLayer, QWidget* widget);
+    void removeImageLayer(RasterImageLayer* imageLayer);
+    RasterImageLayer* getImageLayer(MapLayer* mapLayer, int index) const;
+    int imageLayerCount(MapLayer* mapLayer) const;
+    std::vector<RasterImageLayer*> getAllImageLayers() const;
 
-    // Reverse lookup: find the MapLayer associated with a given widget (or nullptr)
-    MapLayer* layerForWidget(QWidget* widget) const;
+    // Widget queries
+    QWidget* widgetForImageLayer(RasterImageLayer* imageLayer) const;
+    QWidget* widgetForLayer(MapLayer* layer) const;
+    QWidget* widgetForLayer(const QString& absolutePath) const;
+    std::vector<QWidget*> widgetsForMapLayer(MapLayer* mapLayer) const;
+
+    // Reverse lookups
+    MapLayer* mapLayerForImageLayer(RasterImageLayer* imageLayer) const;
+    MapLayer* mapLayerForWidget(QWidget* widget) const;
+    RasterImageLayer* imageLayerForWidget(QWidget* widget) const;
 
 signals:
     void layerAdded(MapLayer* layer);
-    // Emitted just before the layer is destroyed/removed from store
     void layerAboutToBeRemoved(MapLayer* layer);
+    void imageLayerAdded(RasterImageLayer* imageLayer);
+    void imageLayerAboutToBeRemoved(RasterImageLayer* imageLayer);
 
 private:
-    // store shared ownership so other parts can keep raw pointers safely (or use QPointer)
-    std::vector<std::shared_ptr<MapLayer>> m_layers;
-    // mapping from raw MapLayer pointer to associated QWidget*
-    std::unordered_map<MapLayer*, QWidget*> m_layerWidgets;
+    LayerEntry* findLayerEntry(MapLayer* mapLayer);
+    const LayerEntry* findLayerEntry(MapLayer* mapLayer) const;
+
+    std::vector<LayerEntry> m_layers;
+    std::unordered_map<MapLayer*, int> m_mapLayerIndex;
 };

HPPA/MapToolSpectral.cpp

@@ -41,10 +41,10 @@ void MapToolSpectral::canvasMousePressEvent(QMouseEvent* e)
     const int x = static_cast<int>(std::floor(scenePt.x()));
     const int y = static_cast<int>(std::floor(scenePt.y()));
 
-    RasterLayer* rl = canvas()->rasterLayer();
+    auto* imageLayer = canvas()->imageLayer();
+    RasterLayer* rl = imageLayer ? imageLayer->layer() : nullptr;
     if (rl && rl->isValidPixel(x, y))
     {
-        // Place crosshair at pixel center
         canvas()->updateCrosshair(x + 0.5, y + 0.5);
 
         QVector<double> wavelengths;

HPPA/MapToolSpectral.h

@@ -4,6 +4,8 @@
 #include "MapTool.h"
 #include <QVector>
 
+#include "RasterImageLayer.h"
+
 class QGraphicsLineItem;
 
 class MapToolSpectral : public MapTool

HPPA/MultibandRasterRenderer.cpp

@@ -1,30 +1,32 @@
-#include "RasterRenderer.h"
+#include "MultibandRasterRenderer.h"
 #include "RasterDataProvider.h"
 #include <QDebug>
 #include <algorithm>
 
-RasterRenderer::RasterRenderer(RasterDataProvider* provider)
-    : m_provider(provider)
+MultibandRasterRenderer::MultibandRasterRenderer(RasterDataProvider* provider)
+    : RasterRendererBase(provider)
 {
 }
 
-void RasterRenderer::stretchTo8bit(const std::vector<float>& in, std::vector<unsigned char>& out, float minVal, float maxVal)
+void MultibandRasterRenderer::stretchTo8bit(const std::vector<float>& in, std::vector<unsigned char>& out, float minVal, float maxVal)
 {
     size_t n = in.size();
     out.resize(n);
-    if (maxVal <= minVal) {
+    if (maxVal <= minVal)
+    {
         std::fill(out.begin(), out.end(), 0);
         return;
     }
     float denom = 1.0f / (maxVal - minVal);
-    for (size_t i = 0; i < n; ++i) {
+    for (size_t i = 0; i < n; ++i)
+    {
         float v = (in[i] - minVal) * denom;
         v = std::min(std::max(v, 0.0f), 1.0f);
         out[i] = static_cast<unsigned char>(v * 255.0f);
     }
 }
 
-QImage RasterRenderer::render(const Params& params)
+QImage MultibandRasterRenderer::render()
 {
     if (!m_provider) return QImage();
     int bands = m_provider->bandCount();
@@ -38,7 +40,7 @@ QImage RasterRenderer::render(const Params& params)
     auto chooseBandIndexForWave = [&](double wave)->int {
         if (wavelengths.empty()) {
             // fallback: select R,G,B as first three bands
-            if (bands >= 3) return (wave==params.rWave?0:(wave==params.gWave?1:2));
+            if (bands >= 3) return (wave==m_params.rWave?0:(wave==m_params.gWave?1:2));
             if (bands >= 1) return 0;
             return -1;
         }
@@ -53,9 +55,9 @@ QImage RasterRenderer::render(const Params& params)
         return std::min(2, bands-1);
     };
 
-    int rIdx = chooseBandIndexForWave(params.rWave);
-    int gIdx = chooseBandIndexForWave(params.gWave);
-    int bIdx = chooseBandIndexForWave(params.bWave);
+    int rIdx = chooseBandIndexForWave(m_params.rWave);
+    int gIdx = chooseBandIndexForWave(m_params.gWave);
+    int bIdx = chooseBandIndexForWave(m_params.bWave);
 
     std::vector<float> rbuf, gbuf, bbuf;
     if (rIdx >= 0) m_provider->readBandAsFloat(rIdx, rbuf);
@@ -63,8 +65,8 @@ QImage RasterRenderer::render(const Params& params)
     if (bIdx >= 0) m_provider->readBandAsFloat(bIdx, bbuf);
 
     std::vector<unsigned char> r8, g8, b8;
-    float minV = static_cast<float>(params.minValue);
-    float maxV = static_cast<float>(params.maxValue);
+    float minV = static_cast<float>(m_params.minValue);
+    float maxV = static_cast<float>(m_params.maxValue);
     if (!rbuf.empty()) stretchTo8bit(rbuf, r8, minV, maxV);
     if (!gbuf.empty()) stretchTo8bit(gbuf, g8, minV, maxV);
     if (!bbuf.empty()) stretchTo8bit(bbuf, b8, minV, maxV);

HPPA/MultibandRasterRenderer.h

@@ -0,0 +1,26 @@
+#pragma once
+
+#include "RasterRendererBase.h"
+#include "RasterRenderParams.h"
+#include <vector>
+#include <memory>
+
+class RasterDataProvider;
+
+class MultibandRasterRenderer : public RasterRendererBase
+{
+public:
+    explicit MultibandRasterRenderer(RasterDataProvider* provider);
+
+    QImage render() override;
+
+    // Parameter access
+    MultibandRenderParams params() const { return m_params; }
+    void setParams(const MultibandRenderParams& params) { m_params = params; }
+
+private:
+    MultibandRenderParams m_params;
+
+    // Helper to map float buffer to 8-bit with min/max stretch
+    static void stretchTo8bit(const std::vector<float>& in, std::vector<unsigned char>& out, float minVal, float maxVal);
+};

HPPA/QDoubleSlider.cpp

@@ -6,7 +6,8 @@ m_Multiplier(100.0)
 {
 	connect(this, SIGNAL(valueChanged(int)), this, SLOT(notifyValueChanged(int)));
 
-	setSingleStep(1);
+	setSingleStep(0);
+	setPageStep(0);
 	setRange(1, 500);
 
 	setOrientation(Qt::Horizontal);

HPPA/RasterImageLayer.cpp

@@ -0,0 +1,66 @@
+#include "RasterImageLayer.h"
+#include "RasterLayer.h"
+#include "RasterDataProvider.h"
+#include "RasterRendererBase.h"
+#include "MultibandRasterRenderer.h"
+#include "SinglebandRasterRenderer.h"
+
+RasterImageLayer::RasterImageLayer(RasterLayer* layer, RendererType type)
+    : m_layer(layer)
+    , m_rendererType(type)
+{
+    if (!m_layer) return;
+
+    RasterDataProvider* provider = nullptr;
+    if (m_layer->dataProvider()) {
+        provider = m_layer->dataProvider();
+    } else if (m_layer->openDataProvider()) {
+        provider = m_layer->dataProvider();
+    }
+
+    if (!provider) return;
+
+    switch (type) {
+    case RendererType::Multiband: {
+        auto* multiRenderer = new MultibandRasterRenderer(provider);
+        m_renderer.reset(multiRenderer);
+        multiRenderer->setParams(m_multibandParams);
+        break;
+    }
+    case RendererType::Singleband: {
+        auto* singleRenderer = new SinglebandRasterRenderer(provider);
+        m_renderer.reset(singleRenderer);
+        singleRenderer->setParams(m_singlebandParams);
+        break;
+    }
+    }
+}
+
+RasterImageLayer::~RasterImageLayer()
+{
+    m_renderer.reset();
+}
+
+QImage RasterImageLayer::render()
+{
+    if (!m_renderer) return QImage();
+    return m_renderer->render();
+}
+
+void RasterImageLayer::setMultibandParams(const MultibandRenderParams& params)
+{
+    m_multibandParams = params;
+    if (m_rendererType == RendererType::Multiband) {
+        auto* r = static_cast<MultibandRasterRenderer*>(m_renderer.get());
+        r->setParams(params);
+    }
+}
+
+void RasterImageLayer::setSinglebandParams(const SinglebandRenderParams& params)
+{
+    m_singlebandParams = params;
+    if (m_rendererType == RendererType::Singleband) {
+        auto* r = static_cast<SinglebandRasterRenderer*>(m_renderer.get());
+        r->setParams(params);
+    }
+}

HPPA/RasterImageLayer.h

@@ -0,0 +1,44 @@
+#pragma once
+
+#include <memory>
+#include <QImage>
+
+#include "RasterRendererBase.h"
+#include "RasterRenderParams.h"
+
+class RasterLayer;
+class RasterRendererBase;
+class MultibandRasterRenderer;
+class SinglebandRasterRenderer;
+
+class RasterImageLayer
+{
+public:
+    enum class RendererType {
+        Multiband,
+        Singleband
+    };
+
+    RasterImageLayer(RasterLayer* layer, RendererType type);
+    ~RasterImageLayer();
+
+    QImage render();
+
+    RasterLayer* layer() const { return m_layer; }
+    RasterRendererBase* renderer() const { return m_renderer.get(); }
+    RendererType rendererType() const { return m_rendererType; }
+
+    // Type-safe params access
+    MultibandRenderParams multibandParams() const { return m_multibandParams; }
+    SinglebandRenderParams singlebandParams() const { return m_singlebandParams; }
+
+    void setMultibandParams(const MultibandRenderParams& params);
+    void setSinglebandParams(const SinglebandRenderParams& params);
+
+private:
+    RasterLayer* m_layer;
+    RendererType m_rendererType;
+    std::unique_ptr<RasterRendererBase> m_renderer;
+    MultibandRenderParams m_multibandParams;
+    SinglebandRenderParams m_singlebandParams;
+};

HPPA/RasterLayer.cpp

@@ -1,12 +1,9 @@
 #include "RasterLayer.h"
 #include "RasterDataProvider.h"
-#include "RasterRenderer.h"
-#include <algorithm>
 
 RasterLayer::RasterLayer(const QString& name, const QString& uri)
     : MapLayer(name, uri)
 {
-    // lazy creation
 }
 
 RasterLayer::~RasterLayer()
@@ -23,18 +20,11 @@ RasterDataProvider* RasterLayer::dataProvider() const
     return m_provider ? m_provider.get() : nullptr;
 }
 
-RasterRenderer* RasterLayer::renderer() const
-{
-    return m_renderer ? m_renderer.get() : nullptr;
-}
-
 bool RasterLayer::openDataProvider()
 {
     if (!m_provider) m_provider = std::make_unique<RasterDataProvider>(dataPath());
     if (!m_provider) return false;
-    bool ok = m_provider->open();
-    if (ok && !m_renderer) m_renderer = std::make_unique<RasterRenderer>(m_provider.get());
-    return ok;
+    return m_provider->open();
 }
 
 bool RasterLayer::isValidPixel(int x, int y)
@@ -71,31 +61,6 @@ bool RasterLayer::readPixelSpectrum(int x, int y, QVector<double>& wavelengths,
     return true;
 }
 
-QImage RasterLayer::render(const RenderParams& params)
-{
-    if (!m_provider) {
-        if (!openDataProvider()) return QImage();
-    }
-    if (!m_renderer) m_renderer = std::make_unique<RasterRenderer>(m_provider.get());
-    RasterRenderer::Params p;
-    p.rWave = params.rWave;
-    p.gWave = params.gWave;
-    p.bWave = params.bWave;
-    p.minValue = params.minValue;
-    p.maxValue = params.maxValue;
-    return m_renderer->render(p);
-}
-
-RasterLayer::RenderParams RasterLayer::currentRenderParams() const
-{
-    return m_currentParams;
-}
-
-void RasterLayer::setCurrentRenderParams(const RenderParams& params)
-{
-    m_currentParams = params;
-}
-
 bool RasterLayer::wavelengthRange(double& minWave, double& maxWave) const
 {
     auto wl = bandWavelengths();
@@ -108,7 +73,6 @@ bool RasterLayer::wavelengthRange(double& minWave, double& maxWave) const
 std::vector<double> RasterLayer::bandWavelengths() const
 {
     if (!m_provider) {
-        // need to open provider to read wavelengths - cast away const for lazy init
         auto* self = const_cast<RasterLayer*>(this);
         if (!self->openDataProvider()) return {};
     }

HPPA/RasterLayer.h

@@ -2,11 +2,10 @@
 
 #include "MapLayer.h"
 #include <memory>
-#include <QImage>
 #include <QVector>
+#include <vector>
 
 class RasterDataProvider;
-class RasterRenderer;
 
 class RasterLayer : public MapLayer
 {
@@ -17,9 +16,8 @@ public:
 
     LayerType layerType() const override;
 
-    // Access provider/renderer
+    // Access provider
     RasterDataProvider* dataProvider() const;
-    RasterRenderer* renderer() const;
 
     // Create or open provider based on this layer's uri
     bool openDataProvider();
@@ -27,29 +25,12 @@ public:
     bool isValidPixel(int x, int y);
     bool readPixelSpectrum(int x, int y, QVector<double>& wavelengths, QVector<double>& spectrum);
 
-    struct RenderParams {
-        double rWave = 665.0; // default wavelengths (nm)
-        double gWave = 560.0;
-        double bWave = 490.0;
-        double minValue = 0.0; // optional stretch
-        double maxValue = 4095.0;
-    };
-
-    // Render the raster using current provider and renderer. Returns an empty QImage on failure.
-    QImage render(const RenderParams& params);
-
-    // Current render params stored per layer
-    RenderParams currentRenderParams() const;
-    void setCurrentRenderParams(const RenderParams& params);
-
     // Get wavelength range from data provider (min, max). Returns false if unavailable.
     bool wavelengthRange(double& minWave, double& maxWave) const;
 
     // Get all band wavelengths
     std::vector<double> bandWavelengths() const;
 
-private:
+protected:
     std::unique_ptr<RasterDataProvider> m_provider;
-    std::unique_ptr<RasterRenderer> m_renderer;
-    RenderParams m_currentParams;
 };

HPPA/RasterRenderParams.h

@@ -0,0 +1,19 @@
+#pragma once
+
+// Common base struct for all render parameters
+struct RasterRenderParamsBase {
+    double minValue = 0.0;
+    double maxValue = 4095.0;
+};
+
+// Parameters for multiband rendering (RGB with wavelengths)
+struct MultibandRenderParams : RasterRenderParamsBase {
+    double rWave = 665.0;
+    double gWave = 560.0;
+    double bWave = 490.0;
+};
+
+// Parameters for singleband rendering (wavelength)
+struct SinglebandRenderParams : RasterRenderParamsBase {
+    double wavelength = 550.0;
+};

HPPA/RasterRenderer.h

@@ -1,29 +0,0 @@
-#pragma once
-
-#include <QImage>
-#include <vector>
-
-class RasterDataProvider;
-
-class RasterRenderer
-{
-public:
-    struct Params {
-        double rWave = 665.0;
-        double gWave = 560.0;
-        double bWave = 490.0;
-        double minValue = 0.0;
-        double maxValue = 255.0;
-    };
-
-    explicit RasterRenderer(RasterDataProvider* provider);
-
-    // Render to an 8-bit RGB image. Returns empty image on failure.
-    QImage render(const Params& params);
-
-private:
-    RasterDataProvider* m_provider;
-
-    // helper to map float buffer to 8-bit with min/max stretch
-    static void stretchTo8bit(const std::vector<float>& in, std::vector<unsigned char>& out, float minVal, float maxVal);
-};

HPPA/RasterRendererBase.cpp

@@ -0,0 +1,6 @@
+#include "RasterRendererBase.h"
+
+RasterRendererBase::RasterRendererBase(RasterDataProvider* provider)
+	: m_provider(provider)
+{
+}

HPPA/RasterRendererBase.h

@@ -0,0 +1,25 @@
+#pragma once
+
+#include <QImage>
+#include <memory>
+
+class RasterDataProvider;
+
+class RasterRendererBase
+{
+public:
+    //struct Params {
+    //    virtual ~Params() = default;
+    //};
+
+    virtual ~RasterRendererBase() = default;
+
+    virtual QImage render() = 0;
+
+    RasterDataProvider* dataProvider() const { return m_provider; }
+
+protected:
+    explicit RasterRendererBase(RasterDataProvider* provider);
+
+    RasterDataProvider* m_provider = nullptr;
+};

HPPA/SingleLensReflexCamera.ui

@@ -0,0 +1,160 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<ui version="4.0">
+ <class>SingleLensReflexCameraClass</class>
+ <widget class="QDialog" name="SingleLensReflexCameraClass">
+  <property name="geometry">
+   <rect>
+    <x>0</x>
+    <y>0</y>
+    <width>855</width>
+    <height>481</height>
+   </rect>
+  </property>
+  <property name="sizePolicy">
+   <sizepolicy hsizetype="Expanding" vsizetype="Expanding">
+    <horstretch>0</horstretch>
+    <verstretch>0</verstretch>
+   </sizepolicy>
+  </property>
+  <property name="windowTitle">
+   <string>SingleLensReflexCamera</string>
+  </property>
+  <property name="styleSheet">
+   <string notr="true">QGroupBox
+{
+	border: 12px solid transparent;
+	/*border-top: 12px solid transparent;
+    border-right: 0px solid transparent;
+    border-bottom: 0px solid transparent;
+    border-left: 0px solid transparent;*/
+	color: #ACCDFF;
+}
+
+QPushButton
+{
+	/*width: 172px;
+	height: 56px;*/
+	font: 19pt &quot;新宋体&quot;;
+	background-color: qlineargradient(
+        spread:pad, 
+        x1:0.5, y1:0, x2:0.5, y2:1, 
+        stop:0 #283D86, 
+        stop:1 #0F1A40
+    );
+	color: white;
+    border: none;
+    padding: 8px 16px;
+    border-radius: 4px;
+}
+QPushButton:hover
+{
+    background-color: qlineargradient(
+        spread:pad, 
+        x1:0, y1:0, x2:1, y2:0, 
+        stop:0 #3A4875, 
+        stop:1 #5F6B91
+    );
+}
+/* 按下时的效果 */
+QPushButton:pressed
+{
+    background-color: qlineargradient(
+        spread:pad, 
+        x1:0, y1:0, x2:1, y2:0, 
+        stop:0 #1A254F, 
+        stop:1 #3A466B
+    );
+    /* 可选：添加下压效果 */
+    padding-top: 9px;
+    padding-bottom: 7px;
+}</string>
+  </property>
+  <layout class="QGridLayout" name="gridLayout_2">
+   <item row="0" column="1">
+    <spacer name="verticalSpacer">
+     <property name="orientation">
+      <enum>Qt::Vertical</enum>
+     </property>
+     <property name="sizeHint" stdset="0">
+      <size>
+       <width>18</width>
+       <height>100</height>
+      </size>
+     </property>
+    </spacer>
+   </item>
+   <item row="1" column="0">
+    <spacer name="horizontalSpacer">
+     <property name="orientation">
+      <enum>Qt::Horizontal</enum>
+     </property>
+     <property name="sizeHint" stdset="0">
+      <size>
+       <width>135</width>
+       <height>20</height>
+      </size>
+     </property>
+    </spacer>
+   </item>
+   <item row="1" column="1">
+    <layout class="QGridLayout" name="gridLayout">
+     <item row="0" column="1">
+      <widget class="QPushButton" name="closeSLRCamera_btn">
+       <property name="sizePolicy">
+        <sizepolicy hsizetype="Expanding" vsizetype="Expanding">
+         <horstretch>0</horstretch>
+         <verstretch>0</verstretch>
+        </sizepolicy>
+       </property>
+       <property name="text">
+        <string>关   闭</string>
+       </property>
+      </widget>
+     </item>
+     <item row="0" column="0">
+      <widget class="QPushButton" name="openSLRCamera_btn">
+       <property name="sizePolicy">
+        <sizepolicy hsizetype="Expanding" vsizetype="Expanding">
+         <horstretch>0</horstretch>
+         <verstretch>0</verstretch>
+        </sizepolicy>
+       </property>
+       <property name="text">
+        <string>打   开</string>
+       </property>
+      </widget>
+     </item>
+    </layout>
+   </item>
+   <item row="1" column="2">
+    <spacer name="horizontalSpacer_2">
+     <property name="orientation">
+      <enum>Qt::Horizontal</enum>
+     </property>
+     <property name="sizeHint" stdset="0">
+      <size>
+       <width>135</width>
+       <height>20</height>
+      </size>
+     </property>
+    </spacer>
+   </item>
+   <item row="2" column="1">
+    <spacer name="verticalSpacer_3">
+     <property name="orientation">
+      <enum>Qt::Vertical</enum>
+     </property>
+     <property name="sizeHint" stdset="0">
+      <size>
+       <width>18</width>
+       <height>100</height>
+      </size>
+     </property>
+    </spacer>
+   </item>
+  </layout>
+ </widget>
+ <layoutdefault spacing="6" margin="11"/>
+ <resources/>
+ <connections/>
+</ui>

HPPA/SingleLensReflexCameraWindow.cpp

@@ -0,0 +1,95 @@
+#include "SingleLensReflexCameraWindow.h"
+
+SingleLensReflexCameraWindow::SingleLensReflexCameraWindow(QWidget* parent)
+    : QDialog(parent)
+{
+    ui.setupUi(this);
+
+    m_SLRCameraThread = new QThread();
+    m_SingleLensReflexCameraOperation = new SingleLensReflexCameraOperation();
+    m_SingleLensReflexCameraOperation->moveToThread(m_SLRCameraThread);
+    m_SLRCameraThread->start();
+
+    connect(ui.openSLRCamera_btn, &QPushButton::clicked, this, &SingleLensReflexCameraWindow::openSLRCamera);
+    connect(ui.closeSLRCamera_btn, &QPushButton::clicked, this, &SingleLensReflexCameraWindow::closeSLRCamera);
+
+    connect(this, &SingleLensReflexCameraWindow::openSLRCameraSignal, m_SingleLensReflexCameraOperation, &SingleLensReflexCameraOperation::OpenSLRCamera);
+
+    connect(m_SingleLensReflexCameraOperation, &SingleLensReflexCameraOperation::CamOpenedSignal, this, &SingleLensReflexCameraWindow::onCamOpened);
+    connect(m_SingleLensReflexCameraOperation, &SingleLensReflexCameraOperation::CamClosedSignal, this, &SingleLensReflexCameraWindow::onCamClosed);
+
+    connect(m_SingleLensReflexCameraOperation, &SingleLensReflexCameraOperation::PlotSignal, this, &SingleLensReflexCameraWindow::PlotSLRImageSignal);
+    connect(m_SingleLensReflexCameraOperation, &SingleLensReflexCameraOperation::CamClosedSignal, this, &SingleLensReflexCameraWindow::SLRCamClosedSignal);
+}
+
+SingleLensReflexCameraWindow::~SingleLensReflexCameraWindow()
+{
+    m_SLRCameraThread->quit();
+    m_SLRCameraThread->wait();
+    delete m_SingleLensReflexCameraOperation;
+    m_SingleLensReflexCameraOperation = nullptr;
+}
+
+void SingleLensReflexCameraWindow::openSLRCamera()
+{
+    if (!m_SingleLensReflexCameraOperation->getRecordStatus())
+    {
+        emit openSLRCameraSignal();
+    }
+}
+
+void SingleLensReflexCameraWindow::onCamOpened()
+{
+    ui.openSLRCamera_btn->setEnabled(false);
+    ui.closeSLRCamera_btn->setEnabled(true);
+
+    ui.openSLRCamera_btn->setText(QString::fromLocal8Bit("已打开"));
+}
+
+void SingleLensReflexCameraWindow::closeSLRCamera()
+{
+    m_SingleLensReflexCameraOperation->CloseSLRCamera();
+}
+
+void SingleLensReflexCameraWindow::onCamClosed()
+{
+    ui.openSLRCamera_btn->setEnabled(true);
+    ui.closeSLRCamera_btn->setEnabled(false);
+
+    ui.openSLRCamera_btn->setText(QString::fromLocal8Bit("打   开"));
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------
+SingleLensReflexCameraOperation::SingleLensReflexCameraOperation()
+{
+    m_func = nullptr;
+    record = false;
+}
+
+SingleLensReflexCameraOperation::~SingleLensReflexCameraOperation()
+{
+}
+
+void SingleLensReflexCameraOperation::OpenSLRCamera()
+{
+    
+}
+
+void SingleLensReflexCameraOperation::OpenSLRCamera_callback()
+{
+
+}
+
+void SingleLensReflexCameraOperation::setCallback(void(*func)())
+{
+    m_func = func;
+}
+
+void SingleLensReflexCameraOperation::CloseSLRCamera()
+{
+    std::cout << "SingleLensReflexCameraOperation::CloseSLRCamera，关闭单反相机" << std::endl;
+
+    record = false;
+
+    emit CamClosedSignal();
+}

HPPA/SingleLensReflexCameraWindow.h

@@ -0,0 +1,76 @@
+#pragma once
+
+#include <QDialog>
+#include <QNetworkRequest>
+#include <QNetworkReply>
+#include <QNetworkAccessManager>
+#include <QImage>
+#include <Qthread>
+#include <QDir>
+
+#include <iostream>
+#include "ui_SingleLensReflexCamera.h"
+#include "AppSettings.h"
+
+#include <fstream>
+#include <opencv2/opencv.hpp>
+typedef void(*func)();
+
+class SingleLensReflexCameraOperation :public QObject
+{
+	Q_OBJECT
+
+public:
+	SingleLensReflexCameraOperation();
+	~SingleLensReflexCameraOperation();
+
+	QImage m_colorImage;
+	QImage m_depthImage;
+	void setCallback(void(*func)());
+	bool getRecordStatus() const { return record; }
+
+private:
+	cv::Mat frame;
+
+	func m_func;
+
+	bool record;
+
+public slots:
+	void OpenSLRCamera();
+	void OpenSLRCamera_callback();//不使用信号而使用回调函数来通知界面刷新视频
+	void CloseSLRCamera();
+
+signals:
+	void PlotSignal();
+
+	void CamOpenedSignal();
+	void CamClosedSignal();
+};
+
+class SingleLensReflexCameraWindow : public QDialog
+{
+	Q_OBJECT
+
+public:
+	SingleLensReflexCameraWindow(QWidget* parent = nullptr);
+	~SingleLensReflexCameraWindow();
+
+	SingleLensReflexCameraOperation* m_SingleLensReflexCameraOperation;
+
+public Q_SLOTS:
+	void openSLRCamera();
+	void onCamOpened();
+	void closeSLRCamera();
+	void onCamClosed();
+
+signals:
+	void openSLRCameraSignal();
+	void PlotSLRImageSignal();
+	void SLRCamClosedSignal();
+
+private:
+	Ui::SingleLensReflexCameraClass ui;
+	QThread* m_SLRCameraThread;
+
+};

HPPA/SinglebandRasterRenderer.cpp

@@ -0,0 +1,85 @@
+#include "SinglebandRasterRenderer.h"
+#include "RasterDataProvider.h"
+#include <algorithm>
+
+SinglebandRasterRenderer::SinglebandRasterRenderer(RasterDataProvider* provider)
+    : RasterRendererBase(provider)
+{
+}
+
+void SinglebandRasterRenderer::stretchTo8bit(const std::vector<float>& in, std::vector<unsigned char>& out, float minVal, float maxVal)
+{
+    size_t n = in.size();
+    out.resize(n);
+    if (maxVal <= minVal) {
+        std::fill(out.begin(), out.end(), 0);
+        return;
+    }
+    float denom = 1.0f / (maxVal - minVal);
+    for (size_t i = 0; i < n; ++i) {
+        float v = (in[i] - minVal) * denom;
+        v = std::min(std::max(v, 0.0f), 1.0f);
+        out[i] = static_cast<unsigned char>(v * 255.0f);
+    }
+}
+
+int SinglebandRasterRenderer::nearestBandIndex(double wave) const
+{
+    if (!m_provider) return -1;
+
+    int bands = m_provider->bandCount();
+    if (bands <= 0) return -1;
+
+    std::vector<double> wavelengths = m_provider->bandWavelengths();
+    if (wavelengths.empty()) {
+        // No wavelengths available, fallback to first band
+        return 0;
+    }
+
+    int best = -1;
+    double bestDiff = 1e12;
+    for (int i = 0; i < (int)wavelengths.size(); ++i) {
+        if (wavelengths[i] < 0) continue;
+        double d = std::abs(wavelengths[i] - wave);
+        if (d < bestDiff) {
+            bestDiff = d;
+            best = i;
+        }
+    }
+
+    return (best >= 0) ? best : 0;
+}
+
+QImage SinglebandRasterRenderer::render()
+{
+    if (!m_provider) return QImage();
+
+    int w = m_provider->width();
+    int h = m_provider->height();
+    if (w <= 0 || h <= 0) return QImage();
+
+    int bandIdx = nearestBandIndex(m_params.wavelength);
+    if (bandIdx < 0 || bandIdx >= m_provider->bandCount()) {
+        bandIdx = 0;
+    }
+
+    std::vector<float> buf;
+    m_provider->readBandAsFloat(bandIdx, buf);
+
+    std::vector<unsigned char> gray8;
+    float minV = static_cast<float>(m_params.minValue);
+    float maxV = static_cast<float>(m_params.maxValue);
+    if (!buf.empty()) {
+        stretchTo8bit(buf, gray8, minV, maxV);
+    }
+
+    QImage out(w, h, QImage::Format_Grayscale8);
+    for (int y = 0; y < h; ++y) {
+        unsigned char* scan = out.scanLine(y);
+        for (int x = 0; x < w; ++x) {
+            int idx = y * w + x;
+            scan[x] = (gray8.size() > (size_t)idx) ? gray8[idx] : 0;
+        }
+    }
+    return out;
+}

HPPA/SinglebandRasterRenderer.h

@@ -0,0 +1,27 @@
+#pragma once
+
+#include "RasterRendererBase.h"
+#include "RasterRenderParams.h"
+#include <vector>
+
+class RasterDataProvider;
+
+class SinglebandRasterRenderer : public RasterRendererBase
+{
+public:
+    explicit SinglebandRasterRenderer(RasterDataProvider* provider);
+
+    QImage render() override;
+
+    // Parameter access
+    SinglebandRenderParams params() const { return m_params; }
+    void setParams(const SinglebandRenderParams& params) { m_params = params; }
+
+private:
+    SinglebandRenderParams m_params;
+
+    int nearestBandIndex(double wave) const;
+
+    // Helper to map float buffer to 8-bit with min/max stretch
+    static void stretchTo8bit(const std::vector<float>& in, std::vector<unsigned char>& out, float minVal, float maxVal);
+};

HPPA/TabManager.cpp

@@ -7,6 +7,24 @@ TabManager::TabManager(QTabWidget* tabWidget, QObject* parent)
     Q_ASSERT(m_tabWidget);
 }
 
+void TabManager::hideAllTabs()
+{
+    int tabNumber = m_tabWidget->count();
+    for (size_t i = 0; i < tabNumber; i++)
+    {
+        int idx = 0;
+
+        TabInfo info;
+        info.index = idx;
+        info.text = m_tabWidget->tabText(idx);
+        info.icon = m_tabWidget->tabIcon(idx);
+        info.toolTip = m_tabWidget->tabToolTip(idx);
+
+        m_hiddenTabs.insert(m_tabWidget->widget(idx), info);
+        m_tabWidget->removeTab(idx);
+    }
+}
+
 void TabManager::hideTab(QWidget* page)
 {
     if (!page || !m_tabWidget)

HPPA/TabManager.h

@@ -10,6 +10,7 @@ class TabManager : public QObject
 public:
     explicit TabManager(QTabWidget* tabWidget, QObject* parent = nullptr);
 
+	void hideAllTabs();
     void hideTab(QWidget* page);
     void showTab(QWidget* page);
     bool isHidden(QWidget* page) const;

HPPA/View3D.cpp

@@ -373,3 +373,17 @@ void View3DLinearStage::setLoc(std::vector<double> loc)
 
     m_armTransform->setTranslation(QVector3D(x, 0, 0));
 }
+
+View3DMicroscopicMotionModel::View3DMicroscopicMotionModel(const QString& baseModelPath, const QString& armModelPath, QWidget* parent)
+    :View3DBase(baseModelPath, armModelPath, parent)
+{
+
+}
+
+void View3DMicroscopicMotionModel::setLoc(std::vector<double> loc)
+{
+    double x = round(loc[0] * 100) / 100;
+    double y = round(loc[1] * 100) / 100;
+
+    m_armTransform->setTranslation(QVector3D(x, y, 0));
+}

HPPA/View3D.h

@@ -106,6 +106,24 @@ private:
 
 private:
 
+public Q_SLOTS:
+    void setLoc(std::vector<double> loc);
+};
+
+class View3DMicroscopicMotionModel : public View3DBase
+{
+    Q_OBJECT
+public:
+    View3DMicroscopicMotionModel(const QString& baseModelPath,
+        const QString& armModelPath,
+        QWidget* parent = nullptr);
+
+protected:
+
+private:
+
+private:
+
 public Q_SLOTS:
     void setLoc(std::vector<double> loc);
 };

HPPA/View3DModelManager.cpp

@@ -13,15 +13,21 @@ View3DModelManager::View3DModelManager(QWidget* parent)
 
 void View3DModelManager::switchScenario(ScenarioType type)
 {
-    if (type == ScenarioType::PlantPhenotype) {
+    if (type == ScenarioType::PlantPhenotype) 
+    {
         ensurePlantPhenotypeView();
         m_stackedWidget->setCurrentWidget(m_viewPlant);
     }
-    else {
+    if (type == ScenarioType::OneMotor)
+    {
         ensureOneMotorView();
         m_stackedWidget->setCurrentWidget(m_viewMotor);
     }
-
+    if (type == ScenarioType::MicroscopicMotionControl)
+    {
+        ensureMicroscopicMotionControlView();
+        m_stackedWidget->setCurrentWidget(m_viewMicroscopicMotionControlModel);
+    }
     emit scenarioChanged(type);
 }
 
@@ -46,6 +52,27 @@ void View3DModelManager::ensurePlantPhenotypeView()
     emit created3DModelPlantPhenotype();
 }
 
+void View3DModelManager::ensureMicroscopicMotionControlView()
+{
+    if (m_viewMicroscopicMotionControlModel)
+        return;
+
+    QString basePath = QCoreApplication::applicationDirPath();
+
+    m_viewMicroscopicMotionControlModel = new View3DMicroscopicMotionModel(
+        basePath + "/3DModel/MicroscopicMotionModel_static.obj",
+        basePath + "/3DModel/MicroscopicMotionModel_moving.obj",
+        m_stackedWidget
+    );
+
+    m_viewMicroscopicMotionControlModel->setViewCenter(1000, 1000, -1000);
+    m_viewMicroscopicMotionControlModel->setDistance(5000);
+
+    m_stackedWidget->addWidget(m_viewMicroscopicMotionControlModel);
+
+    emit created3DModelMicroscopicMotion();
+}
+
 void View3DModelManager::ensureOneMotorView()
 {
     if (m_viewMotor)

HPPA/View3DModelManager.h

@@ -16,7 +16,8 @@ class View3DModelManager : public QWidget
 public:
     enum class ScenarioType {
         PlantPhenotype,
-        OneMotor
+        OneMotor,
+        MicroscopicMotionControl
     };
 
     explicit View3DModelManager(QWidget* parent = nullptr);
@@ -25,14 +26,17 @@ public:
 
     View3DPlantPhenotype* m_viewPlant = nullptr;
     View3DLinearStage* m_viewMotor = nullptr;
+    View3DMicroscopicMotionModel* m_viewMicroscopicMotionControlModel = nullptr;
 
 signals:
     void scenarioChanged(ScenarioType type);
     void created3DModelPlantPhenotype();
     void created3DModelOneMotor();
+    void created3DModelMicroscopicMotion();
 
 private:
     void ensurePlantPhenotypeView();
+    void ensureMicroscopicMotionControlView();
     void ensureOneMotorView();
 
 private:

HPPA/about.ui

@@ -288,7 +288,7 @@ QPushButton:pressed
 }</string>
             </property>
             <property name="text">
-             <string>版本：3.0.1</string>
+             <string>版本：3.0.2</string>
             </property>
            </widget>
           </item>

HPPA/imageControl.cpp

@@ -1,5 +1,5 @@
 #include "imageControl.h"
-#include "RasterLayer.h"
+#include "RasterImageLayer.h"
 #include <algorithm>
 #include <cmath>
 
@@ -8,6 +8,14 @@ ImageControl::ImageControl(QWidget* parent)
 {
 	ui.setupUi(this);
 
+	ui.sliderRed->setPageStep(0);
+	ui.sliderGreen->setPageStep(0);
+	ui.sliderBlue->setPageStep(0);
+
+	ui.sliderRed->setSingleStep(0);
+	ui.sliderGreen->setSingleStep(0);
+	ui.sliderBlue->setSingleStep(0);
+
 	// Spinbox valueChanged: only sync the paired slider (no render)
 	connect(ui.spinRed, QOverload<double>::of(&QDoubleSpinBox::valueChanged), this, &ImageControl::onSpinRedValueChanged);
 	connect(ui.spinGreen, QOverload<double>::of(&QDoubleSpinBox::valueChanged), this, &ImageControl::onSpinGreenValueChanged);
@@ -91,7 +99,7 @@ ImageControl::~ImageControl()
 {
 }
 
-void ImageControl::setActiveLayer(RasterLayer* layer)
+void ImageControl::setActiveLayer(RasterImageLayer* layer)
 {
 	m_activeLayer = layer;
 
@@ -102,8 +110,8 @@ void ImageControl::setActiveLayer(RasterLayer* layer)
 	}
 	setEnabled(true);
 
-	// Get band wavelengths from the layer's header
-	m_wavelengths = layer->bandWavelengths();
+	// Get band wavelengths from the underlying RasterLayer's header
+	m_wavelengths = layer->layer()->bandWavelengths();
 	std::sort(m_wavelengths.begin(), m_wavelengths.end());
 
 	if (m_wavelengths.empty()) {
@@ -137,19 +145,13 @@ void ImageControl::setActiveLayer(RasterLayer* layer)
 	int maxIdx = static_cast<int>(m_wavelengths.size()) - 1;
 	ui.sliderRed->setMinimum(0);
 	ui.sliderRed->setMaximum(maxIdx);
-	ui.sliderRed->setSingleStep(1);
-	ui.sliderRed->setPageStep(1);
 	ui.sliderGreen->setMinimum(0);
 	ui.sliderGreen->setMaximum(maxIdx);
-	ui.sliderGreen->setSingleStep(1);
-	ui.sliderGreen->setPageStep(1);
 	ui.sliderBlue->setMinimum(0);
 	ui.sliderBlue->setMaximum(maxIdx);
-	ui.sliderBlue->setSingleStep(1);
-	ui.sliderBlue->setPageStep(1);
 
-	// Set current values from layer's render params
-	auto params = layer->currentRenderParams();
+	// Set current values from layer's render params (multiband)
+	auto params = layer->multibandParams();
 
 	int rIdx = nearestBandIndex(params.rWave);
 	int gIdx = nearestBandIndex(params.gWave);
@@ -166,7 +168,7 @@ void ImageControl::setActiveLayer(RasterLayer* layer)
 	blockAllSignals(false);
 }
 
-RasterLayer* ImageControl::activeLayer() const
+RasterImageLayer* ImageControl::activeLayer() const
 {
 	return m_activeLayer;
 }
@@ -324,13 +326,13 @@ void ImageControl::emitBandChange()
 	double g = ui.spinGreen->value();
 	double b = ui.spinBlue->value();
 
-	// Update active layer's stored render params
+	// Update active layer's stored render params (multiband)
 	if (m_activeLayer) {
-		auto params = m_activeLayer->currentRenderParams();
+		auto params = m_activeLayer->multibandParams();
 		params.rWave = r;
 		params.gWave = g;
 		params.bWave = b;
-		m_activeLayer->setCurrentRenderParams(params);
+		m_activeLayer->setMultibandParams(params);
 	}
 
 	emit bandSelectionChanged(r, g, b);

HPPA/imageControl.h

@@ -6,9 +6,10 @@
 #include <QNetworkAccessManager>
 #include <vector>
 
+#include "RasterLayer.h"
 #include "ui_imgControl.h"
 
-class RasterLayer;
+class RasterImageLayer;
 
 class ImageControl : public QDialog
 {
@@ -18,9 +19,9 @@ public:
 	ImageControl(QWidget* parent = nullptr);
 	~ImageControl();
 
-	// Populate controls from a RasterLayer's wavelength info and current render params
-	void setActiveLayer(RasterLayer* layer);
-	RasterLayer* activeLayer() const;
+	// Populate controls from a RasterImageLayer's wavelength info and current render params
+	void setActiveLayer(RasterImageLayer* layer);
+	RasterImageLayer* activeLayer() const;
 
 public Q_SLOTS:
 
@@ -62,7 +63,7 @@ private:
 	void setControlsToBandIndex(QDoubleSpinBox* spin, QSlider* slider, int idx);
 
 	Ui::ImageControl ui;
-	RasterLayer* m_activeLayer = nullptr;
+	RasterImageLayer* m_activeLayer = nullptr;
 	double m_minWave = 374.5;
 	double m_maxWave = 948.1;
 	std::vector<double> m_wavelengths; // band wavelengths from header

HPPA/set.ui

@@ -9,8 +9,8 @@
    <rect>
     <x>0</x>
     <y>0</y>
-    <width>486</width>
-    <height>229</height>
+    <width>641</width>
+    <height>320</height>
    </rect>
   </property>
   <property name="windowTitle">
@@ -234,26 +234,58 @@ QPushButton:pressed
       </item>
       <item row="1" column="0">
        <widget class="QWidget" name="widget" native="true">
-        <layout class="QGridLayout" name="gridLayout_2">
+        <layout class="QGridLayout" name="gridLayout_2" rowstretch="3,2">
          <item row="0" column="0">
-          <widget class="QLabel" name="label">
-           <property name="text">
-            <string>数据路径</string>
-           </property>
+          <widget class="QWidget" name="widget_2" native="true">
+           <layout class="QGridLayout" name="gridLayout_3">
+            <item row="0" column="0">
+             <widget class="QLabel" name="label">
+              <property name="text">
+               <string>数据路径</string>
+              </property>
+             </widget>
+            </item>
+            <item row="0" column="1">
+             <widget class="QLineEdit" name="dataFolderLineEdit">
+              <property name="readOnly">
+               <bool>true</bool>
+              </property>
+             </widget>
+            </item>
+            <item row="0" column="2">
+             <widget class="QPushButton" name="dataFolderBtn">
+              <property name="text">
+               <string>...</string>
+              </property>
+             </widget>
+            </item>
+           </layout>
           </widget>
          </item>
-         <item row="0" column="1">
-          <widget class="QLineEdit" name="dataFolderLineEdit">
-           <property name="readOnly">
-            <bool>true</bool>
-           </property>
-          </widget>
-         </item>
-         <item row="0" column="2">
-          <widget class="QPushButton" name="dataFolderBtn">
-           <property name="text">
-            <string>...</string>
-           </property>
+         <item row="1" column="0">
+          <widget class="QWidget" name="widget_3" native="true">
+           <layout class="QGridLayout" name="gridLayout_4" columnstretch="5,2">
+            <item row="0" column="0">
+             <spacer name="horizontalSpacer">
+              <property name="orientation">
+               <enum>Qt::Horizontal</enum>
+              </property>
+              <property name="sizeHint" stdset="0">
+               <size>
+                <width>411</width>
+                <height>20</height>
+               </size>
+              </property>
+             </spacer>
+            </item>
+            <item row="0" column="1">
+             <widget class="QPushButton" name="confirmBtn">
+              <property name="text">
+               <string>确认</string>
+              </property>
+             </widget>
+            </item>
+           </layout>
           </widget>
          </item>
         </layout>

HPPA/setWindow.cpp

@@ -12,6 +12,7 @@ setWindow::setWindow(QWidget* parent)
 
 	connect(this->ui.closeBtn, SIGNAL(released()), this, SLOT(onExit()));
 	connect(this->ui.dataFolderBtn, SIGNAL(clicked()), this, SLOT(onSelectDataFolder()));
+	connect(this->ui.confirmBtn, SIGNAL(clicked()), this, SLOT(onExit()));
 
 	loadSettings();
 }