gisrasterlayer.h

Go to the documentation of this file.

 
#ifndef GISRASTERLAYER_H
#define GISRASTERLAYER_H
 
#include "layers/tilepyramidlayer.h"
#include "render/colorramp.h"
#include "render/renderers/palettedrasterrenderer.h"
 
#include <QHash>
#include <QImage>
#include <QFutureWatcher>
#include <QList>
#include <QMutex>
#include <QPair>
#include <QSet>
#include <QString>
#include <QThreadPool>
#include <QVector>
 
#include <atomic>
#include <memory>
#include <vector>
 
// Forward-declare GDAL types
class GDALDataset;
class OGRCoordinateTransformation;
class OGRSpatialReference;
class SpatialReferenceSystem;
class OpenSWMMVisWorkspace;
class RasterTileItem;
 
namespace OpenSWMM::Render { class IRasterRenderer; }
 
// RasterColorRamp is defined in render/colorramp.h (relocated 2026-05-24,
// Slice BB-α). Kept at global scope for back-compat with existing callers
// + Q_DECLARE_METATYPE.
 
class GISRasterLayer : public TilePyramidLayer
{
    Q_OBJECT
    Q_PROPERTY(QString  filePath    READ filePath    NOTIFY filePathChanged)
    Q_PROPERTY(int      bandCount   READ bandCount   CONSTANT)
    Q_PROPERTY(int      renderBand  READ renderBand  WRITE setRenderBand NOTIFY renderBandChanged)
    Q_PROPERTY(double   noDataValue READ noDataValue NOTIFY noDataValueChanged)
 
    // Slice U-7 — Q_CLASSINFO groups for the unified LayerStyleDialog.
    Q_CLASSINFO("group:filePath",    "Source")
    Q_CLASSINFO("group:bandCount",   "Source")
    Q_CLASSINFO("group:renderBand",  "Display")
    Q_CLASSINFO("group:noDataValue", "Display")
 
public:
 
    explicit GISRasterLayer(const QString &filePath,
                            OpenSWMMVisWorkspace *parent = nullptr);
 
    ~GISRasterLayer() override;
 
    void openAsync(const QString &filePath);
 
    // ----- Dataset info ---------------------------------------------------
 
    [[nodiscard]] QString filePath()    const;
    [[nodiscard]] int     bandCount()   const;
    [[nodiscard]] int     renderBand()  const;
    [[nodiscard]] double  noDataValue() const;
 
    [[nodiscard]] QString detectVerticalUnit() const;
 
    void setRenderBand(int band);
 
    [[nodiscard]] bool hasNoDataValue() const;
 
    // ----- Self-description for the Layer Properties dialog ----------------
    [[nodiscard]] QString sourceDescription() const override;
    [[nodiscard]] QVector<QPair<QString, QString>> extendedMetadata() const override;
 
    // ----- Per-band data access (symbology inputs) -------------------------
    // All read the primary dataset under m_datasetMutex and cache per band
    // (caches drop on close / re-open). Pure: no signals are emitted.
 
    [[nodiscard]] QPair<double, double> bandRange(int band) const;
 
    [[nodiscard]] QVector<double> sampleValues(int band, int maxSamples = 200000) const;
 
    [[nodiscard]] QList<int> uniqueValues(int band, int cap = 256) const;
 
    [[nodiscard]] bool hasColorTable() const;
 
    [[nodiscard]] QList<OpenSWMM::Render::PalettedRasterRenderer::Class> colorTableClasses() const;
 
    [[nodiscard]] bool isByteRaster() const;
 
    [[nodiscard]] std::vector<std::unique_ptr<openswmmvis::ui::ILayerStyleSubject>>
        styleSubjects() override;
 
    // ----- Raster renderer (Slice BI Phase 8.13.6.7; P5/R-1 full switch) ---
    // The raster renderer is the §J.2 seam every raster paint path goes
    // through: warpToCanvas() colourises single-band tiles via
    // m_rasterRenderer->colorForValue(), and a MultiBandColorRenderer
    // switches the warp onto the RGB composite path. The open-time default
    // is chosen from the dataset (colour table ⇒ Paletted; ≥3 Byte bands ⇒
    // MultiBandColor; otherwise Graduated continuous grayscale over the band
    // statistics). Persisted / restored by StyleFileIO + ProjectSerializer.
 
    [[nodiscard]] OpenSWMM::Render::IRasterRenderer *rasterRenderer() const;
 
    void setRasterRenderer(std::unique_ptr<OpenSWMM::Render::IRasterRenderer> r);
 
    void notifyRasterRendererEdited();
 
    // ----- Pixel query ----------------------------------------------------
 
    [[nodiscard]] double valueAt(double mapX, double mapY,
                                 const SpatialReferenceSystem *canvasSRS,
                                 int band = 1,
                                 bool *ok = nullptr) const;
 
    // ----- OpenSWMMVisLayer interface -----------------------------------------
 
    [[nodiscard]] bool isRasterLayer() const override { return true; }
 
    void setIsBasemap(bool on);
    [[nodiscard]] bool isBasemapLayer() const override { return m_isBasemap; }
 
    void fetchCache(const MapExtent &extent,
                    const QSize &viewportSize,
                    const SpatialReferenceSystem *srs) override;
 
    void render(QPainter *painter,
                const MapExtent &extent,
                const QSize &imageSize,
                const SpatialReferenceSystem *srs) override;
 
    void populateScene(QGraphicsScene *scene,
                       const MapExtent &canvasExtent,
                       const SpatialReferenceSystem *canvasSRS) override;
 
    void depopulateScene(QGraphicsScene *scene) override;
 
    void refreshScene(QGraphicsScene *scene,
                      const MapExtent &canvasExtent,
                      const SpatialReferenceSystem *canvasSRS) override;
 
    void onCanvasCRSChanged(const SpatialReferenceSystem *newCanvasSRS) override;
 
    // ----- VS.6 — hillshade relief overlay (single-band DTM rasters) ---------
    // When enabled, warpToCanvas() composites a hillshade lighting factor over
    // the colour-ramped pixels using the warped elevation grid. Parameters
    // mirror HillshadeSymbolLayerSpec; stored as primitives to keep this
    // header free of the render/ spec include.
    [[nodiscard]] bool hillshadeEnabled() const { return m_hillshadeEnabled; }
    void setHillshadeEnabled(bool on);
    [[nodiscard]] double hillshadeAzimuthDeg()  const { return m_hillshadeAzimuthDeg; }
    [[nodiscard]] double hillshadeAltitudeDeg() const { return m_hillshadeAltitudeDeg; }
    [[nodiscard]] double hillshadeZFactor()     const { return m_hillshadeZFactor; }
    [[nodiscard]] double hillshadeStrength()    const { return m_hillshadeStrength; }
    void setHillshadeParams(double azimuthDeg, double altitudeDeg,
                            double zFactor, double strength);
 
signals:
    void filePathChanged(const QString &path);
    void renderBandChanged(int band);
    void noDataValueChanged(double value);
    void rasterRendererChanged();
 
    void openFinished(bool ok);
 
    void overviewBuildStarted(const QString &name);
    void overviewBuildFinished(bool ok);
 
private:
    // Worker-thread payload for openAsync(): the GDAL open + metadata read +
    // band-stats scan produce this POD (no QObject state), which
    // applyOpenResult() then folds into the layer on the GUI thread. Defined
    // in the .cpp.
    struct OpenResult;
    [[nodiscard]] static OpenResult doOpenWork(const QString &filePath);
    void applyOpenResult(const OpenResult &r);
 
    void openDataset(const QString &filePath);
    void closeDataset();
    void invalidateCache();
 
    // ── Overview (pyramid) preprocessing — Phase 1 ────────────────────────
    void maybeBuildOverviews();
    void buildOverviewsAsync();
 
    // Snapshot of everything a worker-thread tile warp reads, taken on the
    // GUI thread at launch so the worker never dereferences live layer state
    // (the renderer is a clone() — zero locking in the colourise loop).
    struct WarpParams
    {
        int    renderBand  = 1;
        // RGB composite path (MultiBandColorRenderer): `bands` lists the
        // source bands feeding R, G, B (and optionally A); otherwise it holds
        // the single render band and the colourise loop runs.
        bool          rgb = false;
        QVector<int>  bands;
        bool   hasNoData   = false;
        double noDataValue = 0.0;
        bool   hillshadeEnabled     = false;
        double hillshadeAzimuthDeg  = 315.0;
        double hillshadeAltitudeDeg = 45.0;
        double hillshadeZFactor     = 1.0;
        double hillshadeStrength    = 0.5;
        std::shared_ptr<const OpenSWMM::Render::IRasterRenderer> renderer;
    };
    [[nodiscard]] WarpParams snapshotWarpParams() const;
 
    [[nodiscard]] QImage warpToCanvas(GDALDataset *src,
                                      const MapExtent &canvasExtent,
                                      const SpatialReferenceSystem *canvasSRS,
                                      int pixelWidth,
                                      int pixelHeight,
                                      const WarpParams &params) const;
 
    [[nodiscard]] GDALDataset *buildWindowedSource(
        GDALDataset *src,
        const MapExtent &canvasExtent, const SpatialReferenceSystem *canvasSRS,
        int pixelWidth, int pixelHeight, int outBands, bool isRGB,
        const WarpParams &params) const;
 
    // ── Phase 3 — fixed-grid tile pyramid (off-thread, cached) ───────────
    // Tiles are 256² images in CANVAS CRS on a fixed power-of-2 grid, so a pan
    // reuses the tiles it already has and only the new edge tiles are produced.
    // Each tile is one warpToCanvas() of its canvas-CRS extent (overview-aware),
    // produced on up to N concurrent workers (one pooled GDAL handle each),
    // cached in the TilePyramidLayer base, and composited by render() with a
    // coarser-tile fallback for tiles still in production.
    static constexpr int kTilePx = 256;
    // Fallback stand-ins may be at most 2^6 = 64× coarser than the view level
    // (a 4-px sub-rect of a 256² ancestor).
    static constexpr double kMaxAncestorSpanRatio = 64.0;
    struct TileReq { int level; int col; int row; };
    // Worker → GUI payload for one produced tile. `gen` is the cache
    // generation captured at launch; results from before an invalidateCache()
    // are dropped instead of polluting the fresh cache.
    struct TileResult
    {
        QString   key;
        QImage    img;
        MapExtent extent;
        int       level = 0;
        quint64   gen   = 0;
    };
    [[nodiscard]] static int levelForResolution(double mapUnitsPerPixel);
    [[nodiscard]] static MapExtent tileExtent(int level, int col, int row);
    [[nodiscard]] static QString   tileKey(int level, int col, int row);
    void requestTiles(const MapExtent &extent, const QSize &viewportSize,
                      const SpatialReferenceSystem *canvasSRS);
    void enqueueSeedTiles();
    void startNextTiles();
    void onSlotFinished(int slotIndex);
 
    // ── Parallel tile production — N-slot GDAL handle pool ───────────────
    // N read-only handles to the same file; a slot borrows one for the warp
    // duration. Acquire (startNextTiles) and release (onSlotFinished) both run
    // on the GUI thread, so the free-list needs no mutex; workers only *use*
    // their borrowed handle.
    struct TileSlot
    {
        std::unique_ptr<QFutureWatcher<TileResult>> watcher;
        bool                    busy   = false;
        GDALDataset            *handle = nullptr;  // borrowed from m_freeHandles
        SpatialReferenceSystem *srs    = nullptr;  // per-tile clone; freed on finish
    };
    void openHandlePool();
    void closeHandlePool();
    void drainTileSlots();
    void finishSlot(TileSlot &slot);
 
    [[nodiscard]] QList<OpenSWMM::Render::PalettedRasterRenderer::Class>
        readColorTableLocked() const;
 
    QString          m_filePath;
    int              m_renderBand = 1;
    bool             m_isBasemap  = false;  
    double           m_noDataValue = std::numeric_limits<double>::quiet_NaN();
    bool             m_hasNoData  = false;
 
    // Per-band symbology inputs (see bandRange / sampleValues). Guarded by
    // m_datasetMutex; cleared whenever the dataset closes or re-opens.
    mutable QHash<int, QPair<double, double>> m_bandRangeCache;
    mutable QHash<int, QVector<double>>       m_sampleCache;
 
    // VS.6 — hillshade relief overlay parameters (see public accessors).
    bool             m_hillshadeEnabled    = false;
    double           m_hillshadeAzimuthDeg = 315.0;
    double           m_hillshadeAltitudeDeg = 45.0;
    double           m_hillshadeZFactor    = 1.0;
    double           m_hillshadeStrength   = 0.5;
 
    GDALDataset     *m_dataset    = nullptr;  
    // Guards m_dataset for the paths that still share the primary handle:
    // valueAt() (single-pixel probe), closeDataset(), and the post-.ovr-build
    // reload/reopen. Tile warps no longer take it — each worker reads through
    // its own pooled handle with a WarpParams snapshot.
    mutable QMutex   m_datasetMutex;
 
    // valueAt()'s cached canvas→raster probe transform (guarded by
    // m_datasetMutex). Keyed on the two OGRSpatialReference identities;
    // nullptr CT with matching keys means the CRSs are the same.
    mutable OGRCoordinateTransformation *m_probeCT = nullptr;
    mutable const OGRSpatialReference   *m_probeCTCanvasKey = nullptr;
    mutable const OGRSpatialReference   *m_probeCTRasterKey = nullptr;
    // Set after a background .ovr build; consumed by the next fetchCache()
    // (GUI thread), which reopens m_dataset so the new overviews become visible.
    std::atomic<bool> m_datasetReloadPending{false};
    bool              m_overviewBuildInFlight = false;
 
    // Tile pyramid state. The tile cache itself lives in the TilePyramidLayer
    // base (mutex-guarded: render() reads from the MapRenderJob worker while
    // the GUI thread inserts). Everything below is GUI-thread only.
    QList<TileReq>          m_tileQueue;         // FIFO of tiles still to produce
    QSet<QString>           m_queuedKeys;        // de-dup: queued ∪ in-flight
    quint64                 m_cacheGeneration = 0; // bumped by invalidateCache()
    quint64                 m_seedGeneration  = ~0ULL; // last gen seeds were queued
    SpatialReferenceSystem *m_currentSRS   = nullptr;  // latest canvas-CRS snapshot (template)
 
    // Parallel production (see TileSlot above). m_tilePool bounds tile warps
    // to N threads and keeps them off the global pool used by openAsync /
    // overview builds.
    int                        m_maxConcurrentTiles = 1;
    QThreadPool                m_tilePool;
    std::vector<GDALDataset *> m_poolHandles;  // owns the N pooled handles
    QList<GDALDataset *>       m_freeHandles;  // GUI-thread free-list
    std::vector<TileSlot>      m_slots;
 
    // Persistent scene item (kept visible as placeholder until new warp completes)
    RasterTileItem  *m_sceneItem  = nullptr;
 
    // Single source of truth for raster colouring (P5/R-1). Initialised
    // eagerly in the ctor (a grayscale GraduatedRasterRenderer) so
    // rasterRenderer() never returns null; applyOpenResult() replaces it with
    // the dataset-appropriate default, and warpToCanvas() colourises through
    // a clone of it.
    std::unique_ptr<OpenSWMM::Render::IRasterRenderer> m_rasterRenderer;
};
 
Q_DECLARE_METATYPE(GISRasterLayer *)
// Q_DECLARE_METATYPE(RasterColorRamp) is in render/colorramp.h (Slice BB-α).
 
#endif // GISRASTERLAYER_H