int main(int argc, char * argv[])
{
CGAL::Timer task_timer;
task_timer.start();
const char* mesh_filename = (argc>1) ? argv[1] : "data/bear.off";
std::ifstream in_mesh(mesh_filename);
if(!in_mesh) {
std::cerr << "Error: problem loading the input data" << std::endl;
return 1;
}
SurfaceMesh sm; // underlying mesh of the seam mesh
in_mesh >> sm;
// Selection file that contains the cones and possibly the path between cones
// -- the first line for the cones indices
// -- the second line must be empty
// -- the third line optionally provides the seam edges indices as 'e11 e12 e21 e22 e31 e32' etc.
const char* cone_filename = (argc>2) ? argv[2] : "data/bear.selection.txt";
// Read the cones and compute their corresponding vertex_descriptor in the underlying mesh 'sm'
std::vector<SM_vertex_descriptor> cone_sm_vds;
SMP::read_cones<SurfaceMesh>(sm, cone_filename, std::back_inserter(cone_sm_vds));
// Two property maps to store the seam edges and vertices
Seam_edge_pmap seam_edge_pm = sm.add_property_map<SM_edge_descriptor, bool>("e:on_seam", false).first;
Seam_vertex_pmap seam_vertex_pm = sm.add_property_map<SM_vertex_descriptor, bool>("v:on_seam",false).first;
// The seam mesh
Mesh mesh(sm, seam_edge_pm, seam_vertex_pm);
// If provided, use the path between cones to create a seam mesh
SM_halfedge_descriptor smhd = mesh.add_seams(cone_filename);
// If not provided, compute the paths using shortest paths
if(smhd == SM_halfedge_descriptor() ) {
std::cout << "No seams given in input, computing the shortest paths between consecutive cones" << std::endl;
std::list<SM_edge_descriptor> seam_edges;
SMP::compute_shortest_paths_between_cones(sm, cone_sm_vds.begin(), cone_sm_vds.end(), seam_edges);
// Add the seams to the seam mesh
BOOST_FOREACH(SM_edge_descriptor e, seam_edges) {
mesh.add_seam(source(e, sm), target(e, sm));
}
int main(int argc, char * argv[])
{
std::ifstream in_mesh((argc>1)?argv[1]:"data/lion.off");
if(!in_mesh) {
std::cerr << "Error: problem loading the input data" << std::endl;
return 1;
}
PolyMesh sm;
in_mesh >> sm;
// Two property maps to store the seam edges and vertices
Seam_edge_uhm seam_edge_uhm(false);
Seam_edge_pmap seam_edge_pm(seam_edge_uhm);
Seam_vertex_uhm seam_vertex_uhm(false);
Seam_vertex_pmap seam_vertex_pm(seam_vertex_uhm);
Mesh mesh(sm, seam_edge_pm, seam_vertex_pm);
const char* filename = (argc>2) ? argv[2] : "data/lion.selection.txt";
SM_halfedge_descriptor smhd = mesh.add_seams(filename);
if(smhd == SM_halfedge_descriptor() ) {
std::cerr << "Warning: No seams in input" << std::endl;
}
// The 2D points of the uv parametrisation will be written into this map
// Note that this is a halfedge property map, and that uv values
// are only stored for the canonical halfedges representing a vertex
UV_uhm uv_uhm;
UV_pmap uv_pm(uv_uhm);
// A halfedge on the (possibly virtual) border
halfedge_descriptor bhd = CGAL::Polygon_mesh_processing::longest_border(mesh).first;
SMP::parameterize(mesh, bhd, uv_pm);
std::ofstream out("result.off");
SMP::IO::output_uvmap_to_off(mesh, bhd, uv_pm, out);
return 0;
}
int main(int argc, char* argv[])
{
ApplicationsLib::LogogSetup logo_setup;
TCLAP::CmdLine cmd(
"Integrates the given element property and outputs an OGS-5 direct "
"Neumann boundary condition. The mesh has to contain a property "
"'bulk_node_ids' that stores the original subsurface "
"mesh node ids. Such surface meshes can be created using the OGS-6 "
"tool ExtractSurface.\n\n"
"OpenGeoSys-6 software, version " +
BaseLib::BuildInfo::git_describe +
".\n"
"Copyright (c) 2012-2019, OpenGeoSys Community "
"(http://www.opengeosys.org)",
' ', BaseLib::BuildInfo::git_describe);
TCLAP::ValueArg<std::string> in_mesh("i",
"in-mesh",
"the surface mesh that has an element "
"property for the Neumann "
"boundary condition",
true,
"",
"filename for surface mesh input");
cmd.add(in_mesh);
TCLAP::ValueArg<std::string> property_in_arg(
"p",
"property-in-name",
"name of an element property used for the computation of the "
"Neumann boundary condition",
true,
"",
"string (property name)");
cmd.add(property_in_arg);
TCLAP::ValueArg<std::string> property_out_arg(
"",
"property-out-name",
"name of the node based property used for the output of the "
"Neumann boundary condition",
true,
"",
"string (property name)");
cmd.add(property_out_arg);
TCLAP::ValueArg<std::string> result_file(
"o",
"result-out",
"the file name the result will be written to ",
true,
"",
"output file name");
cmd.add(result_file);
cmd.parse( argc, argv );
// read surface mesh
std::unique_ptr<MeshLib::Mesh> surface_mesh(
MeshLib::IO::readMeshFromFile(in_mesh.getValue()));
auto const* const node_id_pv =
[&]() -> MeshLib::PropertyVector<std::size_t>* {
try
{
return surface_mesh->getProperties().getPropertyVector<std::size_t>(
"bulk_node_ids", MeshLib::MeshItemType::Node, 1);
}
catch (std::runtime_error const& e)
{
WARN("%s", e.what());
return nullptr;
}
}();
if (!node_id_pv)
return EXIT_FAILURE;
std::vector<double> integrated_values = getSurfaceIntegratedValuesForNodes(
*surface_mesh, property_in_arg.getValue());
std::vector<std::pair<std::size_t, double>> direct_values;
direct_values.reserve(surface_mesh->getNumberOfNodes());
for (auto const* node : surface_mesh->getNodes())
{
auto const id(node->getID());
auto const subsurface_node_id((*node_id_pv)[id]);
auto const val(integrated_values[id]);
direct_values.push_back(std::make_pair(subsurface_node_id, val));
}
auto* const pv =
surface_mesh->getProperties().createNewPropertyVector<double>(
property_out_arg.getValue(), MeshLib::MeshItemType::Node, 1);
pv->resize(surface_mesh->getNodes().size());
for (std::size_t k(0); k < surface_mesh->getNodes().size(); ++k)
{
(*pv)[k] = direct_values[k].second;
}
MeshLib::IO::writeMeshToFile(*surface_mesh, result_file.getValue());
std::ofstream result_out(result_file.getValue() + ".txt");
result_out.precision(std::numeric_limits<double>::digits10);
for (auto const& p : direct_values)
result_out << p.first << " " << p.second << "\n";
return EXIT_SUCCESS;
}
