MeshRefinement.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 <MeshKernel/AveragingInterpolation.hpp>
#include <MeshKernel/Parameters.hpp>
#include <MeshKernel/Polygons.hpp>
#include <MeshKernel/Utilities/RTreeBase.hpp>
 
namespace meshkernel
{
    // Forward declarations
    class Mesh2D;
 
    class MeshRefinement
    {
        enum class FaceLocation
        {
            Land = 1,
            Water = 2,
            LandWater = 3
        };
 
    public:
        enum class RefinementType
        {
            WaveCourant = 1,
            RefinementLevels = 2,
            RidgeDetection = 3
        };
 
        MeshRefinement(Mesh2D& mesh,
                       const Polygons& polygon,
                       std::unique_ptr<MeshInterpolation> interpolant,
                       const MeshRefinementParameters& meshRefinementParameters);
 
        MeshRefinement(Mesh2D& mesh,
                       const Polygons& polygon,
                       std::unique_ptr<MeshInterpolation> interpolant,
                       const MeshRefinementParameters& meshRefinementParameters,
                       bool useNodalRefinement);
 
        MeshRefinement(Mesh2D& mesh,
                       const Polygons& polygon,
                       const MeshRefinementParameters& meshRefinementParameters);
 
        [[nodiscard]] std::unique_ptr<UndoAction> Compute();
 
    private:
        void FindBrotherEdges();
 
        void ComputeNodeMaskAtPolygonPerimeter();
 
        void ComputeRefinementMasksFromSamples();
 
        void ComputeRefinementMaskFromEdgeSize();
 
        void ComputeRefinementMasksForRefinementLevels(UInt face,
                                                       size_t& numberOfEdgesToRefine,
                                                       std::vector<UInt>& edgeToRefine) const;
 
        bool DetermineRequiredRefinement(const UInt face,
                                         const UInt edge) const;
 
        void ResetNumberOfEdgesToRefineForFace(const UInt face,
                                               const std::vector<UInt>& edgeToRefine,
                                               size_t& numberOfEdgesToRefine) const;
 
        void DetermineEdgesToRefine(const UInt face,
                                    std::vector<UInt>& edgeToRefine,
                                    size_t& numberOfEdgesToRefine) const;
 
        void ComputeRefinementMasksForWaveCourant(UInt face,
                                                  size_t& numberOfEdgesToRefine,
                                                  std::vector<UInt>& edgeToRefine);
 
        void ComputeRefinementMasksForRidgeDetection(UInt face,
                                                     size_t& numberOfEdgesToRefine,
                                                     std::vector<UInt>& edgeToRefine) const;
 
        void ComputeRefinementMasksFromSamples(UInt face);
 
        void ComputeEdgesRefinementMask();
 
        void FindHangingNodes(UInt face);
 
        UInt CountHangingNodes() const;
 
        UInt CountHangingEdges() const;
 
        UInt CountEdgesToRefine(UInt face) const;
 
        void UpdateFaceMask(const int level);
 
#if 0
        [[nodiscard]] UInt DeleteIsolatedHangingnodes();
#endif
 
        void ConnectOneHangingNodeForQuadrilateral(const UInt numNonHangingNodes,
                                                   const std::vector<UInt>& edgeEndNodeCache,
                                                   std::vector<UInt>& hangingNodeCache,
                                                   CompoundUndoAction& hangingNodeAction);
 
        void ConnectTwoHangingNodesForQuadrilateral(const UInt numNonHangingNodes,
                                                    const std::vector<UInt>& edgeEndNodeCache,
                                                    std::vector<UInt>& hangingNodeCache,
                                                    CompoundUndoAction& hangingNodeAction);
 
        void ConnectOneHangingNodeForTriangle(const UInt numNonHangingNodes,
                                              const std::vector<UInt>& edgeEndNodeCache,
                                              std::vector<UInt>& hangingNodeCache,
                                              CompoundUndoAction& hangingNodeAction);
 
        void ConnectTwoHangingNodesForTriangle(const UInt numNonHangingNodes,
                                               std::vector<UInt>& hangingNodeCache,
                                               CompoundUndoAction& hangingNodeAction);
 
        std::unique_ptr<meshkernel::UndoAction> ConnectHangingNodes();
 
        void FindEdgesToSplit(const UInt faceId,
                              const UInt numEdges,
                              std::vector<bool>& splitEdge) const;
 
        void UpdateFaceRefinementMask(std::vector<bool>& splitEdge);
 
        void UpdateEdgeRefinementMask();
 
        void SmoothRefinementMasks();
 
        bool IsSplittingIsRequiredForFace(const UInt faceId) const;
 
        UInt UpdateEdgeMaskForNonHangingEdge(const UInt faceId,
                                             const UInt numFaceNodes,
                                             const UInt iter,
                                             const UInt maxiter);
 
        void ComputeIfFaceShouldBeSplit();
 
        Point ComputeMidPoint(const Point& firstNode, const Point& secondNode) const;
 
        int DetermineNodeMaskValue(const int firstNodeMask, const int secondNodeMask) const;
 
        bool DetermineIfParentIsCrossed(const UInt faceId, const UInt numEdges) const;
 
        bool FindNonHangingNodeEdges(const UInt faceId,
                                     const UInt numEdges,
                                     std::vector<UInt>& notHangingFaceNodes,
                                     std::vector<UInt>& nonHangingEdges,
                                     UInt& numBrotherEdges) const;
 
        void ComputeSplittingNode(const UInt faceId,
                                  std::vector<Point>& facePolygonWithoutHangingNodes,
                                  std::vector<UInt>& localEdgesNumFaces,
                                  Point& splittingNode) const;
 
        void FindFacePolygonWithoutHangingNodes(const UInt faceId,
                                                const std::vector<UInt>& nonHangingEdges,
                                                std::vector<Point>& facePolygonWithoutHangingNodes,
                                                std::vector<UInt>& localEdgesNumFaces) const;
 
        void SplitEdges(const bool isParentCrossed,
                        const std::vector<UInt>& localEdgesNumFaces,
                        const std::vector<UInt>& notHangingFaceNodes,
                        const Point& splittingNode,
                        CompoundUndoAction& refineFacesAction);
 
        std::unique_ptr<meshkernel::UndoAction> RefineFacesBySplittingEdges();
 
        bool IsEdgeToBeRefinedBasedFaceLocationTypeAndCourantCriteria(UInt edge, FaceLocation faceLocationType) const;
 
        bool IsRefineNeededBasedOnCourantCriteria(UInt edge, double depthValues) const;
 
        void ComputeFaceLocationTypes();
 
        void ComputeEdgeBelowMinSizeAfterRefinement();
 
        std::unique_ptr<RTreeBase> m_samplesRTree; 
 
        std::vector<int> m_faceMask;                           
        std::vector<int> m_edgeMask;                           
        std::vector<bool> m_isEdgeBelowMinSizeAfterRefinement; 
        std::vector<int> m_nodeMask;                           
        std::vector<UInt> m_brotherEdges;                      
 
        std::vector<bool> m_isHangingNodeCache;       
        std::vector<bool> m_isHangingEdgeCache;       
        std::vector<Point> m_polygonNodesCache;       
        std::vector<UInt> m_localNodeIndicesCache;    
        std::vector<UInt> m_globalEdgeIndicesCache;   
        std::vector<UInt> m_refineEdgeCache;          
        std::vector<FaceLocation> m_faceLocationType; 
        std::vector<double> m_edgeLengths;            
 
        RefinementType m_refinementType = RefinementType::WaveCourant; 
        bool m_directionalRefinement = false;                          
 
        Mesh2D& m_mesh;                                      
        std::unique_ptr<MeshInterpolation> m_interpolant;    
        Polygons m_polygons;                                 
        MeshRefinementParameters m_meshRefinementParameters; 
        bool m_useNodalRefinement = false;                   
        const double m_mergingDistance = 0.001;              
        bool m_isRefinementBasedOnSamples = false;           
    };
} // namespace meshkernel