gisvectorlayer.h

Go to the documentation of this file.

 
#ifndef GISVECTORLAYER_H
#define GISVECTORLAYER_H
 
#include "layers/openswmmvislayer.h"
#include "render/iattributeprovider.h"   // Slice DM.3
#include "render/labelconfig.h"
 
#include <QColor>
#include <QFont>
#include <QJsonObject>
#include <QList>
#include <QPainterPath>
#include <QPen>
#include <QBrush>
#include <QString>
#include <QVariantMap>
 
#include <memory>
 
class QGraphicsItem;
 
// Forward-declare GDAL/OGR types
class GDALDataset;
class OGRLayer;
class OGRFeature;
class OGRCoordinateTransformation;
 
class SpatialReferenceSystem;
class OpenSWMMVisWorkspace;
class GisVectorSymbolAdapter;   // persistent symbol adapter — styleSubjects()
 
namespace OpenSWMM::Render {
class IFeatureRenderer;
class RuleList;   // Slice B.3 — see m_ruleList below.
}
 
struct GISVectorSymbol
{
    // ----- Point / marker -------------------------------------------------
    enum MarkerShape { Circle, Square, Triangle, Diamond, Star, Cross };
 
    MarkerShape markerShape    = Circle;
    double      markerSize     = 6.0;   
    QColor      markerFill     = QColor(Qt::red);
    QColor      markerOutline  = QColor(Qt::darkRed);
    double      markerOutlineW = 1.0;
 
    // ----- Line -----------------------------------------------------------
    // Width is in screen pixels (cosmetic pen applied at populate time).
    // Default 2.0 — temporary until the theming component (Slice AC) takes
    // over per-attribute styling.
    QPen        linePen        = QPen(QColor(Qt::blue), 2.0);
 
    // ----- Polygon --------------------------------------------------------
    QBrush      polygonFill    = QBrush(QColor(100, 149, 237, 160)); // cornflower blue
    QPen        polygonOutline = QPen(QColor(Qt::darkBlue), 2.0);
 
    // ----- Labels ---------------------------------------------------------
    bool        showLabels     = false;
    QString     labelField;             
    QFont       labelFont;
    QColor      labelColor     = Qt::black;
 
    OpenSWMM::Render::LabelConfig labelConfig;
 
    [[nodiscard]] QJsonObject toJson() const;
    void fromJson(const QJsonObject &j);
};
 
class GISVectorLayer : public OpenSWMMVisLayer,
                       public OpenSWMM::Render::IAttributeProvider  // Slice DM.3
{
    Q_OBJECT
    Q_INTERFACES(OpenSWMM::Render::IAttributeProvider)  // Slice DM.3
    Q_PROPERTY(QString    filePath     READ filePath     NOTIFY filePathChanged)
    Q_PROPERTY(QString    layerName    READ ogrLayerName NOTIFY layerNameChanged)
    Q_PROPERTY(int        featureCount READ featureCount NOTIFY featureCountChanged)
    Q_PROPERTY(QString    filterExpr   READ filterExpression WRITE setFilterExpression
               NOTIFY filterExpressionChanged)
    Q_PROPERTY(GISVectorSymbol symbol  READ symbol WRITE setSymbol NOTIFY symbolChanged)
 
public:
 
    explicit GISVectorLayer(const QString &filePath,
                            const QString &layerName = {},
                            OpenSWMMVisWorkspace *parent = nullptr);
 
    ~GISVectorLayer() override;
 
    void openAsync(const QString &filePath, const QString &layerName = {});
 
    // ----- Multi-layer enumeration (sublayer picker) ----------------------
 
    struct OgrSublayerInfo
    {
        QString   name;               
        QString   geometryType;       
        long long featureCount = -1;  
        QString   crsDescription;     
        int       index = -1;         
    };
 
    [[nodiscard]] static QList<OgrSublayerInfo>
        enumerateSublayers(const QString &filePath, QString *errorOut = nullptr);
 
    // ----- Dataset info ---------------------------------------------------
 
    [[nodiscard]] QString filePath() const;
 
    [[nodiscard]] QString ogrLayerName() const;
 
    [[nodiscard]] class OGRLayer *ogrLayer() const { return m_ogrLayer; }
 
    void appendScenePolygonsTo(QPainterPath &out) const;
 
    [[nodiscard]] int featureCount() const;
 
    [[nodiscard]] QStringList fieldNames() const;
 
    // ----- Self-description for the Layer Properties dialog ----------------
    [[nodiscard]] QString sourceDescription() const override;
    [[nodiscard]] QVector<QPair<QString, QString>> extendedMetadata() const override;
 
    // ----- IAttributeProvider (Slice DM.3) --------------------------------
    //
    // GIS layers have no SWMM category. The interface's `cat` arg is
    // ignored; we always return the OGR field list (the same data
    // fieldNames() exposes) wrapped as AttributeField. All entries
    // are isDynamic=false — vector attributes don't change per
    // animation frame.
    [[nodiscard]] QVector<OpenSWMM::Render::AttributeField>
        availableAttributes(OpenSWMMVis::SwmmCategory cat) const override;
 
    // ----- Filtering ------------------------------------------------------
 
    [[nodiscard]] QString filterExpression() const;
 
    void setFilterExpression(const QString &expr);
 
    // ----- Symbology ------------------------------------------------------
 
    [[nodiscard]] GISVectorSymbol symbol() const;
    void setSymbol(const GISVectorSymbol &symbol);
 
    // VS.10 — labelConfig() inherited from OpenSWMMVisLayer; only the setter
    // is overridden to mirror fields onto the legacy GISVectorSymbol bag.
    void setLabelConfig(const OpenSWMM::Render::LabelConfig &cfg) override;
 
    [[nodiscard]] QStringList ogrFieldNames() const;
 
    [[nodiscard]] std::vector<std::unique_ptr<openswmmvis::ui::ILayerStyleSubject>>
        styleSubjects() override;
 
    // ----- Renderer (Slice BI Phase 8.13.6.6 + Slice B.3) -----------------
    // API plumbing only — paint loop still consults m_symbol directly.
    // Sub-phase 8.13.6.4 (deferred until Slice BB ColorRamp lands) will
    // refactor the paint loop to consult the renderer instead. Slice B.3
    // migrated the renderer's home to the m_ruleList's active Rule —
    // renderer() / setRenderer() are facades over the Rule.
 
    [[nodiscard]] OpenSWMM::Render::IFeatureRenderer *renderer() const;
 
    void setRenderer(std::unique_ptr<OpenSWMM::Render::IFeatureRenderer> r);
 
    // ----- Rule Model (Slice B.3, Phase B) --------------------------------
    //
    // GISVectorLayer is the first concrete layer to migrate to the Rule
    // Model. The layer owns a single-Rule RuleList that wraps the
    // renderer; `renderer()` and `setRenderer()` are facades over the
    // active Rule's owned IFeatureRenderer. LayerStyleDialog detects
    // `ruleList() != nullptr` and mounts RuleSymbologyTab in the
    // Symbology tab (Slice B.2 dispatch).
    [[nodiscard]] OpenSWMM::Render::RuleList *ruleList() override;
    [[nodiscard]] const OpenSWMM::Render::RuleList *ruleList() const override;
 
    // ----- Selection ------------------------------------------------------
 
    [[nodiscard]] QSet<long long> selectedFeatureIds() const;
 
    void setSelectedFeatureIds(const QSet<long long> &ids);
 
    void clearSelection();
 
    [[nodiscard]] QSet<long long> featureIdsInRect(
        const MapExtent &rectCanvasCrs) const;
 
    [[nodiscard]] QVector<QPointF> selectedFeatureAnchors() const;
 
    // ----- Identify -------------------------------------------------------
 
    [[nodiscard]] QList<QVariantMap> identifyAt(double mapX, double mapY,
                                                const SpatialReferenceSystem *canvasSRS,
                                                double tolerance = 1e-6) const;
 
    [[nodiscard]] QList<QVariantMap> identifyAt(double mapX, double mapY,
                                                double tolerance = 1e-6) const;
 
    // ----- OpenSWMMVisLayer interface -----------------------------------------
 
    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;
 
signals:
    void filePathChanged(const QString &path);
    void layerNameChanged(const QString &name);
    void featureCountChanged(int count);
    void filterExpressionChanged(const QString &expr);
    void symbolChanged(const GISVectorSymbol &symbol);
 
    // VS.10 — labelConfigChanged() is inherited from OpenSWMMVisLayer.
    void selectionChanged(const QSet<long long> &selectedIds);
    void rendererChanged();
 
    void openFinished(bool ok);
 
    void crsAssumed(const QString &filePath);
 
private:
    // Worker-thread payload for openAsync(): GDALOpenEx + GetLayer + extent +
    // CRS produce this POD (no QObject state), folded into the layer on the
    // GUI thread by applyOpenResult(). Defined in the .cpp.
    struct OpenResult;
    [[nodiscard]] static OpenResult doOpenWork(const QString &filePath,
                                               const QString &layerName,
                                               unsigned openFlags);
    void applyOpenResult(const OpenResult &r);
 
protected:
    void setOpenFlags(unsigned flags) { m_openFlags = flags; }
    [[nodiscard]] unsigned openFlags() const { return m_openFlags; }
 
    [[nodiscard]] GDALDataset *dataset() const { return m_dataset; }
 
    void markSceneDirty() { m_needsRebuild = true; }
 
    void openDataset(const QString &filePath, const QString &layerName);
 
    void closeDataset();
 
private:
    void rebuildTransform(const SpatialReferenceSystem *canvasSRS) const;
 
    void ensureTransform(const SpatialReferenceSystem *canvasSRS) const;
 
    void syncSymbolFromRenderer();
 
    QString                      m_filePath;
    QString                      m_ogrLayerName;
    QString                      m_filterExpr;
    GISVectorSymbol              m_symbol;
    // Persistent symbol adapter (adapter-ownership refactor) — lazily built
    // by styleSubjects(), owned via QObject parenting.
    GisVectorSymbolAdapter      *m_symbolAdapter = nullptr;
    // VS.10 — m_labelConfig moved to OpenSWMMVisLayer (base owns it now).
    QSet<long long>              m_selectedIds;
 
    unsigned                     m_openFlags = 0;   // seeded in the ctor
 
    GDALDataset                 *m_dataset   = nullptr; 
    OGRLayer                    *m_ogrLayer  = nullptr; 
    mutable OGRCoordinateTransformation *m_transform = nullptr; 
    mutable QString m_transformCanvasWkt;
 
    mutable bool m_warnedNoCRS = false;
 
    // Slice BI Phase 8.13.6.6 — renderer plumbing.  Initialised eagerly in
    // the ctor (default SingleSymbolRenderer) so renderer() never returns
    // null.  Paint refactor deferred until Slice BB ColorRamp ships.
    //
    // Slice B.3 — renderer ownership migrated to m_ruleList. The
    // canonical home for the renderer is now the active Rule's owned
    // IFeatureRenderer. renderer() and setRenderer() are thin facades
    // over m_ruleList->activeRule()->renderer() — no per-layer unique_ptr
    // duplicate. Legend code paths (legendoverlay, legendlayertreemodel,
    // legendclasseditcommands) keep working through the facade.
    std::unique_ptr<OpenSWMM::Render::RuleList>         m_ruleList;
 
    // Dirty flag — skip scene rebuild when only the view extent changed
    bool                         m_needsRebuild = true;
 
    // Owned QGraphicsItems currently in the scene — avoids O(n) scene scan
    // in depopulateScene (which previously used dynamic_cast on every item).
    QList<QGraphicsItem *>       m_sceneItems;
};
 
Q_DECLARE_METATYPE(GISVectorLayer *)
Q_DECLARE_METATYPE(GISVectorSymbol)
 
#endif // GISVECTORLAYER_H