diff --git a/Arrangement_on_surface_2/include/CGAL/graph_traits_Arrangement_2.h b/Arrangement_on_surface_2/include/CGAL/graph_traits_Arrangement_2.h index c2f60f80039..f8c9dcdb219 100644 --- a/Arrangement_on_surface_2/include/CGAL/graph_traits_Arrangement_2.h +++ b/Arrangement_on_surface_2/include/CGAL/graph_traits_Arrangement_2.h @@ -33,7 +33,7 @@ */ // include this to avoid a VC15 warning -#include +#include #include #include diff --git a/Arrangement_on_surface_2/include/CGAL/graph_traits_dual_arrangement_2.h b/Arrangement_on_surface_2/include/CGAL/graph_traits_dual_arrangement_2.h index 060db488191..d9bed57a668 100644 --- a/Arrangement_on_surface_2/include/CGAL/graph_traits_dual_arrangement_2.h +++ b/Arrangement_on_surface_2/include/CGAL/graph_traits_dual_arrangement_2.h @@ -34,7 +34,7 @@ */ // include this to avoid a VC15 warning -#include +#include #include #include diff --git a/Arrangement_on_surface_2/include/CGAL/graph_traits_dual_arrangement_on_surface_2.h b/Arrangement_on_surface_2/include/CGAL/graph_traits_dual_arrangement_on_surface_2.h index ac1180a7a6d..767821316db 100644 --- a/Arrangement_on_surface_2/include/CGAL/graph_traits_dual_arrangement_on_surface_2.h +++ b/Arrangement_on_surface_2/include/CGAL/graph_traits_dual_arrangement_on_surface_2.h @@ -34,7 +34,7 @@ */ // include this to avoid a VC15 warning -#include +#include #include #include diff --git a/Arrangement_on_surface_2/include/CGAL/graph_traits_dual_arrangement_on_surface_with_history_2.h b/Arrangement_on_surface_2/include/CGAL/graph_traits_dual_arrangement_on_surface_with_history_2.h index a93ff9f0ed8..0156c854a14 100644 --- a/Arrangement_on_surface_2/include/CGAL/graph_traits_dual_arrangement_on_surface_with_history_2.h +++ b/Arrangement_on_surface_2/include/CGAL/graph_traits_dual_arrangement_on_surface_with_history_2.h @@ -35,7 +35,7 @@ */ // include this to avoid a VC15 warning -#include +#include #include #include diff --git a/Arrangement_on_surface_2/include/CGAL/graph_traits_dual_arrangement_with_history_2.h b/Arrangement_on_surface_2/include/CGAL/graph_traits_dual_arrangement_with_history_2.h index 6ab1c8c5b51..03848de9e1f 100644 --- a/Arrangement_on_surface_2/include/CGAL/graph_traits_dual_arrangement_with_history_2.h +++ b/Arrangement_on_surface_2/include/CGAL/graph_traits_dual_arrangement_with_history_2.h @@ -35,7 +35,7 @@ */ // include this to avoid a VC15 warning -#include +#include #include #include diff --git a/BGL/include/CGAL/boost/graph/Face_filtered_graph.h b/BGL/include/CGAL/boost/graph/Face_filtered_graph.h index 6995d383ce7..5e492063e7c 100644 --- a/BGL/include/CGAL/boost/graph/Face_filtered_graph.h +++ b/BGL/include/CGAL/boost/graph/Face_filtered_graph.h @@ -24,7 +24,7 @@ #include #include #include -#include +#include #include #include #include @@ -148,9 +148,9 @@ struct Face_filtered_graph #endif ) : _graph(const_cast(graph)) - , fimap(boost::choose_param(get_param(np, internal_np::face_index), get_const_property_map(face_index, graph))) - , vimap(boost::choose_param(get_param(np, boost::vertex_index), get_const_property_map(boost::vertex_index, graph))) - , himap(boost::choose_param(get_param(np, internal_np::halfedge_index), get_const_property_map(halfedge_index, graph))) + , fimap(parameters::choose_parameter(parameters::get_parameter(np, internal_np::face_index), get_const_property_map(face_index, graph))) + , vimap(parameters::choose_parameter(parameters::get_parameter(np, internal_np::vertex_index), get_const_property_map(boost::vertex_index, graph))) + , himap(parameters::choose_parameter(parameters::get_parameter(np, internal_np::halfedge_index), get_const_property_map(halfedge_index, graph))) { set_selected_faces(selected_face_patch_indices, face_patch_index_map); } @@ -203,9 +203,9 @@ struct Face_filtered_graph const CGAL_BGL_NP_CLASS& np ) : _graph(const_cast(graph)) - , fimap(boost::choose_param(get_param(np, internal_np::face_index), get_const_property_map(face_index, graph))) - , vimap(boost::choose_param(get_param(np, boost::vertex_index), get_const_property_map(boost::vertex_index, graph))) - , himap(boost::choose_param(get_param(np, internal_np::halfedge_index), get_const_property_map(halfedge_index, graph))) + , fimap(parameters::choose_parameter(parameters::get_parameter(np, internal_np::face_index), get_const_property_map(face_index, graph))) + , vimap(parameters::choose_parameter(parameters::get_parameter(np, internal_np::vertex_index), get_const_property_map(boost::vertex_index, graph))) + , himap(parameters::choose_parameter(parameters::get_parameter(np, internal_np::halfedge_index), get_const_property_map(halfedge_index, graph))) { set_selected_faces(selected_face_patch_index, face_patch_index_map); } @@ -248,9 +248,9 @@ struct Face_filtered_graph const FaceRange& selected_faces, const CGAL_BGL_NP_CLASS& np) : _graph(const_cast(graph)) - , fimap(boost::choose_param(get_param(np, internal_np::face_index), get_const_property_map(face_index, graph))) - , vimap(boost::choose_param(get_param(np, boost::vertex_index), get_const_property_map(boost::vertex_index, graph))) - , himap(boost::choose_param(get_param(np, internal_np::halfedge_index), get_const_property_map(halfedge_index, graph))) + , fimap(parameters::choose_parameter(parameters::get_parameter(np, internal_np::face_index), get_const_property_map(face_index, graph))) + , vimap(parameters::choose_parameter(parameters::get_parameter(np, internal_np::vertex_index), get_const_property_map(boost::vertex_index, graph))) + , himap(parameters::choose_parameter(parameters::get_parameter(np, internal_np::halfedge_index), get_const_property_map(halfedge_index, graph))) { set_selected_faces(selected_faces); } diff --git a/BGL/include/CGAL/boost/graph/METIS/partition_dual_graph.h b/BGL/include/CGAL/boost/graph/METIS/partition_dual_graph.h index 7e2a15870a7..32e99bb34ff 100644 --- a/BGL/include/CGAL/boost/graph/METIS/partition_dual_graph.h +++ b/BGL/include/CGAL/boost/graph/METIS/partition_dual_graph.h @@ -26,7 +26,7 @@ #include #include #include -#include +#include #include #include @@ -51,8 +51,8 @@ void partition_dual_graph(const TriangleMesh& tm, CGAL_precondition(CGAL::is_triangle_mesh(tm)); CGAL_precondition_msg(nparts > 1, ("Partitioning requires a number of parts > 1")); - using boost::choose_param; - using boost::get_param; + using parameters::choose_parameter; + using parameters::get_parameter; typedef typename boost::graph_traits::vertex_descriptor vertex_descriptor; typedef typename boost::graph_traits::halfedge_descriptor halfedge_descriptor; @@ -60,7 +60,7 @@ void partition_dual_graph(const TriangleMesh& tm, // vertex index map typedef typename CGAL::Polygon_mesh_processing::GetVertexIndexMap::type Indices; - Indices indices = choose_param(get_param(np, internal_np::vertex_index), + Indices indices = choose_parameter(get_parameter(np, internal_np::vertex_index), get_const_property_map(boost::vertex_index, tm)); idx_t nn = static_cast(num_vertices(tm)); @@ -119,8 +119,8 @@ void partition_dual_graph(const TriangleMesh& tm, Output_vertex_partition_ids vo; Output_face_partition_ids fo; - vo(tm, indices, npart, get_param(np, internal_np::vertex_partition_id)); - fo(tm, epart, get_param(np, internal_np::face_partition_id)); + vo(tm, indices, npart, get_parameter(np, internal_np::vertex_partition_id)); + fo(tm, epart, get_parameter(np, internal_np::face_partition_id)); delete[] eptr; delete[] eind; @@ -131,7 +131,7 @@ void partition_dual_graph(const TriangleMesh& tm, template void partition_dual_graph(const TriangleMesh& tm, int nparts, - const boost::param_not_found, // no METIS options were passed + const internal_np::Param_not_found, // no METIS options were passed const NamedParameters& np) { idx_t options[METIS_NOPTIONS]; @@ -180,9 +180,9 @@ void partition_dual_graph(const TriangleMesh& tm, int nparts, template void partition_dual_graph(const TriangleMesh& tm, int nparts, const NamedParameters& np) { - using boost::get_param; + using parameters::get_parameter; - return partition_dual_graph(tm, nparts, get_param(np, internal_np::METIS_options), np); + return partition_dual_graph(tm, nparts, get_parameter(np, internal_np::METIS_options), np); } template diff --git a/BGL/include/CGAL/boost/graph/METIS/partition_graph.h b/BGL/include/CGAL/boost/graph/METIS/partition_graph.h index d0f3e56b759..48875922720 100644 --- a/BGL/include/CGAL/boost/graph/METIS/partition_graph.h +++ b/BGL/include/CGAL/boost/graph/METIS/partition_graph.h @@ -24,7 +24,7 @@ #include #include #include -#include +#include #include #include @@ -44,7 +44,7 @@ struct Output_vertex_partition_ids { template void operator()(const TriangleMesh&, const Indices, - idx_t const * const, boost::param_not_found) { } + idx_t const * const, internal_np::Param_not_found) { } template void operator()(const TriangleMesh&, - idx_t const * const, boost::param_not_found) { } + idx_t const * const, internal_np::Param_not_found) { } template void operator()(const TriangleMesh& tm, idx_t const * const epart, @@ -86,8 +86,8 @@ void partition_graph(const TriangleMesh& tm, CGAL_precondition(CGAL::is_triangle_mesh(tm)); CGAL_precondition_msg(nparts > 1, ("Partitioning requires a number of parts > 1")); - using boost::choose_param; - using boost::get_param; + using parameters::choose_parameter; + using parameters::get_parameter; typedef typename boost::graph_traits::vertex_descriptor vertex_descriptor; typedef typename boost::graph_traits::halfedge_descriptor halfedge_descriptor; @@ -95,7 +95,7 @@ void partition_graph(const TriangleMesh& tm, //Vertex index map typedef typename CGAL::Polygon_mesh_processing::GetVertexIndexMap::type Indices; - Indices indices = choose_param(get_param(np, internal_np::vertex_index), + Indices indices = choose_parameter(get_parameter(np, internal_np::vertex_index), get_const_property_map(boost::vertex_index, tm)); idx_t nn = static_cast(num_vertices(tm)); @@ -151,8 +151,8 @@ void partition_graph(const TriangleMesh& tm, Output_vertex_partition_ids vo; Output_face_partition_ids fo; - vo(tm, indices, npart, get_param(np, internal_np::vertex_partition_id)); - fo(tm, epart, get_param(np, internal_np::face_partition_id)); + vo(tm, indices, npart, get_parameter(np, internal_np::vertex_partition_id)); + fo(tm, epart, get_parameter(np, internal_np::face_partition_id)); delete[] eptr; delete[] eind; @@ -163,7 +163,7 @@ void partition_graph(const TriangleMesh& tm, template void partition_graph(const TriangleMesh& tm, int nparts, - const boost::param_not_found, // no METIS options were passed + const internal_np::Param_not_found, // no METIS options were passed const NamedParameters& np) { idx_t options[METIS_NOPTIONS]; @@ -212,9 +212,9 @@ void partition_graph(const TriangleMesh& tm, int nparts, template void partition_graph(const TriangleMesh& tm, int nparts, const NamedParameters& np) { - using boost::get_param; + using parameters::get_parameter; - return partition_graph(tm, nparts, get_param(np, internal_np::METIS_options), np); + return partition_graph(tm, nparts, get_parameter(np, internal_np::METIS_options), np); } template diff --git a/BGL/include/CGAL/boost/graph/Named_function_parameters.h b/BGL/include/CGAL/boost/graph/Named_function_parameters.h new file mode 100644 index 00000000000..055bfeebc36 --- /dev/null +++ b/BGL/include/CGAL/boost/graph/Named_function_parameters.h @@ -0,0 +1,237 @@ +// Copyright (c) 2019 GeometryFactory (France). All rights reserved. +// +// This file is part of CGAL (www.cgal.org); you can redistribute it and/or +// modify it under the terms of the GNU Lesser General Public License as +// published by the Free Software Foundation; either version 3 of the License, +// or (at your option) any later version. +// +// Licensees holding a valid commercial license may use this file in +// accordance with the commercial license agreement provided with the software. +// +// This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE +// WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. +// +// $URL$ +// $Id$ +// SPDX-License-Identifier: LGPL-3.0+ +// +// +// Author(s) : Sebastien Loriot + +#ifndef CGAL_BOOST_GRAPH_NAMED_FUNCTION_PARAMS_H +#define CGAL_BOOST_GRAPH_NAMED_FUNCTION_PARAMS_H + +#include + +#include +#include + +#define CGAL_BGL_NP_TEMPLATE_PARAMETERS T, typename Tag, typename Base +#define CGAL_BGL_NP_CLASS CGAL::Named_function_parameters + + +namespace CGAL { +namespace internal_np{ + +struct No_property {}; +struct Param_not_found {}; + +enum all_default_t { all_default }; + +// define enum types and values for new named parameters +#define CGAL_add_named_parameter(X, Y, Z) \ + enum X { Y }; +#include +#undef CGAL_add_named_parameter + +template +struct Named_params_impl : Base +{ + T v; // copy of the parameter + Named_params_impl(T v, const Base& b) + : Base(b) + , v(v) + {} +}; + +// partial specialization for base class of the recursive nesting +template +struct Named_params_impl +{ + T v; // copy of the parameter + Named_params_impl(T v) + : v(v) + {} +}; + +// Helper class to get the type of a named parameter pack given a query tag +template +struct Get_param; + +template< typename T, typename Tag, typename Query_tag> +struct Get_param< Named_params_impl, Query_tag > +{ + typedef Param_not_found type; +}; + +template< typename T, typename Tag, typename Base> +struct Get_param< Named_params_impl, Tag > +{ + typedef T type; +}; + +template< typename T, typename Tag> +struct Get_param< Named_params_impl, Tag > +{ + typedef T type; +}; + + +template< typename T, typename Tag, typename Base, typename Query_tag> +struct Get_param< Named_params_impl, Query_tag> +{ + typedef typename Get_param::type type; +}; + +// helper to choose the default +template +struct Lookup_named_param_def +{ + typedef typename internal_np::Get_param::type NP_type; + + typedef typename boost::mpl::if_< + boost::is_same, + D, NP_type>::type + type; +}; + +// helper function to extract the value from a named parameter pack given a query tag +template +T get_parameter_impl(const Named_params_impl& np, Tag) +{ + return np.v; +} + +template< typename T, typename Tag, typename Query_tag> +Param_not_found get_parameter_impl(const Named_params_impl&, Query_tag) +{ + return Param_not_found(); +} + +template< typename T, typename Tag> +T get_parameter_impl(const Named_params_impl& np, Tag) +{ + return np.v; +}; + +template +typename Get_param, Query_tag>::type +get_parameter_impl(const Named_params_impl& np, Query_tag tag) +{ + CGAL_static_assertion( (!boost::is_same::value) ); + return get_parameter_impl(static_cast(np), tag); +} + +} // end of internal_np namespace + + +template +struct Named_function_parameters + : internal_np::Named_params_impl +{ + typedef internal_np::Named_params_impl base; + typedef Named_function_parameters self; + + Named_function_parameters(T v = T()) : base(v) {} + Named_function_parameters(T v, const Base& b) : base(v, b) {} + + Named_function_parameters + all_default() const + { + typedef Named_function_parameters Params; + return Params(*this); + } + +// create the functions for new named parameters and the one imported boost +// used to concatenate several parameters +#define CGAL_add_named_parameter(X, Y, Z) \ + template \ + Named_function_parameters \ + Z(const K& k) const \ + { \ + typedef Named_function_parameters Params;\ + return Params(k, *this); \ + } +#include +#undef CGAL_add_named_parameter +}; + +namespace parameters { + +Named_function_parameters +inline all_default() +{ + typedef Named_function_parameters Params; + return Params(); +} + +template +Named_function_parameters +inline no_parameters(Named_function_parameters) +{ + typedef Named_function_parameters Params; + return Params(); +} + +// define free functions for named parameters +#define CGAL_add_named_parameter(X, Y, Z) \ + template \ + Named_function_parameters \ + Z(K const& p) \ + { \ + typedef Named_function_parameters Params;\ + return Params(p); \ + } +#include +#undef CGAL_add_named_parameter + +// function to extract a parameter +template +typename internal_np::Get_param, Query_tag>::type +get_parameter(const Named_function_parameters& np, Query_tag tag) +{ + return internal_np::get_parameter_impl(static_cast&>(np), tag); +} + +template +D choose_parameter(const internal_np::Param_not_found&, const D& d) +{ + return d; +} + +template +const T& +choose_parameter(const T& t, const D&) +{ + return t; +} + +bool inline is_default_parameter(const internal_np::Param_not_found&) +{ + return true; +} + +template +bool is_default_parameter(const T&) +{ + return false; +} + +} // end of parameters namespace + +} //namespace CGAL + + + + +#endif // CGAL_BOOST_GRAPH_NAMED_FUNCTION_PARAMS_HPP diff --git a/BGL/include/CGAL/boost/graph/boost_parameters_interface.h b/BGL/include/CGAL/boost/graph/boost_parameters_interface.h deleted file mode 100644 index 8af0898910d..00000000000 --- a/BGL/include/CGAL/boost/graph/boost_parameters_interface.h +++ /dev/null @@ -1,23 +0,0 @@ -// Copyright (c) 2017 GeometryFactory (France). All rights reserved. -// -// This file is part of CGAL (www.cgal.org); you can redistribute it and/or -// modify it under the terms of the GNU Lesser General Public License as -// published by the Free Software Foundation; either version 3 of the License, -// or (at your option) any later version. -// -// Licensees holding a valid commercial license may use this file in -// accordance with the commercial license agreement provided with the software. -// -// This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE -// WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. -// -// $URL$ -// $Id$ -// SPDX-License-Identifier: LGPL-3.0+ -// -// -// 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, vertex_index_map) -CGAL_add_named_parameter(graph_visitor_t, graph_visitor, visitor) diff --git a/BGL/include/CGAL/boost/graph/copy_face_graph.h b/BGL/include/CGAL/boost/graph/copy_face_graph.h index 3a869f2838c..980dc093db7 100644 --- a/BGL/include/CGAL/boost/graph/copy_face_graph.h +++ b/BGL/include/CGAL/boost/graph/copy_face_graph.h @@ -29,7 +29,7 @@ #include #include #include -#include +#include #include #include #include @@ -248,7 +248,7 @@ boost::function_output_iterator > make_functor(PMA return boost::make_function_output_iterator(Output_iterator_functor(map)); } -inline Emptyset_iterator make_functor(const boost::param_not_found&) +inline Emptyset_iterator make_functor(const internal_np::Param_not_found&) { return Emptyset_iterator(); } @@ -332,26 +332,27 @@ template void copy_face_graph(const SourceMesh& sm, TargetMesh& tm, #ifndef DOXYGEN_RUNNING - const CGAL::cgal_bgl_named_params& np1, - const CGAL::cgal_bgl_named_params& np2 + const CGAL::Named_function_parameters& np1, + const CGAL::Named_function_parameters& np2 #else const NamedParameters1& np1, const NamedParameters2& np2 #endif ) { - using boost::choose_param; + using parameters::choose_parameter; + using parameters::get_parameter; internal::copy_face_graph(sm, tm, CGAL::graph_has_property(), - choose_param(get_param(np1, internal_np::vertex_to_vertex_output_iterator), - impl::make_functor(get_param(np1, internal_np::vertex_to_vertex_map))), - choose_param(get_param(np1, internal_np::halfedge_to_halfedge_output_iterator), - impl::make_functor(get_param(np1, internal_np::halfedge_to_halfedge_map))), - choose_param(get_param(np1, internal_np::face_to_face_output_iterator), - impl::make_functor(get_param(np1, internal_np::face_to_face_map))), - choose_param(get_param(np1, internal_np::vertex_point), + choose_parameter(get_parameter(np1, internal_np::vertex_to_vertex_output_iterator), + impl::make_functor(get_parameter(np1, internal_np::vertex_to_vertex_map))), + choose_parameter(get_parameter(np1, internal_np::halfedge_to_halfedge_output_iterator), + impl::make_functor(get_parameter(np1, internal_np::halfedge_to_halfedge_map))), + choose_parameter(get_parameter(np1, internal_np::face_to_face_output_iterator), + impl::make_functor(get_parameter(np1, internal_np::face_to_face_map))), + choose_parameter(get_parameter(np1, internal_np::vertex_point), get(vertex_point, sm)), - choose_param(get_param(np2, internal_np::vertex_point), + choose_parameter(get_parameter(np2, internal_np::vertex_point), get(vertex_point, tm))); } @@ -364,7 +365,7 @@ void copy_face_graph(const SourceMesh& sm, TargetMesh& tm) template void copy_face_graph(const SourceMesh& sm, TargetMesh& tm, - const CGAL::cgal_bgl_named_params& np) + const CGAL::Named_function_parameters& np) { copy_face_graph(sm, tm, np, parameters::all_default()); } diff --git a/BGL/include/CGAL/boost/graph/dijkstra_shortest_paths.h b/BGL/include/CGAL/boost/graph/dijkstra_shortest_paths.h index 9b5ca5fc66e..265fb0b07dd 100644 --- a/BGL/include/CGAL/boost/graph/dijkstra_shortest_paths.h +++ b/BGL/include/CGAL/boost/graph/dijkstra_shortest_paths.h @@ -23,7 +23,7 @@ #define CGAL_BOOST_GRAPH_DIJKSTRA_SHORTEST_PATHS_H // This will push/pop a VC15 warning -#include +#include #include #include diff --git a/BGL/include/CGAL/boost/graph/graph_traits_OpenMesh.h b/BGL/include/CGAL/boost/graph/graph_traits_OpenMesh.h index 9c624d32537..5a6ad46d9ab 100644 --- a/BGL/include/CGAL/boost/graph/graph_traits_OpenMesh.h +++ b/BGL/include/CGAL/boost/graph/graph_traits_OpenMesh.h @@ -19,7 +19,7 @@ // Author(s) : Andreas Fabri, Philipp Moeller // include this to avoid a VC15 warning -#include +#include #include #include diff --git a/BGL/include/CGAL/boost/graph/io.h b/BGL/include/CGAL/boost/graph/io.h index cb5c8082b21..fb89e6e3b0a 100644 --- a/BGL/include/CGAL/boost/graph/io.h +++ b/BGL/include/CGAL/boost/graph/io.h @@ -33,7 +33,7 @@ #include #include #include -#include +#include #include namespace CGAL { @@ -143,8 +143,11 @@ bool write_off(std::ostream& os, typedef typename boost::graph_traits::vertices_size_type vertices_size_type; typedef typename boost::graph_traits::faces_size_type faces_size_type; + using parameters::choose_parameter; + using parameters::get_parameter; + typename Polygon_mesh_processing::GetVertexPointMap::const_type - vpm = choose_param(get_param(np, internal_np::vertex_point), + vpm = choose_parameter(get_parameter(np, internal_np::vertex_point), get_const_property_map(CGAL::vertex_point, g)); vertices_size_type nv = static_cast(std::distance(vertices(g).first, vertices(g).second)); faces_size_type nf = static_cast(std::distance(faces(g).first, faces(g).second)); @@ -259,6 +262,8 @@ bool read_off(std::istream& is, NamedParameters np) { using namespace internal::read_off_tools; + using parameters::choose_parameter; + using parameters::get_parameter; typedef typename boost::graph_traits::vertex_descriptor vertex_descriptor; typedef typename boost::graph_traits::vertices_size_type vertices_size_type; @@ -267,7 +272,7 @@ bool read_off(std::istream& is, typedef typename Polygon_mesh_processing::GetVertexPointMap::type Vpm; typedef typename boost::property_traits::value_type Point_3; - Vpm vpm = choose_param(get_param(np, internal_np::vertex_point), + Vpm vpm = choose_parameter(get_parameter(np, internal_np::vertex_point), get_property_map(CGAL::vertex_point, g)); vertices_size_type nv, nvf; faces_size_type nf; @@ -370,7 +375,10 @@ bool write_inp(std::ostream& os, typedef typename Polygon_mesh_processing::GetVertexPointMap::const_type VPM; typedef typename boost::property_traits::value_type Point_3; - VPM vpm = choose_param(get_param(np, internal_np::vertex_point), + using parameters::choose_parameter; + using parameters::get_parameter; + + VPM vpm = choose_parameter(get_parameter(np, internal_np::vertex_point), get_const_property_map(CGAL::vertex_point, g)); os << "*Part, name=" << name << "\n*Node\n"; diff --git a/BGL/include/CGAL/boost/graph/named_function_params.h b/BGL/include/CGAL/boost/graph/named_function_params.h deleted file mode 100644 index 9ec2365d134..00000000000 --- a/BGL/include/CGAL/boost/graph/named_function_params.h +++ /dev/null @@ -1,205 +0,0 @@ -//======================================================================= -// Copyright 1997, 1998, 1999, 2000 University of Notre Dame. -// Authors: Andrew Lumsdaine, Lie-Quan Lee, Jeremy G. Siek -// -// This file is part of the Boost Graph Library -// -// Distributed under the Boost Software License, Version 1.0. (See -// accompanying file LICENSE_1_0.txt or copy at -// https://www.boost.org/LICENSE_1_0.txt) -//======================================================================= -// Copyright (c) 2007 GeometryFactory (France). All rights reserved. -// -// $URL$ -// $Id$ -// SPDX-License-Identifier: BSL-1.0 -// -// Author(s) : Andreas Fabri, Fernando Cacciola - -#ifndef CGAL_BOOST_GRAPH_NAMED_FUNCTION_PARAMS_H -#define CGAL_BOOST_GRAPH_NAMED_FUNCTION_PARAMS_H - -#include - -#include - -#include -#if defined(BOOST_MSVC) -# pragma warning(push) -# pragma warning(disable:4172) // returning address of local variable or temporary -#endif - -#include - -#if defined(BOOST_MSVC) -# pragma warning(pop) -#endif - - -#include -#include - -// An explanation about the version hackery below: There is no real -// API to introduce custom properties to the Graph API and the -// internals have changed with Boost Version 1.51 and changes aren't -// backward compatible. To work around that we carry around two -// versions of cgal_bgl_named_params. One imitates the pre 1.51 -// bgl_named_params, the newer one hooks into the API through -// inheritance and addition of the some partial specializations. - -#if BOOST_VERSION < 105100 -namespace boost{ - typedef detail::error_property_not_found param_not_found; - - template - struct lookup_named_param_def { - typedef Def type; - static const Def& get(const Args&, const Def& def) {return def;} - }; - - template - struct lookup_named_param_def, Def> { - typedef T type; - static const type& get(const bgl_named_params& p, const Def&) { - return p.m_value; - } - }; - - template - struct lookup_named_param_def, Def> { - typedef typename lookup_named_param_def::type type; - static const type& get(const bgl_named_params& p, const Def& def) { - return lookup_named_param_def::get(p.m_base, def); - } - }; -} //end of namespace boost -#endif - -#define CGAL_BGL_NP_TEMPLATE_PARAMETERS T, typename Tag, typename Base -#define CGAL_BGL_NP_CLASS CGAL::cgal_bgl_named_params - -namespace CGAL { -namespace internal_np{ -enum all_default_t { all_default }; //cannot use macro because it takes no argument - -// 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::graph_visitor; - -// define enum types and values for new named parameters -#define CGAL_add_named_parameter(X, Y, Z) \ - enum X { Y }; -#include -#undef CGAL_add_named_parameter - -}//internal_np - - template - struct cgal_bgl_named_params : boost::bgl_named_params - { - typedef boost::bgl_named_params base; - typedef cgal_bgl_named_params self; - - cgal_bgl_named_params(T v = T()) : base(v) {} - cgal_bgl_named_params(T v, const Base& b) : base(v, b) {} - cgal_bgl_named_params - all_default() const - { - typedef cgal_bgl_named_params Params; - return Params(*this); - } - -// create the functions for new named parameters and the one imported boost -// used to concatenate several parameters -#define CGAL_add_named_parameter(X, Y, Z) \ - template \ - cgal_bgl_named_params \ - Z(const K& k) const \ - { \ - typedef cgal_bgl_named_params Params;\ - return Params(k, *this); \ - } -#include -#include -#undef CGAL_add_named_parameter - }; - -namespace parameters { - - cgal_bgl_named_params - inline all_default() - { - typedef cgal_bgl_named_params Params; - return Params(); - } - - - template - cgal_bgl_named_params - inline no_parameters(cgal_bgl_named_params) - { - typedef cgal_bgl_named_params Params; - return Params(); - } - -// define free functions for named parameters -#define CGAL_add_named_parameter(X, Y, Z) \ - template \ - cgal_bgl_named_params \ - Z(K const& p) \ - { \ - typedef cgal_bgl_named_params Params;\ - return Params(p); \ - } -#include -#include -#undef CGAL_add_named_parameter - - } // namespace parameters - -} //namespace CGAL - -// partial specializations hate inheritance and we need to repeat -// those here. this is rather fragile. -namespace boost { - -#if BOOST_VERSION < 105100 -template -inline -typename property_value< CGAL::cgal_bgl_named_params, Tag2>::type -get_param(const CGAL::cgal_bgl_named_params& p, Tag2 tag2) -{ - enum { match = detail::same_property::value }; - typedef typename - boost::property_value< CGAL::cgal_bgl_named_params, Tag2>::type T2; - T2* t2 = 0; - typedef detail::property_value_dispatch Dispatcher; - return Dispatcher::const_get_value(p, t2, tag2); -} -#endif - - -template -struct lookup_named_param_def, Def> { - typedef T type; - static const type& get(const bgl_named_params& p, const Def&) { - return p.m_value; - } -}; - -template -struct lookup_named_param_def, Def> { - typedef typename lookup_named_param_def::type type; - static const type& get(const bgl_named_params& p, const Def& def) { - return lookup_named_param_def::get(p.m_base, def); - } -}; -} // boost - -#include - -#endif // CGAL_BOOST_GRAPH_NAMED_FUNCTION_PARAMS_HPP diff --git a/BGL/include/CGAL/boost/graph/named_params_helper.h b/BGL/include/CGAL/boost/graph/named_params_helper.h index 90e8bdc08cd..be68585bec2 100644 --- a/BGL/include/CGAL/boost/graph/named_params_helper.h +++ b/BGL/include/CGAL/boost/graph/named_params_helper.h @@ -19,7 +19,7 @@ #ifndef CGAL_BOOST_GRAPH_NAMED_PARAMETERS_HELPERS_H #define CGAL_BOOST_GRAPH_NAMED_PARAMETERS_HELPERS_H -#include +#include #include #include @@ -30,7 +30,7 @@ #include #include -#include + namespace CGAL { @@ -123,12 +123,12 @@ namespace CGAL { typedef typename property_map_selector::type DefaultVPMap; public: - typedef typename boost::lookup_named_param_def< + typedef typename internal_np::Lookup_named_param_def< internal_np::vertex_point_t, NamedParameters, DefaultVPMap > ::type type; - typedef typename boost::lookup_named_param_def< + typedef typename internal_np::Lookup_named_param_def< internal_np::vertex_point_t, NamedParameters, DefaultVPMap_const @@ -146,28 +146,28 @@ namespace CGAL { }; template, + typename NamedParametersGT = Named_function_parameters, typename NamedParametersVPM = NamedParametersGT > class GetGeomTraits { typedef typename CGAL::graph_has_property::type Has_internal_pmap; - typedef typename boost::lookup_named_param_def < + typedef typename internal_np::Lookup_named_param_def < internal_np::vertex_point_t, NamedParametersVPM, - boost::param_not_found + internal_np::Param_not_found > ::type NP_vpm; struct Fake_GT {};//to be used if there is no internal vertex_point_map in PolygonMesh - typedef typename boost::mpl::if_c< Has_internal_pmap::value || !boost::is_same::value + typedef typename boost::mpl::if_c< Has_internal_pmap::value || !boost::is_same::value , typename GetK::Kernel , Fake_GT >::type DefaultKernel; public: - typedef typename boost::lookup_named_param_def < + typedef typename internal_np::Lookup_named_param_def < internal_np::geom_traits_t, NamedParametersGT, DefaultKernel @@ -180,12 +180,12 @@ namespace CGAL { typedef typename property_map_selector::type DefaultMap; typedef typename property_map_selector::const_type DefaultMap_const; public: - typedef typename boost::lookup_named_param_def < + typedef typename internal_np::Lookup_named_param_def < internal_np::face_index_t, NamedParameters, DefaultMap > ::type type; - typedef typename boost::lookup_named_param_def < + typedef typename internal_np::Lookup_named_param_def < internal_np::face_index_t, NamedParameters, DefaultMap_const @@ -199,7 +199,7 @@ namespace CGAL { { typedef typename property_map_selector::type DefaultMap; public: - typedef typename boost::lookup_named_param_def < + typedef typename internal_np::Lookup_named_param_def < internal_np::vertex_index_t, NamedParameters, DefaultMap @@ -222,7 +222,7 @@ namespace CGAL { public: typedef DummyNormalPmap NoMap; - typedef typename boost::lookup_named_param_def < + typedef typename internal_np::Lookup_named_param_def < internal_np::face_normal_t, NamedParameters, DummyNormalPmap//default @@ -249,7 +249,7 @@ namespace CGAL { namespace parameters { template - cgal_bgl_named_params + Named_function_parameters inline all_default(const PointRange&) { return CGAL::parameters::all_default(); @@ -268,13 +268,13 @@ namespace CGAL { typedef typename CGAL::Identity_property_map DefaultPMap; public: - typedef typename boost::lookup_named_param_def< + typedef typename internal_np::Lookup_named_param_def< internal_np::point_t, NamedParameters, DefaultPMap > ::type type; - typedef typename boost::lookup_named_param_def< + typedef typename internal_np::Lookup_named_param_def< internal_np::point_t, NamedParameters, DefaultPMap @@ -309,13 +309,13 @@ namespace CGAL { typedef typename CGAL::Identity_property_map DefaultPMap; public: - typedef typename boost::lookup_named_param_def< + typedef typename internal_np::Lookup_named_param_def< internal_np::query_point_t, NamedParameters, DefaultPMap > ::type type; - typedef typename boost::lookup_named_param_def< + typedef typename internal_np::Lookup_named_param_def< internal_np::query_point_t, NamedParameters, DefaultPMap @@ -355,7 +355,7 @@ namespace CGAL { public: typedef DummyNormalMap NoMap; - typedef typename boost::lookup_named_param_def < + typedef typename internal_np::Lookup_named_param_def < internal_np::normal_t, NamedParameters, DummyNormalMap//default @@ -369,13 +369,13 @@ namespace CGAL { typedef typename CGAL::Identity_property_map DefaultPMap; public: - typedef typename boost::lookup_named_param_def< + typedef typename internal_np::Lookup_named_param_def< internal_np::plane_t, NamedParameters, DefaultPMap > ::type type; - typedef typename boost::lookup_named_param_def< + typedef typename internal_np::Lookup_named_param_def< internal_np::plane_t, NamedParameters, DefaultPMap @@ -398,7 +398,7 @@ namespace CGAL { public: typedef DummyPlaneIndexMap NoMap; - typedef typename boost::lookup_named_param_def < + typedef typename internal_np::Lookup_named_param_def < internal_np::plane_index_t, NamedParameters, DummyPlaneIndexMap//default @@ -434,7 +434,7 @@ namespace CGAL { class GetSolver { public: - typedef typename boost::lookup_named_param_def < + typedef typename internal_np::Lookup_named_param_def < internal_np::sparse_linear_solver_t, NamedParameters, DefaultSolver @@ -445,7 +445,7 @@ namespace CGAL { class GetDiagonalizeTraits { public: - typedef typename boost::lookup_named_param_def < + typedef typename internal_np::Lookup_named_param_def < internal_np::diagonalize_traits_t, NamedParameters, Default_diagonalize_traits @@ -466,7 +466,7 @@ namespace CGAL { public: typedef DummySvdTraits NoTraits; - typedef typename boost::lookup_named_param_def < + typedef typename internal_np::Lookup_named_param_def < internal_np::svd_traits_t, NamedParameters, #if defined(CGAL_EIGEN3_ENABLED) diff --git a/BGL/include/CGAL/boost/graph/parameters_interface.h b/BGL/include/CGAL/boost/graph/parameters_interface.h index bd4f15d8e23..15480fbe734 100644 --- a/BGL/include/CGAL/boost/graph/parameters_interface.h +++ b/BGL/include/CGAL/boost/graph/parameters_interface.h @@ -23,6 +23,8 @@ CGAL_add_named_parameter(vertex_point_t, vertex_point, vertex_point_map) CGAL_add_named_parameter(halfedge_index_t, halfedge_index, halfedge_index_map) CGAL_add_named_parameter(edge_index_t, edge_index, edge_index_map) CGAL_add_named_parameter(face_index_t, face_index, face_index_map) +CGAL_add_named_parameter(vertex_index_t, vertex_index, vertex_index_map) +CGAL_add_named_parameter(graph_visitor_t, graph_visitor, visitor) CGAL_add_named_parameter(edge_is_constrained_t, edge_is_constrained, edge_is_constrained_map) CGAL_add_named_parameter(first_index_t, first_index, first_index) diff --git a/BGL/test/BGL/test_cgal_bgl_named_params.cpp b/BGL/test/BGL/test_cgal_bgl_named_params.cpp index 346043ff037..9bc2a0e1370 100644 --- a/BGL/test/BGL/test_cgal_bgl_named_params.cpp +++ b/BGL/test/BGL/test_cgal_bgl_named_params.cpp @@ -1,4 +1,4 @@ -#include +#include #include #include @@ -22,171 +22,167 @@ void check_same_type(T) template void test(const NamedParameters& np) { - using boost::get_param; + using CGAL::parameters::get_parameter; // Test values - // Named parameters from Boost - assert(get_param(np, boost::vertex_index).v == 0); - assert(get_param(np, boost::graph_visitor).v == 1); - // Named parameters that we use in CGAL - assert(get_param(np, CGAL::internal_np::vertex_point).v == 2); - assert(get_param(np, CGAL::internal_np::halfedge_index).v == 3); - assert(get_param(np, CGAL::internal_np::edge_index).v == 4); - assert(get_param(np, CGAL::internal_np::face_index).v == 5); + assert(get_parameter(np, CGAL::internal_np::vertex_index).v == 0); + assert(get_parameter(np, CGAL::internal_np::graph_visitor).v == 1); + assert(get_parameter(np, CGAL::internal_np::vertex_point).v == 2); + assert(get_parameter(np, CGAL::internal_np::halfedge_index).v == 3); + assert(get_parameter(np, CGAL::internal_np::edge_index).v == 4); + assert(get_parameter(np, CGAL::internal_np::face_index).v == 5); - assert(get_param(np, CGAL::internal_np::edge_is_constrained).v == 6); - assert(get_param(np, CGAL::internal_np::first_index).v == 7); - assert(get_param(np, CGAL::internal_np::number_of_iterations).v == 8); + assert(get_parameter(np, CGAL::internal_np::edge_is_constrained).v == 6); + assert(get_parameter(np, CGAL::internal_np::first_index).v == 7); + assert(get_parameter(np, CGAL::internal_np::number_of_iterations).v == 8); - assert(get_param(np, CGAL::internal_np::METIS_options).v == 800000001); - assert(get_param(np, CGAL::internal_np::vertex_partition_id).v == 800000002); - assert(get_param(np, CGAL::internal_np::face_partition_id).v == 800000003); + assert(get_parameter(np, CGAL::internal_np::METIS_options).v == 800000001); + assert(get_parameter(np, CGAL::internal_np::vertex_partition_id).v == 800000002); + assert(get_parameter(np, CGAL::internal_np::face_partition_id).v == 800000003); - assert(get_param(np, CGAL::internal_np::vertex_to_vertex_output_iterator).v == 800000004); - assert(get_param(np, CGAL::internal_np::halfedge_to_halfedge_output_iterator).v == 800000005); - assert(get_param(np, CGAL::internal_np::face_to_face_output_iterator).v == 800000006); + assert(get_parameter(np, CGAL::internal_np::vertex_to_vertex_output_iterator).v == 800000004); + assert(get_parameter(np, CGAL::internal_np::halfedge_to_halfedge_output_iterator).v == 800000005); + assert(get_parameter(np, CGAL::internal_np::face_to_face_output_iterator).v == 800000006); - assert(get_param(np, CGAL::internal_np::vertex_to_vertex_map).v == 800000007); - assert(get_param(np, CGAL::internal_np::halfedge_to_halfedge_map).v == 800000008); - assert(get_param(np, CGAL::internal_np::face_to_face_map).v == 800000009); + assert(get_parameter(np, CGAL::internal_np::vertex_to_vertex_map).v == 800000007); + assert(get_parameter(np, CGAL::internal_np::halfedge_to_halfedge_map).v == 800000008); + assert(get_parameter(np, CGAL::internal_np::face_to_face_map).v == 800000009); // Named parameters that we use in the package 'Mesh_3' - assert(get_param(np, CGAL::internal_np::vertex_feature_degree).v == 9); + assert(get_parameter(np, CGAL::internal_np::vertex_feature_degree).v == 9); // Named parameters used in the package 'Polygon Mesh Processing' - assert(get_param(np, CGAL::internal_np::geom_traits).v == 10); - assert(get_param(np, CGAL::internal_np::vertex_incident_patches).v == 11); - assert(get_param(np, CGAL::internal_np::density_control_factor).v == 12); - assert(get_param(np, CGAL::internal_np::use_delaunay_triangulation).v == 13); - assert(get_param(np, CGAL::internal_np::fairing_continuity).v == 14); - assert(get_param(np, CGAL::internal_np::sparse_linear_solver).v == 15); - assert(get_param(np, CGAL::internal_np::number_of_relaxation_steps).v == 16); - assert(get_param(np, CGAL::internal_np::protect_constraints).v == 17); - assert(get_param(np, CGAL::internal_np::relax_constraints).v == 18); - assert(get_param(np, CGAL::internal_np::collapse_constraints).v == 43); - assert(get_param(np, CGAL::internal_np::vertex_is_constrained).v == 19); - assert(get_param(np, CGAL::internal_np::face_patch).v == 20); - assert(get_param(np, CGAL::internal_np::random_uniform_sampling).v == 21); - assert(get_param(np, CGAL::internal_np::grid_sampling).v == 22); - assert(get_param(np, CGAL::internal_np::monte_carlo_sampling).v == 23); - assert(get_param(np, CGAL::internal_np::do_sample_edges).v == 24); - assert(get_param(np, CGAL::internal_np::do_sample_vertices).v == 25); - assert(get_param(np, CGAL::internal_np::do_sample_faces).v == 26); - assert(get_param(np, CGAL::internal_np::number_of_points_on_faces).v == 27); - assert(get_param(np, CGAL::internal_np::number_of_points_per_face).v == 28); - assert(get_param(np, CGAL::internal_np::grid_spacing).v == 29); - assert(get_param(np, CGAL::internal_np::number_of_points_per_edge).v == 30); - assert(get_param(np, CGAL::internal_np::number_of_points_on_edges).v == 31); - assert(get_param(np, CGAL::internal_np::nb_points_per_area_unit).v == 32); - assert(get_param(np, CGAL::internal_np::nb_points_per_distance_unit).v == 33); - assert(get_param(np, CGAL::internal_np::throw_on_self_intersection).v == 43); - assert(get_param(np, CGAL::internal_np::clip_volume).v == 44); - assert(get_param(np, CGAL::internal_np::use_compact_clipper).v == 45); - assert(get_param(np, CGAL::internal_np::erase_all_duplicates).v == 48); - assert(get_param(np, CGAL::internal_np::require_same_orientation).v == 49); - assert(get_param(np, CGAL::internal_np::use_bool_op_to_clip_surface).v == 50); + assert(get_parameter(np, CGAL::internal_np::geom_traits).v == 10); + assert(get_parameter(np, CGAL::internal_np::vertex_incident_patches).v == 11); + assert(get_parameter(np, CGAL::internal_np::density_control_factor).v == 12); + assert(get_parameter(np, CGAL::internal_np::use_delaunay_triangulation).v == 13); + assert(get_parameter(np, CGAL::internal_np::fairing_continuity).v == 14); + assert(get_parameter(np, CGAL::internal_np::sparse_linear_solver).v == 15); + assert(get_parameter(np, CGAL::internal_np::number_of_relaxation_steps).v == 16); + assert(get_parameter(np, CGAL::internal_np::protect_constraints).v == 17); + assert(get_parameter(np, CGAL::internal_np::relax_constraints).v == 18); + assert(get_parameter(np, CGAL::internal_np::collapse_constraints).v == 43); + assert(get_parameter(np, CGAL::internal_np::vertex_is_constrained).v == 19); + assert(get_parameter(np, CGAL::internal_np::face_patch).v == 20); + assert(get_parameter(np, CGAL::internal_np::random_uniform_sampling).v == 21); + assert(get_parameter(np, CGAL::internal_np::grid_sampling).v == 22); + assert(get_parameter(np, CGAL::internal_np::monte_carlo_sampling).v == 23); + assert(get_parameter(np, CGAL::internal_np::do_sample_edges).v == 24); + assert(get_parameter(np, CGAL::internal_np::do_sample_vertices).v == 25); + assert(get_parameter(np, CGAL::internal_np::do_sample_faces).v == 26); + assert(get_parameter(np, CGAL::internal_np::number_of_points_on_faces).v == 27); + assert(get_parameter(np, CGAL::internal_np::number_of_points_per_face).v == 28); + assert(get_parameter(np, CGAL::internal_np::grid_spacing).v == 29); + assert(get_parameter(np, CGAL::internal_np::number_of_points_per_edge).v == 30); + assert(get_parameter(np, CGAL::internal_np::number_of_points_on_edges).v == 31); + assert(get_parameter(np, CGAL::internal_np::nb_points_per_area_unit).v == 32); + assert(get_parameter(np, CGAL::internal_np::nb_points_per_distance_unit).v == 33); + assert(get_parameter(np, CGAL::internal_np::throw_on_self_intersection).v == 43); + assert(get_parameter(np, CGAL::internal_np::clip_volume).v == 44); + assert(get_parameter(np, CGAL::internal_np::use_compact_clipper).v == 45); + assert(get_parameter(np, CGAL::internal_np::erase_all_duplicates).v == 48); + assert(get_parameter(np, CGAL::internal_np::require_same_orientation).v == 49); + assert(get_parameter(np, CGAL::internal_np::use_bool_op_to_clip_surface).v == 50); // Named parameters that we use in the package 'Surface Mesh Simplification' - assert(get_param(np, CGAL::internal_np::get_cost_policy).v == 34); - assert(get_param(np, CGAL::internal_np::get_placement_policy).v == 35); + assert(get_parameter(np, CGAL::internal_np::get_cost_policy).v == 34); + assert(get_parameter(np, CGAL::internal_np::get_placement_policy).v == 35); // To-be-documented named parameters - assert(get_param(np, CGAL::internal_np::face_normal).v == 36); - assert(get_param(np, CGAL::internal_np::random_seed).v == 37); - assert(get_param(np, CGAL::internal_np::do_project).v == 38); + assert(get_parameter(np, CGAL::internal_np::face_normal).v == 36); + assert(get_parameter(np, CGAL::internal_np::random_seed).v == 37); + assert(get_parameter(np, CGAL::internal_np::do_project).v == 38); // Internal named parameters - assert(get_param(np, CGAL::internal_np::weight_calculator).v == 39); - assert(get_param(np, CGAL::internal_np::preserve_genus).v == 40); - assert(get_param(np, CGAL::internal_np::verbosity_level).v == 41); - assert(get_param(np, CGAL::internal_np::use_binary_mode).v == 51); - assert(get_param(np, CGAL::internal_np::projection_functor).v == 42); - assert(get_param(np, CGAL::internal_np::apply_per_connected_component).v == 46); - assert(get_param(np, CGAL::internal_np::output_iterator).v == 47); + assert(get_parameter(np, CGAL::internal_np::weight_calculator).v == 39); + assert(get_parameter(np, CGAL::internal_np::preserve_genus).v == 40); + assert(get_parameter(np, CGAL::internal_np::verbosity_level).v == 41); + assert(get_parameter(np, CGAL::internal_np::use_binary_mode).v == 51); + assert(get_parameter(np, CGAL::internal_np::projection_functor).v == 42); + assert(get_parameter(np, CGAL::internal_np::apply_per_connected_component).v == 46); + assert(get_parameter(np, CGAL::internal_np::output_iterator).v == 47); // Test types - // Named parameters from Boost - check_same_type<0>(get_param(np, boost::vertex_index)); - check_same_type<1>(get_param(np, boost::graph_visitor)); - // Named parameters that we use in CGAL - check_same_type<2>(get_param(np, CGAL::internal_np::vertex_point)); - check_same_type<3>(get_param(np, CGAL::internal_np::halfedge_index)); - check_same_type<4>(get_param(np, CGAL::internal_np::edge_index)); - check_same_type<5>(get_param(np, CGAL::internal_np::face_index)); + check_same_type<0>(get_parameter(np, CGAL::internal_np::vertex_index)); + check_same_type<1>(get_parameter(np, CGAL::internal_np::graph_visitor)); + check_same_type<2>(get_parameter(np, CGAL::internal_np::vertex_point)); + check_same_type<3>(get_parameter(np, CGAL::internal_np::halfedge_index)); + check_same_type<4>(get_parameter(np, CGAL::internal_np::edge_index)); + check_same_type<5>(get_parameter(np, CGAL::internal_np::face_index)); - check_same_type<6>(get_param(np, CGAL::internal_np::edge_is_constrained)); - check_same_type<7>(get_param(np, CGAL::internal_np::first_index)); - check_same_type<8>(get_param(np, CGAL::internal_np::number_of_iterations)); + check_same_type<6>(get_parameter(np, CGAL::internal_np::edge_is_constrained)); + check_same_type<7>(get_parameter(np, CGAL::internal_np::first_index)); + check_same_type<8>(get_parameter(np, CGAL::internal_np::number_of_iterations)); - check_same_type<800000001>(get_param(np, CGAL::internal_np::METIS_options)); - check_same_type<800000002>(get_param(np, CGAL::internal_np::vertex_partition_id)); - check_same_type<800000003>(get_param(np, CGAL::internal_np::face_partition_id)); - check_same_type<800000004>(get_param(np, CGAL::internal_np::vertex_to_vertex_output_iterator)); - check_same_type<800000005>(get_param(np, CGAL::internal_np::halfedge_to_halfedge_output_iterator)); - check_same_type<800000006>(get_param(np, CGAL::internal_np::face_to_face_output_iterator)); - check_same_type<800000007>(get_param(np, CGAL::internal_np::vertex_to_vertex_map)); - check_same_type<800000008>(get_param(np, CGAL::internal_np::halfedge_to_halfedge_map)); - check_same_type<800000009>(get_param(np, CGAL::internal_np::face_to_face_map)); + check_same_type<800000001>(get_parameter(np, CGAL::internal_np::METIS_options)); + check_same_type<800000002>(get_parameter(np, CGAL::internal_np::vertex_partition_id)); + check_same_type<800000003>(get_parameter(np, CGAL::internal_np::face_partition_id)); + check_same_type<800000004>(get_parameter(np, CGAL::internal_np::vertex_to_vertex_output_iterator)); + check_same_type<800000005>(get_parameter(np, CGAL::internal_np::halfedge_to_halfedge_output_iterator)); + check_same_type<800000006>(get_parameter(np, CGAL::internal_np::face_to_face_output_iterator)); + check_same_type<800000007>(get_parameter(np, CGAL::internal_np::vertex_to_vertex_map)); + check_same_type<800000008>(get_parameter(np, CGAL::internal_np::halfedge_to_halfedge_map)); + check_same_type<800000009>(get_parameter(np, CGAL::internal_np::face_to_face_map)); // Named parameters that we use in the package 'Mesh_3' - check_same_type<9>(get_param(np, CGAL::internal_np::vertex_feature_degree)); + check_same_type<9>(get_parameter(np, CGAL::internal_np::vertex_feature_degree)); // Named parameters used in the package 'Polygon Mesh Processing' - check_same_type<10>(get_param(np, CGAL::internal_np::geom_traits)); - check_same_type<11>(get_param(np, CGAL::internal_np::vertex_incident_patches)); - check_same_type<12>(get_param(np, CGAL::internal_np::density_control_factor)); - check_same_type<13>(get_param(np, CGAL::internal_np::use_delaunay_triangulation)); - check_same_type<14>(get_param(np, CGAL::internal_np::fairing_continuity)); - check_same_type<15>(get_param(np, CGAL::internal_np::sparse_linear_solver)); - check_same_type<16>(get_param(np, CGAL::internal_np::number_of_relaxation_steps)); - check_same_type<17>(get_param(np, CGAL::internal_np::protect_constraints)); - check_same_type<18>(get_param(np, CGAL::internal_np::relax_constraints)); - check_same_type<43>(get_param(np, CGAL::internal_np::collapse_constraints)); - check_same_type<19>(get_param(np, CGAL::internal_np::vertex_is_constrained)); - check_same_type<20>(get_param(np, CGAL::internal_np::face_patch)); - check_same_type<21>(get_param(np, CGAL::internal_np::random_uniform_sampling)); - check_same_type<22>(get_param(np, CGAL::internal_np::grid_sampling)); - check_same_type<23>(get_param(np, CGAL::internal_np::monte_carlo_sampling)); - check_same_type<24>(get_param(np, CGAL::internal_np::do_sample_edges)); - check_same_type<25>(get_param(np, CGAL::internal_np::do_sample_vertices)); - check_same_type<26>(get_param(np, CGAL::internal_np::do_sample_faces)); - check_same_type<27>(get_param(np, CGAL::internal_np::number_of_points_on_faces)); - check_same_type<28>(get_param(np, CGAL::internal_np::number_of_points_per_face)); - check_same_type<29>(get_param(np, CGAL::internal_np::grid_spacing)); - check_same_type<30>(get_param(np, CGAL::internal_np::number_of_points_per_edge)); - check_same_type<31>(get_param(np, CGAL::internal_np::number_of_points_on_edges)); - check_same_type<32>(get_param(np, CGAL::internal_np::nb_points_per_area_unit)); - check_same_type<33>(get_param(np, CGAL::internal_np::nb_points_per_distance_unit)); - check_same_type<43>(get_param(np, CGAL::internal_np::throw_on_self_intersection)); - check_same_type<44>(get_param(np, CGAL::internal_np::clip_volume)); - check_same_type<45>(get_param(np, CGAL::internal_np::use_compact_clipper)); - check_same_type<48>(get_param(np, CGAL::internal_np::erase_all_duplicates)); - check_same_type<49>(get_param(np, CGAL::internal_np::require_same_orientation)); - check_same_type<50>(get_param(np, CGAL::internal_np::use_bool_op_to_clip_surface)); + check_same_type<10>(get_parameter(np, CGAL::internal_np::geom_traits)); + check_same_type<11>(get_parameter(np, CGAL::internal_np::vertex_incident_patches)); + check_same_type<12>(get_parameter(np, CGAL::internal_np::density_control_factor)); + check_same_type<13>(get_parameter(np, CGAL::internal_np::use_delaunay_triangulation)); + check_same_type<14>(get_parameter(np, CGAL::internal_np::fairing_continuity)); + check_same_type<15>(get_parameter(np, CGAL::internal_np::sparse_linear_solver)); + check_same_type<16>(get_parameter(np, CGAL::internal_np::number_of_relaxation_steps)); + check_same_type<17>(get_parameter(np, CGAL::internal_np::protect_constraints)); + check_same_type<18>(get_parameter(np, CGAL::internal_np::relax_constraints)); + check_same_type<43>(get_parameter(np, CGAL::internal_np::collapse_constraints)); + check_same_type<19>(get_parameter(np, CGAL::internal_np::vertex_is_constrained)); + check_same_type<20>(get_parameter(np, CGAL::internal_np::face_patch)); + check_same_type<21>(get_parameter(np, CGAL::internal_np::random_uniform_sampling)); + check_same_type<22>(get_parameter(np, CGAL::internal_np::grid_sampling)); + check_same_type<23>(get_parameter(np, CGAL::internal_np::monte_carlo_sampling)); + check_same_type<24>(get_parameter(np, CGAL::internal_np::do_sample_edges)); + check_same_type<25>(get_parameter(np, CGAL::internal_np::do_sample_vertices)); + check_same_type<26>(get_parameter(np, CGAL::internal_np::do_sample_faces)); + check_same_type<27>(get_parameter(np, CGAL::internal_np::number_of_points_on_faces)); + check_same_type<28>(get_parameter(np, CGAL::internal_np::number_of_points_per_face)); + check_same_type<29>(get_parameter(np, CGAL::internal_np::grid_spacing)); + check_same_type<30>(get_parameter(np, CGAL::internal_np::number_of_points_per_edge)); + check_same_type<31>(get_parameter(np, CGAL::internal_np::number_of_points_on_edges)); + check_same_type<32>(get_parameter(np, CGAL::internal_np::nb_points_per_area_unit)); + check_same_type<33>(get_parameter(np, CGAL::internal_np::nb_points_per_distance_unit)); + check_same_type<43>(get_parameter(np, CGAL::internal_np::throw_on_self_intersection)); + check_same_type<44>(get_parameter(np, CGAL::internal_np::clip_volume)); + check_same_type<45>(get_parameter(np, CGAL::internal_np::use_compact_clipper)); + check_same_type<48>(get_parameter(np, CGAL::internal_np::erase_all_duplicates)); + check_same_type<49>(get_parameter(np, CGAL::internal_np::require_same_orientation)); + check_same_type<50>(get_parameter(np, CGAL::internal_np::use_bool_op_to_clip_surface)); // Named parameters that we use in the package 'Surface Mesh Simplification' - check_same_type<34>(get_param(np, CGAL::internal_np::get_cost_policy)); - check_same_type<35>(get_param(np, CGAL::internal_np::get_placement_policy)); + check_same_type<34>(get_parameter(np, CGAL::internal_np::get_cost_policy)); + check_same_type<35>(get_parameter(np, CGAL::internal_np::get_placement_policy)); // To-be-documented named parameters - check_same_type<36>(get_param(np, CGAL::internal_np::face_normal)); - check_same_type<37>(get_param(np, CGAL::internal_np::random_seed)); - check_same_type<38>(get_param(np, CGAL::internal_np::do_project)); + check_same_type<36>(get_parameter(np, CGAL::internal_np::face_normal)); + check_same_type<37>(get_parameter(np, CGAL::internal_np::random_seed)); + check_same_type<38>(get_parameter(np, CGAL::internal_np::do_project)); // Internal named parameters - check_same_type<39>(get_param(np, CGAL::internal_np::weight_calculator)); - check_same_type<40>(get_param(np, CGAL::internal_np::preserve_genus)); - check_same_type<41>(get_param(np, CGAL::internal_np::verbosity_level)); - check_same_type<51>(get_param(np, CGAL::internal_np::use_binary_mode)); - check_same_type<42>(get_param(np, CGAL::internal_np::projection_functor)); - check_same_type<46>(get_param(np, CGAL::internal_np::apply_per_connected_component)); - check_same_type<47>(get_param(np, CGAL::internal_np::output_iterator)); + check_same_type<39>(get_parameter(np, CGAL::internal_np::weight_calculator)); + check_same_type<40>(get_parameter(np, CGAL::internal_np::preserve_genus)); + check_same_type<41>(get_parameter(np, CGAL::internal_np::verbosity_level)); + check_same_type<51>(get_parameter(np, CGAL::internal_np::use_binary_mode)); + check_same_type<42>(get_parameter(np, CGAL::internal_np::projection_functor)); + check_same_type<46>(get_parameter(np, CGAL::internal_np::apply_per_connected_component)); + check_same_type<47>(get_parameter(np, CGAL::internal_np::output_iterator)); } int main() diff --git a/Classification/include/CGAL/Classification/classify.h b/Classification/include/CGAL/Classification/classify.h index e4a94e15386..68736e97bf0 100644 --- a/Classification/include/CGAL/Classification/classify.h +++ b/Classification/include/CGAL/Classification/classify.h @@ -27,6 +27,7 @@ #include #include #include +#include #ifdef CGAL_LINKED_WITH_TBB #include diff --git a/HalfedgeDS/include/CGAL/boost/graph/graph_traits_HalfedgeDS.h b/HalfedgeDS/include/CGAL/boost/graph/graph_traits_HalfedgeDS.h index b0915a0bc7f..2c6c7170285 100644 --- a/HalfedgeDS/include/CGAL/boost/graph/graph_traits_HalfedgeDS.h +++ b/HalfedgeDS/include/CGAL/boost/graph/graph_traits_HalfedgeDS.h @@ -24,7 +24,7 @@ #include // include this to avoid a VC15 warning -#include +#include #include #include diff --git a/HalfedgeDS/include/CGAL/boost/graph/graph_traits_HalfedgeDS_default.h b/HalfedgeDS/include/CGAL/boost/graph/graph_traits_HalfedgeDS_default.h index 1f84f085c02..10b83ae2e27 100644 --- a/HalfedgeDS/include/CGAL/boost/graph/graph_traits_HalfedgeDS_default.h +++ b/HalfedgeDS/include/CGAL/boost/graph/graph_traits_HalfedgeDS_default.h @@ -22,6 +22,7 @@ #define CGAL_GRAPH_TRAITS_HALFEDGEDS_DEFAULT_H #include +#include #include #include #include diff --git a/Linear_cell_complex/benchmark/Linear_cell_complex_2/surface_mesh/IO_off.cpp b/Linear_cell_complex/benchmark/Linear_cell_complex_2/surface_mesh/IO_off.cpp index 9642d452a04..3f77147c898 100644 --- a/Linear_cell_complex/benchmark/Linear_cell_complex_2/surface_mesh/IO_off.cpp +++ b/Linear_cell_complex/benchmark/Linear_cell_complex_2/surface_mesh/IO_off.cpp @@ -24,7 +24,7 @@ #include "IO.h" #include -#include +#include #include //== IMPLEMENTATION =========================================================== @@ -55,7 +55,7 @@ bool read_off_ascii(Surface_mesh& mesh, Vec2f t; Surface_mesh::Vertex v; typename CGAL::Polygon_mesh_processing::GetVertexPointMap::const_type - vpm = choose_param(get_param(np, CGAL::boost::internal_np::vertex_point), + vpm = choose_parameter(get_parameter(np, CGAL::boost::internal_np::vertex_point), get_const_property_map(CGAL::vertex_point, mesh)); @@ -177,7 +177,7 @@ bool read_off_binary(Surface_mesh& mesh, if (has_normals) normals = mesh.vertex_property("v:normal"); if (has_texcoords) texcoords = mesh.vertex_property("v:texcoord"); typename CGAL::Polygon_mesh_processing::GetVertexPointMap::const_type - vpm = choose_param(get_param(np, CGAL::boost::internal_np::vertex_point), + vpm = choose_parameter(get_parameter(np, CGAL::boost::internal_np::vertex_point), get_const_property_map(CGAL::vertex_point, mesh)); diff --git a/Point_set_3/include/CGAL/Point_set_3.h b/Point_set_3/include/CGAL/Point_set_3.h index df0ea714daf..7e2f45db142 100644 --- a/Point_set_3/include/CGAL/Point_set_3.h +++ b/Point_set_3/include/CGAL/Point_set_3.h @@ -31,7 +31,7 @@ #include -#include +#include #include @@ -959,13 +959,13 @@ public: #ifdef DOXYGEN_RUNNING unspecified_type #else - cgal_bgl_named_params + Named_function_parameters ::Kernel, internal_np::geom_traits_t, - cgal_bgl_named_params + Named_function_parameters ::template Property_map, internal_np::normal_t, - cgal_bgl_named_params + Named_function_parameters ::template Property_map, internal_np::point_t> > > #endif @@ -1302,13 +1302,13 @@ namespace Point_set_processing_3 namespace parameters { template - cgal_bgl_named_params + Named_function_parameters ::Kernel, internal_np::geom_traits_t, - cgal_bgl_named_params + Named_function_parameters ::template Property_map, internal_np::normal_t, - cgal_bgl_named_params + Named_function_parameters ::template Property_map, internal_np::point_t> > > inline all_default(const CGAL::Point_set_3& ps) diff --git a/Point_set_processing_3/doc/Point_set_processing_3/Doxyfile.in b/Point_set_processing_3/doc/Point_set_processing_3/Doxyfile.in index 8838125a25a..0cb964d6dbb 100644 --- a/Point_set_processing_3/doc/Point_set_processing_3/Doxyfile.in +++ b/Point_set_processing_3/doc/Point_set_processing_3/Doxyfile.in @@ -14,4 +14,6 @@ ALIASES += "cgalNPTableBegin=
\1 " - + +EXPAND_AS_DEFINED = CGAL_BGL_NP_TEMPLATE_PARAMETERS \ + CGAL_BGL_NP_CLASS diff --git a/Point_set_processing_3/include/CGAL/IO/read_las_points.h b/Point_set_processing_3/include/CGAL/IO/read_las_points.h index 15bbd562387..6e9117926bf 100644 --- a/Point_set_processing_3/include/CGAL/IO/read_las_points.h +++ b/Point_set_processing_3/include/CGAL/IO/read_las_points.h @@ -35,7 +35,7 @@ #include #include -#include +#include #include #include @@ -468,12 +468,13 @@ bool read_las_points(std::istream& stream, const CGAL_BGL_NP_CLASS& np) #endif { - using boost::choose_param; + using parameters::choose_parameter; + using parameters::get_parameter; typedef Point_set_processing_3::Fake_point_range PointRange; typedef typename Point_set_processing_3::GetPointMap::type PointMap; - PointMap point_map = choose_param(get_param(np, internal_np::point_map), PointMap()); + PointMap point_map = choose_parameter(get_parameter(np, internal_np::point_map), PointMap()); return read_las_points_with_properties (stream, output, make_las_point_reader (point_map)); diff --git a/Point_set_processing_3/include/CGAL/IO/read_off_points.h b/Point_set_processing_3/include/CGAL/IO/read_off_points.h index 2c7e1c03d0a..13d07076e71 100644 --- a/Point_set_processing_3/include/CGAL/IO/read_off_points.h +++ b/Point_set_processing_3/include/CGAL/IO/read_off_points.h @@ -31,7 +31,7 @@ #include #include -#include +#include #include #include @@ -85,7 +85,8 @@ read_off_points( const CGAL_BGL_NP_CLASS& np) #endif { - using boost::choose_param; + using parameters::choose_parameter; + using parameters::get_parameter; typedef Point_set_processing_3::Fake_point_range PointRange; @@ -97,8 +98,8 @@ read_off_points( bool has_normals = !(boost::is_same::NoMap>::value); - PointMap point_map = choose_param(get_param(np, internal_np::point_map), PointMap()); - NormalMap normal_map = choose_param(get_param(np, internal_np::normal_map), NormalMap()); + PointMap point_map = choose_parameter(get_parameter(np, internal_np::point_map), PointMap()); + NormalMap normal_map = choose_parameter(get_parameter(np, internal_np::normal_map), NormalMap()); // value_type_traits is a workaround as back_insert_iterator's value_type is void // typedef typename value_type_traits::type Enriched_point; diff --git a/Point_set_processing_3/include/CGAL/IO/read_ply_points.h b/Point_set_processing_3/include/CGAL/IO/read_ply_points.h index 094e3ac7633..8ac4e0aef20 100644 --- a/Point_set_processing_3/include/CGAL/IO/read_ply_points.h +++ b/Point_set_processing_3/include/CGAL/IO/read_ply_points.h @@ -36,7 +36,7 @@ #include #include -#include +#include #include #include @@ -863,7 +863,8 @@ bool read_ply_points(std::istream& stream, const CGAL_BGL_NP_CLASS& np) #endif { - using boost::choose_param; + using parameters::choose_parameter; + using parameters::get_parameter; typedef Point_set_processing_3::Fake_point_range PointRange; @@ -874,8 +875,8 @@ bool read_ply_points(std::istream& stream, bool has_normals = !(boost::is_same::NoMap>::value); - PointMap point_map = choose_param(get_param(np, internal_np::point_map), PointMap()); - NormalMap normal_map = choose_param(get_param(np, internal_np::normal_map), NormalMap()); + PointMap point_map = choose_parameter(get_parameter(np, internal_np::point_map), PointMap()); + NormalMap normal_map = choose_parameter(get_parameter(np, internal_np::normal_map), NormalMap()); if (has_normals) return read_ply_points_with_properties (stream, output, diff --git a/Point_set_processing_3/include/CGAL/IO/read_xyz_points.h b/Point_set_processing_3/include/CGAL/IO/read_xyz_points.h index 8a9ea1df92c..4b5ddd8649c 100644 --- a/Point_set_processing_3/include/CGAL/IO/read_xyz_points.h +++ b/Point_set_processing_3/include/CGAL/IO/read_xyz_points.h @@ -30,7 +30,7 @@ #include #include -#include +#include #include #include @@ -84,7 +84,8 @@ read_xyz_points( const CGAL_BGL_NP_CLASS& np) #endif { - using boost::choose_param; + using parameters::choose_parameter; + using parameters::get_parameter; typedef Point_set_processing_3::Fake_point_range PointRange; @@ -96,8 +97,8 @@ read_xyz_points( bool has_normals = !(boost::is_same::NoMap>::value); - PointMap point_map = choose_param(get_param(np, internal_np::point_map), PointMap()); - NormalMap normal_map = choose_param(get_param(np, internal_np::normal_map), NormalMap()); + PointMap point_map = choose_parameter(get_parameter(np, internal_np::point_map), PointMap()); + NormalMap normal_map = choose_parameter(get_parameter(np, internal_np::normal_map), NormalMap()); // value_type_traits is a workaround as back_insert_iterator's value_type is void //typedef typename value_type_traits::type Enriched_point; diff --git a/Point_set_processing_3/include/CGAL/IO/write_las_points.h b/Point_set_processing_3/include/CGAL/IO/write_las_points.h index c44e78160c3..33e0a311a8f 100644 --- a/Point_set_processing_3/include/CGAL/IO/write_las_points.h +++ b/Point_set_processing_3/include/CGAL/IO/write_las_points.h @@ -285,10 +285,11 @@ write_las_points( const PointRange& points, const NamedParameters& np) { - using boost::choose_param; + using parameters::choose_parameter; + using parameters::get_parameter; typedef typename Point_set_processing_3::GetPointMap::type PointMap; - PointMap point_map = choose_param(get_param(np, internal_np::point_map), PointMap()); + PointMap point_map = choose_parameter(get_parameter(np, internal_np::point_map), PointMap()); return write_las_points_with_properties (stream, points, make_las_point_writer(point_map)); } diff --git a/Point_set_processing_3/include/CGAL/IO/write_off_points.h b/Point_set_processing_3/include/CGAL/IO/write_off_points.h index a945db1c004..8afaa784c8b 100644 --- a/Point_set_processing_3/include/CGAL/IO/write_off_points.h +++ b/Point_set_processing_3/include/CGAL/IO/write_off_points.h @@ -71,7 +71,8 @@ write_off_points( const PointRange& points, const NamedParameters& np) { - using boost::choose_param; + using parameters::choose_parameter; + using parameters::get_parameter; // basic geometric types typedef typename Point_set_processing_3::GetPointMap::type PointMap; @@ -80,8 +81,8 @@ write_off_points( bool has_normals = !(boost::is_same::NoMap>::value); - PointMap point_map = choose_param(get_param(np, internal_np::point_map), PointMap()); - NormalMap normal_map = choose_param(get_param(np, internal_np::normal_map), NormalMap()); + PointMap point_map = choose_parameter(get_parameter(np, internal_np::point_map), PointMap()); + NormalMap normal_map = choose_parameter(get_parameter(np, internal_np::normal_map), NormalMap()); CGAL_point_set_processing_precondition(points.begin() != points.end()); diff --git a/Point_set_processing_3/include/CGAL/IO/write_ply_points.h b/Point_set_processing_3/include/CGAL/IO/write_ply_points.h index 6640469daaa..2bbd1c23491 100644 --- a/Point_set_processing_3/include/CGAL/IO/write_ply_points.h +++ b/Point_set_processing_3/include/CGAL/IO/write_ply_points.h @@ -35,7 +35,7 @@ #include #include -#include +#include #include #include @@ -429,7 +429,8 @@ write_ply_points( const PointRange& points, const NamedParameters& np) { - using boost::choose_param; + using parameters::choose_parameter; + using parameters::get_parameter; // basic geometric types typedef typename Point_set_processing_3::GetPointMap::type PointMap; @@ -438,8 +439,8 @@ write_ply_points( bool has_normals = !(boost::is_same::NoMap>::value); - PointMap point_map = choose_param(get_param(np, internal_np::point_map), PointMap()); - NormalMap normal_map = choose_param(get_param(np, internal_np::normal_map), NormalMap()); + PointMap point_map = choose_parameter(get_parameter(np, internal_np::point_map), PointMap()); + NormalMap normal_map = choose_parameter(get_parameter(np, internal_np::normal_map), NormalMap()); if (has_normals) return write_ply_points_with_properties( diff --git a/Point_set_processing_3/include/CGAL/IO/write_xyz_points.h b/Point_set_processing_3/include/CGAL/IO/write_xyz_points.h index f8ebf39fcbc..b8cb6e6893a 100644 --- a/Point_set_processing_3/include/CGAL/IO/write_xyz_points.h +++ b/Point_set_processing_3/include/CGAL/IO/write_xyz_points.h @@ -29,7 +29,7 @@ #include #include -#include +#include #include #include @@ -71,7 +71,8 @@ write_xyz_points( const PointRange& points, const NamedParameters& np) { - using boost::choose_param; + using parameters::choose_parameter; + using parameters::get_parameter; // basic geometric types typedef typename Point_set_processing_3::GetPointMap::type PointMap; @@ -80,8 +81,8 @@ write_xyz_points( bool has_normals = !(boost::is_same::NoMap>::value); - PointMap point_map = choose_param(get_param(np, internal_np::point_map), PointMap()); - NormalMap normal_map = choose_param(get_param(np, internal_np::normal_map), NormalMap()); + PointMap point_map = choose_parameter(get_parameter(np, internal_np::point_map), PointMap()); + NormalMap normal_map = choose_parameter(get_parameter(np, internal_np::normal_map), NormalMap()); CGAL_point_set_processing_precondition(points.begin() != points.end()); diff --git a/Point_set_processing_3/include/CGAL/bilateral_smooth_point_set.h b/Point_set_processing_3/include/CGAL/bilateral_smooth_point_set.h index 123ac9ea5f8..5f55e59a9eb 100644 --- a/Point_set_processing_3/include/CGAL/bilateral_smooth_point_set.h +++ b/Point_set_processing_3/include/CGAL/bilateral_smooth_point_set.h @@ -33,7 +33,7 @@ #include #include -#include +#include #include #include @@ -448,7 +448,8 @@ bilateral_smooth_point_set( unsigned int k, const NamedParameters& np) { - using boost::choose_param; + using parameters::choose_parameter; + using parameters::get_parameter; // basic geometric types typedef typename Point_set_processing_3::GetPointMap::type PointMap; @@ -463,8 +464,8 @@ bilateral_smooth_point_set( typedef typename std::vector > Pwns; typedef typename Kernel::FT FT; - double sharpness_angle = choose_param(get_param(np, internal_np::sharpness_angle), 30.); - const cpp11::function& callback = choose_param(get_param(np, internal_np::callback), + double sharpness_angle = choose_parameter(get_parameter(np, internal_np::sharpness_angle), 30.); + const cpp11::function& callback = choose_parameter(get_parameter(np, internal_np::callback), cpp11::function()); CGAL_point_set_processing_precondition(points.begin() != points.end()); @@ -477,8 +478,8 @@ bilateral_smooth_point_set( typedef CGAL::Orthogonal_k_neighbor_search Neighbor_search; typedef typename Neighbor_search::Tree Tree; - PointMap point_map = choose_param(get_param(np, internal_np::point_map), PointMap()); - NormalMap normal_map = choose_param(get_param(np, internal_np::normal_map), NormalMap()); + PointMap point_map = choose_parameter(get_parameter(np, internal_np::point_map), PointMap()); + NormalMap normal_map = choose_parameter(get_parameter(np, internal_np::normal_map), NormalMap()); // copy points and normals Pwns pwns; diff --git a/Point_set_processing_3/include/CGAL/compute_average_spacing.h b/Point_set_processing_3/include/CGAL/compute_average_spacing.h index a1807ac9f08..1405fe37da1 100644 --- a/Point_set_processing_3/include/CGAL/compute_average_spacing.h +++ b/Point_set_processing_3/include/CGAL/compute_average_spacing.h @@ -33,7 +33,7 @@ #include #include -#include +#include #include #include @@ -46,6 +46,11 @@ #include #endif // CGAL_LINKED_WITH_TBB +#ifdef DOXYGEN_RUNNING +#define CGAL_BGL_NP_TEMPLATE_PARAMETERS NamedParameters +#define CGAL_BGL_NP_CLASS NamedParameters +#endif + namespace CGAL { @@ -184,28 +189,29 @@ compute_average_spacing(const typename Kernel::Point_3& query, ///< 3D point who */ template #ifdef DOXYGEN_RUNNING FT #else - typename Point_set_processing_3::GetK::Kernel::FT + typename Point_set_processing_3::GetK::Kernel::FT #endif compute_average_spacing( const PointRange& points, unsigned int k, - const NamedParameters& np) + const CGAL_BGL_NP_CLASS& np) { - using boost::choose_param; + using parameters::choose_parameter; + using parameters::get_parameter; // basic geometric types - typedef typename Point_set_processing_3::GetPointMap::const_type PointMap; - typedef typename Point_set_processing_3::GetK::Kernel Kernel; + typedef typename Point_set_processing_3::GetPointMap::const_type PointMap; + typedef typename Point_set_processing_3::GetK::Kernel Kernel; typedef typename Kernel::Point_3 Point; - PointMap point_map = choose_param(get_param(np, internal_np::point_map), PointMap()); - const cpp11::function& callback = choose_param(get_param(np, internal_np::callback), + PointMap point_map = choose_parameter(get_parameter(np, internal_np::point_map), PointMap()); + const cpp11::function& callback = choose_parameter(get_parameter(np, internal_np::callback), cpp11::function()); // types for K nearest neighbors search structure diff --git a/Point_set_processing_3/include/CGAL/edge_aware_upsample_point_set.h b/Point_set_processing_3/include/CGAL/edge_aware_upsample_point_set.h index b66026ac2ea..c4390072e11 100644 --- a/Point_set_processing_3/include/CGAL/edge_aware_upsample_point_set.h +++ b/Point_set_processing_3/include/CGAL/edge_aware_upsample_point_set.h @@ -32,7 +32,7 @@ #include #include -#include +#include #include #include @@ -328,7 +328,8 @@ edge_aware_upsample_point_set( OutputIterator output, const NamedParameters& np) { - using boost::choose_param; + using parameters::choose_parameter; + using parameters::get_parameter; // basic geometric types typedef typename Point_set_processing_3::GetPointMap::type PointMap; @@ -344,12 +345,12 @@ edge_aware_upsample_point_set( typedef typename Kernel::FT FT; typedef typename rich_grid_internal::Rich_point Rich_point; - PointMap point_map = choose_param(get_param(np, internal_np::point_map), PointMap()); - NormalMap normal_map = choose_param(get_param(np, internal_np::normal_map), NormalMap()); - double sharpness_angle = choose_param(get_param(np, internal_np::sharpness_angle), 30.); - double edge_sensitivity = choose_param(get_param(np, internal_np::edge_sensitivity), 1); - double neighbor_radius = choose_param(get_param(np, internal_np::neighbor_radius), -1); - std::size_t number_of_output_points = choose_param(get_param(np, internal_np::number_of_output_points), 1000); + PointMap point_map = choose_parameter(get_parameter(np, internal_np::point_map), PointMap()); + NormalMap normal_map = choose_parameter(get_parameter(np, internal_np::normal_map), NormalMap()); + double sharpness_angle = choose_parameter(get_parameter(np, internal_np::sharpness_angle), 30.); + double edge_sensitivity = choose_parameter(get_parameter(np, internal_np::edge_sensitivity), 1); + double neighbor_radius = choose_parameter(get_parameter(np, internal_np::neighbor_radius), -1); + std::size_t number_of_output_points = choose_parameter(get_parameter(np, internal_np::number_of_output_points), 1000); std::cerr << sharpness_angle << " " << edge_sensitivity << " " << neighbor_radius << " " << number_of_output_points << std::endl; diff --git a/Point_set_processing_3/include/CGAL/estimate_scale.h b/Point_set_processing_3/include/CGAL/estimate_scale.h index 860bf5a183e..dac8adac205 100644 --- a/Point_set_processing_3/include/CGAL/estimate_scale.h +++ b/Point_set_processing_3/include/CGAL/estimate_scale.h @@ -36,7 +36,7 @@ #include #include -#include +#include #include #include @@ -494,15 +494,17 @@ estimate_local_k_neighbor_scales( OutputIterator output, const NamedParameters& np) { - using boost::choose_param; + using parameters::choose_parameter; + using parameters::get_parameter; + typedef typename Point_set_processing_3::GetPointMap::const_type PointMap; typedef typename Point_set_processing_3::GetQueryPointMap::const_type QueryPointMap; typedef typename Point_set_processing_3::GetK::Kernel Kernel; typedef typename boost::property_traits::value_type Point_d; - PointMap point_map = choose_param(get_param(np, internal_np::point_map), PointMap()); - QueryPointMap query_point_map = choose_param(get_param(np, internal_np::query_point_map), QueryPointMap()); + PointMap point_map = choose_parameter(get_parameter(np, internal_np::point_map), PointMap()); + QueryPointMap query_point_map = choose_parameter(get_parameter(np, internal_np::query_point_map), QueryPointMap()); // Build multi-scale KD-tree internal::Quick_multiscale_approximate_knn_distance kdtree (points.begin(), @@ -570,9 +572,11 @@ estimate_global_k_neighbor_scale( const PointRange& points, const NamedParameters& np) { - using boost::choose_param; + using parameters::choose_parameter; + using parameters::get_parameter; + typedef typename Point_set_processing_3::GetPointMap::const_type PointMap; - PointMap point_map = choose_param(get_param(np, internal_np::point_map), PointMap()); + PointMap point_map = choose_parameter(get_parameter(np, internal_np::point_map), PointMap()); std::vector scales; estimate_local_k_neighbor_scales (points, points, std::back_inserter (scales), np.query_point_map(point_map)); std::sort (scales.begin(), scales.end()); @@ -643,15 +647,17 @@ estimate_local_range_scales( OutputIterator output, const NamedParameters& np) { - using boost::choose_param; + using parameters::choose_parameter; + using parameters::get_parameter; + typedef typename Point_set_processing_3::GetPointMap::const_type PointMap; typedef typename Point_set_processing_3::GetQueryPointMap::const_type QueryPointMap; typedef typename Point_set_processing_3::GetK::Kernel Kernel; typedef typename boost::property_traits::value_type Point_d; - PointMap point_map = choose_param(get_param(np, internal_np::point_map), PointMap()); - QueryPointMap query_point_map = choose_param(get_param(np, internal_np::query_point_map), QueryPointMap()); + PointMap point_map = choose_parameter(get_parameter(np, internal_np::point_map), PointMap()); + QueryPointMap query_point_map = choose_parameter(get_parameter(np, internal_np::query_point_map), QueryPointMap()); // Build multi-scale KD-tree internal::Quick_multiscale_approximate_knn_distance kdtree (points.begin(), @@ -726,10 +732,12 @@ estimate_global_range_scale( const PointRange& points, const NamedParameters& np) { - using boost::choose_param; + using parameters::choose_parameter; + using parameters::get_parameter; + std::vector scales; typedef typename Point_set_processing_3::GetPointMap::const_type PointMap; - PointMap point_map = choose_param(get_param(np, internal_np::point_map), PointMap()); + PointMap point_map = choose_parameter(get_parameter(np, internal_np::point_map), PointMap()); estimate_local_range_scales (points, points, std::back_inserter (scales), np.query_point_map(point_map)); std::sort (scales.begin(), scales.end()); return std::sqrt (scales[scales.size() / 2]); diff --git a/Point_set_processing_3/include/CGAL/grid_simplify_point_set.h b/Point_set_processing_3/include/CGAL/grid_simplify_point_set.h index a4d59e32f92..9919b664769 100644 --- a/Point_set_processing_3/include/CGAL/grid_simplify_point_set.h +++ b/Point_set_processing_3/include/CGAL/grid_simplify_point_set.h @@ -33,7 +33,7 @@ #include #include -#include +#include #include #include @@ -208,11 +208,12 @@ grid_simplify_point_set( double epsilon, const NamedParameters& np) { - using boost::choose_param; + using parameters::choose_parameter; + using parameters::get_parameter; typedef typename Point_set_processing_3::GetPointMap::const_type PointMap; - PointMap point_map = choose_param(get_param(np, internal_np::point_map), PointMap()); - const cpp11::function& callback = choose_param(get_param(np, internal_np::callback), + PointMap point_map = choose_parameter(get_parameter(np, internal_np::point_map), PointMap()); + const cpp11::function& callback = choose_parameter(get_parameter(np, internal_np::callback), cpp11::function()); // actual type of input points diff --git a/Point_set_processing_3/include/CGAL/hierarchy_simplify_point_set.h b/Point_set_processing_3/include/CGAL/hierarchy_simplify_point_set.h index b12bda49e87..831e3d58586 100644 --- a/Point_set_processing_3/include/CGAL/hierarchy_simplify_point_set.h +++ b/Point_set_processing_3/include/CGAL/hierarchy_simplify_point_set.h @@ -41,7 +41,7 @@ #include #include -#include +#include #include namespace CGAL { @@ -161,7 +161,8 @@ namespace CGAL { hierarchy_simplify_point_set (PointRange& points, const NamedParameters& np) { - using boost::choose_param; + using parameters::choose_parameter; + using parameters::get_parameter; // basic geometric types typedef typename Point_set_processing_3::GetPointMap::type PointMap; @@ -172,10 +173,10 @@ namespace CGAL { typedef typename Kernel::Vector_3 Vector; typedef typename Kernel::FT FT; - PointMap point_map = choose_param(get_param(np, internal_np::point_map), PointMap()); - unsigned int size = choose_param(get_param(np, internal_np::size), 10); - double var_max = choose_param(get_param(np, internal_np::maximum_variation), 1./3.); - const cpp11::function& callback = choose_param(get_param(np, internal_np::callback), + PointMap point_map = choose_parameter(get_parameter(np, internal_np::point_map), PointMap()); + unsigned int size = choose_parameter(get_parameter(np, internal_np::size), 10); + double var_max = choose_parameter(get_parameter(np, internal_np::maximum_variation), 1./3.); + const cpp11::function& callback = choose_parameter(get_parameter(np, internal_np::callback), cpp11::function()); typedef typename std::iterator_traits::value_type Input_type; diff --git a/Point_set_processing_3/include/CGAL/jet_estimate_normals.h b/Point_set_processing_3/include/CGAL/jet_estimate_normals.h index 646f2c5a8bc..eaeeff049cd 100644 --- a/Point_set_processing_3/include/CGAL/jet_estimate_normals.h +++ b/Point_set_processing_3/include/CGAL/jet_estimate_normals.h @@ -34,7 +34,7 @@ #include #include -#include +#include #include #include @@ -212,7 +212,8 @@ jet_estimate_normals( unsigned int k, const NamedParameters& np) { - using boost::choose_param; + using parameters::choose_parameter; + using parameters::get_parameter; CGAL_TRACE("Calls jet_estimate_normals()\n"); @@ -229,10 +230,10 @@ jet_estimate_normals( typename GetSvdTraits::NoTraits>::value), "Error: no SVD traits"); - PointMap point_map = choose_param(get_param(np, internal_np::point_map), PointMap()); - NormalMap normal_map = choose_param(get_param(np, internal_np::normal_map), NormalMap()); - unsigned int degree_fitting = choose_param(get_param(np, internal_np::degree_fitting), 2); - const cpp11::function& callback = choose_param(get_param(np, internal_np::callback), + PointMap point_map = choose_parameter(get_parameter(np, internal_np::point_map), PointMap()); + NormalMap normal_map = choose_parameter(get_parameter(np, internal_np::normal_map), NormalMap()); + unsigned int degree_fitting = choose_parameter(get_parameter(np, internal_np::degree_fitting), 2); + const cpp11::function& callback = choose_parameter(get_parameter(np, internal_np::callback), cpp11::function()); typedef typename Kernel::Point_3 Point; diff --git a/Point_set_processing_3/include/CGAL/jet_smooth_point_set.h b/Point_set_processing_3/include/CGAL/jet_smooth_point_set.h index e0557b3b412..56e735063a2 100644 --- a/Point_set_processing_3/include/CGAL/jet_smooth_point_set.h +++ b/Point_set_processing_3/include/CGAL/jet_smooth_point_set.h @@ -33,7 +33,7 @@ #include #include -#include +#include #include #include @@ -216,7 +216,8 @@ jet_smooth_point_set( unsigned int k, const NamedParameters& np) { - using boost::choose_param; + using parameters::choose_parameter; + using parameters::get_parameter; // basic geometric types typedef typename Point_set_processing_3::GetPointMap::type PointMap; @@ -227,10 +228,10 @@ jet_smooth_point_set( typename GetSvdTraits::NoTraits>::value), "Error: no SVD traits"); - PointMap point_map = choose_param(get_param(np, internal_np::point_map), PointMap()); - unsigned int degree_fitting = choose_param(get_param(np, internal_np::degree_fitting), 2); - unsigned int degree_monge = choose_param(get_param(np, internal_np::degree_monge), 2); - const cpp11::function& callback = choose_param(get_param(np, internal_np::callback), + PointMap point_map = choose_parameter(get_parameter(np, internal_np::point_map), PointMap()); + unsigned int degree_fitting = choose_parameter(get_parameter(np, internal_np::degree_fitting), 2); + unsigned int degree_monge = choose_parameter(get_parameter(np, internal_np::degree_monge), 2); + const cpp11::function& callback = choose_parameter(get_parameter(np, internal_np::callback), cpp11::function()); typedef typename Kernel::Point_3 Point; diff --git a/Point_set_processing_3/include/CGAL/mst_orient_normals.h b/Point_set_processing_3/include/CGAL/mst_orient_normals.h index 8dd0bd69d92..6c8ae6be09a 100644 --- a/Point_set_processing_3/include/CGAL/mst_orient_normals.h +++ b/Point_set_processing_3/include/CGAL/mst_orient_normals.h @@ -35,7 +35,7 @@ #include #include -#include +#include #include #include @@ -614,7 +614,9 @@ mst_orient_normals( unsigned int k, const NamedParameters& np) { - using boost::choose_param; + using parameters::choose_parameter; + using parameters::get_parameter; + CGAL_TRACE("Calls mst_orient_normals()\n"); typedef typename Point_set_processing_3::GetPointMap::type PointMap; @@ -626,9 +628,9 @@ mst_orient_normals( typename Point_set_processing_3::GetNormalMap::NoMap>::value), "Error: no normal map"); - PointMap point_map = choose_param(get_param(np, internal_np::point_map), PointMap()); - NormalMap normal_map = choose_param(get_param(np, internal_np::normal_map), NormalMap()); - ConstrainedMap constrained_map = choose_param(get_param(np, internal_np::point_is_constrained), ConstrainedMap()); + PointMap point_map = choose_parameter(get_parameter(np, internal_np::point_map), PointMap()); + NormalMap normal_map = choose_parameter(get_parameter(np, internal_np::normal_map), NormalMap()); + ConstrainedMap constrained_map = choose_parameter(get_parameter(np, internal_np::point_is_constrained), ConstrainedMap()); Kernel kernel; // Bring private stuff to scope diff --git a/Point_set_processing_3/include/CGAL/pca_estimate_normals.h b/Point_set_processing_3/include/CGAL/pca_estimate_normals.h index 133e793384a..302e0efb338 100644 --- a/Point_set_processing_3/include/CGAL/pca_estimate_normals.h +++ b/Point_set_processing_3/include/CGAL/pca_estimate_normals.h @@ -35,7 +35,7 @@ #include #include -#include +#include #include #include @@ -199,7 +199,9 @@ pca_estimate_normals( unsigned int k, const NamedParameters& np) { - using boost::choose_param; + using parameters::choose_parameter; + using parameters::get_parameter; + CGAL_TRACE("Calls pca_estimate_normals()\n"); // basic geometric types @@ -211,9 +213,9 @@ pca_estimate_normals( typename Point_set_processing_3::GetNormalMap::NoMap>::value), "Error: no normal map"); - PointMap point_map = choose_param(get_param(np, internal_np::point_map), PointMap()); - NormalMap normal_map = choose_param(get_param(np, internal_np::normal_map), NormalMap()); - const cpp11::function& callback = choose_param(get_param(np, internal_np::callback), + PointMap point_map = choose_parameter(get_parameter(np, internal_np::point_map), PointMap()); + NormalMap normal_map = choose_parameter(get_parameter(np, internal_np::normal_map), NormalMap()); + const cpp11::function& callback = choose_parameter(get_parameter(np, internal_np::callback), cpp11::function()); typedef typename Kernel::Point_3 Point; diff --git a/Point_set_processing_3/include/CGAL/random_simplify_point_set.h b/Point_set_processing_3/include/CGAL/random_simplify_point_set.h index 51017d05771..925d7b3ff5f 100644 --- a/Point_set_processing_3/include/CGAL/random_simplify_point_set.h +++ b/Point_set_processing_3/include/CGAL/random_simplify_point_set.h @@ -31,7 +31,7 @@ #include #include -#include +#include #include #include diff --git a/Point_set_processing_3/include/CGAL/remove_outliers.h b/Point_set_processing_3/include/CGAL/remove_outliers.h index d3df9cae48b..50dc230de58 100644 --- a/Point_set_processing_3/include/CGAL/remove_outliers.h +++ b/Point_set_processing_3/include/CGAL/remove_outliers.h @@ -31,7 +31,7 @@ #include #include -#include +#include #include #include @@ -162,16 +162,17 @@ remove_outliers( unsigned int k, const NamedParameters& np) { - using boost::choose_param; + using parameters::choose_parameter; + using parameters::get_parameter; // geometric types typedef typename Point_set_processing_3::GetPointMap::type PointMap; typedef typename Point_set_processing_3::GetK::Kernel Kernel; - PointMap point_map = choose_param(get_param(np, internal_np::point_map), PointMap()); - double threshold_percent = choose_param(get_param(np, internal_np::threshold_percent), 10.); - double threshold_distance = choose_param(get_param(np, internal_np::threshold_distance), 0.); - const cpp11::function& callback = choose_param(get_param(np, internal_np::callback), + PointMap point_map = choose_parameter(get_parameter(np, internal_np::point_map), PointMap()); + double threshold_percent = choose_parameter(get_parameter(np, internal_np::threshold_percent), 10.); + double threshold_distance = choose_parameter(get_parameter(np, internal_np::threshold_distance), 0.); + const cpp11::function& callback = choose_parameter(get_parameter(np, internal_np::callback), cpp11::function()); typedef typename Kernel::FT FT; diff --git a/Point_set_processing_3/include/CGAL/structure_point_set.h b/Point_set_processing_3/include/CGAL/structure_point_set.h index cc83bdc5409..be074232e2c 100644 --- a/Point_set_processing_3/include/CGAL/structure_point_set.h +++ b/Point_set_processing_3/include/CGAL/structure_point_set.h @@ -42,7 +42,7 @@ #include #include -#include +#include #include #include @@ -235,7 +235,8 @@ public: double epsilon, const NamedParameters& np) { - using boost::choose_param; + using parameters::choose_parameter; + using parameters::get_parameter; // basic geometric types typedef typename Point_set_processing_3::GetPointMap::type PointMap; @@ -250,11 +251,11 @@ public: typename Point_set_processing_3::GetPlaneIndexMap::NoMap>::value), "Error: no plane index map"); - PointMap point_map = choose_param(get_param(np, internal_np::point_map), PointMap()); - NormalMap normal_map = choose_param(get_param(np, internal_np::normal_map), NormalMap()); - PlaneMap plane_map = choose_param(get_param(np, internal_np::plane_map), PlaneMap()); - PlaneIndexMap index_map = choose_param(get_param(np, internal_np::plane_index_map), PlaneIndexMap()); - double attraction_factor = choose_param(get_param(np, internal_np::attraction_factor), 3.); + PointMap point_map = choose_parameter(get_parameter(np, internal_np::point_map), PointMap()); + NormalMap normal_map = choose_parameter(get_parameter(np, internal_np::normal_map), NormalMap()); + PlaneMap plane_map = choose_parameter(get_parameter(np, internal_np::plane_map), PlaneMap()); + PlaneIndexMap index_map = choose_parameter(get_parameter(np, internal_np::plane_index_map), PlaneIndexMap()); + double attraction_factor = choose_parameter(get_parameter(np, internal_np::attraction_factor), 3.); m_points.reserve(points.size()); m_normals.reserve(points.size()); @@ -1553,7 +1554,8 @@ structure_point_set (const PointRange& points, double epsilon, const NamedParameters& np) { - using boost::choose_param; + using parameters::choose_parameter; + using parameters::get_parameter; typedef typename Point_set_processing_3::GetK::Kernel Kernel; diff --git a/Point_set_processing_3/include/CGAL/vcm_estimate_normals.h b/Point_set_processing_3/include/CGAL/vcm_estimate_normals.h index 96cd7f8f7c1..b1344960a4c 100644 --- a/Point_set_processing_3/include/CGAL/vcm_estimate_normals.h +++ b/Point_set_processing_3/include/CGAL/vcm_estimate_normals.h @@ -38,7 +38,7 @@ #include #include -#include +#include #include #include @@ -265,12 +265,14 @@ compute_vcm (const PointRange& points, double convolution_radius, const NamedParameters& np) { - using boost::choose_param; + using parameters::choose_parameter; + using parameters::get_parameter; + // basic geometric types typedef typename Point_set_processing_3::GetPointMap::type PointMap; typedef typename Point_set_processing_3::GetK::Kernel Kernel; - PointMap point_map = choose_param(get_param(np, internal_np::point_map), PointMap()); + PointMap point_map = choose_parameter(get_parameter(np, internal_np::point_map), PointMap()); Kernel kernel; // First, compute the VCM for each point @@ -345,7 +347,9 @@ vcm_estimate_normals_internal (PointRange& points, int nb_neighbors_convolve = -1 ///< number of neighbors used during the convolution. ) { - using boost::choose_param; + using parameters::choose_parameter; + using parameters::get_parameter; + // basic geometric types typedef typename Point_set_processing_3::GetPointMap::type PointMap; typedef typename Point_set_processing_3::GetNormalMap::type NormalMap; @@ -356,8 +360,8 @@ vcm_estimate_normals_internal (PointRange& points, typename Point_set_processing_3::GetNormalMap::NoMap>::value), "Error: no normal map"); - PointMap point_map = choose_param(get_param(np, internal_np::point_map), PointMap()); - NormalMap normal_map = choose_param(get_param(np, internal_np::normal_map), NormalMap()); + PointMap point_map = choose_parameter(get_parameter(np, internal_np::point_map), PointMap()); + NormalMap normal_map = choose_parameter(get_parameter(np, internal_np::normal_map), NormalMap()); typedef cpp11::array Covariance; diff --git a/Point_set_processing_3/include/CGAL/wlop_simplify_and_regularize_point_set.h b/Point_set_processing_3/include/CGAL/wlop_simplify_and_regularize_point_set.h index 87c03e7ddbd..02aceb64990 100644 --- a/Point_set_processing_3/include/CGAL/wlop_simplify_and_regularize_point_set.h +++ b/Point_set_processing_3/include/CGAL/wlop_simplify_and_regularize_point_set.h @@ -32,7 +32,7 @@ #include #include -#include +#include #include #include #include @@ -470,18 +470,19 @@ wlop_simplify_and_regularize_point_set( const NamedParameters& np ) { - using boost::choose_param; + using parameters::choose_parameter; + using parameters::get_parameter; // basic geometric types typedef typename Point_set_processing_3::GetPointMap::type PointMap; typedef typename Point_set_processing_3::GetK::Kernel Kernel; - PointMap point_map = choose_param(get_param(np, internal_np::point_map), PointMap()); - double select_percentage = choose_param(get_param(np, internal_np::select_percentage), 5.); - double radius = choose_param(get_param(np, internal_np::neighbor_radius), -1); - unsigned int iter_number = choose_param(get_param(np, internal_np::number_of_iterations), 35); - bool require_uniform_sampling = choose_param(get_param(np, internal_np::require_uniform_sampling), false); - const cpp11::function& callback = choose_param(get_param(np, internal_np::callback), + PointMap point_map = choose_parameter(get_parameter(np, internal_np::point_map), PointMap()); + double select_percentage = choose_parameter(get_parameter(np, internal_np::select_percentage), 5.); + double radius = choose_parameter(get_parameter(np, internal_np::neighbor_radius), -1); + unsigned int iter_number = choose_parameter(get_parameter(np, internal_np::number_of_iterations), 35); + bool require_uniform_sampling = choose_parameter(get_parameter(np, internal_np::require_uniform_sampling), false); + const cpp11::function& callback = choose_parameter(get_parameter(np, internal_np::callback), cpp11::function()); typedef typename Kernel::Point_3 Point; diff --git a/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/bbox.h b/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/bbox.h index 0419603d52c..5c32b5db6fd 100644 --- a/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/bbox.h +++ b/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/bbox.h @@ -66,14 +66,14 @@ namespace CGAL { CGAL::Bbox_3 bbox(const PolygonMesh& pmesh, const CGAL_PMP_NP_CLASS& np) { - using boost::choose_param; - using boost::get_param; + using parameters::choose_parameter; + using parameters::get_parameter; typename GetVertexPointMap::const_type - vpm = choose_param(get_param(np, internal_np::vertex_point), + vpm = choose_parameter(get_parameter(np, internal_np::vertex_point), get_const_property_map(CGAL::vertex_point, pmesh)); typedef typename GetGeomTraits::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()); typename GT::Construct_bbox_3 get_bbox = gt.construct_bbox_3_object(); typedef typename boost::graph_traits::vertex_descriptor vertex_descriptor; @@ -116,14 +116,14 @@ namespace CGAL { const PolygonMesh& pmesh, const NamedParameters& np) { - using boost::choose_param; - using boost::get_param; + using parameters::choose_parameter; + using parameters::get_parameter; typename GetVertexPointMap::const_type - vpm = choose_param(get_param(np, internal_np::vertex_point), + vpm = choose_parameter(get_parameter(np, internal_np::vertex_point), get_const_property_map(CGAL::vertex_point, pmesh)); typedef typename GetGeomTraits::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()); typename GT::Construct_bbox_3 get_bbox = gt.construct_bbox_3_object(); return get_bbox( get(vpm, vd) ); @@ -159,14 +159,14 @@ namespace CGAL { const PolygonMesh& pmesh, const NamedParameters& np) { - using boost::choose_param; - using boost::get_param; + using parameters::choose_parameter; + using parameters::get_parameter; typename GetVertexPointMap::const_type - vpm = choose_param(get_param(np, internal_np::vertex_point), + vpm = choose_parameter(get_parameter(np, internal_np::vertex_point), get_const_property_map(CGAL::vertex_point, pmesh)); typedef typename GetGeomTraits::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()); typename GT::Construct_bbox_3 get_bbox = gt.construct_bbox_3_object(); return get_bbox( get(vpm, source(ed, pmesh)) ) + @@ -203,14 +203,14 @@ namespace CGAL { const PolygonMesh& pmesh, const NamedParameters& np) { - using boost::choose_param; - using boost::get_param; + using parameters::choose_parameter; + using parameters::get_parameter; typename GetVertexPointMap::const_type - vpm = choose_param(get_param(np, internal_np::vertex_point), + vpm = choose_parameter(get_parameter(np, internal_np::vertex_point), get_const_property_map(CGAL::vertex_point, pmesh)); typedef typename GetGeomTraits::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()); typename GT::Construct_bbox_3 get_bbox = gt.construct_bbox_3_object(); typedef typename boost::graph_traits::halfedge_descriptor halfedge_descriptor; diff --git a/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/border.h b/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/border.h index 6e7c905b64d..f32cc1f656f 100644 --- a/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/border.h +++ b/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/border.h @@ -200,8 +200,8 @@ namespace Polygon_mesh_processing { } //face index map given as a named parameter, or as an internal property map - FIMap fim = boost::choose_param(get_param(np, internal_np::face_index), - get_const_property_map(CGAL::face_index, pmesh)); + FIMap fim = parameters::choose_parameter(parameters::get_parameter(np, internal_np::face_index), + get_const_property_map(CGAL::face_index, pmesh)); return internal::border_halfedges_impl(faces, fim, out, pmesh, np); } diff --git a/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/clip.h b/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/clip.h index 078097a4ebf..269da38f7ba 100644 --- a/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/clip.h +++ b/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/clip.h @@ -71,7 +71,7 @@ clip_to_bbox(const Plane_3& plane, typedef typename GetVertexPointMap::type Vpm; - Vpm vpm_out = boost::choose_param(boost::get_param(np, internal_np::vertex_point), + Vpm vpm_out = parameters::choose_parameter(parameters::get_parameter(np, internal_np::vertex_point), get_property_map(boost::vertex_point, tm_out)); @@ -334,7 +334,7 @@ clip( TriangleMesh& tm, const NamedParameters2& np_c) { const bool clip_volume = - boost::choose_param(boost::get_param(np_tm, internal_np::clip_volume), false); + boost::choose_parameter(boost::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); diff --git a/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/compute_normal.h b/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/compute_normal.h index e3d52c2bcef..dddfa5a6d85 100644 --- a/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/compute_normal.h +++ b/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/compute_normal.h @@ -137,14 +137,14 @@ compute_face_normal(typename boost::graph_traits::face_descriptor f , const PolygonMesh& pmesh , const NamedParameters& np) { - using boost::choose_param; - using boost::get_param; + using parameters::choose_parameter; + using parameters::get_parameter; typedef typename GetGeomTraits::type GT; - GT traits = choose_param(get_param(np, internal_np::geom_traits), GT()); + GT traits = choose_parameter(get_parameter(np, internal_np::geom_traits), GT()); typedef typename GetVertexPointMap::const_type VPMap; - VPMap vpmap = choose_param(get_param(np, internal_np::vertex_point), + VPMap vpmap = choose_parameter(get_parameter(np, internal_np::vertex_point), get_const_property_map(vertex_point, pmesh)); typedef typename GT::Point_3 Point; @@ -235,18 +235,19 @@ compute_vertex_normal(typename boost::graph_traits::vertex_descript const NamedParameters& np ) { - using boost::choose_param; + using parameters::choose_parameter; + using parameters::get_parameter; typedef typename GetGeomTraits::type GT; typedef typename GT::Vector_3 Vector; - GT traits = choose_param(get_param(np, internal_np::geom_traits), GT()); + GT traits = choose_parameter(get_parameter(np, internal_np::geom_traits), GT()); typedef typename GetFaceNormalMap::NoMap DefaultMap; - typedef typename boost::lookup_named_param_def < + typedef typename internal_np::Lookup_named_param_def < internal_np::face_normal_t, NamedParameters, DefaultMap> ::type FaceNormalMap; - FaceNormalMap fnmap = choose_param(get_param(np, internal_np::face_normal), DefaultMap()); + FaceNormalMap fnmap = choose_parameter(get_parameter(np, internal_np::face_normal), DefaultMap()); bool fnmap_valid = !boost::is_same #include -#include +#include #include #include #include @@ -133,16 +133,16 @@ connected_component(typename boost::graph_traits::face_descriptor s , FaceOutputIterator out , const NamedParameters& np) { - using boost::choose_param; - using boost::get_param; + using parameters::choose_parameter; + using parameters::get_parameter; - typedef typename boost::lookup_named_param_def < + typedef typename internal_np::Lookup_named_param_def < internal_np::edge_is_constrained_t, NamedParameters, internal::No_constraint//default > ::type EdgeConstraintMap; EdgeConstraintMap ecmap - = choose_param(get_param(np, internal_np::edge_is_constrained), + = choose_parameter(get_parameter(np, internal_np::edge_is_constrained), internal::No_constraint()); typedef typename boost::graph_traits::face_descriptor face_descriptor; @@ -213,16 +213,16 @@ connected_components(const PolygonMesh& pmesh, FaceComponentMap fcm, const NamedParameters& np) { - using boost::choose_param; - using boost::get_param; + using parameters::choose_parameter; + using parameters::get_parameter; - typedef typename boost::lookup_named_param_def < + typedef typename internal_np::Lookup_named_param_def < internal_np::edge_is_constrained_t, NamedParameters, internal::No_constraint//default > ::type EdgeConstraintMap; EdgeConstraintMap ecmap - = choose_param(get_param(np, internal_np::edge_is_constrained), + = choose_parameter(get_parameter(np, internal_np::edge_is_constrained), internal::No_constraint()); typedef Dual Dual; @@ -234,7 +234,7 @@ connected_components(const PolygonMesh& pmesh, internal::No_border(pmesh, ecmap)); typename GetFaceIndexMap::const_type - fimap = choose_param(get_param(np, internal_np::face_index), + fimap = choose_parameter(get_parameter(np, internal_np::face_index), get_const_property_map(boost::face_index, pmesh)); return boost::connected_components(finite_dual, @@ -296,12 +296,12 @@ std::size_t keep_largest_connected_components(PolygonMesh& pmesh typedef PolygonMesh PM; typedef typename boost::graph_traits::face_descriptor face_descriptor; - using boost::choose_param; - using boost::get_param; + using parameters::choose_parameter; + using parameters::get_parameter; //FaceIndexMap typedef typename GetFaceIndexMap::type FaceIndexMap; - FaceIndexMap fimap = choose_param(get_param(np, internal_np::face_index), + FaceIndexMap fimap = choose_parameter(get_parameter(np, internal_np::face_index), get_property_map(boost::face_index, pmesh)); //vector_property_map @@ -379,12 +379,12 @@ std::size_t keep_large_connected_components(PolygonMesh& pmesh typedef PolygonMesh PM; typedef typename boost::graph_traits::face_descriptor face_descriptor; - using boost::choose_param; - using boost::get_param; + using parameters::choose_parameter; + using parameters::get_parameter; //FaceIndexMap typedef typename GetFaceIndexMap::type FaceIndexMap; - FaceIndexMap fim = choose_param(get_param(np, internal_np::face_index), + FaceIndexMap fim = choose_parameter(get_parameter(np, internal_np::face_index), get_property_map(boost::face_index, pmesh)); //vector_property_map @@ -433,8 +433,8 @@ void keep_or_remove_connected_components(PolygonMesh& pmesh , const NamedParameters& np) { typedef PolygonMesh PM; - using boost::choose_param; - using boost::get_param; + using parameters::choose_parameter; + using parameters::get_parameter; typedef typename boost::graph_traits::face_descriptor face_descriptor; typedef typename boost::graph_traits::face_iterator face_iterator; @@ -446,7 +446,7 @@ void keep_or_remove_connected_components(PolygonMesh& pmesh //VertexIndexMap typedef typename GetVertexIndexMap::type VertexIndexMap; - VertexIndexMap vim = choose_param(get_param(np, internal_np::vertex_index), + VertexIndexMap vim = choose_parameter(get_parameter(np, internal_np::vertex_index), get_const_property_map(boost::vertex_index, pmesh)); std::set cc_to_keep; @@ -683,12 +683,12 @@ void remove_connected_components(PolygonMesh& pmesh if (components_to_remove.empty()) return; typedef PolygonMesh PM; typedef typename boost::graph_traits::face_descriptor face_descriptor; - using boost::choose_param; - using boost::get_param; + using parameters::choose_parameter; + using parameters::get_parameter; //FaceIndexMap typedef typename GetFaceIndexMap::type FaceIndexMap; - FaceIndexMap fim = choose_param(get_param(np, internal_np::face_index), + FaceIndexMap fim = choose_parameter(get_parameter(np, internal_np::face_index), get_property_map(boost::face_index, pmesh)); //vector_property_map @@ -741,12 +741,12 @@ void keep_connected_components(PolygonMesh& pmesh typedef PolygonMesh PM; typedef typename boost::graph_traits::face_descriptor face_descriptor; - using boost::choose_param; - using boost::get_param; + using parameters::choose_parameter; + using parameters::get_parameter; //FaceIndexMap typedef typename GetFaceIndexMap::type FaceIndexMap; - FaceIndexMap fim = choose_param(get_param(np, internal_np::face_index), + FaceIndexMap fim = choose_parameter(get_parameter(np, internal_np::face_index), get_property_map(boost::face_index, pmesh)); //vector_property_map diff --git a/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/corefinement.h b/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/corefinement.h index c7ba7288508..4159605e3c8 100644 --- a/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/corefinement.h +++ b/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/corefinement.h @@ -193,10 +193,10 @@ 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(boost::get_param(np, internal_np::vertex_point), + Vpm vpm = parameters::choose_parameter(parameters::get_parameter(np, internal_np::vertex_point), get_const_property_map(boost::vertex_point, tm)); - Fid_map fid_map = boost::choose_param(boost::get_param(np, internal_np::face_index), + Fid_map fid_map = parameters::choose_parameter(parameters::get_parameter(np, internal_np::face_index), get_const_property_map(boost::face_index, tm)); std::vector face_cc(num_faces(tm), std::size_t(-1)); @@ -249,13 +249,13 @@ bool does_bound_a_volume(const TriangleMesh& tm) /// \endcond #define CGAL_COREF_SET_OUTPUT_EDGE_MARK_MAP(I) \ - typedef typename boost::lookup_named_param_def < \ + typedef typename internal_np::Lookup_named_param_def < \ internal_np::edge_is_constrained_t, \ NamedParametersOut##I, \ Corefinement::No_mark \ > ::type Ecm_out_##I; \ Ecm_out_##I ecm_out_##I = \ - boost::choose_param( boost::get_param(cpp11::get(nps_out), internal_np::edge_is_constrained), \ + parameters::choose_parameter( parameters::get_parameter(cpp11::get(nps_out), internal_np::edge_is_constrained), \ Corefinement::No_mark() ); @@ -361,7 +361,7 @@ corefine_and_compute_boolean_operations( NamedParametersOut3>& nps_out) { const bool throw_on_self_intersection = - boost::choose_param(boost::get_param(np1, internal_np::throw_on_self_intersection), false); + parameters::choose_parameter(parameters::get_parameter(np1, internal_np::throw_on_self_intersection), false); // Vertex point maps //for input meshes @@ -374,10 +374,10 @@ corefine_and_compute_boolean_operations( static const bool same_vpm = (boost::is_same::value); ) CGAL_static_assertion(same_vpm); - Vpm vpm1 = boost::choose_param(boost::get_param(np1, internal_np::vertex_point), + Vpm vpm1 = parameters::choose_parameter(parameters::get_parameter(np1, internal_np::vertex_point), get_property_map(boost::vertex_point, tm1)); - Vpm vpm2 = boost::choose_param(boost::get_param(np2, internal_np::vertex_point), + Vpm vpm2 = parameters::choose_parameter(parameters::get_parameter(np2, internal_np::vertex_point), get_property_map(boost::vertex_point, tm2)); typedef typename boost::property_traits::value_type Point_3; @@ -494,21 +494,21 @@ corefine_and_compute_boolean_operations( // Edge is-constrained maps //for input meshes - typedef typename boost::lookup_named_param_def < + typedef typename internal_np::Lookup_named_param_def < internal_np::edge_is_constrained_t, NamedParameters1, Corefinement::No_mark//default > ::type Ecm1; - typedef typename boost::lookup_named_param_def < + typedef typename internal_np::Lookup_named_param_def < internal_np::edge_is_constrained_t, NamedParameters2, Corefinement::No_mark//default > ::type Ecm2; - Ecm1 ecm1 = boost::choose_param( boost::get_param(np1, internal_np::edge_is_constrained), + Ecm1 ecm1 = parameters::choose_parameter( parameters::get_parameter(np1, internal_np::edge_is_constrained), Corefinement::No_mark() ); - Ecm2 ecm2 = boost::choose_param( boost::get_param(np2, internal_np::edge_is_constrained), + Ecm2 ecm2 = parameters::choose_parameter( parameters::get_parameter(np2, internal_np::edge_is_constrained), Corefinement::No_mark() ); typedef Corefinement::Ecm_bind Ecm_in; @@ -533,17 +533,17 @@ corefine_and_compute_boolean_operations( static const bool same_fidmap = (boost::is_same::value);) CGAL_static_assertion(same_fidmap); - Fid_map fid_map1 = boost::choose_param(boost::get_param(np1, internal_np::face_index), + Fid_map fid_map1 = parameters::choose_parameter(parameters::get_parameter(np1, internal_np::face_index), get_property_map(boost::face_index, tm1)); - Fid_map fid_map2 = boost::choose_param(boost::get_param(np2, internal_np::face_index), + Fid_map fid_map2 = parameters::choose_parameter(parameters::get_parameter(np2, internal_np::face_index), get_property_map(boost::face_index, tm2)); // User visitor - typedef typename boost::lookup_named_param_def < + typedef typename internal_np::Lookup_named_param_def < internal_np::graph_visitor_t, NamedParameters1, Corefinement::Default_visitor//default > ::type User_visitor; - User_visitor uv( boost::choose_param( boost::get_param(np1, internal_np::graph_visitor), + User_visitor uv( parameters::choose_parameter( parameters::get_parameter(np1, internal_np::graph_visitor), Corefinement::Default_visitor() ) ); // surface intersection algorithm call @@ -841,7 +841,7 @@ corefine_and_compute_difference( TriangleMesh& tm1, const NamedParameters2& np2) { const bool throw_on_self_intersection = - boost::choose_param(boost::get_param(np1, internal_np::throw_on_self_intersection), false); + parameters::choose_parameter(parameters::get_parameter(np1, internal_np::throw_on_self_intersection), false); // Vertex point maps typedef typename GetVertexPointMap::value);) CGAL_static_assertion(same_vpm); - Vpm vpm1 = boost::choose_param(boost::get_param(np1, internal_np::vertex_point), + Vpm vpm1 = parameters::choose_parameter(parameters::get_parameter(np1, internal_np::vertex_point), get_property_map(boost::vertex_point, tm1)); - Vpm vpm2 = boost::choose_param(boost::get_param(np2, internal_np::vertex_point), + Vpm vpm2 = parameters::choose_parameter(parameters::get_parameter(np2, internal_np::vertex_point), get_property_map(boost::vertex_point, tm2)); // Edge is-constrained maps - typedef typename boost::lookup_named_param_def < + typedef typename internal_np::Lookup_named_param_def < internal_np::edge_is_constrained_t, NamedParameters1, Corefinement::No_mark//default > ::type Ecm1; - typedef typename boost::lookup_named_param_def < + typedef typename internal_np::Lookup_named_param_def < internal_np::edge_is_constrained_t, NamedParameters2, Corefinement::No_mark//default > ::type Ecm2; - Ecm1 ecm1 = boost::choose_param( boost::get_param(np1, internal_np::edge_is_constrained), + Ecm1 ecm1 = parameters::choose_parameter( parameters::get_parameter(np1, internal_np::edge_is_constrained), Corefinement::No_mark() ); - Ecm2 ecm2 = boost::choose_param( boost::get_param(np2, internal_np::edge_is_constrained), + Ecm2 ecm2 = parameters::choose_parameter( parameters::get_parameter(np2, internal_np::edge_is_constrained), Corefinement::No_mark() ); typedef Corefinement::Ecm_bind Ecm; @@ -887,12 +887,12 @@ corefine_and_compute_difference( TriangleMesh& tm1, } // User visitor - typedef typename boost::lookup_named_param_def < + typedef typename internal_np::Lookup_named_param_def < internal_np::graph_visitor_t, NamedParameters1, Corefinement::Default_visitor//default > ::type User_visitor; - User_visitor uv( boost::choose_param( boost::get_param(np1, internal_np::graph_visitor), + User_visitor uv( parameters::choose_parameter( parameters::get_parameter(np1, internal_np::graph_visitor), Corefinement::Default_visitor() ) ); // surface intersection algorithm call @@ -945,27 +945,27 @@ namespace experimental { typedef typename GetVertexPointMap::type Vpm; - Vpm vpm = boost::choose_param(boost::get_param(np, internal_np::vertex_point), + Vpm vpm = parameters::choose_parameter(parameters::get_parameter(np, internal_np::vertex_point), get_property_map(boost::vertex_point, tm)); // Edge is-constrained maps - typedef typename boost::lookup_named_param_def < + typedef typename internal_np::Lookup_named_param_def < internal_np::edge_is_constrained_t, NamedParameters, Corefinement::No_mark//default > ::type Ecm; - Ecm ecm = boost::choose_param( boost::get_param(np, internal_np::edge_is_constrained), + Ecm ecm = parameters::choose_parameter( parameters::get_parameter(np, internal_np::edge_is_constrained), Corefinement::No_mark() ); // User visitor - typedef typename boost::lookup_named_param_def < + typedef typename internal_np::Lookup_named_param_def < internal_np::graph_visitor_t, NamedParameters, Corefinement::Default_visitor//default > ::type User_visitor; - User_visitor uv( boost::choose_param( boost::get_param(np, internal_np::graph_visitor), + User_visitor uv( parameters::choose_parameter( parameters::get_parameter(np, internal_np::graph_visitor), Corefinement::Default_visitor() ) ); @@ -1020,28 +1020,28 @@ namespace experimental { // Vertex point maps typedef typename GetVertexPointMap::type Vpm; - Vpm vpm = boost::choose_param(boost::get_param(np, internal_np::vertex_point), + Vpm vpm = parameters::choose_parameter(parameters::get_parameter(np, internal_np::vertex_point), get_property_map(boost::vertex_point, tm)); // Face index map typedef typename GetFaceIndexMap::type Fid_map; - Fid_map fid_map = boost::choose_param(boost::get_param(np, internal_np::face_index), + Fid_map fid_map = parameters::choose_parameter(parameters::get_parameter(np, internal_np::face_index), get_property_map(boost::face_index, tm)); // Edge is-constrained maps - typedef typename boost::lookup_named_param_def < + typedef typename internal_np::Lookup_named_param_def < internal_np::edge_is_constrained_t, NamedParameters, Corefinement::No_mark//default > ::type Ecm; - Ecm ecm = boost::choose_param( boost::get_param(np, internal_np::edge_is_constrained), + Ecm ecm = parameters::choose_parameter( parameters::get_parameter(np, internal_np::edge_is_constrained), Corefinement::No_mark() ); // User visitor - typedef typename boost::lookup_named_param_def < + typedef typename internal_np::Lookup_named_param_def < internal_np::graph_visitor_t, NamedParameters, Corefinement::Default_visitor//default > ::type User_visitor; - User_visitor uv( boost::choose_param( boost::get_param(np, internal_np::graph_visitor), + User_visitor uv( parameters::choose_parameter( parameters::get_parameter(np, internal_np::graph_visitor), Corefinement::Default_visitor() ) ); // surface intersection algorithm call diff --git a/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/detect_features.h b/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/detect_features.h index 433cdd75222..754443fede9 100644 --- a/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/detect_features.h +++ b/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/detect_features.h @@ -149,11 +149,11 @@ detect_surface_patches(PolygonMesh& p, { //extract types from NPs typename GetFaceIndexMap::const_type - fimap = boost::choose_param(get_param(np, internal_np::face_index), + fimap = parameters::choose_parameter(parameters::get_parameter(np, internal_np::face_index), get_const_property_map(boost::face_index, p)); int offset = static_cast( - boost::choose_param(get_param(np, internal_np::first_index), + parameters::choose_parameter(parameters::get_parameter(np, internal_np::first_index), 1)); internal::PatchIdMapWrapper::edge_descriptor edge_descriptor; typedef typename boost::graph_traits::halfedge_descriptor halfedge_descriptor; @@ -286,10 +286,10 @@ void detect_sharp_edges(PolygonMesh& pmesh, { //extract types from NPs typedef typename GetGeomTraits::type GT; - typedef typename GetGeomTraits::type::FT FT; + typedef typename GT::FT FT; internal::sharp_call(pmesh, angle_in_deg, edge_is_feature_map, - get_param(np, internal_np::vertex_feature_degree)); + parameters::get_parameter(np, internal_np::vertex_feature_degree)); } @@ -365,7 +365,7 @@ namespace internal template - void vip_call(PolygonMesh&, PIDMap, const boost::param_not_found&, EIFMap) + void vip_call(PolygonMesh&, PIDMap, const internal_np::Param_not_found&, EIFMap) { //do nothing when the parameter is not given } @@ -440,7 +440,7 @@ sharp_edges_segmentation(PolygonMesh& pmesh, internal::detect_surface_patches(pmesh, patch_id_map, edge_is_feature_map, np); internal::vip_call(pmesh, patch_id_map, - get_param(np, internal_np::vertex_incident_patches), edge_is_feature_map); + parameters::get_parameter(np, internal_np::vertex_incident_patches), edge_is_feature_map); return result; } diff --git a/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/distance.h b/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/distance.h index 5b83e37234d..893ec4724fa 100644 --- a/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/distance.h +++ b/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/distance.h @@ -341,32 +341,32 @@ sample_triangle_mesh(const TriangleMesh& tm, typedef typename GT::halfedge_descriptor halfedge_descriptor; typedef typename GT::edge_descriptor edge_descriptor; - using boost::choose_param; - using boost::get_param; - using boost::is_default_param; + using parameters::choose_parameter; + using parameters::get_parameter; + using parameters::is_default_parameter; - Vpm pmap = choose_param(get_param(np, internal_np::vertex_point), + Vpm pmap = choose_parameter(get_parameter(np, internal_np::vertex_point), get_const_property_map(vertex_point, tm)); typedef Creator_uniform_3 Creator; - Geom_traits geomtraits = choose_param(get_param(np, internal_np::geom_traits), Geom_traits()); + Geom_traits geomtraits = choose_parameter(get_parameter(np, internal_np::geom_traits), Geom_traits()); - 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); + bool use_rs = choose_parameter(get_parameter(np, internal_np::random_uniform_sampling), true); + bool use_gs = choose_parameter(get_parameter(np, internal_np::grid_sampling), false); + bool use_ms = choose_parameter(get_parameter(np, internal_np::monte_carlo_sampling), false); if (use_gs || use_ms) - if (is_default_param(get_param(np, internal_np::random_uniform_sampling))) + if (is_default_parameter(get_parameter(np, internal_np::random_uniform_sampling))) use_rs=false; - 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); + bool smpl_vrtcs = choose_parameter(get_parameter(np, internal_np::do_sample_vertices), true); + bool smpl_dgs = choose_parameter(get_parameter(np, internal_np::do_sample_edges), true); + bool smpl_fcs = choose_parameter(get_parameter(np, internal_np::do_sample_faces), true); - 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.); + double nb_pts_a_u = choose_parameter(get_parameter(np, internal_np::nb_points_per_area_unit), 0.); + double nb_pts_l_u = choose_parameter(get_parameter(np, internal_np::nb_points_per_distance_unit), 0.); // sample vertices if (smpl_vrtcs) @@ -381,7 +381,7 @@ sample_triangle_mesh(const TriangleMesh& tm, // grid sampling if (use_gs) { - double grid_spacing_ = choose_param(get_param(np, internal_np::grid_spacing), 0.); + double grid_spacing_ = choose_parameter(get_parameter(np, internal_np::grid_spacing), 0.); if (grid_spacing_==0.) { // set grid spacing to the shortest edge length @@ -408,9 +408,9 @@ sample_triangle_mesh(const TriangleMesh& tm, double min_edge_length = (std::numeric_limits::max)(); std::size_t nb_points_per_face = - choose_param(get_param(np, internal_np::number_of_points_per_face), 0); + choose_parameter(get_parameter(np, internal_np::number_of_points_per_face), 0); std::size_t nb_points_per_edge = - choose_param(get_param(np, internal_np::number_of_points_per_edge), 0); + choose_parameter(get_parameter(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.) ) @@ -489,7 +489,7 @@ sample_triangle_mesh(const TriangleMesh& tm, // sample faces if(smpl_fcs) { - std::size_t nb_points = choose_param(get_param(np, internal_np::number_of_points_on_faces), 0); + std::size_t nb_points = choose_parameter(get_parameter(np, internal_np::number_of_points_on_faces), 0); Random_points_in_triangle_mesh_3 g(tm, pmap); if (nb_points == 0) { @@ -505,7 +505,7 @@ sample_triangle_mesh(const TriangleMesh& tm, if (smpl_dgs) { std::size_t nb_points = - choose_param(get_param(np, internal_np::number_of_points_on_edges), 0); + choose_parameter(get_parameter(np, internal_np::number_of_points_on_edges), 0); Random_points_on_edge_list_graph_3 g(tm, pmap); if (nb_points == 0) { @@ -631,7 +631,7 @@ double approximate_Hausdorff_distance( const TriangleMesh& tm1, NamedParameters1>::type Geom_traits; return approximate_Hausdorff_distance( - tm1, tm2, np1, choose_param(get_param(np2, internal_np::vertex_point), + tm1, tm2, np1, parameters::choose_parameter(parameters::get_parameter(np2, internal_np::vertex_point), get_const_property_map(vertex_point, tm2))); } @@ -688,7 +688,7 @@ double max_distance_to_triangle_mesh(const PointRange& points, NamedParameters>::type Geom_traits; return approximate_Hausdorff_distance - (points,tm,choose_param(get_param(np, internal_np::vertex_point), + (points,tm,parameters::choose_parameter(parameters::get_parameter(np, internal_np::vertex_point), get_const_property_map(vertex_point, tm))); } @@ -735,8 +735,8 @@ 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, internal_np::vertex_point), - get_const_property_map(vertex_point, tm)), + points[i] = get(parameters::choose_parameter(parameters::get_parameter(np, internal_np::vertex_point), + get_const_property_map(vertex_point, tm)), target(hd, tm)); hd = next(hd, tm); } diff --git a/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/extrude.h b/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/extrude.h index ae7dc759dba..d6829941c42 100644 --- a/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/extrude.h +++ b/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/extrude.h @@ -28,7 +28,7 @@ #include #include -#include +#include #include #include #include @@ -178,9 +178,12 @@ void extrude_mesh(const InputMesh& input, typedef typename GetVertexPointMap < OutputMesh, NamedParameters2>::type VPMap; typedef typename GetVertexPointMap < InputMesh, NamedParameters1>::const_type IVPMap; - VPMap output_vpm = choose_param(get_param(np_out, internal_np::vertex_point), + using parameters::get_parameter; + using parameters::choose_parameter; + + VPMap output_vpm = choose_parameter(get_parameter(np_out, internal_np::vertex_point), get_property_map(vertex_point, output)); - IVPMap input_vpm = choose_param(get_param(np_in, internal_np::vertex_point), + IVPMap input_vpm = choose_parameter(get_parameter(np_in, internal_np::vertex_point), get_const_property_map(vertex_point, input)); std::vector > bottom_v2v; @@ -273,7 +276,7 @@ void extrude_mesh(const InputMesh& input, const NamedParameters2& np_out) { typedef typename GetVertexPointMap < OutputMesh, NamedParameters2>::type VPMap; - VPMap output_vpm = choose_param(get_param(np_out, internal_np::vertex_point), + VPMap output_vpm = parameters::choose_parameter(parameters::get_parameter(np_out, internal_np::vertex_point), get_property_map(vertex_point, output)); extrude_impl::Const_dist_translation< diff --git a/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/fair.h b/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/fair.h index ecc2f3ebdad..8a679c7ba6d 100644 --- a/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/fair.h +++ b/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/fair.h @@ -116,8 +116,8 @@ namespace internal { const VertexRange& vertices, const NamedParameters& np) { - using boost::get_param; - using boost::choose_param; + using parameters::get_parameter; + using parameters::choose_parameter; CGAL_precondition(is_triangle_mesh(tmesh)); @@ -149,13 +149,13 @@ namespace internal { typedef CGAL::internal::Cotangent_weight_with_voronoi_area_fairing Default_Weight_calculator; - VPMap vpmap_ = choose_param(get_param(np, internal_np::vertex_point), + VPMap vpmap_ = choose_parameter(get_parameter(np, internal_np::vertex_point), get_property_map(vertex_point, tmesh)); return internal::fair(tmesh, vertices, - 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), + choose_parameter(get_parameter(np, internal_np::sparse_linear_solver), Default_solver()), + choose_parameter(get_parameter(np, internal_np::weight_calculator), Default_Weight_calculator(tmesh, vpmap_)), + choose_parameter(get_parameter(np, internal_np::fairing_continuity), 1), vpmap_ ); } diff --git a/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/internal/Corefinement/face_graph_utils.h b/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/internal/Corefinement/face_graph_utils.h index 1349fbc2c43..5d9759f9659 100644 --- a/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/internal/Corefinement/face_graph_utils.h +++ b/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/internal/Corefinement/face_graph_utils.h @@ -206,8 +206,8 @@ boost::optional< typename TweakedGetVertexPointMap::type > get_vpm(const NP& np, boost::optional opm, boost::true_type) { if (boost::none == opm) return boost::none; - return boost::choose_param( - boost::get_param(np, internal_np::vertex_point), + return parameters::choose_parameter( + parameters::get_parameter(np, internal_np::vertex_point), get_property_map(boost::vertex_point, *(*opm)) ); } diff --git a/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/internal/Isotropic_remeshing/remesh_impl.h b/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/internal/Isotropic_remeshing/remesh_impl.h index 8994b0453e7..f37a4b93ba1 100644 --- a/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/internal/Isotropic_remeshing/remesh_impl.h +++ b/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/internal/Isotropic_remeshing/remesh_impl.h @@ -1060,7 +1060,7 @@ namespace internal { // PMP book : // "maps the vertices back to the surface" - void project_to_surface(boost::param_not_found) + void project_to_surface(internal_np::Param_not_found) { //todo : handle the case of boundary vertices #ifdef CGAL_PMP_REMESHING_VERBOSE diff --git a/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/internal/named_function_params.h b/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/internal/named_function_params.h index 2379bbf48a4..93471268e55 100644 --- a/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/internal/named_function_params.h +++ b/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/internal/named_function_params.h @@ -25,7 +25,7 @@ #include -#include +#include #define CGAL_PMP_NP_TEMPLATE_PARAMETERS CGAL_BGL_NP_TEMPLATE_PARAMETERS #define CGAL_PMP_NP_CLASS CGAL_BGL_NP_CLASS diff --git a/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/intersection.h b/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/intersection.h index 54bd62babbd..42ee61d4aa7 100644 --- a/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/intersection.h +++ b/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/intersection.h @@ -402,8 +402,8 @@ compute_face_face_intersection(const FaceRange& face_range1, const NamedParameters1& np1, const NamedParameters2& np2) { - using boost::get_param; - using boost::choose_param; + using parameters::get_parameter; + using parameters::choose_parameter; CGAL_precondition(CGAL::is_triangle_mesh(tm1)); CGAL_precondition(CGAL::is_triangle_mesh(tm2)); @@ -433,9 +433,9 @@ compute_face_face_intersection(const FaceRange& face_range1, typedef typename GetVertexPointMap::const_type VertexPointMap1; typedef typename GetVertexPointMap::const_type VertexPointMap2; - VertexPointMap1 vpmap1 = choose_param(get_param(np1, internal_np::vertex_point), + VertexPointMap1 vpmap1 = choose_parameter(get_parameter(np1, internal_np::vertex_point), get_const_property_map(boost::vertex_point, tm1)); - VertexPointMap2 vpmap2 = choose_param(get_param(np2, internal_np::vertex_point), + VertexPointMap2 vpmap2 = choose_parameter(get_parameter(np2, internal_np::vertex_point), get_const_property_map(boost::vertex_point, tm2)); CGAL_static_assertion( (boost::is_same< @@ -461,7 +461,7 @@ compute_face_face_intersection(const FaceRange& face_range1, // compute intersections filtered out by boxes typedef typename GetGeomTraits::type GeomTraits; - GeomTraits gt = choose_param(get_param(np1, internal_np::geom_traits), GeomTraits()); + GeomTraits gt = choose_parameter(get_parameter(np1, internal_np::geom_traits), GeomTraits()); internal::Intersect_faces::face_descriptor face_descriptor; typedef typename GetVertexPointMap::const_type VertexPointMap; - VertexPointMap vpmap = choose_param(get_param(np, internal_np::vertex_point), - get_const_property_map(boost::vertex_point, tm)); + VertexPointMap vpmap = choose_parameter(get_parameter(np, internal_np::vertex_point), + get_const_property_map(boost::vertex_point, tm)); typedef typename boost::property_traits::value_type Point; CGAL_static_assertion( (boost::is_same::type GeomTraits; - GeomTraits gt = choose_param(get_param(np, internal_np::geom_traits), GeomTraits()); + GeomTraits gt = choose_parameter(get_parameter(np, internal_np::geom_traits), GeomTraits()); internal::Intersect_face_polyline::face_descriptor face_descriptor; typedef typename GetVertexPointMap::const_type VertexPointMap; - VertexPointMap vpmap = choose_param(get_param(np, internal_np::vertex_point), - get_const_property_map(boost::vertex_point, tm)); + VertexPointMap vpmap = choose_parameter(get_parameter(np, internal_np::vertex_point), + get_const_property_map(boost::vertex_point, tm)); typedef typename boost::property_traits::value_type Point; typedef typename boost::range_value::type Polyline; CGAL_static_assertion( @@ -731,7 +731,7 @@ compute_face_polylines_intersection(const FaceRange& face_range, // compute intersections filtered out by boxes typedef typename GetGeomTraits::type GeomTraits; - GeomTraits gt = choose_param(get_param(np, internal_np::geom_traits), GeomTraits()); + GeomTraits gt = choose_parameter(get_parameter(np, internal_np::geom_traits), GeomTraits()); internal::Intersect_face_polylines::const_type VertexPointMap1; typedef typename GetVertexPointMap::const_type VertexPointMap2; - VertexPointMap1 vpm1 = choose_param(get_param(np1, internal_np::vertex_point), + VertexPointMap1 vpm1 = choose_parameter(get_parameter(np1, internal_np::vertex_point), get_const_property_map(boost::vertex_point, tm1)); - VertexPointMap2 vpm2 = choose_param(get_param(np2, internal_np::vertex_point), + VertexPointMap2 vpm2 = choose_parameter(get_parameter(np2, internal_np::vertex_point), get_const_property_map(boost::vertex_point, tm2)); typedef typename GetGeomTraits::type GeomTraits; - GeomTraits gt = choose_param(get_param(np1, internal_np::geom_traits), GeomTraits()); + GeomTraits gt = choose_parameter(get_parameter(np1, internal_np::geom_traits), GeomTraits()); return internal::is_mesh2_in_mesh1(tm1, tm2, vpm1, vpm2, gt) || internal::is_mesh2_in_mesh1(tm2, tm1, vpm2, vpm1, gt); @@ -1513,18 +1513,18 @@ struct Mesh_callback template void operator()(const Mesh_box* b1, const Mesh_box* b2) { - using boost::choose_param; - using boost::get_param; + using parameters::choose_parameter; + using parameters::get_parameter; std::size_t mesh_id_1 = std::distance(meshes.begin(), b1->info()); std::size_t mesh_id_2 = std::distance(meshes.begin(), b2->info()); - VPM vpm1 = choose_param(get_param(*(nps.begin() + mesh_id_1), internal_np::vertex_point), - get_const_property_map(CGAL::vertex_point, *b1->info())); + VPM vpm1 = choose_parameter(get_parameter(*(nps.begin() + mesh_id_1), internal_np::vertex_point), + get_const_property_map(CGAL::vertex_point, *b1->info())); - VPM vpm2 = choose_param(get_param(*(nps.begin() + mesh_id_2), internal_np::vertex_point), - get_const_property_map(CGAL::vertex_point, *b2->info())); + VPM vpm2 = choose_parameter(get_parameter(*(nps.begin() + mesh_id_2), internal_np::vertex_point), + get_const_property_map(CGAL::vertex_point, *b2->info())); //surfacic test if(Polygon_mesh_processing::do_intersect(*b1->info(), @@ -1597,12 +1597,12 @@ OutputIterator intersecting_meshes(const TriangleMeshRange& range, NamedParameters np, NamedParametersRange nps) { - using boost::choose_param; - using boost::get_param; + using parameters::choose_parameter; + using parameters::get_parameter; typedef typename TriangleMeshRange::const_iterator TriangleMeshIterator; - bool report_overlap = choose_param(get_param(np, internal_np::overlap_test),false); + bool report_overlap = choose_parameter(get_parameter(np, internal_np::overlap_test),false); typedef CGAL::Box_intersection_d::Box_with_info_d Mesh_box; std::vector boxes; @@ -1620,7 +1620,7 @@ OutputIterator intersecting_meshes(const TriangleMeshRange& range, typedef typename boost::range_value::type NP_rng; typedef typename boost::range_value::type TriangleMesh; typedef typename GetGeomTraits::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()); //get all the pairs of meshes intersecting (no strict inclusion test) @@ -1636,7 +1636,7 @@ OutputIterator intersecting_meshes(const TriangleMeshRange& range, OutputIterator out, NamedParameters np) { - std::vector >nps( + std::vector >nps( std::distance(range.begin(), range.end()), parameters::all_default()); return intersecting_meshes(range, out, np, nps); } @@ -1695,7 +1695,7 @@ surface_intersection(const TriangleMesh& tm1, const NamedParameters2& np2) { const bool throw_on_self_intersection = - boost::choose_param(get_param(np1, internal_np::throw_on_self_intersection), false); + parameters::choose_parameter(parameters::get_parameter(np1, internal_np::throw_on_self_intersection), false); typedef typename GetVertexPointMap::const_type Vpm; @@ -1706,12 +1706,10 @@ surface_intersection(const TriangleMesh& tm1, static const bool same_vpm = (boost::is_same::value);) CGAL_static_assertion(same_vpm); - Vpm vpm1 = choose_const_pmap(get_param(np1, internal_np::vertex_point), - tm1, - vertex_point); - Vpm vpm2 = choose_const_pmap(get_param(np2, internal_np::vertex_point), - tm2, - vertex_point); + Vpm vpm1 = parameters::choose_parameter(parameters::get_parameter(np1, internal_np::vertex_point), + get_const_property_map(CGAL::vertex_point, tm1)); + Vpm vpm2 = parameters::choose_parameter(parameters::get_parameter(np2, internal_np::vertex_point), + get_const_property_map(CGAL::vertex_point, tm2)); Corefinement::Intersection_of_triangle_meshes functor(tm1, tm2, vpm1, vpm2); @@ -1755,9 +1753,8 @@ surface_self_intersection(const TriangleMesh& tm, typedef typename GetVertexPointMap::const_type Vpm; - Vpm vpm = choose_const_pmap(get_param(np, internal_np::vertex_point), - tm, - vertex_point); + Vpm vpm = parameters::choose_parameter(parameters::get_parameter(np, internal_np::vertex_point), + get_const_property_map(CGAL::vertex_point, tm)); // surface intersection algorithm call typedef Corefinement::Default_surface_intersection_visitor::const_type - vpm = choose_param(get_param(np, internal_np::vertex_point), + vpm = choose_parameter(get_parameter(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)), @@ -318,13 +318,13 @@ public: , const TriangleMesh& tmesh , const CGAL_PMP_NP_CLASS& np) { - using boost::choose_param; - using boost::get_param; + using parameters::choose_parameter; + using parameters::get_parameter; CGAL_precondition(boost::graph_traits::null_face() != f); typename GetVertexPointMap::const_type - vpm = choose_param(get_param(np, internal_np::vertex_point), + vpm = choose_parameter(get_parameter(np, internal_np::vertex_point), get_const_property_map(CGAL::vertex_point, tmesh)); typedef typename boost::graph_traits::halfedge_descriptor halfedge_descriptor; @@ -501,11 +501,11 @@ volume(const TriangleMesh& tmesh, const CGAL_PMP_NP_CLASS& np) CGAL_assertion(is_triangle_mesh(tmesh)); CGAL_assertion(is_closed(tmesh)); - using boost::choose_param; - using boost::get_param; + using parameters::choose_parameter; + using parameters::get_parameter; typename GetVertexPointMap::const_type - vpm = choose_param(get_param(np, internal_np::vertex_point), + vpm = choose_parameter(get_parameter(np, internal_np::vertex_point), get_const_property_map(CGAL::vertex_point, tmesh)); typename GetGeomTraits::type::Point_3 origin(0, 0, 0); diff --git a/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/orientation.h b/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/orientation.h index c2b32d54d63..486ba067c67 100644 --- a/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/orientation.h +++ b/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/orientation.h @@ -70,18 +70,18 @@ namespace internal{ const PolygonMesh& pmesh, const NamedParameters& np) { - using boost::choose_param; - using boost::get_param; + using parameters::choose_parameter; + using parameters::get_parameter; CGAL_assertion(halfedge(v_max, pmesh)!=boost::graph_traits::null_halfedge()); //VertexPointMap typedef typename GetVertexPointMap::const_type VPMap; - VPMap vpmap = choose_param(get_param(np, internal_np::vertex_point), + VPMap vpmap = choose_parameter(get_parameter(np, internal_np::vertex_point), get_const_property_map(vertex_point, pmesh)); //Kernel typedef typename GetGeomTraits::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()); //among the incoming edges of `v_max`, find one edge `e` with the minimal slope typedef typename boost::graph_traits::halfedge_descriptor halfedge_descriptor; @@ -183,16 +183,16 @@ bool is_outward_oriented(const PolygonMesh& pmesh, if (faces(pmesh).first == faces(pmesh).second) return true; - using boost::choose_param; - using boost::get_param; + using parameters::choose_parameter; + using parameters::get_parameter; //VertexPointMap typedef typename GetVertexPointMap::const_type VPMap; - VPMap vpmap = choose_param(get_param(np, internal_np::vertex_point), + VPMap vpmap = choose_parameter(get_parameter(np, internal_np::vertex_point), get_const_property_map(vertex_point, pmesh)); //Kernel typedef typename GetGeomTraits::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()); //find the vertex with maximal z coordinate internal::Compare_vertex_points_z_3 less_z(vpmap, gt); @@ -483,16 +483,16 @@ void orient(TriangleMesh& tm, const NamedParameters& np) CGAL_assertion(is_valid_polygon_mesh(tm)); CGAL_assertion(is_closed(tm)); - using boost::choose_param; - using boost::get_param; + using parameters::choose_parameter; + using parameters::get_parameter; - bool orient_outward = choose_param( - get_param(np, internal_np::outward_orientation),true); + bool orient_outward = choose_parameter( + get_parameter(np, internal_np::outward_orientation),true); - Vpm vpm = choose_param(get_param(np, internal_np::vertex_point), + Vpm vpm = choose_parameter(get_parameter(np, internal_np::vertex_point), get_const_property_map(boost::vertex_point, tm)); - Fid_map fid_map = choose_param(get_param(np, internal_np::face_index), + Fid_map fid_map = choose_parameter(get_parameter(np, internal_np::face_index), get_const_property_map(boost::face_index, tm)); std::vector face_cc(num_faces(tm), std::size_t(-1)); @@ -590,16 +590,16 @@ void orient_to_bound_a_volume(TriangleMesh& tm, if (!is_closed(tm)) return; if (!is_triangle_mesh(tm)) return; - using boost::choose_param; - using boost::get_param; + using parameters::choose_parameter; + using parameters::get_parameter; - bool orient_outward = choose_param( - get_param(np, internal_np::outward_orientation),true); + bool orient_outward = choose_parameter( + get_parameter(np, internal_np::outward_orientation),true); - Vpm vpm = choose_param(get_param(np, internal_np::vertex_point), + Vpm vpm = choose_parameter(get_parameter(np, internal_np::vertex_point), get_const_property_map(boost::vertex_point, tm)); - Fid_map fid_map = choose_param(get_param(np, internal_np::face_index), + Fid_map fid_map = choose_parameter(get_parameter(np, internal_np::face_index), get_const_property_map(boost::face_index, tm)); std::vector face_cc(num_faces(tm), std::size_t(-1)); diff --git a/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/random_perturbation.h b/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/random_perturbation.h index 8a210843b1e..a9a0d904735 100644 --- a/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/random_perturbation.h +++ b/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/random_perturbation.h @@ -151,8 +151,8 @@ void random_perturbation(VertexRange vertices , const NamedParameters& np) { typedef TriangleMesh PM; - using boost::get_param; - using boost::choose_param; + using parameters::get_parameter; + using parameters::choose_parameter; typedef typename boost::graph_traits::vertex_descriptor vertex_descriptor; @@ -165,22 +165,22 @@ void random_perturbation(VertexRange vertices #endif typedef typename GetGeomTraits::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::type VPMap; - VPMap vpmap = choose_param(get_param(np, internal_np::vertex_point), + VPMap vpmap = choose_parameter(get_parameter(np, internal_np::vertex_point), get_property_map(vertex_point, tmesh)); - typedef typename boost::lookup_named_param_def < + typedef typename internal_np::Lookup_named_param_def < internal_np::vertex_is_constrained_t, NamedParameters, Constant_property_map // default > ::type VCMap; - VCMap vcmap = choose_param(get_param(np, internal_np::vertex_is_constrained), - Constant_property_map(false)); + VCMap vcmap = choose_parameter(get_parameter(np, internal_np::vertex_is_constrained), + Constant_property_map(false)); - unsigned int seed = choose_param(get_param(np, internal_np::random_seed), -1); - bool do_project = choose_param(get_param(np, internal_np::do_project), true); + unsigned int seed = choose_parameter(get_parameter(np, internal_np::random_seed), -1); + bool do_project = choose_parameter(get_parameter(np, internal_np::do_project), true); CGAL::Random rng = (seed == unsigned(-1)) ? CGAL::Random() : CGAL::Random(seed); diff --git a/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/refine.h b/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/refine.h index 8a6319284b5..88535bc196f 100644 --- a/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/refine.h +++ b/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/refine.h @@ -83,20 +83,20 @@ namespace Polygon_mesh_processing { VertexOutputIterator vertices_out, const NamedParameters& np) { - using boost::choose_param; - using boost::get_param; + using parameters::choose_parameter; + using parameters::get_parameter; CGAL_precondition(is_triangle_mesh(tmesh) ); typedef typename GetVertexPointMap::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_property_map(vertex_point, tmesh)); internal::Refine_Polyhedron_3 refine_functor(tmesh, vpm); refine_functor.refine(faces, faces_out, vertices_out, - choose_param(get_param(np, internal_np::density_control_factor), CGAL::sqrt(2.))); + choose_parameter(get_parameter(np, internal_np::density_control_factor), CGAL::sqrt(2.))); return std::make_pair(faces_out, vertices_out); } diff --git a/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/remesh.h b/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/remesh.h index 337a62e49f3..a738cbaada0 100644 --- a/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/remesh.h +++ b/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/remesh.h @@ -148,8 +148,8 @@ void isotropic_remeshing(const FaceRange& faces typedef PolygonMesh PM; typedef typename boost::graph_traits::vertex_descriptor vertex_descriptor; typedef typename boost::graph_traits::edge_descriptor edge_descriptor; - using boost::get_param; - using boost::choose_param; + using parameters::get_parameter; + using parameters::choose_parameter; #ifdef CGAL_PMP_REMESHING_VERBOSE std::cout << std::endl; @@ -160,45 +160,45 @@ void isotropic_remeshing(const FaceRange& faces #endif static const bool need_aabb_tree = - boost::is_default_param(get_param(np, internal_np::projection_functor)); + parameters::is_default_parameter(get_parameter(np, internal_np::projection_functor)); typedef typename GetGeomTraits::type GT; GT gt = choose_param(get_param(np, internal_np::geom_traits), GT()); typedef typename GetVertexPointMap::type VPMap; - VPMap vpmap = choose_param(get_param(np, internal_np::vertex_point), + VPMap vpmap = choose_parameter(get_parameter(np, internal_np::vertex_point), get_property_map(vertex_point, pmesh)); typedef typename GetFaceIndexMap::type FIMap; - FIMap fimap = choose_param(get_param(np, internal_np::face_index), + FIMap fimap = choose_parameter(get_parameter(np, internal_np::face_index), get_property_map(face_index, pmesh)); - typedef typename boost::lookup_named_param_def < + typedef typename internal_np::Lookup_named_param_def < internal_np::edge_is_constrained_t, NamedParameters, Constant_property_map // default (no constraint pmap) > ::type ECMap; - ECMap ecmap = choose_param(get_param(np, internal_np::edge_is_constrained), - Constant_property_map(false)); + ECMap ecmap = choose_parameter(get_parameter(np, internal_np::edge_is_constrained), + Constant_property_map(false)); - typedef typename boost::lookup_named_param_def < + typedef typename internal_np::Lookup_named_param_def < internal_np::vertex_is_constrained_t, NamedParameters, Constant_property_map // default (no constraint pmap) > ::type VCMap; - VCMap vcmap = choose_param(get_param(np, internal_np::vertex_is_constrained), - Constant_property_map(false)); + VCMap vcmap = choose_parameter(get_parameter(np, internal_np::vertex_is_constrained), + Constant_property_map(false)); - bool protect = choose_param(get_param(np, internal_np::protect_constraints), false); - typedef typename boost::lookup_named_param_def < + bool protect = choose_parameter(get_parameter(np, internal_np::protect_constraints), false); + typedef typename internal_np::Lookup_named_param_def < internal_np::face_patch_t, NamedParameters, internal::Connected_components_pmap//default > ::type FPMap; - FPMap fpmap = choose_param( - get_param(np, internal_np::face_patch), + FPMap fpmap = choose_parameter( + get_parameter(np, internal_np::face_patch), internal::Connected_components_pmap(faces, pmesh, ecmap, fimap, - boost::is_default_param(get_param(np, internal_np::face_patch)) && (need_aabb_tree + parameters::is_default_parameter(get_parameter(np, internal_np::face_patch)) && (need_aabb_tree #if !defined(CGAL_NO_PRECONDITIONS) || protect // face patch map is used to identify patch border edges to check protected edges are short enough #endif @@ -236,10 +236,10 @@ void isotropic_remeshing(const FaceRange& faces std::cout << " done ("<< t.time() <<" sec)." << std::endl; #endif - bool collapse_constraints = choose_param(get_param(np, internal_np::collapse_constraints), true); - 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); + bool collapse_constraints = choose_parameter(get_parameter(np, internal_np::collapse_constraints), true); + unsigned int nb_iterations = choose_parameter(get_parameter(np, internal_np::number_of_iterations), 1); + bool smoothing_1d = choose_parameter(get_parameter(np, internal_np::relax_constraints), false); + unsigned int nb_laplacian = choose_parameter(get_parameter(np, internal_np::number_of_relaxation_steps), 1); #ifdef CGAL_PMP_REMESHING_VERBOSE std::cout << std::endl; @@ -260,8 +260,8 @@ void isotropic_remeshing(const FaceRange& faces } remesher.equalize_valences(); remesher.tangential_relaxation(smoothing_1d, nb_laplacian); - if ( choose_param(get_param(np, internal_np::do_project), true) ) - remesher.project_to_surface(get_param(np, internal_np::projection_functor)); + if ( choose_parameter(get_parameter(np, internal_np::do_project), true) ) + remesher.project_to_surface(get_parameter(np, internal_np::projection_functor)); #ifdef CGAL_PMP_REMESHING_VERBOSE std::cout << std::endl; #endif @@ -337,27 +337,27 @@ void split_long_edges(const EdgeRange& edges typedef PolygonMesh PM; typedef typename boost::graph_traits::edge_descriptor edge_descriptor; typedef typename boost::graph_traits::vertex_descriptor vertex_descriptor; - using boost::choose_param; - using boost::get_param; + using parameters::choose_parameter; + using parameters::get_parameter; typedef typename GetGeomTraits::type GT; GT gt = choose_param(get_param(np, internal_np::geom_traits), GT()); typedef typename GetVertexPointMap::type VPMap; - VPMap vpmap = choose_param(get_param(np, internal_np::vertex_point), + VPMap vpmap = choose_parameter(get_parameter(np, internal_np::vertex_point), get_property_map(vertex_point, pmesh)); typedef typename GetFaceIndexMap::type FIMap; - FIMap fimap = choose_param(get_param(np, internal_np::face_index), + FIMap fimap = choose_parameter(get_parameter(np, internal_np::face_index), get_property_map(face_index, pmesh)); - typedef typename boost::lookup_named_param_def < + typedef typename internal_np::Lookup_named_param_def < internal_np::edge_is_constrained_t, NamedParameters, Constant_property_map // default (no constraint pmap) > ::type ECMap; - ECMap ecmap = choose_param(get_param(np, internal_np::edge_is_constrained), - Constant_property_map(false)); + ECMap ecmap = choose_parameter(get_parameter(np, internal_np::edge_is_constrained), + Constant_property_map(false)); typename internal::Incremental_remesher, // no constraint pmap diff --git a/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/repair.h b/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/repair.h index b0fae9cf46a..381bbb94fe8 100644 --- a/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/repair.h +++ b/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/repair.h @@ -546,8 +546,8 @@ bool remove_degenerate_edges(const EdgeRange& edge_range, CGAL_assertion(CGAL::is_triangle_mesh(tmesh)); CGAL_assertion(CGAL::is_valid_polygon_mesh(tmesh)); - using boost::get_param; - using boost::choose_param; + using parameters::get_parameter; + using parameters::choose_parameter; typedef TriangleMesh TM; typedef typename boost::graph_traits GT; @@ -557,7 +557,7 @@ bool remove_degenerate_edges(const EdgeRange& edge_range, typedef typename GT::vertex_descriptor vertex_descriptor; typedef typename GetVertexPointMap::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_property_map(vertex_point, tmesh)); typedef typename GetGeomTraits::type Traits; @@ -982,8 +982,8 @@ bool remove_degenerate_faces( TriangleMesh& tmesh, { CGAL_assertion(CGAL::is_triangle_mesh(tmesh)); - using boost::get_param; - using boost::choose_param; + using parameters::get_parameter; + using parameters::choose_parameter; typedef TriangleMesh TM; typedef typename boost::graph_traits GT; @@ -993,10 +993,10 @@ bool remove_degenerate_faces( TriangleMesh& tmesh, typedef typename GT::vertex_descriptor vertex_descriptor; typedef typename GetVertexPointMap::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_property_map(vertex_point, tmesh)); typedef typename GetGeomTraits::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 boost::property_traits::value_type Point_3; typedef typename boost::property_traits::reference Point_ref; @@ -2554,12 +2554,12 @@ bool remove_self_intersections(TriangleMesh& tm, const NamedParameters& np) // named parameter extraction typedef typename GetVertexPointMap::type VertexPointMap; - VertexPointMap vpm = boost::choose_param(boost::get_param(np, internal_np::vertex_point), + VertexPointMap vpm = parameters::choose_parameter(parameters::get_parameter(np, internal_np::vertex_point), get_property_map(vertex_point, tm)); - const int max_steps = boost::choose_param(boost::get_param(np, internal_np::number_of_iterations), 7); - bool verbose = boost::choose_param(boost::get_param(np, internal_np::verbosity_level), 0) > 0; - bool preserve_genus = boost::choose_param(boost::get_param(np, internal_np::preserve_genus), true); + const int max_steps = parameters::choose_parameter(parameters::get_parameter(np, internal_np::number_of_iterations), 7); + bool verbose = parameters::choose_parameter(parameters::get_parameter(np, internal_np::verbosity_level), 0) > 0; + bool preserve_genus = parameters::choose_parameter(parameters::get_parameter(np, internal_np::preserve_genus), true); if (verbose) std::cout << "DEBUG: Starting remove_self_intersections, is_valid(tm)? " << is_valid_polygon_mesh(tm) << "\n"; diff --git a/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/self_intersections.h b/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/self_intersections.h index 9efc2527619..b3067d30003 100644 --- a/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/self_intersections.h +++ b/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/self_intersections.h @@ -273,7 +273,7 @@ self_intersections(const TriangleMesh& tmesh #ifdef DOXYGEN_RUNNING , const NamedParameters& np) #else - , const cgal_bgl_named_params& np) + , const Named_function_parameters& np) #endif { return self_intersections(faces(tmesh), tmesh, out, np); @@ -341,8 +341,8 @@ self_intersections( const FaceRange& face_range, ); typedef typename GetVertexPointMap::const_type VertexPointMap; - VertexPointMap vpmap = boost::choose_param(get_param(np, internal_np::vertex_point), - get_const_property_map(boost::vertex_point, tmesh)); + VertexPointMap vpmap = parameters::choose_parameter(parameters::get_parameter(np, internal_np::vertex_point), + get_const_property_map(boost::vertex_point, tmesh)); BOOST_FOREACH(face_descriptor f, face_range) { @@ -367,7 +367,7 @@ self_intersections( const FaceRange& face_range, typedef typename GetGeomTraits::type GeomTraits; CGAL::internal::Intersect_facets intersect_facets(tmesh, out, vpmap, - boost::choose_param(get_param(np, internal_np::geom_traits), GeomTraits())); + parameters::choose_parameter(parameters::get_parameter(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); diff --git a/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/stitch_borders.h b/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/stitch_borders.h index 2bfb06cdd15..230e4c0659c 100644 --- a/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/stitch_borders.h +++ b/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/stitch_borders.h @@ -183,14 +183,14 @@ collect_duplicated_stitchable_boundary_edges Face_cc_map cc; std::size_t num_component = 0; std::vector > border_edges_per_cc; - bool per_cc = boost::choose_param(get_param(np, internal_np::apply_per_connected_component), - false); + bool per_cc = parameters::choose_parameter(parameters::get_parameter(np, internal_np::apply_per_connected_component), + false); if(per_cc) { cc = get(Face_property_tag(), pmesh); typedef typename GetFaceIndexMap::const_type FIMap; - FIMap fim = boost::choose_param(get_param(np, internal_np::face_index), - get_const_property_map(face_index, pmesh)); + FIMap fim = parameters::choose_parameter(parameters::get_parameter(np, internal_np::face_index), + get_const_property_map(face_index, pmesh)); num_component = num_component_wrapper(pmesh, cc, fim); border_edges_per_cc.resize(num_component); } @@ -654,8 +654,8 @@ template void stitch_borders(PolygonMesh& pmesh, const CGAL_PMP_NP_CLASS& np) { - using boost::choose_param; - using boost::get_param; + using parameters::choose_parameter; + using parameters::get_parameter; typedef typename boost::graph_traits::halfedge_descriptor halfedge_descriptor; std::vector< std::pair > hedge_pairs_to_stitch; typedef typename GetVertexPointMap::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, pmesh)); internal::stitch_boundary_cycles(pmesh, np); diff --git a/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/transform.h b/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/transform.h index cb2fac6ed76..95a78831293 100644 --- a/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/transform.h +++ b/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/transform.h @@ -54,8 +54,8 @@ void transform(const Transformation& transformation, const NamedParameters& np) { typedef typename GetVertexPointMap::type VPMap; - VPMap vpm = choose_param(get_param(np, internal_np::vertex_point), - get_property_map(vertex_point, mesh)); + VPMap vpm = parameters::choose_parameter(parameters::get_parameter(np, internal_np::vertex_point), + get_property_map(vertex_point, mesh)); BOOST_FOREACH(typename boost::graph_traits::vertex_descriptor vd, vertices(mesh)) { diff --git a/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/triangulate_faces.h b/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/triangulate_faces.h index 241f0e494b3..79d3c8888e4 100644 --- a/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/triangulate_faces.h +++ b/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/triangulate_faces.h @@ -431,20 +431,20 @@ bool triangulate_face(typename boost::graph_traits::face_descriptor PolygonMesh& pmesh, const NamedParameters& np) { - using boost::choose_param; - using boost::get_param; + using parameters::choose_parameter; + using parameters::get_parameter; //VertexPointMap typedef typename GetVertexPointMap::type VPMap; - VPMap vpmap = choose_param(get_param(np, internal_np::vertex_point), + VPMap vpmap = choose_parameter(get_parameter(np, internal_np::vertex_point), get_property_map(vertex_point, pmesh)); //Kernel typedef typename GetGeomTraits::type Kernel; - Kernel traits = choose_param(get_param(np, internal_np::geom_traits), Kernel()); + Kernel traits = choose_parameter(get_parameter(np, internal_np::geom_traits), Kernel()); //Option - bool use_cdt = choose_param(get_param(np, internal_np::use_delaunay_triangulation), true); + bool use_cdt = choose_parameter(get_parameter(np, internal_np::use_delaunay_triangulation), true); internal::Triangulate_modifier modifier(vpmap, traits); return modifier.triangulate_face(f, pmesh, use_cdt); @@ -486,20 +486,20 @@ bool triangulate_faces(FaceRange face_range, PolygonMesh& pmesh, const NamedParameters& np) { - using boost::choose_param; - using boost::get_param; + using parameters::choose_parameter; + using parameters::get_parameter; //VertexPointMap typedef typename GetVertexPointMap::type VPMap; - VPMap vpmap = choose_param(get_param(np, internal_np::vertex_point), + VPMap vpmap = choose_parameter(get_parameter(np, internal_np::vertex_point), get_property_map(vertex_point, pmesh)); //Kernel typedef typename GetGeomTraits::type Kernel; - Kernel traits = choose_param(get_param(np, internal_np::geom_traits), Kernel()); + Kernel traits = choose_parameter(get_parameter(np, internal_np::geom_traits), Kernel()); //Option - bool use_cdt = choose_param(get_param(np, internal_np::use_delaunay_triangulation), true); + bool use_cdt = choose_parameter(get_parameter(np, internal_np::use_delaunay_triangulation), true); internal::Triangulate_modifier modifier(vpmap, traits); return modifier(face_range, pmesh, use_cdt); diff --git a/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/triangulate_hole.h b/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/triangulate_hole.h index 24c2983604b..5b72abe0c9d 100644 --- a/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/triangulate_hole.h +++ b/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/triangulate_hole.h @@ -88,14 +88,14 @@ namespace Polygon_mesh_processing { OutputIterator out, const NamedParameters& np) { - using boost::choose_param; - using boost::get_param; + using parameters::choose_parameter; + using parameters::get_parameter; bool use_dt3 = #ifdef CGAL_HOLE_FILLING_DO_NOT_USE_DT3 false; #else - choose_param(get_param(np, internal_np::use_delaunay_triangulation), true); + choose_parameter(get_parameter(np, internal_np::use_delaunay_triangulation), true); #endif CGAL_precondition(face(border_halfedge, pmesh) == boost::graph_traits::null_face()); @@ -103,9 +103,9 @@ namespace Polygon_mesh_processing { return internal::triangulate_hole_polygon_mesh(pmesh, border_halfedge, out, - choose_param(get_param(np, internal_np::vertex_point), get_property_map(vertex_point, pmesh)), + choose_parameter(get_parameter(np, internal_np::vertex_point), get_property_map(vertex_point, pmesh)), use_dt3, - choose_param(get_param(np, internal_np::geom_traits), typename GetGeomTraits::type())) + choose_parameter(get_parameter(np, internal_np::geom_traits), typename GetGeomTraits::type())) .first; } @@ -333,14 +333,14 @@ namespace Polygon_mesh_processing { OutputIterator out, const NamedParameters& np) { - using boost::choose_param; - using boost::get_param; + using parameters::choose_parameter; + using parameters::get_parameter; bool use_dt3 = #ifdef CGAL_HOLE_FILLING_DO_NOT_USE_DT3 false; #else - choose_param(get_param(np, internal_np::use_delaunay_triangulation), true); + choose_parameter(get_parameter(np, internal_np::use_delaunay_triangulation), true); #endif typedef CGAL::internal::Weight_min_max_dihedral_and_area Weight; @@ -360,7 +360,7 @@ namespace Polygon_mesh_processing { triangulate_hole_polyline(points, third_points, tracer, WC(), use_dt3, - choose_param(get_param(np, internal_np::geom_traits), + choose_parameter(get_parameter(np, internal_np::geom_traits), typename CGAL::Kernel_traits::Kernel())); CGAL_assertion(holes.empty()); diff --git a/Polygon_mesh_processing/test/Polygon_mesh_processing/test_orient_cc.cpp b/Polygon_mesh_processing/test/Polygon_mesh_processing/test_orient_cc.cpp index 78e66369cbb..0dddec56099 100644 --- a/Polygon_mesh_processing/test/Polygon_mesh_processing/test_orient_cc.cpp +++ b/Polygon_mesh_processing/test/Polygon_mesh_processing/test_orient_cc.cpp @@ -22,11 +22,14 @@ bool test_orientation(TriangleMesh& tm, bool is_positive, const NamedParameters& typedef typename CGAL::Polygon_mesh_processing::GetFaceIndexMap::const_type Fid_map; - Vpm vpm = boost::choose_param(get_param(np, CGAL::internal_np::vertex_point), - CGAL::get_const_property_map(boost::vertex_point, tm)); + using CGAL::parameters::choose_parameter; + using CGAL::parameters::get_parameter; + + Vpm vpm = choose_parameter(get_parameter(np, CGAL::internal_np::vertex_point), + CGAL::get_const_property_map(boost::vertex_point, tm)); - Fid_map fid_map = boost::choose_param(get_param(np, CGAL::internal_np::face_index), - CGAL::get_const_property_map(boost::face_index, tm)); + Fid_map fid_map = choose_parameter(get_parameter(np, CGAL::internal_np::face_index), + CGAL::get_const_property_map(boost::face_index, tm)); std::vector face_cc(num_faces(tm), std::size_t(-1)); diff --git a/Polyhedron/demo/Polyhedron/Plugins/PMP/Inside_out_plugin.cpp b/Polyhedron/demo/Polyhedron/Plugins/PMP/Inside_out_plugin.cpp index b1941923dff..9458f8c6cd6 100644 --- a/Polyhedron/demo/Polyhedron/Plugins/PMP/Inside_out_plugin.cpp +++ b/Polyhedron/demo/Polyhedron/Plugins/PMP/Inside_out_plugin.cpp @@ -120,9 +120,9 @@ void Polyhedron_demo_inside_out_plugin::on_actionOrientCC_triggered() SMesh* pMesh = sm_item->polyhedron(); if(pMesh){ if(is_closed(*pMesh)) - CGAL::Polygon_mesh_processing::orient_to_bound_a_volume(*pMesh, item==items.first()); + CGAL::Polygon_mesh_processing::orient_to_bound_a_volume(*pMesh); else - CGAL::Polygon_mesh_processing::orient(*pMesh, item==items.first()); + CGAL::Polygon_mesh_processing::orient(*pMesh); sm_item->invalidateOpenGLBuffers(); } } diff --git a/Polyhedron/demo/Polyhedron/include/Point_set_3.h b/Polyhedron/demo/Polyhedron/include/Point_set_3.h index b8aca00fc11..d00ee356b94 100644 --- a/Polyhedron/demo/Polyhedron/include/Point_set_3.h +++ b/Polyhedron/demo/Polyhedron/include/Point_set_3.h @@ -505,13 +505,13 @@ public: bool are_radii_uptodate() const { return m_radii_are_uptodate; } void set_radii_uptodate(bool /*on*/) { m_radii_are_uptodate = false; } - CGAL::cgal_bgl_named_params + CGAL::Named_function_parameters , CGAL::internal_np::normal_t, - CGAL::cgal_bgl_named_params + CGAL::Named_function_parameters , CGAL::internal_np::point_t> > > inline parameters() const @@ -598,13 +598,13 @@ namespace Point_set_processing_3 namespace parameters { template - cgal_bgl_named_params + Named_function_parameters ::template Property_map, internal_np::normal_t, - cgal_bgl_named_params + Named_function_parameters ::template Property_map, internal_np::point_t> > > inline all_default(const ::Point_set_3& ps) diff --git a/Polyhedron_IO/include/CGAL/IO/Polyhedron_iostream.h b/Polyhedron_IO/include/CGAL/IO/Polyhedron_iostream.h index e8173637eda..a0aad3117c6 100644 --- a/Polyhedron_IO/include/CGAL/IO/Polyhedron_iostream.h +++ b/Polyhedron_IO/include/CGAL/IO/Polyhedron_iostream.h @@ -29,7 +29,7 @@ #include #include #include -#include +#include #include namespace CGAL { @@ -41,11 +41,14 @@ template < class Traits, class HDS, class Alloc, class NamedParameters> bool write_off( std::ostream& out, const Polyhedron_3& P, const NamedParameters& np){ + using parameters::choose_parameter; + using parameters::get_parameter; + // writes P to `out' in PRETTY, ASCII or BINARY format // as the stream indicates. File_header_OFF header( is_binary( out), ! is_pretty( out), false); typename CGAL::Polygon_mesh_processing::GetVertexPointMap, NamedParameters>::const_type - vpm = choose_param(get_param(np, internal_np::vertex_point), + vpm = choose_parameter(get_parameter(np, internal_np::vertex_point), get_const_property_map(CGAL::vertex_point, P)); CGAL::print_polyhedron_with_header_OFF( out, P, header, vpm); return out.good(); @@ -70,11 +73,14 @@ read_off(std::istream& in, Polyhedron_3& P, NamedParameters np) { // reads a polyhedron from `in' and appends it to P. - typedef typename CGAL::Polygon_mesh_processing::GetVertexPointMap, NamedParameters>::type Vpm; - Vpm vpm = choose_param(get_param(np, internal_np::vertex_point), - get_property_map(CGAL::vertex_point, P)); + typedef typename CGAL::Polygon_mesh_processing::GetVertexPointMap, NamedParameters>::type Vpm; + using parameters::choose_parameter; + using parameters::get_parameter; + + Vpm vpm = choose_parameter(get_parameter(np, internal_np::vertex_point), + get_property_map(CGAL::vertex_point, P)); CGAL::scan_OFF( in, P); - if(!boost::is_default_param(get_param(np, internal_np::vertex_point))) + if(!parameters::is_default_parameter(get_parameter(np, internal_np::vertex_point))) { typedef typename boost::graph_traits >::vertex_descriptor Vertex; typename property_map_selector, boost::vertex_point_t>::type diff --git a/Polyhedron_IO/include/CGAL/IO/generic_print_polyhedron.h b/Polyhedron_IO/include/CGAL/IO/generic_print_polyhedron.h index eae9c811ca0..3eb28ea1a5a 100644 --- a/Polyhedron_IO/include/CGAL/IO/generic_print_polyhedron.h +++ b/Polyhedron_IO/include/CGAL/IO/generic_print_polyhedron.h @@ -24,7 +24,7 @@ #include -#include +#include #include #include #include diff --git a/Scripts/developer_scripts/update_to_CGAL_np.sh b/Scripts/developer_scripts/update_to_CGAL_np.sh new file mode 100644 index 00000000000..5e437b461e3 --- /dev/null +++ b/Scripts/developer_scripts/update_to_CGAL_np.sh @@ -0,0 +1,17 @@ +#!/bin/bash + +ack -l --cpp boost::lookup_named_param_def | xargs sed -i 's/boost::lookup_named_param_def/internal_np::Lookup_named_param_def/g' +ack -l --cpp boost::param_not_found | xargs sed -i 's/boost::param_not_found/internal_np::Param_not_found/g' +ack -l --cpp boost::is_default_param | xargs sed -i 's/boost::is_default_param/parameters::is_default_parameter/g' +ack -l --cpp boost::get_param | xargs sed -i 's/boost::get_param/parameters::get_parameter/g' +ack -l --cpp boost::choose_param | xargs sed -i 's/boost::choose_param/parameters::choose_parameter/g' +ack -l --cpp cgal_bgl_named_params | xargs sed -i 's/cgal_bgl_named_params/Named_function_parameters/g' + + +ack -l --cpp choose_param | xargs sed -i -E 's/choose_param[ ]*\(/choose_parameter(/g' +ack -l --cpp get_param | xargs sed -i -E 's/get_param[ ]*\(/get_parameter(/g' +ack -l --cpp is_default_param | xargs sed -i -E 's/is_default_param[ ]*\(/is_default_parameter(/g' + +ack vertex_index_t | grep get_param + +git checkout BGL/include/CGAL/boost/graph/dijkstra_shortest_paths.hpp diff --git a/Subdivision_method_3/include/CGAL/Subdivision_method_3/subdivision_hosts_3.h b/Subdivision_method_3/include/CGAL/Subdivision_method_3/subdivision_hosts_3.h index 014f8b472b7..9a70cccda33 100644 --- a/Subdivision_method_3/include/CGAL/Subdivision_method_3/subdivision_hosts_3.h +++ b/Subdivision_method_3/include/CGAL/Subdivision_method_3/subdivision_hosts_3.h @@ -31,7 +31,7 @@ #include -#include +#include #include #include @@ -84,14 +84,14 @@ void PQQ(PolygonMesh& pmesh, Mask mask, int step = 1) { template void PQQ(PolygonMesh& pmesh, Mask mask, const NamedParameters& np) { // todo: static assert that PolygonMesh == Mask::PolygonMesh - using boost::choose_param; - using boost::get_param; + using parameters::choose_parameter; + using parameters::get_parameter; typedef typename Polygon_mesh_processing::GetVertexPointMap::type Vpm; - Vpm vpm = choose_param(get_param(np, internal_np::vertex_point), + Vpm vpm = choose_parameter(get_parameter(np, internal_np::vertex_point), get_property_map(CGAL::vertex_point, pmesh)); - unsigned int step = choose_param(get_param(np, internal_np::number_of_iterations), 1); + unsigned int step = choose_parameter(get_parameter(np, internal_np::number_of_iterations), 1); for (unsigned int i = 0; i < step; i++) internal::PQQ_1step(pmesh, vpm, mask); } @@ -131,14 +131,14 @@ void PTQ(PolygonMesh& pmesh, Mask mask, int step = 1) { template void PTQ(PolygonMesh& pmesh, Mask mask, const NamedParameters& np) { // todo: static assert that PolygonMesh == Mask::PolygonMesh - using boost::choose_param; - using boost::get_param; + using parameters::choose_parameter; + using parameters::get_parameter; typedef typename Polygon_mesh_processing::GetVertexPointMap::type Vpm; - Vpm vpm = choose_param(get_param(np, internal_np::vertex_point), + Vpm vpm = choose_parameter(get_parameter(np, internal_np::vertex_point), get_property_map(CGAL::vertex_point, pmesh)); - unsigned int step = choose_param(get_param(np, internal_np::number_of_iterations), 1); + unsigned int step = choose_parameter(get_parameter(np, internal_np::number_of_iterations), 1); for (unsigned int i = 0; i < step; i++) internal::PTQ_1step(pmesh, vpm, mask); } @@ -181,14 +181,14 @@ void DQQ(PolygonMesh& pmesh, Mask mask, int step = 1) { template void DQQ(PolygonMesh& pmesh, Mask mask, const NamedParameters& np) { // todo: static assert that PolygonMesh == Mask::PolygonMesh - using boost::choose_param; - using boost::get_param; + using parameters::choose_parameter; + using parameters::get_parameter; typedef typename Polygon_mesh_processing::GetVertexPointMap::type Vpm; - Vpm vpm = choose_param(get_param(np, internal_np::vertex_point), + Vpm vpm = choose_parameter(get_parameter(np, internal_np::vertex_point), get_property_map(CGAL::vertex_point, pmesh)); - unsigned int step = choose_param(get_param(np, internal_np::number_of_iterations), 1); + unsigned int step = choose_parameter(get_parameter(np, internal_np::number_of_iterations), 1); for (unsigned int i = 0; i < step; i++) internal::DQQ_1step(pmesh, vpm, mask); } @@ -233,14 +233,14 @@ void Sqrt3(PolygonMesh& pmesh, Mask mask, int step = 1) { template void Sqrt3(PolygonMesh& pmesh, Mask mask, const NamedParameters& np) { // todo: static assert that PolygonMesh == Mask::PolygonMesh - using boost::choose_param; - using boost::get_param; + using parameters::choose_parameter; + using parameters::get_parameter; typedef typename Polygon_mesh_processing::GetVertexPointMap::type Vpm; - Vpm vpm = choose_param(get_param(np, internal_np::vertex_point), + Vpm vpm = choose_parameter(get_parameter(np, internal_np::vertex_point), get_property_map(CGAL::vertex_point, pmesh)); - unsigned int step = choose_param(get_param(np, internal_np::number_of_iterations), 1); + unsigned int step = choose_parameter(get_parameter(np, internal_np::number_of_iterations), 1); for (unsigned int i = 0; i < step; i++) internal::Sqrt3_1step(pmesh, vpm, mask, (i%2==1)); } diff --git a/Subdivision_method_3/include/CGAL/Subdivision_method_3/subdivision_methods_3.h b/Subdivision_method_3/include/CGAL/Subdivision_method_3/subdivision_methods_3.h index f8bb8d8a064..fcaea769ff2 100644 --- a/Subdivision_method_3/include/CGAL/Subdivision_method_3/subdivision_methods_3.h +++ b/Subdivision_method_3/include/CGAL/Subdivision_method_3/subdivision_methods_3.h @@ -29,7 +29,7 @@ #include -#include +#include #include #include @@ -128,13 +128,13 @@ void CatmullClark_subdivision(PolygonMesh& pmesh, int step) { **/ template void CatmullClark_subdivision(PolygonMesh& pmesh, const NamedParameters& np) { - using boost::choose_param; - using boost::get_param; + using parameters::choose_parameter; + using parameters::get_parameter; typedef typename Polygon_mesh_processing::GetVertexPointMap::type Vpm; - Vpm vpm = choose_param(get_param(np, internal_np::vertex_point), + Vpm vpm = choose_parameter(get_parameter(np, internal_np::vertex_point), get_property_map(CGAL::vertex_point, pmesh)); - unsigned int step = choose_param(get_param(np, internal_np::number_of_iterations), 1); + unsigned int step = choose_parameter(get_parameter(np, internal_np::number_of_iterations), 1); CatmullClark_mask_3 mask(&pmesh, vpm); for(unsigned int i = 0; i < step; i++) @@ -181,13 +181,13 @@ void Loop_subdivision(PolygonMesh& pmesh, int step) { **/ template void Loop_subdivision(PolygonMesh& pmesh, const NamedParameters& np) { - using boost::choose_param; - using boost::get_param; + using parameters::choose_parameter; + using parameters::get_parameter; typedef typename Polygon_mesh_processing::GetVertexPointMap::type Vpm; - Vpm vpm = choose_param(get_param(np, internal_np::vertex_point), + Vpm vpm = choose_parameter(get_parameter(np, internal_np::vertex_point), get_property_map(CGAL::vertex_point, pmesh)); - unsigned int step = choose_param(get_param(np, internal_np::number_of_iterations), 1); + unsigned int step = choose_parameter(get_parameter(np, internal_np::number_of_iterations), 1); Loop_mask_3 mask(&pmesh, vpm); for(unsigned int i = 0; i < step; i++) @@ -234,13 +234,13 @@ void DooSabin_subdivision(PolygonMesh& pmesh, int step) { **/ template void DooSabin_subdivision(PolygonMesh& pmesh, const NamedParameters& np) { - using boost::choose_param; - using boost::get_param; + using parameters::choose_parameter; + using parameters::get_parameter; typedef typename Polygon_mesh_processing::GetVertexPointMap::type Vpm; - Vpm vpm = choose_param(get_param(np, internal_np::vertex_point), + Vpm vpm = choose_parameter(get_parameter(np, internal_np::vertex_point), get_property_map(CGAL::vertex_point, pmesh)); - unsigned int step = choose_param(get_param(np, internal_np::number_of_iterations), 1); + unsigned int step = choose_parameter(get_parameter(np, internal_np::number_of_iterations), 1); DooSabin_mask_3 mask(&pmesh, vpm); for(unsigned int i = 0; i < step; i++) @@ -292,13 +292,13 @@ void Sqrt3_subdivision(PolygonMesh& pmesh, int step) { **/ template void Sqrt3_subdivision(PolygonMesh& pmesh, const NamedParameters& np) { - using boost::choose_param; - using boost::get_param; + using parameters::choose_parameter; + using parameters::get_parameter; typedef typename Polygon_mesh_processing::GetVertexPointMap::type Vpm; - Vpm vpm = choose_param(get_param(np, internal_np::vertex_point), + Vpm vpm = choose_parameter(get_parameter(np, internal_np::vertex_point), get_property_map(CGAL::vertex_point, pmesh)); - unsigned int step = choose_param(get_param(np, internal_np::number_of_iterations), 1); + unsigned int step = choose_parameter(get_parameter(np, internal_np::number_of_iterations), 1); Sqrt3_mask_3 mask(&pmesh, vpm); for(unsigned int i = 0; i < step; i++) diff --git a/Surface_mesh/include/CGAL/Surface_mesh/Surface_mesh.h b/Surface_mesh/include/CGAL/Surface_mesh/Surface_mesh.h index e6db9aa5255..b9e31616161 100644 --- a/Surface_mesh/include/CGAL/Surface_mesh/Surface_mesh.h +++ b/Surface_mesh/include/CGAL/Surface_mesh/Surface_mesh.h @@ -56,7 +56,7 @@ #include #include #include -#include +#include namespace CGAL { @@ -2110,13 +2110,16 @@ private: //------------------------------------------------------- private data bool has_fcolors; boost::tie(fcolors, has_fcolors) = sm.template property_map("f:color"); + using parameters::choose_parameter; + using parameters::get_parameter; + if(!has_fcolors && !has_vcolors) os << "OFF\n" << sm.number_of_vertices() << " " << sm.number_of_faces() << " 0\n"; else os << "COFF\n" << sm.number_of_vertices() << " " << sm.number_of_faces() << " 0\n"; std::vector reindex; typename Polygon_mesh_processing::GetVertexPointMap, NamedParameters>::const_type - vpm = choose_param(get_param(np, internal_np::vertex_point), + vpm = choose_parameter(get_parameter(np, internal_np::vertex_point), get_const_property_map(CGAL::vertex_point, sm)); reindex.resize(sm.num_vertices()); int n = 0; @@ -2201,8 +2204,11 @@ private: //------------------------------------------------------- private data typedef typename Mesh::Face_index Face_index; typedef typename Mesh::Vertex_index Vertex_index; typedef typename Mesh::size_type size_type; + using parameters::choose_parameter; + using parameters::get_parameter; + typename CGAL::Polygon_mesh_processing::GetVertexPointMap, NamedParameters>::type - vpm = choose_param(get_param(np, CGAL::internal_np::vertex_point), + vpm = choose_parameter(get_parameter(np, CGAL::internal_np::vertex_point), get_property_map(CGAL::vertex_point, sm)); int n, f, e; std::string off; diff --git a/Surface_mesh/include/CGAL/boost/graph/graph_traits_Surface_mesh.h b/Surface_mesh/include/CGAL/boost/graph/graph_traits_Surface_mesh.h index f42cd99887e..34d6fdeaeca 100644 --- a/Surface_mesh/include/CGAL/boost/graph/graph_traits_Surface_mesh.h +++ b/Surface_mesh/include/CGAL/boost/graph/graph_traits_Surface_mesh.h @@ -26,7 +26,7 @@ #include // include this to avoid a VC15 warning -#include +#include #include #include diff --git a/Surface_mesh_segmentation/include/CGAL/internal/Surface_mesh_segmentation/Alpha_expansion_graph_cut.h b/Surface_mesh_segmentation/include/CGAL/internal/Surface_mesh_segmentation/Alpha_expansion_graph_cut.h index 17b8a2c53c8..bda22c32d48 100644 --- a/Surface_mesh_segmentation/include/CGAL/internal/Surface_mesh_segmentation/Alpha_expansion_graph_cut.h +++ b/Surface_mesh_segmentation/include/CGAL/internal/Surface_mesh_segmentation/Alpha_expansion_graph_cut.h @@ -47,7 +47,7 @@ #endif #include -#include +#include #include #ifdef CGAL_DO_NOT_USE_BOYKOV_KOLMOGOROV_MAXFLOW_SOFTWARE diff --git a/Surface_mesh_simplification/include/CGAL/Surface_mesh_simplification/edge_collapse.h b/Surface_mesh_simplification/include/CGAL/Surface_mesh_simplification/edge_collapse.h index 09db7ab2890..a84aa262923 100644 --- a/Surface_mesh_simplification/include/CGAL/Surface_mesh_simplification/edge_collapse.h +++ b/Surface_mesh_simplification/include/CGAL/Surface_mesh_simplification/edge_collapse.h @@ -24,7 +24,7 @@ #include -#include +#include #include #include @@ -102,12 +102,11 @@ struct Dummy_visitor template int edge_collapse ( TM& aSurface , ShouldStop const& aShould_stop - , cgal_bgl_named_params const& aParams + , Named_function_parameters const& aParams ) { - using boost::choose_param ; - using boost::choose_const_pmap ; - using boost::get_param ; + using parameters::choose_parameter; + using parameters::get_parameter; LindstromTurk_params lPolicyParams ; @@ -115,25 +114,24 @@ int edge_collapse ( TM& aSurface return edge_collapse(aSurface ,aShould_stop - ,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()) - ,choose_param (get_param(aParams,internal_np::get_cost_policy), LindstromTurk_cost()) - ,choose_param (get_param(aParams,internal_np::get_placement_policy), LindstromTurk_placement()) - ,choose_param (get_param(aParams,vis), Dummy_visitor()) + ,choose_parameter(get_parameter(aParams,internal_np::vertex_index), get_const_property_map(boost::vertex_index, aSurface)) + ,choose_parameter(get_parameter(aParams,internal_np::vertex_point),get_property_map(vertex_point, aSurface)) + ,choose_parameter(get_parameter(aParams,internal_np::halfedge_index),get_const_property_map(boost::halfedge_index, aSurface)) + ,choose_parameter(get_parameter(aParams,internal_np::edge_is_constrained),No_constrained_edge_map()) + ,choose_parameter(get_parameter(aParams,internal_np::get_cost_policy), LindstromTurk_cost()) + ,choose_parameter(get_parameter(aParams,internal_np::get_placement_policy), LindstromTurk_placement()) + ,choose_parameter(get_parameter(aParams,vis), Dummy_visitor()) ); } template int edge_collapse ( TM& aSurface , ShouldStop const& aShould_stop - , cgal_bgl_named_params const& aParams + , Named_function_parameters const& aParams ) { - using boost::choose_param ; - using boost::choose_const_pmap ; - using boost::get_param ; + using parameters::choose_parameter; + using parameters::get_parameter; LindstromTurk_params lPolicyParams ; @@ -141,13 +139,13 @@ int edge_collapse ( TM& aSurface return edge_collapse(aSurface ,aShould_stop - ,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()) - ,choose_param (get_param(aParams,internal_np::get_cost_policy), LindstromTurk_cost()) - ,choose_param (get_param(aParams,internal_np::get_placement_policy), LindstromTurk_placement()) - ,choose_param (get_param(aParams,vis), Dummy_visitor()) + ,choose_parameter(get_parameter(aParams,internal_np::vertex_index), get_const_property_map(boost::vertex_index, aSurface)) + ,choose_parameter(get_parameter(aParams,internal_np::vertex_point),get_property_map(vertex_point, aSurface)) + ,choose_parameter(get_parameter(aParams,internal_np::halfedge_index),get_const_property_map(boost::halfedge_index, aSurface)) + ,choose_parameter(get_parameter(aParams,internal_np::edge_is_constrained),No_constrained_edge_map()) + ,choose_parameter(get_parameter(aParams,internal_np::get_cost_policy), LindstromTurk_cost()) + ,choose_parameter(get_parameter(aParams,internal_np::get_placement_policy), LindstromTurk_placement()) + ,choose_parameter(get_parameter(aParams,vis), Dummy_visitor()) ); } diff --git a/Triangulation_2/include/CGAL/boost/graph/graph_traits_Constrained_Delaunay_triangulation_2.h b/Triangulation_2/include/CGAL/boost/graph/graph_traits_Constrained_Delaunay_triangulation_2.h index 9c9180d3135..af848b05868 100644 --- a/Triangulation_2/include/CGAL/boost/graph/graph_traits_Constrained_Delaunay_triangulation_2.h +++ b/Triangulation_2/include/CGAL/boost/graph/graph_traits_Constrained_Delaunay_triangulation_2.h @@ -22,7 +22,7 @@ #define CGAL_GRAPH_TRAITS_CONSTRAINED_DELAUNAY_TRIANGULATION_2_H // include this to avoid a VC15 warning -#include +#include #include #include diff --git a/Triangulation_2/include/CGAL/boost/graph/graph_traits_Constrained_triangulation_2.h b/Triangulation_2/include/CGAL/boost/graph/graph_traits_Constrained_triangulation_2.h index f235ef1e975..71c2595be71 100644 --- a/Triangulation_2/include/CGAL/boost/graph/graph_traits_Constrained_triangulation_2.h +++ b/Triangulation_2/include/CGAL/boost/graph/graph_traits_Constrained_triangulation_2.h @@ -22,7 +22,7 @@ #define CGAL_GRAPH_TRAITS_CONSTRAINED_TRIANGULATION_2_H // include this to avoid a VC15 warning -#include +#include #include #include diff --git a/Triangulation_2/include/CGAL/boost/graph/graph_traits_Constrained_triangulation_plus_2.h b/Triangulation_2/include/CGAL/boost/graph/graph_traits_Constrained_triangulation_plus_2.h index 5d35c80e748..86830b254e4 100644 --- a/Triangulation_2/include/CGAL/boost/graph/graph_traits_Constrained_triangulation_plus_2.h +++ b/Triangulation_2/include/CGAL/boost/graph/graph_traits_Constrained_triangulation_plus_2.h @@ -22,7 +22,7 @@ #define CGAL_GRAPH_TRAITS_CONSTRAINED_TRIANGULATION_PLUS_2_H // include this to avoid a VC15 warning -#include +#include #include #include diff --git a/Triangulation_2/include/CGAL/boost/graph/graph_traits_Delaunay_triangulation_2.h b/Triangulation_2/include/CGAL/boost/graph/graph_traits_Delaunay_triangulation_2.h index 4ce347b7e6f..868b4c365db 100644 --- a/Triangulation_2/include/CGAL/boost/graph/graph_traits_Delaunay_triangulation_2.h +++ b/Triangulation_2/include/CGAL/boost/graph/graph_traits_Delaunay_triangulation_2.h @@ -22,7 +22,7 @@ #define CGAL_GRAPH_TRAITS_DELAUNAY_TRIANGULATION_2_H // include this to avoid a VC15 warning -#include +#include #include #include diff --git a/Triangulation_2/include/CGAL/boost/graph/graph_traits_Regular_triangulation_2.h b/Triangulation_2/include/CGAL/boost/graph/graph_traits_Regular_triangulation_2.h index 6c5fc6c41c6..e2900ca5d3d 100644 --- a/Triangulation_2/include/CGAL/boost/graph/graph_traits_Regular_triangulation_2.h +++ b/Triangulation_2/include/CGAL/boost/graph/graph_traits_Regular_triangulation_2.h @@ -22,7 +22,7 @@ #define CGAL_GRAPH_TRAITS_REGULAR_TRIANGULATION_2_H // include this to avoid a VC15 warning -#include +#include #include #include diff --git a/Triangulation_2/include/CGAL/boost/graph/graph_traits_Triangulation_2.h b/Triangulation_2/include/CGAL/boost/graph/graph_traits_Triangulation_2.h index 0a901850a6d..9d5685647e0 100644 --- a/Triangulation_2/include/CGAL/boost/graph/graph_traits_Triangulation_2.h +++ b/Triangulation_2/include/CGAL/boost/graph/graph_traits_Triangulation_2.h @@ -24,7 +24,7 @@ #include // include this to avoid a VC15 warning -#include +#include #include #include #include diff --git a/Triangulation_2/include/CGAL/boost/graph/graph_traits_Triangulation_data_structure_2.h b/Triangulation_2/include/CGAL/boost/graph/graph_traits_Triangulation_data_structure_2.h index 4a79b2f69ef..fee7dcc69b2 100644 --- a/Triangulation_2/include/CGAL/boost/graph/graph_traits_Triangulation_data_structure_2.h +++ b/Triangulation_2/include/CGAL/boost/graph/graph_traits_Triangulation_data_structure_2.h @@ -24,7 +24,7 @@ #include // include this to avoid a VC15 warning -#include +#include #include #include diff --git a/Triangulation_2/include/CGAL/boost/graph/graph_traits_Triangulation_hierarchy_2.h b/Triangulation_2/include/CGAL/boost/graph/graph_traits_Triangulation_hierarchy_2.h index dd24d64a7ae..615b81d3640 100644 --- a/Triangulation_2/include/CGAL/boost/graph/graph_traits_Triangulation_hierarchy_2.h +++ b/Triangulation_2/include/CGAL/boost/graph/graph_traits_Triangulation_hierarchy_2.h @@ -22,7 +22,7 @@ #define CGAL_GRAPH_TRAITS_TRIANGULATION_HIERARCHY_2_H // include this to avoid a VC15 warning -#include +#include #include #include
" ALIASES += "cgalNPEnd=