117 lines
2.9 KiB
C++
117 lines
2.9 KiB
C++
#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;
|
|
}
|
|
|
|
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;
|
|
}
|
|
|
|
bool RasterLayer::isValidPixel(int x, int y)
|
|
{
|
|
if (!m_provider) {
|
|
if (!openDataProvider()) return false;
|
|
}
|
|
return m_provider->isValidPixel(x, y);
|
|
}
|
|
|
|
bool RasterLayer::readPixelSpectrum(int x, int y, QVector<double>& wavelengths, QVector<double>& spectrum)
|
|
{
|
|
if (!m_provider) {
|
|
if (!openDataProvider()) return false;
|
|
}
|
|
|
|
std::vector<double> wl;
|
|
std::vector<double> sp;
|
|
|
|
if (!m_provider->readPixelSpectrum(x, y, sp)) return false;
|
|
|
|
wl = m_provider->bandWavelengths();
|
|
|
|
wavelengths = QVector<double>::fromStdVector(wl);
|
|
spectrum = QVector<double>::fromStdVector(sp);
|
|
|
|
if (wavelengths.size() != spectrum.size()) {
|
|
wavelengths.resize(spectrum.size());
|
|
for (int i = 0; i < wavelengths.size(); ++i) {
|
|
wavelengths[i] = i;
|
|
}
|
|
}
|
|
|
|
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();
|
|
if (wl.empty()) return false;
|
|
minWave = *std::min_element(wl.begin(), wl.end());
|
|
maxWave = *std::max_element(wl.begin(), wl.end());
|
|
return true;
|
|
}
|
|
|
|
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 {};
|
|
}
|
|
return m_provider->bandWavelengths();
|
|
}
|