graduatedrenderer.h

Go to the documentation of this file.

 
#ifndef OPENSWMM_RENDER_GRADUATEDRENDERER_H
#define OPENSWMM_RENDER_GRADUATEDRENDERER_H
 
#include "render/attributesource.h"
#include "render/colorramp.h"
#include "render/ifeaturerenderer.h"
#include "render/intervalbinner.h"
 
#include <QColor>
#include <QHash>
#include <QList>
#include <QString>
#include <QVector>
 
namespace OpenSWMM::Render
{
 
class GraduatedRenderer final : public IFeatureRenderer
{
public:
    GraduatedRenderer() = default;
    ~GraduatedRenderer() override = default;
 
    [[nodiscard]] QString classifyAttribute() const { return m_classifyAttribute; }
    void setClassifyAttribute(QString name) { m_classifyAttribute = std::move(name); }
 
    [[nodiscard]] QString sizeAttribute() const { return m_sizeAttribute; }
    void setSizeAttribute(QString name)
    {
        if (name == m_sizeAttribute) return;
        m_sizeAttribute = std::move(name);
        // New attribute → the sampled value range is stale; invalidate so
        // the owning layer's next rebuild re-derives it from data.
        m_sizeValueMin = m_sizeValueMax = 0.0;
    }
 
    [[nodiscard]] QString effectiveSizeAttribute() const
    {
        return m_sizeAttribute.isEmpty() ? m_classifyAttribute : m_sizeAttribute;
    }
 
    [[nodiscard]] bool sizeAxisIndependent() const
    {
        return !m_sizeAttribute.isEmpty()
               && m_sizeAttribute != m_classifyAttribute;
    }
 
    [[nodiscard]] double sizeValueMin() const { return m_sizeValueMin; }
    [[nodiscard]] double sizeValueMax() const { return m_sizeValueMax; }
    [[nodiscard]] bool   sizeValueRangeValid() const
    { return m_sizeValueMax > m_sizeValueMin; }
    void setSizeValueRange(double mn, double mx)
    { m_sizeValueMin = mn; m_sizeValueMax = mx; }
 
    [[nodiscard]] AttributeSourceKind sourceKind() const { return m_sourceKind; }
    void setSourceKind(AttributeSourceKind k) { m_sourceKind = k; }
 
    [[nodiscard]] RangeMode rangeMode() const { return m_rangeMode; }
    void setRangeMode(RangeMode m) { m_rangeMode = m; }
 
    [[nodiscard]] double minValue() const { return m_ramp.minValue; }
    [[nodiscard]] double maxValue() const { return m_ramp.maxValue; }
    void setRange(double minValue, double maxValue);
 
    [[nodiscard]] const RasterColorRamp &ramp() const { return m_ramp; }
    void setRamp(RasterColorRamp ramp);
 
    [[nodiscard]] const IntervalBinner &binner() const { return m_binner; }
    void setBinner(IntervalBinner b);
 
    [[nodiscard]] const QVector<double> &lastBreaks() const { return m_lastBreaks; }
 
    void clearBreaks() { m_lastBreaks.clear(); }
 
    static void classifyIfNeeded(GraduatedRenderer *g, const QVector<double> &samples)
    {
        if (g && g->lastBreaks().isEmpty() && !samples.isEmpty())
            g->autoClassify(samples);
    }
 
    [[nodiscard]] QList<QColor> binColors() const;
    void setBinColors(QList<QColor> colors);
    [[nodiscard]] int binCount() const { return m_binner.binCount(); }
 
    [[nodiscard]] const SymbolStyle &baseSymbol() const { return m_baseSymbol; }
    void setBaseSymbol(SymbolStyle s);
 
    void autoClassify(const QVector<double> &samples);
 
    [[nodiscard]] QColor colorForValue(double v) const;
 
    [[nodiscard]] QColor colorForBin(int bin) const;
 
    [[nodiscard]] bool outputSizeEnabled() const { return m_outputSizeEnabled; }
    void setOutputSizeEnabled(bool on) { m_outputSizeEnabled = on; }
 
    [[nodiscard]] bool outputColorEnabled() const { return m_outputColorEnabled; }
    void setOutputColorEnabled(bool on) { m_outputColorEnabled = on; }
 
    [[nodiscard]] double outputSizeMin() const { return m_outputSizeMin; }
    [[nodiscard]] double outputSizeMax() const { return m_outputSizeMax; }
    void setOutputSizeRange(double minPx, double maxPx);
 
    [[nodiscard]] double sizeForBin(int bin) const;
 
    [[nodiscard]] double sizeForValue(double v) const;
 
    [[nodiscard]] bool outputWidthEnabled() const { return m_outputWidthEnabled; }
    void setOutputWidthEnabled(bool on) { m_outputWidthEnabled = on; }
 
    [[nodiscard]] double outputWidthMin() const { return m_outputWidthMin; }
    [[nodiscard]] double outputWidthMax() const { return m_outputWidthMax; }
    void setOutputWidthRange(double minPx, double maxPx);
 
    [[nodiscard]] double widthForBin(int bin) const;
 
    [[nodiscard]] double widthForValue(double v) const;
 
    // IFeatureRenderer.
    [[nodiscard]] QString rendererId() const override { return QStringLiteral("graduated"); }
    [[nodiscard]] SymbolStyle symbolFor(const FeatureRef &f,
                                        const QVariantMap &attrs) const override;
    [[nodiscard]] QList<LegendSymbolItem> legendSymbolItems() const override;
    [[nodiscard]] QJsonObject toJson() const override;
    void fromJson(const QJsonObject &j) override;
    [[nodiscard]] std::unique_ptr<IFeatureRenderer> clone() const override;
 
    // ── Per-class editing (Slice BB Phase 8.6.16) ──────────────────────
    // classKey is the bin index as a string ("0", "1", …). Only colour
    // is editable for graduated — size/width are global on this renderer.
    // Overrides persist through ramp changes but become "dormant" if the
    // bin count drops below the override index (they re-emerge if the
    // bin count grows again, modelling undo-friendly user intent).
    [[nodiscard]] bool supportsClassEdit(ClassEditKind kind) const override
    {
        return kind == ClassEditKind::Color;
    }
    [[nodiscard]] QColor colorForClass(const QString &classKey) const override;
    void setColorForClass(const QString &classKey, const QColor &color) override;
    void clearClassEditOverrides() override;
 
    [[nodiscard]] const QHash<int, QColor> &binColorOverrides() const noexcept
    { return m_binColorOverrides; }
 
private:
    QString          m_classifyAttribute;
    // Independent size/width attribute (empty = follow classifyAttribute)
    // + its sampled value range (invalid until the owning layer derives it).
    QString          m_sizeAttribute;
    double           m_sizeValueMin = 0.0;
    double           m_sizeValueMax = 0.0;
    RasterColorRamp  m_ramp = RasterColorRamp::viridis(0.0, 1.0);
    IntervalBinner   m_binner;          // EqualInterval, 5 bins by default
    QVector<double>  m_lastBreaks;
    SymbolStyle      m_baseSymbol;
 
    // Slice BI Phase 8.13.43-α — output-axis toggles.
    bool             m_outputColorEnabled = true;
    bool             m_outputSizeEnabled  = false;
    double           m_outputSizeMin      = 2.0;
    double           m_outputSizeMax      = 14.0;
 
    // VS.4 — independent line-width output axis.
    bool             m_outputWidthEnabled = false;
    double           m_outputWidthMin     = 0.5;
    double           m_outputWidthMax     = 6.0;
 
    // P2 — static/dynamic source + range-mode spine.
    AttributeSourceKind m_sourceKind = AttributeSourceKind::Static;
    RangeMode           m_rangeMode  = RangeMode::FixedOverRun;
 
    // Slice BB Phase 8.6.16 — sparse per-bin colour overrides.
    QHash<int, QColor> m_binColorOverrides;
};
 
} // namespace OpenSWMM::Render
 
#endif // OPENSWMM_RENDER_GRADUATEDRENDERER_H