tangchao0503/HPPA
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

toc添加数据管理功能

Browse Source
This commit is contained in:
tangchao0503
2026-05-22 16:21:41 +08:00
parent eda0a01098
commit dcce0a6665
29 changed files with 792 additions and 240 deletions
Download Patch File Download Diff File Expand all files Collapse all files

127
HPPA/HPPA.cpp
View File

@ -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 <algorithm>
#include <cmath>
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<LayerTreeLayer*>(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<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);
MapLayer* mapLayer = layerNode->mapLayer();
}
void HPPA::removeImageByTreeIndex()
{
QModelIndex currentIndexTmp = m_layerTreeView->currentIndex();
if (!currentIndexTmp.isValid()) return;
LayerTreeModel* model = const_cast<LayerTreeModel*>(static_cast<const LayerTreeModel*>(currentIndexTmp.model()));
if (!model) return;
LayerTreeNode* node = static_cast<LayerTreeNode*>(currentIndexTmp.internalPointer());
if (!node || node->type() != LayerTreeNode::Type::Image) return;
auto* layerNode = static_cast<LayerTreeImageNode*>(node);
RasterImageLayer* rasterImageLayer = layerNode->imageLayer();
QWidget* layerWidget = nullptr;
if (rasterImageLayer && m_MapLayerStore)
{
layerWidget = m_MapLayerStore->widgetForImageLayer(rasterImageLayer);
m_MapLayerStore->removeImageLayer(rasterImageLayer);
}
if (layerWidget && m_imageViewerTabWidget)
{
const int tabIndex = m_imageViewerTabWidget->indexOf(layerWidget);
if (tabIndex >= 0)
{
if (m_recordFrameCounter)
{
m_recordFrameCounter->removeCounter(layerWidget);
}
m_imageViewerTabWidget->removeTab(tabIndex);
}
layerWidget->deleteLater();
}
LayerTreeNode* parent = node->parentNode();
int row = node->rowInParent();
LayerTreeNode* removed = model->removeNode(parent, row);
if (removed)
{
delete removed;
}
}
void HPPA::removeAllLayersInRasterGroup()
{
if (!m_LayerTreeModel || !m_RasterGroup) return;
@ -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<RasterLayer*>(layer);
if (rl)
{
m_ic->setActiveLayer(rl);
QList<Mapcavas*> mapcavas = currentWidget->findChildren<Mapcavas*>();
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*> mapcavas = mapcavasContainer->findChildren<Mapcavas*>();
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<RasterLayer*>(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*> 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->widgetForLayer(mapLayer);
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();
}

3
HPPA/HPPA.h
View File

@ -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);

12
HPPA/HPPA.vcxproj
View File

@ -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" />
@ -229,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" />
@ -237,7 +242,10 @@
<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" />

28
HPPA/HPPA.vcxproj.filters
View File

@ -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">
@ -220,6 +226,12 @@
<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">
@ -360,6 +372,9 @@
<QtMoc Include="SingleLensReflexCameraWindow.h">
<Filter>Header Files</Filter>
</QtMoc>
<QtMoc Include="LayerTreeImageNode.h">
<Filter>Header Files</Filter>
</QtMoc>
</ItemGroup>
<ItemGroup>
<ClInclude Include="imageProcessor.h">
@ -395,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">

29
HPPA/ImageViewer.cpp
View File

@ -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);

14
HPPA/ImageViewer.h
View File

@ -4,7 +4,8 @@
#include "QGraphicsView"
#include "qlabel.h"
#include <QVector>
#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; // 平移速度

31
HPPA/LayerTreeImageNode.cpp Normal file
View File

@ -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;
}

30
HPPA/LayerTreeImageNode.h Normal file
View File

@ -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;
};

2
HPPA/LayerTreeModel.cpp
View File

@ -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;

2
HPPA/LayerTreeModel.h
View File

@ -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;

12
HPPA/LayerTreeViewMenuProvider.cpp
View File

@ -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)
{

228
HPPA/MapLayerStore.cpp
View File

@ -1,43 +1,93 @@
#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;
}
}
@ -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<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
{
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<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];
}

59
HPPA/MapLayerStore.h
View File

@ -2,53 +2,70 @@
#include <QObject>
#include <QString>
#include <QFileInfo>
#include <vector>
#include <memory>
#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);
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<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;
};

4
HPPA/MapToolSpectral.cpp
View File

@ -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;

2
HPPA/MapToolSpectral.h
View File

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

22
HPPA/RasterRenderer.cpp → HPPA/MultibandRasterRenderer.cpp
View File

@ -1,14 +1,14 @@
#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);
@ -24,7 +24,7 @@ void RasterRenderer::stretchTo8bit(const std::vector<float>& in, std::vector<uns
}
}
QImage RasterRenderer::render(const Params& params)
QImage MultibandRasterRenderer::render()
{
if (!m_provider) return QImage();
int bands = m_provider->bandCount();
@ -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<float> 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<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);

26
HPPA/MultibandRasterRenderer.h Normal file
View File

@ -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);
};

66
HPPA/RasterImageLayer.cpp Normal file
View File

@ -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);
}
}

44
HPPA/RasterImageLayer.h Normal file
View File

@ -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;
};

44
HPPA/RasterLayer.cpp
View File

@ -1,21 +1,18 @@
#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()
{
}
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<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 {};
}

25
HPPA/RasterLayer.h
View File

@ -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;
};

19
HPPA/RasterRenderParams.h Normal file
View File

@ -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;
};

29
HPPA/RasterRenderer.h
View File

@ -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);
};

6
HPPA/RasterRendererBase.cpp Normal file
View File

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

25
HPPA/RasterRendererBase.h Normal file
View File

@ -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;
};

85
HPPA/SinglebandRasterRenderer.cpp Normal file
View File

@ -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;
}

27
HPPA/SinglebandRasterRenderer.h Normal file
View File

@ -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);
};

20
HPPA/imageControl.cpp
View File

@ -1,5 +1,5 @@
#include "imageControl.h"
#include "RasterLayer.h"
#include "RasterImageLayer.h"
#include <algorithm>
#include <cmath>
@ -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);

11
HPPA/imageControl.h
View File

@ -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