coordinategeodetic.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_GEO_COORDINATEGEODETIC_H
#define SWIFT_MISC_GEO_COORDINATEGEODETIC_H
 
#include <array>
 
#include <QString>
#include <QVector3D>
 
#include "misc/aviation/altitude.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/units.h"
#include "misc/propertyindexref.h"
#include "misc/swiftmiscexport.h"
#include "misc/valueobject.h"
 
SWIFT_DECLARE_VALUEOBJECT_MIXINS(swift::misc::geo, CCoordinateGeodetic)
 
namespace swift::misc
{
    namespace geo
    {
        class SWIFT_MISC_EXPORT ICoordinateGeodetic
        {
        public:
            enum ColumnIndex
            {
                IndexLatitude = CPropertyIndexRef::GlobalIndexICoordinateGeodetic,
                IndexLongitude,
                IndexLatitudeAsString,
                IndexLongitudeAsString,
                IndexGeodeticHeight,
                IndexGeodeticHeightAsString,
                IndexNormalVector
            };
 
            ICoordinateGeodetic() = default;
 
            virtual ~ICoordinateGeodetic();
 
            ICoordinateGeodetic(const ICoordinateGeodetic &) = default;
 
            ICoordinateGeodetic &operator=(const ICoordinateGeodetic &) = default;
 
            virtual CLatitude latitude() const = 0;
 
            virtual CLongitude longitude() const = 0;
 
            virtual const aviation::CAltitude &geodeticHeight() const = 0;
 
            virtual QVector3D normalVector() const = 0;
 
            virtual std::array<double, 3> normalVectorDouble() const = 0;
 
            bool equalNormalVectorDouble(const std::array<double, 3> &otherVector) const;
 
            bool equalNormalVectorDouble(const ICoordinateGeodetic &otherCoordinate) const;
 
            QString latitudeAsString() const { return this->latitude().toQString(true); }
 
            QString longitudeAsString() const { return this->longitude().toQString(true); }
 
            QString geodeticHeightAsString() const { return this->geodeticHeight().toQString(true); }
 
            bool isGeodeticHeightNull() const { return this->geodeticHeight().isNull(); }
 
            bool hasMSLGeodeticHeight() const { return this->geodeticHeight().hasMeanSeaLevelValue(); }
 
            virtual bool isNull() const { return this->normalVector().isNull(); }
 
            physical_quantities::CLength calculateGreatCircleDistance(const ICoordinateGeodetic &otherCoordinate) const;
 
            bool isWithinRange(const ICoordinateGeodetic &otherCoordinate,
                               const physical_quantities::CLength &range) const;
 
            physical_quantities::CAngle calculateBearing(const ICoordinateGeodetic &otherCoordinate) const;
 
            QVariant propertyByIndex(CPropertyIndexRef index) const;
 
            int comparePropertyByIndex(CPropertyIndexRef index, const ICoordinateGeodetic &compareValue) const;
 
            QString convertToQString(bool i18n = false) const;
 
            bool isNaNVector() const;
            bool isNaNVectorDouble() const;
            bool isInfVector() const;
            bool isInfVectorDouble() const;
            bool isValidVectorRange() const;
            static bool isValidVector(const std::array<double, 3> &v);
 
        protected:
            static bool canHandleIndex(CPropertyIndexRef index);
        };
 
        SWIFT_MISC_EXPORT physical_quantities::CLength
        calculateGreatCircleDistance(const ICoordinateGeodetic &coordinate1, const ICoordinateGeodetic &coordinate2);
 
        SWIFT_MISC_EXPORT physical_quantities::CAngle calculateBearing(const ICoordinateGeodetic &coordinate1,
                                                                       const ICoordinateGeodetic &coordinate2);
 
        SWIFT_MISC_EXPORT double calculateEuclideanDistance(const ICoordinateGeodetic &coordinate1,
                                                            const ICoordinateGeodetic &coordinate2);
 
        SWIFT_MISC_EXPORT double calculateEuclideanDistanceSquared(const ICoordinateGeodetic &coordinate1,
                                                                   const ICoordinateGeodetic &coordinate2);
 
        class SWIFT_MISC_EXPORT ICoordinateWithRelativePosition : public ICoordinateGeodetic
        {
        public:
            enum ColumnIndex
            {
                IndexRelativeDistance = CPropertyIndexRef::GlobalIndexICoordinateWithRelativePosition,
                IndexRelativeBearing
            };
 
            const physical_quantities::CLength &getRelativeDistance() const { return m_relativeDistance; }
 
            void setRelativeDistance(const physical_quantities::CLength &distance) { m_relativeDistance = distance; }
 
            const physical_quantities::CAngle &getRelativeBearing() const { return m_relativeBearing; }
 
            void setRelativeBearing(const physical_quantities::CAngle &angle) { m_relativeBearing = angle; }
 
            bool hasValidRelativeDistance() const { return !m_relativeDistance.isNull(); }
 
            bool hasValidRelativeBearing() const { return !m_relativeBearing.isNull(); }
 
            physical_quantities::CLength calculcateAndUpdateRelativeDistance(const geo::ICoordinateGeodetic &position);
 
            physical_quantities::CLength
            calculcateAndUpdateRelativeDistanceAndBearing(const geo::ICoordinateGeodetic &position);
 
            QVariant propertyByIndex(CPropertyIndexRef index) const;
 
            void setPropertyByIndex(CPropertyIndexRef index, const QVariant &variant);
 
            int comparePropertyByIndex(CPropertyIndexRef index,
                                       const ICoordinateWithRelativePosition &compareValue) const;
 
            QString convertToQString(bool i18n = false) const;
 
        protected:
            ICoordinateWithRelativePosition();
 
            static bool canHandleIndex(CPropertyIndexRef index);
 
            physical_quantities::CAngle m_relativeBearing { 0, nullptr }; 
            physical_quantities::CLength m_relativeDistance { 0, nullptr }; 
        };
 
        class SWIFT_MISC_EXPORT CCoordinateGeodetic :
            public CValueObject<CCoordinateGeodetic>,
            public ICoordinateGeodetic
        {
        public:
            CCoordinateGeodetic() {}
 
            CCoordinateGeodetic(const QVector3D &normal)
                : m_x(static_cast<double>(normal.x())), m_y(static_cast<double>(normal.y())),
                  m_z(static_cast<double>(normal.z()))
            {}
 
            CCoordinateGeodetic(const std::array<double, 3> &normalVector);
 
            CCoordinateGeodetic(const CLatitude &latitude, const CLongitude &longitude);
 
            CCoordinateGeodetic(const CLatitude &latitude, const CLongitude &longitude,
                                const aviation::CAltitude &geodeticHeight);
 
            CCoordinateGeodetic(double latitudeDegrees, double longitudeDegrees);
 
            CCoordinateGeodetic(double latitudeDegrees, double longitudeDegrees, double heightFeet);
 
            CCoordinateGeodetic(const ICoordinateGeodetic &coordinate);
 
            CCoordinateGeodetic calculatePosition(const physical_quantities::CLength &distance,
                                                  const physical_quantities::CAngle &relBearing) const;
 
            virtual CLatitude latitude() const override;
 
            virtual CLongitude longitude() const override;
 
            virtual const aviation::CAltitude &geodeticHeight() const override { return m_geodeticHeight; }
 
            virtual QVector3D normalVector() const override;
 
            virtual std::array<double, 3> normalVectorDouble() const override;
 
            QVariant propertyByIndex(CPropertyIndexRef index) const;
 
            void setPropertyByIndex(CPropertyIndexRef index, const QVariant &variant);
 
            int comparePropertyByIndex(CPropertyIndexRef index, const CCoordinateGeodetic &compareValue) const;
 
            CCoordinateGeodetic &switchUnit(const physical_quantities::CLengthUnit &unit);
 
            void setLatitude(const CLatitude &latitude);
 
            void setLatitudeFromWgs84(const QString &wgs);
 
            void setLongitude(const CLongitude &longitude);
 
            void setLongitudeFromWgs84(const QString &wgs);
 
            void setLatLong(const CLatitude &latitude, const CLongitude &longitude);
 
            void setLatLongFromWgs84(const QString &latitude, const QString &longitude);
 
            void setGeodeticHeight(const aviation::CAltitude &height) { m_geodeticHeight = height; }
 
            void setGeodeticHeightToNull();
 
            void setNormalVector(const QVector3D &normal)
            {
                m_x = static_cast<double>(normal.x());
                m_y = static_cast<double>(normal.y());
                m_z = static_cast<double>(normal.z());
            }
 
            void setNormalVector(double x, double y, double z)
            {
                m_x = x;
                m_y = y;
                m_z = z;
            }
 
            void setNormalVector(const std::array<double, 3> &normalVector);
 
            int clampVector();
 
            void setNull()
            {
                this->setNormalVector(0, 0, 0);
                m_geodeticHeight.setNull();
            }
 
            virtual bool isNull() const override
            {
                if (m_geodeticHeight.isNull()) { return true; }
                return math::CMathUtils::epsilonZeroLimits(m_x) && math::CMathUtils::epsilonZeroLimits(m_y) &&
                       math::CMathUtils::epsilonZeroLimits(m_z);
            }
 
            static CCoordinateGeodetic fromWgs84(const QString &latitudeWgs84, const QString &longitudeWgs84,
                                                 const aviation::CAltitude &geodeticHeight = {});
 
            static const CCoordinateGeodetic &null();
 
            QString convertToQString(bool i18n = false) const;
 
        private:
            // Coordinates are stored using `double` internally and use `double` for most calculations.
            // They use `double` when converting to and from lat/lon representation.
            // `QVector3D` is only used for calculating distance and bearing.
            double m_x = 0; 
            double m_y = 0; 
            double m_z = 0; 
            aviation::CAltitude m_geodeticHeight { 0, nullptr }; 
 
            SWIFT_METACLASS(
                CCoordinateGeodetic,
                SWIFT_METAMEMBER(x),
                SWIFT_METAMEMBER(y),
                SWIFT_METAMEMBER(z),
                SWIFT_METAMEMBER(geodeticHeight));
        };
    } // namespace geo
 
    template <>
    struct TString<geo::ICoordinateGeodetic>
    {
        static QString toQString(const geo::ICoordinateGeodetic &coord) { return coord.convertToQString(); }
    };
} // namespace swift::misc
 
Q_DECLARE_METATYPE(swift::misc::geo::CCoordinateGeodetic)
 
#endif // SWIFT_MISC_GEO_COORDINATEGEODETIC_H