LandBoundaries.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 <memory>
 
#include <MeshKernel/Entities.hpp>
#include <MeshKernel/LandBoundary.hpp>
#include <MeshKernel/UndoActions/UndoAction.hpp>
 
#include <memory>
 
namespace meshkernel
{
    class Polygons;
    class Mesh2D;
 
    class LandBoundaries
    {
 
    public:
        enum class ProjectToLandBoundaryOption
        {
            DoNotProjectToLandBoundary = 0,
            ToOriginalNetBoundary = 1,
            OuterMeshBoundaryToLandBoundary = 2,
            InnerAndOuterMeshBoundaryToLandBoundary = 3,
            WholeMesh = 4
        };
        enum class ProjectToLandBoundaryOption {…};
 
        LandBoundaries() = default;
 
        LandBoundaries(const std::vector<Point>& landBoundary,
                       Mesh2D& mesh,
                       const Polygons& polygons);
 
        void Administrate();
 
        void FindNearestMeshBoundary(ProjectToLandBoundaryOption projectToLandBoundaryOption);
 
        [[nodiscard]] std::unique_ptr<UndoAction> SnapMeshToLandBoundaries() const;
 
        auto GetNumNodes() const { return m_landBoundary.GetNumNodes(); }
 
        std::vector<UInt> m_meshNodesLandBoundarySegments; 
 
    private:
        void AssignLandBoundaryPolylineToMeshNodes(UInt edgeIndex,
                                                   bool initialize,
                                                   const std::vector<UInt>& nodes,
                                                   UInt numNodes);
 
        void AddLandBoundary(const std::vector<UInt>& nodesLoc,
                             UInt numNodesLoc,
                             UInt nodeIndex);
 
        bool MakePath(UInt landBoundaryIndex, UInt& numNodesInPath, UInt& numRejectedNodesInPath);
 
        void ComputeMeshNodeMask(UInt landBoundaryIndex);
 
        void ComputeMask(UInt segmentIndex,
                         bool meshBoundOnly,
                         UInt startLandBoundaryIndex,
                         UInt endLandBoundaryIndex,
                         UInt& leftIndex,
                         UInt& rightIndex,
                         double& leftEdgeRatio,
                         double& rightEdgeRatio);
 
        void MaskMeshFaceMask(UInt landBoundaryIndex, const std::vector<UInt>& initialFaces);
 
        [[nodiscard]] UInt IsMeshEdgeCloseToLandBoundaries(UInt landBoundaryIndex, UInt edge);
 
        std::tuple<UInt, UInt> FindStartEndMeshNodesDijkstraAlgorithm(UInt landBoundaryIndex);
 
        UInt FindStartEndMeshNodesFromEdges(UInt edge, Point point) const;
 
        std::vector<UInt> ShortestPath(UInt landBoundaryIndex, UInt startMeshNode);
 
        std::tuple<double, Point, UInt, double> NearestLandBoundarySegment(UInt landBoundaryIndex, const Point& node) const;
 
        bool InitialiseNodeLocations(const bool initialize,
                                     const UInt edgeIndex,
                                     const std::vector<UInt>& nodes,
                                     const UInt numNodes,
                                     std::vector<UInt>& nodesLoc,
                                     UInt& numNodesLoc) const;
 
        UInt GetSegmentIndex(const UInt nearestLandBoundaryNodeIndex) const;
 
        bool StopPathSearch(const UInt landBoundaryIndex, const UInt currentNode);
 
        bool ContainsCrossedFace(const UInt landBoundaryIndex, const UInt otherFace);
 
        void MaskFacesCloseToBoundary(const UInt landBoundaryIndex);
 
        void GetLandBoundaryNode(const double closeDistance,
                                 const Point& firstMeshNode,
                                 const Point& secondMeshNode,
                                 const UInt currentNode,
                                 UInt& landBoundaryNode,
                                 bool& isWithinSegment) const;
 
        Mesh2D& m_mesh;                                           
        const Polygons m_polygons;                                
        LandBoundary m_landBoundary;                              
        std::vector<Point> m_polygonNodesCache;                   
        std::vector<std::pair<UInt, UInt>> m_validLandBoundaries; 
        std::vector<UInt> m_nodeFaceIndices;                      
 
        std::vector<UInt> m_nodeMask; 
        std::vector<bool> m_faceMask; 
        std::vector<UInt> m_edgeMask; 
 
        bool m_landMask = true;          
        bool m_addLandboundaries = true; 
 
        // caches
        std::vector<double> m_nodesMinDistances; 
 
        // Parameters
        const double m_closeToLandBoundaryFactor = 5.0; 
        const double m_closeWholeMeshFactor = 1.0;      
        const double m_minDistanceFromLandFactor = 2.0; 
 
        // findOnlyOuterMeshBoundary
        bool m_findOnlyOuterMeshBoundary = false; 
    };
    class LandBoundaries {…};
 
} // namespace meshkernel