GeoMapProvider.h

/***************************************************************************
 *   Copyright (C) 2019-2024 by Stefan Kebekus                             *
 *   stefan.kebekus@gmail.com                                              *
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 3 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 *   This program is distributed in the hope that it will be useful,       *
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
 *   GNU General Public License for more details.                          *
 *                                                                         *
 *   You should have received a copy of the GNU General Public License     *
 *   along with this program; if not, write to the                         *
 *   Free Software Foundation, Inc.,                                       *
 *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
 ***************************************************************************/
 
#pragma once
 
#include <QCache>
#include <QFuture>
#include <QGeoRectangle>
#include <QImage>
#include <QProperty>
#include <QQmlEngine>
#include <QStandardPaths>
#include <QTemporaryFile>
#include <QTimer>
#include <optional>
#include <utility>
 
#include "Airspace.h"
#include "GlobalObject.h"
#include "TileServer.h"
#include "Waypoint.h"
#include "fileFormats/MBTILES.h"
 
using namespace Qt::Literals::StringLiterals;
 
 
namespace GeoMaps
{

 
class GeoMapProvider : public GlobalObject
{
    Q_OBJECT
    QML_ELEMENT
    QML_SINGLETON
 
public:
    explicit GeoMapProvider(QObject *parent = nullptr);
 
    // No default constructor, important for QML singleton
    explicit GeoMapProvider() = delete;
 
    // deferred initialization
    void deferredInitialization() override;
 
    // factory function for QML singleton
    static GeoMaps::GeoMapProvider* create(QQmlEngine* /*unused*/, QJSEngine* /*unused*/)
    {
        return GlobalObject::geoMapProvider();
    }

    ~GeoMapProvider() override;
 
 
 
    //
    // Properties
    //

    Q_PROPERTY(QList<GeoMaps::Airspace> airspaces READ airspaces BINDABLE bindableAirspaces)
 
    
    Q_PROPERTY(QStringList availableRasterMaps READ availableRasterMaps BINDABLE bindableAvailableRasterMaps)

    Q_PROPERTY(QString copyrightNotice READ copyrightNotice CONSTANT)

    Q_PROPERTY(QString currentRasterMap READ currentRasterMap WRITE setCurrentRasterMap BINDABLE bindableCurrentRasterMap)

    Q_PROPERTY(int currentRasterMapTileSize READ currentRasterMapTileSize BINDABLE bindableCurrentRasterMapTileSize)

    Q_PROPERTY(QByteArray geoJSON READ geoJSON BINDABLE bindableGeoJSON)

    Q_PROPERTY(QStringList oversizedMaps READ oversizedMaps BINDABLE bindableOversizedMaps)

    Q_PROPERTY(QString serverUrl READ serverUrl NOTIFY serverUrlChanged)

    Q_PROPERTY(QString styleFileURL READ styleFileURL NOTIFY styleFileURLChanged)

    Q_PROPERTY(QList<QSharedPointer<FileFormats::MBTILES>> terrainMapTiles READ terrainMapTiles NOTIFY terrainMapTilesChanged)

    Q_PROPERTY(QList<GeoMaps::Waypoint> waypoints READ waypoints NOTIFY waypointsChanged)
 
 
 
    //
    // Getter Methods
    //

    [[nodiscard]] QList<GeoMaps::Airspace> airspaces() const {return m_airspaces.value();}

    [[nodiscard]] QBindable<QList<GeoMaps::Airspace>> bindableAirspaces() {return &m_airspaces;}

    [[nodiscard]] QStringList availableRasterMaps() const
    {
        return m_availableRasterMaps.value();
    }

    [[nodiscard]] QBindable<QStringList> bindableAvailableRasterMaps() const
    {
        return &m_availableRasterMaps;
    }

    [[nodiscard]] static QString copyrightNotice();

    [[nodiscard]] QString currentRasterMap() const {return m_currentRasterMap.value();}

    [[nodiscard]] QBindable<QString> bindableCurrentRasterMap() const {return &m_currentRasterMap;}

    [[nodiscard]] int currentRasterMapTileSize() const {return m_currentRasterMapTileSize.value();}

    [[nodiscard]] QBindable<int> bindableCurrentRasterMapTileSize() const {return &m_currentRasterMapTileSize;}

    [[nodiscard]] QByteArray geoJSON() const {return m_combinedGeoJSON.value();}

    [[nodiscard]] QBindable<QByteArray> bindableGeoJSON() {return &m_combinedGeoJSON;}

    [[nodiscard]] QStringList oversizedMaps() const {return m_oversizedMaps.value();}

    [[nodiscard]] QBindable<QStringList> bindableOversizedMaps() {return &m_oversizedMaps;}

    [[nodiscard]] QString serverUrl() {return m_tileServer.serverUrl();}

    [[nodiscard]] QString styleFileURL();

    [[nodiscard]] QList<QSharedPointer<FileFormats::MBTILES>> terrainMapTiles() const
    {
        return m_terrainMapTiles;
    }

    [[nodiscard]] QList<Waypoint> waypoints();

    [[nodiscard]] QStringList waypointSearchKeys() const { return m_waypointIndex.searchKeys; }
 
 
 
    //
    // Setter Methods
    //

    void setCurrentRasterMap(const QString& mapName);
 
 
 
    //
    // Methods
    //

    [[nodiscard]] Q_INVOKABLE QVariantList airspacesAtPosition(const QGeoCoordinate &position);

    [[nodiscard]] Q_INVOKABLE GeoMaps::Waypoint closestWaypoint(QGeoCoordinate position, const QGeoCoordinate &distPosition);

    [[nodiscard]] Q_INVOKABLE static GeoMaps::Waypoint createWaypoint()
    {
        return {};
    }

    [[nodiscard]] Q_INVOKABLE Units::Distance terrainElevationAMSL(const QGeoCoordinate& coordinate);

    [[nodiscard]] Q_INVOKABLE static QByteArray emptyGeoJSON();

    [[nodiscard]] Q_INVOKABLE Waypoint findByID(const QString& icaoID);

    [[nodiscard]] Q_INVOKABLE QList<GeoMaps::Waypoint> nearbyWaypoints(const QGeoCoordinate& position, const QString& type);
 
 
signals:
    void geoJSONChanged();

    void oversizedMapsChanged();

    void styleFileURLChanged();

    void serverUrlChanged();

    void terrainMapTilesChanged();

    void waypointsChanged();
 
private:
    Q_DISABLE_COPY_MOVE(GeoMapProvider)
 
    // This slot is called every time the the set of aviation maps qchanges. It
    // fills the aviation data cache.
    void onAviationMapsChanged();
 
    // This slot is called every time the the set of MBTile files changes. It
    // sets up the tile server to and generates a new style file.
    void onMBTILESChanged();
 
    // This slot is called just before one of the MBTile files is replaced or
    // deleted. It releases every handle to the file, so that the file can be
    // replaced (Windows refuses to rename over or delete an open file). The
    // tile server is set up again with the new file in onMBTILESChanged().
    void onMBTILESAboutToChange(const QString& fileName);
 
    // Sets up the tile server to serve the raster map with the given name
    // under "rasterMap" and updates the properties currentRasterMap and
    // currentRasterMapTileSize. Does not emit styleFileURLChanged().
    void serveRasterMap(const QString& mapName);
 
 
    // Interal function that does most of the work for aviationMapsChanged()
    // emits geoJSONChanged() when done. This function is meant to be run in a
    // separate thread.
    // Lookup structures over _waypoints_, built together with the waypoint
    // list on the worker thread and replaced together with it. Rows are
    // indices into _waypoints_.
    struct WaypointIndex {
        // First row (in name order) for every non-empty ICAO code
        QHash<QString, int> rowByICAOCode;
        // Per row: simplify(name) + ' ' + simplify(ICAO code)
        QStringList searchKeys;
        // (cell, row) pairs sorted by cell; see cellOf()
        QList<std::pair<qint32, int>> cells;
    };
    struct aviationDataCacheResult {
        QList<Waypoint> waypoints;
        WaypointIndex index;
        QList<Airspace> airspaces;
        QByteArray combinedGeoJSON;
    };
    aviationDataCacheResult fillAviationDataCache(QStringList JSONFileNames, bool hideGlidingSectors);
 
    // Builds the index for a waypoint list. Static and side-effect free, so
    // that it can run on the worker thread.
    static WaypointIndex buildWaypointIndex(const QList<Waypoint>& waypoints);
 
    // Spatial grid cell of a coordinate: 0.1° x 0.1° cells, numbered
    // latCell*3600 + lonCell with latCell in 0..1799 and lonCell in 0..3599.
    static qint32 cellOf(const QGeoCoordinate& coordinate);
 
    // Rows of all map waypoints that may lie within radiusM of position. The
    // result is a superset of the waypoints within that distance. Returns
    // nullopt if the position is invalid or the area is so large that the
    // caller should scan all rows instead.
    [[nodiscard]] std::optional<QList<int>> rowsNear(const QGeoCoordinate& position, double radiusM) const;
 
    // This is the path under which map tiles are available on the m_tileServer.
    // This is set to a random number that changes every time the set of MBTile
    // files changes
    QString _currentBaseMapPath;
    QString _currentTerrainMapPath;
 
    // Tile Server
    TileServer m_tileServer;
 
    // Temporary file that holds the current style file
    QPointer<QTemporaryFile> m_styleFile;
 
    //
    // Aviation Data Cache
    //
    QFuture<GeoMaps::GeoMapProvider::aviationDataCacheResult> _aviationDataCacheFuture; // Future; indicates if fillAviationDataCache() is currently running
    QTimer _aviationDataCacheTimer;         // Timer used to start another run of fillAviationDataCache()
 
    //
    // MBTILES
    //
    QList<QSharedPointer<FileFormats::MBTILES>> m_baseMapVectorTiles;
    QProperty<QList<QSharedPointer<FileFormats::MBTILES>>> m_baseMapRasterTiles;
    QList<QSharedPointer<FileFormats::MBTILES>> m_terrainMapTiles;
 
    QProperty<QStringList> m_availableRasterMaps;
    QStringList computeAvailableRasterMaps();
 
    QProperty<QString> m_currentRasterMap {u"non-empty place holder"_s};
    QPropertyNotifier m_currentRasterMapNotifier; // Used to save the currentRasterMap
    QProperty<int> m_currentRasterMapTileSize {512};
 
    Q_OBJECT_BINDABLE_PROPERTY(GeoMaps::GeoMapProvider, QByteArray, m_combinedGeoJSON, &GeoMaps::GeoMapProvider::geoJSONChanged)
    QList<Waypoint> _waypoints_; // Cache: Waypoints
    WaypointIndex m_waypointIndex; // Lookup structures over _waypoints_
    QProperty<QList<Airspace>> m_airspaces; // Cache: Airspaces
 
    // Aviation maps whose file size exceeds maxAviationMapFileSize are ignored
    // when compiling the aviation data; parsing them would exhaust the memory
    // available on mobile devices (see issue #676). The peak memory used when
    // parsing is roughly ten times the file size.
    static constexpr qint64 maxAviationMapFileSize = 50*1024*1024;
    static constexpr qint64 maxGeoJSONCacheSize = 150*1024*1024;
    Q_OBJECT_BINDABLE_PROPERTY(GeoMaps::GeoMapProvider, QStringList, m_oversizedMaps, &GeoMaps::GeoMapProvider::oversizedMapsChanged)
 
    // TerrainImageCache
    QCache<qint64,QImage> terrainTileCache {6}; // Hold 6 tiles, roughly 1.2MB
 
    // GeoJSON file
    QString geoJSONCache {QStandardPaths::writableLocation(QStandardPaths::AppDataLocation) + u"/aviationData.json"_s};
};
 
} // namespace GeoMaps