ConnectMeshes.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 <array>
#include <utility>
#include <vector>
 
#include "MeshKernel/Definitions.hpp"
#include "MeshKernel/Mesh2D.hpp"
#include "MeshKernel/Point.hpp"
#include "MeshKernel/Polygons.hpp"
#include "MeshKernel/Utilities/RTreeBase.hpp"
 
namespace meshkernel
{
 
    // Functionality re-implemented from connectcurvilinearquadsddtype.f90
    class ConnectMeshes final
    {
    public:
        static constexpr double DefaultMaximumSeparationFraction = 0.4;
 
        static constexpr double minimumParallelDeviation = 0.9;
 
        [[nodiscard]] static std::unique_ptr<meshkernel::UndoAction> Compute(Mesh2D& mesh, const double separationFraction = DefaultMaximumSeparationFraction);
 
        [[nodiscard]] static std::unique_ptr<meshkernel::UndoAction> Compute(Mesh2D& mesh, const Polygons& polygon, const double separationFraction = DefaultMaximumSeparationFraction);
 
    private:
        static constexpr double EdgeLengthTolerance = 1.0e-10;
 
        static constexpr UInt m_maximumNumberOfIrregularElementsAlongEdge = 5;
 
        enum class MergeIndicator
        {
            Initial,
            DoMerge,
            DoNotMerge
        };
 
        using BoundedIntegerArray = std::array<UInt, m_maximumNumberOfIrregularElementsAlongEdge>;
 
        using NodesToMerge = std::pair<UInt, UInt>;
 
        struct IrregularEdgeInfo
        {
            BoundedIntegerArray hangingNodes{constants::missing::uintValue,
                                             constants::missing::uintValue,
                                             constants::missing::uintValue,
                                             constants::missing::uintValue,
                                             constants::missing::uintValue};
            UInt edgeCount = 0;
            UInt startNode = constants::missing::uintValue;
            UInt endNode = constants::missing::uintValue;
        };
 
        using IrregularEdgeInfoArray = std::vector<IrregularEdgeInfo>;
 
        static void AreEdgesAdjacent(const Mesh2D& mesh,
                                     const double separationFraction,
                                     const UInt edge1,
                                     const UInt edge2,
                                     bool& areAdjacent,
                                     UInt& startNode,
                                     UInt& endNode,
                                     const std::vector<double>& edgeLengths);
 
        static void GetQuadrilateralElementsOnDomainBoundary(const Mesh2D& mesh,
                                                             const std::vector<Boolean>& nodeInsidePolygon,
                                                             std::vector<UInt>& elementsOnDomainBoundary,
                                                             std::vector<UInt>& edgesOnDomainBoundary,
                                                             std::vector<double>& edgeLengths);
 
        static void GetOrderedDistanceFromPoint(const Mesh2D& mesh,
                                                const std::vector<UInt>& nodeIndices,
                                                const UInt numberOfNodes,
                                                const Point& point,
                                                BoundedIntegerArray& nearestNeighbours);
 
        static std::unique_ptr<meshkernel::UndoAction> MergeNodes(Mesh2D& mesh, const std::vector<NodesToMerge>& nodesToMerge, std::vector<MergeIndicator>& mergeIndicator);
 
        [[nodiscard]] static std::unique_ptr<meshkernel::UndoAction> FreeOneHangingNode(Mesh2D& mesh,
                                                                                        const BoundedIntegerArray& hangingNodes,
                                                                                        const UInt startNode,
                                                                                        const UInt endNode);
 
        [[nodiscard]] static std::unique_ptr<meshkernel::UndoAction> FreeTwoHangingNodes(Mesh2D& mesh,
                                                                                         const UInt faceId,
                                                                                         const UInt edgeId,
                                                                                         const BoundedIntegerArray& hangingNodes,
                                                                                         const UInt startNode,
                                                                                         const UInt endNode);
 
        [[nodiscard]] static std::unique_ptr<meshkernel::UndoAction> FreeThreeHangingNodes(Mesh2D& mesh,
                                                                                           const UInt faceId,
                                                                                           const UInt edgeId,
                                                                                           const BoundedIntegerArray& hangingNodes,
                                                                                           const UInt startNode,
                                                                                           const UInt endNode);
 
        [[nodiscard]] static std::unique_ptr<meshkernel::UndoAction> FreeFourHangingNodes(Mesh2D& mesh,
                                                                                          const UInt faceId,
                                                                                          const UInt edgeId,
                                                                                          const BoundedIntegerArray& hangingNodes,
                                                                                          const UInt startNode,
                                                                                          const UInt endNode);
 
        [[nodiscard]] static std::unique_ptr<meshkernel::UndoAction> FreeHangingNodes(Mesh2D& mesh,
                                                                                      const UInt numberOfHangingNodes,
                                                                                      const std::vector<UInt>& hangingNodesOnEdge,
                                                                                      const UInt faceId,
                                                                                      const Edge& boundaryEdge,
                                                                                      const Point& boundaryNode,
                                                                                      const UInt edgeId);
 
        static void GatherHangingNodeIds(const Mesh2D& mesh,
                                         const double separationFraction,
                                         const std::vector<UInt>& edgesOnDomainBoundary,
                                         const std::vector<double>& edgeLengths,
                                         IrregularEdgeInfoArray& irregularEdges);
 
        static void GatherNodesToMerge(const UInt startNode,
                                       const UInt endNode,
                                       const Edge& boundaryEdge,
                                       std::vector<NodesToMerge>& nodesToMerge,
                                       std::vector<MergeIndicator>& mergeIndicator);
 
        static void GatherHangingNodes(const UInt primaryStartNode,
                                       const UInt primaryEndNode,
                                       const Edge& irregularEdge,
                                       std::vector<UInt>& hangingNodesOnEdge,
                                       UInt& numberOfHangingNodes,
                                       std::vector<MergeIndicator>& mergeIndicator);
    };
    class ConnectMeshes final {…};
 
} // namespace meshkernel