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 6f0e29428a1..32ed33ee965 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 @@ -146,9 +146,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); } @@ -201,9 +201,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); } @@ -246,9 +246,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 16b3a781025..84342845638 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 b63586b3bcb..c00cb0587dc 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 9a2cb628825..4ee5d2041b0 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 ade5d54f684..b3a78b93cd0 100644 --- a/BGL/include/CGAL/boost/graph/io.h +++ b/BGL/include/CGAL/boost/graph/io.h @@ -32,7 +32,7 @@ #include #include #include -#include +#include #include namespace CGAL { @@ -54,10 +54,13 @@ bool write_wrl(std::ostream& os, typedef typename boost::graph_traits::vertex_descriptor vertex_descriptor; typedef typename boost::graph_traits::face_descriptor face_descriptor; typedef typename boost::graph_traits::vertices_size_type vertices_size_type; + + using parameters::get_parameter; + using parameters::choose_parameter; typename Polygon_mesh_processing::GetVertexPointMap::const_type - vpm = choose_param(get_param(np, internal_np::vertex_point), - get_const_property_map(CGAL::vertex_point, g)); + vpm = choose_parameter(get_parameter(np, internal_np::vertex_point), + get_const_property_map(CGAL::vertex_point, g)); boost::container::flat_map reindex; int n = 0; @@ -142,9 +145,12 @@ 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), - get_const_property_map(CGAL::vertex_point, g)); + vpm = choose_parameter(get_parameter(np, internal_np::vertex_point), + get_const_property_map(CGAL::vertex_point, g)); 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)); @@ -258,6 +264,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; @@ -266,8 +274,8 @@ 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), - get_property_map(CGAL::vertex_point, g)); + 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; int ignore; @@ -369,8 +377,11 @@ 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), - get_const_property_map(CGAL::vertex_point, g)); + 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"; boost::container::flat_map reindex; @@ -416,8 +427,10 @@ write_polys(std::ostream& os, typedef typename boost::graph_traits::vertex_descriptor vertex_descriptor; typedef typename boost::graph_traits::face_iterator face_iterator; typedef typename CGAL::Polygon_mesh_processing::GetVertexIndexMap::type Vimap; - Vimap V = choose_param(get_param(np, CGAL::internal_np::vertex_index), - get_const_property_map(CGAL::internal_np::vertex_index, mesh)); + using parameters::get_parameter; + using parameters::choose_parameter; + Vimap V = choose_parameter(get_parameter(np, internal_np::vertex_index), + get_const_property_map(boost::vertex_index, mesh)); std::vector connectivity_table; std::vector offsets; @@ -451,8 +464,10 @@ write_polys_tag(std::ostream& os, typedef typename boost::graph_traits::vertex_descriptor vertex_descriptor; typedef typename boost::graph_traits::face_iterator face_iterator; typedef typename CGAL::Polygon_mesh_processing::GetVertexIndexMap::type Vimap; - Vimap V = choose_param(get_param(np, CGAL::internal_np::vertex_index), - get_const_property_map(CGAL::internal_np::vertex_index, mesh)); + using parameters::get_parameter; + using parameters::choose_parameter; + Vimap V = choose_parameter(get_parameter(np, internal_np::vertex_index), + get_const_property_map(boost::vertex_index, mesh)); std::string formatattribute = binary ? " format=\"appended\"" : " format=\"ascii\""; @@ -540,8 +555,10 @@ write_points_tag(std::ostream& os, { typedef typename boost::graph_traits::vertex_iterator vertex_iterator; typedef typename CGAL::Polygon_mesh_processing::GetVertexPointMap::const_type Vpmap; - Vpmap vpm = choose_param(get_param(np, CGAL::vertex_point), - get_const_property_map(CGAL::vertex_point, mesh)); + using parameters::get_parameter; + using parameters::choose_parameter; + Vpmap vpm = choose_parameter(get_parameter(np, internal_np::vertex_point), + get_const_property_map(CGAL::vertex_point, mesh)); typedef typename boost::property_traits::value_type Point_t; typedef typename CGAL::Kernel_traits::Kernel Gt; typedef typename Gt::FT FT; @@ -583,8 +600,10 @@ write_polys_points(std::ostream& os, { typedef typename boost::graph_traits::vertex_iterator vertex_iterator; typedef typename CGAL::Polygon_mesh_processing::GetVertexPointMap::const_type Vpmap; - Vpmap vpm = choose_param(get_param(np, CGAL::vertex_point), - get_const_property_map(CGAL::vertex_point, mesh)); + using parameters::get_parameter; + using parameters::choose_parameter; + Vpmap vpm = choose_parameter(get_parameter(np, internal_np::vertex_point), + get_const_property_map(CGAL::vertex_point, mesh)); typedef typename boost::property_traits::value_type Point_t; typedef typename CGAL::Kernel_traits::Kernel Gt; typedef typename Gt::FT FT; @@ -653,7 +672,7 @@ void write_vtp(std::ostream& os, os << " \n"; std::size_t offset = 0; - const bool binary = boost::choose_param(boost::get_param(np, internal_np::use_binary_mode), true); + const bool binary = parameters::choose_parameter(parameters::get_parameter(np, internal_np::use_binary_mode), true); internal::write_vtp::write_points_tag(os,mesh,binary,offset, np); internal::write_vtp::write_polys_tag(os,mesh,binary,offset, np); os << " \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..bf8c2c606da 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 @@ -331,7 +331,7 @@ namespace CGAL { >::Kernel Default_kernel; public: - typedef typename boost::lookup_named_param_def < + typedef typename internal_np::Lookup_named_param_def < internal_np::geom_traits_t, NamedParameters, Default_kernel @@ -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 @@ -421,7 +421,7 @@ namespace CGAL { public: typedef DummyConstrainedMap NoMap; - typedef typename boost::lookup_named_param_def < + typedef typename internal_np::Lookup_named_param_def < internal_np::point_is_constrained_t, NamedParameters, DummyConstrainedMap //default @@ -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 06d61f79dfa..e3c4f7dbe08 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 92ca95d58a3..70b757b4af0 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,181 +22,177 @@ 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_param(np, CGAL::internal_np::face_size_map).v == 52); - assert(get_param(np, CGAL::internal_np::snapping_tolerance).v == 57); - assert(get_param(np, CGAL::internal_np::use_angle_smoothing).v == 53); - assert(get_param(np, CGAL::internal_np::use_area_smoothing).v == 54); - assert(get_param(np, CGAL::internal_np::use_Delaunay_flips).v == 55); - assert(get_param(np, CGAL::internal_np::use_safety_constraints).v == 56); + 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); + assert(get_parameter(np, CGAL::internal_np::face_size_map).v == 52); + assert(get_parameter(np, CGAL::internal_np::snapping_tolerance).v == 57); + assert(get_parameter(np, CGAL::internal_np::use_angle_smoothing).v == 53); + assert(get_parameter(np, CGAL::internal_np::use_area_smoothing).v == 54); + assert(get_parameter(np, CGAL::internal_np::use_Delaunay_flips).v == 55); + assert(get_parameter(np, CGAL::internal_np::use_safety_constraints).v == 56); // 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<52>(get_param(np, CGAL::internal_np::face_size_map)); - check_same_type<57>(get_param(np, CGAL::internal_np::snapping_tolerance)); - check_same_type<53>(get_param(np, CGAL::internal_np::use_angle_smoothing)); - check_same_type<54>(get_param(np, CGAL::internal_np::use_area_smoothing)); - check_same_type<55>(get_param(np, CGAL::internal_np::use_Delaunay_flips)); - check_same_type<56>(get_param(np, CGAL::internal_np::use_safety_constraints)); + 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)); + check_same_type<52>(get_parameter(np, CGAL::internal_np::face_size_map)); + check_same_type<57>(get_parameter(np, CGAL::internal_np::snapping_tolerance)); + check_same_type<53>(get_parameter(np, CGAL::internal_np::use_angle_smoothing)); + check_same_type<54>(get_parameter(np, CGAL::internal_np::use_area_smoothing)); + check_same_type<55>(get_parameter(np, CGAL::internal_np::use_Delaunay_flips)); + check_same_type<56>(get_parameter(np, CGAL::internal_np::use_safety_constraints)); // 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 3d0f73ce92c..60e0ff9b73e 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 @@ -1303,13 +1303,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 deac58ea8be..cba7e7001e6 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 @@ -32,7 +32,7 @@ #include #include -#include +#include #include #include @@ -465,12 +465,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 f993f17a766..8af714c1f77 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 @@ -34,7 +34,7 @@ #include #include -#include +#include #include #include @@ -241,7 +241,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; @@ -252,8 +253,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 8f32bb552cf..1a4bcbaf9fb 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 @@ -282,10 +282,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 d8558d10b7a..bb2221a0c8f 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 @@ -32,7 +32,7 @@ #include #include -#include +#include #include #include @@ -189,7 +189,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; @@ -198,8 +199,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 f8900c62967..4c1126cd1f5 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 @@ -34,7 +34,7 @@ #include #include -#include +#include #include #include @@ -404,7 +404,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; @@ -419,9 +420,9 @@ 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 std::function& callback = choose_param(get_param(np, internal_np::callback), - std::function()); + double sharpness_angle = choose_parameter(get_parameter(np, internal_np::sharpness_angle), 30.); + const std::function& callback = choose_parameter(get_parameter(np, internal_np::callback), + std::function()); CGAL_point_set_processing_precondition(points.begin() != points.end()); CGAL_point_set_processing_precondition(k > 1); @@ -433,9 +434,9 @@ 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()); - FT neighbor_radius = choose_param(get_param(np, internal_np::neighbor_radius), FT(0)); + 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()); + FT neighbor_radius = choose_parameter(get_parameter(np, internal_np::neighbor_radius), FT(0)); // 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 c89455efd23..3815053df8b 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,29 +189,30 @@ 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 std::function& callback = choose_param(get_param(np, internal_np::callback), - std::function()); + PointMap point_map = choose_parameter(get_parameter(np, internal_np::point_map), PointMap()); + const std::function& callback = choose_parameter(get_parameter(np, internal_np::callback), + std::function()); // types for K nearest neighbors search structure typedef typename Kernel::FT FT; 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 c76178a201a..64a473b51a5 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 b85806f5c83..d34a68673b4 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 a3a38098913..307cd3110fd 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 @@ -32,7 +32,7 @@ #include #include -#include +#include #include #include @@ -208,12 +208,13 @@ 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 std::function& callback = choose_param(get_param(np, internal_np::callback), - std::function()); + PointMap point_map = choose_parameter(get_parameter(np, internal_np::point_map), PointMap()); + const std::function& callback = choose_parameter(get_parameter(np, internal_np::callback), + std::function()); // actual type of input points typedef typename std::iterator_traits::value_type Enriched_point; 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 a2390db0eed..b8a30081217 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,11 +173,11 @@ 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 std::function& callback = choose_param(get_param(np, internal_np::callback), - std::function()); + 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 std::function& callback = choose_parameter(get_parameter(np, internal_np::callback), + std::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 e1796be667a..13dffd49ef6 100644 --- a/Point_set_processing_3/include/CGAL/jet_estimate_normals.h +++ b/Point_set_processing_3/include/CGAL/jet_estimate_normals.h @@ -35,7 +35,7 @@ #include #include -#include +#include #include #include @@ -206,7 +206,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"); @@ -224,10 +225,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); - FT neighbor_radius = choose_param(get_param(np, internal_np::neighbor_radius), FT(0)); + 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); + FT neighbor_radius = choose_parameter(get_parameter(np, internal_np::neighbor_radius), FT(0)); const std::function& callback = choose_param(get_param(np, internal_np::callback), std::function()); 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 b8918df0eb0..7e57f4d664a 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 @@ -34,7 +34,7 @@ #include #include -#include +#include #include #include @@ -210,7 +210,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; @@ -221,12 +222,12 @@ 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()); - typename Kernel::FT neighbor_radius = choose_param(get_param(np, internal_np::neighbor_radius), - typename Kernel::FT(0)); - 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 std::function& callback = choose_param(get_param(np, internal_np::callback), + PointMap point_map = choose_parameter(get_parameter(np, internal_np::point_map), PointMap()); + typename Kernel::FT neighbor_radius = choose_parameter(get_parameter(np, internal_np::neighbor_radius), + typename Kernel::FT(0)); + 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 std::function& callback = choose_parameter(get_parameter(np, internal_np::callback), std::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 2db5da5d3d8..eea4681cf55 100644 --- a/Point_set_processing_3/include/CGAL/mst_orient_normals.h +++ b/Point_set_processing_3/include/CGAL/mst_orient_normals.h @@ -36,7 +36,7 @@ #include #include -#include +#include #include #include @@ -613,7 +613,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; @@ -625,8 +627,8 @@ 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()); + 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()); typename Kernel::FT neighbor_radius = choose_param(get_param(np, internal_np::neighbor_radius), typename Kernel::FT(0)); ConstrainedMap constrained_map = choose_param(get_param(np, internal_np::point_is_constrained), ConstrainedMap()); 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 54f110c236d..90a0574a88f 100644 --- a/Point_set_processing_3/include/CGAL/pca_estimate_normals.h +++ b/Point_set_processing_3/include/CGAL/pca_estimate_normals.h @@ -36,7 +36,7 @@ #include #include -#include +#include #include #include @@ -195,7 +195,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 @@ -208,11 +210,11 @@ 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()); - FT neighbor_radius = choose_param(get_param(np, internal_np::neighbor_radius), FT(0)); - const std::function& callback = choose_param(get_param(np, internal_np::callback), - std::function()); + 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()); + FT neighbor_radius = choose_parameter(get_parameter(np, internal_np::neighbor_radius), FT(0)); + const std::function& callback = choose_parameter(get_parameter(np, internal_np::callback), + std::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 63b8cc9702f..b694416e821 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 6cb08460c27..e08f50dfca6 100644 --- a/Point_set_processing_3/include/CGAL/remove_outliers.h +++ b/Point_set_processing_3/include/CGAL/remove_outliers.h @@ -32,7 +32,7 @@ #include #include -#include +#include #include #include @@ -153,17 +153,18 @@ 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()); - typename Kernel::FT neighbor_radius = choose_param(get_param(np, internal_np::neighbor_radius), - typename Kernel::FT(0)); - 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.); + PointMap point_map = choose_parameter(get_parameter(np, internal_np::point_map), PointMap()); + typename Kernel::FT neighbor_radius = choose_parameter(get_parameter(np, internal_np::neighbor_radius), + typename Kernel::FT(0)); + 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 std::function& callback = choose_param(get_param(np, internal_np::callback), std::function()); 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 c57b0b110cd..b5623b20992 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 @@ -211,7 +211,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; @@ -226,11 +227,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()); @@ -1529,7 +1530,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 6e41c9b591d..63dd6881161 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 @@ -323,7 +325,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; @@ -334,8 +338,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 std::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 9ed0706f207..866cdadd44f 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,19 +470,20 @@ 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 std::function& callback = choose_param(get_param(np, internal_np::callback), - std::function()); + 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 std::function& callback = choose_parameter(get_parameter(np, internal_np::callback), + std::function()); typedef typename Kernel::Point_3 Point; typedef typename Kernel::FT FT; 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 2018e9b81ad..678703009ec 100644 --- a/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/bbox.h +++ b/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/bbox.h @@ -65,14 +65,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; @@ -115,14 +115,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) ); @@ -158,14 +158,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)) ) + @@ -202,14 +202,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 165316ecf5a..ec6bf344009 100644 --- a/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/border.h +++ b/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/border.h @@ -199,8 +199,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 b5534260247..1a85761f3f8 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); + parameters::choose_parameter(parameters::get_parameter(np_tm, internal_np::clip_volume), false); if (clip_volume && is_closed(tm)) return corefine_and_compute_intersection(tm, clipper, tm, np_tm, np_c); 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 a0039b0273b..51f780c9fab 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; @@ -234,18 +234,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 @@ -132,16 +132,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; @@ -212,16 +212,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; @@ -233,7 +233,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, @@ -304,13 +304,13 @@ 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), - get_property_map(boost::face_index, pmesh)); + FaceIndexMap fimap = choose_parameter(get_parameter(np, internal_np::face_index), + get_property_map(boost::face_index, pmesh)); // FaceSizeMap typedef typename boost::lookup_named_param_def::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), - get_property_map(boost::face_index, pmesh)); + FaceIndexMap fim = choose_parameter(get_parameter(np, internal_np::face_index), + get_property_map(boost::face_index, pmesh)); typedef typename boost::lookup_named_param_def::face_descriptor face_descriptor; typedef typename boost::graph_traits::face_iterator face_iterator; @@ -490,7 +490,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; @@ -727,12 +727,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 @@ -785,12 +785,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 97491b151a9..542b9f535ae 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,14 +249,14 @@ 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(std::get(nps_out), internal_np::edge_is_constrained), \ - Corefinement::No_mark() ); + internal_np::choose_parameter( internal_np::get_parameter(std::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 @@ -564,7 +564,7 @@ corefine_and_compute_boolean_operations( vpm_out_tuple, ecms_out, uv, output); // special case used for clipping open meshes - if ( boost::choose_param( boost::get_param(np1, internal_np::use_bool_op_to_clip_surface), + if ( parameters::choose_parameter( parameters::get_parameter(np1, internal_np::use_bool_op_to_clip_surface), false) ) { CGAL_assertion(output[Corefinement::INTERSECTION] != boost::none); @@ -572,7 +572,7 @@ corefine_and_compute_boolean_operations( CGAL_assertion(output[Corefinement::TM1_MINUS_TM2] == boost::none); CGAL_assertion(output[Corefinement::TM2_MINUS_TM1] == boost::none); const bool use_compact_clipper = - boost::choose_param( boost::get_param(np1, internal_np::use_compact_clipper), + parameters::choose_parameter( parameters::get_parameter(np1, internal_np::use_compact_clipper), true); ob.setup_for_clipping_a_surface(use_compact_clipper); } @@ -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 fde41825686..371f21a5f97 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 944fe523fb3..c89e341c604 100644 --- a/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/distance.h +++ b/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/distance.h @@ -340,32 +340,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) @@ -380,7 +380,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 @@ -407,9 +407,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.) ) @@ -488,7 +488,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) { @@ -504,7 +504,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) { @@ -630,7 +630,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))); } @@ -687,7 +687,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))); } @@ -734,8 +734,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 2cd10bfebc5..400f265c4e2 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 8ca1c6649b0..9bc75a85b0c 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 e2e70c66398..003e51180bd 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 @@ -1059,7 +1059,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 4029676a33c..2030a836fc2 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::halfedge_descriptor h, const PolygonMesh& pmesh, const NamedParameters& np) { - using boost::choose_param; - using boost::get_param; + using internal_np::choose_parameter; + using internal_np::get_parameter; typename GetVertexPointMap::const_type - vpm = choose_param(get_param(np, internal_np::vertex_point), - get_const_property_map(CGAL::vertex_point, pmesh)); + 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)), get(vpm, target(h, pmesh)))); @@ -321,16 +321,16 @@ face_area(typename boost::graph_traits::face_descriptor f, const TriangleMesh& tmesh, const CGAL_PMP_NP_CLASS& np) { - using boost::choose_param; - using boost::get_param; + using internal_np::choose_parameter; + using internal_np::get_parameter; typedef typename boost::graph_traits::halfedge_descriptor halfedge_descriptor; CGAL_precondition(boost::graph_traits::null_face() != f); typename GetVertexPointMap::const_type - vpm = choose_param(get_param(np, internal_np::vertex_point), - get_const_property_map(CGAL::vertex_point, tmesh)); + vpm = choose_parameter(get_parameter(np, internal_np::vertex_point), + get_const_property_map(CGAL::vertex_point, tmesh)); halfedge_descriptor hd = halfedge(f, tmesh); halfedge_descriptor nhd = next(hd, tmesh); @@ -504,11 +504,11 @@ volume(const TriangleMesh& tmesh, 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/merge_border_vertices.h b/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/merge_border_vertices.h index a37799e7c63..55d1a8a65d6 100644 --- a/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/merge_border_vertices.h +++ b/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/merge_border_vertices.h @@ -218,8 +218,11 @@ void merge_duplicated_vertices_in_boundary_cycle( typedef typename boost::graph_traits::halfedge_descriptor halfedge_descriptor; typedef typename GetVertexPointMap::const_type Vpm; - Vpm vpm = choose_param(get_param(np, internal_np::vertex_point), - get_const_property_map(vertex_point, pm)); + using parameters::get_parameter; + using parameters::choose_parameter; + + Vpm vpm = choose_parameter(get_parameter(np, internal_np::vertex_point), + get_const_property_map(vertex_point, pm)); // collect all the halfedges of the cycle std::vector< std::pair > cycle_hedges; 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 1728e1d45ca..f13fdb9bbc5 100644 --- a/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/orientation.h +++ b/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/orientation.h @@ -69,18 +69,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; @@ -182,16 +182,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); @@ -482,16 +482,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)); @@ -589,16 +589,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 df007a02c8d..cc66bccf967 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 @@ -150,8 +150,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; @@ -164,22 +164,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..62479ad4912 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()); + 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, 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()); + 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, 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 3418e8d8bd1..8a243201420 100644 --- a/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/repair.h +++ b/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/repair.h @@ -581,8 +581,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; @@ -592,7 +592,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; @@ -1109,8 +1109,8 @@ bool remove_degenerate_faces(const FaceRange& face_range, { 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; @@ -1120,10 +1120,10 @@ bool remove_degenerate_faces(const FaceRange& face_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; - 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; @@ -2078,18 +2078,18 @@ std::size_t make_umbrella_manifold(typename boost::graph_traits::ha typedef typename boost::graph_traits::vertex_descriptor vertex_descriptor; typedef typename boost::graph_traits::halfedge_descriptor halfedge_descriptor; - using boost::get_param; - using boost::choose_param; + using parameters::get_parameter; + using parameters::choose_parameter; typedef typename GetVertexPointMap::type VertexPointMap; - VertexPointMap vpm = choose_param(get_param(np, internal_np::vertex_point), + VertexPointMap vpm = choose_parameter(get_parameter(np, internal_np::vertex_point), get_property_map(vertex_point, pm)); - typedef typename boost::lookup_named_param_def // default (no constraint pmap) >::type VerticesMap; - VerticesMap cmap = choose_param(get_param(np, internal_np::vertex_is_constrained), + VerticesMap cmap = choose_parameter(get_parameter(np, internal_np::vertex_is_constrained), Constant_property_map(false)); std::size_t nb_new_vertices = 0; @@ -2881,12 +2881,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/repair_polygon_soup.h b/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/repair_polygon_soup.h index a36a29733ba..0b3de74bd38 100644 --- a/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/repair_polygon_soup.h +++ b/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/repair_polygon_soup.h @@ -23,7 +23,7 @@ #include -#include +#include #include #include @@ -70,7 +70,7 @@ struct Polygon_types template struct GetPolygonGeomTraits { - typedef typename boost::lookup_named_param_def < + typedef typename internal_np::Lookup_named_param_def < internal_np::geom_traits_t, NamedParameters, typename CGAL::Kernel_traits< @@ -518,11 +518,11 @@ std::size_t merge_duplicate_points_in_polygon_soup(PointRange& points, typedef typename internal::Polygon_types::Point_3 Point_3; typedef typename internal::Polygon_types::Polygon_3 Polygon_3; - using boost::get_param; - using boost::choose_param; + using parameters::get_parameter; + using parameters::choose_parameter; typedef typename internal::GetPolygonGeomTraits::type Traits; - Traits traits = choose_param(get_param(np, internal_np::geom_traits), Traits()); + Traits traits = choose_parameter(get_parameter(np, internal_np::geom_traits), Traits()); typedef typename Traits::Less_xyz_3 Less_xyz_3; @@ -909,13 +909,13 @@ std::size_t merge_duplicate_polygons_in_polygon_soup(const PointRange& points, PolygonRange& polygons, const NamedParameters& np) { - using boost::get_param; - using boost::choose_param; + using parameters::get_parameter; + using parameters::choose_parameter; typedef typename internal::Polygon_types::P_ID P_ID; - const bool erase_all_duplicates = choose_param(get_param(np, internal_np::erase_all_duplicates), false); - const bool same_orientation = choose_param(get_param(np, internal_np::require_same_orientation), false); + const bool erase_all_duplicates = choose_parameter(get_parameter(np, internal_np::erase_all_duplicates), false); + const bool same_orientation = choose_parameter(get_parameter(np, internal_np::require_same_orientation), false); #ifdef CGAL_PMP_REPAIR_POLYGON_SOUP_VERBOSE_PP std::cout << "Only polygons with the same orientation are duplicates: " << std::boolalpha << same_orientation << std::endl; @@ -923,7 +923,7 @@ std::size_t merge_duplicate_polygons_in_polygon_soup(const PointRange& points, #endif typedef typename internal::GetPolygonGeomTraits::type Traits; - Traits traits = choose_param(get_param(np, internal_np::geom_traits), Traits()); + Traits traits = choose_parameter(get_parameter(np, internal_np::geom_traits), Traits()); std::vector > all_duplicate_polygons; internal::collect_duplicate_polygons(points, polygons, std::back_inserter(all_duplicate_polygons), traits, same_orientation); @@ -1066,11 +1066,11 @@ void repair_polygon_soup(PointRange& points, PolygonRange& polygons, const NamedParameters& np) { - using boost::get_param; - using boost::choose_param; + using parameters::get_parameter; + using parameters::choose_parameter; typedef typename internal::GetPolygonGeomTraits::type Traits; - Traits traits = choose_param(get_param(np, internal_np::geom_traits), Traits()); + Traits traits = choose_parameter(get_parameter(np, internal_np::geom_traits), Traits()); #ifdef CGAL_PMP_REPAIR_POLYGON_SOUP_VERBOSE std::cout << "Repairing soup with " << points.size() << " points and " << polygons.size() << " polygons" << std::endl; 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 8723edaae79..114e4591ab0 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 @@ -272,7 +272,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); @@ -340,8 +340,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)); for(face_descriptor f : face_range) { @@ -366,7 +366,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/shape_predicates.h b/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/shape_predicates.h index 6201e81046e..bc8bc962b01 100644 --- a/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/shape_predicates.h +++ b/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/shape_predicates.h @@ -74,15 +74,15 @@ bool is_degenerate_edge(typename boost::graph_traits::edge_descript const PolygonMesh& pm, const NamedParameters& np) { - using boost::get_param; - using boost::choose_param; + using parameters::get_parameter; + using parameters::choose_parameter; typedef typename GetVertexPointMap::const_type VertexPointMap; - VertexPointMap vpmap = choose_param(get_param(np, internal_np::vertex_point), + VertexPointMap vpmap = choose_parameter(get_parameter(np, internal_np::vertex_point), get_const_property_map(vertex_point, pm)); typedef typename GetGeomTraits::type Traits; - Traits traits = choose_param(get_param(np, internal_np::geom_traits), Traits()); + Traits traits = choose_parameter(get_parameter(np, internal_np::geom_traits), Traits()); return traits.equal_3_object()(get(vpmap, source(e, pm)), get(vpmap, target(e, pm))); } @@ -127,15 +127,15 @@ bool is_degenerate_triangle_face(typename boost::graph_traits::fac { CGAL_precondition(CGAL::is_triangle(halfedge(f, tm), tm)); - using boost::get_param; - using boost::choose_param; + using parameters::get_parameter; + using parameters::choose_parameter; typedef typename GetVertexPointMap::const_type VertexPointMap; - VertexPointMap vpmap = choose_param(get_param(np, internal_np::vertex_point), + VertexPointMap vpmap = choose_parameter(get_parameter(np, internal_np::vertex_point), get_const_property_map(vertex_point, tm)); typedef typename GetGeomTraits::type Traits; - Traits traits = choose_param(get_param(np, internal_np::geom_traits), Traits()); + Traits traits = choose_parameter(get_parameter(np, internal_np::geom_traits), Traits()); typename boost::graph_traits::halfedge_descriptor h = halfedge(f, tm); @@ -186,17 +186,17 @@ is_needle_triangle_face(typename boost::graph_traits::face_descrip { CGAL_precondition(threshold >= 1.); - using boost::get_param; - using boost::choose_param; + using parameters::get_parameter; + using parameters::choose_parameter; typedef typename boost::graph_traits::halfedge_descriptor halfedge_descriptor; typedef typename GetVertexPointMap::const_type VertexPointMap; - VertexPointMap vpmap = choose_param(get_param(np, internal_np::vertex_point), + VertexPointMap vpmap = choose_parameter(get_parameter(np, internal_np::vertex_point), get_const_property_map(vertex_point, tm)); typedef typename GetGeomTraits::type Traits; - Traits traits = choose_param(get_param(np, internal_np::geom_traits), Traits()); + Traits traits = choose_parameter(get_parameter(np, internal_np::geom_traits), Traits()); typedef typename Traits::FT FT; @@ -288,18 +288,18 @@ is_cap_triangle_face(typename boost::graph_traits::face_descriptor CGAL_precondition(threshold >= -1.); CGAL_precondition(threshold <= 0.); - using boost::get_param; - using boost::choose_param; + using parameters::get_parameter; + using parameters::choose_parameter; typedef typename boost::graph_traits::vertex_descriptor vertex_descriptor; typedef typename boost::graph_traits::halfedge_descriptor halfedge_descriptor; typedef typename GetVertexPointMap::const_type VertexPointMap; - VertexPointMap vpmap = choose_param(get_param(np, internal_np::vertex_point), + VertexPointMap vpmap = choose_parameter(get_parameter(np, internal_np::vertex_point), get_const_property_map(vertex_point, tm)); typedef typename GetGeomTraits::type Traits; - Traits traits = choose_param(get_param(np, internal_np::geom_traits), Traits()); + Traits traits = choose_parameter(get_parameter(np, internal_np::geom_traits), Traits()); typedef typename Traits::FT FT; typedef typename Traits::Vector_3 Vector_3; 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 e2d79d4019f..f9491528d53 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 @@ -181,14 +181,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); } @@ -561,13 +561,13 @@ std::size_t stitch_boundary_cycle(const typename boost::graph_traits::halfedge_descriptor halfedge_descriptor; 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, pm)); std::size_t stitched_boundary_cycles_n = 0; @@ -720,8 +720,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)); 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 135f7dbf432..e56fd09eb88 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)); for(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 fbfb9e90184..c61c26d0aee 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 @@ -430,20 +430,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); @@ -485,20 +485,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 0fe379626c1..c6ce20869cf 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 @@ -90,14 +90,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()); @@ -105,9 +105,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; } @@ -343,14 +343,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; @@ -370,7 +370,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/include/CGAL/Rigid_triangle_mesh_collision_detection.h b/Polygon_mesh_processing/include/CGAL/Rigid_triangle_mesh_collision_detection.h index c8b84fe38ca..32449ddebc2 100644 --- a/Polygon_mesh_processing/include/CGAL/Rigid_triangle_mesh_collision_detection.h +++ b/Polygon_mesh_processing/include/CGAL/Rigid_triangle_mesh_collision_detection.h @@ -234,7 +234,7 @@ public: CGAL_static_assertion(same_vpm); Vpm vpm = - boost::choose_param(boost::get_param(np, internal_np::vertex_point), + parameters::choose_parameter(parameters::get_parameter(np, internal_np::vertex_point), get_const_property_map(boost::vertex_point, tm) ); // now add the mesh std::size_t id = get_id_for_new_mesh(); @@ -530,8 +530,8 @@ public: using Polygon_mesh_processing::GetFaceIndexMap; const bool maybe_several_cc = - boost::choose_param( - boost::get_param(np, internal_np::apply_per_connected_component), true); + parameters::choose_parameter( + parameters::get_parameter(np, internal_np::apply_per_connected_component), true); typedef typename GetVertexPointMap::const_type Local_vpm; @@ -542,7 +542,7 @@ public: CGAL_static_assertion(same_vpm); Vpm vpm = - boost::choose_param(boost::get_param(np, internal_np::vertex_point), + parameters::choose_parameter(parameters::get_parameter(np, internal_np::vertex_point), get_const_property_map(boost::vertex_point, tm) ); if (maybe_several_cc) @@ -555,7 +555,7 @@ public: NamedParameters>::type Fid_map; Fid_map fid_map = - boost::choose_param(boost::get_param(np, internal_np::face_index), + parameters::choose_parameter(parameters::get_parameter(np, internal_np::face_index), get_const_property_map(boost::face_index, tm)); std::size_t nb_cc = 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 318b3b70da8..9981758189c 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 bab53f34637..002566630f6 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 3bdb9cc5a08..d24e422234f 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 0898682805c..6898d6c21cb 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 a775be11a5d..63e3eeb4a63 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 { @@ -2112,13 +2112,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; @@ -2398,8 +2401,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_approximation/include/CGAL/Surface_mesh_approximation/approximate_triangle_mesh.h b/Surface_mesh_approximation/include/CGAL/Surface_mesh_approximation/approximate_triangle_mesh.h index e0afeda9673..5f493567cee 100644 --- a/Surface_mesh_approximation/include/CGAL/Surface_mesh_approximation/approximate_triangle_mesh.h +++ b/Surface_mesh_approximation/include/CGAL/Surface_mesh_approximation/approximate_triangle_mesh.h @@ -27,7 +27,7 @@ #include -#include +#include #include #include @@ -127,22 +127,22 @@ unspecified_type all_default(); template bool approximate_triangle_mesh(const TriangleMesh &tm, const NamedParameters &np) { - using boost::get_param; - using boost::choose_param; - using boost::is_default_param; + using parameters::get_parameter; + using parameters::choose_parameter; + using parameters::is_default_parameter; typedef typename Polygon_mesh_processing::GetGeomTraits::type Geom_traits; typedef typename Geom_traits::FT FT; typedef typename Polygon_mesh_processing::GetVertexPointMap::type Vertex_point_map; - Vertex_point_map point_pmap = choose_param(get_param(np, internal_np::vertex_point), + Vertex_point_map point_pmap = choose_parameter(get_parameter(np, internal_np::vertex_point), get_property_map(vertex_point, const_cast(tm))); typedef CGAL::Variational_shape_approximation L21_approx; typedef typename L21_approx::Error_metric L21_metric; - const Verbose_level vl = choose_param( - get_param(np, internal_np::verbose_level), SILENT); + const Verbose_level vl = choose_parameter( + get_parameter(np, internal_np::verbose_level), SILENT); const std::size_t number_of_faces = std::distance(faces(tm).first, faces(tm).second); const std::size_t number_of_vertices = std::distance(vertices(tm).first, vertices(tm).second); @@ -157,14 +157,14 @@ bool approximate_triangle_mesh(const TriangleMesh &tm, const NamedParameters &np L21_approx approx(tm, point_pmap, metric); // hierarchical seeding by default - const Seeding_method method = choose_param( - get_param(np, internal_np::seeding_method), HIERARCHICAL); - const std::size_t max_nb_of_proxies = choose_param( - get_param(np, internal_np::max_number_of_proxies), 0); - const FT min_error_drop = choose_param( - get_param(np, internal_np::min_error_drop), FT(0.0)); - const std::size_t nb_of_relaxations = choose_param( - get_param(np, internal_np::number_of_relaxations), 5); + const Seeding_method method = choose_parameter( + get_parameter(np, internal_np::seeding_method), HIERARCHICAL); + const std::size_t max_nb_of_proxies = choose_parameter( + get_parameter(np, internal_np::max_number_of_proxies), 0); + const FT min_error_drop = choose_parameter( + get_parameter(np, internal_np::min_error_drop), FT(0.0)); + const std::size_t nb_of_relaxations = choose_parameter( + get_parameter(np, internal_np::number_of_relaxations), 5); if (vl == VERBOSE) { std::cout << (method == RANDOM ? "Random" : @@ -179,8 +179,8 @@ bool approximate_triangle_mesh(const TriangleMesh &tm, const NamedParameters &np if (vl == MAIN_STEPS || vl == VERBOSE) std::cout << "Seeding done." << std::endl; - const std::size_t nb_of_iterations = choose_param( - get_param(np, internal_np::number_of_iterations), 20); + const std::size_t nb_of_iterations = choose_parameter( + get_parameter(np, internal_np::number_of_iterations), 20); if (vl == VERBOSE) std::cout << "\n#nb_of_iterations = " << nb_of_iterations << std::endl; @@ -193,30 +193,30 @@ bool approximate_triangle_mesh(const TriangleMesh &tm, const NamedParameters &np } // get proxy map - approx.proxy_map( get_param(np, internal_np::face_proxy_map) ); + approx.proxy_map( get_parameter(np, internal_np::face_proxy_map) ); - if (!boost::is_default_param(get_param(np, internal_np::face_proxy_map)) + if (!parameters::is_default_parameter(get_parameter(np, internal_np::face_proxy_map)) && (vl == MAIN_STEPS || vl == VERBOSE)) std::cout << "Filling face proxy map done." << std::endl; // get proxies - approx.proxies( get_param(np, internal_np::proxies) ); + approx.proxies( get_parameter(np, internal_np::proxies) ); - if (!is_default_param( get_param(np, internal_np::proxies) ) + if (!is_default_parameter( get_parameter(np, internal_np::proxies) ) && (vl == MAIN_STEPS || vl == VERBOSE)) std::cout << "Get proxies done." << std::endl; // meshing bool is_manifold = false; - if (!is_default_param( get_param(np, internal_np::anchors)) - || !is_default_param( get_param(np, internal_np::triangles) )) + if (!is_default_parameter( get_parameter(np, internal_np::anchors)) + || !is_default_parameter( get_parameter(np, internal_np::triangles) )) { if (vl == VERBOSE) { - const FT subdivision_ratio = choose_param(get_param(np, internal_np::subdivision_ratio), FT(5.0)); - const bool relative_to_chord = choose_param(get_param(np, internal_np::relative_to_chord), false); - const bool with_dihedral_angle = choose_param(get_param(np, internal_np::with_dihedral_angle), false); - const bool optimize_anchor_location = choose_param(get_param(np, internal_np::optimize_anchor_location), true); - const bool pca_plane = choose_param(get_param(np, internal_np::pca_plane), false); + const FT subdivision_ratio = choose_parameter(get_parameter(np, internal_np::subdivision_ratio), FT(5.0)); + const bool relative_to_chord = choose_parameter(get_parameter(np, internal_np::relative_to_chord), false); + const bool with_dihedral_angle = choose_parameter(get_parameter(np, internal_np::with_dihedral_angle), false); + const bool optimize_anchor_location = choose_parameter(get_parameter(np, internal_np::optimize_anchor_location), true); + const bool pca_plane = choose_parameter(get_parameter(np, internal_np::pca_plane), false); std::cout << "Meshing: " << "\nchord_error = " << subdivision_ratio << "\nrelative_to_chord = " << relative_to_chord @@ -233,16 +233,16 @@ bool approximate_triangle_mesh(const TriangleMesh &tm, const NamedParameters &np } // get anchor points - approx.anchor_points( get_param(np, internal_np::anchors) ); + approx.anchor_points( get_parameter(np, internal_np::anchors) ); - if (!is_default_param( get_param(np, internal_np::anchors) ) + if (!is_default_parameter( get_parameter(np, internal_np::anchors) ) && (vl == MAIN_STEPS || vl == VERBOSE)) std::cout << "Get anchors done." << std::endl; // get indexed triangles - approx.indexed_triangles( get_param(np, internal_np::triangles) ); + approx.indexed_triangles( get_parameter(np, internal_np::triangles) ); - if (!is_default_param( get_param(np, internal_np::triangles) ) + if (!is_default_parameter( get_parameter(np, internal_np::triangles) ) && (vl == MAIN_STEPS || vl == VERBOSE)) std::cout << "Get indexed triangles done." << std::endl; diff --git a/Surface_mesh_approximation/include/CGAL/Variational_shape_approximation.h b/Surface_mesh_approximation/include/CGAL/Variational_shape_approximation.h index 0106b053c01..83aa0e2bba2 100644 --- a/Surface_mesh_approximation/include/CGAL/Variational_shape_approximation.h +++ b/Surface_mesh_approximation/include/CGAL/Variational_shape_approximation.h @@ -44,7 +44,7 @@ #include #include -#include +#include #include #include @@ -322,17 +322,17 @@ public: */ template std::size_t initialize_seeds(const NamedParameters &np) { - using boost::get_param; - using boost::choose_param; + using parameters::get_parameter; + using parameters::choose_parameter; - const Surface_mesh_approximation::Seeding_method method = choose_param( - get_param(np, internal_np::seeding_method), Surface_mesh_approximation::HIERARCHICAL); - std::size_t max_nb_proxies = choose_param( - get_param(np, internal_np::max_number_of_proxies), 0); - FT min_error_drop = choose_param( - get_param(np, internal_np::min_error_drop), FT(0.0)); - const std::size_t nb_relaxations = choose_param( - get_param(np, internal_np::number_of_relaxations), 5); + const Surface_mesh_approximation::Seeding_method method = choose_parameter( + get_parameter(np, internal_np::seeding_method), Surface_mesh_approximation::HIERARCHICAL); + std::size_t max_nb_proxies = choose_parameter( + get_parameter(np, internal_np::max_number_of_proxies), 0); + FT min_error_drop = choose_parameter( + get_parameter(np, internal_np::min_error_drop), FT(0.0)); + const std::size_t nb_relaxations = choose_parameter( + get_parameter(np, internal_np::number_of_relaxations), 5); // adjust parameters if (max_nb_proxies < (m_nb_of_faces / 3) && max_nb_proxies > 0) { @@ -797,14 +797,14 @@ public: */ template bool extract_mesh(const NamedParameters &np) { - using boost::get_param; - using boost::choose_param; + using parameters::get_parameter; + using parameters::choose_parameter; - const FT subdivision_ratio = choose_param(get_param(np, internal_np::subdivision_ratio), FT(5.0)); - const bool relative_to_chord = choose_param(get_param(np, internal_np::relative_to_chord), false); - const bool with_dihedral_angle = choose_param(get_param(np, internal_np::with_dihedral_angle), false); - const bool optimize_anchor_location = choose_param(get_param(np, internal_np::optimize_anchor_location), true); - const bool pca_plane = choose_param(get_param(np, internal_np::pca_plane), false); + const FT subdivision_ratio = choose_parameter(get_parameter(np, internal_np::subdivision_ratio), FT(5.0)); + const bool relative_to_chord = choose_parameter(get_parameter(np, internal_np::relative_to_chord), false); + const bool with_dihedral_angle = choose_parameter(get_parameter(np, internal_np::with_dihedral_angle), false); + const bool optimize_anchor_location = choose_parameter(get_parameter(np, internal_np::optimize_anchor_location), true); + const bool pca_plane = choose_parameter(get_parameter(np, internal_np::pca_plane), false); // compute averaged edge length, used in chord subdivision m_average_edge_length = compute_averaged_edge_length(*m_ptm, m_vpoint_map); @@ -860,19 +860,19 @@ public: */ template void output(const NamedParameters &np) const { - using boost::get_param; - using boost::choose_param; + using parameters::get_parameter; + using parameters::choose_parameter; // get proxy map - proxy_map( get_param(np, internal_np::face_proxy_map) ); + proxy_map( get_parameter(np, internal_np::face_proxy_map) ); // get proxies - proxies( get_param(np, internal_np::proxies) ); + proxies( get_parameter(np, internal_np::proxies) ); // get anchor points - anchor_points( get_param(np, internal_np::anchors) ); + anchor_points( get_parameter(np, internal_np::anchors) ); // get indexed triangles - indexed_triangles( get_param(np, internal_np::triangles) ); + indexed_triangles( get_parameter(np, internal_np::triangles) ); } /*! @@ -896,7 +896,7 @@ public: /*! * @brief dummy function for named parameters. */ - void proxy_map(boost::param_not_found) const {} + void proxy_map(internal_np::Param_not_found) const {} /*! * @brief gets the face region of the specified proxy. @@ -928,7 +928,7 @@ public: /*! * @brief dummy function for named parameters. */ - void proxies(boost::param_not_found) const {} + void proxies(internal_np::Param_not_found) const {} /*! * @brief gets the wrapped proxies. @@ -955,7 +955,7 @@ public: /*! * @brief dummy function for named parameters. */ - void anchor_points(boost::param_not_found) const {} + void anchor_points(internal_np::Param_not_found) const {} /*! * @brief gets the anchor vertices. @@ -983,7 +983,7 @@ public: /*! * @brief dummy function for named parameters. */ - void indexed_triangles(boost::param_not_found) const {} + void indexed_triangles(internal_np::Param_not_found) const {} /*! * @brief gets the indexed boundary polygon approximation. 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 395e46dcf83..03648a28bd5 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_Triangulation_data_structure_2.h b/Triangulation_2/include/CGAL/boost/graph/graph_traits_Triangulation_data_structure_2.h index 28de1f8cc58..f9c92c1e580 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
" ALIASES += "cgalNPEnd=