maphandler.h

#ifndef IVS3D_MAPHANDLER_H
#define IVS3D_MAPHANDLER_H
 
#include <QGeoCoordinate>
#include <QGeoPath>
#include <QGeoPolygon>
#include <QLineF>
#include <QList>
#include <QMetaType>
#include <QObject>
#include <QPointF>
#include <QPolygonF>
#include <QQuickItem>
#include <QVariantList>
#include <QtGlobal>
#include <cmath>
#include <float.h>
 
// Set to 1 to enable partial marker styling based on selected/total ratio.
#ifndef GEOMAP_ENABLE_PARTIAL_SELECTION
#define GEOMAP_ENABLE_PARTIAL_SELECTION 1
#endif
 
using GpsDataList = QList<QPair<QPointF, bool>>;
Q_DECLARE_METATYPE(GpsDataList)
 
struct GpsPointState {
    QPointF point;
    bool used = false;
    qreal ratio = 0.0;
};
 
using GpsPointStateList = QList<GpsPointState>;
Q_DECLARE_METATYPE(GpsPointStateList)
 
 
class MapHandler : public QObject
{
    Q_OBJECT
 
    //--- METHOD DECLARATION ---//
 
  public:
    explicit MapHandler(QObject* parent = nullptr);
 
    void addPoints(const GpsDataList& m_gpsData);
 
    void updatePoints(const GpsPointStateList& changedPoints);
 
    void setPolygon(const QPolygonF& poly);
 
    void replaceData(const GpsDataList& gpsData, const QPolygonF& polygon);
    void updatePointsAndPolygon(const GpsPointStateList& changedPoints,
                                const QPolygonF& polygon);
 
    void emitCircleSignal(const QGeoCoordinate& coordinate, QString name,
                          bool used, qreal ratio)
    {
        Q_EMIT circleSignal(coordinate, name, used, ratio);
    }
    void emitAdjustMapCenter(const QGeoCoordinate& coordinate)
    {
        Q_EMIT adjustMap(coordinate);
    }
    void emitCreatePolyline(const QGeoCoordinate& coordinate)
    {
        Q_EMIT createPolyline(coordinate);
    }
    void emitSetTracePath(const QVariantList& coordinates)
    {
        Q_EMIT setTracePath(coordinates);
    }
    void emitSetMapSelect(const QGeoPath& path)
    {
        Q_EMIT setMapSelect(path);
    }
    void emitSetMapSelectCoordinates(const QVariantList& coordinates)
    {
        Q_EMIT setMapSelectCoordinates(coordinates);
    }
    void emitSetPoint(const int index, bool used)
    {
        Q_EMIT setPoint(index, used);
    }
 
    void emitSetPointState(const int index, bool used, qreal ratio)
    {
        Q_EMIT setPointState(index, used, ratio);
    }
 
    void emitSetPartialSelectionEnabled(bool enabled)
    {
      Q_EMIT setPartialSelectionEnabled(enabled);
    }
    void emitGetMapItems()
    {
        Q_EMIT getMapItems();
    }
 
    void drawGpsDataOnMap();
 
  Q_SIGNALS:
    void circleSignal(const QGeoCoordinate& coordinate, QString name, bool used,
                      qreal ratio);
    void adjustMap(const QGeoCoordinate& coordinate);
    void createPolyline(const QGeoCoordinate& coordinate);
    void setTracePath(const QVariantList& coordinates);
    void setMapSelect(const QGeoPath& path);
    void setMapSelectCoordinates(const QVariantList& coordinates);
    void setPoint(const int index, bool used);
    void setPointState(const int index, bool used, qreal ratio);
    void setPartialSelectionEnabled(bool enabled);
    void setPointHighlight(const int index, bool highlighted);
    void getMapItems();
    void clearMap();
 
  signals:
    void gpsClicked(QPointF gpsPoint, bool used);
 
    void gpsSelected(QPolygonF polyF);
 
  public slots:
    // Slot to signal which is emitted when a gps point on the map is clicked
    void onQmlGpsClicked(const QString& text);
    // Slot to signal which is emitted when the map is right clicked
    void onQmlMapClicked(const QString& text);
    // Slot to signal which returns all items on the map
    void onQmlMapItems(const QVariant& variant);
 
    void onQmlDeleteSelection();
 
    void onQmlSelectionBack();
 
    void onQmlSelectionForward();
 
    void setCurrentIndex(uint index);
    void setPartialSelectionMode(bool enabled);
 
  private:
    void newMapItems();
 
    QPolygonF geoPolyToPolyF();
 
    QList<QLineF> geoPolyToLineList();
 
    QPointF pointAtGeo(int index);
 
    QPointF minDistance(QPointF A, QPointF B, QPointF newPoint);
    void applyCurrentIndexHighlight();
 
    //--- METHOD DECLARATION ---//
 
  private:
    QMap<QPointF, bool> mGpsMap;
    QMap<QPointF, qreal> mPointSelectionRatio;
 
    QList<QPointF> mOrderedGpsList;
    QList<QPointF> mSourceIndexToPoint;
 
    QGeoPolygon mPolygon;
 
    QSet<QPointF> mChangedPoints;
 
    QMap<QPointF, int> mMapItems;
 
    QList<QGeoPolygon> mPolyStack;
 
    int mCurrentStackPos = -1;
    int mCurrentSourceIndex = -1;
    int mCurrentMapItemIndex = -1;
    bool mPartialSelectionEnabled = GEOMAP_ENABLE_PARTIAL_SELECTION != 0;
};
 
#endif // IVS3D_MAPHANDLER_H