OGS
MeshElementRemovalDialog.cpp
Go to the documentation of this file.
1
16
17#include <Eigen/StdVector>
18#include <QList>
19#include <QListWidgetItem>
20#include <algorithm>
21
24#include "GeoLib/AABB.h"
26#include "MeshLib/Mesh.h"
28#include "MeshLib/Node.h"
29#include "MeshLib/Properties.h"
31
34 DataHolderLib::Project const& project, QDialog* parent)
35 : QDialog(parent),
36 _project(project),
37 _currentIndex(0),
38 _aabbIndex(std::numeric_limits<unsigned>::max()),
39 _scalarIndex(std::numeric_limits<unsigned>::max())
40{
41 setupUi(this);
42
43 auto const& mesh_vec(_project.getMeshObjects());
44
45 const std::size_t nMeshes(mesh_vec.size());
46 for (std::size_t i = 0; i < nMeshes; ++i)
47 {
48 std::string name = mesh_vec[i]->getName();
49 this->meshNameComboBox->addItem(QString::fromStdString(name));
50 }
51
52 if (mesh_vec.empty())
53 {
54 OGSError::box("No meshes available.");
55 QMetaObject::invokeMethod(this, "close", Qt::QueuedConnection);
56 }
57}
58
60
62{
63 if (this->newMeshNameEdit->text().size() == 0)
64 {
65 OGSError::box("Please enter name for new mesh.");
66 return;
67 }
68
69 bool anything_checked(false);
70
71 const MeshLib::Mesh* msh =
72 _project.getMesh(this->meshNameComboBox->currentText().toStdString());
74 if (this->elementTypeCheckBox->isChecked())
75 {
76 QList<QListWidgetItem*> items =
77 this->elementTypeListWidget->selectedItems();
78 for (auto& item : items)
79 {
81 MeshLib::String2MeshElemType(item->text().toStdString()));
82 }
83 anything_checked = true;
84 }
85 if (this->scalarArrayCheckBox->isChecked())
86 {
87 std::string const array_name =
88 this->scalarArrayComboBox->currentText().toStdString();
89 double min_val;
90 double max_val;
91 bool outside = this->outsideButton->isChecked();
92 if (outside)
93 {
94 min_val = this->outsideScalarMinEdit->text().toDouble();
95 max_val = this->outsideScalarMaxEdit->text().toDouble();
96 }
97 else
98 {
99 min_val = this->insideScalarMinEdit->text().toDouble();
100 max_val = this->insideScalarMaxEdit->text().toDouble();
101 }
102
103 std::size_t n_marked_elements(0);
104 if (msh->getProperties().existsPropertyVector<double>(array_name))
105 {
106 n_marked_elements = ex.searchByPropertyValueRange<double>(
107 array_name, min_val, max_val, outside);
108 }
109 if (msh->getProperties().existsPropertyVector<int>(array_name))
110 {
111 int const lbound = static_cast<int>(min_val);
112 int const rbound = static_cast<int>(max_val);
113 n_marked_elements = ex.searchByPropertyValueRange<int>(
114 array_name, lbound, rbound, outside);
115 }
116
117 if (n_marked_elements > 0)
118 {
119 anything_checked = true;
120 }
121 }
122 if (this->boundingBoxCheckBox->isChecked())
123 {
124 std::vector<MeshLib::Node*> const& nodes(
126 .getMesh(this->meshNameComboBox->currentText().toStdString())
127 ->getNodes());
128 GeoLib::AABB const aabb(nodes.begin(), nodes.end());
129 auto [minAABB, maxAABB] = aabb.getMinMaxPoints();
130
131 // only extract bounding box parameters that have been edited (otherwise
132 // there will be rounding errors!)
133 minAABB[0] =
134 (aabb_edits[0]) ? this->xMinEdit->text().toDouble() : (minAABB[0]);
135 maxAABB[0] =
136 (aabb_edits[1]) ? this->xMaxEdit->text().toDouble() : (maxAABB[0]);
137 minAABB[1] =
138 (aabb_edits[2]) ? this->yMinEdit->text().toDouble() : (minAABB[1]);
139 maxAABB[1] =
140 (aabb_edits[3]) ? this->yMaxEdit->text().toDouble() : (maxAABB[1]);
141 minAABB[2] =
142 (aabb_edits[4]) ? this->zMinEdit->text().toDouble() : (minAABB[2]);
143 maxAABB[2] =
144 (aabb_edits[5]) ? this->zMaxEdit->text().toDouble() : (maxAABB[2]);
145 std::vector<Eigen::Vector3d, Eigen::aligned_allocator<Eigen::Vector3d>>
146 extent{minAABB, maxAABB};
147 const GeoLib::AABB updated_aabb(extent.begin(), extent.end());
148 ex.searchByBoundingBox(updated_aabb,
149 this->invertBoundingBoxCheckBox->isChecked());
150 anything_checked = true;
151 }
152
153 if (this->zeroVolumeCheckBox->isChecked())
154 {
155 ex.searchByContent();
156 anything_checked = true;
157 }
158
159 if (anything_checked)
160 {
162 *msh, ex.getSearchedElementIDs(),
163 this->newMeshNameEdit->text().toStdString());
164 if (new_mesh)
165 {
166 emit meshAdded(new_mesh);
167 }
168 else
169 {
170 if (ex.getSearchedElementIDs().empty())
171 {
173 "The current selection removes NO mesh elements.");
174 }
175 return;
176 }
177 }
178 else
179 {
180 OGSError::box("No condition set for elements to remove.");
181 return;
182 }
183
184 this->done(QDialog::Accepted);
185}
186
188{
189 this->done(QDialog::Rejected);
190}
191
193 MeshLib::Mesh const& mesh) const
194{
195 for (auto [name, property] : mesh.getProperties())
196 {
197 if (property->getMeshItemType() != MeshLib::MeshItemType::Cell)
198 {
199 continue;
200 }
201 this->scalarArrayComboBox->addItem(
202 QString::fromStdString(std::string(name)));
204 }
205 return this->scalarArrayComboBox->count();
206}
207
209{
210 this->scalarArrayComboBox->setEnabled(enable);
211 this->outsideButton->setEnabled(enable);
212 this->insideButton->setEnabled(enable);
213 this->outsideScalarMinEdit->setEnabled(enable &&
214 this->outsideButton->isChecked());
215 this->outsideScalarMaxEdit->setEnabled(enable &&
216 this->outsideButton->isChecked());
217 this->insideScalarMinEdit->setEnabled(enable &&
218 this->insideButton->isChecked());
219 this->insideScalarMaxEdit->setEnabled(enable &&
220 this->insideButton->isChecked());
221}
222
224{
225 this->outsideScalarMinEdit->setEnabled(outside);
226 this->outsideScalarMaxEdit->setEnabled(outside);
227 this->insideScalarMinEdit->setEnabled(!outside);
228 this->insideScalarMaxEdit->setEnabled(!outside);
229}
230
232{
233 toggleScalarEdits(!this->insideButton->isChecked());
234}
235
237{
238 this->invertBoundingBoxCheckBox->setEnabled(is_checked);
239 this->xMinEdit->setEnabled(is_checked);
240 this->xMaxEdit->setEnabled(is_checked);
241 this->yMinEdit->setEnabled(is_checked);
242 this->yMaxEdit->setEnabled(is_checked);
243 this->zMinEdit->setEnabled(is_checked);
244 this->zMaxEdit->setEnabled(is_checked);
245
246 if (is_checked && (_currentIndex != _aabbIndex))
247 {
249 std::vector<MeshLib::Node*> const& nodes(
251 .getMesh(this->meshNameComboBox->currentText().toStdString())
252 ->getNodes());
253 GeoLib::AABB aabb(nodes.begin(), nodes.end());
254 auto const& minAABB = aabb.getMinPoint();
255 auto const& maxAABB = aabb.getMaxPoint();
256 this->xMinEdit->setText(QString::number(minAABB[0], 'f'));
257 this->xMaxEdit->setText(QString::number(maxAABB[0], 'f'));
258 this->yMinEdit->setText(QString::number(minAABB[1], 'f'));
259 this->yMaxEdit->setText(QString::number(maxAABB[1], 'f'));
260 this->zMinEdit->setText(QString::number(minAABB[2], 'f'));
261 this->zMaxEdit->setText(QString::number(maxAABB[2], 'f'));
262 aabb_edits.fill(false);
263 }
264}
265
267 bool const is_checked)
268{
269 if (is_checked == true)
270 {
271 this->xOutsideLabel->setText("X between");
272 this->yOutsideLabel->setText("Y between");
273 this->zOutsideLabel->setText("Z between");
274 }
275 else
276 {
277 this->xOutsideLabel->setText("X outside of");
278 this->yOutsideLabel->setText("Y outside of");
279 this->zOutsideLabel->setText("Z outside of");
280 }
281}
282
284{
285 this->elementTypeListWidget->setEnabled(is_checked);
286}
287
289{
290 if (!is_checked)
291 {
293 return;
294 }
295
296 MeshLib::Mesh const* const mesh =
297 _project.getMesh(meshNameComboBox->currentText().toStdString());
298 if (addScalarArrays(*mesh) > 0)
299 {
301 }
302 else
303 {
305 OGSError::box("No scalar arrays found");
307 }
308}
309
311{
312 Q_UNUSED(idx);
313 this->_currentIndex = this->meshNameComboBox->currentIndex();
314 this->newMeshNameEdit->setText(this->meshNameComboBox->currentText() +
315 "_new");
316 this->elementTypeListWidget->clearSelection();
317 this->scalarArrayComboBox->clear();
318 this->outsideScalarMinEdit->setText("");
319 this->outsideScalarMaxEdit->setText("");
320 this->insideScalarMinEdit->setText("");
321 this->insideScalarMaxEdit->setText("");
322 on_scalarArrayCheckBox_toggled(this->scalarArrayCheckBox->isChecked());
323 on_boundingBoxCheckBox_toggled(this->boundingBoxCheckBox->isChecked());
324}
325
327 int idx)
328{
329 Q_UNUSED(idx);
330 std::string const vec_name(
331 scalarArrayComboBox->currentText().toStdString());
332 if (vec_name.empty())
333 {
334 return;
335 }
336
337 MeshLib::Mesh const* const mesh =
338 _project.getMesh(meshNameComboBox->currentText().toStdString());
339 if (mesh == nullptr)
340 {
341 return;
342 }
343 MeshLib::Properties const& properties = mesh->getProperties();
344
345 if (properties.existsPropertyVector<int>(vec_name))
346 {
347 setRangeValues<int>(*properties.getPropertyVector<int>(vec_name));
348 }
349 else if (properties.existsPropertyVector<double>(vec_name))
350 {
351 setRangeValues<double>(*properties.getPropertyVector<double>(vec_name));
352 }
353}
354
355template <typename T>
358{
359 auto min = std::min_element(vec.cbegin(), vec.cend());
360 auto max = std::max_element(vec.cbegin(), vec.cend());
361 this->outsideScalarMinEdit->setText(QString::number(*min));
362 this->outsideScalarMaxEdit->setText(QString::number(*max));
363 this->insideScalarMinEdit->setText(QString::number(*min));
364 this->insideScalarMaxEdit->setText(QString::number(*max));
365}
Definition of the AABB class.
Definition of the Element class.
Definition of the MeshElementRemovalDialog class.
Definition of the class Properties that implements a container of properties.
Definition of the Mesh class.
Definition of the Node class.
Definition of the OGSError class.
const std::vector< std::unique_ptr< MeshLib::Mesh > > & getMeshObjects() const
Returns all the meshes with their respective names.
Definition Project.h:57
const MeshLib::Mesh * getMesh(const std::string &name) const
Definition Project.cpp:43
Class AABB is an axis aligned bounding box around a given set of geometric points of (template) type ...
Definition AABB.h:56
Eigen::Vector3d const & getMaxPoint() const
Definition AABB.h:187
Eigen::Vector3d const & getMinPoint() const
Definition AABB.h:180
MinMaxPoints getMinMaxPoints() const
Definition AABB.h:174
~MeshElementRemovalDialog() override
void setRangeValues(MeshLib::PropertyVector< T > const &vec)
void on_elementTypeCheckBox_toggled(bool is_checked)
MeshElementRemovalDialog(DataHolderLib::Project const &project, QDialog *parent=nullptr)
Constructor.
void toggleScalarEdits(bool outside) const
DataHolderLib::Project const & _project
void on_insideButton_toggled(bool is_checked)
void on_invertBoundingBoxCheckBox_toggled(bool const is_checked)
void meshAdded(MeshLib::Mesh *mesh)
void on_scalarArrayCheckBox_toggled(bool is_checked)
void on_scalarArrayComboBox_currentIndexChanged(int idx)
std::size_t addScalarArrays(MeshLib::Mesh const &mesh) const
void enableScalarArrayWidgets(bool enable) const
void on_boundingBoxCheckBox_toggled(bool is_checked)
Element search class.
std::size_t searchByBoundingBox(GeoLib::AABB const &aabb, bool const invert=false)
const std::vector< std::size_t > & getSearchedElementIDs() const
return marked elements
std::size_t searchByElementType(MeshElemType eleType)
Marks all elements of the given element type.
std::size_t searchByPropertyValueRange(std::string const &property_name, PROPERTY_TYPE const min_property_value, PROPERTY_TYPE const max_property_value, bool outside_of)
std::size_t searchByContent(double eps=std::numeric_limits< double >::epsilon())
Marks all elements with a volume smaller than eps.
Properties & getProperties()
Definition Mesh.h:134
Property manager on mesh items. Class Properties manages scalar, vector or matrix properties....
Definition Properties.h:36
bool existsPropertyVector(std::string_view name) const
PropertyVector< T > const * getPropertyVector(std::string_view name) const
static void box(const QString &e)
Definition OGSError.cpp:23
MeshElemType String2MeshElemType(const std::string &s)
Given a string of the shortened name of the element type, this returns the corresponding MeshElemType...
Definition MeshEnums.cpp:95
MeshLib::Mesh * removeElements(const MeshLib::Mesh &mesh, const std::vector< std::size_t > &removed_element_ids, const std::string &new_mesh_name)
OGSMesh getMesh(std::string const &name)