PolygonalEnclosure.hpp

//---- GPL ---------------------------------------------------------------------
//
// Copyright (C)  Stichting Deltares, 2011-2023.
//
// 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 <utility>
#include <vector>
 
#include "MeshKernel/BoundingBox.hpp"
#include "MeshKernel/Entities.hpp"
#include "MeshKernel/Point.hpp"
#include "MeshKernel/Polygon.hpp"
 
namespace meshkernel
{
 
    class PolygonalEnclosure
    {
    public:
        enum class Region
        {
            None,     
            Exterior, 
            Interior  
        };
        enum class Region {…};
 
        PolygonalEnclosure(const std::vector<Point>& points,
                           Projection projection);
 
        const Polygon& Outer() const;
 
        UInt NumberOfInner() const;
 
        const Polygon& Inner(size_t i) const;
 
        UInt GetNumberOfNodes() const;
 
        bool Contains(const Point& pnt) const;
 
        Region ContainsRegion(const Point& pnt) const;
 
        UInt NumberOfPoints(const bool includeInterior) const;
 
        void SnapToLandBoundary(size_t startIndex, size_t endIndex, const LandBoundary& landBoundary);
 
        std::vector<Point> Refine(UInt startIndex, UInt endIndex, double refinementDistance) const;
 
        std::vector<Point> LinearRefine(UInt startIndex, UInt endIndex) const;
 
        std::tuple<std::unique_ptr<PolygonalEnclosure>, std::unique_ptr<PolygonalEnclosure>> OffsetCopy(double distance, bool outwardsAndInwards) const;
 
    private:
        using IndexRange = std::pair<UInt, UInt>;
 
        using IndexRangeArray = std::vector<IndexRange>;
 
        static Polygon ConstructPolygon(const std::vector<Point>& points,
                                        size_t start,
                                        size_t end,
                                        Projection projection);
 
        static void CopyPoints(const std::vector<Point>& source,
                               const size_t start,
                               const size_t end,
                               UInt& count,
                               std::vector<Point>& target);
 
        void ConstructOuterPolygon(const std::vector<Point>& points,
                                   size_t start, size_t end,
                                   const IndexRangeArray& innerIndices,
                                   Projection projection);
 
        void ConstructInnerPolygons(const std::vector<Point>& points,
                                    const IndexRangeArray& innerIndices,
                                    Projection projection);
 
        Polygon m_outer;
 
        std::vector<Polygon> m_inner;
    };
    class PolygonalEnclosure {…};
 
} // namespace meshkernel
 
inline const meshkernel::Polygon& meshkernel::PolygonalEnclosure::Outer() const
{
    return m_outer;
}
inline const meshkernel::Polygon& meshkernel::PolygonalEnclosure::Outer() const {…}
 
inline meshkernel::UInt meshkernel::PolygonalEnclosure::NumberOfInner() const
{
    return static_cast<UInt>(m_inner.size());
}
inline meshkernel::UInt meshkernel::PolygonalEnclosure::NumberOfInner() const {…}
 
inline const meshkernel::Polygon& meshkernel::PolygonalEnclosure::Inner(const size_t i) const
{
    return m_inner[i];
}
inline const meshkernel::Polygon& meshkernel::PolygonalEnclosure::Inner(const size_t i) const {…}