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

move enum for named parameters inside internal_np namespace

This commit is contained in:
Sébastien Loriot 2017-02-13 10:23:01 +01:00
parent 9b8f910cee
commit e9395aba6f
26 changed files with 231 additions and 264 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
BGL/include/CGAL/boost/graph/boost_parameters_interface.h
View File

@ -18,5 +18,5 @@
// Author(s) : Maxime Gimeno
// List the named parameters imported from boost we are using in CGAL
CGAL_add_named_parameter(vertex_index_t, vertex_index_map, vertex_index_map)
CGAL_add_named_parameter(vertex_index_t, vertex_index, vertex_index_map)
CGAL_add_named_parameter(graph_visitor_t, visitor, visitor)

46
BGL/include/CGAL/boost/graph/named_function_params.h
View File

@ -103,13 +103,23 @@ namespace boost{
namespace CGAL {
namespace parameters{
namespace internal_np{
// for uniformity we import them in this namespace. Note that
// it is an import so that if we use the named parameter function
// from boost it will work
using boost::vertex_index_t;
using boost::vertex_index;
using boost::graph_visitor_t;
using boost::visitor;
// define enum types and values for new named parameters
#define CGAL_add_named_parameter(X, Y, Z) \
enum X { Y };
#include <CGAL/boost/graph/parameters_interface.h>
#undef CGAL_add_named_parameter
}//parameters
}//internal_np
template <typename T, typename Tag, typename Base = boost::no_property>
struct cgal_bgl_named_params : boost::bgl_named_params<T, Tag, Base>
@ -124,50 +134,30 @@ namespace parameters{
// used to concatenate several parameters
#define CGAL_add_named_parameter(X, Y, Z) \
template<typename K> \
cgal_bgl_named_params<K, parameters::X, self> \
cgal_bgl_named_params<K, internal_np::X, self> \
Z(const K& k) const \
{ \
typedef cgal_bgl_named_params<K, parameters::X, self> Params;\
typedef cgal_bgl_named_params<K, internal_np::X, self> Params;\
return Params(k, *this); \
}
#include <CGAL/boost/graph/parameters_interface.h>
#undef CGAL_add_named_parameter
#define CGAL_add_named_parameter(X, Y, Z) \
template<typename K> \
cgal_bgl_named_params<K, boost::X, self> \
Z(const K& k) const \
{ \
typedef cgal_bgl_named_params<K, boost::X, self> Params; \
return Params(k, *this); \
}
#include <CGAL/boost/graph/boost_parameters_interface.h>
#undef CGAL_add_named_parameter
};
namespace parameters {
// define free functions for new named parameters and the one imported from boost
// define free functions for named parameters
#define CGAL_add_named_parameter(X, Y, Z) \
template <typename K> \
cgal_bgl_named_params<K, boost::X> \
cgal_bgl_named_params<K, internal_np::X> \
Z(K const& p) \
{ \
typedef cgal_bgl_named_params<K, boost::X> Params;\
return Params(p); \
}
#include <CGAL/boost/graph/boost_parameters_interface.h>
#undef CGAL_add_named_parameter
#define CGAL_add_named_parameter(X, Y, Z) \
template <typename K> \
cgal_bgl_named_params<K, X> \
Z(K const& p) \
{ \
typedef cgal_bgl_named_params<K, X> Params;\
typedef cgal_bgl_named_params<K, internal_np::X> Params;\
return Params(p); \
}
#include <CGAL/boost/graph/parameters_interface.h>
#include <CGAL/boost/graph/boost_parameters_interface.h>
#undef CGAL_add_named_parameter
} // namespace parameters

11
BGL/include/CGAL/boost/graph/parameters_interface.h
View File

@ -17,13 +17,12 @@
//
// Author(s) : Maxime Gimeno
// List of new named parameters that we use in CGAL
CGAL_add_named_parameter(vertex_point_t, vertex_point_map, vertex_point_map)
CGAL_add_named_parameter(face_index_t, face_index_map, face_index_map)
CGAL_add_named_parameter(edge_index_t, edge_index_map, edge_index_map)
CGAL_add_named_parameter(halfedge_index_t, halfedge_index_map, halfedge_index_map)
// List of named parameters that we use in CGAL
CGAL_add_named_parameter(vertex_point_t, vertex_point, vertex_point_map)
CGAL_add_named_parameter(face_index_t, face_index, face_index_map)
CGAL_add_named_parameter(edge_index_t, edge_index, edge_index_map)
CGAL_add_named_parameter(halfedge_index_t, halfedge_index, halfedge_index_map)
CGAL_add_named_parameter(edge_is_constrained_t, edge_is_constrained, edge_is_constrained_map)
CGAL_add_named_parameter(edge_is_constrained_params_t, edge_is_constrained_params, edge_is_constrained_map_params)
CGAL_add_named_parameter(set_cache_policy_t, set_cache_policy, set_cache)
CGAL_add_named_parameter(get_cost_policy_t, get_cost_policy, get_cost)
CGAL_add_named_parameter(get_cost_policy_params_t, get_cost_policy_params, get_cost_params)

52
BGL/test/BGL/test_cgal_bgl_named_params.cpp
View File

@ -2,6 +2,8 @@
#include <CGAL/assertions.h>
#include <boost/type_traits/is_same.hpp>
template <int i>
struct A{
A(int v):v(v){}
@ -20,35 +22,33 @@ template<class NamedParameters>
void test(const NamedParameters& np)
{
// test values
assert( get_param(np,boost::vertex_index).v == 0 );
assert( get_param(np,boost::halfedge_index).v == 1 );
assert( get_param(np,boost::face_index).v == 2 );
assert( get_param(np,boost::vertex_point).v == 3 );
assert( get_param(np,boost::edge_index).v == 5 );
assert( get_param(np,CGAL::internal_np::vertex_index).v == 0 );
assert( get_param(np,CGAL::internal_np::halfedge_index).v == 1 );
assert( get_param(np,CGAL::internal_np::face_index).v == 2 );
assert( get_param(np,CGAL::internal_np::vertex_point).v == 3 );
assert( get_param(np,CGAL::internal_np::edge_index).v == 5 );
assert( get_param(np,boost::graph_visitor).v == 6 );
assert( get_param(np,CGAL::parameters::set_cache_policy).v == 7 );
assert( get_param(np,CGAL::parameters::get_cost_policy).v == 8 );
assert( get_param(np,CGAL::parameters::get_cost_policy_params).v == 9 );
assert( get_param(np,CGAL::parameters::get_placement_policy).v == 10 );
assert( get_param(np,CGAL::parameters::get_placement_policy_params).v == 11 );
assert( get_param(np,CGAL::parameters::edge_is_constrained).v == 12 );
assert( get_param(np,CGAL::parameters::edge_is_constrained_params).v == 13 );
assert( get_param(np,CGAL::internal_np::set_cache_policy).v == 7 );
assert( get_param(np,CGAL::internal_np::get_cost_policy).v == 8 );
assert( get_param(np,CGAL::internal_np::get_cost_policy_params).v == 9 );
assert( get_param(np,CGAL::internal_np::get_placement_policy).v == 10 );
assert( get_param(np,CGAL::internal_np::get_placement_policy_params).v == 11 );
assert( get_param(np,CGAL::internal_np::edge_is_constrained).v == 12 );
//test types
check_same_type<0>( get_param(np,boost::vertex_index) );
check_same_type<1>( get_param(np,boost::halfedge_index) );
check_same_type<2>( get_param(np,boost::face_index) );
check_same_type<3>( get_param(np,boost::vertex_point) );
check_same_type<4>( get_param(np,CGAL::parameters::vertex_is_fixed) );
check_same_type<5>( get_param(np,boost::edge_index) );
check_same_type<1>( get_param(np,CGAL::internal_np::halfedge_index) );
check_same_type<2>( get_param(np,CGAL::internal_np::face_index) );
check_same_type<3>( get_param(np,CGAL::internal_np::vertex_point) );
check_same_type<5>( get_param(np,CGAL::internal_np::edge_index) );
check_same_type<6>( get_param(np,boost::graph_visitor) );
check_same_type<7>( get_param(np,CGAL::parameters::set_cache_policy) );
check_same_type<8>( get_param(np,CGAL::parameters::get_cost_policy) );
check_same_type<9>( get_param(np,CGAL::parameters::get_cost_policy_params) );
check_same_type<10>( get_param(np,CGAL::parameters::get_placement_policy) );
check_same_type<11>( get_param(np,CGAL::parameters::get_placement_policy_params) );
check_same_type<12>( get_param(np,CGAL::parameters::edge_is_constrained) );
check_same_type<13>( get_param(np,CGAL::parameters::edge_is_constrained_params) );
check_same_type<7>( get_param(np,CGAL::internal_np::set_cache_policy) );
check_same_type<8>( get_param(np,CGAL::internal_np::get_cost_policy) );
check_same_type<9>( get_param(np,CGAL::internal_np::get_cost_policy_params) );
check_same_type<10>( get_param(np,CGAL::internal_np::get_placement_policy) );
check_same_type<11>( get_param(np,CGAL::internal_np::get_placement_policy_params) );
check_same_type<12>( get_param(np,CGAL::internal_np::edge_is_constrained) );
}
int main()
@ -58,7 +58,6 @@ int main()
halfedge_index_map(A<1>(1)).
face_index_map(A<2>(2)).
vertex_point_map(A<3>(3)).
vertex_is_fixed_map(A<4>(4)).
edge_index_map(A<5>(5)).
visitor(A<6>(6)).
set_cache(A<7>(7)).
@ -66,7 +65,6 @@ int main()
get_cost_params(A<9>(9)).
get_placement(A<10>(10)).
get_placement_params(A<11>(11)).
edge_is_constrained_map(A<12>(12)).
edge_is_constrained_map_params(A<13>(13))
edge_is_constrained_map(A<12>(12))
);
}

16
Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/bbox.h
View File

@ -68,11 +68,11 @@ namespace CGAL {
using boost::choose_param;
using boost::get_param;
typename GetVertexPointMap<PolygonMesh, CGAL_PMP_NP_CLASS>::const_type
vpm = choose_param(get_param(np, vertex_point),
vpm = choose_param(get_param(np, internal_np::vertex_point),
get_const_property_map(CGAL::vertex_point, pmesh));
typedef typename GetGeomTraits<PolygonMesh, CGAL_PMP_NP_CLASS>::type GT;
GT gt = choose_param(get_param(np, CGAL::parameters::geom_traits), GT());
GT gt = choose_param(get_param(np, internal_np::geom_traits), GT());
typename GT::Construct_bbox_3 get_bbox = gt.construct_bbox_3_object();
typedef typename boost::graph_traits<PolygonMesh>::halfedge_descriptor halfedge_descriptor;
@ -119,11 +119,11 @@ namespace CGAL {
using boost::choose_param;
using boost::get_param;
typename GetVertexPointMap<PolygonMesh, NamedParameters>::const_type
vpm = choose_param(get_param(np, vertex_point),
vpm = choose_param(get_param(np, internal_np::vertex_point),
get_const_property_map(CGAL::vertex_point, pmesh));
typedef typename GetGeomTraits<PolygonMesh, NamedParameters>::type GT;
GT gt = choose_param(get_param(np, CGAL::parameters::geom_traits), GT());
GT gt = choose_param(get_param(np, internal_np::geom_traits), GT());
typename GT::Construct_bbox_3 get_bbox = gt.construct_bbox_3_object();
return get_bbox( get(vpm, vd) );
@ -162,11 +162,11 @@ namespace CGAL {
using boost::choose_param;
using boost::get_param;
typename GetVertexPointMap<PolygonMesh, NamedParameters>::const_type
vpm = choose_param(get_param(np, vertex_point),
vpm = choose_param(get_param(np, internal_np::vertex_point),
get_const_property_map(CGAL::vertex_point, pmesh));
typedef typename GetGeomTraits<PolygonMesh, NamedParameters>::type GT;
GT gt = choose_param(get_param(np, CGAL::parameters::geom_traits), GT());
GT gt = choose_param(get_param(np, internal_np::geom_traits), GT());
typename GT::Construct_bbox_3 get_bbox = gt.construct_bbox_3_object();
return get_bbox( get(vpm, source(ed, pmesh)) ) +
@ -206,11 +206,11 @@ namespace CGAL {
using boost::choose_param;
using boost::get_param;
typename GetVertexPointMap<PolygonMesh, NamedParameters>::const_type
vpm = choose_param(get_param(np, vertex_point),
vpm = choose_param(get_param(np, internal_np::vertex_point),
get_const_property_map(CGAL::vertex_point, pmesh));
typedef typename GetGeomTraits<PolygonMesh, NamedParameters>::type GT;
GT gt = choose_param(get_param(np, CGAL::parameters::geom_traits), GT());
GT gt = choose_param(get_param(np, internal_np::geom_traits), GT());
typename GT::Construct_bbox_3 get_bbox = gt.construct_bbox_3_object();
typedef typename boost::graph_traits<PolygonMesh>::halfedge_descriptor halfedge_descriptor;

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

@ -198,7 +198,7 @@ namespace Polygon_mesh_processing {
}
//face index map given as a named parameter, or as an internal property map
FIMap fim = choose_param(get_param(np, CGAL::face_index),
FIMap fim = choose_param(get_param(np, internal_np::face_index),
get_const_property_map(CGAL::face_index, pmesh));
return internal::border_halfedges_impl(faces, fim, out, pmesh, np);

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

@ -138,11 +138,11 @@ compute_face_normal(typename boost::graph_traits<PolygonMesh>::face_descriptor f
using boost::choose_param;
using boost::get_param;
GT traits = choose_param(get_param(np, CGAL::parameters::geom_traits), GT());
GT traits = choose_param(get_param(np, internal_np::geom_traits), GT());
Vector normal = traits.construct_vector_3_object()(CGAL::NULL_VECTOR);
sum_normals<Point>(pmesh, f
, choose_param(get_param(np, vertex_point), get_const_property_map(CGAL::vertex_point, pmesh))
, choose_param(get_param(np, internal_np::vertex_point), get_const_property_map(CGAL::vertex_point, pmesh))
, normal
, traits);
@ -232,14 +232,14 @@ compute_vertex_normal(typename boost::graph_traits<PolygonMesh>::vertex_descript
typedef typename GetGeomTraits<PolygonMesh, NamedParameters>::type GT;
typedef typename GT::Vector_3 Vector;
GT traits = choose_param(get_param(np, CGAL::parameters::geom_traits), GT());
GT traits = choose_param(get_param(np, internal_np::geom_traits), GT());
typedef typename GetFaceNormalMap<PolygonMesh, NamedParameters>::NoMap DefaultMap;
typedef typename boost::lookup_named_param_def <
CGAL::parameters::face_normal_t,
internal_np::face_normal_t,
NamedParameters,
DefaultMap> ::type FaceNormalMap;
FaceNormalMap fnmap = choose_param(get_param(np, CGAL::parameters::face_normal), DefaultMap());
FaceNormalMap fnmap = choose_param(get_param(np, internal_np::face_normal), DefaultMap());
bool fnmap_valid
= !boost::is_same<FaceNormalMap,
DefaultMap

22
Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/connected_components.h
View File

@ -436,12 +436,12 @@ connected_component(typename boost::graph_traits<PolygonMesh>::face_descriptor s
using boost::get_param;
typedef typename boost::lookup_named_param_def <
CGAL::parameters::edge_is_constrained_t,
internal_np::edge_is_constrained_t,
NamedParameters,
internal::No_constraint<PolygonMesh>//default
> ::type EdgeConstraintMap;
EdgeConstraintMap ecmap
= choose_param(get_param(np, CGAL::parameters::edge_is_constrained),
= choose_param(get_param(np, internal_np::edge_is_constrained),
internal::No_constraint<PolygonMesh>());
typedef typename boost::graph_traits<PolygonMesh>::face_descriptor face_descriptor;
@ -516,12 +516,12 @@ connected_components(const PolygonMesh& pmesh,
using boost::get_param;
typedef typename boost::lookup_named_param_def <
CGAL::parameters::edge_is_constrained_t,
internal_np::edge_is_constrained_t,
NamedParameters,
internal::No_constraint<PolygonMesh>//default
> ::type EdgeConstraintMap;
EdgeConstraintMap ecmap
= choose_param(get_param(np, CGAL::parameters::edge_is_constrained),
= choose_param(get_param(np, internal_np::edge_is_constrained),
internal::No_constraint<PolygonMesh>());
typedef Dual<PolygonMesh> Dual;
@ -533,8 +533,8 @@ connected_components(const PolygonMesh& pmesh,
internal::No_border<PolygonMesh, EdgeConstraintMap>(pmesh, ecmap));
typename GetFaceIndexMap<PolygonMesh, NamedParameters>::const_type
fimap = choose_param(get_param(np, face_index),
get_const_property_map(face_index, pmesh));
fimap = choose_param(get_param(np, internal_np::face_index),
get_const_property_map(boost::face_index, pmesh));
return boost::connected_components(finite_dual,
fcm,
@ -600,7 +600,7 @@ std::size_t keep_largest_connected_components(PolygonMesh& pmesh
//FaceIndexMap
typedef typename GetFaceIndexMap<PM, NamedParameters>::type FaceIndexMap;
FaceIndexMap fimap = choose_param(get_param(np, boost::face_index),
FaceIndexMap fimap = choose_param(get_param(np, internal_np::face_index),
get_property_map(boost::face_index, pmesh));
//vector_property_map
@ -683,7 +683,7 @@ std::size_t keep_large_connected_components(PolygonMesh& pmesh
//FaceIndexMap
typedef typename GetFaceIndexMap<PM, NamedParameters>::type FaceIndexMap;
FaceIndexMap fim = choose_param(get_param(np, boost::face_index),
FaceIndexMap fim = choose_param(get_param(np, internal_np::face_index),
get_property_map(boost::face_index, pmesh));
//vector_property_map
@ -745,7 +745,7 @@ void keep_or_remove_connected_components(PolygonMesh& pmesh
//VertexIndexMap
typedef typename GetVertexIndexMap<PM, NamedParameters>::type VertexIndexMap;
VertexIndexMap vim = choose_param(get_param(np, boost::vertex_index),
VertexIndexMap vim = choose_param(get_param(np, internal_np::vertex_index),
get_const_property_map(boost::vertex_index, pmesh));
std::set<std::size_t> cc_to_keep;
@ -987,7 +987,7 @@ void remove_connected_components(PolygonMesh& pmesh
//FaceIndexMap
typedef typename GetFaceIndexMap<PM, CGAL_PMP_NP_CLASS>::type FaceIndexMap;
FaceIndexMap fim = choose_param(get_param(np, boost::face_index),
FaceIndexMap fim = choose_param(get_param(np, internal_np::face_index),
get_property_map(boost::face_index, pmesh));
//vector_property_map
@ -1045,7 +1045,7 @@ void keep_connected_components(PolygonMesh& pmesh
//FaceIndexMap
typedef typename GetFaceIndexMap<PM, CGAL_PMP_NP_CLASS>::type FaceIndexMap;
FaceIndexMap fim = choose_param(get_param(np, boost::face_index),
FaceIndexMap fim = choose_param(get_param(np, internal_np::face_index),
get_property_map(boost::face_index, pmesh));
//vector_property_map

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

@ -164,11 +164,11 @@ bool does_bound_a_volume(const TriangleMesh& tm, const NamedParameters& np)
if (!is_closed(tm)) return false;
if (!is_triangle_mesh(tm)) return false;
Vpm vpm = boost::choose_param(get_param(np, vertex_point),
get_const_property_map(vertex_point, tm));
Vpm vpm = boost::choose_param(get_param(np, internal_np::vertex_point),
get_const_property_map(boost::vertex_point, tm));
Fid_map fid_map = boost::choose_param(get_param(np, face_index),
get_const_property_map(face_index, tm));
Fid_map fid_map = boost::choose_param(get_param(np, internal_np::face_index),
get_const_property_map(boost::face_index, tm));
std::vector<std::size_t> face_cc(num_faces(tm), std::size_t(-1));
@ -222,8 +222,8 @@ bool does_bound_a_volume(const TriangleMesh& tm)
if (desired_output[i]!=boost::none) \
{ \
vpm_out.push_back( \
boost::choose_param(get_param(cpp11::get<i>(nps_out), vertex_point), \
get_property_map(vertex_point, *(*desired_output[i])))); \
boost::choose_param(get_param(cpp11::get<i>(nps_out), internal_np::vertex_point), \
get_property_map(boost::vertex_point, *(*desired_output[i])))); \
output_vpms[i]=&vpm_out.back(); \
} \
else \
@ -231,12 +231,12 @@ bool does_bound_a_volume(const TriangleMesh& tm)
#define CGAL_COREF_SET_OUTPUT_EDGE_MARK_MAP(I) \
typedef typename boost::lookup_named_param_def < \
CGAL::parameters::edge_is_constrained_t, \
internal_np::edge_is_constrained_t, \
NamedParametersOut##I, \
Corefinement::No_mark<TriangleMesh> \
> ::type Ecm_out_##I; \
Ecm_out_##I ecm_out_##I = \
boost::choose_param( get_param(cpp11::get<I>(nps_out), CGAL::parameters::edge_is_constrained), \
boost::choose_param( get_param(cpp11::get<I>(nps_out), internal_np::edge_is_constrained), \
Corefinement::No_mark<TriangleMesh>() );
@ -274,11 +274,11 @@ boolean_operation( TriangleMesh& tm1,
static const bool same_vpm = (boost::is_same<Vpm,Vpm2>::value); )
CGAL_static_assertion(same_vpm);
Vpm vpm1 = boost::choose_param(get_param(np1, vertex_point),
get_property_map(vertex_point, tm1));
Vpm vpm1 = boost::choose_param(get_param(np1, internal_np::vertex_point),
get_property_map(boost::vertex_point, tm1));
Vpm vpm2 = boost::choose_param(get_param(np2, vertex_point),
get_property_map(vertex_point, tm2));
Vpm vpm2 = boost::choose_param(get_param(np2, internal_np::vertex_point),
get_property_map(boost::vertex_point, tm2));
//for output meshes
cpp11::array<Vpm*, 4> output_vpms;
@ -328,20 +328,20 @@ boolean_operation( TriangleMesh& tm1,
// Edge is-constrained maps
//for input meshes
typedef typename boost::lookup_named_param_def <
CGAL::parameters::edge_is_constrained_t,
internal_np::edge_is_constrained_t,
NamedParameters1,
Corefinement::No_mark<TriangleMesh>//default
> ::type Ecm1;
typedef typename boost::lookup_named_param_def <
CGAL::parameters::edge_is_constrained_t,
internal_np::edge_is_constrained_t,
NamedParameters2,
Corefinement::No_mark<TriangleMesh>//default
> ::type Ecm2;
Ecm1 ecm1 = boost::choose_param( boost::get_param(np1, CGAL::parameters::edge_is_constrained),
Ecm1 ecm1 = boost::choose_param( boost::get_param(np1, internal_np::edge_is_constrained),
Corefinement::No_mark<TriangleMesh>() );
Ecm2 ecm2 = boost::choose_param( boost::get_param(np2, CGAL::parameters::edge_is_constrained),
Ecm2 ecm2 = boost::choose_param( boost::get_param(np2, internal_np::edge_is_constrained),
Corefinement::No_mark<TriangleMesh>() );
typedef Corefinement::Ecm_bind<TriangleMesh, Ecm1, Ecm2> Ecm_in;
@ -366,10 +366,10 @@ boolean_operation( TriangleMesh& tm1,
static const bool same_fidmap = (boost::is_same<Fid_map,Fid_map2>::value);)
CGAL_static_assertion(same_fidmap);
Fid_map fid_map1 = boost::choose_param(get_param(np1, face_index),
get_property_map(face_index, tm1));
Fid_map fid_map2 = boost::choose_param(get_param(np2, face_index),
get_property_map(face_index, tm2));
Fid_map fid_map1 = boost::choose_param(get_param(np1, internal_np::face_index),
get_property_map(boost::face_index, tm1));
Fid_map fid_map2 = boost::choose_param(get_param(np2, internal_np::face_index),
get_property_map(boost::face_index, tm2));
// surface intersection algorithm call
typedef Corefinement::Default_node_visitor<TriangleMesh> Dnv;
typedef Corefinement::Default_face_visitor<TriangleMesh> Dfv;
@ -618,28 +618,28 @@ corefine_and_compute_difference( TriangleMesh& tm1,
static const bool same_vpm = (boost::is_same<Vpm,Vpm2>::value);)
CGAL_static_assertion(same_vpm);
Vpm vpm1 = boost::choose_param(get_param(np1, vertex_point),
get_property_map(vertex_point, tm1));
Vpm vpm1 = boost::choose_param(get_param(np1, internal_np::vertex_point),
get_property_map(boost::vertex_point, tm1));
Vpm vpm2 = boost::choose_param(get_param(np2, vertex_point),
get_property_map(vertex_point, tm2));
Vpm vpm2 = boost::choose_param(get_param(np2, internal_np::vertex_point),
get_property_map(boost::vertex_point, tm2));
// Edge is-constrained maps
typedef typename boost::lookup_named_param_def <
CGAL::parameters::edge_is_constrained_t,
internal_np::edge_is_constrained_t,
NamedParameters1,
Corefinement::No_mark<TriangleMesh>//default
> ::type Ecm1;
typedef typename boost::lookup_named_param_def <
CGAL::parameters::edge_is_constrained_t,
internal_np::edge_is_constrained_t,
NamedParameters2,
Corefinement::No_mark<TriangleMesh>//default
> ::type Ecm2;
Ecm1 ecm1 = boost::choose_param( get_param(np1, CGAL::parameters::edge_is_constrained),
Ecm1 ecm1 = boost::choose_param( get_param(np1, internal_np::edge_is_constrained),
Corefinement::No_mark<TriangleMesh>() );
Ecm2 ecm2 = boost::choose_param( get_param(np2, CGAL::parameters::edge_is_constrained),
Ecm2 ecm2 = boost::choose_param( get_param(np2, internal_np::edge_is_constrained),
Corefinement::No_mark<TriangleMesh>() );
typedef Corefinement::Ecm_bind<TriangleMesh, Ecm1, Ecm2> Ecm;

38
Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/distance.h
View File

@ -340,28 +340,28 @@ sample_triangle_mesh(const TriangleMesh& tm,
using boost::get_param;
using boost::is_default_param;
Vpm pmap = choose_param(get_param(np, vertex_point),
Vpm pmap = choose_param(get_param(np, internal_np::vertex_point),
get_const_property_map(vertex_point, tm));
typedef Creator_uniform_3<typename Geom_traits::FT,
typename Geom_traits::Point_3> Creator;
Geom_traits geomtraits = choose_param(get_param(np, CGAL::parameters::geom_traits), Geom_traits());
Geom_traits geomtraits = choose_param(get_param(np, internal_np::geom_traits), Geom_traits());
bool use_rs = choose_param(get_param(np, CGAL::parameters::random_uniform_sampling), true);
bool use_gs = choose_param(get_param(np, CGAL::parameters::grid_sampling), false);
bool use_ms = choose_param(get_param(np, CGAL::parameters::monte_carlo_sampling), false);
bool use_rs = choose_param(get_param(np, internal_np::random_uniform_sampling), true);
bool use_gs = choose_param(get_param(np, internal_np::grid_sampling), false);
bool use_ms = choose_param(get_param(np, internal_np::monte_carlo_sampling), false);
if (use_gs || use_ms)
if (is_default_param(get_param(np, CGAL::parameters::random_uniform_sampling)))
if (is_default_param(get_param(np, internal_np::random_uniform_sampling)))
use_rs=false;
bool smpl_vrtcs = choose_param(get_param(np, CGAL::parameters::do_sample_vertices), true);
bool smpl_dgs = choose_param(get_param(np, CGAL::parameters::do_sample_edges), true);
bool smpl_fcs = choose_param(get_param(np, CGAL::parameters::do_sample_faces), true);
bool smpl_vrtcs = choose_param(get_param(np, internal_np::do_sample_vertices), true);
bool smpl_dgs = choose_param(get_param(np, internal_np::do_sample_edges), true);
bool smpl_fcs = choose_param(get_param(np, internal_np::do_sample_faces), true);
double nb_pts_a_u = choose_param(get_param(np, CGAL::parameters::nb_points_per_area_unit), 0.);
double nb_pts_l_u = choose_param(get_param(np, CGAL::parameters::nb_points_per_distance_unit), 0.);
double nb_pts_a_u = choose_param(get_param(np, internal_np::nb_points_per_area_unit), 0.);
double nb_pts_l_u = choose_param(get_param(np, internal_np::nb_points_per_distance_unit), 0.);
// sample vertices
if (smpl_vrtcs)
@ -376,7 +376,7 @@ sample_triangle_mesh(const TriangleMesh& tm,
// grid sampling
if (use_gs)
{
double grid_spacing_ = choose_param(get_param(np, CGAL::parameters::grid_spacing), 0.);
double grid_spacing_ = choose_param(get_param(np, internal_np::grid_spacing), 0.);
if (grid_spacing_==0.)
{
// set grid spacing to the shortest edge length
@ -403,9 +403,9 @@ sample_triangle_mesh(const TriangleMesh& tm,
double min_edge_length = (std::numeric_limits<double>::max)();
std::size_t nb_points_per_face =
choose_param(get_param(np, CGAL::parameters::number_of_points_per_face), 0);
choose_param(get_param(np, internal_np::number_of_points_per_face), 0);
std::size_t nb_points_per_edge =
choose_param(get_param(np, CGAL::parameters::number_of_points_per_edge), 0);
choose_param(get_param(np, internal_np::number_of_points_per_edge), 0);
if ((nb_points_per_face == 0 && nb_pts_a_u ==0.) ||
(nb_points_per_edge == 0 && nb_pts_l_u ==0.) )
@ -484,7 +484,7 @@ sample_triangle_mesh(const TriangleMesh& tm,
// sample faces
if(smpl_fcs)
{
std::size_t nb_points = choose_param(get_param(np, CGAL::parameters::number_of_points_on_faces), 0);
std::size_t nb_points = choose_param(get_param(np, internal_np::number_of_points_on_faces), 0);
Random_points_in_triangle_mesh_3<TriangleMesh, Vpm, Creator> g(tm, pmap);
if (nb_points == 0)
{
@ -500,7 +500,7 @@ sample_triangle_mesh(const TriangleMesh& tm,
if (smpl_dgs)
{
std::size_t nb_points =
choose_param(get_param(np, CGAL::parameters::number_of_points_on_edges), 0);
choose_param(get_param(np, internal_np::number_of_points_on_edges), 0);
Random_points_on_edge_list_graph_3<TriangleMesh, Vpm, Creator> g(tm, pmap);
if (nb_points == 0)
{
@ -626,7 +626,7 @@ double approximate_Hausdorff_distance( const TriangleMesh& tm1,
NamedParameters1>::type Geom_traits;
return approximate_Hausdorff_distance<Concurrency_tag, Geom_traits>(
tm1, tm2, np1, choose_param(get_param(np2, vertex_point),
tm1, tm2, np1, choose_param(get_param(np2, internal_np::vertex_point),
get_const_property_map(vertex_point, tm2)));
}
@ -683,7 +683,7 @@ double max_distance_to_triangle_mesh(const PointRange& points,
NamedParameters>::type Geom_traits;
return approximate_Hausdorff_distance<Concurrency_tag, Geom_traits>
(points,tm,choose_param(get_param(np, vertex_point),
(points,tm,choose_param(get_param(np, internal_np::vertex_point),
get_const_property_map(vertex_point, tm)));
}
@ -730,7 +730,7 @@ double approximate_max_distance_to_point_set(const TriangleMesh& tm,
typename GT::halfedge_descriptor hd(halfedge(f,tm));
for(int i=0; i<3; ++i)
{
points[i] = get(choose_param(get_param(np, vertex_point),
points[i] = get(choose_param(get_param(np, internal_np::vertex_point),
get_const_property_map(vertex_point, tm)),
target(hd, tm));
hd = next(hd, tm);

8
Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/fair.h
View File

@ -147,13 +147,13 @@ namespace internal {
typedef CGAL::internal::Cotangent_weight_with_voronoi_area_fairing<TriangleMesh, VPMap>
Default_Weight_calculator;
VPMap vpmap_ = choose_param(get_param(np, vertex_point),
VPMap vpmap_ = choose_param(get_param(np, internal_np::vertex_point),
get_property_map(vertex_point, tmesh));
return internal::fair(tmesh, vertices,
choose_param(get_param(np, CGAL::parameters::sparse_linear_solver), Default_solver()),
choose_param(get_param(np, CGAL::parameters::weight_calculator), Default_Weight_calculator(tmesh, vpmap_)),
choose_param(get_param(np, CGAL::parameters::fairing_continuity), 1),
choose_param(get_param(np, internal_np::sparse_linear_solver), Default_solver()),
choose_param(get_param(np, internal_np::weight_calculator), Default_Weight_calculator(tmesh, vpmap_)),
choose_param(get_param(np, internal_np::fairing_continuity), 1),
vpmap_
);
}

16
Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/internal/clip.h
View File

@ -61,13 +61,13 @@ clip_open_impl( TriangleMesh& tm,
typedef typename GT::halfedge_descriptor halfedge_descriptor;
typedef typename GT::face_descriptor face_descriptor;
Fid_map fid_map = boost::choose_param(get_param(np_tm, face_index),
get_property_map(face_index, tm));
Vid_map vid_map = boost::choose_param(get_param(np_tm, boost::vertex_index),
Fid_map fid_map = boost::choose_param(get_param(np_tm, internal_np::face_index),
get_property_map(boost::face_index, tm));
Vid_map vid_map = boost::choose_param(get_param(np_tm, internal_np::vertex_index),
get_property_map(boost::vertex_index, tm));
Vpm vpm1 = boost::choose_param(get_param(np_tm, vertex_point),
Vpm vpm1 = boost::choose_param(get_param(np_tm, internal_np::vertex_point),
get_property_map(vertex_point, tm));
Vpm vpm_c = boost::choose_param(get_param(np_c, vertex_point),
Vpm vpm_c = boost::choose_param(get_param(np_c, internal_np::vertex_point),
get_property_map(vertex_point, clipper));
// init indices if needed
@ -205,7 +205,7 @@ clip( TriangleMesh& tm,
return corefine_and_compute_intersection(tm, clipper, tm, np_tm, np_c);
return internal::clip_open_impl(tm, clipper,
get_param(np_tm, CGAL::parameters::edge_is_constrained), np_tm, np_c);
get_param(np_tm, internal_np::edge_is_constrained), np_tm, np_c);
}
/// \todo document me
@ -224,8 +224,8 @@ clip_to_bbox(const Plane_3& plane,
typedef typename GetVertexPointMap<TriangleMesh,
NamedParameters>::type Vpm;
Vpm vpm_out = boost::choose_param(get_param(np, vertex_point),
get_property_map(vertex_point, tm_out));
Vpm vpm_out = boost::choose_param(get_param(np, internal_np::vertex_point),
get_property_map(boost::vertex_point, tm_out));
cpp11::array<Point_3,8> corners= {{

47
Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/internal/named_function_params.h
View File

@ -30,17 +30,17 @@
#define CGAL_PMP_NP_CLASS CGAL::pmp_bgl_named_params<T,Tag,Base>
namespace CGAL{
namespace parameters{
namespace internal_np{
enum all_default_t { all_default }; //cannot use macro because it takes no argument
// define enum types and values for new named parameters
#define CGAL_add_named_parameter(X, Y, Z) \
enum X { Y };
#include <CGAL/Polygon_mesh_processing/internal/parameters_interface.h>
#undef CGAL_add_named_parameter
}//parameters
}//internal_np
template <typename T, typename Tag, typename Base = boost::no_property>
struct pmp_bgl_named_params
: CGAL::cgal_bgl_named_params<T, Tag, Base>
@ -50,10 +50,10 @@ enum all_default_t { all_default }; //cannot use macro because it takes no argum
pmp_bgl_named_params(T v = T()) : base(v) {}
pmp_bgl_named_params(T v, const Base& b) : base(v, b) {}
pmp_bgl_named_params<bool, parameters::all_default_t, self>
pmp_bgl_named_params<bool, internal_np::all_default_t, self>
all_default() const
{
typedef pmp_bgl_named_params<bool, parameters::all_default_t, self> Params;
typedef pmp_bgl_named_params<bool, internal_np::all_default_t, self> Params;
return Params(*this);
}
@ -61,24 +61,14 @@ enum all_default_t { all_default }; //cannot use macro because it takes no argum
// used to concatenate several parameters
#define CGAL_add_named_parameter(X, Y, Z) \
template<typename K> \
pmp_bgl_named_params<K, parameters::X, self> \
pmp_bgl_named_params<K, internal_np::X, self> \
Z(const K& k) const \
{ \
typedef pmp_bgl_named_params<K, parameters::X, self> Params; \
typedef pmp_bgl_named_params<K, internal_np::X, self> Params; \
return Params(k, *this); \
}
#include <CGAL/Polygon_mesh_processing/internal/parameters_interface.h>
#include <CGAL/boost/graph/parameters_interface.h>
#undef CGAL_add_named_parameter
#define CGAL_add_named_parameter(X, Y, Z) \
template<typename K> \
pmp_bgl_named_params<K, boost::X, self> \
Z(const K& k) const \
{ \
typedef pmp_bgl_named_params<K, boost::X, self> Params; \
return Params(k, *this); \
}
#include <CGAL/boost/graph/boost_parameters_interface.h>
#undef CGAL_add_named_parameter
};
@ -87,10 +77,10 @@ namespace Polygon_mesh_processing{
namespace parameters{
pmp_bgl_named_params<bool, CGAL::parameters::all_default_t>
pmp_bgl_named_params<bool, internal_np::all_default_t>
inline all_default()
{
typedef pmp_bgl_named_params<bool, CGAL::parameters::all_default_t> Params;
typedef pmp_bgl_named_params<bool, internal_np::all_default_t> Params;
return Params();
}
@ -106,24 +96,15 @@ pmp_bgl_named_params<bool, CGAL::parameters::all_default_t>
// define free functions for new named parameters and the one imported from BGL and boost
#define CGAL_add_named_parameter(X, Y, Z) \
template<typename K> \
pmp_bgl_named_params<K, CGAL::parameters::X> \
pmp_bgl_named_params<K, internal_np::X> \
Z(const K& k) \
{ \
typedef pmp_bgl_named_params<K, CGAL::parameters::X> Params; \
return Params(k); \
}
#include <CGAL/boost/graph/parameters_interface.h>
#include <CGAL/Polygon_mesh_processing/internal/parameters_interface.h>
#undef CGAL_add_named_parameter
#define CGAL_add_named_parameter(X, Y, Z) \
template<typename K> \
pmp_bgl_named_params<K, boost::X> \
Z(const K& k) \
{ \
typedef pmp_bgl_named_params<K, boost::X> Params; \
typedef pmp_bgl_named_params<K, internal_np::X> Params; \
return Params(k); \
}
#include <CGAL/boost/graph/boost_parameters_interface.h>
#include <CGAL/boost/graph/parameters_interface.h>
#include <CGAL/Polygon_mesh_processing/internal/parameters_interface.h>
#undef CGAL_add_named_parameter
} //namespace parameters
} //namespace Polygon_mesh_processing

18
Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/internal/named_params_helper.h
View File

@ -97,12 +97,12 @@ class GetVertexPointMap
DefaultVPMap;
public:
typedef typename boost::lookup_named_param_def<
boost::vertex_point_t,
internal_np::vertex_point_t,
NamedParameters,
DefaultVPMap
> ::type type;
typedef typename boost::lookup_named_param_def<
boost::vertex_point_t,
internal_np::vertex_point_t,
NamedParameters,
DefaultVPMap_const
> ::type const_type;
@ -118,7 +118,7 @@ public:
typedef typename CGAL::Kernel_traits<Point>::Kernel Kernel;
};
template<typename PolygonMesh, typename NamedParameters = pmp_bgl_named_params<bool, parameters::all_default_t> >
template<typename PolygonMesh, typename NamedParameters = pmp_bgl_named_params<bool, internal_np::all_default_t> >
class GetGeomTraits
{
typedef typename boost::graph_has_property<PolygonMesh, boost::vertex_point_t>::type
@ -132,7 +132,7 @@ class GetGeomTraits
public:
typedef typename boost::lookup_named_param_def <
CGAL::parameters::geom_traits_t,
internal_np::geom_traits_t,
NamedParameters,
DefaultKernel
> ::type type;
@ -161,12 +161,12 @@ class GetFaceIndexMap
typedef typename property_map_selector<PolygonMesh, boost::face_index_t>::const_type DefaultMap_const;
public:
typedef typename boost::lookup_named_param_def <
boost::face_index_t,
internal_np::face_index_t,
NamedParameters,
DefaultMap
> ::type type;
typedef typename boost::lookup_named_param_def <
boost::face_index_t,
internal_np::face_index_t,
NamedParameters,
DefaultMap_const
> ::type const_type;
@ -180,7 +180,7 @@ class GetVertexIndexMap
typedef typename property_map_selector<PolygonMesh, boost::vertex_index_t>::type DefaultMap;
public:
typedef typename boost::lookup_named_param_def <
boost::vertex_index_t,
internal_np::vertex_index_t,
NamedParameters,
DefaultMap
> ::type type;
@ -203,7 +203,7 @@ class GetFaceNormalMap
public:
typedef DummyNormalPmap NoMap;
typedef typename boost::lookup_named_param_def <
CGAL::parameters::face_normal_t,
internal_np::face_normal_t,
NamedParameters,
DummyNormalPmap//default
> ::type type;
@ -214,7 +214,7 @@ class GetSolver
{
public:
typedef typename boost::lookup_named_param_def <
CGAL::parameters::sparse_linear_solver_t,
internal_np::sparse_linear_solver_t,
NamedParameters,
DefaultSolver
> ::type type;

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

@ -85,10 +85,10 @@ surface_intersection(const TriangleMesh& tm1,
static const bool same_vpm = (boost::is_same<Vpm,Vpm2>::value);)
CGAL_static_assertion(same_vpm);
Vpm vpm1 = choose_const_pmap(get_param(np1, boost::vertex_point),
Vpm vpm1 = choose_const_pmap(get_param(np1, internal_np::vertex_point),
tm1,
vertex_point);
Vpm vpm2 = choose_const_pmap(get_param(np2, boost::vertex_point),
Vpm vpm2 = choose_const_pmap(get_param(np2, internal_np::vertex_point),
tm2,
vertex_point);

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

@ -96,7 +96,7 @@ namespace Polygon_mesh_processing {
using boost::get_param;
typename GetVertexPointMap<PolygonMesh, NamedParameters>::const_type
vpm = choose_param(get_param(np, vertex_point),
vpm = choose_param(get_param(np, internal_np::vertex_point),
get_const_property_map(CGAL::vertex_point, pmesh));
return CGAL::approximate_sqrt(CGAL::squared_distance(get(vpm, source(h, pmesh)),
@ -243,7 +243,7 @@ namespace Polygon_mesh_processing {
CGAL_precondition(boost::graph_traits<TriangleMesh>::null_face() != f);
typename GetVertexPointMap<TriangleMesh, CGAL_PMP_NP_CLASS>::const_type
vpm = choose_param(get_param(np, vertex_point),
vpm = choose_param(get_param(np, internal_np::vertex_point),
get_const_property_map(CGAL::vertex_point, tmesh));
typedef typename boost::graph_traits<TriangleMesh>::halfedge_descriptor halfedge_descriptor;
@ -424,7 +424,7 @@ volume(const TriangleMesh& tmesh, const CGAL_PMP_NP_CLASS& np)
using boost::get_param;
typename GetVertexPointMap<TriangleMesh, CGAL_PMP_NP_CLASS>::const_type
vpm = choose_param(get_param(np, vertex_point),
vpm = choose_param(get_param(np, internal_np::vertex_point),
get_const_property_map(CGAL::vertex_point, tmesh));
typename GetGeomTraits<TriangleMesh, CGAL_PMP_NP_CLASS>::type::Point_3
origin(0, 0, 0);

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

@ -114,7 +114,7 @@ bool is_outward_oriented(const PolygonMesh& pmesh,
//VertexPointMap
typedef typename GetVertexPointMap<PolygonMesh, NamedParameters>::const_type VPMap;
VPMap vpmap = choose_param(get_param(np, vertex_point),
VPMap vpmap = choose_param(get_param(np, internal_np::vertex_point),
get_const_property_map(vertex_point, pmesh));
//Kernel
typedef typename GetGeomTraits<PolygonMesh, NamedParameters>::type Kernel;

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

@ -88,14 +88,14 @@ namespace Polygon_mesh_processing {
CGAL_precondition(is_triangle_mesh(tmesh) );
typedef typename GetVertexPointMap<TriangleMesh,NamedParameters>::type VPmap;
VPmap vpm = choose_param(get_param(np, vertex_point),
VPmap vpm = choose_param(get_param(np, internal_np::vertex_point),
get_property_map(vertex_point, tmesh));
internal::Refine_Polyhedron_3<TriangleMesh, VPmap> refine_functor(tmesh, vpm);
refine_functor.refine(faces,
faces_out,
vertices_out,
choose_param(get_param(np, CGAL::parameters::density_control_factor), CGAL::sqrt(2.)));
choose_param(get_param(np, internal_np::density_control_factor), CGAL::sqrt(2.)));
return std::make_pair(faces_out, vertices_out);
}

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

@ -145,48 +145,48 @@ void isotropic_remeshing(const FaceRange& faces
typedef typename GetGeomTraits<PM, NamedParameters>::type GT;
typedef typename GetVertexPointMap<PM, NamedParameters>::type VPMap;
VPMap vpmap = choose_param(get_param(np, vertex_point),
VPMap vpmap = choose_param(get_param(np, internal_np::vertex_point),
get_property_map(vertex_point, pmesh));
typedef typename GetFaceIndexMap<PM, NamedParameters>::type FIMap;
FIMap fimap = choose_param(get_param(np, face_index),
FIMap fimap = choose_param(get_param(np, internal_np::face_index),
get_property_map(face_index, pmesh));
typedef typename boost::lookup_named_param_def <
CGAL::parameters::edge_is_constrained_t,
internal_np::edge_is_constrained_t,
NamedParameters,
internal::Border_constraint_pmap<PM, FaceRange, FIMap>//default
> ::type ECMap;
ECMap ecmap = (boost::is_same<ECMap, internal::Border_constraint_pmap<PM, FaceRange, FIMap> >::value)
//avoid constructing the Border_constraint_pmap if it's not used
? choose_param(get_param(np, CGAL::parameters::edge_is_constrained)
? choose_param(get_param(np, internal_np::edge_is_constrained)
, internal::Border_constraint_pmap<PM, FaceRange, FIMap>(pmesh, faces, fimap))
: choose_param(get_param(np, CGAL::parameters::edge_is_constrained)
: choose_param(get_param(np, internal_np::edge_is_constrained)
, internal::Border_constraint_pmap<PM, FaceRange, FIMap>());
typedef typename boost::lookup_named_param_def <
CGAL::parameters::vertex_is_constrained_t,
internal_np::vertex_is_constrained_t,
NamedParameters,
internal::No_constraint_pmap<vertex_descriptor>//default
> ::type VCMap;
VCMap vcmap = choose_param(get_param(np, CGAL::parameters::vertex_is_constrained),
VCMap vcmap = choose_param(get_param(np, internal_np::vertex_is_constrained),
internal::No_constraint_pmap<vertex_descriptor>());
typedef typename boost::lookup_named_param_def <
CGAL::parameters::face_patch_t,
internal_np::face_patch_t,
NamedParameters,
internal::Connected_components_pmap<PM, ECMap, FIMap>//default
> ::type FPMap;
FPMap fpmap = (boost::is_same<FPMap, internal::Connected_components_pmap<PM, ECMap, FIMap> >::value)
? choose_param(get_param(np, CGAL::parameters::face_patch),
? choose_param(get_param(np, internal_np::face_patch),
internal::Connected_components_pmap<PM, ECMap, FIMap>(pmesh, ecmap, fimap))
: choose_param(get_param(np, CGAL::parameters::face_patch),
: choose_param(get_param(np, internal_np::face_patch),
internal::Connected_components_pmap<PM, ECMap, FIMap>());//do not compute cc's
double low = 4. / 5. * target_edge_length;
double high = 4. / 3. * target_edge_length;
bool protect = choose_param(get_param(np, CGAL::parameters::protect_constraints), false);
bool protect = choose_param(get_param(np, internal_np::protect_constraints), false);
if(protect)
{
std::string msg("Isotropic remeshing : protect_constraints cannot be set to");
@ -214,9 +214,9 @@ void isotropic_remeshing(const FaceRange& faces
std::cout << " done ("<< t.time() <<" sec)." << std::endl;
#endif
unsigned int nb_iterations = choose_param(get_param(np, CGAL::parameters::number_of_iterations), 1);
bool smoothing_1d = choose_param(get_param(np, CGAL::parameters::relax_constraints), false);
unsigned int nb_laplacian = choose_param(get_param(np, CGAL::parameters::number_of_relaxation_steps), 1);
unsigned int nb_iterations = choose_param(get_param(np, internal_np::number_of_iterations), 1);
bool smoothing_1d = choose_param(get_param(np, internal_np::relax_constraints), false);
unsigned int nb_laplacian = choose_param(get_param(np, internal_np::number_of_relaxation_steps), 1);
#ifdef CGAL_PMP_REMESHING_VERBOSE
std::cout << std::endl;
@ -313,19 +313,19 @@ void split_long_edges(const EdgeRange& edges
typedef typename GetGeomTraits<PM, NamedParameters>::type GT;
typedef typename GetVertexPointMap<PM, NamedParameters>::type VPMap;
VPMap vpmap = choose_param(get_param(np, vertex_point),
VPMap vpmap = choose_param(get_param(np, internal_np::vertex_point),
get_property_map(vertex_point, pmesh));
typedef typename GetFaceIndexMap<PM, NamedParameters>::type FIMap;
FIMap fimap = choose_param(get_param(np, face_index),
FIMap fimap = choose_param(get_param(np, internal_np::face_index),
get_property_map(face_index, pmesh));
typedef typename boost::lookup_named_param_def <
CGAL::parameters::edge_is_constrained_t,
internal_np::edge_is_constrained_t,
NamedParameters,
internal::No_constraint_pmap<edge_descriptor>//default
> ::type ECMap;
ECMap ecmap = choose_param(get_param(np, CGAL::parameters::edge_is_constrained),
ECMap ecmap = choose_param(get_param(np, internal_np::edge_is_constrained),
internal::No_constraint_pmap<edge_descriptor>());
typename internal::Incremental_remesher<PM, VPMap, GT, ECMap,

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

@ -366,10 +366,10 @@ std::size_t remove_null_edges(
typedef typename GT::vertex_descriptor vertex_descriptor;
typedef typename GetVertexPointMap<TM, NamedParameters>::type VertexPointMap;
VertexPointMap vpmap = choose_param(get_param(np, vertex_point),
VertexPointMap vpmap = choose_param(get_param(np, internal_np::vertex_point),
get_property_map(vertex_point, tmesh));
typedef typename GetGeomTraits<TM, NamedParameters>::type Traits;
Traits traits = choose_param(get_param(np, CGAL::parameters::geom_traits), Traits());
Traits traits = choose_param(get_param(np, internal_np::geom_traits), Traits());
std::size_t nb_deg_faces = 0;
@ -687,10 +687,10 @@ std::size_t remove_degenerate_faces(TriangleMesh& tmesh,
typedef typename GT::vertex_descriptor vertex_descriptor;
typedef typename GetVertexPointMap<TM, NamedParameters>::type VertexPointMap;
VertexPointMap vpmap = choose_param(get_param(np, vertex_point),
VertexPointMap vpmap = choose_param(get_param(np, internal_np::vertex_point),
get_property_map(vertex_point, tmesh));
typedef typename GetGeomTraits<TM, NamedParameters>::type Traits;
Traits traits = choose_param(get_param(np, CGAL::parameters::geom_traits), Traits());
Traits traits = choose_param(get_param(np, internal_np::geom_traits), Traits());
// First remove edges of length 0
std::size_t nb_deg_faces = remove_null_edges(edges(tmesh), tmesh, np);

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

@ -336,8 +336,8 @@ self_intersections( const FaceRange& face_range,
);
typedef typename GetVertexPointMap<TM, NamedParameters>::const_type VertexPointMap;
VertexPointMap vpmap = boost::choose_param(get_param(np, vertex_point),
get_const_property_map(vertex_point, tmesh));
VertexPointMap vpmap = boost::choose_param(get_param(np, internal_np::vertex_point),
get_const_property_map(boost::vertex_point, tmesh));
BOOST_FOREACH(face_descriptor f, face_range)
{
@ -357,7 +357,7 @@ self_intersections( const FaceRange& face_range,
typedef typename GetGeomTraits<TM, NamedParameters>::type GeomTraits;
CGAL::internal::Intersect_facets<TM,GeomTraits,Box,OutputIterator,VertexPointMap>
intersect_facets(tmesh, out, vpmap,
boost::choose_param(get_param(np, CGAL::parameters::geom_traits), GeomTraits()));
boost::choose_param(get_param(np, internal_np::geom_traits), GeomTraits()));
std::ptrdiff_t cutoff = 2000;
CGAL::box_self_intersection_d(box_ptr.begin(), box_ptr.end(),intersect_facets,cutoff);

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

@ -305,7 +305,7 @@ void stitch_borders(PolygonMesh& pmesh,
using boost::get_param;
typedef typename GetVertexPointMap<PolygonMesh, NamedParameters>::const_type VPMap;
VPMap vpm = choose_param(get_param(np, vertex_point),
VPMap vpm = choose_param(get_param(np, internal_np::vertex_point),
get_const_property_map(vertex_point, pmesh));
internal::Naive_border_stitching_modifier<PolygonMesh, VPMap, HalfedgePairsRange>
@ -356,7 +356,7 @@ void stitch_borders(PolygonMesh& pmesh, const CGAL_PMP_NP_CLASS& np)
std::vector< std::pair<halfedge_descriptor, halfedge_descriptor> > hedge_pairs_to_stitch;
typedef typename GetVertexPointMap<PolygonMesh, CGAL_PMP_NP_CLASS>::const_type VPMap;
VPMap vpm = choose_param(get_param(np, vertex_point),
VPMap vpm = choose_param(get_param(np, internal_np::vertex_point),
get_const_property_map(vertex_point, pmesh));
internal::detect_duplicated_boundary_edges(pmesh,

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

@ -332,7 +332,7 @@ bool triangulate_face(typename boost::graph_traits<PolygonMesh>::face_descripto
//VertexPointMap
typedef typename GetVertexPointMap<PolygonMesh, NamedParameters>::type VPMap;
VPMap vpmap = choose_param(get_param(np, vertex_point),
VPMap vpmap = choose_param(get_param(np, internal_np::vertex_point),
get_property_map(vertex_point, pmesh));
//Kernel
typedef typename GetGeomTraits<PolygonMesh, NamedParameters>::type Kernel;
@ -382,7 +382,7 @@ bool triangulate_faces(FaceRange face_range,
//VertexPointMap
typedef typename GetVertexPointMap<PolygonMesh, NamedParameters>::type VPMap;
VPMap vpmap = choose_param(get_param(np, vertex_point),
VPMap vpmap = choose_param(get_param(np, internal_np::vertex_point),
get_property_map(vertex_point, pmesh));
//Kernel
typedef typename GetGeomTraits<PolygonMesh, NamedParameters>::type Kernel;

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

@ -94,7 +94,7 @@ namespace Polygon_mesh_processing {
#ifdef CGAL_HOLE_FILLING_DO_NOT_USE_DT3
false;
#else
choose_param(get_param(np, CGAL::parameters::use_delaunay_triangulation), true);
choose_param(get_param(np, internal_np::use_delaunay_triangulation), true);
#endif
CGAL_precondition(face(border_halfedge, pmesh) == boost::graph_traits<PolygonMesh>::null_face());
@ -102,9 +102,9 @@ namespace Polygon_mesh_processing {
return internal::triangulate_hole_polygon_mesh(pmesh,
border_halfedge,
out,
choose_param(get_param(np, vertex_point), get_property_map(vertex_point, pmesh)),
choose_param(get_param(np, internal_np::vertex_point), get_property_map(vertex_point, pmesh)),
use_dt3,
choose_param(get_param(np, CGAL::parameters::geom_traits), typename GetGeomTraits<PolygonMesh,NamedParameters>::type()))
choose_param(get_param(np, internal_np::geom_traits), typename GetGeomTraits<PolygonMesh,NamedParameters>::type()))
.first;
}
@ -339,7 +339,7 @@ namespace Polygon_mesh_processing {
#ifdef CGAL_HOLE_FILLING_DO_NOT_USE_DT3
false;
#else
choose_param(get_param(np, CGAL::parameters::use_delaunay_triangulation), true);
choose_param(get_param(np, internal_np::use_delaunay_triangulation), true);
#endif
typedef CGAL::internal::Weight_min_max_dihedral_and_area Weight;
@ -359,7 +359,7 @@ namespace Polygon_mesh_processing {
triangulate_hole_polyline(points, third_points, tracer, WC(),
use_dt3,
choose_param(get_param(np, CGAL::parameters::geom_traits),
choose_param(get_param(np, internal_np::geom_traits),
typename CGAL::Kernel_traits<Point>::Kernel()));
CGAL_assertion(holes.empty());

37
Polygon_mesh_processing/test/Polygon_mesh_processing/test_pmp_bgl_named_params.cpp
View File

@ -20,10 +20,10 @@ template<class NamedParameters>
void test_np(const NamedParameters& np)
{
// test values
assert( get_param(np,boost::vertex_index).v == 0 );
assert( get_param(np,CGAL::internal_np::vertex_index).v == 0 );
// assert( get_param(np,boost::halfedge_index).v == 1 );
assert( get_param(np,boost::face_index).v == 2 );
assert( get_param(np,boost::vertex_point).v == 3 );
assert( get_param(np,CGAL::internal_np::face_index).v == 2 );
assert( get_param(np,CGAL::internal_np::vertex_point).v == 3 );
// assert( get_param(np,boost::edge_index).v == 5 );
// assert( get_param(np,boost::graph_visitor).v == 6 );
// assert( get_param(np,CGAL::set_cache_policy).v == 7 );
@ -31,20 +31,20 @@ void test_np(const NamedParameters& np)
// assert( get_param(np,CGAL::get_cost_policy_params).v == 9 );
// assert( get_param(np,CGAL::get_placement_policy).v == 10 );
// assert( get_param(np,CGAL::get_placement_policy_params).v == 11 );
assert( get_param(np,CGAL::parameters::edge_is_constrained).v == 12 );
assert( get_param(np,CGAL::internal_np::edge_is_constrained).v == 12 );
// assert( get_param(np,CGAL::edge_is_constrained_params).v == 13 );
//
assert( get_param(np,CGAL::parameters::density_control_factor).v == 14 );
assert( get_param(np,CGAL::parameters::use_delaunay_triangulation).v == 15 );
assert( get_param(np,CGAL::parameters::fairing_continuity).v == 16 );
assert( get_param(np,CGAL::parameters::sparse_linear_solver).v == 17 );
assert( get_param(np,CGAL::parameters::weight_calculator).v == 18 );
assert( get_param(np,CGAL::internal_np::density_control_factor).v == 14 );
assert( get_param(np,CGAL::internal_np::use_delaunay_triangulation).v == 15 );
assert( get_param(np,CGAL::internal_np::fairing_continuity).v == 16 );
assert( get_param(np,CGAL::internal_np::sparse_linear_solver).v == 17 );
assert( get_param(np,CGAL::internal_np::weight_calculator).v == 18 );
//test types
check_same_type<0>( get_param(np,boost::vertex_index) );
check_same_type<0>( get_param(np,CGAL::internal_np::vertex_index) );
// check_same_type<1>( get_param(np,boost::halfedge_index) );
check_same_type<2>( get_param(np,boost::face_index) );
check_same_type<3>( get_param(np,boost::vertex_point) );
check_same_type<2>( get_param(np,CGAL::internal_np::face_index) );
check_same_type<3>( get_param(np,CGAL::internal_np::vertex_point) );
// check_same_type<5>( get_param(np,boost::edge_index) );
// check_same_type<6>( get_param(np,boost::graph_visitor) );
// check_same_type<7>( get_param(np,CGAL::set_cache_policy) );
@ -52,14 +52,14 @@ void test_np(const NamedParameters& np)
// check_same_type<9>( get_param(np,CGAL::get_cost_policy_params) );
// check_same_type<10>( get_param(np,CGAL::get_placement_policy) );
// check_same_type<11>( get_param(np,CGAL::get_placement_policy_params) );
check_same_type<12>( get_param(np,CGAL::parameters::edge_is_constrained) );
check_same_type<12>( get_param(np,CGAL::internal_np::edge_is_constrained) );
// check_same_type<13>( get_param(np,CGAL::edge_is_constrained_params) );
//
check_same_type<14>( get_param(np,CGAL::parameters::density_control_factor) );
check_same_type<15>( get_param(np,CGAL::parameters::use_delaunay_triangulation) );
check_same_type<16>( get_param(np,CGAL::parameters::fairing_continuity) );
check_same_type<17>( get_param(np,CGAL::parameters::sparse_linear_solver) );
check_same_type<18>( get_param(np,CGAL::parameters::weight_calculator) );
check_same_type<14>( get_param(np,CGAL::internal_np::density_control_factor) );
check_same_type<15>( get_param(np,CGAL::internal_np::use_delaunay_triangulation) );
check_same_type<16>( get_param(np,CGAL::internal_np::fairing_continuity) );
check_same_type<17>( get_param(np,CGAL::internal_np::sparse_linear_solver) );
check_same_type<18>( get_param(np,CGAL::internal_np::weight_calculator) );
}
int main()
@ -79,7 +79,6 @@ int main()
// get_placement(A<10>(10)).
// get_placement_params(A<11>(11)).
edge_is_constrained_map(A<12>(12)).
// edge_is_constrained_map_params(A<13>(13)).
// continue with PMP specific named params
density_control_factor(A<14>(14)).
use_delaunay_triangulation(A<15>(15)).

28
Surface_mesh_simplification/include/CGAL/Surface_mesh_simplification/edge_collapse.h
View File

@ -110,16 +110,16 @@ int edge_collapse ( ECM& aSurface
LindstromTurk_params lPolicyParams ;
boost::graph_visitor_t vis = boost::graph_visitor_t() ;
internal_np::graph_visitor_t vis = internal_np::graph_visitor_t() ;
return edge_collapse(aSurface
,aShould_stop
,choose_const_pmap(get_param(aParams,boost::vertex_index),aSurface,boost::vertex_index)
,choose_pmap(get_param(aParams,boost::vertex_point),aSurface,boost::vertex_point)
,choose_const_pmap(get_param(aParams,boost::halfedge_index),aSurface,boost::halfedge_index)
,choose_param (get_param(aParams,CGAL::parameters::edge_is_constrained),No_constrained_edge_map<ECM>())
,choose_param (get_param(aParams,CGAL::parameters::get_cost_policy), LindstromTurk_cost<ECM>())
,choose_param (get_param(aParams,CGAL::parameters::get_placement_policy), LindstromTurk_placement<ECM>())
,choose_const_pmap(get_param(aParams,internal_np::vertex_index),aSurface,boost::vertex_index)
,choose_pmap(get_param(aParams,internal_np::vertex_point),aSurface,boost::vertex_point)
,choose_const_pmap(get_param(aParams,internal_np::halfedge_index),aSurface,boost::halfedge_index)
,choose_param (get_param(aParams,internal_np::edge_is_constrained),No_constrained_edge_map<ECM>())
,choose_param (get_param(aParams,internal_np::get_cost_policy), LindstromTurk_cost<ECM>())
,choose_param (get_param(aParams,internal_np::get_placement_policy), LindstromTurk_placement<ECM>())
,choose_param (get_param(aParams,vis), Dummy_visitor())
);
@ -136,16 +136,16 @@ int edge_collapse ( ECM& aSurface
LindstromTurk_params lPolicyParams ;
boost::graph_visitor_t vis = boost::graph_visitor_t() ;
internal_np::graph_visitor_t vis = internal_np::graph_visitor_t() ;
return edge_collapse(aSurface
,aShould_stop
,choose_const_pmap(get_param(aParams,boost::vertex_index),aSurface,boost::vertex_index)
,choose_const_pmap(get_param(aParams,boost::vertex_point),aSurface,boost::vertex_point)
,choose_const_pmap(get_param(aParams,boost::halfedge_index),aSurface,boost::halfedge_index)
,choose_param (get_param(aParams,CGAL::parameters::edge_is_constrained),No_constrained_edge_map<ECM>())
,choose_param (get_param(aParams,CGAL::parameters::get_cost_policy), LindstromTurk_cost<ECM>())
,choose_param (get_param(aParams,CGAL::parameters::get_placement_policy), LindstromTurk_placement<ECM>())
,choose_const_pmap(get_param(aParams,internal_np::vertex_index),aSurface,boost::vertex_index)
,choose_const_pmap(get_param(aParams,internal_np::vertex_point),aSurface,boost::vertex_point)
,choose_const_pmap(get_param(aParams,internal_np::halfedge_index),aSurface,boost::halfedge_index)
,choose_param (get_param(aParams,internal_np::edge_is_constrained),No_constrained_edge_map<ECM>())
,choose_param (get_param(aParams,internal_np::get_cost_policy), LindstromTurk_cost<ECM>())
,choose_param (get_param(aParams,internal_np::get_placement_policy), LindstromTurk_placement<ECM>())
,choose_param (get_param(aParams,vis), Dummy_visitor())
);