CameraCalc.h

Go to the documentation of this file.

#pragma once
 
#include <QtQmlIntegration/QtQmlIntegration>
 
#include "CameraSpec.h"
#include "SettingsFact.h"
#include "QGroundControlQmlGlobal.h"
 
class PlanMasterController;
 
class CameraCalc : public CameraSpec
{
    Q_OBJECT
    QML_ELEMENT
    QML_UNCREATABLE("")
public:
    CameraCalc(PlanMasterController* masterController, const QString& settingsGroup, QObject* parent = nullptr);
 
    Q_PROPERTY(QString          xlatCustomCameraName        READ xlatCustomCameraName                                           CONSTANT)                                   
    Q_PROPERTY(QString          xlatManualCameraName        READ xlatManualCameraName                                           CONSTANT)                                   
    Q_PROPERTY(bool             isManualCamera              READ isManualCamera                                                 NOTIFY isManualCameraChanged)
    Q_PROPERTY(bool             isCustomCamera              READ isCustomCamera                                                 NOTIFY isCustomCameraChanged)
    Q_PROPERTY(QString          cameraBrand                 MEMBER _cameraBrand         WRITE setCameraBrand                    NOTIFY cameraBrandChanged)
    Q_PROPERTY(QString          cameraModel                 MEMBER _cameraModel         WRITE setCameraModel                    NOTIFY cameraModelChanged)
    Q_PROPERTY(QStringList      cameraBrandList             MEMBER _cameraBrandList                                             CONSTANT)
    Q_PROPERTY(QStringList      cameraModelList             MEMBER _cameraModelList                                             NOTIFY cameraModelListChanged)
    Q_PROPERTY(Fact*            valueSetIsDistance          READ valueSetIsDistance                                             CONSTANT)                                   
    Q_PROPERTY(Fact*            distanceToSurface           READ distanceToSurface                                              CONSTANT)                                   
    Q_PROPERTY(Fact*            imageDensity                READ imageDensity                                                   CONSTANT)                                   
    Q_PROPERTY(Fact*            frontalOverlap              READ frontalOverlap                                                 CONSTANT)
    Q_PROPERTY(Fact*            sideOverlap                 READ sideOverlap                                                    CONSTANT)
    Q_PROPERTY(Fact*            adjustedFootprintSide       READ adjustedFootprintSide                                          CONSTANT)                                   
    Q_PROPERTY(Fact*            adjustedFootprintFrontal    READ adjustedFootprintFrontal                                       CONSTANT)                                   
 
    // When we are creating a manual grid we still use CameraCalc to store the manual grid information. It's a bastardization of what
    // CameraCalc is meant for but it greatly simplifies code and persistance of manual grids.
    //  grid altitude -         distanceToSurface
    //  grid altitude mode -    distanceMode
    //  trigger distance -      adjustedFootprintFrontal
    //  transect spacing -      adjustedFootprintSide
    Q_PROPERTY(QGroundControlQmlGlobal::AltitudeFrame distanceMode READ distanceMode WRITE setDistanceMode NOTIFY distanceModeChanged)
 
    // The following values are calculated from the camera properties
    Q_PROPERTY(double imageFootprintSide    READ imageFootprintSide     NOTIFY imageFootprintSideChanged)       
    Q_PROPERTY(double imageFootprintFrontal READ imageFootprintFrontal  NOTIFY imageFootprintFrontalChanged)    
 
    static QString xlatCustomCameraName     (void);
    static QString xlatManualCameraName     (void);
    static QString canonicalCustomCameraName(void);
    static QString canonicalManualCameraName(void);
 
    Fact* valueSetIsDistance        (void) { return &_valueSetIsDistanceFact; }
    Fact* distanceToSurface         (void) { return &_distanceToSurfaceFact; }
    Fact* imageDensity              (void) { return &_imageDensityFact; }
    Fact* frontalOverlap            (void) { return &_frontalOverlapFact; }
    Fact* sideOverlap               (void) { return &_sideOverlapFact; }
    Fact* adjustedFootprintSide     (void) { return &_adjustedFootprintSideFact; }
    Fact* adjustedFootprintFrontal  (void) { return &_adjustedFootprintFrontalFact; }
 
    const Fact* valueSetIsDistance          (void) const { return &_valueSetIsDistanceFact; }
    const Fact* distanceToSurface           (void) const { return &_distanceToSurfaceFact; }
    const Fact* imageDensity                (void) const { return &_imageDensityFact; }
    const Fact* frontalOverlap              (void) const { return &_frontalOverlapFact; }
    const Fact* sideOverlap                 (void) const { return &_sideOverlapFact; }
    const Fact* adjustedFootprintSide       (void) const { return &_adjustedFootprintSideFact; }
    const Fact* adjustedFootprintFrontal    (void) const { return &_adjustedFootprintFrontalFact; }
 
    bool    isManualCamera              (void) const { return _cameraNameFact.rawValue().toString() == canonicalManualCameraName(); }
    bool    isCustomCamera              (void) const { return _cameraNameFact.rawValue().toString() == canonicalCustomCameraName(); }
    double  imageFootprintSide          (void) const { return _imageFootprintSide; }
    double  imageFootprintFrontal       (void) const { return _imageFootprintFrontal; }
    QGroundControlQmlGlobal::AltitudeFrame distanceMode(void) const { return _distanceMode; }
 
    void setDistanceMode                (QGroundControlQmlGlobal::AltitudeFrame altFrame);
    void setCameraBrand                 (const QString& cameraBrand);
    void setCameraModel                 (const QString& cameraModel);
 
    void save(QJsonObject& json) const;
    bool load(const QJsonObject& json, bool deprecatedFollowTerrain, QString& errorString, bool forPresets);
 
    void _setCameraNameFromV3TransectLoad   (const QString& cameraName);
 
    static constexpr const char* cameraNameName                  = "CameraName";
    static constexpr const char* valueSetIsDistanceName          = "ValueSetIsDistance";
    static constexpr const char* distanceToSurfaceName           = "DistanceToSurface";
    static constexpr const char* distanceModeName                = "DistanceMode";
    static constexpr const char* imageDensityName                = "ImageDensity";
    static constexpr const char* frontalOverlapName              = "FrontalOverlap";
    static constexpr const char* sideOverlapName                 = "SideOverlap";
    static constexpr const char* adjustedFootprintFrontalName    = "AdjustedFootprintFrontal";
    static constexpr const char* adjustedFootprintSideName       = "AdjustedFootprintSide";
 
signals:
    void imageFootprintSideChanged          (double imageFootprintSide);
    void imageFootprintFrontalChanged       (double imageFootprintFrontal);
    void distanceModeChanged                (int altFrame);
    void isManualCameraChanged              (void);
    void isCustomCameraChanged              (void);
    void cameraBrandChanged                 (void);
    void cameraModelChanged                 (void);
    void cameraModelListChanged             (void);
    void updateCameraStats                  (void);
 
private slots:
    void _recalcTriggerDistance             (void);
    void _setDirty                          (void);
    void _cameraNameChanged                 (void);
 
private:
    void    _setBrandModelFromCanonicalName (const QString& cameraName);
    void    _rebuildCameraModelList         (void);
    QString _validCanonicalCameraName       (const QString& cameraName);
 
    bool                                _disableRecalc              = false;
    QString                             _cameraBrand;
    QString                             _cameraModel;
    QStringList                         _cameraBrandList;
    QStringList                         _cameraModelList;
    QGroundControlQmlGlobal::AltitudeFrame    _distanceMode               = QGroundControlQmlGlobal::AltitudeFrameRelative;
    double                              _imageFootprintSide         = 0;
    double                              _imageFootprintFrontal      = 0;
    QVariantList                        _knownCameraList;
 
    QMap<QString, FactMetaData*> _metaDataMap;
 
    SettingsFact _cameraNameFact;
    SettingsFact _valueSetIsDistanceFact;
    SettingsFact _distanceToSurfaceFact;
    SettingsFact _imageDensityFact;
    SettingsFact _frontalOverlapFact;
    SettingsFact _sideOverlapFact;
    SettingsFact _adjustedFootprintSideFact;
    SettingsFact _adjustedFootprintFrontalFact;
 
    // The following are deprecated and only included in order to convert V0 formats
    enum CameraSpecType {
        CameraSpecNone,
        CameraSpecCustom,
        CameraSpecKnown
    };
 
    static constexpr const char* _jsonCameraSpecTypeKeyDeprecated            = "CameraSpecType";
    // The following are deprecated and only included in order to convert V1 formats
    static constexpr const char* _jsonDistanceToSurfaceRelativeKeyDeprecated = "DistanceToSurfaceRelative";
};