Mesh.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/BoundingBox.hpp"
#include "MeshKernel/Definitions.hpp"
#include "MeshKernel/Entities.hpp"
#include "MeshKernel/Exceptions.hpp"
#include "MeshKernel/UndoActions/AddEdgeAction.hpp"
#include "MeshKernel/UndoActions/AddNodeAction.hpp"
#include "MeshKernel/UndoActions/CompoundUndoAction.hpp"
#include "MeshKernel/UndoActions/DeleteEdgeAction.hpp"
#include "MeshKernel/UndoActions/DeleteNodeAction.hpp"
#include "MeshKernel/UndoActions/FullUnstructuredGridUndo.hpp"
#include "MeshKernel/UndoActions/MeshConversionAction.hpp"
#include "MeshKernel/UndoActions/NodeTranslationAction.hpp"
#include "MeshKernel/UndoActions/ResetEdgeAction.hpp"
#include "MeshKernel/UndoActions/ResetNodeAction.hpp"
#include "MeshKernel/UndoActions/UndoAction.hpp"
#include "Utilities/RTreeBase.hpp"
 
namespace meshkernel
{
    class Polygons;
 
    class Mesh
    {
    public:
        enum class Type
        {
            Mesh1D, 
            Mesh2D  
        };
 
        virtual ~Mesh() = default;
 
        Mesh();
 
        Mesh& operator=(const Mesh& mesh) = delete;
 
        Mesh& operator=(Mesh&& mesh) = delete;
 
        Mesh(const Mesh& mesh) = delete;
 
        Mesh(Mesh&& mesh) = delete;
 
        explicit Mesh(Projection projection);
 
        Mesh(const std::vector<Edge>& edges,
             const std::vector<Point>& nodes,
             Projection projection);
 
        [[nodiscard]] bool IsNodeOnBoundary(UInt node) const { return m_nodesNumEdges[node] == 1; }
 
        [[nodiscard]] auto GetNumNodes() const { return static_cast<UInt>(m_nodes.size()); }
 
        [[nodiscard]] auto GetNumEdges() const { return static_cast<UInt>(m_edges.size()); }
 
        [[nodiscard]] auto GetNumFaces() const { return static_cast<UInt>(m_facesNodes.size()); }
 
        [[nodiscard]] UInt GetNumValidNodes() const;
 
        [[nodiscard]] UInt GetNumValidEdges() const;
 
        [[nodiscard]] auto GetNumFaceEdges(UInt faceIndex) const { return m_numFacesNodes[faceIndex]; }
 
        [[nodiscard]] auto GetNumEdgesFaces(UInt edgeIndex) const { return m_edgesNumFaces[edgeIndex]; }
 
        // TODO add unit test and with all failing cases
        [[nodiscard]] UInt GetEdgeIndex(const UInt elementId, const UInt edgeId) const;
 
        // TODO add unit test and with all failing cases
        [[nodiscard]] UInt GetNodeIndex(const UInt elementId, const UInt nodeId) const;
 
        [[nodiscard]] bool IsEdgeOnBoundary(UInt edge) const { return m_edgesNumFaces[edge] == 1; }
 
        [[nodiscard]] bool IsFaceOnBoundary(UInt face) const;
 
        // TODO Can this be removed?
        const std::vector<Point>& Nodes() const;
 
        const Point& Node(const UInt index) const;
 
        void SetNodes(const std::vector<Point>& newValues);
 
        void SetNode(const UInt index, const Point& newValue);
 
        [[nodiscard]] std::unique_ptr<ResetNodeAction> ResetNode(const UInt index, const Point& newValue);
 
        // TODO get rid of this function
        const std::vector<Edge>& Edges() const;
 
        const Edge& GetEdge(const UInt index) const;
 
        void SetEdges(const std::vector<Edge>& newValues);
 
        void SetEdge(const UInt index, const Edge& edge);
 
        [[nodiscard]] std::unique_ptr<ResetEdgeAction> ResetEdge(UInt edgeId, const Edge& edge);
 
        UInt GetLocalFaceNodeIndex(const UInt faceIndex, const UInt nodeIndex) const;
 
        [[nodiscard]] std::unique_ptr<UndoAction> MergeTwoNodes(UInt startNode, UInt endNode);
 
        [[nodiscard]] std::unique_ptr<UndoAction> MergeNodesInPolygon(const Polygons& polygons, double mergingDistance);
 
        [[nodiscard]] std::tuple<UInt, std::unique_ptr<AddNodeAction>> InsertNode(const Point& newPoint);
 
        [[nodiscard]] std::tuple<UInt, std::unique_ptr<AddEdgeAction>> ConnectNodes(UInt startNode, UInt endNode);
 
        [[nodiscard]] std::unique_ptr<DeleteNodeAction> DeleteNode(UInt node);
 
        [[nodiscard]] UInt FindEdge(UInt firstNodeIndex, UInt secondNodeIndex) const;
 
        [[nodiscard]] UInt FindEdgeWithLinearSearch(UInt firstNodeIndex, UInt secondNodeIndex) const;
 
        [[nodiscard]] std::unique_ptr<UndoAction> MoveNode(Point newPoint, UInt nodeindex);
 
        [[nodiscard]] UInt FindLocationIndex(Point point,
                                             Location location,
                                             const std::vector<bool>& locationMask = {},
                                             const BoundingBox& boundingBox = {});
 
        [[nodiscard]] UInt FindNodeCloseToAPoint(Point const& point, double searchRadius);
 
        [[nodiscard]] std::unique_ptr<DeleteEdgeAction> DeleteEdge(UInt edge);
 
        [[nodiscard]] UInt FindCommonNode(UInt firstEdgeIndex, UInt secondEdgeIndex) const;
 
        void ComputeEdgesLengths();
 
        [[nodiscard]] double ComputeMinEdgeLength(const Polygons& polygon) const;
 
        void ComputeEdgesCenters();
 
        bool NodeAdministration();
 
        void DeleteInvalidNodesAndEdges();
 
        virtual void Administrate(CompoundUndoAction* undoAction = nullptr);
 
        void AdministrateNodesEdges(CompoundUndoAction* undoAction = nullptr);
 
        void SortEdgesInCounterClockWiseOrder(UInt startNode, UInt endNode);
 
        double ComputeMaxLengthSurroundingEdges(UInt node);
 
        void BuildTree(Location location, const BoundingBox& boundingBox = {});
 
        [[nodiscard]] std::vector<Point> ComputeLocations(Location location) const;
 
        [[nodiscard]] std::vector<bool> IsLocationInPolygon(const Polygons& polygon, Location location) const;
 
        Mesh& operator+=(Mesh const& rhs);
 
        std::unique_ptr<UndoAction> Join(const Mesh& rhs);
 
        std::vector<UInt> GetValidNodeMapping() const;
 
        std::vector<UInt> GetValidEdgeMapping() const;
 
        bool IsValidEdge(const UInt edgeId) const;
 
        void CommitAction(const ResetNodeAction& undoAction);
 
        void CommitAction(const AddNodeAction& undoAction);
 
        void CommitAction(const AddEdgeAction& undoAction);
 
        void CommitAction(const ResetEdgeAction& undoAction);
 
        void CommitAction(const DeleteNodeAction& undoAction);
 
        void CommitAction(NodeTranslationAction& undoAction);
 
        void CommitAction(MeshConversionAction& undoAction);
 
        void CommitAction(const DeleteEdgeAction& undoAction);
 
        void CommitAction(FullUnstructuredGridUndo& undoAction);
 
        void RestoreAction(const ResetNodeAction& undoAction);
 
        void RestoreAction(const AddNodeAction& undoAction);
 
        void RestoreAction(const AddEdgeAction& undoAction);
 
        void RestoreAction(const ResetEdgeAction& undoAction);
 
        void RestoreAction(const DeleteNodeAction& undoAction);
 
        void RestoreAction(NodeTranslationAction& undoAction);
 
        void RestoreAction(MeshConversionAction& undoAction);
 
        void RestoreAction(const DeleteEdgeAction& undoAction);
 
        void RestoreAction(FullUnstructuredGridUndo& undoAction);
 
        RTreeBase& GetRTree(Location location) const { return *m_RTrees.at(location); }
 
        void SetNodesRTreeRequiresUpdate(bool value) { m_nodesRTreeRequiresUpdate = value; }
 
        void SetEdgesRTreeRequiresUpdate(bool value) { m_edgesRTreeRequiresUpdate = value; }
 
        void SetFacesRTreeRequiresUpdate(bool value) { m_facesRTreeRequiresUpdate = value; }
 
        // nodes
        std::vector<std::vector<UInt>> m_nodesEdges; 
        std::vector<UInt> m_nodesNumEdges;           
        std::vector<std::vector<UInt>> m_nodesNodes; 
        std::vector<int> m_nodesTypes;               
 
        // edges
        std::vector<std::array<UInt, 2>> m_edgesFaces; 
        std::vector<UInt> m_edgesNumFaces;             
        std::vector<double> m_edgeLengths;             
        std::vector<Point> m_edgesCenters;             
 
        // faces
        std::vector<std::vector<UInt>> m_facesNodes; 
        std::vector<UInt> m_numFacesNodes;           
        std::vector<std::vector<UInt>> m_facesEdges; 
        std::vector<Point> m_facesCircumcenters;     
        std::vector<Point> m_facesMassCenters;       
        std::vector<double> m_faceArea;              
 
        Projection m_projection; 
 
        // constants
        static constexpr UInt m_maximumNumberOfEdgesPerNode = 16;                                  
        static constexpr UInt m_maximumNumberOfEdgesPerFace = 6;                                   
        static constexpr UInt m_maximumNumberOfNodesPerFace = 6;                                   
        static constexpr UInt m_maximumNumberOfConnectedNodes = m_maximumNumberOfEdgesPerNode * 4; 
 
    protected:
        bool AdministrationRequired() const;
 
        void SetAdministrationRequired(const bool value);
 
        // Make private
        std::vector<Point> m_nodes; 
        std::vector<Edge> m_edges;  
 
    private:
        static double constexpr m_minimumDeltaCoordinate = 1e-14; 
 
        // RTrees
        bool m_nodesRTreeRequiresUpdate = true;                            
        bool m_edgesRTreeRequiresUpdate = true;                            
        bool m_facesRTreeRequiresUpdate = true;                            
        bool m_administrationRequired = true;                              
        std::unordered_map<Location, std::unique_ptr<RTreeBase>> m_RTrees; 
        BoundingBox m_boundingBoxCache;                                    
 
        void SetUnConnectedNodesAndEdgesToInvalid(CompoundUndoAction* undoAction);
 
        void FindConnectedNodes(std::vector<bool>& connectedNodes,
                                UInt& numInvalidEdges) const;
 
        void InvalidateUnConnectedNodes(const std::vector<bool>& connectedNodes,
                                        UInt& numInvalidNodes,
                                        CompoundUndoAction* undoAction = nullptr);
    };
} // namespace meshkernel
 
inline const std::vector<meshkernel::Point>& meshkernel::Mesh::Nodes() const
{
    return m_nodes;
}
 
inline const meshkernel::Point& meshkernel::Mesh::Node(const UInt index) const
{
    if (index >= GetNumNodes())
    {
        throw ConstraintError("The node index, {}, is not in range.", index);
    }
 
    return m_nodes[index];
}
 
inline void meshkernel::Mesh::SetNodes(const std::vector<Point>& newValues)
{
    m_nodes = newValues;
    m_nodesRTreeRequiresUpdate = true;
    m_edgesRTreeRequiresUpdate = true;
    m_facesRTreeRequiresUpdate = true;
    m_administrationRequired = true;
}
 
inline const meshkernel::Edge& meshkernel::Mesh::GetEdge(const UInt index) const
{
    if (index >= GetNumEdges())
    {
        throw ConstraintError("The edge index, {}, is not in range.", index);
    }
 
    return m_edges[index];
}
 
inline void meshkernel::Mesh::SetEdge(const UInt index, const Edge& edge)
{
    if (index >= GetNumEdges())
    {
        throw ConstraintError("The edge index, {}, is not in range.", index);
    }
 
    m_administrationRequired = true;
    m_edges[index] = edge;
}
 
inline const std::vector<meshkernel::Edge>& meshkernel::Mesh::Edges() const
{
    return m_edges;
}
 
inline void meshkernel::Mesh::SetEdges(const std::vector<Edge>& newValues)
{
    m_edges = newValues;
    m_nodesRTreeRequiresUpdate = true;
    m_edgesRTreeRequiresUpdate = true;
    m_facesRTreeRequiresUpdate = true;
    m_administrationRequired = true;
}
 
inline bool meshkernel::Mesh::AdministrationRequired() const
{
    return m_administrationRequired;
}