int main (int argc, char* argv[])
{
ApplicationsLib::LogogSetup logog_setup;
TCLAP::CmdLine cmd("Edit material IDs of mesh elements.", ' ', "0.1");
TCLAP::SwitchArg replaceArg("r", "replace", "replace material IDs", false);
TCLAP::SwitchArg condenseArg("c", "condense", "condense material IDs", false);
TCLAP::SwitchArg specifyArg("s", "specify", "specify material IDs by element types (-e)", false);
std::vector<TCLAP::Arg*> vec_xors;
vec_xors.push_back(&replaceArg);
vec_xors.push_back(&condenseArg);
vec_xors.push_back(&specifyArg);
cmd.xorAdd(vec_xors);
TCLAP::ValueArg<std::string> mesh_in("i", "mesh-input-file",
"the name of the file containing the input mesh", true,
"", "file name");
cmd.add(mesh_in);
TCLAP::ValueArg<std::string> mesh_out("o", "mesh-output-file",
"the name of the file the mesh will be written to", true,
"", "file name");
cmd.add(mesh_out);
TCLAP::MultiArg<unsigned> matIDArg("m", "current-material-id",
"current material id to be replaced", false, "number");
cmd.add(matIDArg);
TCLAP::ValueArg<unsigned> newIDArg("n", "new-material-id",
"new material id", false, 0, "number");
cmd.add(newIDArg);
std::vector<std::string> eleList(MeshLib::getMeshElemTypeStringsShort());
TCLAP::ValuesConstraint<std::string> allowedVals(eleList);
TCLAP::ValueArg<std::string> eleTypeArg("e", "element-type",
"element type", false, "", &allowedVals);
cmd.add(eleTypeArg);
cmd.parse(argc, argv);
if (!replaceArg.isSet() && !condenseArg.isSet() && !specifyArg.isSet()) {
INFO("Please select editing mode: -r or -c or -s");
return 0;
} else if (replaceArg.isSet() && condenseArg.isSet()) {
INFO("Please select only one editing mode: -r or -c or -s");
return 0;
} else if (replaceArg.isSet()) {
if (!matIDArg.isSet() || !newIDArg.isSet()) {
INFO("current and new material IDs must be provided for replacement");
return 0;
}
} else if (specifyArg.isSet()) {
if (!eleTypeArg.isSet() || !newIDArg.isSet()) {
INFO("element type and new material IDs must be provided to specify elements");
return 0;
}
}
std::unique_ptr<MeshLib::Mesh> mesh(
MeshLib::IO::readMeshFromFile(mesh_in.getValue()));
INFO("Mesh read: %d nodes, %d elements.", mesh->getNNodes(), mesh->getNElements());
if (condenseArg.isSet()) {
INFO("Condensing material ID...");
MeshLib::ElementValueModification::condense(*mesh);
} else if (replaceArg.isSet()) {
INFO("Replacing material ID...");
const auto vecOldID = matIDArg.getValue();
const unsigned newID = newIDArg.getValue();
for (auto oldID : vecOldID) {
INFO("%d -> %d", oldID, newID);
MeshLib::ElementValueModification::replace(*mesh, oldID, newID, true);
}
} else if (specifyArg.isSet()) {
INFO("Specifying material ID...");
const std::string eleTypeName(eleTypeArg.getValue());
const MeshLib::MeshElemType eleType = MeshLib::String2MeshElemType(eleTypeName);
const unsigned newID = newIDArg.getValue();
unsigned cnt = MeshLib::ElementValueModification::setByElementType(*mesh, eleType, newID);
INFO("updated %d elements", cnt);
}
MeshLib::IO::writeMeshToFile(*mesh, mesh_out.getValue());
return EXIT_SUCCESS;
}
int main (int argc, char* argv[])
{
LOGOG_INITIALIZE();
logog::Cout* logog_cout (new logog::Cout);
BaseLib::LogogSimpleFormatter *custom_format (new BaseLib::LogogSimpleFormatter);
logog_cout->SetFormatter(*custom_format);
TCLAP::CmdLine cmd("Remove mesh elements.", ' ', "0.1");
// Bounding box params
TCLAP::ValueArg<double> zLargeArg("", "z-max", "largest allowed extent in z-dimension",
false, std::numeric_limits<double>::max(), "value");
cmd.add(zLargeArg);
TCLAP::ValueArg<double> zSmallArg("", "z-min", "smallest allowed extent in z-dimension",
false, -1 * std::numeric_limits<double>::max(), "value");
cmd.add(zSmallArg);
TCLAP::ValueArg<double> yLargeArg("", "y-max", "largest allowed extent in y-dimension",
false, std::numeric_limits<double>::max(), "value");
cmd.add(yLargeArg);
TCLAP::ValueArg<double> ySmallArg("", "y-min", "smallest allowed extent in y-dimension",
false, -1 * std::numeric_limits<double>::max(), "value");
cmd.add(ySmallArg);
TCLAP::ValueArg<double> xLargeArg("", "x-max", "largest allowed extent in x-dimension",
false, std::numeric_limits<double>::max(), "value");
cmd.add(xLargeArg);
TCLAP::ValueArg<double> xSmallArg("", "x-min", "smallest allowed extent in x-dimension",
false, -1 * std::numeric_limits<double>::max(), "value");
cmd.add(xSmallArg);
// Non-bounding-box params
TCLAP::SwitchArg zveArg("z", "zero-volume", "remove zero volume elements", false);
cmd.add(zveArg);
TCLAP::MultiArg<std::string> eleTypeArg("t", "element-type",
"element type to be removed", false, "element type");
cmd.add(eleTypeArg);
TCLAP::MultiArg<unsigned> matIDArg("m", "material-id",
"material id", false, "material id");
cmd.add(matIDArg);
// I/O params
TCLAP::ValueArg<std::string> mesh_out("o", "mesh-output-file",
"the name of the file the mesh will be written to", true,
"", "file name of output mesh");
cmd.add(mesh_out);
TCLAP::ValueArg<std::string> mesh_in("i", "mesh-input-file",
"the name of the file containing the input mesh", true,
"", "file name of input mesh");
cmd.add(mesh_in);
cmd.parse(argc, argv);
MeshLib::Mesh const*const mesh (FileIO::readMeshFromFile(mesh_in.getValue()));
INFO("Mesh read: %d nodes, %d elements.", mesh->getNNodes(), mesh->getNElements());
MeshLib::ElementSearch ex(*mesh);
// search elements IDs to be removed
if (zveArg.isSet()) {
const std::size_t n_removed_elements = ex.searchByContent();
INFO("%d zero volume elements found.", n_removed_elements);
}
if (eleTypeArg.isSet()) {
const std::vector<std::string> eleTypeNames = eleTypeArg.getValue();
for (auto typeName : eleTypeNames) {
const MeshLib::MeshElemType type = MeshLib::String2MeshElemType(typeName);
if (type == MeshLib::MeshElemType::INVALID) continue;
const std::size_t n_removed_elements = ex.searchByElementType(type);
INFO("%d %s elements found.", n_removed_elements, typeName.c_str());
}
}
if (matIDArg.isSet()) {
const std::vector<unsigned> vec_matID = matIDArg.getValue();
for (auto matID : vec_matID) {
const std::size_t n_removed_elements = ex.searchByMaterialID(matID);
INFO("%d elements with material ID %d found.", n_removed_elements, matID);
}
}
if (xSmallArg.isSet() || xLargeArg.isSet() ||
ySmallArg.isSet() || yLargeArg.isSet() ||
zSmallArg.isSet() || zLargeArg.isSet())
{
bool aabb_error (false);
if (xSmallArg.getValue() >= xLargeArg.getValue())
{
ERR ("Minimum x-extent larger than maximum x-extent.");
aabb_error = true;
}
if (ySmallArg.getValue() >= yLargeArg.getValue())
{
ERR ("Minimum y-extent larger than maximum y-extent.");
aabb_error = true;
}
if (zSmallArg.getValue() >= zLargeArg.getValue())
{
ERR ("Minimum z-extent larger than maximum z-extent.");
aabb_error = true;
}
if (aabb_error)
return 1;
std::array<MathLib::Point3d, 2> extent({{
MathLib::Point3d(std::array<double,3>{{xSmallArg.getValue(),
ySmallArg.getValue(), zSmallArg.getValue()}}),
MathLib::Point3d(std::array<double,3>{{xLargeArg.getValue(),
yLargeArg.getValue(), zLargeArg.getValue()}})}});
const std::size_t n_removed_elements = ex.searchByBoundingBox(
GeoLib::AABB(extent.begin(), extent.end()));
INFO("%d elements found.", n_removed_elements);
}
// remove the elements and create a new mesh object.
MeshLib::Mesh const*const new_mesh = MeshLib::removeElements(*mesh, ex.getSearchedElementIDs(), mesh->getName());
// write into a file
FileIO::Legacy::MeshIO meshIO;
meshIO.setMesh(new_mesh);
meshIO.writeToFile(mesh_out.getValue());
delete custom_format;
delete logog_cout;
LOGOG_SHUTDOWN();
return 0;
}
int main (int argc, char* argv[])
{
LOGOG_INITIALIZE();
logog::Cout* logog_cout (new logog::Cout);
BaseLib::LogogSimpleFormatter *custom_format (new BaseLib::LogogSimpleFormatter);
logog_cout->SetFormatter(*custom_format);
TCLAP::CmdLine cmd("Remove mesh elements.", ' ', "0.1");
TCLAP::ValueArg<std::string> mesh_in("i", "mesh-input-file",
"the name of the file containing the input mesh", true,
"", "file name of input mesh");
cmd.add(mesh_in);
TCLAP::ValueArg<std::string> mesh_out("o", "mesh-output-file",
"the name of the file the mesh will be written to", true,
"", "file name of output mesh");
cmd.add(mesh_out);
TCLAP::SwitchArg zveArg("z", "zero-volume", "remove zero volume elements", false);
cmd.add(zveArg);
TCLAP::MultiArg<std::string> eleTypeArg("t", "element-type",
"element type to be removed", false, "element type");
cmd.add(eleTypeArg);
TCLAP::MultiArg<unsigned> matIDArg("m", "material-id",
"material id", false, "material id");
cmd.add(matIDArg);
cmd.parse(argc, argv);
MeshLib::Mesh* mesh (FileIO::readMeshFromFile(mesh_in.getValue()));
INFO("Mesh read: %d nodes, %d elements.", mesh->getNNodes(), mesh->getNElements());
// search elements IDs to be removed
std::vector<std::size_t> vec_elementIDs_removed;
if (zveArg.isSet()) {
std::vector<std::size_t> vec_matched = searchByZeroContent(mesh->getElements());
updateUnion(vec_matched, vec_elementIDs_removed);
INFO("%d zero volume elements found.", vec_matched.size());
}
if (eleTypeArg.isSet()) {
std::vector<std::string> eleTypeNames = eleTypeArg.getValue();
for (auto typeName : eleTypeNames) {
MeshElemType type = String2MeshElemType(typeName);
if (type == MeshElemType::INVALID) continue;
std::vector<std::size_t> vec_matched = searchByElementType(mesh->getElements(), type);
updateUnion(vec_matched, vec_elementIDs_removed);
INFO("%d %s elements found.", vec_matched.size(), typeName.c_str());
}
}
if (matIDArg.isSet()) {
std::vector<unsigned> vec_matID = matIDArg.getValue();
for (auto matID : vec_matID) {
std::vector<std::size_t> vec_matched = searchByMaterialID(mesh->getElements(), matID);
updateUnion(vec_matched, vec_elementIDs_removed);
INFO("%d elements with material ID %d found.", vec_matched.size(), matID);
}
}
// remove the elements
INFO("Removing total %d elements...", vec_elementIDs_removed.size());
std::vector<MeshLib::Element*> tmp_eles = excludeElements(mesh->getElements(), vec_elementIDs_removed);
INFO("%d elements remained.", tmp_eles.size());
std::vector<MeshLib::Node*> new_nodes;
std::vector<MeshLib::Element*> new_eles;
copyNodesElements(mesh->getNodes(), tmp_eles, new_nodes, new_eles);
// create a new mesh object. Unsued nodes are removed while construction
MeshLib::Mesh* new_mesh(new MeshLib::Mesh(mesh->getName(), new_nodes, new_eles));
// write into a file
FileIO::Legacy::MeshIO meshIO;
meshIO.setMesh(new_mesh);
meshIO.writeToFile(mesh_out.getValue());
delete custom_format;
delete logog_cout;
LOGOG_SHUTDOWN();
return 0;
}
