OGS
RemoveMeshComponents.cpp
Go to the documentation of this file.
1
12
16#include "MeshLib/Node.h"
18
19namespace MeshToolsLib
20{
21namespace details
22{
23std::vector<MeshLib::Element*> excludeElementCopy(
24 std::vector<MeshLib::Element*> const& vec_src_eles,
25 std::vector<std::size_t> const& vec_removed)
26{
27 std::vector<MeshLib::Element*> vec_dest_eles(vec_src_eles.size() -
28 vec_removed.size());
29
30 unsigned cnt(0);
31 for (std::size_t i = 0; i < vec_removed[0]; ++i)
32 {
33 vec_dest_eles[cnt++] = vec_src_eles[i];
34 }
35 for (std::size_t i = 1; i < vec_removed.size(); ++i)
36 {
37 for (std::size_t j = vec_removed[i - 1] + 1; j < vec_removed[i]; ++j)
38 {
39 vec_dest_eles[cnt++] = vec_src_eles[j];
40 }
41 }
42 for (std::size_t i = vec_removed.back() + 1; i < vec_src_eles.size(); ++i)
43 {
44 vec_dest_eles[cnt++] = vec_src_eles[i];
45 }
46
47 return vec_dest_eles;
48}
49
50} // namespace details
51
53 const MeshLib::Mesh& mesh,
54 const std::vector<std::size_t>& removed_element_ids,
55 const std::string& new_mesh_name)
56{
57 if (removed_element_ids.empty())
58 {
59 INFO("No elements to remove");
60 return nullptr;
61 }
62
63 INFO("Removing total {:d} elements...", removed_element_ids.size());
64 std::vector<MeshLib::Element*> tmp_elems =
65 details::excludeElementCopy(mesh.getElements(), removed_element_ids);
66 INFO("{:d} elements remain in mesh.", tmp_elems.size());
67
68 // copy node and element objects
69 std::vector<MeshLib::Node*> new_nodes =
71 std::vector<MeshLib::Element*> new_elems =
72 MeshLib::copyElementVector(tmp_elems, new_nodes);
73
74 // delete unused nodes
75 MeshLib::NodeSearch ns(mesh);
76 ns.searchNodesConnectedToOnlyGivenElements(removed_element_ids);
77 auto& removed_node_ids(ns.getSearchedNodeIDs());
78 INFO("Removing total {:d} nodes...", removed_node_ids.size());
79 for (auto nodeid : removed_node_ids)
80 {
81 delete new_nodes[nodeid];
82 new_nodes[nodeid] = nullptr;
83 }
84 new_nodes.erase(std::remove(new_nodes.begin(), new_nodes.end(), nullptr),
85 new_nodes.end());
86
87 if (!new_elems.empty())
88 {
89 MeshLib::Mesh* new_mesh =
90 new MeshLib::Mesh(new_mesh_name, new_nodes, new_elems,
92 removed_element_ids, removed_node_ids));
93 return new_mesh;
94 }
95
96 INFO("Current selection removes all elements.");
97 return nullptr;
98}
99
100std::vector<bool> markUnusedNodes(
101 std::vector<MeshLib::Element*> const& elements,
102 std::vector<MeshLib::Node*> const& nodes)
103{
104 std::vector<bool> unused_nodes(nodes.size(), true);
105 for (auto e : elements)
106 {
107 for (unsigned i = 0; i < e->getNumberOfNodes(); i++)
108 {
109 unused_nodes[getNodeIndex(*e, i)] = false;
110 }
111 }
112
113 return unused_nodes;
114}
115
116void removeMarkedNodes(std::vector<bool> const& nodes_to_delete,
117 std::vector<MeshLib::Node*>& nodes)
118{
119 assert(nodes_to_delete.size() == nodes.size());
120
121 for (std::size_t i = 0; i < nodes.size(); i++)
122 {
123 if (nodes_to_delete[i])
124 {
125 delete nodes[i];
126 nodes[i] = nullptr;
127 }
128 }
129 nodes.erase(remove(begin(nodes), end(nodes), nullptr), end(nodes));
130}
131
133 const std::vector<std::size_t>& del_nodes_idx,
134 const std::string& new_mesh_name)
135{
136 if (del_nodes_idx.empty())
137 {
138 return nullptr;
139 }
140
141 // copy node and element objects
142 std::vector<MeshLib::Node*> new_nodes =
144 std::vector<MeshLib::Element*> new_elems =
145 MeshLib::copyElementVector(mesh.getElements(), new_nodes);
146
147 // delete elements
148 MeshLib::ElementSearch es(mesh);
149 es.searchByNodeIDs(del_nodes_idx);
150 auto& removed_element_ids = es.getSearchedElementIDs();
151 for (auto eid : removed_element_ids)
152 {
153 delete new_elems[eid];
154 new_elems[eid] = nullptr;
155 }
156 new_elems.erase(std::remove(new_elems.begin(), new_elems.end(), nullptr),
157 new_elems.end());
158
159 // check unused nodes due to element deletion
160 std::vector<bool> const node_delete_flag =
161 markUnusedNodes(new_elems, new_nodes);
162
163 // delete unused nodes
164 removeMarkedNodes(node_delete_flag, new_nodes);
165
166 if (!new_elems.empty())
167 {
168 MeshLib::Mesh* new_mesh =
169 new MeshLib::Mesh(new_mesh_name, new_nodes, new_elems,
171 removed_element_ids, del_nodes_idx));
172 return new_mesh;
173 }
174
175 return nullptr;
176}
177} // namespace MeshToolsLib
Definition of Duplicate functions.
Definition of the Element class.
void INFO(fmt::format_string< Args... > fmt, Args &&... args)
Definition: Logging.h:35
Definition of the Node class.
Element search class.
Definition: ElementSearch.h:28
const std::vector< std::size_t > & getSearchedElementIDs() const
return marked elements
Definition: ElementSearch.h:33
std::size_t searchByNodeIDs(const std::vector< std::size_t > &nodes)
Marks all elements connecting to any of the given nodes.
std::vector< Node * > const & getNodes() const
Get the nodes-vector for the mesh.
Definition: Mesh.h:102
std::vector< Element * > const & getElements() const
Get the element-vector for the mesh.
Definition: Mesh.h:105
Properties & getProperties()
Definition: Mesh.h:130
Node search class.
Definition: NodeSearch.h:25
std::size_t searchNodesConnectedToOnlyGivenElements(const std::vector< std::size_t > &elements)
Definition: NodeSearch.cpp:24
const std::vector< std::size_t > & getSearchedNodeIDs() const
return marked node IDs
Definition: NodeSearch.h:30
Properties excludeCopyProperties(std::vector< std::size_t > const &exclude_elem_ids, std::vector< std::size_t > const &exclude_node_ids) const
Definition: Properties.cpp:57
std::vector< Node * > copyNodeVector(const std::vector< Node * > &nodes)
Creates a deep copy of a Node vector.
std::vector< Element * > copyElementVector(std::vector< Element * > const &elements, std::vector< Node * > const &new_nodes, std::vector< std::size_t > const *const node_id_map)
std::vector< MeshLib::Element * > excludeElementCopy(std::vector< MeshLib::Element * > const &vec_src_eles, std::vector< std::size_t > const &vec_removed)
std::vector< bool > markUnusedNodes(std::vector< MeshLib::Element * > const &elements, std::vector< MeshLib::Node * > const &nodes)
Marks nodes not used by any of the elements.
void removeMarkedNodes(std::vector< bool > const &nodes_to_delete, std::vector< MeshLib::Node * > &nodes)
Deallocates and removes nodes marked true.
MeshLib::Mesh * removeNodes(const MeshLib::Mesh &mesh, const std::vector< std::size_t > &del_nodes_idx, const std::string &new_mesh_name)
MeshLib::Mesh * removeElements(const MeshLib::Mesh &mesh, const std::vector< std::size_t > &removed_element_ids, const std::string &new_mesh_name)