geoobjectlist.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: Copyright (C) 2015 swift Project Community / Contributors
// SPDX-License-Identifier: GPL-3.0-or-later OR LicenseRef-swift-pilot-client-1
 
 
#ifndef SWIFT_MISC_GEO_GEOOBJECTLIST_H
#define SWIFT_MISC_GEO_GEOOBJECTLIST_H
 
#include <tuple>
 
#include <QList>
 
#include "misc/aviation/altitude.h"
#include "misc/geo/coordinategeodetic.h"
#include "misc/pq/length.h"
#include "misc/sequence.h"
#include "misc/swiftmiscexport.h"
 
namespace swift::misc::geo
{
    template <class OBJ, class CONTAINER>
    class IGeoObjectList
    {
    public:
        using MinMaxAverageHeight = std::tuple<aviation::CAltitude, aviation::CAltitude, aviation::CAltitude, int>;
 
        CONTAINER findWithinRange(const ICoordinateGeodetic &coordinate,
                                  const physical_quantities::CLength &range) const
        {
            return this->container().findBy(
                [&](const OBJ &geoObj) { return calculateGreatCircleDistance(geoObj, coordinate) <= range; });
        }
 
        CONTAINER findOutsideRange(const ICoordinateGeodetic &coordinate,
                                   const physical_quantities::CLength &range) const
        {
            return this->container().findBy(
                [&](const OBJ &geoObj) { return calculateGreatCircleDistance(geoObj, coordinate) > range; });
        }
 
        OBJ findFirstWithinRangeOrDefault(const ICoordinateGeodetic &coordinate,
                                          const physical_quantities::CLength &range) const
        {
            return this->container().findFirstByOrDefault(
                [&](const OBJ &geoObj) { return calculateGreatCircleDistance(geoObj, coordinate) <= range; });
        }
 
        CONTAINER findWithGeodeticMSLHeight() const
        {
            return this->container().findBy(&OBJ::hasMSLGeodeticHeight, true);
        }
 
        bool containsObjectInRange(const ICoordinateGeodetic &coordinate,
                                   const physical_quantities::CLength &range) const
        {
            return this->container().containsBy([&](const OBJ &geoObj) {
                const physical_quantities::CLength d = coordinate.calculateGreatCircleDistance(geoObj);
                return d <= range;
            });
        }
 
        bool containsObjectOutsideRange(const ICoordinateGeodetic &coordinate,
                                        const physical_quantities::CLength &range) const
        {
            return this->container().containsBy([&](const OBJ &geoObj) {
                const physical_quantities::CLength d = coordinate.calculateGreatCircleDistance(geoObj);
                return d > range;
            });
        }
 
        bool containsNullPosition() const
        {
            return this->container().containsBy([&](const ICoordinateGeodetic &geoObj) { return geoObj.isNull(); });
        }
 
        bool containsNullPositionOrHeight() const
        {
            return this->container().containsBy(
                [&](const ICoordinateGeodetic &geoObj) { return geoObj.isNull() || geoObj.isGeodeticHeightNull(); });
        }
 
        MinMaxAverageHeight findMinMaxAverageHeight() const
        {
            MinMaxAverageHeight stats { aviation::CAltitude::null(), aviation::CAltitude::null(),
                                        aviation::CAltitude::null(), 0 };
            if (this->container().isEmpty()) { return stats; } // avoid div by zero
            int count = 0;
            double avgFt = 0;
            for (const OBJ &obj : this->container())
            {
                if (!obj.hasMSLGeodeticHeight()) { continue; }
                const aviation::CAltitude alt = obj.geodeticHeight();
                if (std::get<0>(stats).isNull() || std::get<0>(stats) > alt)
                {
                    std::get<0>(stats) = alt; // min.
                }
                if (std::get<1>(stats).isNull() || std::get<1>(stats) < alt)
                {
                    std::get<1>(stats) = alt; // max.
                }
                avgFt += alt.value(physical_quantities::CLengthUnit::ft()); // add up
                count++;
            }
 
            if (count > 0)
            {
                std::get<2>(stats) = aviation::CAltitude(avgFt / count, aviation::CAltitude::MeanSeaLevel,
                                                         physical_quantities::CLengthUnit::ft());
            }
            std::get<3>(stats) = count;
            return stats;
        }
 
        aviation::CAltitude findMaxHeight() const
        {
            if (this->container().isEmpty()) { return aviation::CAltitude::null(); }
            aviation::CAltitude max = aviation::CAltitude::null();
            for (const OBJ &obj : this->container())
            {
                if (!obj.hasMSLGeodeticHeight()) { continue; }
                const aviation::CAltitude alt = obj.geodeticHeight();
                if (max.isNull() || alt > max) { max = alt; }
            }
            return max;
        }
 
        int removeInsideRange(const ICoordinateGeodetic &coordinate, const physical_quantities::CLength &range)
        {
            const int size = this->container().size();
            const CONTAINER copy = this->container().findOutsideRange(coordinate, range);
            const int d = size - copy.size();
            if (d > 0) { *this = copy; }
            return d;
        }
 
        int removeOutsideRange(const ICoordinateGeodetic &coordinate, const physical_quantities::CLength &range)
        {
            const int size = this->container().size();
            const CONTAINER copy = this->container().findWithinRange(coordinate, range);
            const int d = size - copy.size();
            if (d > 0) { *this = copy; }
            return d;
        }
 
        int removeWithoutGeodeticHeight()
        {
            const int size = this->container().size();
            const CONTAINER copy = this->findWithGeodeticMSLHeight();
            const int d = size - copy.size();
            if (d > 0) { *this = copy; }
            return d;
        }
 
        CONTAINER findClosest(int number, const ICoordinateGeodetic &coordinate) const
        {
            CONTAINER closest = this->container().partiallySorted(number, [&](const OBJ &a, const OBJ &b) {
                return calculateEuclideanDistanceSquared(a, coordinate) <
                       calculateEuclideanDistanceSquared(b, coordinate);
            });
            closest.truncate(number);
            return closest;
        }
 
        CONTAINER findFarthest(int number, const ICoordinateGeodetic &coordinate) const
        {
            CONTAINER farthest = this->container().partiallySorted(number, [&](const OBJ &a, const OBJ &b) {
                return calculateEuclideanDistanceSquared(a, coordinate) >
                       calculateEuclideanDistanceSquared(b, coordinate);
            });
            farthest.truncate(number);
            return farthest;
        }
 
        OBJ findClosestWithinRange(const ICoordinateGeodetic &coordinate,
                                   const physical_quantities::CLength &range) const
        {
            OBJ closest;
            physical_quantities::CLength distance = physical_quantities::CLength::null();
            for (const OBJ &obj : this->container())
            {
                const physical_quantities::CLength d = coordinate.calculateGreatCircleDistance(obj);
                if (d > range) { continue; }
                if (distance.isNull() || distance > d)
                {
                    distance = d;
                    closest = obj;
                }
            }
            return closest;
        }
 
        void sortByEuclideanDistanceSquared(const ICoordinateGeodetic &coordinate)
        {
            this->container().sort([&](const OBJ &a, const OBJ &b) {
                return calculateEuclideanDistanceSquared(a, coordinate) <
                       calculateEuclideanDistanceSquared(b, coordinate);
            });
        }
 
        CONTAINER sortedByEuclideanDistanceSquared(const ICoordinateGeodetic &coordinate) const
        {
            CONTAINER copy(this->container());
            copy.sortByEuclideanDistanceSquared(coordinate);
            return copy;
        }
 
    protected:
        IGeoObjectList() {}
 
        const CONTAINER &container() const { return static_cast<const CONTAINER &>(*this); }
 
        CONTAINER &container() { return static_cast<CONTAINER &>(*this); }
    };
 
    template <class OBJ, class CONTAINER>
    class IGeoObjectWithRelativePositionList : public IGeoObjectList<OBJ, CONTAINER>
    {
    public:
        void sortByRange(const ICoordinateGeodetic &position, bool updateValues)
        {
            if (updateValues) { this->calculcateAndUpdateRelativeDistanceAndBearing(position); }
            this->container().sort(
                [&](const OBJ &a, const OBJ &b) { return a.getRelativeDistance() < b.getRelativeDistance(); });
        }
 
        void sortByDistanceToReferencePosition()
        {
            this->container().sort(
                [&](const OBJ &a, const OBJ &b) { return a.getRelativeDistance() < b.getRelativeDistance(); });
        }
 
        void partiallySortByDistanceToReferencePosition(int number)
        {
            this->container().partiallySort(
                number, [&](const OBJ &a, const OBJ &b) { return a.getRelativeDistance() < b.getRelativeDistance(); });
        }
 
        CONTAINER getClosestObjects(int number) const
        {
            if (number < 1) { return CONTAINER(); }
            if (this->container().size() >= number) { return (this->container()); }
            CONTAINER closest(this->container());
            closest.partiallySortByDistanceToReferencePosition(number);
            Q_ASSERT_X(closest.size() <= number, Q_FUNC_INFO, "size exceeded");
            return closest;
        }
 
        void removeIfOutsideRange(const ICoordinateGeodetic &position, const physical_quantities::CLength &maxDistance,
                                  bool updateValues)
        {
            this->container().removeIf([&](OBJ &geoObj) {
                return updateValues ? geoObj.calculcateAndUpdateRelativeDistanceAndBearing(position) > maxDistance :
                                      geoObj.calculateGreatCircleDistance(position) > maxDistance;
            });
        }
 
        void calculcateAndUpdateRelativeDistanceAndBearing(const ICoordinateGeodetic &position)
        {
            for (OBJ &geoObj : this->container()) { geoObj.calculcateAndUpdateRelativeDistanceAndBearing(position); }
        }
 
    protected:
        IGeoObjectWithRelativePositionList() {}
    };
} // namespace swift::misc::geo
 
#endif // SWIFT_MISC_GEO_GEOOBJECTLIST_H