Loading [MathJax]/extensions/MathZoom.js
OGS
VoxelGridFromLayeredMeshes.cpp File Reference

Detailed Description

Definition in file VoxelGridFromLayeredMeshes.cpp.

Include dependency graph for VoxelGridFromLayeredMeshes.cpp:

Go to the source code of this file.

Functions

void adjustExtent (std::pair< MathLib::Point3d, MathLib::Point3d > &extent, MeshLib::Mesh const &mesh)
 
std::unique_ptr< MeshLib::MeshgenerateInitialMesh (std::pair< MathLib::Point3d, MathLib::Point3d > &extent, std::array< double, 3 > const &res)
 
MeshLib::Element const * getProjectedElement (MeshLib::MeshElementGrid const &grid, MathLib::Point3d const &node, double const max_edge)
 
void voteMatId (MathLib::Point3d const &node, MeshLib::MeshElementGrid const &grid, double const max_edge, std::size_t &nullptr_cnt, std::size_t &upper_layer_cnt, std::size_t &lower_layer_cnt)
 
void setMaterialIDs (MeshLib::Mesh &mesh, std::vector< MeshLib::Mesh const * > const &layers, bool const dilate)
 
std::vector< std::size_t > markSpecificElements (MeshLib::Mesh const &mesh, int const mat_id)
 

Variables

static std::string mat_name = "MaterialIDs"
 

Function Documentation

◆ adjustExtent()

void adjustExtent ( std::pair< MathLib::Point3d, MathLib::Point3d > & extent,
MeshLib::Mesh const & mesh )

Definition at line 23 of file VoxelGridFromLayeredMeshes.cpp.

25{
26 auto const& nodes = mesh.getNodes();
27 GeoLib::AABB aabb(nodes.cbegin(), nodes.cend());
28 for (std::size_t i = 0; i < 3; ++i)
29 {
30 extent.first[i] = std::min(extent.first[i], aabb.getMinPoint()[i]);
31 extent.second[i] = std::max(extent.second[i], aabb.getMaxPoint()[i]);
32 }
33}
Class AABB is an axis aligned bounding box around a given set of geometric points of (template) type ...
Definition AABB.h:56

References GeoLib::AABB::getMaxPoint(), GeoLib::AABB::getMinPoint(), and MeshLib::Mesh::getNodes().

Referenced by MeshToolsLib::MeshGenerators::VoxelFromLayeredMeshes::createVoxelFromLayeredMesh().

◆ generateInitialMesh()

std::unique_ptr< MeshLib::Mesh > generateInitialMesh ( std::pair< MathLib::Point3d, MathLib::Point3d > & extent,
std::array< double, 3 > const & res )

Definition at line 36 of file VoxelGridFromLayeredMeshes.cpp.

39{
40 INFO("Creating initial mesh...");
41 std::array<double, 3> mesh_range{{extent.second[0] - extent.first[0],
42 extent.second[1] - extent.first[1],
43 extent.second[2] - extent.first[2]}};
44 std::array<std::size_t, 3> const n_cells{
45 {static_cast<std::size_t>(std::ceil(mesh_range[0] / res[0])),
46 static_cast<std::size_t>(std::ceil(mesh_range[1] / res[1])),
47 static_cast<std::size_t>(std::ceil(mesh_range[2] / res[2]))}};
48 for (std::size_t i = 0; i < 3; ++i)
49 {
50 double const ext_range = n_cells[i] * res[i];
51 double const offset = (ext_range - mesh_range[i]) / 2.0;
52 mesh_range[i] = ext_range;
53 extent.first[i] -= offset;
54 extent.second[i] += offset;
55 }
56 std::unique_ptr<MeshLib::Mesh> mesh(
58 mesh_range[0], mesh_range[1], mesh_range[2], n_cells[0], n_cells[1],
59 n_cells[2], extent.first));
60 auto mat_id = mesh->getProperties().createNewPropertyVector<int>(
61 mat_name, MeshLib::MeshItemType::Cell, mesh->getNumberOfElements(), 1);
62 if (!mat_id)
63 {
64 return nullptr;
65 }
66 ranges::fill(*mat_id, -1);
67 return mesh;
68}
void INFO(fmt::format_string< Args... > fmt, Args &&... args)
Definition Logging.h:35
static std::string mat_name
MeshLib::Mesh * generateRegularHexMesh(const BaseLib::ISubdivision &div_x, const BaseLib::ISubdivision &div_y, const BaseLib::ISubdivision &div_z, MathLib::Point3d const &origin=MathLib::ORIGIN, std::string const &mesh_name="mesh")

References MeshLib::Cell, MeshToolsLib::MeshGenerator::generateRegularHexMesh(), INFO(), and mat_name.

Referenced by MeshToolsLib::MeshGenerators::VoxelFromLayeredMeshes::createVoxelFromLayeredMesh().

◆ getProjectedElement()

MeshLib::Element const * getProjectedElement ( MeshLib::MeshElementGrid const & grid,
MathLib::Point3d const & node,
double const max_edge )

Definition at line 71 of file VoxelGridFromLayeredMeshes.cpp.

75{
76 constexpr double max_val = std::numeric_limits<double>::max();
77 MathLib::Point3d const min_vol{
78 {node[0] - max_edge, node[1] - max_edge, -max_val}};
79 MathLib::Point3d const max_vol{
80 {node[0] + max_edge, node[1] + max_edge, max_val}};
81 auto const& intersection_candidates =
82 grid.getElementsInVolume(min_vol, max_vol);
84 intersection_candidates, node);
85}
MeshLib::Element const * getProjectedElement(std::vector< const MeshLib::Element * > const &elements, MathLib::Point3d const &node)

References MeshLib::MeshElementGrid::getElementsInVolume(), and MeshToolsLib::ProjectPointOnMesh::getProjectedElement().

Referenced by voteMatId().

◆ markSpecificElements()

std::vector< std::size_t > markSpecificElements ( MeshLib::Mesh const & mesh,
int const mat_id )

Definition at line 191 of file VoxelGridFromLayeredMeshes.cpp.

193{
194 std::vector<std::size_t> marked_elems;
195 auto const mat_ids = *MeshLib::materialIDs(mesh);
196 std::size_t const n_elems = mat_ids.size();
197 for (std::size_t i = 0; i < n_elems; ++i)
198 {
199 if (mat_ids[i] == mat_id)
200 {
201 marked_elems.push_back(i);
202 }
203 }
204 return marked_elems;
205}
PropertyVector< int > const * materialIDs(Mesh const &mesh)
Definition Mesh.cpp:269

References MeshLib::materialIDs().

Referenced by MeshToolsLib::MeshGenerators::VoxelFromLayeredMeshes::createVoxelFromLayeredMesh().

◆ setMaterialIDs()

void setMaterialIDs ( MeshLib::Mesh & mesh,
std::vector< MeshLib::Mesh const * > const & layers,
bool const dilate )

Definition at line 113 of file VoxelGridFromLayeredMeshes.cpp.

116{
117 INFO("Setting material properties...");
118 std::size_t const n_layers = layers.size();
119 auto const& elems = mesh.getElements();
120 std::size_t const n_elems = mesh.getNumberOfElements();
121 auto mat_ids = mesh.getProperties().getPropertyVector<int>(mat_name);
122 std::vector<bool> is_set(n_elems, false);
123 for (int i = n_layers - 1; i >= 0; --i)
124 {
125 INFO("-> Layer {:d}", n_layers - i - 1);
126 MeshLib::MeshElementGrid const grid(*layers[i]);
127 auto const edgeLengths = minMaxEdgeLength(layers[i]->getElements());
128 double const max_edge = edgeLengths.second;
129 for (std::size_t j = 0; j < n_elems; ++j)
130 {
131 if (is_set[j])
132 {
133 continue;
134 }
135
136 std::size_t nullptr_cnt(0);
137 std::size_t upper_layer_cnt(0);
138 std::size_t lower_layer_cnt(0);
139
140 auto const& node = MeshLib::getCenterOfGravity(*elems[j]);
141 voteMatId(node, grid, max_edge, nullptr_cnt, upper_layer_cnt,
142 lower_layer_cnt);
143 if (nullptr_cnt)
144 {
145 // if no element was found at centre point, vote via corners
146 for (std::size_t k = 0; k < 8; ++k)
147 {
148 MeshLib::Node const& n = *elems[j]->getNode(k);
149 voteMatId(n, grid, max_edge, nullptr_cnt, upper_layer_cnt,
150 lower_layer_cnt);
151 }
152
153 // If the "dilate"-param is set, a mat ID will be assigned if at
154 // least one node was voting for a specific layer. Without the
155 // "dilate"-param, an absolute majority is needed. In case of a
156 // tie, the lower layer will be favoured.
157 if ((upper_layer_cnt == 0 && lower_layer_cnt == 0) ||
158 (!dilate && nullptr_cnt >= upper_layer_cnt &&
159 nullptr_cnt >= lower_layer_cnt))
160 {
161 continue;
162 }
163 if (upper_layer_cnt > lower_layer_cnt)
164 {
165 (*mat_ids)[j] = n_layers - i - 1;
166 }
167 else
168 {
169 is_set[j] = true;
170 }
171 continue;
172 }
173 if (upper_layer_cnt)
174 {
175 (*mat_ids)[j] = n_layers - i - 1;
176 }
177 else
178 {
179 is_set[j] = true;
180 }
181 }
182 }
183 // set all elements above uppermost layer back to -1 so they are
184 // subsequently cut
185 std::replace(mat_ids->begin(), mat_ids->end(),
186 static_cast<int>(n_layers - 1), -1);
187}
void voteMatId(MathLib::Point3d const &node, MeshLib::MeshElementGrid const &grid, double const max_edge, std::size_t &nullptr_cnt, std::size_t &upper_layer_cnt, std::size_t &lower_layer_cnt)
std::vector< Element * > const & getElements() const
Get the element-vector for the mesh.
Definition Mesh.h:111
Properties & getProperties()
Definition Mesh.h:136
std::size_t getNumberOfElements() const
Get the number of elements.
Definition Mesh.h:99
PropertyVector< T > const * getPropertyVector(std::string_view name) const
std::pair< double, double > minMaxEdgeLength(std::vector< Element * > const &elements)
Returns the minimum and maximum edge length for given elements.
Definition Mesh.cpp:190
MathLib::Point3d getCenterOfGravity(Element const &element)
Calculates the center of gravity for the mesh element.
Definition Element.cpp:142

References MeshLib::getCenterOfGravity(), MeshLib::Mesh::getElements(), MeshLib::Mesh::getNumberOfElements(), MeshLib::Mesh::getProperties(), MeshLib::Properties::getPropertyVector(), INFO(), mat_name, and voteMatId().

Referenced by MeshToolsLib::MeshGenerators::VoxelFromLayeredMeshes::createVoxelFromLayeredMesh().

◆ voteMatId()

void voteMatId ( MathLib::Point3d const & node,
MeshLib::MeshElementGrid const & grid,
double const max_edge,
std::size_t & nullptr_cnt,
std::size_t & upper_layer_cnt,
std::size_t & lower_layer_cnt )

Definition at line 89 of file VoxelGridFromLayeredMeshes.cpp.

95{
96 auto const& proj_elem = getProjectedElement(grid, node, max_edge);
97 if (proj_elem == nullptr)
98 {
99 nullptr_cnt++;
100 return;
101 }
102 if (node[2] >
104 {
105 upper_layer_cnt++;
106 return;
107 }
108 lower_layer_cnt++;
109}
MeshLib::Element const * getProjectedElement(MeshLib::MeshElementGrid const &grid, MathLib::Point3d const &node, double const max_edge)
double getElevation(MeshLib::Element const &element, MathLib::Point3d const &node)

References MeshToolsLib::ProjectPointOnMesh::getElevation(), and getProjectedElement().

Referenced by setMaterialIDs().

Variable Documentation

◆ mat_name

std::string mat_name = "MaterialIDs"
static

Definition at line 20 of file VoxelGridFromLayeredMeshes.cpp.

Referenced by generateInitialMesh(), and setMaterialIDs().