mapcanvas.h

Go to the documentation of this file.

 
#ifndef MAPCANVAS_H
#define MAPCANVAS_H
 
#include "map/mapextent.h"
#include "map/mapundostack.h"
#include "map/scalebarsettings.h"
 
#include <QHash>
#include <QImage>
#include <QList>
#include <QPointer>
#include <QRectF>
#include <QStringList>
#include <QTimer>
#include <QTransform>
#include <QVector>
#include <QWidget>
#include <optional>
 
class OpenSWMMVisScene;
class OpenSWMMVisGraphicsView;
class OpenSWMMVisLayer;
class SpatialReferenceSystem;
class OpenSWMMVisMapTool;
class MapUndoStack;
class MapRenderJob;
class MeshProfileOverlay;
class ProfilePathOverlay;
class SelectionBeaconOverlay;
class QGestureEvent;
 
class MapCanvas : public QWidget
{
    Q_OBJECT
 
    Q_PROPERTY(MapExtent extent READ extent WRITE setExtent NOTIFY extentChanged)
    Q_PROPERTY(double    scale  READ scale  NOTIFY scaleChanged)
    Q_PROPERTY(bool      showScaleBar    READ showScaleBar    WRITE setShowScaleBar
               NOTIFY showScaleBarChanged)
    Q_PROPERTY(bool      showCoordinates READ showCoordinates WRITE setShowCoordinates
               NOTIFY showCoordinatesChanged)
    Q_PROPERTY(int       maxUndoCount    READ maxUndoCount    WRITE setMaxUndoCount
               NOTIFY maxUndoCountChanged)
    Q_PROPERTY(QColor    backgroundColor READ backgroundColor WRITE setBackgroundColor
               NOTIFY backgroundColorChanged)
    Q_PROPERTY(ScaleBarSettings* scaleBarSettings READ scaleBarSettings CONSTANT)
 
public:
 
    explicit MapCanvas(QWidget *parent = nullptr);
    ~MapCanvas() override;
 
    // ----- Scene access --------------------------------------------------
 
    [[nodiscard]] OpenSWMMVisScene *mapScene() const;
 
    // ----- Overlay view access -------------------------------------------
 
    [[nodiscard]] OpenSWMMVisGraphicsView *overlayView() const;
 
    // ----- CRS -----------------------------------------------------------
 
    [[nodiscard]] SpatialReferenceSystem *canvasSRS() const;
 
    void setCanvasSRS(SpatialReferenceSystem *srs, bool ownsSRS = false);
 
    bool setCanvasSRSByCode(const QString &authName, int code);
 
    // ----- Extent / view -------------------------------------------------
 
    [[nodiscard]] MapExtent extent() const;
 
    void setExtent(const MapExtent &extent, bool pushUndo = true);
 
    void zoomToFullExtent();
    void zoomIn(double factor = 2.0);
    void zoomOut(double factor = 2.0);
    void pan(double dx, double dy);
 
    [[nodiscard]] double scale() const;
 
    [[nodiscard]] double scaleDenominator() const;
 
    void setScaleDenominator(double denom);
 
    // ----- Interactive navigation (used by map tools) --------------------
 
    void translateViewBy(int dx, int dy);
 
    void zoomAroundCursor(double factor, const QPoint &viewportPos);
 
    void syncExtentFromView();
 
    // ----- Layer management ----------------------------------------------
 
    [[nodiscard]] const QList<OpenSWMMVisLayer *> &layers() const;
 
    void addLayer(OpenSWMMVisLayer *layer, bool pushUndo = true);
    void insertLayer(int position, OpenSWMMVisLayer *layer, bool pushUndo = true);
    OpenSWMMVisLayer *takeLayer(int index, bool pushUndo = true);
    void moveLayer(int fromIndex, int toIndex, bool pushUndo = true);
 
    void reorderLayers(const QList<OpenSWMMVisLayer *> &newOrder,
                       bool pushUndo = true);
 
    [[nodiscard]] int layerCount() const;
    [[nodiscard]] OpenSWMMVisLayer *layerAt(int index) const;
    [[nodiscard]] MapExtent fullExtent() const;
 
    // ----- Layer-group (category) order — Slice LTR-2026-09-19 ------------
    //
    // The layer tree shows the stack bucketed into category groups
    // (openswmmvis::ui::CategoryId). Invariant kept by this class: the
    // stack is always GROUPED — every category's layers are contiguous,
    // groups appear in layerGroupOrder() sequence (index 0 = top of tree =
    // highest canvas index = drawn last). addLayer() therefore inserts a
    // new layer at the top of its own group, not at the top of the stack,
    // so tree order and paint order never disagree.
 
    [[nodiscard]] QVector<int> layerGroupOrder() const;
    void setLayerGroupOrder(const QVector<int> &order);
 
    [[nodiscard]] static QString layerOrderKey(const OpenSWMMVisLayer *layer);
    void setPendingLayerOrder(const QStringList &keysBottomToTop);
    [[nodiscard]] QStringList pendingLayerOrder() const;
    [[nodiscard]] int groupedInsertPosition(const OpenSWMMVisLayer *layer) const;
 
    bool moveSublayer(OpenSWMMVisLayer *host, int from, int to, bool pushUndo = true);
 
    [[nodiscard]] MapExtent extentInCanvasCRS(const OpenSWMMVisLayer *layer,
                                              const MapExtent &nativeExtent) const;
 
    [[nodiscard]] MapExtent layerExtentInCanvasCRS(const OpenSWMMVisLayer *layer) const;
 
    // ----- Active tool ---------------------------------------------------
 
    [[nodiscard]] OpenSWMMVisMapTool *activeTool() const;
    void setActiveTool(OpenSWMMVisMapTool *tool);
 
    // ----- Mesh-profile overlay ------------------------------------------
 
    void setMeshProfileOverlay(MeshProfileOverlay *overlay);
 
    [[nodiscard]] MeshProfileOverlay *meshProfileOverlay() const
    { return m_meshProfileOverlay; }
 
    void setProfilePathOverlay(ProfilePathOverlay *overlay);
 
    [[nodiscard]] SelectionBeaconOverlay *selectionBeacon() const
    { return m_selectionBeacon; }
 
public slots:
    void flashSelection();
 
    void clearSelectionBeacon();
 
public:
 
    // ----- Undo ----------------------------------------------------------
 
    [[nodiscard]] MapUndoStack *undoStack() const;
    [[nodiscard]] int maxUndoCount() const;
    void setMaxUndoCount(int count);
 
    // ----- Decorations ---------------------------------------------------
 
    [[nodiscard]] bool showScaleBar() const;
    void setShowScaleBar(bool show);
 
    [[nodiscard]] bool showCoordinates() const;
    void setShowCoordinates(bool show);
 
    void setTerrainElevation(const std::optional<double> &z);
 
    void setTerrainUnit(const QString &unit);
 
    [[nodiscard]] std::optional<double> terrainZ() const { return m_terrainZ; }
 
    [[nodiscard]] QString terrainUnit() const { return m_terrainUnit; }
 
    [[nodiscard]] QColor backgroundColor() const;
    void setBackgroundColor(const QColor &color);
 
    [[nodiscard]] ScaleBarSettings *scaleBarSettings() const;
 
    // ----- Coordinate conversion -----------------------------------------
 
    void toMapCoords(int px, int py, double &mapX, double &mapY) const;
    void toPixelCoords(double mapX, double mapY, int &px, int &py) const;
 
    // ----- Refresh -------------------------------------------------------
 
    enum DirtyChannel {
        NoChannel  = 0x0,
        Raster     = 0x1,   
        Scene      = 0x2,   
        Overlay    = 0x4,   
        Extent     = 0x8,   
    };
    Q_DECLARE_FLAGS(DirtyChannels, DirtyChannel)
 
    
    void invalidate(DirtyChannels channels,
                    const QString &reason = QString());
 
    void suspendRefresh();
    void resumeRefresh();
 
    // ----- Legacy refresh API (kept for call-site backward compat) -------
 
    void refresh();
    void refreshLayerItems();
 
    // ----- Pan state (suppresses tile reloads during drag) ----------------
 
    void beginPan();
    void endPan();
    [[nodiscard]] bool isPanning() const;
 
    // Used by ChangeCRSCommand::undo/redo to apply a CRS without pushing to the undo stack.
    void applyCRSInternal(SpatialReferenceSystem *srs, bool ownsSRS);
 
signals:
    void extentChanged(const MapExtent &extent);
    void scaleChanged(double scale);
    void canvasSRSChanged(SpatialReferenceSystem *srs);
    void layerAdded(OpenSWMMVisLayer *layer);
    void layerRemoved(OpenSWMMVisLayer *layer);
    void layerOrderChanged();
    void sublayerOrderChanged(OpenSWMMVisLayer *host);
    void activeToolChanged(OpenSWMMVisMapTool *tool);
    void cursorPositionChanged(double mapX, double mapY);
    void showScaleBarChanged(bool show);
    void showCoordinatesChanged(bool show);
    void maxUndoCountChanged(int count);
    void backgroundColorChanged(const QColor &color);
 
protected:
    void paintEvent(QPaintEvent *event)             override;
    void resizeEvent(QResizeEvent *event)          override;
    void showEvent(QShowEvent *event)              override;
    void hideEvent(QHideEvent *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;
    void keyPressEvent(QKeyEvent *event)           override;
    void keyReleaseEvent(QKeyEvent *event)         override;
 
    bool event(QEvent *event)                      override;
 
    void gestureEvent(QGestureEvent *event);
 
private slots:
    void onLayerRepaintRequested();
    void onRenderJobFinished(QImage result);
    void fireRasterChannel();
    void fireSceneChannel();
    void onDragRenderTick();
    void syncScaleBarFromPreferences();
    void syncQsgRenderKindsFromPreferences();
 
private:
 
    // Extent / overlay management
    void renderSceneBuffer();   
    void applyExtentToOverlay();
    void ensureOverlaySceneRectCovers(const QRectF &needed);
    [[nodiscard]] QRectF overlayVisibleSceneRect() const;
    [[nodiscard]] MapExtent arCorrectedExtent(const MapExtent &ext) const;
    void updateLayerZValues();
 
    // Render job management
    void startRenderJob();
    void cancelRenderJob();
 
    // Decorations (painted in widget coordinates)
    void renderScaleBar(QPainter &painter) const;
    void renderCoordinates(QPainter &painter, double mapX, double mapY) const;
    void renderTerrainLabel(QPainter &painter) const;
 
    // Returns ground distance (metres) represented by one horizontal screen pixel
    // at the centre of the current view.  CRS-aware: uses the cosine-latitude
    // formula for geographic CRS and linearUnitsToMetres() for projected CRS.
    [[nodiscard]] double metresPerPixel() const;
 
    // ----- Scene & overlay ------------------------------------------------
    OpenSWMMVisScene           *m_scene          = nullptr;
    OpenSWMMVisGraphicsView    *m_overlayView    = nullptr;
 
    // ----- CRS & extent ---------------------------------------------------
    SpatialReferenceSystem *m_canvasSRS      = nullptr;
    bool                    m_ownsSRS        = false;
    MapExtent               m_extent;
    QList<OpenSWMMVisLayer *>   m_layers;
    QVector<int>            m_layerGroupOrder;     // see layerGroupOrder()
    QStringList             m_pendingLayerOrder;   // see setPendingLayerOrder()
 
    // ----- Active tool & undo ---------------------------------------------
    OpenSWMMVisMapTool         *m_activeTool     = nullptr;
    MapUndoStack           *m_undoStack      = nullptr;
 
    // ----- Mesh-profile overlay (painted above the QSG frame) -------------
    // Not owned: MeshProfilePlotDialog creates it and clears this pointer
    // (setMeshProfileOverlay(nullptr)) before deleting it.
    MeshProfileOverlay         *m_meshProfileOverlay = nullptr;
 
    // Not owned: MapToolSelectProfile creates it and clears this pointer
    // (setProfilePathOverlay(nullptr)) before deleting it.
    ProfilePathOverlay         *m_profilePathOverlay = nullptr;
 
    // Selection locator. Canvas-owned (unlike the profile overlays, which a
    // dialog/tool binds and unbinds) because selection is always present.
    SelectionBeaconOverlay     *m_selectionBeacon = nullptr;
    [[nodiscard]] QVector<QPointF> resolveSelectionAnchors() const;
    void wireSelectionBeaconTo(OpenSWMMVisLayer *layer);
    void appendMeshSelectionAnchors(class SWMM2DMeshLayer *ml,
                                    QVector<QPointF> &anchors) const;
    QSet<QObject *>             m_beaconWiredLayers;
 
    // ----- Decorations ----------------------------------------------------
    bool                    m_showScaleBar   = true;
    bool                    m_showCoords     = false;
    std::optional<double>   m_terrainZ;           // set by TerrainToolbar sampling
    QString                 m_terrainUnit;        // "ft" or "m" from UnitSystem
    QColor                  m_bgColor        = Qt::white;
    ScaleBarSettings       *m_scaleBarSettings = nullptr;
 
    // ----- Refresh timer --------------------------------------------------
    QTimer                 *m_refreshTimer   = nullptr;
 
    // ----- Phase 0.9 — per-channel dirty / debounce -----------------------
    QTimer                 *m_rasterTimer    = nullptr;
    QTimer                 *m_sceneTimer     = nullptr;
    DirtyChannels           m_pendingChannels = NoChannel;
    int                     m_suspendDepth   = 0;
    QString                 m_pendingReason;
 
    // ----- QGIS-style render buffers --------------------------------------
    QImage                  m_mapBuffer;          
    MapExtent               m_mapBufferExtent;    
    MapExtent               m_pendingRenderExtent;
    QImage                  m_frameBuffer;        
    MapRenderJob           *m_renderJob   = nullptr;
 
    // QGIS-style cache for the vector QGraphicsScene (2D mesh, GIS vectors,
    // annotations), used only during an active pan/zoom gesture: the scene is
    // rasterised live when idle (so selection / profile / hover stay
    // immediate) and that same buffer is blitted with a stale-buffer transform
    // during pan/zoom, instead of re-running QGraphicsScene::render() — which
    // paints the full mesh — on every gesture frame.
    QImage                  m_sceneBuffer;
    MapExtent               m_sceneBufferExtent;
    // P2 — true ⇒ m_sceneBuffer must be re-rendered before the next
    // non-gesture blit. Set by QGraphicsScene::changed, scene-affecting
    // refreshes, and non-raster repaintRequested; cleared by
    // renderSceneBuffer(). Lets tile arrivals and decoration repaints skip
    // the full scene rasterisation.
    bool                    m_sceneDirty     = true;
 
    // ----- Pan / zoom state -----------------------------------------------
    bool                    m_isPanning      = false;
    bool                    m_isZooming      = false;
    MapExtent               m_panStartExtent;
    // P3 — repeating ~200 ms timer active only while m_isPanning: warms the
    // raster tile caches at the current drag extent and starts a render job,
    // so blank margins fill DURING the drag instead of only after mouse-up.
    QTimer                 *m_dragRenderTimer = nullptr;
    double                  m_lastMouseMapX  = 0.0;
    double                  m_lastMouseMapY  = 0.0;
    int                     m_lastMousePxX   = 0;
    int                     m_lastMousePxY   = 0;
 
    // ----- Middle-mouse global pan ----------------------------------------
    bool                    m_middlePanActive = false;
    QPoint                  m_middlePanStart;
 
    // ----- Phase B.RHI — QQuickWidget host for the QSG renderers ----------
    // A transparent child widget overlaying the canvas, hosting (VS.8 +
    // Mesh Tiled LOD P1.1) a root Item with three stacked renderers:
    // SWMM2DMeshQSGRenderer (terrain mesh: elevation fill / wireframe /
    // contours) at the BOTTOM, SWMM2DResultsQSGRenderer (flood map: Gouraud
    // depth fill / bands / isolines / arrows) above it, and
    // SWMMLayerQSGRenderer (SWMM network: nodes/links/subcatchments) on top.
    // The QPainter SWMM2DMeshGraphicsItem path remains the mesh fallback
    // (preference Rendering/QsgMeshEnabled, env OPENSWMM_QSG_MESH=0).
    // Native Metal on macOS, Vulkan on Linux, D3D11 on Windows.
    // See docs/RENDERING_5M_PLAN.md (Phase B.RHI).
    class QQuickWidget               *m_qsgWidget       = nullptr;
    class SWMMLayerQSGRenderer       *m_qsgRenderer     = nullptr;
    class SWMM2DResultsQSGRenderer   *m_qsg2DRenderer   = nullptr;
    class SWMM2DMeshQSGRenderer      *m_qsgMeshRenderer = nullptr;
 
    // Cached QSG framebuffer (re-grabbed only when something the QSG
    // renderer cares about actually changed — extent, layer, widget
    // size, or a layer's repaintRequested signal). Without this cache,
    // every basemap repaint event paid the cost of a synchronous
    // repaint() + grabFramebuffer() on the QSG widget, which dominates
    // paintEvent on large models.
    QImage                       m_qsgFrameCache;
    bool                         m_qsgFrameDirty = true;
    MapExtent                    m_qsgCachedExtent;
    class SWMMModelLayer        *m_qsgCachedLayer = nullptr;
    class SWMM2DResultsLayer    *m_qsgCached2DLayer = nullptr;
    class SWMM2DMeshLayer       *m_qsgCachedMeshLayer = nullptr;
    QSize                        m_qsgCachedSize;
 
    // Sum of the three QSG renderers' contentRevision() counters as of the
    // last successful grab. The renderers bump their counter the moment an
    // external change marks them dirty, so comparing against this catches a
    // change that landed after the canvas already consumed (and cleared)
    // m_qsgFrameDirty — otherwise that grab would have captured a frame the
    // renderer had not yet rebuilt, and nothing would ever regrab it.
    quint64                      m_qsgCachedContentRev = 0;
 
    [[nodiscard]] quint64 qsgContentRevision() const;
 
    // VS.8 — true while the canvas force-enabled the 1D QSG kinds because a
    // 2D results layer is QSG-owned (the network must composite above the
    // flood map inside the same QSG frame). Restored from Preferences when
    // the 2D layer goes away.
    bool                         m_qsg1DForced = false;
};
 
Q_DECLARE_OPERATORS_FOR_FLAGS(MapCanvas::DirtyChannels)
 
#endif // MAPCANVAS_H