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