void PlainDictionary::save(std::ostream &output, ControlInformation &controlInformation, ProgressListener *listener)
{
controlInformation.setFormat(HDTVocabulary::DICTIONARY_TYPE_PLAIN);
controlInformation.setUint("mapping", this->mapping);
controlInformation.setUint("sizeStrings", this->sizeStrings);
controlInformation.setUint("numEntries", this->getNumberOfElements());
controlInformation.save(output);
unsigned int i = 0;
unsigned int counter=0;
const char marker = '\1';
//shared subjects-objects from subjects
for (i = 0; i < shared.size(); i++) {
output << shared[i]->str;
output.put(marker); //character to split file
counter++;
NOTIFYCOND(listener, "PlainDictionary saving shared", counter, getNumberOfElements());
}
output.put(marker); //extra line to set the begining of next part of dictionary
//not shared subjects
for (i = 0; i < subjects.size(); i++) {
output << subjects[i]->str;
output.put(marker); //character to split file
counter++;
NOTIFYCOND(listener, "PlainDictionary saving subjects", counter, getNumberOfElements());
}
output.put(marker); //extra line to set the begining of next part of dictionary
//not shared objects
for (i = 0; i < objects.size(); i++) {
output << objects[i]->str;
output.put(marker); //character to split file
counter++;
NOTIFYCOND(listener, "PlainDictionary saving objects", counter, getNumberOfElements());
}
output.put(marker); //extra line to set the begining of next part of dictionary
//predicates
for (i = 0; i < predicates.size(); i++) {
output << predicates[i]->str;
output.put(marker); //character to split file
counter++;
NOTIFYCOND(listener, "PlainDictionary saving predicates", counter, getNumberOfElements());
}
output.put(marker);
}
void CompactTriples::populateHeader(Header &header, string rootNode) {
header.insert(rootNode, HDTVocabulary::TRIPLES_TYPE, HDTVocabulary::TRIPLES_TYPE_COMPACT);
header.insert(rootNode, HDTVocabulary::TRIPLES_NUM_TRIPLES, getNumberOfElements() );
header.insert(rootNode, HDTVocabulary::TRIPLES_ORDER, getOrderStr(order) );
header.insert(rootNode, HDTVocabulary::TRIPLES_SEQY_TYPE, streamY->getType() );
header.insert(rootNode, HDTVocabulary::TRIPLES_SEQZ_TYPE, streamZ->getType() );
}
virtual std::string getElementAt(int i) override
{
if (i >= getNumberOfElements() || i < 0)
return "???";
return gettext(SORT_NAME_INVENTORY[i]);
}
std::string getElementAt(int i){
if ((i >= 0) && (i < getNumberOfElements()))
return (std::string)(settings.locals[i]->artificial ? "} " : "{ ") +
(std::string)(settings.locals[i]->chosen ? "> " : "") +
(std::string)(settings.locals[i]->name);
else return "";
}
std::string Palette::getElementAt(int i)
{
if (i < 0 || i >= getNumberOfElements())
return "";
return mColVector[i].text;
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
void QuadGeom::addAttributeMatrix(const QString& name, AttributeMatrix::Pointer data)
{
if (data->getType() != 0 || data->getType() != 1 || data->getType() != 2)
{
// QuadGeom can only accept vertex, edge, or face Attribute Matrices
return;
}
if (data->getType() == 0 && static_cast<int64_t>(data->getNumTuples()) != getNumberOfVertices())
{
return;
}
if (data->getType() == 1 && static_cast<int64_t>(data->getNumTuples()) != getNumberOfEdges())
{
return;
}
if (data->getType() == 2 && data->getNumTuples() != getNumberOfElements())
{
return;
}
if (data->getName().compare(name) != 0)
{
data->setName(name);
}
m_AttributeMatrices[name] = data;
}
virtual std::string getElementAt(int i)
{
if (i < 0 || i >= getNumberOfElements())
return _("???");
return mStrings.at(i);
}
Palette::ColorType Palette::getColorTypeAt(int i)
{
if (i < 0 || i >= getNumberOfElements())
return CHAT;
return mColVector[i].type;
}
virtual std::string getElementAt(int i)
{
if (i >= getNumberOfElements() || i < 0)
return _("???");
return gettext(OPENGL_NAME[i]);
}
virtual std::string getElementAt(int i)
{
if (i >= getNumberOfElements())
return _("???");
return SIZE_NAME[i];
}
virtual std::string getElementAt(int i)
{
if (i >= getNumberOfElements())
return _("???");
return (*player_relations.getPlayerIgnoreStrategies())[i]->mDescription;
}
int UserPalette::getColorTypeAt(int i)
{
if (i < 0 || i >= getNumberOfElements())
return BEING;
return mColors[i].type;
}
std::string UserPalette::getElementAt(int i)
{
if (i < 0 || i >= getNumberOfElements())
{
return "";
}
return mColors[i].text;
}
int GroupModel::nbGroup(std::string group)
{
for(int i=0; i < getNumberOfElements(); ++i)
if(group == getElementAt(i))
return i;
return -1; // Error value : group not found
}
int ModeListModel::getIndexOf(const std::string &widthXHeightMode)
{
std::string currentMode;
for (int i = 0; i < getNumberOfElements(); i++)
{
currentMode = getElementAt(i);
if (currentMode == widthXHeightMode)
return i;
}
return -1;
}
TEST(MeshLib, ElementStatus)
{
const unsigned width (100);
const unsigned elements_per_side (20);
auto const mesh = std::unique_ptr<MeshLib::Mesh>{
MeshLib::MeshGenerator::generateRegularQuadMesh(width, elements_per_side)};
auto* const material_id_properties =
mesh->getProperties().createNewPropertyVector<int>(
"MaterialIDs", MeshLib::MeshItemType::Cell);
ASSERT_NE(nullptr, material_id_properties);
material_id_properties->resize(mesh->getNumberOfElements());
const std::vector<MeshLib::Element*> elements (mesh->getElements());
for (unsigned i=0; i<elements_per_side; ++i)
{
for (unsigned j=0; j<elements_per_side; ++j)
(*material_id_properties)[elements[i*elements_per_side + j]->getID()] = i;
}
{
// all elements and nodes active
MeshLib::ElementStatus status(mesh.get());
ASSERT_EQ (elements.size(), status.getNumberOfActiveElements());
ASSERT_EQ (mesh->getNumberOfNodes(), status.getNumberOfActiveNodes());
}
{
// set material 1 to false
std::vector<int> inactiveMat{1};
MeshLib::ElementStatus status(mesh.get(), inactiveMat);
ASSERT_EQ (elements.size()-elements_per_side, status.getNumberOfActiveElements());
}
{
// set material 0 and 1 to false
std::vector<int> inactiveMat{0, 1};
MeshLib::ElementStatus status(mesh.get(), inactiveMat);
ASSERT_EQ (elements.size()-(2*elements_per_side), status.getNumberOfActiveElements());
// active elements
auto &active_elements (status.getActiveElements());
ASSERT_EQ (active_elements.size(), status.getNumberOfActiveElements());
// active nodes
auto& active_nodes (status.getActiveNodes());
ASSERT_EQ (active_nodes.size(), status.getNumberOfActiveNodes());
}
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
void VertexGeom::addAttributeMatrix(const QString& name, AttributeMatrix::Pointer data)
{
if (data->getType() != 0)
{
// VertexGeom can only accept vertex Attribute Matrices
return;
}
if (data->getNumTuples() != getNumberOfElements())
{
return;
}
if (data->getName().compare(name) != 0)
{
data->setName(name);
}
m_AttributeMatrices[name] = data;
}
void CompactTriples::save(std::ostream & output, ControlInformation &controlInformation, ProgressListener *listener)
{
controlInformation.clear();
controlInformation.setUint("numTriples", getNumberOfElements());
controlInformation.setFormat(HDTVocabulary::TRIPLES_TYPE_COMPACT);
controlInformation.setUint("order", order);
controlInformation.save(output);
IntermediateListener iListener(listener);
iListener.setRange(0,30);
iListener.notifyProgress(0, "CompactTriples saving Stream Y");
streamY->save(output);
iListener.setRange(30,100);
iListener.notifyProgress(0, "CompactTriples saving Stream Z");
streamZ->save(output);
}
TEST_F(TestVtkMeshConverter, Conversion)
{
auto mesh = std::unique_ptr<MeshLib::Mesh>(
MeshLib::VtkMeshConverter::convertUnstructuredGrid(vtu));
ASSERT_EQ(mesh->getNumberOfNodes(), vtu->GetNumberOfPoints());
ASSERT_EQ(mesh->getNumberOfElements(), vtu->GetNumberOfCells());
ASSERT_EQ(mesh->getElement(0)->getCellType(), MeshLib::CellType::HEX8);
auto meshProperties = mesh->getProperties();
// MaterialIDs are converted to an int property
auto const* const materialIds =
meshProperties.getPropertyVector<int>("MaterialIDs");
ASSERT_NE(nullptr, materialIds);
auto vtkMaterialIds = vtu->GetCellData()->GetArray("MaterialIDs");
ASSERT_EQ(materialIds->size(), vtkMaterialIds->GetNumberOfTuples());
for(std::size_t i = 0; i < materialIds->size(); i++)
ASSERT_EQ((*materialIds)[i], vtkMaterialIds->GetTuple1(i));
}
void PlainTriples::save(std::ostream & output, ControlInformation &controlInformation, ProgressListener *listener)
{
controlInformation.clear();
controlInformation.setUint("numTriples", getNumberOfElements());
controlInformation.setFormat(HDTVocabulary::TRIPLES_TYPE_PLAIN);
controlInformation.setUint("order", order);
controlInformation.save(output);
IntermediateListener iListener(listener);
iListener.setRange(0,33);
iListener.notifyProgress(0, "PlainTriples saving subjects");
streamX->save(output);
iListener.setRange(33, 66);
iListener.notifyProgress(0, "PlainTriples saving predicates");
streamY->save(output);
iListener.setRange(66, 100);
iListener.notifyProgress(0, "PlainTriples saving objects");
streamZ->save(output);
}
virtual std::string getElementAt(int i)
{
if (i >= getNumberOfElements() || i < 0)
return "";
return gettext(RELATION_NAMES[i]);
}
TEST_F(InSituMesh, DISABLED_MappedMeshSourceRoundtrip)
#endif
{
// TODO Add more comparison criteria
ASSERT_TRUE(mesh != nullptr);
std::string test_data_file(BaseLib::BuildInfo::tests_tmp_path + "/MappedMeshSourceRoundtrip.vtu");
// -- Test VtkMappedMeshSource, i.e. OGS mesh to VTK mesh
vtkNew<MeshLib::VtkMappedMeshSource> vtkSource;
vtkSource->SetMesh(mesh);
vtkSource->Update();
vtkUnstructuredGrid* output = vtkSource->GetOutput();
// Point and cell numbers
ASSERT_EQ((subdivisions+1)*(subdivisions+1)*(subdivisions+1), output->GetNumberOfPoints());
ASSERT_EQ(subdivisions*subdivisions*subdivisions, output->GetNumberOfCells());
// Point data arrays
vtkDataArray* pointDoubleArray = output->GetPointData()->GetScalars("PointDoubleProperty");
ASSERT_EQ(pointDoubleArray->GetSize(), mesh->getNumberOfNodes());
ASSERT_EQ(pointDoubleArray->GetComponent(0, 0), 1.0);
double* range = pointDoubleArray->GetRange(0);
ASSERT_EQ(range[0], 1.0);
ASSERT_EQ(range[1], 1.0 + mesh->getNumberOfNodes() - 1.0);
vtkDataArray* pointIntArray = output->GetPointData()->GetScalars("PointIntProperty");
ASSERT_EQ(pointIntArray->GetSize(), mesh->getNumberOfNodes());
ASSERT_EQ(pointIntArray->GetComponent(0, 0), 1.0);
range = pointIntArray->GetRange(0);
ASSERT_EQ(range[0], 1.0);
ASSERT_EQ(range[1], 1 + mesh->getNumberOfNodes() - 1);
vtkDataArray* pointUnsignedArray = output->GetPointData()->GetScalars("PointUnsignedProperty");
ASSERT_EQ(pointUnsignedArray->GetSize(), mesh->getNumberOfNodes());
ASSERT_EQ(pointUnsignedArray->GetComponent(0, 0), 1.0);
range = pointUnsignedArray->GetRange(0);
ASSERT_EQ(range[0], 1.0);
ASSERT_EQ(range[1], 1 + mesh->getNumberOfNodes() - 1);
// Cell data arrays
vtkDataArray* cellDoubleArray = output->GetCellData()->GetScalars("CellDoubleProperty");
ASSERT_EQ(cellDoubleArray->GetSize(), mesh->getNumberOfElements());
ASSERT_EQ(cellDoubleArray->GetComponent(0, 0), 1.0);
range = cellDoubleArray->GetRange(0);
ASSERT_EQ(range[0], 1.0);
ASSERT_EQ(range[1], 1.0 + mesh->getNumberOfElements() - 1.0);
vtkDataArray* cellIntArray = output->GetCellData()->GetScalars("CellIntProperty");
ASSERT_EQ(cellIntArray->GetSize(), mesh->getNumberOfElements());
ASSERT_EQ(cellIntArray->GetComponent(0, 0), 1.0);
range = cellIntArray->GetRange(0);
ASSERT_EQ(range[0], 1.0);
ASSERT_EQ(range[1], 1 + mesh->getNumberOfElements() - 1);
vtkDataArray* cellUnsignedArray = output->GetCellData()->GetScalars("CellUnsignedProperty");
ASSERT_EQ(cellUnsignedArray->GetSize(), mesh->getNumberOfElements());
ASSERT_EQ(cellUnsignedArray->GetComponent(0, 0), 1.0);
range = cellUnsignedArray->GetRange(0);
ASSERT_EQ(range[0], 1.0);
ASSERT_EQ(range[1], 1 + mesh->getNumberOfElements() - 1);
// Field data arrays
vtkDataArray* fieldDoubleArray = vtkDataArray::SafeDownCast(
output->GetFieldData()->GetAbstractArray("FieldDoubleProperty"));
ASSERT_EQ(fieldDoubleArray->GetSize(), mesh->getNumberOfElements() * 2);
ASSERT_EQ(fieldDoubleArray->GetComponent(0, 0), 1.0);
range = fieldDoubleArray->GetRange(0);
ASSERT_EQ(range[0], 1.0);
ASSERT_EQ(range[1], mesh->getNumberOfElements() * 2);
vtkDataArray* fieldIntArray = vtkDataArray::SafeDownCast(
output->GetFieldData()->GetAbstractArray("FieldIntProperty"));
ASSERT_EQ(fieldIntArray->GetSize(), mesh->getNumberOfElements() * 2);
ASSERT_EQ(fieldIntArray->GetComponent(0, 0), 1.0);
range = fieldIntArray->GetRange(0);
ASSERT_EQ(range[0], 1.0);
ASSERT_EQ(range[1], mesh->getNumberOfElements() * 2);
vtkDataArray* fieldUnsignedArray = vtkDataArray::SafeDownCast(
output->GetFieldData()->GetAbstractArray("FieldUnsignedProperty"));
ASSERT_EQ(fieldUnsignedArray->GetSize(), mesh->getNumberOfElements() * 2);
ASSERT_EQ(fieldUnsignedArray->GetComponent(0, 0), 1.0);
range = fieldUnsignedArray->GetRange(0);
ASSERT_EQ(range[0], 1.0);
ASSERT_EQ(range[1], mesh->getNumberOfElements() * 2);
// -- Write VTK mesh to file (in all combinations of binary, appended and compressed)
// TODO: atm vtkXMLWriter::Ascii fails
for(int dataMode : { vtkXMLWriter::Appended, vtkXMLWriter::Binary })
{
for(bool compressed : { true, false })
{
if(dataMode == vtkXMLWriter::Ascii && compressed)
continue;
MeshLib::IO::VtuInterface vtuInterface(mesh, dataMode, compressed);
ASSERT_TRUE(vtuInterface.writeToFile(test_data_file));
// -- Read back VTK mesh
vtkSmartPointer<vtkXMLUnstructuredGridReader> reader =
vtkSmartPointer<vtkXMLUnstructuredGridReader>::New();
reader->SetFileName(test_data_file.c_str());
reader->Update();
vtkUnstructuredGrid *vtkMesh = reader->GetOutput();
// Both VTK meshes should be identical
ASSERT_EQ(vtkMesh->GetNumberOfPoints(), output->GetNumberOfPoints());
ASSERT_EQ(vtkMesh->GetNumberOfCells(), output->GetNumberOfCells());
ASSERT_EQ(vtkMesh->GetFieldData()->GetNumberOfArrays(), output->GetFieldData()->GetNumberOfArrays());
ASSERT_EQ(vtkMesh->GetPointData()->GetScalars("PointDoubleProperty")->GetNumberOfTuples(),
pointDoubleArray->GetNumberOfTuples());
ASSERT_EQ(vtkMesh->GetPointData()->GetScalars("PointIntProperty")->GetNumberOfTuples(),
pointIntArray->GetNumberOfTuples());
ASSERT_EQ(vtkMesh->GetPointData()->GetScalars("PointUnsignedProperty")->GetNumberOfTuples(),
pointUnsignedArray->GetNumberOfTuples());
ASSERT_EQ(vtkMesh->GetCellData()->GetScalars("CellDoubleProperty")->GetNumberOfTuples(),
cellDoubleArray->GetNumberOfTuples());
ASSERT_EQ(vtkMesh->GetCellData()->GetScalars("CellIntProperty")->GetNumberOfTuples(),
cellIntArray->GetNumberOfTuples());
ASSERT_EQ(vtkMesh->GetCellData()->GetScalars("CellUnsignedProperty")->GetNumberOfTuples(),
cellUnsignedArray->GetNumberOfTuples());
auto get_field_data =
[&vtkMesh](std::string const array_name) -> vtkDataArray* {
return vtkDataArray::SafeDownCast(
vtkMesh->GetFieldData()->GetAbstractArray(
array_name.c_str()));
};
ASSERT_EQ(
get_field_data("FieldDoubleProperty")->GetNumberOfTuples(),
fieldDoubleArray->GetNumberOfTuples());
ASSERT_EQ(get_field_data("FieldIntProperty")->GetNumberOfTuples(),
fieldIntArray->GetNumberOfTuples());
ASSERT_EQ(
get_field_data("FieldUnsignedProperty")->GetNumberOfTuples(),
fieldUnsignedArray->GetNumberOfTuples());
// Both OGS meshes should be identical
auto newMesh = std::unique_ptr<MeshLib::Mesh>{MeshLib::VtkMeshConverter::convertUnstructuredGrid(vtkMesh)};
ASSERT_EQ(mesh->getNumberOfNodes(), newMesh->getNumberOfNodes());
ASSERT_EQ(mesh->getNumberOfElements(), newMesh->getNumberOfElements());
// Both properties should be identical
auto meshProperties = mesh->getProperties();
auto newMeshProperties = newMesh->getProperties();
ASSERT_EQ(newMeshProperties.hasPropertyVector("PointDoubleProperty"),
meshProperties.hasPropertyVector("PointDoubleProperty"));
ASSERT_EQ(newMeshProperties.hasPropertyVector("PointIntProperty"),
meshProperties.hasPropertyVector("PointIntProperty"));
ASSERT_EQ(newMeshProperties.hasPropertyVector("PointUnsignedProperty"),
meshProperties.hasPropertyVector("PointUnsignedProperty"));
ASSERT_EQ(newMeshProperties.hasPropertyVector("CellDoubleProperty"),
meshProperties.hasPropertyVector("CellDoubleProperty"));
ASSERT_EQ(newMeshProperties.hasPropertyVector("CellIntProperty"),
meshProperties.hasPropertyVector("CellIntProperty"));
ASSERT_EQ(newMeshProperties.hasPropertyVector("CellUnsignedProperty"),
meshProperties.hasPropertyVector("CellUnsignedProperty"));
ASSERT_EQ(newMeshProperties.hasPropertyVector("FieldDoubleProperty"),
meshProperties.hasPropertyVector("FieldDoubleProperty"));
ASSERT_EQ(newMeshProperties.hasPropertyVector("FieldIntProperty"),
meshProperties.hasPropertyVector("FieldIntProperty"));
ASSERT_EQ(newMeshProperties.hasPropertyVector("FieldUnsignedProperty"),
meshProperties.hasPropertyVector("FieldUnsignedProperty"));
ASSERT_EQ(newMeshProperties.hasPropertyVector("MaterialIDs"),
meshProperties.hasPropertyVector("MaterialIDs"));
// Check some properties on equality
auto const* const doubleProps =
meshProperties.getPropertyVector<double>("PointDoubleProperty");
auto const* const newDoubleProps =
newMeshProperties.getPropertyVector<double>(
"PointDoubleProperty");
ASSERT_EQ(newDoubleProps->getNumberOfComponents(),
doubleProps->getNumberOfComponents());
ASSERT_EQ(newDoubleProps->getNumberOfTuples(),
doubleProps->getNumberOfTuples());
ASSERT_EQ(newDoubleProps->size(), doubleProps->size());
for (std::size_t i = 0; i < doubleProps->size(); i++)
ASSERT_EQ((*newDoubleProps)[i], (*doubleProps)[i]);
auto unsignedProps = meshProperties.getPropertyVector<unsigned>(
"CellUnsignedProperty");
auto newUnsignedIds = newMeshProperties.getPropertyVector<unsigned>(
"CellUnsignedProperty");
ASSERT_EQ(newUnsignedIds->getNumberOfComponents(),
unsignedProps->getNumberOfComponents());
ASSERT_EQ(newUnsignedIds->getNumberOfTuples(),
unsignedProps->getNumberOfTuples());
ASSERT_EQ(newUnsignedIds->size(), unsignedProps->size());
for (std::size_t i = 0; i < unsignedProps->size(); i++)
ASSERT_EQ((*newUnsignedIds)[i], (*unsignedProps)[i]);
{ // Field data
auto p =
meshProperties.getPropertyVector<int>("FieldIntProperty");
auto new_p = newMeshProperties.getPropertyVector<int>(
"FieldIntProperty");
ASSERT_EQ(new_p->getNumberOfComponents(),
p->getNumberOfComponents());
ASSERT_EQ(new_p->getNumberOfTuples(), p->getNumberOfTuples());
ASSERT_EQ(new_p->size(), p->size());
for (std::size_t i = 0; i < unsignedProps->size(); i++)
ASSERT_EQ((*newUnsignedIds)[i], (*unsignedProps)[i]);
}
auto const* const materialIds =
meshProperties.getPropertyVector<int>("MaterialIDs");
auto const* const newMaterialIds =
newMeshProperties.getPropertyVector<int>("MaterialIDs");
ASSERT_EQ(newMaterialIds->getNumberOfComponents(),
materialIds->getNumberOfComponents());
ASSERT_EQ(newMaterialIds->getNumberOfTuples(),
materialIds->getNumberOfTuples());
ASSERT_EQ(newMaterialIds->size(), materialIds->size());
for (std::size_t i = 0; i < materialIds->size(); i++)
ASSERT_EQ((*newMaterialIds)[i], (*materialIds)[i]);
}
}
}
void TriplesKyoto::populateHeader(Header &header, string rootNode)
{
header.insert(rootNode, HDTVocabulary::TRIPLES_TYPE, HDTVocabulary::TRIPLES_TYPE_KYOTO);
header.insert(rootNode, HDTVocabulary::TRIPLES_NUM_TRIPLES, getNumberOfElements() );
header.insert(rootNode, HDTVocabulary::TRIPLES_ORDER, getOrderStr(order) );
}
std::string ListModel::getElementAt(int position)
{
if (position > getNumberOfElements())
return "";
return elements[position];
}
std::unique_ptr<MeshLib::Mesh> appendLinesAlongPolylines(
const MeshLib::Mesh& mesh, const GeoLib::PolylineVec& ply_vec)
{
// copy existing nodes and elements
std::vector<MeshLib::Node*> vec_new_nodes = MeshLib::copyNodeVector(mesh.getNodes());
std::vector<MeshLib::Element*> vec_new_eles = MeshLib::copyElementVector(mesh.getElements(), vec_new_nodes);
auto const material_ids = materialIDs(mesh);
int const max_matID =
material_ids
? *(std::max_element(begin(*material_ids), end(*material_ids)))
: 0;
std::vector<int> new_mat_ids;
const std::size_t n_ply (ply_vec.size());
// for each polyline
for (std::size_t k(0); k < n_ply; k++)
{
const GeoLib::Polyline* ply = (*ply_vec.getVector())[k];
// search nodes on the polyline
MeshGeoToolsLib::MeshNodesAlongPolyline mshNodesAlongPoly(
mesh, *ply, mesh.getMinEdgeLength() * 0.5,
MeshGeoToolsLib::SearchAllNodes::Yes);
auto &vec_nodes_on_ply = mshNodesAlongPoly.getNodeIDs();
if (vec_nodes_on_ply.empty()) {
std::string ply_name;
ply_vec.getNameOfElementByID(k, ply_name);
INFO("No nodes found on polyline %s", ply_name.c_str());
continue;
}
// add line elements
for (std::size_t i=0; i<vec_nodes_on_ply.size()-1; i++) {
std::array<MeshLib::Node*, 2> element_nodes;
element_nodes[0] = vec_new_nodes[vec_nodes_on_ply[i]];
element_nodes[1] = vec_new_nodes[vec_nodes_on_ply[i+1]];
vec_new_eles.push_back(
new MeshLib::Line(element_nodes, vec_new_eles.size()));
new_mat_ids.push_back(max_matID+k+1);
}
}
// generate a mesh
const std::string name = mesh.getName() + "_with_lines";
auto new_mesh =
std::make_unique<MeshLib::Mesh>(name, vec_new_nodes, vec_new_eles);
auto new_material_ids =
new_mesh->getProperties().createNewPropertyVector<int>(
"MaterialIDs", MeshLib::MeshItemType::Cell);
if (!new_material_ids)
{
OGS_FATAL("Could not create MaterialIDs cell vector in new mesh.");
}
new_material_ids->reserve(new_mesh->getNumberOfElements());
if (material_ids != nullptr)
{
std::copy(begin(*material_ids), end(*material_ids),
std::back_inserter(*new_material_ids));
}
else
{
new_material_ids->resize(mesh.getNumberOfElements());
}
std::copy(begin(new_mat_ids), end(new_mat_ids),
std::back_inserter(*new_material_ids));
return new_mesh;
}
std::string ExtendedNamesModel::getElementAt(int i)
{
if (i >= getNumberOfElements() || i < 0)
return "???";
return mNames[CAST_SIZE(i)];
}
std::string getElementAt(int i)
{
if (i >= getNumberOfElements() || i < 0)
return "???";
return gettext(SORT_NAME_BUY[i]);
}
std::string getElementAt(int i) override final
{
if (i >= getNumberOfElements() || i < 0)
return "";
return gettext(RELATION_NAMES[i]);
}
std::string ColorModel::getElementAt(int i)
{
if (i >= getNumberOfElements() || i < 0)
return "???";
return mNames[i];
}
int size(){ return getNumberOfElements(); }
