meshfillsublayer.h

Go to the documentation of this file.

 
#ifndef OPENSWMM_RENDER_SUBLAYERS_MESHFILLSUBLAYER_H
#define OPENSWMM_RENDER_SUBLAYERS_MESHFILLSUBLAYER_H
 
#include "render/classificationscheme.h"
#include "render/isublayer.h"
#include "render/sublayerstyle.h"
 
#include <QColor>
#include <QJsonObject>
#include <QString>
#include <QVector>
 
namespace OpenSWMM::Render
{
 
class MeshFillStyle : public SublayerStyle
{
    Q_OBJECT
 
public:
    enum class CellAttribute : int
    {
        Elevation = 0,   
        Mannings,        
        InitDepth,       
        // Per-cell infiltration (GUI plan §3.5(5)). The METHOD is categorical
        // and colours through categoryColorForValue(); the parameters are
        // ordinary graduated attributes. Values resolve through
        // mesh::resolveInfil, so a cell inheriting from its region tag paints
        // its region's numbers — which is the point: an assignment can be
        // checked visually before a run.
        InfilMethod,     
        InfilF0,         
        InfilFmin,       
        InfilDecay,      
        InfilDryTime,    
        InfilFmax,       
        InfilSuction,    
        InfilKs,         
        InfilIMD,        
        InfilCN,         
        InfilRate,       
        GwKs,            
        GwZs,            
        GwThetaS,        
        GwHu0,           
        GwHg0,           
    };
    Q_ENUM(CellAttribute)
 
private:
    Q_PROPERTY(QColor fillColor         READ fillColor         WRITE setFillColor         NOTIFY styleChanged)
    Q_PROPERTY(double hillshadeStrength READ hillshadeStrength WRITE setHillshadeStrength NOTIFY styleChanged)
    Q_PROPERTY(bool   useElevationRamp  READ useElevationRamp  WRITE setUseElevationRamp  NOTIFY styleChanged)
    // Slice US (mesh) — terrain fill is classified by bed elevation through
    // the shared ClassificationScheme (Continuous = smooth elevation ramp,
    // Classified = discrete bands). useElevationRamp stays the on/off gate.
    Q_PROPERTY(OpenSWMM::Render::ClassificationScheme classification READ scheme WRITE setScheme NOTIFY styleChanged)
    Q_PROPERTY(OpenSWMM::Render::MeshFillStyle::CellAttribute colorByAttribute
               READ colorByAttribute WRITE setColorByAttribute NOTIFY styleChanged)
    // Colour for cells whose selected attribute is unset (NaN). Every gw.*
    // key is 100% NaN until the engine grows a soil column, so this is what
    // the whole mesh renders as when one of them is selected.
    Q_PROPERTY(QColor  noDataColor      READ noDataColor      WRITE setNoDataColor      NOTIFY styleChanged)
    // Palette used when colorByAttribute names a CATEGORICAL attribute (the
    // infiltration method). A ClassificationScheme has only Continuous and
    // Classified modes, both numeric — binning a seven-value enumeration at
    // 0.5/1.5/… is a lie about the data and leaks into the legend labels, the
    // same reasoning that gave the edge BC colours their own properties.
    Q_PROPERTY(QString categoryPalette   READ categoryPalette  WRITE setCategoryPalette  NOTIFY styleChanged)
 
    Q_CLASSINFO("group:fillColor",         "Fill")
    Q_CLASSINFO("group:hillshadeStrength", "Shading")
    Q_CLASSINFO("group:useElevationRamp",  "Fill")
    Q_CLASSINFO("group:colorByAttribute",  "Fill")
    Q_CLASSINFO("group:noDataColor",       "Fill")
    Q_CLASSINFO("group:categoryPalette",   "Fill")
    Q_CLASSINFO("group:classification",    "Classification")
 
public:
    [[nodiscard]] static QByteArray attributeKey(CellAttribute a);
    [[nodiscard]] static CellAttribute attributeFromKey(const QByteArray &key);
 
    explicit MeshFillStyle(QObject *parent = nullptr);
 
    [[nodiscard]] QColor fillColor() const         { return m_fillColor; }
    [[nodiscard]] double hillshadeStrength() const { return m_hillshadeStrength; }
    [[nodiscard]] bool   useElevationRamp() const  { return m_useElevationRamp; }
    [[nodiscard]] CellAttribute colorByAttribute() const { return m_colorByAttribute; }
    [[nodiscard]] QColor  noDataColor() const      { return m_noDataColor; }
    [[nodiscard]] QString categoryPalette() const  { return m_categoryPalette; }
 
    [[nodiscard]] QByteArray colorByAttributeKey() const
    { return attributeKey(m_colorByAttribute); }
 
    [[nodiscard]] bool colorsByElevation() const
    { return m_colorByAttribute == CellAttribute::Elevation; }
 
    [[nodiscard]] bool colorsByCategory() const;
 
    [[nodiscard]] QColor categoryColorForValue(int v) const;
 
    void setFillColor(const QColor &v);
    void setHillshadeStrength(double v);
    void setUseElevationRamp(bool v);
    void setColorByAttribute(CellAttribute v);
    void setNoDataColor(const QColor &v);
    void setCategoryPalette(const QString &v);
 
    [[nodiscard]] const ClassificationScheme &scheme() const { return m_scheme; }
    void setScheme(const ClassificationScheme &s);
 
    [[nodiscard]] QJsonObject toJson() const override;
    void fromJson(const QJsonObject &j) override;
 
private:
    QColor  m_fillColor          = QColor(190, 180, 150);
    double  m_hillshadeStrength  = 0.5;
    bool    m_useElevationRamp   = true;
    CellAttribute m_colorByAttribute = CellAttribute::Elevation;
    QColor  m_noDataColor        = QColor(205, 205, 205, 120);
    QString m_categoryPalette    = QStringLiteral("Tab10");
    ClassificationScheme m_scheme;
};
 
class MeshFillSublayer : public ISublayer
{
    Q_OBJECT
public:
    explicit MeshFillSublayer(QString id_, QObject *parent = nullptr);
 
    Kind    kind() const override        { return FillKind; }
    QString id() const override          { return m_id; }
    QString displayName() const override { return tr("Mesh Terrain"); }
 
    bool  isVisible() const override     { return m_visible; }
    void  setVisible(bool v) override;
    qreal opacity() const override       { return m_opacity; }
    void  setOpacity(qreal o) override;
 
    bool isDynamic() const override      { return false; }
 
    SublayerStyle *style() override      { return m_style; }
 
    QList<LegendSymbolItem> legendSymbolItems() const override;
    QSGNode *buildOrUpdateNode(QSGNode *existing, const SublayerContext &) override;
 
    [[nodiscard]] MeshFillStyle *fillStyle() const { return m_style; }
 
    void setAttributeHasData(bool hasData);
    [[nodiscard]] bool attributeHasData() const { return m_attributeHasData; }
 
    void setDepthUnitLabel(const QString &l) { m_depthUnitLabel = l; }
 
    void setCategoriesPresent(const QVector<int> &values);
    [[nodiscard]] const QVector<int> &categoriesPresent() const
    { return m_categoriesPresent; }
 
private:
    QString        m_id;
    bool           m_visible = true;
    qreal          m_opacity = 1.0;
    MeshFillStyle *m_style;
    bool           m_attributeHasData = true;
    QString        m_depthUnitLabel;
    QVector<int>   m_categoriesPresent;
};
 
} // namespace OpenSWMM::Render
 
#endif