profileplotwidget.h

Go to the documentation of this file.

 
#ifndef PROFILE_PLOT_WIDGET_H
#define PROFILE_PLOT_WIDGET_H
 
#include "plot/profilebuilder.h"
#include "plot/profileplotoptions.h"
 
#include <QBrush>
#include <QColor>
#include <QDateTime>
#include <QPen>
#include <QPointer>
#include <QSet>
#include <QString>
#include <QVector>
#include <QWidget>
 
#include <limits>
#include <memory>
#include <optional>
 
class ProfilePlotWidget : public QWidget
{
    Q_OBJECT
 
public:
    struct SeriesBinding
    {
        QString                                        label;
        QColor                                         color;
        ProfileBuilder::OutputKind                     kind   = ProfileBuilder::OutputKind::HGL;
        std::shared_ptr<ProfileBuilder::SourceDerived> derived;
        QPen                                           pen;
        QBrush                                         brush;
        bool                                           visible = true;
    };
 
    struct LayerToggles
    {
        enum LabelOrientation { Vertical = 0, Horizontal = 1, Diagonal = 2 };
 
        // Per-output user preferences — read by the dialog, ignored by the
        // widget.  Default matches the historic look: HGL + EGL current,
        // Max HGL band on, Max EGL off.
        // Live HGL split into independent line + fill toggles. The
        // legend still shows a single HGL entry whenever either is on.
        bool             currentHglLine   = true;
        bool             currentHglFill   = true;
        bool             currentEgl       = true;
        bool             maxHglBand       = false;
        bool             maxHglLine       = false;
        // EGL has no fill — the only knob is the Max-EGL envelope line.
        bool             maxEglLine       = false;
 
        // Used directly by the widget.
        bool             showNodeLabels   = false;   
        bool             showLinkLabels   = false;   
        bool             inlineNodeLabels = false;   
        LabelOrientation labelOrientation = Vertical;
        int              labelAngleDeg    = 45;      
        bool             useTerrainGround = false;   
    };
 
    explicit ProfilePlotWidget(QWidget *parent = nullptr);
 
    void setPath(const ProfileBuilder::PathStatic &path);
 
    void setSeries(const QVector<SeriesBinding> &series);
    [[nodiscard]] const QVector<SeriesBinding> &series() const { return m_series; }
 
    void setCurrentPeriod(int seriesIdx, int period);
 
    void setCurrentDateTime(const QDateTime &dt);
 
    void setCurrentPeriod(int period);
 
    void setLayerToggles(const LayerToggles &toggles);
    [[nodiscard]] LayerToggles layerToggles() const;
 
    struct Surface2DSample
    {
        double chainage = 0.0;
        double bed      = std::numeric_limits<double>::quiet_NaN();
        double wse      = std::numeric_limits<double>::quiet_NaN();
    };
 
    void setSurface2DSamples(const QVector<Surface2DSample> &samples);
    [[nodiscard]] const QVector<Surface2DSample> &surface2DSamples() const
    { return m_surface2D; }
 
    void setOptions(ProfilePlotOptions *options);
    [[nodiscard]] ProfilePlotOptions *options() const { return m_options; }
 
    void setAxisLabels(const QString &xLabel, const QString &yLabel);
 
    [[nodiscard]] int nodeIndexAt(const QPoint &widgetPos) const;
 
    [[nodiscard]] int linkIndexAt(const QPoint &widgetPos) const;
 
    // ── Zoom / pan controls (driven by the dialog's toolbar) ─────────────
 
    enum class Mode { Identify = 0, Pan, ZoomIn, ZoomOut };
 
    enum class AxisEdge {
        None = 0,
        XMinimum,
        XMaximum,
        YMinimum,
        YMaximum,
    };
    Q_ENUM(AxisEdge)
 
    void setMode(Mode m);
    [[nodiscard]] Mode mode() const { return m_mode; }
 
    [[nodiscard]] AxisEdge axisEdgeAt(const QPoint &widgetPos) const;
    bool setAxisEdgeValue(AxisEdge edge, double value);
    [[nodiscard]] QRectF visibleDataRange() const;
 
    // ── Shared-x API (attribute tracks pane) ────────────────────────────
    //
    // The tracks pane below the profile reproduces this widget's horizontal
    // pixel mapping exactly — same virtual-chainage x quantity, same left/
    // right gutters — so the two charts stay column-aligned through every
    // zoom and pan. Everything it needs is exposed here rather than
    // duplicated: duplicated constants drift.
 
    void setVisibleXRange(double vxMin, double vxMax);
 
    [[nodiscard]] const QVector<double> &virtualChainageTable() const
    { return m_virtualChainage; }
 
    [[nodiscard]] double virtualToRealChainage(double vx) const;
 
    [[nodiscard]] static int chartLeftMarginPx();
    [[nodiscard]] static int chartRightMarginPx();
 
    void zoomBy(double factor);
 
    void fitToExtent();
 
    void setSelectedElementNames(const QStringList &names);
 
signals:
    void visibleXRangeChanged(double vxMin, double vxMax);
 
    void nodeRightClicked(int pathNodeIdx, const QPoint &globalPos);
 
    void linkRightClicked(int pathLinkIdx, const QPoint &globalPos);
 
    void backgroundRightClicked(const QPoint &globalPos);
 
    void nodeClicked(int pathNodeIdx);
 
    void linkClicked(int pathLinkIdx);
 
    void nodeDoubleClicked(int pathNodeIdx);
 
    void linkDoubleClicked(int pathLinkIdx);
 
    void backgroundClicked();
 
protected:
    void paintEvent       (QPaintEvent  *event) override;
    void resizeEvent      (QResizeEvent *event) override;
    void mousePressEvent  (QMouseEvent  *event) override;
    void mouseMoveEvent   (QMouseEvent  *event) override;
    void mouseReleaseEvent(QMouseEvent  *event) override;
    void mouseDoubleClickEvent(QMouseEvent *event) override;
    void wheelEvent       (QWheelEvent  *event) override;
 
private:
    // Plot-rect (data area, excluding axis label gutters) in widget pixels.
    [[nodiscard]] QRectF plotRect() const;
 
    // Dynamic top margin: grows when node / link labels are visible
    // (rendered above the plot as a secondary axis) so they don't overlap
    // the bottom axis tick labels.
    [[nodiscard]] int    topMargin()    const;
    [[nodiscard]] int    bottomMargin() const;
 
    // Data-space → pixel-space conversion.
    [[nodiscard]] QPointF dataToPixel(double chainage, double elev) const;
 
    // ── Virtual-chainage helpers ────────────────────────────────────────
    //
    // Zero-length links (pump/weir/orifice/outlet) would collapse to a single
    // x-pixel using real chainage, so we render in a "virtual" x where each
    // such link contributes a small visual gap.  The axis ticks still display
    // the real chainage at every node — adjacent ticks sharing a value make
    // the gap legible without distorting the distance axis.
 
    [[nodiscard]] double virtualX(int nodeIdx) const;
 
    [[nodiscard]] double virtualXAlongLink(int linkIdx, double frac) const;
 
    // (virtualToRealChainage is declared in the public section — the tracks
    // pane labels its shared x-axis with it.)
 
    // ── Virtual-junction helpers ────────────────────────────────────────
 
    [[nodiscard]] bool isVirtualNode(int nodeIdx) const;
 
    void hglEdgePixels(int linkIdx, qreal &pxU, qreal &pxD) const;
 
    // Recomputes data-space bounds (m_dataXMin, etc.) from m_path + m_series.
    void recomputeBounds();
    bool editAxisEdge(AxisEdge edge);
 
    // Emits visibleXRangeChanged if m_dataXMin/Max moved since the last
    // emission. Called after every x-mutation site so external consumers
    // (the attribute-tracks pane) see exactly one signal per change.
    void emitXRangeIfChanged();
 
    // Per-layer painters (broken out so the paint pipeline reads top-down).
    void paintBackgroundAndAxes  (QPainter &p) const;
    void paintLabelAxis          (QPainter &p) const;
    void paintSoilFill           (QPainter &p) const;
    void paintConduits           (QPainter &p) const;
    void paintNodes              (QPainter &p) const;
    void paintBranchStubs        (QPainter &p) const;
    void paintNodeRoses          (QPainter &p) const;
    void paintSelectionHighlights(QPainter &p) const;
    [[nodiscard]] QColor themeNodeFill   (ProfileBuilder::NodeKind k) const;
    [[nodiscard]] QColor themeNodeOutline(ProfileBuilder::NodeKind k) const;
    [[nodiscard]] QPen   themeVirtualJunctionPen() const;
    [[nodiscard]] QColor themeLinkFill   (ProfileBuilder::LinkKind k) const;
    [[nodiscard]] QColor themeLinkOutline(ProfileBuilder::LinkKind k) const;
    [[nodiscard]] QColor themeSoilFill   () const;
    [[nodiscard]] QColor themeBeddingFill() const;
    [[nodiscard]] QPen   themeConduitOutlinePen() const;
    [[nodiscard]] QPen   themeLinkOutlinePen(ProfileBuilder::LinkKind k) const;
    [[nodiscard]] QBrush themeStreetInvertBrush() const;
 
    // Per-kind dispatch helpers.  Each takes a series index into m_series.
    // The series carries its own resolved pen/brush; the helpers reach into
    // `series.derived` for the appropriate per-period or envelope array.
    //
    // Current-time series (HGL / EGL / WaterSurface) animate with
    // m_currentPeriod; envelope series (Max/Min HGL / EGL / WaterSurface)
    // are static.
    void paintSeriesCurrentLine  (QPainter &p, int seriesIdx) const;
    void paintSeriesEnvelope     (QPainter &p, int seriesIdx) const;
 
    // Envelope-series only — fills the manhole shaft at each node from
    // the node invert up to the envelope value (capped at rim).  Counterpart
    // to paintSeriesEnvelope's per-link fill so the Max/Min HGL / EGL /
    // WaterSurface band reads continuously across nodes instead of leaving
    // empty manhole columns between links.
    void paintNodeEnvelopeFill   (QPainter &p, int seriesIdx) const;
 
    // HGL-series only — in-pipe and in-manhole water fills.  Drawn for
    // every visible HGL series so multi-model overlay reads correctly
    // (each model gets its own water tint).
    void paintHglFill            (QPainter &p, int seriesIdx) const;
    void paintNodeFill           (QPainter &p, int seriesIdx) const;
    // HGL-series only — short horizontal HGL segment at each node,
    // spanning the manhole tube width.  Butts up against the link HGL
    // line at each pipe edge to form a continuous node+link trace.
    void paintNodeHglLine        (QPainter &p, int seriesIdx) const;
    // WaterSurface-series only — in-pipe fill from invert to free-surface
    // depth (caps at rim under pressurization, unlike HGL).
    void paintWaterSurfaceFill   (QPainter &p, int seriesIdx) const;
    // 2D inundation overlay — translucent band from the mesh bed up to the
    // 2D water surface plus a WSE line, per contiguous wet run of stations.
    // Drawn after the soil so it reads as water standing on the ground,
    // and before the 1D fills/lines so the network's own HGL stays on top.
    void paintSurface2D          (QPainter &p) const;
    // Elevation of the DRAWN ground line at a real chainage — the sampled
    // ground (DEM / 2D mesh) or rim-to-rim — so the 2D band fills exactly
    // to it.
    [[nodiscard]] double groundElevAtReal(double realX) const;
    // Real path chainage → virtual x (zero-length links get a visual gap).
    // Shared by the terrain ground line and the 2D overlay.
    [[nodiscard]] double realChainageToVirtualX(double realX) const;
 
    void paintLegend             (QPainter &p) const;
    void paintTimeLabel          (QPainter &p) const;
 
    // Returns true if `kind` is a current-time (animated) series.  All
    // other kinds are envelope series.
    [[nodiscard]] static bool isCurrentTimeKind(ProfileBuilder::OutputKind k);
    // Returns the appropriate per-period array on `derived` for the kind.
    // Returns an empty vector for envelope kinds.
    [[nodiscard]] static const QVector<QVector<double>> &
        currentTimeArray(const ProfileBuilder::SourceDerived &derived,
                         ProfileBuilder::OutputKind kind);
    // Returns the envelope array on `derived` for the kind.  Returns an
    // empty vector for current-time kinds.
    [[nodiscard]] static const QVector<double> &
        envelopeArray(const ProfileBuilder::SourceDerived &derived,
                      ProfileBuilder::OutputKind kind);
 
    ProfileBuilder::PathStatic   m_path;
    QVector<SeriesBinding>       m_series;
    QVector<Surface2DSample>     m_surface2D;      
    double                       m_surface2DMaxWse = std::numeric_limits<double>::quiet_NaN();
    LayerToggles                 m_toggles;
    QPointer<ProfilePlotOptions> m_options;        
    QSet<QString>                m_selectedNames;  
    int                          m_currentSrc    = -1;
    int                          m_currentPeriod = -1;
    QDateTime                    m_currentDateTime;
    QString                      m_xLabel        = QStringLiteral("Distance");
    QString                      m_yLabel        = QStringLiteral("Elevation");
 
    // Last-painted bounding rects of the legend and timestamp chips.  Used
    // for hit-testing in mousePressEvent so the user can grab and drag
    // either overlay.  Updated inside paintLegend / paintTimeLabel.
    mutable QRectF               m_legendRect;
    mutable QRectF               m_timeLabelRect;
    enum class OverlayDrag { None = 0, Legend, TimeLabel };
    OverlayDrag                  m_overlayDrag      = OverlayDrag::None;
    QPoint                       m_overlayDragLastPos;
 
    // Per-node virtual x (matches m_path.chainage size).  Rebuilt in
    // recomputeBounds().  Zero-length links contribute m_virtualGap; all
    // others contribute their real length.
    QVector<double>              m_virtualChainage;
    double                       m_virtualGap        = 0.0;
    double                       m_beddingFloorElev  = 0.0;
    bool                         m_haveBeddingFloor  = false;
 
    // Auto-computed data extent (re-derived on setPath / setSeries).
    double                       m_autoXMin   = 0.0;
    double                       m_autoXMax   = 1.0;
    double                       m_autoYMin   = 0.0;
    double                       m_autoYMax   = 1.0;
    // Currently-visible view bounds.  Equal to the auto extent when the
    // user hasn't zoomed/panned (m_fitMode == true).
    double                       m_dataXMin   = 0.0;
    double                       m_dataXMax   = 1.0;
    double                       m_dataYMin   = 0.0;
    double                       m_dataYMax   = 1.0;
    bool                         m_fitMode    = true;
    // Last-emitted visibleXRangeChanged values (see emitXRangeIfChanged).
    double                       m_lastEmittedXMin = std::numeric_limits<double>::quiet_NaN();
    double                       m_lastEmittedXMax = std::numeric_limits<double>::quiet_NaN();
    Mode                         m_mode       = Mode::Identify;
    bool                         m_panActive  = false;     // pan-drag in progress
    bool                         m_zoomActive = false;     // zoom-rubberband in progress
    AxisEdge                     m_pressedAxisEdge = AxisEdge::None;
    QPoint                       m_lastMousePos;
    QPoint                       m_zoomAnchor;             // start of rubberband
    class QRubberBand           *m_rubberBand = nullptr;
};
 
#endif // PROFILE_PLOT_WIDGET_H