Polygons.hpp

//---- GPL ---------------------------------------------------------------------
//
// Copyright (C)  Stichting Deltares, 2011-2021.
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation version 3.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.
//
// contact: delft3d.support@deltares.nl
// Stichting Deltares
// P.O. Box 177
// 2600 MH Delft, The Netherlands
//
// All indications and logos of, and references to, "Delft3D" and "Deltares"
// are registered trademarks of Stichting Deltares, and remain the property of
// Stichting Deltares. All rights reserved.
//
//------------------------------------------------------------------------------
 
#pragma once
 
#include <vector>
 
#include <MeshKernel/BoundingBox.hpp>
#include <MeshKernel/Exceptions.hpp>
#include <MeshKernel/Polygon.hpp>
#include <MeshKernel/PolygonalEnclosure.hpp>
 
namespace meshkernel
{
 
    class LandBoundary;
 
    class Polygons
    {
    public:
        Polygons() = default;
 
        Polygons(const std::vector<Point>& polygon,
                 Projection projection);
 
        // This is bollocks
        // what about nodes for the interior polygons
        std::tuple<UInt, UInt, UInt> PolygonIndex(UInt startIndex, UInt endIndex) const;
 
        const PolygonalEnclosure& Enclosure(const UInt index) const;
 
        [[nodiscard]] std::vector<std::vector<Point>> ComputePointsInPolygons() const;
 
        [[nodiscard]] std::vector<Point> RefineFirstPolygon(UInt startIndex, UInt endIndex, double refinementDistance) const;
 
        [[nodiscard]] std::vector<Point> RefinePolygon(UInt polygonIndex, UInt startIndex, UInt endIndex, double refinementDistance) const;
 
        [[nodiscard]] std::vector<Point> LinearRefinePolygon(UInt polygonIndex, UInt startIndex, UInt endIndex) const;
 
        [[nodiscard]] Polygons OffsetCopy(double distance, bool innerAndOuter) const;
 
        void SnapToLandBoundary(const LandBoundary& landBoundary, UInt startIndex, UInt endIndex);
 
        [[nodiscard]] bool IsPointInPolygon(Point const& point, UInt polygonIndex) const;
 
        [[nodiscard]] bool IsPointInAnyPolygon(const Point& point) const;
 
        // TODO can reduce the result of this function to only a UInt (valid value => found, invalid => not found)
        [[nodiscard]] std::tuple<bool, UInt> IsPointInPolygons(const Point& point) const;
 
        [[nodiscard]] std::vector<bool> PointsInPolygons(const std::vector<Point>& point) const;
 
        [[nodiscard]] bool IsEmpty() const;
 
        // TODO rename to NumberOfEnclosures or something like that
        [[nodiscard]] UInt GetNumPolygons() const;
 
        [[nodiscard]] UInt GetNumNodes() const;
 
        [[nodiscard]] Projection GetProjection() const { return m_projection; }
 
        [[nodiscard]] std::vector<Point> GatherAllEnclosureNodes() const;
 
        [[nodiscard]] BoundingBox GetBoundingBox(UInt polygonIndex) const;
 
    private:
        double PerimeterClosedPolygon(const std::vector<Point>& polygonNodes) const;
 
        std::vector<double> PolygonEdgeLengths(const std::vector<Point>& polygonNodes) const;
 
        std::vector<PolygonalEnclosure> m_enclosures;                
        Projection m_projection;                                     
        std::vector<std::pair<UInt, UInt>> m_outer_polygons_indices; 
        UInt m_numberOfNodes = 0;                                    
    };
    class Polygons {…};
} // namespace meshkernel
 
inline const meshkernel::PolygonalEnclosure& meshkernel::Polygons::Enclosure(const UInt index) const
{
    if (IsEmpty())
    {
        throw ConstraintError("Enclosures list is empty.");
    }
 
    if (index >= m_enclosures.size())
    {
        throw ConstraintError("Invalid enclosure index: {}, maximum index: {}", index, m_enclosures.size() - 1);
    }
 
    return m_enclosures[index];
}
inline const meshkernel::PolygonalEnclosure& meshkernel::Polygons::Enclosure(const UInt index) const {…}
 
inline meshkernel::UInt meshkernel::Polygons::GetNumPolygons() const
{
    return static_cast<UInt>(m_enclosures.size());
}
inline meshkernel::UInt meshkernel::Polygons::GetNumPolygons() const {…}
 
inline meshkernel::UInt meshkernel::Polygons::GetNumNodes() const
{
    return m_numberOfNodes;
}
inline meshkernel::UInt meshkernel::Polygons::GetNumNodes() const {…}