GeoMapCamera.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 <optional>
 
#include <QtCore/QObject>
#include <QtCore/QPointF>
#include <QtCore/QSizeF>
#include <QtCore/qnumeric.h>
#include <QtGui/QQuaternion>
#include <QtGui/QVector3D>
#include <QtPositioning/QGeoCoordinate>
#include <QtPositioning/QGeoRectangle>
#include <QtQmlIntegration/QtQmlIntegration>
 
class GeoMapCamera : public QObject
{
    Q_OBJECT
    QML_ELEMENT
    Q_PROPERTY(QGeoCoordinate center READ center WRITE setCenter NOTIFY centerChanged)
    Q_PROPERTY(qreal heading READ heading WRITE setHeading NOTIFY headingChanged)
    Q_PROPERTY(qreal tilt READ tilt WRITE setTilt NOTIFY tiltChanged)
    Q_PROPERTY(qreal distance READ distance WRITE setDistance NOTIFY distanceChanged)
    Q_PROPERTY(qreal centerElevation READ centerElevation WRITE setCenterElevation NOTIFY centerElevationChanged)
    Q_PROPERTY(QSizeF viewportSize READ viewportSize WRITE setViewportSize NOTIFY viewportSizeChanged)
    Q_PROPERTY(qreal fieldOfView READ fieldOfView WRITE setFieldOfView NOTIFY fieldOfViewChanged)
    Q_PROPERTY(qreal verticalFieldOfView READ verticalFieldOfView NOTIFY verticalFieldOfViewChanged)
    Q_PROPERTY(qreal unitsPerPixelAtUnitDistance READ unitsPerPixelAtUnitDistance NOTIFY unitsPerPixelAtUnitDistanceChanged)
    Q_PROPERTY(bool isTopDown READ isTopDown NOTIFY tiltChanged)
    Q_PROPERTY(Mode mode READ mode WRITE setMode NOTIFY modeChanged)
    Q_PROPERTY(qreal default3DTilt READ default3DTilt CONSTANT)
    Q_PROPERTY(QPointF sceneOrigin READ sceneOrigin WRITE setSceneOrigin NOTIFY scenePoseChanged)
    Q_PROPERTY(QVector3D scenePosition READ scenePosition NOTIFY scenePoseChanged)
    Q_PROPERTY(QQuaternion sceneRotation READ sceneRotation NOTIFY scenePoseChanged)
 
public:
    explicit GeoMapCamera(QObject* parent = nullptr);
 
    enum class Mode
    {
        Mode2D,
        Mode3D
    };
    Q_ENUM(Mode)
 
    static constexpr qreal kMinDistance = 10.0;
    static constexpr qreal kMaxDistance = 40000000.0;
    static constexpr qreal kMinTilt = 0.0;
    static constexpr qreal kMaxTilt = 85.0;
    static constexpr qreal kDefaultDistance = 1500.0;
    // Applied to the larger viewport axis (see verticalFieldOfView). Moderate
    // angle: wide-angle values skew level circles into tilted ellipses at the
    // screen edges (off-axis rectilinear distortion)
    static constexpr qreal kDefaultFieldOfView = 45.0;
    static constexpr qreal kDefault3DTilt = 55.0;
 
    QGeoCoordinate center() const;
    void setCenter(const QGeoCoordinate& center);
 
    bool isPositioned() const { return _positioned; }
 
    qreal heading() const { return _heading; }
 
    void setHeading(qreal heading);
 
    qreal tilt() const { return _tilt; }
 
    void setTilt(qreal tilt);
 
    qreal distance() const { return _distance; }
 
    void setDistance(qreal distance);
 
    qreal centerElevation() const { return _centerElevation; }
 
    void setCenterElevation(qreal elevation);
 
    QSizeF viewportSize() const { return _viewportSize; }
 
    void setViewportSize(const QSizeF& size);
 
    qreal fieldOfView() const { return _fieldOfView; }
 
    void setFieldOfView(qreal fov);
 
    qreal verticalFieldOfView() const;
 
    qreal unitsPerPixelAtUnitDistance() const;
 
    bool isTopDown() const { return qFuzzyIsNull(_tilt); }
 
    Mode mode() const { return _mode; }
 
    void setMode(Mode mode);
 
    qreal default3DTilt() const { return kDefault3DTilt; }
 
    Q_INVOKABLE void reset();
 
    Q_INVOKABLE void lookAt(const QGeoCoordinate& center, qreal heading, qreal tilt, qreal distance);
 
    Q_INVOKABLE void goTo2D()
    {
        setMode(Mode::Mode2D);
        setTilt(kMinTilt);
    }
 
    Q_INVOKABLE void goTo3D()
    {
        setMode(Mode::Mode3D);
        setTilt(kDefault3DTilt);
    }
 
    Q_INVOKABLE void beginPan(const QPointF& screenPos, double anchorZ = 0.0);
    Q_INVOKABLE void panTo(const QPointF& screenPos);
 
    Q_INVOKABLE void beginOrbit(const QPointF& screenPos, double anchorZ = 0.0);
    Q_INVOKABLE void orbitTo(const QPointF& screenPos);
 
    Q_INVOKABLE void beginLook(const QPointF& screenPos);
    Q_INVOKABLE void lookTo(const QPointF& screenPos);
 
    Q_INVOKABLE void rotateBy(qreal degrees, const QPointF& screenPos);
 
    Q_INVOKABLE void tiltBy(qreal degrees, const QPointF& screenPos);
 
    Q_INVOKABLE void zoom(qreal amount, const QPointF& screenPos);
 
    Q_INVOKABLE void zoomBy(qreal factor, const QPointF& screenPos);
 
    Q_INVOKABLE qreal sceneUnitsPerPixel() const;
 
    Q_INVOKABLE qreal distanceForZoomLevel(qreal zoomLevel) const;
 
    Q_INVOKABLE qreal zoomLevelForDistance(qreal distance) const;
 
    Q_INVOKABLE QGeoCoordinate centerForCoordinateAtScreenPoint(const QGeoCoordinate& coordinate,
                                                                const QPointF& screenPos, double worldZ = 0.0,
                                                                double centerElevation = qQNaN()) const;
 
    Q_INVOKABLE void fitToRegion(const QGeoRectangle& region);
 
    QVector3D cameraPosition() const;
 
    QPointF cameraGroundPosition() const;
 
    QPointF sceneOrigin() const { return _sceneOrigin; }
 
    void setSceneOrigin(const QPointF& origin);
 
    QVector3D scenePosition() const;
 
    QQuaternion sceneRotation() const;
 
    struct PickRay
    {
        double originX = 0.0;
        double originY = 0.0;
        double originZ = 0.0;
        double dirX = 0.0;
        double dirY = 0.0;
        double dirZ = 0.0;
    };
 
    std::optional<PickRay> pickRayAt(const QPointF& screenPos) const;
 
    std::optional<QPointF> screenToGround(const QPointF& screenPos, double planeZ = 0.0) const;
 
    Q_INVOKABLE QGeoCoordinate coordinateAtScreenPoint(const QPointF& screenPos, double worldZ = 0.0) const;
 
    std::optional<QPointF> groundPointCapped(const QPointF& screenPos, double maxRange) const;
 
    std::optional<QPointF> worldToScreen(const QPointF& worldGround, double worldZ = 0.0) const;
 
signals:
    void centerChanged();
    void headingChanged();
    void tiltChanged();
    void distanceChanged();
    void centerElevationChanged();
    void viewportSizeChanged();
    void fieldOfViewChanged();
    void verticalFieldOfViewChanged();
    void unitsPerPixelAtUnitDistanceChanged();
    void modeChanged();
    void scenePoseChanged();
 
private:
    void _setCenterWorld(const QPointF& world);
    void _anchorToScreen(const QPointF& anchorWorld, const QPointF& screenPos, double anchorZ = 0.0);
    static qreal _normalizedHeading(qreal heading);
 
    QPointF _centerWorld;  // mercator meters
    bool _positioned = false;
    QPointF _sceneOrigin;  // mercator meters
    Mode _mode = Mode::Mode2D;
    qreal _heading = 0.0;
    qreal _tilt = 0.0;
    qreal _distance = kDefaultDistance;
    qreal _centerElevation = 0.0;
    QSizeF _viewportSize;
    qreal _fieldOfView = kDefaultFieldOfView;
 
    // Gesture state
    std::optional<QPointF> _panAnchorWorld;
    double _panAnchorZ = 0.0;
    std::optional<QPointF> _orbitAnchorWorld;
    double _orbitAnchorZ = 0.0;
    QPointF _orbitAnchorScreen;
    QPointF _orbitStartScreen;
    qreal _orbitStartHeading = 0.0;
    qreal _orbitStartTilt = 0.0;
    std::optional<QPointF> _lookCameraGround;  // fixed camera ground position (world meters)
    qreal _lookCameraZ = 0.0;
    QPointF _lookStartScreen;
    qreal _lookStartHeading = 0.0;
    qreal _lookStartTilt = 0.0;
};