MeshKernel
Loading...
Searching...
No Matches
Mesh2D.hpp
1//---- GPL ---------------------------------------------------------------------
2//
3// Copyright (C) Stichting Deltares, 2011-2021.
4//
5// This program is free software: you can redistribute it and/or modify
6// it under the terms of the GNU General Public License as published by
7// the Free Software Foundation version 3.
8//
9// This program is distributed in the hope that it will be useful,
10// but WITHOUT ANY WARRANTY; without even the implied warranty of
11// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12// GNU General Public License for more details.
13//
14// You should have received a copy of the GNU General Public License
15// along with this program. If not, see <http://www.gnu.org/licenses/>.
16//
17// contact: delft3d.support@deltares.nl
18// Stichting Deltares
19// P.O. Box 177
20// 2600 MH Delft, The Netherlands
21//
22// All indications and logos of, and references to, "Delft3D" and "Deltares"
23// are registered trademarks of Stichting Deltares, and remain the property of
24// Stichting Deltares. All rights reserved.
25//
26//------------------------------------------------------------------------------
27
28#pragma once
29#include <array>
30#include <ranges>
31#include <utility>
32#include <vector>
33
34#include <MeshKernel/Constants.hpp>
35#include <MeshKernel/Definitions.hpp>
36#include <MeshKernel/Entities.hpp>
37#include <MeshKernel/Mesh.hpp>
38#include <MeshKernel/Polygon.hpp>
39#include <MeshKernel/UndoActions/CompoundUndoAction.hpp>
40#include <MeshKernel/UndoActions/SphericalCoordinatesOffsetAction.hpp>
41#include <MeshKernel/UndoActions/UndoAction.hpp>
42
45namespace meshkernel
46{
47 // Forward declarations
48 class CurvilinearGrid;
49 class Polygons;
50 class GeometryList;
51
57 class Mesh2D final : public Mesh
58 {
59 public:
62
65 {
66 InsideNotIntersected = 0,
67 InsideAndIntersected = 1,
68 FacesWithIncludedCircumcenters = 2
69 };
70
72 ~Mesh2D() override = default;
73
76
79 explicit Mesh2D(Projection projection);
80
85 Mesh2D(const std::vector<Edge>& edges,
86 const std::vector<Point>& nodes,
87 Projection projection);
88
95 Mesh2D(const std::vector<Edge>& edges,
96 const std::vector<Point>& nodes,
97 const std::vector<std::vector<UInt>>& faceNodes,
98 const std::vector<std::uint8_t>& numFaceNodes,
99 Projection projection);
100
105 Mesh2D(const std::vector<Point>& nodes, const Polygons& polygons, Projection projection);
106
108 void Administrate(CompoundUndoAction* undoAction = nullptr) override;
109
111 void ComputeFaceAreaAndMassCenters(bool computeMassCenters = false);
112
114 void FindFaces();
115
119 void FindFacesGivenFaceNodesMapping(const std::vector<std::vector<UInt>>& faceNodes,
120 const std::vector<std::uint8_t>& numFaceNodes);
121
125 [[nodiscard]] std::unique_ptr<SphericalCoordinatesOffsetAction> OffsetSphericalCoordinates(double minx, double maxx);
126
128 void CommitAction(const SphericalCoordinatesOffsetAction& undoAction);
129
133 void RestoreAction(const SphericalCoordinatesOffsetAction& undoAction);
134
141 std::vector<Point>& polygonNodesCache,
142 std::vector<UInt>& localNodeIndicesCache,
143 std::vector<UInt>& globalEdgeIndicesCache) const;
144
147 [[nodiscard]] std::vector<Point> GetObtuseTrianglesCenters();
148
152 [[nodiscard]] std::vector<UInt> GetEdgesCrossingSmallFlowEdges(double smallFlowEdgesThreshold);
153
157 [[nodiscard]] std::vector<Point> GetFlowEdgesCenters(const std::vector<UInt>& edges) const;
158
181 [[nodiscard]] std::unique_ptr<meshkernel::UndoAction> DeleteSmallFlowEdges(double smallFlowEdgesThreshold);
182
200 [[nodiscard]] std::unique_ptr<UndoAction> DeleteSmallTrianglesAtBoundaries(double minFractionalAreaTriangles);
201
203 void ComputeNodeNeighbours(std::vector<std::vector<UInt>>& nodesNodes, UInt& maxNumNeighbours) const;
204
207 void ComputeAspectRatios(std::vector<double>& aspectRatios) const;
208
211
213 MeshNodeType GetNodeType(const UInt nodeId) const { return m_nodesTypes[nodeId]; }
214
216 void GetNodeTypes(std::vector<MeshNodeType>& nodeTypes) const { nodeTypes = m_nodesTypes; }
217
219 [[nodiscard]] std::unique_ptr<UndoAction> DeleteDegeneratedTriangles();
220
222 [[nodiscard]] std::unique_ptr<UndoAction> TriangulateFaces();
223
225 [[nodiscard]] std::unique_ptr<UndoAction> TriangulateFaces(const Polygons& polygon);
226
232 void MakeDualFace(const std::span<const Point> edgeCentres,
233 UInt node,
234 double enlargementFactor,
235 std::vector<Point>& dualFace) const;
236
240 [[nodiscard]] std::vector<UInt> SortedFacesAroundNode(UInt node) const;
241
245 [[nodiscard]] std::vector<Point> ComputeBoundaryPolygons(const std::vector<Point>& polygon);
246
252 void WalkBoundaryFromNode(const Polygon& polygon,
253 std::vector<bool>& isVisited,
254 UInt& currentNode,
255 std::vector<Point>& meshBoundaryPolygon) const;
256
259 [[nodiscard]] std::vector<UInt> GetHangingEdges() const;
260
262 [[nodiscard]] std::unique_ptr<UndoAction> DeleteHangingEdges();
263
267 [[nodiscard]] std::vector<UInt> PointFaceIndices(const std::vector<Point>& points);
268
274 [[nodiscard]] std::unique_ptr<UndoAction> DeleteMesh(const Polygons& polygon, DeleteMeshOptions deletionOption, bool invertDeletion);
275
283 [[nodiscard]] std::vector<bool> FilterBasedOnMetric(Location location, Property property, double minValue, double maxValue) const;
284
289 [[nodiscard]] std::tuple<UInt, UInt> IsSegmentCrossingABoundaryEdge(const Point& firstPoint, const Point& secondPoint) const;
290
296 [[nodiscard]] std::vector<int> MaskEdgesOfFacesInPolygon(const Polygons& polygons, bool invertSelection, bool includeIntersected) const;
297
301 [[nodiscard]] std::vector<int> NodeMaskFromEdgeMask(std::vector<int> const& edgeMask) const;
302
307 [[nodiscard]] std::vector<int> NodeMaskFromPolygon(const Polygons& polygons, bool inside) const;
308
312 UInt FindOppositeEdge(const UInt faceId, const UInt edgeId) const;
313
318 UInt NextFace(const UInt faceId, const UInt edgeId) const;
319
325 static std::unique_ptr<Mesh2D> Merge(const Mesh2D& mesh1, const Mesh2D& mesh2);
326
328 static std::unique_ptr<Mesh2D> Merge(const std::span<const Point>& mesh1Nodes,
329 const std::span<const Edge>& mesh1Edges,
330 const std::span<const Point>& mesh2Nodes,
331 const std::span<const Edge>& mesh2Edges,
332 const Projection projection);
333
337 [[nodiscard]] BoundingBox GetBoundingBox() const;
338
342 [[nodiscard]] std::vector<BoundingBox> GetEdgesBoundingBoxes() const;
343
348 void FindFacesConnectedToNode(UInt nodeIndex, std::vector<UInt>& sharedFaces) const;
349
354 void GetConnectingNodes(UInt nodeIndex, std::vector<UInt>& connectedNodes) const;
355
362 void FindNodesSharedByFaces(UInt nodeIndex, const std::vector<UInt>& sharedFaces, std::vector<UInt>& connectedNodes, std::vector<std::vector<UInt>>& faceNodeMapping) const;
363
368 UInt IsStartOrEnd(const UInt edgeId, const UInt nodeId) const;
369
374 UInt IsLeftOrRight(const UInt elementId, const UInt edgeId) const;
375
379 UInt FindCommonFace(const UInt edge1, const UInt edge2) const;
380
381 private:
382 // orthogonalization
383 static constexpr double m_minimumEdgeLength = 1e-4;
384 static constexpr double m_curvilinearToOrthogonalRatio = 0.5;
385 static constexpr double m_minimumCellArea = 1e-12;
386 static constexpr UInt m_maximumNumberOfHangingNodesAlongEdge = 5;
387
389 using HangingNodeIndexArray = std::array<UInt, m_maximumNumberOfHangingNodesAlongEdge>;
390
392 void ComputeAverageAreOfNeighbouringFaces(const UInt faceId, UInt& numNonBoundaryFaces, double& averageOtherFacesArea) const;
393
395 void FindSmallestCornerAngle(const UInt faceId,
396 double& minCosPhiSmallTriangle,
397 UInt& nodeToPreserve,
398 UInt& firstNodeToMerge,
399 UInt& secondNodeToMerge,
400 UInt& thirdEdgeSmallTriangle) const;
401
403 void DeleteSmallTriangle(const UInt nodeToPreserve,
404 const UInt firstNodeToMerge,
405 const UInt secondNodeToMerge,
406 bool& nodesMerged,
407 CompoundUndoAction& undoAction);
408
410 void FindNodesToDelete(const Polygons& polygon,
411 const bool invertDeletion,
412 std::vector<bool>& isNodeInsidePolygon,
413 std::vector<bool>& deleteNode) const;
414
416 void DeletedMeshNodesAndEdges(const std::function<bool(UInt)>& excludedFace,
417 std::vector<bool>& deleteNode,
418 CompoundUndoAction& deleteMeshAction);
419
421 std::vector<int> ComputeNodeMask(const Polygons& polygons) const;
422
424 std::vector<int> ComputeEdgeMask(const std::vector<int>& nodeMask,
425 bool includeIntersected) const;
426
428 void RemoveIntersected(const std::vector<int>& edgeMask,
429 std::vector<int>& secondEdgeMask) const;
430
432 void InvertSelection(const std::vector<int>& edgeMask,
433 std::vector<int>& secondEdgeMask) const;
434
436 std::vector<bool> FindFacesEntirelyInsidePolygon(const std::vector<bool>& isNodeInsidePolygon) const;
437
442 [[nodiscard]] std::unique_ptr<UndoAction> DeleteMeshFaces(const Polygons& polygon, bool invertDeletion);
443
454 void FindFacesRecursive(UInt startNode,
455 UInt node,
456 UInt previousEdge,
457 UInt numClosingEdges,
458 std::vector<UInt>& edges,
459 std::vector<UInt>& nodes,
460 std::vector<UInt>& sortedEdges,
461 std::vector<UInt>& sortedNodes,
462 std::vector<Point>& nodalValues);
463
468 [[nodiscard]] bool HasTriangleNoAcuteAngles(const std::vector<UInt>& faceNodes, const std::vector<Point>& nodes) const;
469
473 bool HasDuplicateNodes(const UInt numClosingEdges, const std::vector<UInt>& node, std::vector<UInt>& sortedNodes) const;
474
478 bool HasDuplicateEdgeFaces(const UInt numClosingEdges, const std::vector<UInt>& edges, std::vector<UInt>& sortedEdgesFaces) const;
479
481 void ResizeAndInitializeFaceVectors();
482
486 void DoAdministrationGivenFaceNodesMapping(const std::vector<std::vector<UInt>>& faceNodes,
487 const std::vector<std::uint8_t>& numFaceNodes);
488
491 void DoAdministration(CompoundUndoAction* undoAction = nullptr);
492
494 void InitialiseBoundaryNodeClassification(std::vector<int>& intNodeType) const;
495
497 MeshNodeType ClassifyNode(const UInt nodeId) const;
498
500 void ComputeAverageFlowEdgesLength(std::vector<double>& edgesLength,
501 std::vector<double>& averageFlowEdgesLength) const;
502
504 void ComputeAverageEdgeLength(const std::vector<double>& edgesLength,
505 const std::vector<double>& averageFlowEdgesLength,
506 std::vector<bool>& curvilinearGridIndicator,
507 std::vector<std::array<double, 2>>& averageEdgesLength,
508 std::vector<double>& aspectRatios) const;
509
512 UInt InvalidateEdgesWithNoFace();
513
514 std::vector<MeshNodeType> m_nodesTypes;
515 };
516
517} // namespace meshkernel
A class defining a bounding box.
Definition BoundingBox.hpp:40
A class derived from Mesh, which describes unstructures 2d meshes.
Definition Mesh2D.hpp:58
Mesh2D()
Default constructor.
Mesh2D(const std::vector< Edge > &edges, const std::vector< Point > &nodes, const std::vector< std::vector< UInt > > &faceNodes, const std::vector< std::uint8_t > &numFaceNodes, Projection projection)
Construct a mesh2d from face nodes and num face nodes.
~Mesh2D() override=default
Default destructor.
std::vector< int > NodeMaskFromEdgeMask(std::vector< int > const &edgeMask) const
From the edge mask compute the node mask.
static std::unique_ptr< Mesh2D > Merge(const std::span< const Point > &mesh1Nodes, const std::span< const Edge > &mesh1Edges, const std::span< const Point > &mesh2Nodes, const std::span< const Edge > &mesh2Edges, const Projection projection)
Merges mesh node and edge connectivity into a single mesh.
std::unique_ptr< meshkernel::UndoAction > DeleteSmallFlowEdges(double smallFlowEdgesThreshold)
Deletes small flow edges (removesmallflowlinks, part 1)
void ComputeFaceClosedPolygonWithLocalMappings(UInt faceIndex, std::vector< Point > &polygonNodesCache, std::vector< UInt > &localNodeIndicesCache, std::vector< UInt > &globalEdgeIndicesCache) const
For a face create a closed polygon and fill local mapping caches (get_cellpolygon)
UInt NextFace(const UInt faceId, const UInt edgeId) const
Get the next face adjacent to the edge on the opposite side.
MeshNodeType GetNodeType(const UInt nodeId) const
Get the node type.
Definition Mesh2D.hpp:213
DeleteMeshOptions
Enumerator describing the different options to delete a mesh.
Definition Mesh2D.hpp:65
std::vector< BoundingBox > GetEdgesBoundingBoxes() const
Get the bounding boxes of the mesh edges.
void FindNodesSharedByFaces(UInt nodeIndex, const std::vector< UInt > &sharedFaces, std::vector< UInt > &connectedNodes, std::vector< std::vector< UInt > > &faceNodeMapping) const
Find all unique nodes.
UInt FindOppositeEdge(const UInt faceId, const UInt edgeId) const
Find edge on the opposite side of the element.
std::vector< UInt > SortedFacesAroundNode(UInt node) const
Sorts the faces around a node, sorted in counter clock wise order.
std::vector< UInt > GetHangingEdges() const
Gets the hanging edges.
std::vector< int > MaskEdgesOfFacesInPolygon(const Polygons &polygons, bool invertSelection, bool includeIntersected) const
Masks the edges of all faces entirely included in all polygons.
void MakeDualFace(const std::span< const Point > edgeCentres, UInt node, double enlargementFactor, std::vector< Point > &dualFace) const
Make a dual face around the node, enlarged by a factor.
void FindFaces()
Constructs the face nodes mapping, face mass centers and areas.
void RestoreAction(const SphericalCoordinatesOffsetAction &undoAction)
Undo the coordinate offset action.
void CommitAction(const SphericalCoordinatesOffsetAction &undoAction)
Apply the coordinate offset action.
std::tuple< UInt, UInt > IsSegmentCrossingABoundaryEdge(const Point &firstPoint, const Point &secondPoint) const
Inquire if a segment is crossing a face.
void ComputeAspectRatios(std::vector< double > &aspectRatios) const
Gets the aspect ratios (the ratios edges lengths to flow edges lengths)
UInt FindCommonFace(const UInt edge1, const UInt edge2) const
Find the id of the element that is common to both edges.
std::unique_ptr< UndoAction > DeleteSmallTrianglesAtBoundaries(double minFractionalAreaTriangles)
Deletes small triangles at the boundaries (removesmallflowlinks, part 2)
void Administrate(CompoundUndoAction *undoAction=nullptr) override
Perform complete administration.
std::vector< Point > ComputeBoundaryPolygons(const std::vector< Point > &polygon)
Convert all mesh boundaries to a vector of polygon nodes, including holes (copynetboundstopol)
std::vector< UInt > PointFaceIndices(const std::vector< Point > &points)
For a collection of points, compute the face indices including them.
UInt IsStartOrEnd(const UInt edgeId, const UInt nodeId) const
Determine if the node is at the start or end of the edge.
std::vector< UInt > GetEdgesCrossingSmallFlowEdges(double smallFlowEdgesThreshold)
Gets the edges crossing the small flow edges.
void WalkBoundaryFromNode(const Polygon &polygon, std::vector< bool > &isVisited, UInt &currentNode, std::vector< Point > &meshBoundaryPolygon) const
Constructs a polygon from the meshboundary, by walking through the mesh.
void ComputeFaceAreaAndMassCenters(bool computeMassCenters=false)
Compute face mass center.
std::unique_ptr< UndoAction > DeleteDegeneratedTriangles()
Deletes coinciding triangles.
Mesh2D(const std::vector< Point > &nodes, const Polygons &polygons, Projection projection)
Create triangular grid from nodes (triangulatesamplestonetwork)
std::vector< Point > GetFlowEdgesCenters(const std::vector< UInt > &edges) const
Gets the flow edges centers from the crossing edges.
Mesh2D(Projection projection)
Construct a mesh2d using only the projection.
static std::unique_ptr< Mesh2D > Merge(const Mesh2D &mesh1, const Mesh2D &mesh2)
Merges mesh connectivity.
std::unique_ptr< UndoAction > DeleteMesh(const Polygons &polygon, DeleteMeshOptions deletionOption, bool invertDeletion)
Deletes a mesh in a polygon, using several options (delnet)
void GetConnectingNodes(UInt nodeIndex, std::vector< UInt > &connectedNodes) const
Get indices of all nodes that are connected directly to a give node along connected edges.
Mesh2D(const std::vector< Edge > &edges, const std::vector< Point > &nodes, Projection projection)
Construct a mesh2d starting from the edges and nodes.
std::vector< int > NodeMaskFromPolygon(const Polygons &polygons, bool inside) const
Mask all nodes included in all polygons.
UInt IsLeftOrRight(const UInt elementId, const UInt edgeId) const
Determine if the element lies on the left or right side of the edge.
std::vector< Point > GetObtuseTrianglesCenters()
Gets the mass centers of obtuse triangles.
void ComputeNodeNeighbours(std::vector< std::vector< UInt > > &nodesNodes, UInt &maxNumNeighbours) const
Computes node neighbours.
BoundingBox GetBoundingBox() const
Get the mesh bounding box.
std::unique_ptr< UndoAction > TriangulateFaces(const Polygons &polygon)
Transform non-triangular faces inside a polygon to triangular faces.
void ClassifyNodes()
Classifies the nodes (makenetnodescoding)
std::vector< bool > FilterBasedOnMetric(Location location, Property property, double minValue, double maxValue) const
This method generates a mask indicating which locations are within the specified range of the given m...
void FindFacesConnectedToNode(UInt nodeIndex, std::vector< UInt > &sharedFaces) const
Find all faces that have the given node as a vertex.
void GetNodeTypes(std::vector< MeshNodeType > &nodeTypes) const
Get the node type.
Definition Mesh2D.hpp:216
std::unique_ptr< SphericalCoordinatesOffsetAction > OffsetSphericalCoordinates(double minx, double maxx)
Offset the x coordinates if m_projection is spherical.
std::unique_ptr< UndoAction > DeleteHangingEdges()
Deletes the hanging edges.
void FindFacesGivenFaceNodesMapping(const std::vector< std::vector< UInt > > &faceNodes, const std::vector< std::uint8_t > &numFaceNodes)
Find remaining face information given the face nodes mapping.
std::unique_ptr< UndoAction > TriangulateFaces()
Transform non-triangular faces to triangular faces.
A class describing an unstructured mesh. This class contains the shared functionality between 1d or 2...
Definition Mesh.hpp:99
void RestoreAction(const ResetNodeAction &undoAction)
Undo the reset node action.
void CommitAction(const ResetNodeAction &undoAction)
Apply the reset node action.
A struct describing a point in a two-dimensional space.
Definition Point.hpp:41
A closed polygon.
Definition Polygon.hpp:46
A class containing a list of polygonaly enclosed regions.
Definition Polygons.hpp:45
Contains the logic of the C++ static library.
Definition AveragingInterpolation.hpp:37
Projection
Enumerator describing the supported projections.
Definition Definitions.hpp:43
MeshNodeType
Possible unstructured node types.
Definition Definitions.hpp:148
Location
Mesh locations enumeration.
Definition Definitions.hpp:76
Property
Enumerator for different properties on a 2D mesh.
Definition Definitions.hpp:158
std::uint32_t UInt
Integer type used when indexing mesh graph entities.
Definition Definitions.hpp:39