CasulliDeRefinement.hpp

//---- GPL ---------------------------------------------------------------------
//
// Copyright (C)  Stichting Deltares, 2011-2024.
//
// 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 <vector>
 
#include "MeshKernel/Mesh2D.hpp"
#include "MeshKernel/Polygons.hpp"
#include "MeshKernel/UndoActions/UndoAction.hpp"
 
namespace meshkernel
{
    class CasulliDeRefinement
    {
    public:
        [[nodiscard]] static std::unique_ptr<UndoAction> Compute(Mesh2D& mesh);
 
        [[nodiscard]] static std::unique_ptr<UndoAction> Compute(Mesh2D& mesh, const Polygons& polygon);
 
        static std::vector<Point> ElementsToDelete(const Mesh2D& mesh, const Polygons& polygon);
 
    private:
        static constexpr UInt maxIterationCount = 1000;
 
        static constexpr UInt maximumSize = 1000;
 
        enum class ElementType
        {
            WasNodeFirst = 1,  //< front, 'A' face (used to be node, delete it):  1
            WasEdgeFirst = 2,  //< front, 'B' face (used to be edge, keep it):    2
            WasFace = 3,       //< 'C' face (used to be face, keep it):           3
            WasNodeAfter = -1, //< not in front, 'A' face:                       -1
            WasEdgeAfter = -2, //< not in front, 'B' face:                       -2
            Unassigned = 0     //< not assigned a value                           0
        };
 
        enum class ResultIndicator
        {
            ReturnFromFunction, //< Return (false) from the current function
            BreakInnerLoop,     //< Break the inner loop
            ContinueInnerLoop   //< Continue in the inner loop
        };
 
        static bool ElementIsSeed(const Mesh2D& mesh,
                                  const std::vector<int>& nodeTypes,
                                  const UInt element);
 
        static UInt FindElementSeedIndex(const Mesh2D& mesh,
                                         const std::vector<int>& nodeTypes);
 
        static void FindDirectlyConnectedFaces(const Mesh2D& mesh,
                                               const UInt elementId,
                                               std::vector<UInt>& connected);
 
        static void FindIndirectlyConnectedFaces(const Mesh2D& mesh,
                                                 const UInt elementId,
                                                 const std::vector<UInt>& directlyConnected,
                                                 std::vector<UInt>& indirectlyConnected);
 
        static void AssignDirectlyConnected(const std::vector<UInt>& directlyConnected,
                                            std::array<int, 2>& edgeFaces,
                                            UInt& neighbouringElementId);
 
        static void AssignIndirectlyConnected(const std::vector<UInt>& indirectlyConnected,
                                              std::array<int, 2>& edgeFaces,
                                              const UInt neighbouringElementId);
 
        static void FindAdjacentFaces(const Mesh2D& mesh,
                                      const std::vector<UInt>& directlyConnected,
                                      const std::vector<UInt>& indirectlyConnected,
                                      std::vector<std::array<int, 2>>& edgeFaces);
 
        static void FindSurroundingFaces(const Mesh2D& mesh,
                                         const UInt elementId,
                                         std::vector<UInt>& directlyConnected,
                                         std::vector<UInt>& indirectlyConnected,
                                         std::vector<std::array<int, 2>>& edgeFaces);
 
        static void UpdateFaceMaskDirectlyConnectedNodeFirst(const std::vector<UInt>& directlyConnected,
                                                             const Mesh2D& mesh,
                                                             const std::vector<UInt>& frontIndex,
                                                             std::vector<UInt>& frontIndexCopy,
                                                             std::vector<ElementType>& faceMask);
 
        static void UpdateFaceMaskIndirectlyConnectedNodeFirst(const std::vector<UInt>& directlyConnected,
                                                               const Mesh2D& mesh,
                                                               std::vector<ElementType>& faceMask);
 
        static void UpdateFaceMaskDirectlyConnectedEdgeFirst(const std::vector<UInt>& directlyConnected,
                                                             const Mesh2D& mesh,
                                                             const std::vector<UInt>& frontIndex,
                                                             std::vector<UInt>& frontIndexCopy,
                                                             std::vector<ElementType>& faceMask);
 
        static void UpdateFaceMaskIndirectlyConnectedEdgeFirst(const std::vector<UInt>& indirectlyConnected,
                                                               const Mesh2D& mesh,
                                                               const std::vector<UInt>& frontIndex,
                                                               std::vector<UInt>& frontIndexCopy,
                                                               std::vector<ElementType>& faceMask);
 
        static std::vector<ElementType> InitialiseElementType(const Mesh2D& mesh,
                                                              const std::vector<int>& nodeTypes);
 
        static bool ElementCannotBeDeleted(const Mesh2D& mesh,
                                           const std::vector<int>& nodeTypes,
                                           const Polygons& polygon,
                                           const UInt elementId);
 
        static Point ComputeNewNodeCoordinates(const Mesh2D& mesh,
                                               const std::vector<int>& nodeTypes,
                                               const UInt nodeId);
 
        static UInt GetElementIndex(const std::array<int, 2>& edgeFaces,
                                    const UInt index);
 
        static std::tuple<UInt, UInt> FindCommonEdge(Mesh2D& mesh,
                                                     const UInt leftElementId,
                                                     const UInt rightElementId,
                                                     const UInt connectedElementId);
 
        [[nodiscard]] static bool UpdateDirectlyConnectedElements(Mesh2D& mesh,
                                                                  const UInt elementId,
                                                                  const std::vector<UInt>& directlyConnected,
                                                                  const std::vector<std::array<int, 2>>& edgeFaces);
 
        static bool UpdateDirectlyConnectedTriangleElements(Mesh2D& mesh,
                                                            const UInt index,
                                                            const UInt connectedElementId,
                                                            const std::vector<std::array<int, 2>>& edgeFaces);
 
        static void UpdateDirectlyConnectedNonTriangleElements(Mesh2D& mesh,
                                                               const UInt index,
                                                               const UInt elementId,
                                                               const UInt connectedElementId);
 
        static int GetNodeCode(const Mesh2D& mesh,
                               const std::vector<int>& nodeTypes,
                               const UInt elementId);
 
        static void AddElementToList(const Mesh& mesh,
                                     const std::vector<UInt>& frontList,
                                     std::vector<UInt>& frontListCopy,
                                     const UInt elementId);
 
        static void RedirectNodesOfConnectedElements(Mesh2D& mesh,
                                                     const UInt elementId,
                                                     const UInt nodeId,
                                                     const std::vector<UInt>& indirectlyConnected);
 
        static ResultIndicator RemoveBoundaryNodeAndEdge(Mesh2D& mesh,
                                                         const Polygons& polygon,
                                                         const std::vector<int>& nodeTypes,
                                                         const UInt faceNodeIndex,
                                                         const UInt connectedElementId,
                                                         const UInt edgeId,
                                                         const UInt previousEdgeId,
                                                         const UInt nodeId);
 
        [[nodiscard]] static bool RemoveUnwantedBoundaryNodes(Mesh2D& mesh,
                                                              const std::vector<int>& nodeTypes,
                                                              const Polygons& polygon,
                                                              const std::vector<UInt>& indirectlyConnected);
 
        [[nodiscard]] static bool DeleteElement(Mesh2D& mesh,
                                                std::vector<int>& nodeTypes,
                                                const Polygons& polygon,
                                                const UInt elementId,
                                                const std::vector<UInt>& directlyConnected,
                                                const std::vector<UInt>& indirectlyConnected,
                                                const std::vector<std::array<int, 2>>& edgeFaces);
 
        [[nodiscard]] static bool CleanUpEdge(Mesh2D& mesh, const UInt edgeId);
 
        [[nodiscard]] static bool DoDeRefinement(Mesh2D& mesh, const Polygons& polygon);
 
        static std::vector<int> ComputeNodeTypes(const Mesh2D& mesh, const Polygons& polygon);
    };
    class CasulliDeRefinement {…};
 
} // namespace meshkernel