songsenand
/
cgal
mirror of https://github.com/CGAL/cgal
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

update the usage for the new CGAL named function parameters

This commit is contained in:
Sébastien Loriot 2019-07-28 22:30:17 +02:00
parent 2f81a21523
commit aa47744c36
13 changed files with 143 additions and 129 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

39
BGL/include/CGAL/boost/graph/io.h
View File

@ -56,9 +56,12 @@ bool write_wrl(std::ostream& os,
typedef typename boost::graph_traits<FaceGraph>::face_descriptor face_descriptor;
typedef typename boost::graph_traits<FaceGraph>::vertices_size_type vertices_size_type;
using parameters::get_parameter;
using parameters::choose_parameter;
typename Polygon_mesh_processing::GetVertexPointMap<FaceGraph, NamedParameters>::const_type
vpm = choose_param(get_param(np, internal_np::vertex_point),
get_const_property_map(CGAL::vertex_point, g));
vpm = choose_parameter(get_parameter(np, internal_np::vertex_point),
get_const_property_map(CGAL::vertex_point, g));
boost::container::flat_map<vertex_descriptor,vertices_size_type> reindex;
int n = 0;
@ -148,7 +151,7 @@ bool write_off(std::ostream& os,
typename Polygon_mesh_processing::GetVertexPointMap<FaceGraph, NamedParameters>::const_type
vpm = choose_parameter(get_parameter(np, internal_np::vertex_point),
get_const_property_map(CGAL::vertex_point, g));
get_const_property_map(CGAL::vertex_point, g));
vertices_size_type nv = static_cast<vertices_size_type>(std::distance(vertices(g).first, vertices(g).second));
faces_size_type nf = static_cast<faces_size_type>(std::distance(faces(g).first, faces(g).second));
@ -273,7 +276,7 @@ bool read_off(std::istream& is,
typedef typename boost::property_traits<Vpm>::value_type Point_3;
Vpm vpm = choose_parameter(get_parameter(np, internal_np::vertex_point),
get_property_map(CGAL::vertex_point, g));
get_property_map(CGAL::vertex_point, g));
vertices_size_type nv, nvf;
faces_size_type nf;
int ignore;
@ -379,7 +382,7 @@ bool write_inp(std::ostream& os,
using parameters::get_parameter;
VPM vpm = choose_parameter(get_parameter(np, internal_np::vertex_point),
get_const_property_map(CGAL::vertex_point, g));
get_const_property_map(CGAL::vertex_point, g));
os << "*Part, name=" << name << "\n*Node\n";
boost::container::flat_map<vertex_descriptor,vertices_size_type> reindex;
@ -425,8 +428,10 @@ write_polys(std::ostream& os,
typedef typename boost::graph_traits<Mesh>::vertex_descriptor vertex_descriptor;
typedef typename boost::graph_traits<Mesh>::face_iterator face_iterator;
typedef typename CGAL::Polygon_mesh_processing::GetVertexIndexMap<Mesh, NamedParameters>::type Vimap;
Vimap V = choose_param(get_param(np, CGAL::internal_np::vertex_index),
get_const_property_map(CGAL::internal_np::vertex_index, mesh));
using parameters::get_parameter;
using parameters::choose_parameter;
Vimap V = choose_parameter(get_parameter(np, internal_np::vertex_index),
get_const_property_map(boost::vertex_index, mesh));
std::vector<std::size_t> connectivity_table;
std::vector<std::size_t> offsets;
@ -460,8 +465,10 @@ write_polys_tag(std::ostream& os,
typedef typename boost::graph_traits<Mesh>::vertex_descriptor vertex_descriptor;
typedef typename boost::graph_traits<Mesh>::face_iterator face_iterator;
typedef typename CGAL::Polygon_mesh_processing::GetVertexIndexMap<Mesh, NamedParameters>::type Vimap;
Vimap V = choose_param(get_param(np, CGAL::internal_np::vertex_index),
get_const_property_map(CGAL::internal_np::vertex_index, mesh));
using parameters::get_parameter;
using parameters::choose_parameter;
Vimap V = choose_parameter(get_parameter(np, internal_np::vertex_index),
get_const_property_map(boost::vertex_index, mesh));
std::string formatattribute =
binary ? " format=\"appended\"" : " format=\"ascii\"";
@ -549,8 +556,10 @@ write_points_tag(std::ostream& os,
{
typedef typename boost::graph_traits<Mesh>::vertex_iterator vertex_iterator;
typedef typename CGAL::Polygon_mesh_processing::GetVertexPointMap<Mesh, NamedParameters>::const_type Vpmap;
Vpmap vpm = choose_param(get_param(np, CGAL::vertex_point),
get_const_property_map(CGAL::vertex_point, mesh));
using parameters::get_parameter;
using parameters::choose_parameter;
Vpmap vpm = choose_parameter(get_parameter(np, internal_np::vertex_point),
get_const_property_map(CGAL::vertex_point, mesh));
typedef typename boost::property_traits<Vpmap>::value_type Point_t;
typedef typename CGAL::Kernel_traits<Point_t>::Kernel Gt;
typedef typename Gt::FT FT;
@ -592,8 +601,10 @@ write_polys_points(std::ostream& os,
{
typedef typename boost::graph_traits<Mesh>::vertex_iterator vertex_iterator;
typedef typename CGAL::Polygon_mesh_processing::GetVertexPointMap<Mesh, NamedParameters>::const_type Vpmap;
Vpmap vpm = choose_param(get_param(np, CGAL::vertex_point),
get_const_property_map(CGAL::vertex_point, mesh));
using parameters::get_parameter;
using parameters::choose_parameter;
Vpmap vpm = choose_parameter(get_parameter(np, internal_np::vertex_point),
get_const_property_map(CGAL::vertex_point, mesh));
typedef typename boost::property_traits<Vpmap>::value_type Point_t;
typedef typename CGAL::Kernel_traits<Point_t>::Kernel Gt;
typedef typename Gt::FT FT;
@ -662,7 +673,7 @@ void write_vtp(std::ostream& os,
os << " <Piece NumberOfPoints=\"" << num_vertices(mesh)
<< "\" NumberOfPolys=\"" << num_faces(mesh) << "\">\n";
std::size_t offset = 0;
const bool binary = boost::choose_param(boost::get_param(np, internal_np::use_binary_mode), true);
const bool binary = parameters::choose_parameter(parameters::get_parameter(np, internal_np::use_binary_mode), true);
internal::write_vtp::write_points_tag(os,mesh,binary,offset, np);
internal::write_vtp::write_polys_tag(os,mesh,binary,offset, np);
os << " </Piece>\n"

4
BGL/include/CGAL/boost/graph/named_params_helper.h
View File

@ -331,7 +331,7 @@ namespace CGAL {
>::Kernel Default_kernel;
public:
typedef typename boost::lookup_named_param_def <
typedef typename internal_np::Lookup_named_param_def <
internal_np::geom_traits_t,
NamedParameters,
Default_kernel
@ -421,7 +421,7 @@ namespace CGAL {
public:
typedef DummyConstrainedMap NoMap;
typedef typename boost::lookup_named_param_def <
typedef typename internal_np::Lookup_named_param_def <
internal_np::point_is_constrained_t,
NamedParameters,
DummyConstrainedMap //default

2
Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/clip.h
View File

@ -334,7 +334,7 @@ clip( TriangleMesh& tm,
const NamedParameters2& np_c)
{
const bool clip_volume =
boost::choose_parameter(boost::get_parameter(np_tm, internal_np::clip_volume), false);
parameters::choose_parameter(parameters::get_parameter(np_tm, internal_np::clip_volume), false);
if (clip_volume && is_closed(tm))
return corefine_and_compute_intersection(tm, clipper, tm, np_tm, np_c);

4
Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/corefinement.h
View File

@ -564,7 +564,7 @@ corefine_and_compute_boolean_operations(
vpm_out_tuple, ecms_out, uv, output);
// special case used for clipping open meshes
if ( boost::choose_param( boost::get_param(np1, internal_np::use_bool_op_to_clip_surface),
if ( parameters::choose_parameter( parameters::get_parameter(np1, internal_np::use_bool_op_to_clip_surface),
false) )
{
CGAL_assertion(output[Corefinement::INTERSECTION] != boost::none);
@ -572,7 +572,7 @@ corefine_and_compute_boolean_operations(
CGAL_assertion(output[Corefinement::TM1_MINUS_TM2] == boost::none);
CGAL_assertion(output[Corefinement::TM2_MINUS_TM1] == boost::none);
const bool use_compact_clipper =
boost::choose_param( boost::get_param(np1, internal_np::use_compact_clipper),
parameters::choose_parameter( parameters::get_parameter(np1, internal_np::use_compact_clipper),
true);
ob.setup_for_clipping_a_surface(use_compact_clipper);
}

7
Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/merge_border_vertices.h
View File

@ -218,8 +218,11 @@ void merge_duplicated_vertices_in_boundary_cycle(
typedef typename boost::graph_traits<PolygonMesh>::halfedge_descriptor halfedge_descriptor;
typedef typename GetVertexPointMap<PolygonMesh, NamedParameter>::const_type Vpm;
Vpm vpm = choose_param(get_param(np, internal_np::vertex_point),
get_const_property_map(vertex_point, pm));
using parameters::get_parameter;
using parameters::choose_parameter;
Vpm vpm = choose_parameter(get_parameter(np, internal_np::vertex_point),
get_const_property_map(vertex_point, pm));
// collect all the halfedges of the cycle
std::vector< std::pair<halfedge_descriptor, std::size_t> > cycle_hedges;

4
Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/remesh.h
View File

@ -163,7 +163,7 @@ void isotropic_remeshing(const FaceRange& faces
parameters::is_default_parameter(get_parameter(np, internal_np::projection_functor));
typedef typename GetGeomTraits<PM, NamedParameters>::type GT;
GT gt = choose_param(get_param(np, internal_np::geom_traits), GT());
GT gt = choose_parameter(get_parameter(np, internal_np::geom_traits), GT());
typedef typename GetVertexPointMap<PM, NamedParameters>::type VPMap;
VPMap vpmap = choose_parameter(get_parameter(np, internal_np::vertex_point),
@ -341,7 +341,7 @@ void split_long_edges(const EdgeRange& edges
using parameters::get_parameter;
typedef typename GetGeomTraits<PM, NamedParameters>::type GT;
GT gt = choose_param(get_param(np, internal_np::geom_traits), GT());
GT gt = choose_parameter(get_parameter(np, internal_np::geom_traits), GT());
typedef typename GetVertexPointMap<PM, NamedParameters>::type VPMap;
VPMap vpmap = choose_parameter(get_parameter(np, internal_np::vertex_point),

18
Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/repair.h
View File

@ -1784,18 +1784,18 @@ std::size_t make_umbrella_manifold(typename boost::graph_traits<PolygonMesh>::ha
typedef typename boost::graph_traits<PolygonMesh>::vertex_descriptor vertex_descriptor;
typedef typename boost::graph_traits<PolygonMesh>::halfedge_descriptor halfedge_descriptor;
using boost::get_param;
using boost::choose_param;
using parameters::get_parameter;
using parameters::choose_parameter;
typedef typename GetVertexPointMap<PolygonMesh, NamedParameters>::type VertexPointMap;
VertexPointMap vpm = choose_param(get_param(np, internal_np::vertex_point),
VertexPointMap vpm = choose_parameter(get_parameter(np, internal_np::vertex_point),
get_property_map(vertex_point, pm));
typedef typename boost::lookup_named_param_def<internal_np::vertex_is_constrained_t,
typedef typename internal_np::Lookup_named_param_def<internal_np::vertex_is_constrained_t,
NamedParameters,
Constant_property_map<vertex_descriptor, bool> // default (no constraint pmap)
>::type VerticesMap;
VerticesMap cmap = choose_param(get_param(np, internal_np::vertex_is_constrained),
VerticesMap cmap = choose_parameter(get_parameter(np, internal_np::vertex_is_constrained),
Constant_property_map<vertex_descriptor, bool>(false));
std::size_t nb_new_vertices = 0;
@ -1916,20 +1916,20 @@ template <typename PolygonMesh, typename NamedParameters>
std::size_t duplicate_non_manifold_vertices(PolygonMesh& pm,
const NamedParameters& np)
{
using boost::get_param;
using boost::choose_param;
using parameters::get_parameter;
using parameters::choose_parameter;
typedef boost::graph_traits<PolygonMesh> GT;
typedef typename GT::vertex_descriptor vertex_descriptor;
typedef typename GT::halfedge_descriptor halfedge_descriptor;
typedef typename boost::lookup_named_param_def <
typedef typename internal_np::Lookup_named_param_def <
internal_np::output_iterator_t,
NamedParameters,
Emptyset_iterator
> ::type Output_iterator;
Output_iterator out
= choose_param(get_param(np, internal_np::output_iterator),
= choose_parameter(get_parameter(np, internal_np::output_iterator),
Emptyset_iterator());
internal::Vertex_collector<PolygonMesh> dmap;

26
Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/repair_polygon_soup.h
View File

@ -23,7 +23,7 @@
#include <CGAL/license/Polygon_mesh_processing/repair.h>
#include <CGAL/boost/graph/named_function_params.h>
#include <CGAL/boost/graph/Named_function_parameters.h>
#include <CGAL/Polygon_mesh_processing/internal/named_function_params.h>
#include <CGAL/Polygon_mesh_processing/internal/named_params_helper.h>
@ -69,7 +69,7 @@ struct Polygon_types
template <typename PointRange, typename PolygonRange, typename NamedParameters>
struct GetPolygonGeomTraits
{
typedef typename boost::lookup_named_param_def <
typedef typename internal_np::Lookup_named_param_def <
internal_np::geom_traits_t,
NamedParameters,
typename CGAL::Kernel_traits<
@ -517,11 +517,11 @@ std::size_t merge_duplicate_points_in_polygon_soup(PointRange& points,
typedef typename internal::Polygon_types<PointRange, PolygonRange>::Point_3 Point_3;
typedef typename internal::Polygon_types<PointRange, PolygonRange>::Polygon_3 Polygon_3;
using boost::get_param;
using boost::choose_param;
using parameters::get_parameter;
using parameters::choose_parameter;
typedef typename internal::GetPolygonGeomTraits<PointRange, PolygonRange, NamedParameters>::type Traits;
Traits traits = choose_param(get_param(np, internal_np::geom_traits), Traits());
Traits traits = choose_parameter(get_parameter(np, internal_np::geom_traits), Traits());
typedef typename Traits::Less_xyz_3 Less_xyz_3;
@ -908,13 +908,13 @@ std::size_t merge_duplicate_polygons_in_polygon_soup(const PointRange& points,
PolygonRange& polygons,
const NamedParameters& np)
{
using boost::get_param;
using boost::choose_param;
using parameters::get_parameter;
using parameters::choose_parameter;
typedef typename internal::Polygon_types<PointRange, PolygonRange>::P_ID P_ID;
const bool erase_all_duplicates = choose_param(get_param(np, internal_np::erase_all_duplicates), false);
const bool same_orientation = choose_param(get_param(np, internal_np::require_same_orientation), false);
const bool erase_all_duplicates = choose_parameter(get_parameter(np, internal_np::erase_all_duplicates), false);
const bool same_orientation = choose_parameter(get_parameter(np, internal_np::require_same_orientation), false);
#ifdef CGAL_PMP_REPAIR_POLYGON_SOUP_VERBOSE_PP
std::cout << "Only polygons with the same orientation are duplicates: " << std::boolalpha << same_orientation << std::endl;
@ -922,7 +922,7 @@ std::size_t merge_duplicate_polygons_in_polygon_soup(const PointRange& points,
#endif
typedef typename internal::GetPolygonGeomTraits<PointRange, PolygonRange, NamedParameters>::type Traits;
Traits traits = choose_param(get_param(np, internal_np::geom_traits), Traits());
Traits traits = choose_parameter(get_parameter(np, internal_np::geom_traits), Traits());
std::vector<std::vector<P_ID> > all_duplicate_polygons;
internal::collect_duplicate_polygons(points, polygons, std::back_inserter(all_duplicate_polygons), traits, same_orientation);
@ -1065,11 +1065,11 @@ void repair_polygon_soup(PointRange& points,
PolygonRange& polygons,
const NamedParameters& np)
{
using boost::get_param;
using boost::choose_param;
using parameters::get_parameter;
using parameters::choose_parameter;
typedef typename internal::GetPolygonGeomTraits<PointRange, PolygonRange, NamedParameters>::type Traits;
Traits traits = choose_param(get_param(np, internal_np::geom_traits), Traits());
Traits traits = choose_parameter(get_parameter(np, internal_np::geom_traits), Traits());
#ifdef CGAL_PMP_REPAIR_POLYGON_SOUP_VERBOSE
std::cout << "Repairing soup with " << points.size() << " points and " << polygons.size() << " polygons" << std::endl;

32
Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/shape_predicates.h
View File

@ -75,15 +75,15 @@ bool is_degenerate_edge(typename boost::graph_traits<PolygonMesh>::edge_descript
const PolygonMesh& pm,
const NamedParameters& np)
{
using boost::get_param;
using boost::choose_param;
using parameters::get_parameter;
using parameters::choose_parameter;
typedef typename GetVertexPointMap<PolygonMesh, NamedParameters>::const_type VertexPointMap;
VertexPointMap vpmap = choose_param(get_param(np, internal_np::vertex_point),
VertexPointMap vpmap = choose_parameter(get_parameter(np, internal_np::vertex_point),
get_const_property_map(vertex_point, pm));
typedef typename GetGeomTraits<PolygonMesh, NamedParameters>::type Traits;
Traits traits = choose_param(get_param(np, internal_np::geom_traits), Traits());
Traits traits = choose_parameter(get_parameter(np, internal_np::geom_traits), Traits());
return traits.equal_3_object()(get(vpmap, source(e, pm)), get(vpmap, target(e, pm)));
}
@ -128,15 +128,15 @@ bool is_degenerate_triangle_face(typename boost::graph_traits<TriangleMesh>::fac
{
CGAL_precondition(CGAL::is_triangle(halfedge(f, tm), tm));
using boost::get_param;
using boost::choose_param;
using parameters::get_parameter;
using parameters::choose_parameter;
typedef typename GetVertexPointMap<TriangleMesh, NamedParameters>::const_type VertexPointMap;
VertexPointMap vpmap = choose_param(get_param(np, internal_np::vertex_point),
VertexPointMap vpmap = choose_parameter(get_parameter(np, internal_np::vertex_point),
get_const_property_map(vertex_point, tm));
typedef typename GetGeomTraits<TriangleMesh, NamedParameters>::type Traits;
Traits traits = choose_param(get_param(np, internal_np::geom_traits), Traits());
Traits traits = choose_parameter(get_parameter(np, internal_np::geom_traits), Traits());
typename boost::graph_traits<TriangleMesh>::halfedge_descriptor h = halfedge(f, tm);
@ -187,17 +187,17 @@ is_needle_triangle_face(typename boost::graph_traits<TriangleMesh>::face_descrip
{
CGAL_precondition(threshold >= 1.);
using boost::get_param;
using boost::choose_param;
using parameters::get_parameter;
using parameters::choose_parameter;
typedef typename boost::graph_traits<TriangleMesh>::halfedge_descriptor halfedge_descriptor;
typedef typename GetVertexPointMap<TriangleMesh, NamedParameters>::const_type VertexPointMap;
VertexPointMap vpmap = choose_param(get_param(np, internal_np::vertex_point),
VertexPointMap vpmap = choose_parameter(get_parameter(np, internal_np::vertex_point),
get_const_property_map(vertex_point, tm));
typedef typename GetGeomTraits<TriangleMesh, NamedParameters>::type Traits;
Traits traits = choose_param(get_param(np, internal_np::geom_traits), Traits());
Traits traits = choose_parameter(get_parameter(np, internal_np::geom_traits), Traits());
typedef typename Traits::FT FT;
@ -289,18 +289,18 @@ is_cap_triangle_face(typename boost::graph_traits<TriangleMesh>::face_descriptor
CGAL_precondition(threshold >= -1.);
CGAL_precondition(threshold <= 0.);
using boost::get_param;
using boost::choose_param;
using parameters::get_parameter;
using parameters::choose_parameter;
typedef typename boost::graph_traits<TriangleMesh>::vertex_descriptor vertex_descriptor;
typedef typename boost::graph_traits<TriangleMesh>::halfedge_descriptor halfedge_descriptor;
typedef typename GetVertexPointMap<TriangleMesh, NamedParameters>::const_type VertexPointMap;
VertexPointMap vpmap = choose_param(get_param(np, internal_np::vertex_point),
VertexPointMap vpmap = choose_parameter(get_parameter(np, internal_np::vertex_point),
get_const_property_map(vertex_point, tm));
typedef typename GetGeomTraits<TriangleMesh, NamedParameters>::type Traits;
Traits traits = choose_param(get_param(np, internal_np::geom_traits), Traits());
Traits traits = choose_parameter(get_parameter(np, internal_np::geom_traits), Traits());
typedef typename Traits::FT FT;
typedef typename Traits::Vector_3 Vector_3;

6
Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/stitch_borders.h
View File

@ -551,13 +551,13 @@ template <typename PolygonMesh, typename NamedParameters>
std::size_t stitch_boundary_cycles(PolygonMesh& pm,
const NamedParameters& np)
{
using boost::choose_param;
using boost::get_param;
using parameters::choose_parameter;
using parameters::get_parameter;
typedef typename boost::graph_traits<PolygonMesh>::halfedge_descriptor halfedge_descriptor;
typedef typename GetVertexPointMap<PolygonMesh, NamedParameters>::const_type VPMap;
VPMap vpm = choose_param(get_param(np, internal_np::vertex_point),
VPMap vpm = choose_parameter(get_parameter(np, internal_np::vertex_point),
get_const_property_map(vertex_point, pm));
std::vector<halfedge_descriptor> boundary_cycles;

10
Polygon_mesh_processing/include/CGAL/Rigid_triangle_mesh_collision_detection.h
View File

@ -234,7 +234,7 @@ public:
CGAL_static_assertion(same_vpm);
Vpm vpm =
boost::choose_param(boost::get_param(np, internal_np::vertex_point),
parameters::choose_parameter(parameters::get_parameter(np, internal_np::vertex_point),
get_const_property_map(boost::vertex_point, tm) );
// now add the mesh
std::size_t id = get_id_for_new_mesh();
@ -530,8 +530,8 @@ public:
using Polygon_mesh_processing::GetFaceIndexMap;
const bool maybe_several_cc =
boost::choose_param(
boost::get_param(np, internal_np::apply_per_connected_component), true);
parameters::choose_parameter(
parameters::get_parameter(np, internal_np::apply_per_connected_component), true);
typedef typename GetVertexPointMap<TriangleMesh,
NamedParameters>::const_type Local_vpm;
@ -542,7 +542,7 @@ public:
CGAL_static_assertion(same_vpm);
Vpm vpm =
boost::choose_param(boost::get_param(np, internal_np::vertex_point),
parameters::choose_parameter(parameters::get_parameter(np, internal_np::vertex_point),
get_const_property_map(boost::vertex_point, tm) );
if (maybe_several_cc)
@ -555,7 +555,7 @@ public:
NamedParameters>::type Fid_map;
Fid_map fid_map =
boost::choose_param(boost::get_param(np, internal_np::face_index),
parameters::choose_parameter(parameters::get_parameter(np, internal_np::face_index),
get_const_property_map(boost::face_index, tm));
std::size_t nb_cc =

64
Surface_mesh_approximation/include/CGAL/Surface_mesh_approximation/approximate_triangle_mesh.h
View File

@ -27,7 +27,7 @@
#include <CGAL/Variational_shape_approximation.h>
#include <CGAL/boost/graph/named_function_params.h>
#include <CGAL/boost/graph/Named_function_parameters.h>
#include <CGAL/boost/graph/named_params_helper.h>
#include <CGAL/property_map.h>
@ -127,22 +127,22 @@ unspecified_type all_default();
template <typename TriangleMesh, typename NamedParameters>
bool approximate_triangle_mesh(const TriangleMesh &tm, const NamedParameters &np)
{
using boost::get_param;
using boost::choose_param;
using boost::is_default_param;
using parameters::get_parameter;
using parameters::choose_parameter;
using parameters::is_default_parameter;
typedef typename Polygon_mesh_processing::GetGeomTraits<TriangleMesh, NamedParameters>::type Geom_traits;
typedef typename Geom_traits::FT FT;
typedef typename Polygon_mesh_processing::GetVertexPointMap<TriangleMesh, NamedParameters>::type Vertex_point_map;
Vertex_point_map point_pmap = choose_param(get_param(np, internal_np::vertex_point),
Vertex_point_map point_pmap = choose_parameter(get_parameter(np, internal_np::vertex_point),
get_property_map(vertex_point, const_cast<TriangleMesh &>(tm)));
typedef CGAL::Variational_shape_approximation<TriangleMesh, Vertex_point_map> L21_approx;
typedef typename L21_approx::Error_metric L21_metric;
const Verbose_level vl = choose_param(
get_param(np, internal_np::verbose_level), SILENT);
const Verbose_level vl = choose_parameter(
get_parameter(np, internal_np::verbose_level), SILENT);
const std::size_t number_of_faces = std::distance(faces(tm).first, faces(tm).second);
const std::size_t number_of_vertices = std::distance(vertices(tm).first, vertices(tm).second);
@ -157,14 +157,14 @@ bool approximate_triangle_mesh(const TriangleMesh &tm, const NamedParameters &np
L21_approx approx(tm, point_pmap, metric);
// hierarchical seeding by default
const Seeding_method method = choose_param(
get_param(np, internal_np::seeding_method), HIERARCHICAL);
const std::size_t max_nb_of_proxies = choose_param(
get_param(np, internal_np::max_number_of_proxies), 0);
const FT min_error_drop = choose_param(
get_param(np, internal_np::min_error_drop), FT(0.0));
const std::size_t nb_of_relaxations = choose_param(
get_param(np, internal_np::number_of_relaxations), 5);
const Seeding_method method = choose_parameter(
get_parameter(np, internal_np::seeding_method), HIERARCHICAL);
const std::size_t max_nb_of_proxies = choose_parameter(
get_parameter(np, internal_np::max_number_of_proxies), 0);
const FT min_error_drop = choose_parameter(
get_parameter(np, internal_np::min_error_drop), FT(0.0));
const std::size_t nb_of_relaxations = choose_parameter(
get_parameter(np, internal_np::number_of_relaxations), 5);
if (vl == VERBOSE) {
std::cout << (method == RANDOM ? "Random" :
@ -179,8 +179,8 @@ bool approximate_triangle_mesh(const TriangleMesh &tm, const NamedParameters &np
if (vl == MAIN_STEPS || vl == VERBOSE)
std::cout << "Seeding done." << std::endl;
const std::size_t nb_of_iterations = choose_param(
get_param(np, internal_np::number_of_iterations), 20);
const std::size_t nb_of_iterations = choose_parameter(
get_parameter(np, internal_np::number_of_iterations), 20);
if (vl == VERBOSE)
std::cout << "\n#nb_of_iterations = " << nb_of_iterations << std::endl;
@ -193,30 +193,30 @@ bool approximate_triangle_mesh(const TriangleMesh &tm, const NamedParameters &np
}
// get proxy map
approx.proxy_map( get_param(np, internal_np::face_proxy_map) );
approx.proxy_map( get_parameter(np, internal_np::face_proxy_map) );
if (!boost::is_default_param(get_param(np, internal_np::face_proxy_map))
if (!parameters::is_default_parameter(get_parameter(np, internal_np::face_proxy_map))
&& (vl == MAIN_STEPS || vl == VERBOSE))
std::cout << "Filling face proxy map done." << std::endl;
// get proxies
approx.proxies( get_param(np, internal_np::proxies) );
approx.proxies( get_parameter(np, internal_np::proxies) );
if (!is_default_param( get_param(np, internal_np::proxies) )
if (!is_default_parameter( get_parameter(np, internal_np::proxies) )
&& (vl == MAIN_STEPS || vl == VERBOSE))
std::cout << "Get proxies done." << std::endl;
// meshing
bool is_manifold = false;
if (!is_default_param( get_param(np, internal_np::anchors))
|| !is_default_param( get_param(np, internal_np::triangles) ))
if (!is_default_parameter( get_parameter(np, internal_np::anchors))
|| !is_default_parameter( get_parameter(np, internal_np::triangles) ))
{
if (vl == VERBOSE) {
const FT subdivision_ratio = choose_param(get_param(np, internal_np::subdivision_ratio), FT(5.0));
const bool relative_to_chord = choose_param(get_param(np, internal_np::relative_to_chord), false);
const bool with_dihedral_angle = choose_param(get_param(np, internal_np::with_dihedral_angle), false);
const bool optimize_anchor_location = choose_param(get_param(np, internal_np::optimize_anchor_location), true);
const bool pca_plane = choose_param(get_param(np, internal_np::pca_plane), false);
const FT subdivision_ratio = choose_parameter(get_parameter(np, internal_np::subdivision_ratio), FT(5.0));
const bool relative_to_chord = choose_parameter(get_parameter(np, internal_np::relative_to_chord), false);
const bool with_dihedral_angle = choose_parameter(get_parameter(np, internal_np::with_dihedral_angle), false);
const bool optimize_anchor_location = choose_parameter(get_parameter(np, internal_np::optimize_anchor_location), true);
const bool pca_plane = choose_parameter(get_parameter(np, internal_np::pca_plane), false);
std::cout << "Meshing: "
<< "\nchord_error = " << subdivision_ratio
<< "\nrelative_to_chord = " << relative_to_chord
@ -233,16 +233,16 @@ bool approximate_triangle_mesh(const TriangleMesh &tm, const NamedParameters &np
}
// get anchor points
approx.anchor_points( get_param(np, internal_np::anchors) );
approx.anchor_points( get_parameter(np, internal_np::anchors) );
if (!is_default_param( get_param(np, internal_np::anchors) )
if (!is_default_parameter( get_parameter(np, internal_np::anchors) )
&& (vl == MAIN_STEPS || vl == VERBOSE))
std::cout << "Get anchors done." << std::endl;
// get indexed triangles
approx.indexed_triangles( get_param(np, internal_np::triangles) );
approx.indexed_triangles( get_parameter(np, internal_np::triangles) );
if (!is_default_param( get_param(np, internal_np::triangles) )
if (!is_default_parameter( get_parameter(np, internal_np::triangles) )
&& (vl == MAIN_STEPS || vl == VERBOSE))
std::cout << "Get indexed triangles done." << std::endl;

56
Surface_mesh_approximation/include/CGAL/Variational_shape_approximation.h
View File

@ -45,7 +45,7 @@
#include <boost/foreach.hpp>
#include <boost/optional.hpp>
#include <CGAL/boost/graph/named_function_params.h>
#include <CGAL/boost/graph/Named_function_parameters.h>
#include <CGAL/boost/graph/named_params_helper.h>
#include <vector>
@ -323,17 +323,17 @@ public:
*/
template <typename NamedParameters>
std::size_t initialize_seeds(const NamedParameters &np) {
using boost::get_param;
using boost::choose_param;
using parameters::get_parameter;
using parameters::choose_parameter;
const Surface_mesh_approximation::Seeding_method method = choose_param(
get_param(np, internal_np::seeding_method), Surface_mesh_approximation::HIERARCHICAL);
std::size_t max_nb_proxies = choose_param(
get_param(np, internal_np::max_number_of_proxies), 0);
FT min_error_drop = choose_param(
get_param(np, internal_np::min_error_drop), FT(0.0));
const std::size_t nb_relaxations = choose_param(
get_param(np, internal_np::number_of_relaxations), 5);
const Surface_mesh_approximation::Seeding_method method = choose_parameter(
get_parameter(np, internal_np::seeding_method), Surface_mesh_approximation::HIERARCHICAL);
std::size_t max_nb_proxies = choose_parameter(
get_parameter(np, internal_np::max_number_of_proxies), 0);
FT min_error_drop = choose_parameter(
get_parameter(np, internal_np::min_error_drop), FT(0.0));
const std::size_t nb_relaxations = choose_parameter(
get_parameter(np, internal_np::number_of_relaxations), 5);
// adjust parameters
if (max_nb_proxies < (m_nb_of_faces / 3) && max_nb_proxies > 0) {
@ -798,14 +798,14 @@ public:
*/
template <typename NamedParameters>
bool extract_mesh(const NamedParameters &np) {
using boost::get_param;
using boost::choose_param;
using parameters::get_parameter;
using parameters::choose_parameter;
const FT subdivision_ratio = choose_param(get_param(np, internal_np::subdivision_ratio), FT(5.0));
const bool relative_to_chord = choose_param(get_param(np, internal_np::relative_to_chord), false);
const bool with_dihedral_angle = choose_param(get_param(np, internal_np::with_dihedral_angle), false);
const bool optimize_anchor_location = choose_param(get_param(np, internal_np::optimize_anchor_location), true);
const bool pca_plane = choose_param(get_param(np, internal_np::pca_plane), false);
const FT subdivision_ratio = choose_parameter(get_parameter(np, internal_np::subdivision_ratio), FT(5.0));
const bool relative_to_chord = choose_parameter(get_parameter(np, internal_np::relative_to_chord), false);
const bool with_dihedral_angle = choose_parameter(get_parameter(np, internal_np::with_dihedral_angle), false);
const bool optimize_anchor_location = choose_parameter(get_parameter(np, internal_np::optimize_anchor_location), true);
const bool pca_plane = choose_parameter(get_parameter(np, internal_np::pca_plane), false);
// compute averaged edge length, used in chord subdivision
m_average_edge_length = compute_averaged_edge_length(*m_ptm, m_vpoint_map);
@ -861,19 +861,19 @@ public:
*/
template <typename NamedParameters>
void output(const NamedParameters &np) const {
using boost::get_param;
using boost::choose_param;
using parameters::get_parameter;
using parameters::choose_parameter;
// get proxy map
proxy_map( get_param(np, internal_np::face_proxy_map) );
proxy_map( get_parameter(np, internal_np::face_proxy_map) );
// get proxies
proxies( get_param(np, internal_np::proxies) );
proxies( get_parameter(np, internal_np::proxies) );
// get anchor points
anchor_points( get_param(np, internal_np::anchors) );
anchor_points( get_parameter(np, internal_np::anchors) );
// get indexed triangles
indexed_triangles( get_param(np, internal_np::triangles) );
indexed_triangles( get_parameter(np, internal_np::triangles) );
}
/*!
@ -897,7 +897,7 @@ public:
/*!
* @brief dummy function for named parameters.
*/
void proxy_map(boost::param_not_found) const {}
void proxy_map(internal_np::Param_not_found) const {}
/*!
* @brief gets the face region of the specified proxy.
@ -929,7 +929,7 @@ public:
/*!
* @brief dummy function for named parameters.
*/
void proxies(boost::param_not_found) const {}
void proxies(internal_np::Param_not_found) const {}
/*!
* @brief gets the wrapped proxies.
@ -956,7 +956,7 @@ public:
/*!
* @brief dummy function for named parameters.
*/
void anchor_points(boost::param_not_found) const {}
void anchor_points(internal_np::Param_not_found) const {}
/*!
* @brief gets the anchor vertices.
@ -984,7 +984,7 @@ public:
/*!
* @brief dummy function for named parameters.
*/
void indexed_triangles(boost::param_not_found) const {}
void indexed_triangles(internal_np::Param_not_found) const {}
/*!
* @brief gets the indexed boundary polygon approximation.