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; }