SurfacePatchModel.h

Go to the documentation of this file.

/****************************************************************************
 *
 * (c) 2009-2024 QGROUNDCONTROL PROJECT <http://www.qgroundcontrol.org>
 *
 * QGroundControl is licensed according to the terms in the file
 * COPYING.md in the root of the source code directory.
 *
 ****************************************************************************/
 
#pragma once
 
#include <QtCore/QAbstractListModel>
#include <QtCore/QElapsedTimer>
#include <QtCore/QHash>
#include <QtCore/QList>
#include <QtCore/QPointF>
#include <QtCore/QSet>
#include <QtCore/QString>
#include <QtCore/QStringList>
#include <QtGui/QImage>
#include <QtQmlIntegration/QtQmlIntegration>
 
#include "TileMath.h"
 
class GeoScene;
class GeoMapCamera;
class HeightField;
class HeightSource;
class QNetworkAccessManager;
class QTimer;
class SurfaceModel;
class TileImageSource;
 
Q_MOC_INCLUDE("GeoMapCamera.h")
Q_MOC_INCLUDE("GeoScene.h")
Q_MOC_INCLUDE("HeightField.h")
 
class SurfacePatchModel : public QAbstractListModel
{
    Q_OBJECT
    QML_ELEMENT
    Q_PROPERTY(GeoScene* scene READ scene WRITE setScene NOTIFY sceneChanged)
    Q_PROPERTY(bool terrain READ terrain WRITE setTerrain NOTIFY terrainChanged)
    Q_PROPERTY(bool debugHills READ debugHills WRITE setDebugHills NOTIFY debugHillsChanged)
    Q_PROPERTY(QString mapType READ mapType WRITE setMapType NOTIFY mapTypeChanged)
    Q_PROPERTY(int gridSize READ gridSize CONSTANT)
    Q_PROPERTY(double maxRangeMultiplier READ maxRangeMultiplier CONSTANT)
    Q_PROPERTY(int patchCount READ patchCount NOTIFY statsChanged)
    Q_PROPERTY(int pendingCount READ pendingCount NOTIFY statsChanged)
    Q_PROPERTY(int maxZoomLevel READ maxZoomLevel NOTIFY statsChanged)
    Q_PROPERTY(bool statsEnabled READ statsEnabled WRITE setStatsEnabled NOTIFY statsEnabledChanged)
    Q_PROPERTY(QString statsText READ statsText NOTIFY statsTextChanged)
    Q_PROPERTY(bool capturing READ capturing NOTIFY capturingChanged)
 
public:
    explicit SurfacePatchModel(QObject* parent = nullptr);
    ~SurfacePatchModel() override;
 
    enum Roles
    {
        CenterXRole = Qt::UserRole + 1,  
        CenterYRole,                     
        SpanRole,                        
        ZoomRole,                        
        HeightsRole,                     
        ReadyRole,
        CoveredRole,                     
        TileImageRole,                   
        HasTileImageRole,                
        EdgeLodDeltasRole,               
        TileXRole,                       
        TileYRole,                       
    };
 
    GeoScene* scene() const { return _scene; }
 
    void setScene(GeoScene* scene);
 
    bool terrain() const { return _terrain; }
 
    void setTerrain(bool terrain);
 
    bool debugHills() const { return _debugHills; }
 
    void setDebugHills(bool debugHills);
 
    QString mapType() const { return _mapType; }
 
    void setMapType(const QString& mapType);
 
    int gridSize() const;
 
    HeightField* heightField() const { return _heightField; }
 
    Q_INVOKABLE double terrainHeightAt(const QGeoCoordinate& coordinate) const;
 
    Q_INVOKABLE double terrainDataHeightAt(const QGeoCoordinate& coordinate) const;
 
    Q_INVOKABLE bool segmentBelowTerrain(const QGeoCoordinate& from, const QGeoCoordinate& to, double ignoreStartMeters,
                                         double ignoreEndMeters) const;
 
    Q_INVOKABLE QGeoCoordinate surfaceCoordinateAtScreenPoint(const GeoMapCamera* camera, const QPointF& screenPos,
                                                              double zScale) const;
 
    double maxRangeMultiplier() const;
 
    int patchCount() const { return _keys.count(); }
 
    int pendingCount() const;
    int maxZoomLevel() const;
 
    int pendingImageCount() const { return _imageRequestKey.count(); }
 
    void setTileImageNetworkManager(QNetworkAccessManager* networkManager)
    {
        _tileImageNetworkManager = networkManager;
    }
 
    bool statsEnabled() const { return _statsEnabled; }  // GCOVR_EXCL_LINE
 
    void setStatsEnabled(bool enabled);
 
    QString statsText() const { return _statsText; }
 
    bool capturing() const { return _capturing; }
 
    Q_INVOKABLE void startCapture();
 
    Q_INVOKABLE QString stopCapture();
 
    Q_INVOKABLE void analyzeSurface() const;
 
#ifdef QGC_UNITTEST_BUILD
    void drainUpdates();
#endif
 
    int rowCount(const QModelIndex& parent = QModelIndex()) const override;
    QVariant data(const QModelIndex& index, int role) const override;
    QHash<int, QByteArray> roleNames() const override;
 
signals:
    void sceneChanged();
    void terrainChanged();
    void debugHillsChanged();
    void mapTypeChanged();
    void statsChanged();
    void statsEnabledChanged();
    void statsTextChanged();
    void capturingChanged();
    void terrainHeightsChanged();
    void terrainDataChanged();
 
private slots:
    void _patchAdded(const TileMath::TileKey& key);
    void _patchReady(const TileMath::TileKey& key);
    void _patchEdgeDeltasChanged(const TileMath::TileKey& key);
    void _patchRemoved(const TileMath::TileKey& key);
    void _sceneOriginChanged();
    void _tileImageReady(int requestId, const QImage& image);
    void _tileImageFailed(int requestId);
    void _statsTick();
 
private:
    void _rebuildSurfaceModel();
    double _surfaceHeightAt(const QPointF& world) const;
    void _resetImagery();
    void _requestTileImage(const TileMath::TileKey& key);
    void _retryFailedImages();
    void _notifyTileImageChanged(const TileMath::TileKey& key);
    void _invalidateFallbacks(const TileMath::TileKey& tile);
    void _notifyCoveredMayHaveChanged(const TileMath::TileKey& changedKey);
    void _scheduleStatsChanged();
    void _startStatsSampling();
    QImage _fallbackImage(const TileMath::TileKey& key) const;
    QImage _compositeFromChildren(const TileMath::TileKey& key) const;
    QImage _cropFromAncestor(const TileMath::TileKey& key) const;
    bool _fallbackAvailable(const TileMath::TileKey& key) const;
    GeoMapCamera* _camera() const;
 
    static constexpr int kMaxRetiredImages = 128;         
    static constexpr int kMaxAncestorFallbackLevels = 8;  
    static constexpr int kImageRetryMs = 3000;            
    static constexpr double kSegmentSampleSpacingMeters = 30.0;
    static constexpr int kMaxSegmentSamples = 2000;       
 
    GeoScene* _scene = nullptr;
    HeightSource* _heightSource = nullptr;
    HeightField* _heightField = nullptr;
    SurfaceModel* _surfaceModel = nullptr;
    bool _terrain = false;
    bool _debugHills = false;
    QString _mapType;
    TileImageSource* _tileSource = nullptr;
    QNetworkAccessManager* _tileImageNetworkManager = nullptr;  
    QHash<TileMath::TileKey, QImage> _tileImages;               
    mutable QHash<TileMath::TileKey, QImage> _fallbackCache;
    QList<TileMath::TileKey> _retiredOrder;            
    QHash<int, TileMath::TileKey> _imageRequestKey;    
    QHash<TileMath::TileKey, int> _imageRequestByKey;  
    QSet<TileMath::TileKey> _failedImageKeys;          
    QTimer* _imageRetryTimer = nullptr;
    QList<TileMath::TileKey> _keys;                    
 
    // Perf counters sampled by _statsTick (see setStatsEnabled)
    QTimer* _statsTimer = nullptr;
    bool _statsEnabled = false;
    bool _statsNotifyPending = false;  
    QString _statsText;
    int _statAdds = 0;
    int _statRemoves = 0;
    mutable int _statComposites = 0;  
 
    // Capture recording (see startCapture)
    bool _capturing = false;
    QStringList _captureRows;
    QElapsedTimer _captureClock;
    double _captureWorstMaxMs = 0.0;  
    double _captureWorstAvgMs = 0.0;
};