featurelayer.h

Go to the documentation of this file.

 
#ifndef FEATURELAYER_H
#define FEATURELAYER_H
 
#include "layers/gisvectorlayer.h"
#include "feature/featuregeometry.h"
#include "feature/featurestore.h"
#include "feature/featuretypes.h"
 
#include <QJsonObject>
#include <QString>
#include <QVector>
 
#include <memory>
 
class GISRasterLayer;
class SWMM2DMeshLayer;
class MapCanvas;
 
enum class FeatureLayerRole
{
    General = 0,      
    DomainBoundary,   
    Breakline,        
    Region,           
    ParameterZone,    
    SwmmDelineation,  
    BoundaryCondition 
};
 
[[nodiscard]] QString featureLayerRoleLabel(FeatureLayerRole r);
[[nodiscard]] QString featureLayerRoleToken(FeatureLayerRole r);
[[nodiscard]] FeatureLayerRole featureLayerRoleFromToken(const QString &token);
[[nodiscard]] openswmmvis::feature::Schema featureLayerRoleTemplate(FeatureLayerRole r);
[[nodiscard]] openswmmvis::feature::GeometryType
    featureLayerRoleGeometry(FeatureLayerRole r);
 
struct ZPolicy
{
    enum class Source { None = 0, Constant, Raster, Mesh };
 
    Source  source     = Source::None;
    QString sourceLayerId;      
    int     rasterBand = 1;
    double  constant   = 0.0;
    double  densifySpacing = 0.0;
    double  zScale     = 1.0;
    bool    resampleOnEdit = true;
 
    [[nodiscard]] bool isThreeD() const { return source != Source::None; }
    [[nodiscard]] QJsonObject toJson() const;
    [[nodiscard]] static ZPolicy fromJson(const QJsonObject &o);
    [[nodiscard]] bool operator==(const ZPolicy &o) const;
    [[nodiscard]] bool operator!=(const ZPolicy &o) const { return !(*this == o); }
};
 
class FeatureLayer : public GISVectorLayer
{
    Q_OBJECT
 
public:
    using FeatureId       = openswmmvis::feature::FeatureId;
    using Feature         = openswmmvis::feature::Feature;
    using FeatureGeometry = openswmmvis::feature::FeatureGeometry;
    using GeometryType    = openswmmvis::feature::GeometryType;
    using Schema          = openswmmvis::feature::Schema;
    using FieldDef        = openswmmvis::feature::FieldDef;
 
    explicit FeatureLayer(OpenSWMMVisWorkspace *parent = nullptr);
    ~FeatureLayer() override;
 
    [[nodiscard]] static FeatureLayer *create(const QString &gpkgPath,
                                              const QString &desiredName,
                                              GeometryType   type,
                                              const ZPolicy &zPolicy,
                                              const Schema  &schema,
                                              const QString &srsWkt,
                                              FeatureLayerRole role,
                                              QString       *error = nullptr,
                                              OpenSWMMVisWorkspace *parent = nullptr);
 
    [[nodiscard]] bool openTable(const QString &gpkgPath, const QString &table,
                                 QString *error = nullptr);
 
    [[nodiscard]] QString gpkgPath()  const { return m_gpkgPath; }
    [[nodiscard]] QString tableName() const { return m_table; }
    [[nodiscard]] bool    isEditable() const;
 
    // ----- Edit session ---------------------------------------------------
 
    [[nodiscard]] bool isEditing() const { return m_editing; }
    void setEditing(bool on);
 
    // ----- Schema ---------------------------------------------------------
 
    [[nodiscard]] Schema schema() const;
    [[nodiscard]] bool addField(const FieldDef &f, QString *error = nullptr);
    [[nodiscard]] bool removeField(const QString &name, QString *error = nullptr);
 
    // ----- Features -------------------------------------------------------
 
    [[nodiscard]] GeometryType geometryType() const;
    [[nodiscard]] bool isThreeD() const;
    [[nodiscard]] int  count() const;
    [[nodiscard]] QVector<FeatureId> featureIds() const;
    [[nodiscard]] bool feature(FeatureId id, Feature &out) const;
    [[nodiscard]] QVector<Feature> allFeatures() const;
 
    [[nodiscard]] FeatureId addFeature(const Feature &f, QString *error = nullptr);
    [[nodiscard]] bool setGeometry(FeatureId id, const FeatureGeometry &g,
                                   QString *error = nullptr);
    [[nodiscard]] bool setAttributes(FeatureId id, const QVariantMap &attrs,
                                     QString *error = nullptr);
    [[nodiscard]] bool setFeature(FeatureId id, const Feature &f,
                                  QString *error = nullptr);
    [[nodiscard]] bool removeFeature(FeatureId id, QString *error = nullptr);
 
    // ----- Role and Z -----------------------------------------------------
 
    [[nodiscard]] FeatureLayerRole role() const { return m_role; }
    void setRole(FeatureLayerRole r);
 
    [[nodiscard]] ZPolicy zPolicy() const { return m_zPolicy; }
    void setZPolicy(const ZPolicy &p);
 
    int sampleZ(FeatureGeometry &g, const MapCanvas *canvas,
                bool densify = true) const;
 
    int resampleAllZ(const MapCanvas *canvas, QString *error = nullptr);
 
    [[nodiscard]] int unsampledZCount() const;
 
    // ----- Layer overrides ------------------------------------------------
 
    [[nodiscard]] QString sourceDescription() const override;
    [[nodiscard]] QVector<QPair<QString, QString>> extendedMetadata() const override;
 
    // ----- Persistence ----------------------------------------------------
 
    [[nodiscard]] QJsonObject toJson() const;
    void applyJson(const QJsonObject &o);
 
signals:
    void featuresChanged(const QVector<qint64> &ids);
    void schemaChanged();
    void roleChanged(int role);
    void zPolicyChanged();
    void editingChanged(bool editing);
 
private:
    void bindStore();
    void afterWrite(const QVector<qint64> &ids);
 
    [[nodiscard]] GISRasterLayer  *rasterSource(const MapCanvas *canvas) const;
    // Elaborated type specifier: the inherited enumerator
    // OpenSWMMVisLayer::SWMM2DMeshLayer hides the class name in this scope.
    [[nodiscard]] class SWMM2DMeshLayer *meshSource(const MapCanvas *canvas) const;
 
    std::unique_ptr<openswmmvis::feature::FeatureStore> m_store;
    QString          m_gpkgPath;
    QString          m_table;
    FeatureLayerRole m_role = FeatureLayerRole::General;
    ZPolicy          m_zPolicy;
    bool             m_editing = false;
};
 
Q_DECLARE_METATYPE(FeatureLayer *)
 
#endif // FEATURELAYER_H