aircraftsituation.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: Copyright (C) 2013 swift Project Community / Contributors
// SPDX-License-Identifier: GPL-3.0-or-later OR LicenseRef-swift-pilot-client-1

 
#ifndef SWIFT_MISC_AVIATION_AIRCRAFTSITUATION_H
#define SWIFT_MISC_AVIATION_AIRCRAFTSITUATION_H
 
#include <array>
 
#include <QMetaType>
#include <QString>
#include <QVector3D>
 
#include "misc/aviation/aircraftvelocity.h"
#include "misc/aviation/altitude.h"
#include "misc/aviation/callsign.h"
#include "misc/aviation/heading.h"
#include "misc/aviation/ongroundinfo.h"
#include "misc/geo/coordinategeodetic.h"
#include "misc/geo/elevationplane.h"
#include "misc/geo/latitude.h"
#include "misc/geo/longitude.h"
#include "misc/math/mathutils.h"
#include "misc/metaclass.h"
#include "misc/pq/angle.h"
#include "misc/pq/length.h"
#include "misc/pq/speed.h"
#include "misc/pq/time.h"
#include "misc/propertyindexref.h"
#include "misc/swiftmiscexport.h"
#include "misc/timestampbased.h"
#include "misc/valueobject.h"
 
SWIFT_DECLARE_VALUEOBJECT_MIXINS(swift::misc::aviation, CAircraftSituation)
 
namespace swift::misc
{
    namespace geo
    {
        class CElevationPlane;
    }
    namespace aviation
    {
        class CAircraftParts;
        class CAircraftPartsList;
        class CAircraftLights;

        class SWIFT_MISC_EXPORT CAircraftSituation :
            public CValueObject<CAircraftSituation>,
            public geo::ICoordinateGeodetic,
            public ITimestampWithOffsetBased
        {
        public:
            enum ColumnIndex
            {
                IndexPosition = CPropertyIndexRef::GlobalIndexCAircraftSituation,
                IndexLatitude,
                IndexLongitude,
                IndexAltitude,
                IndexHeading,
                IndexBank,
                IndexIsOnGroundInfo,
                IndexPitch,
                IndexPBHInfo,
                IndexVelocity,
                IndexGroundSpeed,
                IndexGroundElevationPlane,
                IndexGroundElevationInfo,
                IndexGroundElevationInfoTransferred,
                IndexGroundElevationInfoString,
                IndexGroundElevationPlusInfo,
                IndexCallsign,
                IndexCG,
                IndexCanLikelySkipNearGroundInterpolation
            };

            enum AltitudeCorrection
            {
                NoCorrection,
                Underflow, 
                DraggedToGround, 
                AGL,
                NoElevation, 
                UnknownCorrection
            };

            enum GndElevationInfo
            {
                // best info (most accurate) last
                NoElevationInfo,
                Test, 
                SituationChange, 
                Extrapolated, 
                Average, 
                Interpolated, 
                FromCache, 
                FromProvider 
            };

            CAircraftSituation() = default;

            CAircraftSituation(const CCallsign &correspondingCallsign);

            CAircraftSituation(const geo::CCoordinateGeodetic &position, const CHeading &heading = {},
                               const physical_quantities::CAngle &pitch = {},
                               const physical_quantities::CAngle &bank = {}, const physical_quantities::CSpeed &gs = {},
                               const geo::CElevationPlane &groundElevation = {});

            CAircraftSituation(const CCallsign &correspondingCallsign, const geo::CCoordinateGeodetic &position,
                               const CHeading &heading = {}, const physical_quantities::CAngle &pitch = {},
                               const physical_quantities::CAngle &bank = {}, const physical_quantities::CSpeed &gs = {},
                               const geo::CElevationPlane &groundElevation = {});

            QString convertToQString(bool i18n = false) const;

            QVariant propertyByIndex(CPropertyIndexRef index) const;

            void setPropertyByIndex(CPropertyIndexRef index, const QVariant &variant);

            int comparePropertyByIndex(CPropertyIndexRef index, const CAircraftSituation &compareValue) const;

            const geo::CCoordinateGeodetic &getPosition() const { return m_position; }

            bool isPositionNull() const { return m_position.isNull(); }

            bool isPositionOrAltitudeNull() const { return this->isPositionNull() || this->getAltitude().isNull(); }

            bool isNull() const override;

            bool isOtherElevationInfoBetter(GndElevationInfo otherInfo, bool transferred) const;

            bool equalPbh(const CAircraftSituation &other) const;

            bool equalPbhAndVector(const CAircraftSituation &other) const;

            bool equalPbhVectorAltitude(const CAircraftSituation &other) const;

            bool equalPbhVectorAltitudeElevation(const CAircraftSituation &other) const;

            void setNull();

            void setPosition(const geo::CCoordinateGeodetic &position) { m_position = position; }

            geo::CLatitude latitude() const override { return m_position.latitude(); }

            geo::CLongitude longitude() const override { return m_position.longitude(); }

            bool isOnGround() const { return m_onGroundInfo.getOnGround() == COnGroundInfo::OnGround; }

            bool isOnGroundFromParts() const;

            bool isOnGroundFromNetwork() const;

            bool isOnGroundInfoAvailable() const;

            bool shouldGuessOnGround() const;

            physical_quantities::CLength getGroundDistance(const physical_quantities::CLength &centerOfGravity) const;

            bool hasGroundDetailsForGndInterpolation() const;

            void setOnGroundDetails(COnGroundInfo::OnGroundDetails details);

            aviation::COnGroundInfo getOnGroundInfo() const;

            void setOnGroundInfo(const aviation::COnGroundInfo &info);

            const CAltitude &geodeticHeight() const override { return m_position.geodeticHeight(); }

            QVector3D normalVector() const override { return m_position.normalVector(); }

            std::array<double, 3> normalVectorDouble() const override { return m_position.normalVectorDouble(); }

            const CAltitude &getGroundElevation() const { return m_groundElevationPlane.getAltitude(); }

            const geo::CElevationPlane &getGroundElevationPlane() const { return m_groundElevationPlane; }

            GndElevationInfo getGroundElevationInfo() const;

            QString getGroundElevationInfoAsString() const;

            QString getGroundElevationAndInfo() const;

            bool isGroundElevationInfoTransferred() const { return m_isElvInfoTransferred; }

            void setGroundElevationInfo(GndElevationInfo details) { m_elvInfo = static_cast<int>(details); }

            bool canTransferGroundElevation(
                const CAircraftSituation &transferToSituation,
                const physical_quantities::CLength &radius = geo::CElevationPlane::singlePointRadius()) const;

            bool transferGroundElevationFromMe(
                CAircraftSituation &transferToSituation,
                const physical_quantities::CLength &radius = geo::CElevationPlane::singlePointRadius()) const;

            bool transferGroundElevationToMe(const CAircraftSituation &fromSituation,
                                             const physical_quantities::CLength &radius, bool transferred);

            bool transferGroundElevationToMe(const CAircraftSituation &fromSituation, bool transferred);

            bool interpolateElevation(const aviation::CAircraftSituation &oldSituation,
                                      const aviation::CAircraftSituation &newSituation);

            bool hasGroundElevation() const;

            bool hasInboundGroundDetails() const;

            bool setGroundElevation(const aviation::CAltitude &altitude, GndElevationInfo info,
                                    bool transferred = false);

            bool setGroundElevation(const geo::CElevationPlane &elevationPlane, GndElevationInfo info,
                                    bool transferred = false);

            bool setGroundElevationChecked(const geo::CElevationPlane &elevationPlane, GndElevationInfo info,
                                           bool transferred = false);

            void resetGroundElevation();

            physical_quantities::CLength getHeightAboveGround() const;

            const CHeading &getHeading() const { return m_heading; }

            void setHeading(const CHeading &heading);

            const CAltitude &getAltitude() const { return m_position.geodeticHeight(); }

            physical_quantities::CLengthUnit getAltitudeUnit() const { return m_position.geodeticHeight().getUnit(); }

            physical_quantities::CLengthUnit getAltitudeOrDefaultUnit() const;

            CAltitude getCorrectedAltitude(bool enableDragToGround = true,
                                           AltitudeCorrection *correction = nullptr) const;
            CAltitude getCorrectedAltitude(const physical_quantities::CLength &centerOfGravity,
                                           bool enableDragToGround = true,
                                           AltitudeCorrection *correction = nullptr) const;

            AltitudeCorrection correctAltitude(bool enableDragToGround = true);
            AltitudeCorrection
            correctAltitude(const physical_quantities::CLength &centerOfGravity = physical_quantities::CLength::null(),
                            bool enableDragToGround = true);

            void setAltitude(const CAltitude &altitude);

            CAltitude addAltitudeOffset(const physical_quantities::CLength &offset);

            CAircraftSituation withAltitudeOffset(const physical_quantities::CLength &offset) const;

            const CAltitude &getPressureAltitude() const { return m_pressureAltitude; }

            void setPressureAltitude(const CAltitude &altitude);

            const physical_quantities::CAngle &getPitch() const { return m_pitch; }

            void setPitch(const physical_quantities::CAngle &pitch);

            const physical_quantities::CAngle &getBank() const { return m_bank; }

            void setBank(const physical_quantities::CAngle &bank);

            void setZeroPBH();

            void setZeroPBHandGs();

            QString getPBHInfo() const;

            void setVelocity(const CAircraftVelocity &velocity)
            {
                m_velocity = velocity;
                m_hasVelocity = true;
            }

            const CAircraftVelocity &getVelocity() const { return m_velocity; }

            bool hasVelocity() const { return m_hasVelocity; }

            const physical_quantities::CSpeed &getGroundSpeed() const { return m_groundSpeed; }

            void setGroundSpeed(const physical_quantities::CSpeed &groundspeed) { m_groundSpeed = groundspeed; }

            bool isMoving() const;

            bool canLikelySkipNearGroundInterpolation() const;

            physical_quantities::CLength
            getDistancePerTime(std::chrono::milliseconds,
                               const physical_quantities::CLength &min = physical_quantities::CLength::null()) const;

            physical_quantities::CLength getDistancePerTime250ms(
                const physical_quantities::CLength &min = physical_quantities::CLength::null()) const;

            const CCallsign &getCallsign() const { return m_correspondingCallsign; }

            bool hasCallsign() const { return !this->getCallsign().isEmpty(); }

            void setCallsign(const CCallsign &callsign);

            const physical_quantities::CLength &getCG() const { return m_cg; }

            void setCG(const physical_quantities::CLength &cg);

            bool hasCG() const { return !m_cg.isNull(); }

            void setInterimFlag(bool flag) { m_isInterim = flag; }

            bool adjustGroundFlag(const CAircraftParts &parts, bool alwaysSetDetails, double timeDeviationFactor = 0.1,
                                  qint64 *differenceMs = nullptr);

            bool adjustGroundFlag(const CAircraftPartsList &partsList, bool alwaysSetDetails,
                                  double timeDeviationFactor = 0.1, qint64 *differenceMs = nullptr);

            bool isInterim() const { return m_isInterim; }

            static const QString &altitudeCorrectionToString(AltitudeCorrection correction);

            static bool isCorrectedAltitude(AltitudeCorrection correction);

            static const QString &gndElevationInfoToString(GndElevationInfo details);

            static const physical_quantities::CLength &deltaNearGround();

            static const CAircraftSituation &null();

            static const physical_quantities::CLength &defaultCG();


            static bool isGfEqualOnGround(double oldGroundFactor, double newGroundFactor)
            {
                using namespace swift::misc::math;
                return CMathUtils::epsilonEqualLimits(1.0, oldGroundFactor) &&
                       CMathUtils::epsilonEqualLimits(1.0, newGroundFactor);
            }

            static bool isGfEqualAirborne(double oldGroundFactor, double newGroundFactor)
            {
                using namespace swift::misc::math;
                return CMathUtils::epsilonEqualLimits(0.0, oldGroundFactor) &&
                       CMathUtils::epsilonEqualLimits(0.0, newGroundFactor);
            }

            static bool isGfStarting(double oldGroundFactor, double newGroundFactor)
            {
                using namespace swift::misc::math;
                return CMathUtils::epsilonEqualLimits(0.0, oldGroundFactor) &&
                       CMathUtils::epsilonEqualLimits(1.0, newGroundFactor);
            }

            static bool isGfLanding(double oldGroundFactor, double newGroundFactor)
            {
                using namespace swift::misc::math;
                return CMathUtils::epsilonEqualLimits(1.0, oldGroundFactor) &&
                       CMathUtils::epsilonEqualLimits(0.0, newGroundFactor);
            }


            static geo::CElevationPlane
            interpolatedElevation(const CAircraftSituation &situation, const CAircraftSituation &oldSituation,
                                  const CAircraftSituation &newSituation,
                                  const physical_quantities::CLength &distance = physical_quantities::CLength::null());

            static constexpr double MaxDeltaElevationFt = 25.0;

            static const physical_quantities::CLength &allowedAltitudeDeviation();

            CAircraftLights guessLights() const;

            static void registerMetadata();
 
        private:
            CCallsign m_correspondingCallsign;
            geo::CCoordinateGeodetic m_position; 
            geo::CElevationPlane m_groundElevationPlane; 
            aviation::CAltitude m_pressureAltitude { 0, nullptr };
            CHeading m_heading { 0, nullptr };
            physical_quantities::CAngle m_pitch { 0, nullptr };
            physical_quantities::CAngle m_bank { 0, nullptr };
            physical_quantities::CSpeed m_groundSpeed { 0, nullptr };
            physical_quantities::CLength m_cg { 0, nullptr };
            bool m_hasVelocity = false;
            CAircraftVelocity m_velocity;
            bool m_isInterim = false; 
            bool m_isElvInfoTransferred = false; 
            int m_elvInfo = static_cast<int>(CAircraftSituation::NoElevationInfo); 
            aviation::COnGroundInfo m_onGroundInfo;
 
            SWIFT_METACLASS(
                CAircraftSituation,
                SWIFT_METAMEMBER(correspondingCallsign),
                SWIFT_METAMEMBER(position),
                SWIFT_METAMEMBER(pressureAltitude),
                SWIFT_METAMEMBER(heading),
                SWIFT_METAMEMBER(pitch),
                SWIFT_METAMEMBER(bank),
                SWIFT_METAMEMBER(groundSpeed),
                SWIFT_METAMEMBER(cg),
                SWIFT_METAMEMBER(hasVelocity),
                SWIFT_METAMEMBER(velocity),
                SWIFT_METAMEMBER(groundElevationPlane),
                SWIFT_METAMEMBER(onGroundInfo),
                SWIFT_METAMEMBER(elvInfo),
                SWIFT_METAMEMBER(isElvInfoTransferred),
                SWIFT_METAMEMBER(timestampMSecsSinceEpoch),
                SWIFT_METAMEMBER(timeOffsetMs),
                SWIFT_METAMEMBER(isInterim));
        };
    } // namespace aviation
} // namespace swift::misc
 
Q_DECLARE_METATYPE(swift::misc::aviation::CAircraftSituation)
Q_DECLARE_METATYPE(swift::misc::aviation::CAircraftSituation::AltitudeCorrection)
Q_DECLARE_METATYPE(swift::misc::aviation::CAircraftSituation::GndElevationInfo)
 
#endif // SWIFT_MISC_AVIATION_AIRCRAFTSITUATION_H