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,
                       std::unique_ptr<MeshInterpolation> interpolant,
                       const MeshRefinementParameters& meshRefinementParameters);
 
        MeshRefinement(Mesh2D& mesh,
                       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;
 
        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;
 
#if 0
        [[nodiscard]] UInt DeleteIsolatedHangingnodes();
#endif
 
        std::unique_ptr<meshkernel::UndoAction> ConnectHangingNodes();
 
        void SmoothRefinementMasks();
 
        void ComputeIfFaceShouldBeSplit();
 
        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; 
 
        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