diff --git a/HPPA/HPPA.cpp b/HPPA/HPPA.cpp index 9de49d0..a8a6fe0 100644 --- a/HPPA/HPPA.cpp +++ b/HPPA/HPPA.cpp @@ -7,11 +7,15 @@ #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 +#include HPPA* HPPA::s_instance = nullptr; @@ -818,8 +822,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) @@ -1011,6 +1015,7 @@ void HPPA::removeLayerByTreeIndex() auto* layerNode = static_cast(node); MapLayer* mapLayer = layerNode->mapLayer(); + QWidget* layerWidget = nullptr; if (mapLayer && m_MapLayerStore) @@ -1042,6 +1047,68 @@ void HPPA::removeLayerByTreeIndex() } } +void HPPA::showColorImageByTreeIndex() +{ + QModelIndex currentIndexTmp = m_layerTreeView->currentIndex(); + + if (!currentIndexTmp.isValid()) return; + + LayerTreeModel* model = const_cast(static_cast(currentIndexTmp.model())); + if (!model) return; + + LayerTreeNode* node = static_cast(currentIndexTmp.internalPointer()); + if (!node || node->type() != LayerTreeNode::Type::Layer) return; + + auto* layerNode = static_cast(node); + MapLayer* mapLayer = layerNode->mapLayer(); + +} + +void HPPA::removeImageByTreeIndex() +{ + QModelIndex currentIndexTmp = m_layerTreeView->currentIndex(); + + if (!currentIndexTmp.isValid()) return; + + LayerTreeModel* model = const_cast(static_cast(currentIndexTmp.model())); + if (!model) return; + + LayerTreeNode* node = static_cast(currentIndexTmp.internalPointer()); + if (!node || node->type() != LayerTreeNode::Type::Image) return; + + auto* layerNode = static_cast(node); + RasterImageLayer* rasterImageLayer = layerNode->imageLayer(); + QWidget* layerWidget = nullptr; + + if (rasterImageLayer && m_MapLayerStore) + { + layerWidget = m_MapLayerStore->widgetForImageLayer(rasterImageLayer); + m_MapLayerStore->removeImageLayer(rasterImageLayer); + } + + if (layerWidget && m_imageViewerTabWidget) + { + const int tabIndex = m_imageViewerTabWidget->indexOf(layerWidget); + if (tabIndex >= 0) + { + if (m_recordFrameCounter) + { + m_recordFrameCounter->removeCounter(layerWidget); + } + m_imageViewerTabWidget->removeTab(tabIndex); + } + layerWidget->deleteLater(); + } + + LayerTreeNode* parent = node->parentNode(); + int row = node->rowInParent(); + LayerTreeNode* removed = model->removeNode(parent, row); + if (removed) + { + delete removed; + } +} + void HPPA::removeAllLayersInRasterGroup() { if (!m_LayerTreeModel || !m_RasterGroup) return; @@ -1651,7 +1718,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 @@ -1671,10 +1738,9 @@ void HPPA::onTabWidgetCurrentChanged(int index)//代码新建一个tab，会调 m_layerTreeView->selectionModel()->blockSignals(false); // Manually update ImageControl since we blocked the signal - RasterLayer* rl = qobject_cast(layer); - if (rl) - { - m_ic->setActiveLayer(rl); + QList mapcavas = currentWidget->findChildren(); + if (!mapcavas.isEmpty()) { + m_ic->setActiveLayer(mapcavas[0]->imageLayer()); } break; } @@ -2546,10 +2612,17 @@ void HPPA::addLayer(const QString& baseName, const QString& filePath,bool refres auto* layerNode = new LayerTreeLayer(ml); LayerTreeNode* node = m_LayerTreeModel->addLayer(m_RasterGroup, layerNode); + if (m_MapLayerStore) m_MapLayerStore->addLayer(ml); + QWidget* mapcavasContainer = onCreateTab(baseName); - if (m_MapLayerStore) m_MapLayerStore->addLayer(ml, mapcavasContainer); + RasterImageLayer* rasterImageLayer = new RasterImageLayer(ml, RasterImageLayer::RendererType::Multiband); QList mapcavas = mapcavasContainer->findChildren(); - mapcavas[0]->setLayers(ml); + mapcavas[0]->setImageLayer(rasterImageLayer); + + LayerTreeImageNode* imageNode = new LayerTreeImageNode(rasterImageLayer, "222"); + LayerTreeNode* node2 = m_LayerTreeModel->addLayer(node, imageNode); + + if (m_MapLayerStore) m_MapLayerStore->addImageLayer(ml, rasterImageLayer, mapcavasContainer); if (refresh) { @@ -2585,9 +2658,6 @@ void HPPA::onLayerTreeSelectionChanged(const QItemSelection& selected, const QIt return; } - RasterLayer* rl = static_cast(mapLayer); - m_ic->setActiveLayer(rl); - // Also switch to the corresponding tab in the image viewer if (m_MapLayerStore && m_imageViewerTabWidget) { QWidget* widget = m_MapLayerStore->widgetForLayer(mapLayer); @@ -2597,28 +2667,37 @@ void HPPA::onLayerTreeSelectionChanged(const QItemSelection& selected, const QIt m_imageViewerTabWidget->setCurrentIndex(tabIndex); } } + + // Get RasterImageLayer from the Mapcavas container + QList mapcavas = widget->findChildren(); + 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->widgetForLayer(mapLayer); if (!container) return; QList mapcavas = container->findChildren(); 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(); } diff --git a/HPPA/HPPA.h b/HPPA/HPPA.h index 2f2058b..dbfd1f4 100644 --- a/HPPA/HPPA.h +++ b/HPPA/HPPA.h @@ -81,6 +81,8 @@ #include "DepthCameraWindow.h" #include "SingleLensReflexCameraWindow.h" +#include "LayerTreeImageNode.h" + #define PI 3.1415926 QT_CHARTS_USE_NAMESPACE//QChartView 使用 需要加宏， 否则无法使用 @@ -375,6 +377,7 @@ public Q_SLOTS: void addLayer(const QString& baseName, const QString& filePath, bool refresh); void onLayerCreatedFromFile(const QString& baseName, const QString& filePath, int fileIndex); void removeLayerByTreeIndex(); + void removeImageByTreeIndex(); void removeAllLayersInRasterGroup(); void onLayerTreeSelectionChanged(const QItemSelection& selected, const QItemSelection& deselected); diff --git a/HPPA/HPPA.vcxproj b/HPPA/HPPA.vcxproj index 0330060..f012c11 100644 --- a/HPPA/HPPA.vcxproj +++ b/HPPA/HPPA.vcxproj @@ -124,6 +124,7 @@ + @@ -143,7 +144,10 @@ - + + + + @@ -229,6 +233,7 @@ + @@ -237,7 +242,10 @@ - + + + + diff --git a/HPPA/HPPA.vcxproj.filters b/HPPA/HPPA.vcxproj.filters index f71e7f5..8c56df8 100644 --- a/HPPA/HPPA.vcxproj.filters +++ b/HPPA/HPPA.vcxproj.filters @@ -160,10 +160,16 @@ Source Files + + Source Files + Source Files - + + Source Files + + Source Files @@ -220,6 +226,12 @@ Source Files + + Source Files + + + Source Files + @@ -360,6 +372,9 @@ Header Files + + Header Files + @@ -395,7 +410,16 @@ Header Files - + + Header Files + + + Header Files + + + Header Files + + Header Files diff --git a/HPPA/ImageViewer.cpp b/HPPA/ImageViewer.cpp index e489c5a..ffed7b4 100644 --- a/HPPA/ImageViewer.cpp +++ b/HPPA/ImageViewer.cpp @@ -6,7 +6,7 @@ #include #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); diff --git a/HPPA/ImageViewer.h b/HPPA/ImageViewer.h index a95f994..d65d6a6 100644 --- a/HPPA/ImageViewer.h +++ b/HPPA/ImageViewer.h @@ -4,7 +4,8 @@ #include "QGraphicsView" #include "qlabel.h" #include -#include "RasterLayer.h" + +class RasterImageLayer; class MapTool; @@ -16,7 +17,7 @@ public: Mapcavas(QWidget* pParent = NULL); ~Mapcavas(); - + void DisplayFrameNumber(int frameNumber); @@ -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; // 平移速度 diff --git a/HPPA/LayerTreeImageNode.cpp b/HPPA/LayerTreeImageNode.cpp new file mode 100644 index 0000000..a3fa595 --- /dev/null +++ b/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; +} diff --git a/HPPA/LayerTreeImageNode.h b/HPPA/LayerTreeImageNode.h new file mode 100644 index 0000000..0ef247a --- /dev/null +++ b/HPPA/LayerTreeImageNode.h @@ -0,0 +1,30 @@ +#pragma once + +#include "LayerTreeNode.h" +#include + +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; +}; + diff --git a/HPPA/LayerTreeModel.cpp b/HPPA/LayerTreeModel.cpp index 04787e6..652ba66 100644 --- a/HPPA/LayerTreeModel.cpp +++ b/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; diff --git a/HPPA/LayerTreeModel.h b/HPPA/LayerTreeModel.h index d575cec..4e4ba5d 100644 --- a/HPPA/LayerTreeModel.h +++ b/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; diff --git a/HPPA/LayerTreeViewMenuProvider.cpp b/HPPA/LayerTreeViewMenuProvider.cpp index d9e4faf..28f86fa 100644 --- a/HPPA/LayerTreeViewMenuProvider.cpp +++ b/HPPA/LayerTreeViewMenuProvider.cpp @@ -36,9 +36,15 @@ 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); + menu->addAction(removeLayerAction); + } + 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) { diff --git a/HPPA/MapLayerStore.cpp b/HPPA/MapLayerStore.cpp index 9287383..a2f3b96 100644 --- a/HPPA/MapLayerStore.cpp +++ b/HPPA/MapLayerStore.cpp @@ -1,43 +1,93 @@ #include "MapLayerStore.h" #include "MapLayer.h" +#include "RasterImageLayer.h" +#include +#include 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(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(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; } } @@ -48,12 +98,12 @@ bool MapLayerStore::containsLayer(const QString& url, bool isAbsolutePath) const QFileInfo fi(url); QString fileName = fi.completeBaseName(); - if (!isAbsolutePath) - { + if (!isAbsolutePath) { return getLayer(fileName) != nullptr; } - for (const auto& l : m_layers) { - if (l->dataPath() == url) + + for (const auto& entry : m_layers) { + if (entry.mapLayer->dataPath() == url) return true; } return false; @@ -61,16 +111,18 @@ bool MapLayerStore::containsLayer(const QString& url, bool isAbsolutePath) const 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 @@ -78,31 +130,129 @@ int MapLayerStore::layerCount() const return (int)m_layers.size(); } +RasterImageLayer* MapLayerStore::getImageLayer(MapLayer* mapLayer, int index) const +{ + 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 MapLayerStore::getAllImageLayers() const +{ + std::vector 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 { - auto it = m_layerWidgets.find(layer); - if (it == m_layerWidgets.end()) return nullptr; - return it->second; + 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 MapLayerStore::widgetsForMapLayer(MapLayer* mapLayer) const { - if (!widget) return nullptr; - for (const auto& kv : m_layerWidgets) { - if (kv.second == widget) return kv.first; + std::vector 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]; +} diff --git a/HPPA/MapLayerStore.h b/HPPA/MapLayerStore.h index 35cac75..4744664 100644 --- a/HPPA/MapLayerStore.h +++ b/HPPA/MapLayerStore.h @@ -2,53 +2,70 @@ #include #include -#include #include #include #include class MapLayer; +class RasterImageLayer; class QWidget; class MapLayerStore : public QObject { Q_OBJECT + + struct ImageLayerEntry { + std::unique_ptr imageLayer; + QWidget* widget; + }; + + struct LayerEntry { + std::unique_ptr mapLayer; + std::vector 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); - - bool containsLayer(const QString& url, bool isAbsolutePath = true) const; - - // 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 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 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> m_layers; - // mapping from raw MapLayer pointer to associated QWidget* - std::unordered_map m_layerWidgets; + LayerEntry* findLayerEntry(MapLayer* mapLayer); + const LayerEntry* findLayerEntry(MapLayer* mapLayer) const; + + std::vector m_layers; + std::unordered_map m_mapLayerIndex; }; diff --git a/HPPA/MapToolSpectral.cpp b/HPPA/MapToolSpectral.cpp index 261de18..42741d4 100644 --- a/HPPA/MapToolSpectral.cpp +++ b/HPPA/MapToolSpectral.cpp @@ -41,10 +41,10 @@ void MapToolSpectral::canvasMousePressEvent(QMouseEvent* e) const int x = static_cast(std::floor(scenePt.x())); const int y = static_cast(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 wavelengths; diff --git a/HPPA/MapToolSpectral.h b/HPPA/MapToolSpectral.h index 22012dc..e8b2560 100644 --- a/HPPA/MapToolSpectral.h +++ b/HPPA/MapToolSpectral.h @@ -4,6 +4,8 @@ #include "MapTool.h" #include +#include "RasterImageLayer.h" + class QGraphicsLineItem; class MapToolSpectral : public MapTool diff --git a/HPPA/RasterRenderer.cpp b/HPPA/MultibandRasterRenderer.cpp similarity index 77% rename from HPPA/RasterRenderer.cpp rename to HPPA/MultibandRasterRenderer.cpp index 6e9ba4e..a51419d 100644 --- a/HPPA/RasterRenderer.cpp +++ b/HPPA/MultibandRasterRenderer.cpp @@ -1,14 +1,14 @@ -#include "RasterRenderer.h" +#include "MultibandRasterRenderer.h" #include "RasterDataProvider.h" #include #include -RasterRenderer::RasterRenderer(RasterDataProvider* provider) - : m_provider(provider) +MultibandRasterRenderer::MultibandRasterRenderer(RasterDataProvider* provider) + : RasterRendererBase(provider) { } -void RasterRenderer::stretchTo8bit(const std::vector& in, std::vector& out, float minVal, float maxVal) +void MultibandRasterRenderer::stretchTo8bit(const std::vector& in, std::vector& out, float minVal, float maxVal) { size_t n = in.size(); out.resize(n); @@ -24,7 +24,7 @@ void RasterRenderer::stretchTo8bit(const std::vector& in, std::vectorbandCount(); @@ -38,7 +38,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 +53,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 rbuf, gbuf, bbuf; if (rIdx >= 0) m_provider->readBandAsFloat(rIdx, rbuf); @@ -63,8 +63,8 @@ QImage RasterRenderer::render(const Params& params) if (bIdx >= 0) m_provider->readBandAsFloat(bIdx, bbuf); std::vector r8, g8, b8; - float minV = static_cast(params.minValue); - float maxV = static_cast(params.maxValue); + float minV = static_cast(m_params.minValue); + float maxV = static_cast(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); diff --git a/HPPA/MultibandRasterRenderer.h b/HPPA/MultibandRasterRenderer.h new file mode 100644 index 0000000..dc7c91e --- /dev/null +++ b/HPPA/MultibandRasterRenderer.h @@ -0,0 +1,26 @@ +#pragma once + +#include "RasterRendererBase.h" +#include "RasterRenderParams.h" +#include +#include + +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& in, std::vector& out, float minVal, float maxVal); +}; diff --git a/HPPA/RasterImageLayer.cpp b/HPPA/RasterImageLayer.cpp new file mode 100644 index 0000000..efe3ca0 --- /dev/null +++ b/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(m_renderer.get()); + r->setParams(params); + } +} + +void RasterImageLayer::setSinglebandParams(const SinglebandRenderParams& params) +{ + m_singlebandParams = params; + if (m_rendererType == RendererType::Singleband) { + auto* r = static_cast(m_renderer.get()); + r->setParams(params); + } +} diff --git a/HPPA/RasterImageLayer.h b/HPPA/RasterImageLayer.h new file mode 100644 index 0000000..66c4ab7 --- /dev/null +++ b/HPPA/RasterImageLayer.h @@ -0,0 +1,44 @@ +#pragma once + +#include +#include + +#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 m_renderer; + MultibandRenderParams m_multibandParams; + SinglebandRenderParams m_singlebandParams; +}; diff --git a/HPPA/RasterLayer.cpp b/HPPA/RasterLayer.cpp index 378dec7..4514acc 100644 --- a/HPPA/RasterLayer.cpp +++ b/HPPA/RasterLayer.cpp @@ -1,21 +1,18 @@ #include "RasterLayer.h" #include "RasterDataProvider.h" -#include "RasterRenderer.h" -#include RasterLayer::RasterLayer(const QString& name, const QString& uri) : MapLayer(name, uri) { - // lazy creation } RasterLayer::~RasterLayer() { } -MapLayer::LayerType RasterLayer::layerType() const -{ - return MapLayer::LayerType::Raster; +MapLayer::LayerType RasterLayer::layerType() const +{ + return MapLayer::LayerType::Raster; } RasterDataProvider* RasterLayer::dataProvider() const @@ -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(dataPath()); if (!m_provider) return false; - bool ok = m_provider->open(); - if (ok && !m_renderer) m_renderer = std::make_unique(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& wavelengths, return true; } -QImage RasterLayer::render(const RenderParams& params) -{ - if (!m_provider) { - if (!openDataProvider()) return QImage(); - } - if (!m_renderer) m_renderer = std::make_unique(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 RasterLayer::bandWavelengths() const { if (!m_provider) { - // need to open provider to read wavelengths - cast away const for lazy init auto* self = const_cast(this); if (!self->openDataProvider()) return {}; } diff --git a/HPPA/RasterLayer.h b/HPPA/RasterLayer.h index fafb800..0cab6bb 100644 --- a/HPPA/RasterLayer.h +++ b/HPPA/RasterLayer.h @@ -2,11 +2,10 @@ #include "MapLayer.h" #include -#include #include +#include 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& wavelengths, QVector& 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 bandWavelengths() const; -private: +protected: std::unique_ptr m_provider; - std::unique_ptr m_renderer; - RenderParams m_currentParams; }; diff --git a/HPPA/RasterRenderParams.h b/HPPA/RasterRenderParams.h new file mode 100644 index 0000000..7364f64 --- /dev/null +++ b/HPPA/RasterRenderParams.h @@ -0,0 +1,19 @@ +#pragma once + +// Common base struct for all render parameters +struct RasterRenderParamsBase { + double minValue = 0.0; + double maxValue = 255.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; +}; diff --git a/HPPA/RasterRenderer.h b/HPPA/RasterRenderer.h deleted file mode 100644 index 648b461..0000000 --- a/HPPA/RasterRenderer.h +++ /dev/null @@ -1,29 +0,0 @@ -#pragma once - -#include -#include - -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& in, std::vector& out, float minVal, float maxVal); -}; diff --git a/HPPA/RasterRendererBase.cpp b/HPPA/RasterRendererBase.cpp new file mode 100644 index 0000000..80fceb7 --- /dev/null +++ b/HPPA/RasterRendererBase.cpp @@ -0,0 +1,6 @@ +#include "RasterRendererBase.h" + +RasterRendererBase::RasterRendererBase(RasterDataProvider* provider) + : m_provider(provider) +{ +} diff --git a/HPPA/RasterRendererBase.h b/HPPA/RasterRendererBase.h new file mode 100644 index 0000000..6b5a4f9 --- /dev/null +++ b/HPPA/RasterRendererBase.h @@ -0,0 +1,25 @@ +#pragma once + +#include +#include + +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; +}; diff --git a/HPPA/SinglebandRasterRenderer.cpp b/HPPA/SinglebandRasterRenderer.cpp new file mode 100644 index 0000000..8a66c07 --- /dev/null +++ b/HPPA/SinglebandRasterRenderer.cpp @@ -0,0 +1,85 @@ +#include "SinglebandRasterRenderer.h" +#include "RasterDataProvider.h" +#include + +SinglebandRasterRenderer::SinglebandRasterRenderer(RasterDataProvider* provider) + : RasterRendererBase(provider) +{ +} + +void SinglebandRasterRenderer::stretchTo8bit(const std::vector& in, std::vector& 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(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 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 buf; + m_provider->readBandAsFloat(bandIdx, buf); + + std::vector gray8; + float minV = static_cast(m_params.minValue); + float maxV = static_cast(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; +} diff --git a/HPPA/SinglebandRasterRenderer.h b/HPPA/SinglebandRasterRenderer.h new file mode 100644 index 0000000..6285dd2 --- /dev/null +++ b/HPPA/SinglebandRasterRenderer.h @@ -0,0 +1,27 @@ +#pragma once + +#include "RasterRendererBase.h" +#include "RasterRenderParams.h" +#include + +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& in, std::vector& out, float minVal, float maxVal); +}; diff --git a/HPPA/imageControl.cpp b/HPPA/imageControl.cpp index 6b275e3..7cfaae4 100644 --- a/HPPA/imageControl.cpp +++ b/HPPA/imageControl.cpp @@ -1,5 +1,5 @@ #include "imageControl.h" -#include "RasterLayer.h" +#include "RasterImageLayer.h" #include #include @@ -99,7 +99,7 @@ ImageControl::~ImageControl() { } -void ImageControl::setActiveLayer(RasterLayer* layer) +void ImageControl::setActiveLayer(RasterImageLayer* layer) { m_activeLayer = layer; @@ -110,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()) { @@ -150,8 +150,8 @@ void ImageControl::setActiveLayer(RasterLayer* layer) ui.sliderBlue->setMinimum(0); ui.sliderBlue->setMaximum(maxIdx); - // 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); @@ -168,7 +168,7 @@ void ImageControl::setActiveLayer(RasterLayer* layer) blockAllSignals(false); } -RasterLayer* ImageControl::activeLayer() const +RasterImageLayer* ImageControl::activeLayer() const { return m_activeLayer; } @@ -326,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); diff --git a/HPPA/imageControl.h b/HPPA/imageControl.h index de8ff3c..0aef291 100644 --- a/HPPA/imageControl.h +++ b/HPPA/imageControl.h @@ -6,9 +6,10 @@ #include #include +#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 m_wavelengths; // band wavelengths from header