void GeoTreeView::mapGeometry()
{
TreeItem* item = static_cast<GeoTreeModel*>(model())->getItem(
this->selectionModel()->currentIndex());
std::string geo_name (item->data(0).toString().toStdString());
emit geometryMappingRequested(geo_name);
}
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("Add EMI data as a scalar cell array to a 2d mesh.", ' ', "0.1");
// I/O params
TCLAP::ValueArg<std::string> poly_out("o", "polydata-output-file",
"the name of the file the data will be written to", true,
"", "file name of polydata file");
cmd.add(poly_out);
TCLAP::ValueArg<std::string> csv_in("i", "csv-input-file",
"csv-file containing EMI data", true,
"", "name of the csv input file");
cmd.add(csv_in);
TCLAP::ValueArg<std::string> dem_in("s", "DEM-file",
"Surface DEM for mapping ERT data", false,
"", "file name of the Surface DEM");
cmd.add(dem_in);
cmd.parse(argc, argv);
MeshLib::Mesh* mesh (nullptr);
if (dem_in.isSet())
{
mesh = FileIO::VtuInterface::readVTUFile(dem_in.getValue());
if (mesh == nullptr)
{
ERR ("Error reading mesh file.");
return -2;
}
if (mesh->getDimension() != 2)
{
ERR ("This utility can handle only 2d meshes at this point.");
delete mesh;
return -3;
}
INFO("Surface mesh read: %d nodes, %d elements.", mesh->getNNodes(), mesh->getNElements());
}
GeoLib::GEOObjects geo_objects;
FileIO::XmlGmlInterface xml(geo_objects);
//std::vector<GeoLib::Polyline*> *lines = new std::vector<GeoLib::Polyline*>;
std::array<char, 2> dipol = {{ 'H', 'V' }};
std::array<char,3> const regions = {{'A', 'B', 'C'}};
for (std::size_t j=0; j<dipol.size(); ++j)
{
std::vector<GeoLib::Point*> *points = new std::vector<GeoLib::Point*>;
for (std::size_t i=0; i<regions.size(); ++i)
{
//std::size_t const start_idx (points->size());
getPointsFromFile(*points, csv_in.getValue(), dipol[j], regions[i]);
//std::size_t const end_idx (points->size());
//GeoLib::Polyline* line = new GeoLib::Polyline(*points);
//for (std::size_t j=start_idx; j<end_idx; ++j)
// line->addPoint(j);
//lines->push_back(line);
}
std::string geo_name (std::string("EMI Data ").append(1,dipol[j]));
geo_objects.addPointVec(points, geo_name);
//geo_objects.addPolylineVec(lines, geo_name);
if (mesh != nullptr)
{
GeoMapper mapper(geo_objects, geo_name);
mapper.mapOnMesh(mesh);
}
xml.setNameForExport(geo_name);
std::string const output_name = poly_out.getValue() + "_" + dipol[j] + ".gml";
xml.writeToFile(output_name);
std::vector<double> emi;
for (std::size_t i=0; i<regions.size(); ++i)
getMeasurements(emi, csv_in.getValue(), dipol[j], regions[i]);
writeMeasurementsToFile(emi, poly_out.getValue(), dipol[j]);
std::for_each(points->begin(), points->end(), std::default_delete<GeoLib::Point>());
delete points;
}
delete mesh;
delete custom_format;
delete logog_cout;
LOGOG_SHUTDOWN();
return 0;
}
int main (int argc, char* argv[])
{
ApplicationsLib::LogogSetup logog_setup;
TCLAP::CmdLine cmd(
"Creates boundary conditions for mesh nodes along polylines."
"The documentation is available at https://docs.opengeosys.org/docs/tools/model-preparation/create-boundary-conditions-along-a-polyline",
' ',
"0.1");
TCLAP::ValueArg<bool> gml_arg("", "gml",
"if switched on write found nodes to file in gml format", false, 0, "bool");
cmd.add(gml_arg);
TCLAP::ValueArg<std::string> output_base_fname("o", "output-base-file-name",
"the base name of the file the output (geometry (gli) and boundary"\
"condition (bc)) will be written to", true,
"", "file name");
cmd.add(output_base_fname);
TCLAP::ValueArg<std::string> bc_type("t", "type",
"the process type the boundary condition will be written for "\
"currently LIQUID_FLOW (primary variable PRESSURE1) and "\
"GROUNDWATER_FLOW (primary variable HEAD, default) are supported", true,
"",
"process type as string (LIQUID_FLOW or GROUNDWATER_FLOW (default))");
cmd.add(bc_type);
TCLAP::ValueArg<double> search_length_arg("s", "search-length",
"The size of the search length. The default value is "
"std::numeric_limits<double>::epsilon()", false,
std::numeric_limits<double>::epsilon(), "floating point number");
cmd.add(search_length_arg);
TCLAP::ValueArg<std::string> geometry_fname("i", "input-geometry",
"the name of the file containing the input geometry", true,
"", "file name");
cmd.add(geometry_fname);
TCLAP::ValueArg<std::string> mesh_arg("m", "mesh-file",
"the name of the file containing the mesh", true,
"", "file name");
cmd.add(mesh_arg);
cmd.parse(argc, argv);
// *** read mesh
INFO("Reading mesh \"%s\" ... ", mesh_arg.getValue().c_str());
MeshLib::Mesh * subsurface_mesh(FileIO::readMeshFromFile(mesh_arg.getValue()));
INFO("done.");
INFO("Extracting top surface of mesh \"%s\" ... ",
mesh_arg.getValue().c_str());
const MathLib::Vector3 dir(0,0,-1);
double const angle(90);
std::unique_ptr<MeshLib::Mesh> surface_mesh(
MeshLib::MeshSurfaceExtraction::getMeshSurface(*subsurface_mesh, dir,
angle));
INFO("done.");
delete subsurface_mesh;
subsurface_mesh = nullptr;
// *** read geometry
GeoLib::GEOObjects geometries;
FileIO::readGeometryFromFile(geometry_fname.getValue(), geometries);
std::string geo_name;
{
std::vector<std::string> geo_names;
geometries.getGeometryNames(geo_names);
geo_name = geo_names[0];
}
// *** check if the data is usable
// *** get vector of polylines
std::vector<GeoLib::Polyline*> const* plys(geometries.getPolylineVec(geo_name));
if (!plys) {
ERR("Could not get vector of polylines out of geometry \"%s\".",
geo_name.c_str());
return -1;
}
MeshGeoToolsLib::SearchLength search_length_strategy;
if (search_length_arg.isSet()) {
search_length_strategy =
MeshGeoToolsLib::SearchLength(search_length_arg.getValue());
}
GeoLib::GEOObjects geometry_sets;
MeshGeoToolsLib::MeshNodeSearcher mesh_searcher(*surface_mesh,
search_length_strategy);
for(std::size_t k(0); k<plys->size(); k++) {
std::vector<std::size_t> ids
(mesh_searcher.getMeshNodeIDsAlongPolyline(*((*plys)[k])));
if (ids.empty())
continue;
std::string geo_name("Polyline-"+std::to_string(k));
convertMeshNodesToGeometry(surface_mesh->getNodes(), ids, geo_name,
geometry_sets);
}
// merge all together
std::vector<std::string> geo_names;
geometry_sets.getGeometryNames(geo_names);
if (geo_names.empty()) {
ERR("Did not find mesh nodes along polylines.");
return -1;
}
std::string merge_name("AllMeshNodesAlongPolylines");
if (geometry_sets.mergeGeometries(geo_names, merge_name) == 2)
merge_name = geo_names[0];
GeoLib::PointVec const* pnt_vec(geometry_sets.getPointVecObj(merge_name));
std::vector<GeoLib::Point*> const* merged_pnts(pnt_vec->getVector());
std::vector<GeoLib::Point> pnts_with_id;
const std::size_t n_merged_pnts(merged_pnts->size());
for(std::size_t k(0); k<n_merged_pnts; ++k) {
pnts_with_id.emplace_back(*((*merged_pnts)[k]), k);
}
std::sort(pnts_with_id.begin(), pnts_with_id.end(),
[](GeoLib::Point const& p0, GeoLib::Point const& p1)
{ return p0 < p1; }
);
double const eps (std::numeric_limits<double>::epsilon());
auto surface_pnts = std::unique_ptr<std::vector<GeoLib::Point*>>(
new std::vector<GeoLib::Point*>);
std::map<std::string, std::size_t> *name_id_map(
new std::map<std::string, std::size_t>
);
// insert first point
surface_pnts->push_back(
new GeoLib::Point(pnts_with_id[0], surface_pnts->size()));
std::string element_name;
pnt_vec->getNameOfElementByID(0, element_name);
name_id_map->insert(
std::pair<std::string, std::size_t>(element_name,0)
);
for (std::size_t k(1); k < n_merged_pnts; ++k) {
const GeoLib::Point& p0 (pnts_with_id[k-1]);
const GeoLib::Point& p1 (pnts_with_id[k]);
if (std::abs (p0[0] - p1[0]) > eps || std::abs (p0[1] - p1[1]) > eps) {
surface_pnts->push_back(new GeoLib::Point(pnts_with_id[k],
surface_pnts->size()));
std::string element_name;
pnt_vec->getNameOfElementByID(k, element_name);
name_id_map->insert(
std::pair<std::string, std::size_t>(element_name,
surface_pnts->size()-1)
);
}
}
std::string surface_name(BaseLib::dropFileExtension(mesh_arg.getValue())+"-MeshNodesAlongPolylines");
geometry_sets.addPointVec(std::move(surface_pnts), surface_name, name_id_map, 1e-6);
// write the BCs and the merged geometry set to file
std::string const base_fname(
BaseLib::dropFileExtension(output_base_fname.getValue()));
writeBCsAndGeometry(geometry_sets, surface_name, base_fname,
bc_type.getValue(), gml_arg.getValue());
return 0;
}
TEST(FileIO, XmlGmlWriterReaderTest)
{
// Writer test
std::string test_data_file(BaseLib::BuildInfo::source_path + "/Tests/FileIO/xmlgmltestdata.gml");
GeoLib::GEOObjects geo_objects;
//setup test data
std::string geo_name("TestData");
{ // Create points.
auto points = std::unique_ptr<std::vector<GeoLib::Point*>>(
new std::vector<GeoLib::Point*>(10));
(*points)[0] = new GeoLib::Point(1, 1, 0);
(*points)[1] = new GeoLib::Point(1, 1, 0);
(*points)[2] = new GeoLib::Point(1, 2, 0);
(*points)[3] = new GeoLib::Point(1, 3, 0);
(*points)[4] = new GeoLib::Point(2, 1, 0);
(*points)[5] = new GeoLib::Point(2, 2, 0);
(*points)[6] = new GeoLib::Point(2, 3, 0);
(*points)[7] = new GeoLib::Point(3, 1, 0);
(*points)[8] = new GeoLib::Point(3, 2, 0);
(*points)[9] = new GeoLib::Point(3, 3, 0);
geo_objects.addPointVec(std::move(points), geo_name);
}
auto const points = geo_objects.getPointVec(geo_name);
const std::vector<std::size_t> pnt_id_map (geo_objects.getPointVecObj(geo_name)->getIDMap());
{ // Create polylines.
auto lines = std::unique_ptr<std::vector<GeoLib::Polyline*>>(
new std::vector<GeoLib::Polyline*>(5));
std::map<std::string, std::size_t>* ply_names =
new std::map<std::string, std::size_t>;
(*lines)[0] = new GeoLib::Polyline(*points);
(*lines)[0]->addPoint(pnt_id_map[0]);
(*lines)[0]->addPoint(pnt_id_map[2]);
(*lines)[0]->addPoint(pnt_id_map[3]);
ply_names->insert(std::pair<std::string, std::size_t>("left", 0));
(*lines)[1] = new GeoLib::Polyline(*points);
(*lines)[1]->addPoint(pnt_id_map[4]);
(*lines)[1]->addPoint(pnt_id_map[5]);
(*lines)[1]->addPoint(pnt_id_map[6]);
ply_names->insert(std::pair<std::string, std::size_t>("center", 1));
(*lines)[2] = new GeoLib::Polyline(*points);
(*lines)[2]->addPoint(pnt_id_map[1]);
(*lines)[2]->addPoint(pnt_id_map[4]);
(*lines)[3] = new GeoLib::Polyline(*points);
(*lines)[3]->addPoint(pnt_id_map[4]);
(*lines)[3]->addPoint(pnt_id_map[7]);
(*lines)[4] = new GeoLib::Polyline(*points);
(*lines)[4]->addPoint(pnt_id_map[7]);
(*lines)[4]->addPoint(pnt_id_map[8]);
(*lines)[4]->addPoint(pnt_id_map[9]);
ply_names->insert(std::pair<std::string, std::size_t>("right", 4));
geo_objects.addPolylineVec(std::move(lines), geo_name, ply_names);
}
{ // Create surfaces.
auto sfcs = std::unique_ptr<std::vector<GeoLib::Surface*>>(
new std::vector<GeoLib::Surface*>(2));
(*sfcs)[0] = new GeoLib::Surface(*points);
(*sfcs)[0]->addTriangle(pnt_id_map[1], pnt_id_map[4], pnt_id_map[2]);
(*sfcs)[0]->addTriangle(pnt_id_map[2], pnt_id_map[4], pnt_id_map[5]);
(*sfcs)[0]->addTriangle(pnt_id_map[2], pnt_id_map[5], pnt_id_map[3]);
(*sfcs)[0]->addTriangle(pnt_id_map[3], pnt_id_map[5], pnt_id_map[6]);
(*sfcs)[1] = new GeoLib::Surface(*points);
(*sfcs)[1]->addTriangle(pnt_id_map[4], pnt_id_map[7], pnt_id_map[9]);
(*sfcs)[1]->addTriangle(pnt_id_map[4], pnt_id_map[9], pnt_id_map[6]);
geo_objects.addSurfaceVec(std::move(sfcs), geo_name);
}
FileIO::XmlGmlInterface xml(geo_objects);
xml.setNameForExport(geo_name);
int result = xml.writeToFile(test_data_file);
ASSERT_EQ(result, 1);
// Reader test
result = xml.readFile(QString::fromStdString(test_data_file));
ASSERT_EQ(result, 1);
const std::vector<GeoLib::Point*> *readerPoints = geo_objects.getPointVec(geo_name);
const GeoLib::PolylineVec *line_vec = geo_objects.getPolylineVecObj(geo_name);
const std::vector<GeoLib::Polyline*> *readerLines = geo_objects.getPolylineVec(geo_name);
const std::vector<GeoLib::Surface*> *readerSfcs = geo_objects.getSurfaceVec(geo_name);
ASSERT_EQ(9u, readerPoints->size());
ASSERT_EQ(5u, readerLines->size());
ASSERT_EQ(2u, readerSfcs->size());
GeoLib::Point* pnt = (*readerPoints)[7];
ASSERT_EQ(3.0, (*pnt)[0]);
ASSERT_EQ(2.0, (*pnt)[1]);
ASSERT_EQ(0.0, (*pnt)[2]);
GeoLib::Polyline* line = (*readerLines)[4];
ASSERT_EQ(3u, line->getNumberOfPoints());
ASSERT_EQ(6u, line->getPointID(0));
ASSERT_EQ(7u, line->getPointID(1));
ASSERT_EQ(8u, line->getPointID(2));
std::string line_name("");
line_vec->getNameOfElementByID(4, line_name);
ASSERT_EQ("right", line_name);
GeoLib::Surface* sfc = (*readerSfcs)[1];
ASSERT_EQ(2u, sfc->getNTriangles());
const GeoLib::Triangle* tri = (*sfc)[1];
ASSERT_EQ(3u, (*tri)[0]);
ASSERT_EQ(8u, (*tri)[1]);
ASSERT_EQ(5u, (*tri)[2]);
boost::filesystem::remove(test_data_file);
test_data_file += ".md5";
boost::filesystem::remove(test_data_file);
}