From cebf0657d80cf266735f59dde690eaa211f0c7e0 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?S=C3=A9bastien=20Loriot?= Date: Sun, 14 Jul 2019 22:45:47 +0200 Subject: [PATCH 1/7] Use a full CGAL version of named function parameters no longer rely on boost --- .../CGAL/boost/graph/Face_filtered_graph.h | 18 +- .../boost/graph/METIS/partition_dual_graph.h | 16 +- .../CGAL/boost/graph/METIS/partition_graph.h | 20 +- .../boost/graph/boost_parameters_interface.h | 23 -- .../CGAL/boost/graph/copy_face_graph.h | 21 +- BGL/include/CGAL/boost/graph/io.h | 14 +- .../CGAL/boost/graph/named_function_params.h | 311 ++++++++++-------- .../CGAL/boost/graph/named_params_helper.h | 44 +-- .../CGAL/boost/graph/parameters_interface.h | 2 + BGL/test/BGL/test_cgal_bgl_named_params.cpp | 234 +++++++------ .../include/CGAL/Classification/classify.h | 1 + .../graph/graph_traits_HalfedgeDS_default.h | 1 + .../surface_mesh/IO_off.cpp | 4 +- .../include/CGAL/IO/read_las_points.h | 5 +- .../include/CGAL/IO/read_off_points.h | 7 +- .../include/CGAL/IO/read_ply_points.h | 7 +- .../include/CGAL/IO/read_xyz_points.h | 7 +- .../include/CGAL/IO/write_las_points.h | 5 +- .../include/CGAL/IO/write_off_points.h | 7 +- .../include/CGAL/IO/write_ply_points.h | 7 +- .../include/CGAL/IO/write_xyz_points.h | 7 +- .../include/CGAL/bilateral_smooth_point_set.h | 11 +- .../include/CGAL/compute_average_spacing.h | 7 +- .../CGAL/edge_aware_upsample_point_set.h | 15 +- .../include/CGAL/estimate_scale.h | 28 +- .../include/CGAL/grid_simplify_point_set.h | 7 +- .../CGAL/hierarchy_simplify_point_set.h | 11 +- .../include/CGAL/jet_estimate_normals.h | 11 +- .../include/CGAL/jet_smooth_point_set.h | 11 +- .../include/CGAL/mst_orient_normals.h | 8 +- .../include/CGAL/pca_estimate_normals.h | 10 +- .../include/CGAL/remove_outliers.h | 11 +- .../include/CGAL/structure_point_set.h | 16 +- .../include/CGAL/vcm_estimate_normals.h | 14 +- .../wlop_simplify_and_regularize_point_set.h | 15 +- .../CGAL/Polygon_mesh_processing/bbox.h | 32 +- .../CGAL/Polygon_mesh_processing/border.h | 4 +- .../CGAL/Polygon_mesh_processing/clip.h | 12 +- .../Polygon_mesh_processing/compute_normal.h | 17 +- .../connected_components.h | 48 +-- .../Polygon_mesh_processing/corefinement.h | 70 ++-- .../Polygon_mesh_processing/detect_features.h | 14 +- .../CGAL/Polygon_mesh_processing/distance.h | 46 +-- .../CGAL/Polygon_mesh_processing/extrude.h | 9 +- .../CGAL/Polygon_mesh_processing/fair.h | 12 +- .../internal/Corefinement/face_graph_utils.h | 4 +- .../Isotropic_remeshing/remesh_impl.h | 2 +- .../Polygon_mesh_processing/intersection.h | 81 +++-- .../CGAL/Polygon_mesh_processing/measure.h | 18 +- .../Polygon_mesh_processing/orientation.h | 40 +-- .../random_perturbation.h | 16 +- .../CGAL/Polygon_mesh_processing/refine.h | 8 +- .../CGAL/Polygon_mesh_processing/remesh.h | 52 +-- .../CGAL/Polygon_mesh_processing/repair.h | 24 +- .../self_intersections.h | 6 +- .../Polygon_mesh_processing/stitch_borders.h | 18 +- .../CGAL/Polygon_mesh_processing/transform.h | 4 +- .../triangulate_faces.h | 20 +- .../triangulate_hole.h | 18 +- .../test_orient_cc.cpp | 11 +- .../Plugins/PMP/Inside_out_plugin.cpp | 8 +- .../include/CGAL/IO/Polyhedron_iostream.h | 16 +- .../subdivision_hosts_3.h | 32 +- .../subdivision_methods_3.h | 32 +- .../include/CGAL/Surface_mesh/Surface_mesh.h | 10 +- .../edge_collapse.h | 38 +-- 66 files changed, 863 insertions(+), 795 deletions(-) delete mode 100644 BGL/include/CGAL/boost/graph/boost_parameters_interface.h diff --git a/BGL/include/CGAL/boost/graph/Face_filtered_graph.h b/BGL/include/CGAL/boost/graph/Face_filtered_graph.h index a80f8053dd3..b4fbdbdb4b2 100644 --- a/BGL/include/CGAL/boost/graph/Face_filtered_graph.h +++ b/BGL/include/CGAL/boost/graph/Face_filtered_graph.h @@ -148,9 +148,9 @@ struct Face_filtered_graph #endif ) : _graph(const_cast(graph)) - , fimap(boost::choose_param(get_param(np, internal_np::face_index), get_const_property_map(face_index, graph))) - , vimap(boost::choose_param(get_param(np, boost::vertex_index), get_const_property_map(boost::vertex_index, graph))) - , himap(boost::choose_param(get_param(np, internal_np::halfedge_index), get_const_property_map(halfedge_index, graph))) + , fimap(parameters::choose_parameter(get_parameter(np, internal_np::face_index), get_const_property_map(face_index, graph))) + , vimap(parameters::choose_parameter(get_parameter(np, internal_np::vertex_index), get_const_property_map(boost::vertex_index, graph))) + , himap(parameters::choose_parameter(get_parameter(np, internal_np::halfedge_index), get_const_property_map(halfedge_index, graph))) { set_selected_faces(selected_face_patch_indices, face_patch_index_map); } @@ -203,9 +203,9 @@ struct Face_filtered_graph const CGAL_BGL_NP_CLASS& np ) : _graph(const_cast(graph)) - , fimap(boost::choose_param(get_param(np, internal_np::face_index), get_const_property_map(face_index, graph))) - , vimap(boost::choose_param(get_param(np, boost::vertex_index), get_const_property_map(boost::vertex_index, graph))) - , himap(boost::choose_param(get_param(np, internal_np::halfedge_index), get_const_property_map(halfedge_index, graph))) + , fimap(parameters::choose_parameter(get_parameter(np, internal_np::face_index), get_const_property_map(face_index, graph))) + , vimap(parameters::choose_parameter(get_parameter(np, internal_np::vertex_index), get_const_property_map(boost::vertex_index, graph))) + , himap(parameters::choose_parameter(get_parameter(np, internal_np::halfedge_index), get_const_property_map(halfedge_index, graph))) { set_selected_faces(selected_face_patch_index, face_patch_index_map); } @@ -248,9 +248,9 @@ struct Face_filtered_graph const FaceRange& selected_faces, const CGAL_BGL_NP_CLASS& np) : _graph(const_cast(graph)) - , fimap(boost::choose_param(get_param(np, internal_np::face_index), get_const_property_map(face_index, graph))) - , vimap(boost::choose_param(get_param(np, boost::vertex_index), get_const_property_map(boost::vertex_index, graph))) - , himap(boost::choose_param(get_param(np, internal_np::halfedge_index), get_const_property_map(halfedge_index, graph))) + , fimap(parameters::choose_parameter(get_parameter(np, internal_np::face_index), get_const_property_map(face_index, graph))) + , vimap(parameters::choose_parameter(get_parameter(np, internal_np::vertex_index), get_const_property_map(boost::vertex_index, graph))) + , himap(parameters::choose_parameter(get_parameter(np, internal_np::halfedge_index), get_const_property_map(halfedge_index, graph))) { set_selected_faces(selected_faces); } diff --git a/BGL/include/CGAL/boost/graph/METIS/partition_dual_graph.h b/BGL/include/CGAL/boost/graph/METIS/partition_dual_graph.h index 7e2a15870a7..c7f22c5831f 100644 --- a/BGL/include/CGAL/boost/graph/METIS/partition_dual_graph.h +++ b/BGL/include/CGAL/boost/graph/METIS/partition_dual_graph.h @@ -51,8 +51,8 @@ void partition_dual_graph(const TriangleMesh& tm, CGAL_precondition(CGAL::is_triangle_mesh(tm)); CGAL_precondition_msg(nparts > 1, ("Partitioning requires a number of parts > 1")); - using boost::choose_param; - using boost::get_param; + using parameters::choose_parameter; + using parameters::get_parameter; typedef typename boost::graph_traits::vertex_descriptor vertex_descriptor; typedef typename boost::graph_traits::halfedge_descriptor halfedge_descriptor; @@ -60,7 +60,7 @@ void partition_dual_graph(const TriangleMesh& tm, // vertex index map typedef typename CGAL::Polygon_mesh_processing::GetVertexIndexMap::type Indices; - Indices indices = choose_param(get_param(np, internal_np::vertex_index), + Indices indices = choose_parameter(get_parameter(np, internal_np::vertex_index), get_const_property_map(boost::vertex_index, tm)); idx_t nn = static_cast(num_vertices(tm)); @@ -119,8 +119,8 @@ void partition_dual_graph(const TriangleMesh& tm, Output_vertex_partition_ids vo; Output_face_partition_ids fo; - vo(tm, indices, npart, get_param(np, internal_np::vertex_partition_id)); - fo(tm, epart, get_param(np, internal_np::face_partition_id)); + vo(tm, indices, npart, get_parameter(np, internal_np::vertex_partition_id)); + fo(tm, epart, get_parameter(np, internal_np::face_partition_id)); delete[] eptr; delete[] eind; @@ -131,7 +131,7 @@ void partition_dual_graph(const TriangleMesh& tm, template void partition_dual_graph(const TriangleMesh& tm, int nparts, - const boost::param_not_found, // no METIS options were passed + const internal_np::Param_not_found, // no METIS options were passed const NamedParameters& np) { idx_t options[METIS_NOPTIONS]; @@ -180,9 +180,9 @@ void partition_dual_graph(const TriangleMesh& tm, int nparts, template void partition_dual_graph(const TriangleMesh& tm, int nparts, const NamedParameters& np) { - using boost::get_param; + using parameters::get_parameter; - return partition_dual_graph(tm, nparts, get_param(np, internal_np::METIS_options), np); + return partition_dual_graph(tm, nparts, get_parameter(np, internal_np::METIS_options), np); } template diff --git a/BGL/include/CGAL/boost/graph/METIS/partition_graph.h b/BGL/include/CGAL/boost/graph/METIS/partition_graph.h index d0f3e56b759..5218268a4ba 100644 --- a/BGL/include/CGAL/boost/graph/METIS/partition_graph.h +++ b/BGL/include/CGAL/boost/graph/METIS/partition_graph.h @@ -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/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 6be3d3ac865..838d0ee5a0a 100644 --- a/BGL/include/CGAL/boost/graph/copy_face_graph.h +++ b/BGL/include/CGAL/boost/graph/copy_face_graph.h @@ -244,7 +244,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(); } @@ -336,18 +336,19 @@ void copy_face_graph(const SourceMesh& sm, TargetMesh& tm, #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))); } diff --git a/BGL/include/CGAL/boost/graph/io.h b/BGL/include/CGAL/boost/graph/io.h index 2ad04ff8fe8..431bf45455a 100644 --- a/BGL/include/CGAL/boost/graph/io.h +++ b/BGL/include/CGAL/boost/graph/io.h @@ -59,8 +59,11 @@ bool write_off(std::ostream& os, typedef typename boost::graph_traits::vertices_size_type vertices_size_type; typedef typename boost::graph_traits::faces_size_type faces_size_type; + using parameters::choose_parameter; + using parameters::get_parameter; + typename Polygon_mesh_processing::GetVertexPointMap::const_type - vpm = choose_param(get_param(np, internal_np::vertex_point), + vpm = choose_parameter(get_parameter(np, internal_np::vertex_point), get_const_property_map(CGAL::vertex_point, g)); vertices_size_type nv = static_cast(std::distance(vertices(g).first, vertices(g).second)); faces_size_type nf = static_cast(std::distance(faces(g).first, faces(g).second)); @@ -175,6 +178,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; @@ -183,7 +188,7 @@ bool read_off(std::istream& is, typedef typename Polygon_mesh_processing::GetVertexPointMap::type Vpm; typedef typename boost::property_traits::value_type Point_3; - Vpm vpm = choose_param(get_param(np, internal_np::vertex_point), + Vpm vpm = choose_parameter(get_parameter(np, internal_np::vertex_point), get_property_map(CGAL::vertex_point, g)); vertices_size_type nv, nvf; faces_size_type nf; @@ -286,7 +291,10 @@ bool write_inp(std::ostream& os, typedef typename Polygon_mesh_processing::GetVertexPointMap::const_type VPM; typedef typename boost::property_traits::value_type Point_3; - VPM vpm = choose_param(get_param(np, internal_np::vertex_point), + using parameters::choose_parameter; + using parameters::get_parameter; + + VPM vpm = choose_parameter(get_parameter(np, internal_np::vertex_point), get_const_property_map(CGAL::vertex_point, g)); os << "*Part, name=" << name << "\n*Node\n"; diff --git a/BGL/include/CGAL/boost/graph/named_function_params.h b/BGL/include/CGAL/boost/graph/named_function_params.h index 205269a856d..90b3e0c9575 100644 --- a/BGL/include/CGAL/boost/graph/named_function_params.h +++ b/BGL/include/CGAL/boost/graph/named_function_params.h @@ -1,94 +1,42 @@ -//======================================================================= -// Copyright 1997, 1998, 1999, 2000 University of Notre Dame. -// Authors: Andrew Lumsdaine, Lie-Quan Lee, Jeremy G. Siek +// Copyright (c) 2019 GeometryFactory (France). All rights reserved. // -// This file is part of the Boost Graph Library +// 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. // -// Distributed under the Boost Software License, Version 1.0. (See -// accompanying file LICENSE_1_0.txt or copy at -// http://www.boost.org/LICENSE_1_0.txt) -//======================================================================= -// Copyright (c) 2007 GeometryFactory (France). All rights reserved. +// 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: BSL-1.0 +// SPDX-License-Identifier: LGPL-3.0+ // -// Author(s) : Andreas Fabri, Fernando Cacciola +// +// Author(s) : Sebastien Loriot #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 +#include #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; +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) \ @@ -96,22 +44,113 @@ using boost::graph_visitor; #include #undef CGAL_add_named_parameter -}//internal_np +template +struct Named_params_impl : Base +{ + T v; // copy of the parameter + Named_params_impl(T v, const Base& b) + : Base(b) + , v(v) + {} +}; - template - struct cgal_bgl_named_params : boost::bgl_named_params +// 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 cgal_bgl_named_params + : internal_np::Named_params_impl +{ + typedef internal_np::Named_params_impl 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 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); - } + 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 @@ -124,27 +163,25 @@ using boost::graph_visitor; 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(); - } +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(); - } +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) \ @@ -156,50 +193,46 @@ namespace parameters { return Params(p); \ } #include -#include #undef CGAL_add_named_parameter - } // namespace parameters +// function to extract a parameter +template +typename internal_np::Get_param, Query_tag>::type +get_parameter(const cgal_bgl_named_params& np, Query_tag tag) +{ + return internal_np::get_parameter_impl(static_cast&>(np), tag); +} + +template +const 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 -// 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 517a750d901..712e0946da8 100644 --- a/BGL/include/CGAL/boost/graph/named_params_helper.h +++ b/BGL/include/CGAL/boost/graph/named_params_helper.h @@ -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 @@ -153,21 +153,21 @@ namespace CGAL { 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 @@ -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 @@ -349,7 +349,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 @@ -363,13 +363,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 @@ -392,7 +392,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 @@ -405,7 +405,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 @@ -416,7 +416,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 @@ -437,7 +437,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 1ec0f1504de..2b10dbfa032 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 019ad98dedf..77a6549dca9 100644 --- a/BGL/test/BGL/test_cgal_bgl_named_params.cpp +++ b/BGL/test/BGL/test_cgal_bgl_named_params.cpp @@ -22,161 +22,157 @@ 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_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); // 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::projection_functor).v == 42); - assert(get_param(np, CGAL::internal_np::apply_per_connected_component).v == 46); + 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::projection_functor).v == 42); + assert(get_parameter(np, CGAL::internal_np::apply_per_connected_component).v == 46); // 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<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)); // 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<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<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<42>(get_parameter(np, CGAL::internal_np::projection_functor)); + check_same_type<46>(get_parameter(np, CGAL::internal_np::apply_per_connected_component)); } int main() diff --git a/Classification/include/CGAL/Classification/classify.h b/Classification/include/CGAL/Classification/classify.h index ea36f3845b9..d8670fa867f 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_default.h b/HalfedgeDS/include/CGAL/boost/graph/graph_traits_HalfedgeDS_default.h index 6b3898880b1..eba0b4fe01f 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..659a84f5a01 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 @@ -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_processing_3/include/CGAL/IO/read_las_points.h b/Point_set_processing_3/include/CGAL/IO/read_las_points.h index c28d8d16a6d..576c1a87cb8 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 @@ -468,12 +468,13 @@ bool read_las_points(std::istream& stream, const CGAL_BGL_NP_CLASS& np) #endif { - using boost::choose_param; + using parameters::choose_parameter; + using parameters::get_parameter; typedef Point_set_processing_3::Fake_point_range PointRange; typedef typename Point_set_processing_3::GetPointMap::type PointMap; - PointMap point_map = choose_param(get_param(np, internal_np::point_map), PointMap()); + PointMap point_map = choose_parameter(get_parameter(np, internal_np::point_map), PointMap()); return read_las_points_with_properties (stream, output, make_las_point_reader (point_map)); diff --git a/Point_set_processing_3/include/CGAL/IO/read_off_points.h b/Point_set_processing_3/include/CGAL/IO/read_off_points.h index e0e2b9d0f21..e0486840f98 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 @@ -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 5a3c819bf52..30348fc9000 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 @@ -863,7 +863,8 @@ bool read_ply_points(std::istream& stream, const CGAL_BGL_NP_CLASS& np) #endif { - using boost::choose_param; + using parameters::choose_parameter; + using parameters::get_parameter; typedef Point_set_processing_3::Fake_point_range PointRange; @@ -874,8 +875,8 @@ bool read_ply_points(std::istream& stream, bool has_normals = !(boost::is_same::NoMap>::value); - PointMap point_map = choose_param(get_param(np, internal_np::point_map), PointMap()); - NormalMap normal_map = choose_param(get_param(np, internal_np::normal_map), NormalMap()); + PointMap point_map = choose_parameter(get_parameter(np, internal_np::point_map), PointMap()); + NormalMap normal_map = choose_parameter(get_parameter(np, internal_np::normal_map), NormalMap()); if (has_normals) return read_ply_points_with_properties (stream, output, diff --git a/Point_set_processing_3/include/CGAL/IO/read_xyz_points.h b/Point_set_processing_3/include/CGAL/IO/read_xyz_points.h index 4af3a2c15ea..5ef24a364a5 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 @@ -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 1d8e15cb85a..61a7b4541e7 100644 --- a/Point_set_processing_3/include/CGAL/IO/write_las_points.h +++ b/Point_set_processing_3/include/CGAL/IO/write_las_points.h @@ -285,10 +285,11 @@ write_las_points( const PointRange& points, const NamedParameters& np) { - using boost::choose_param; + using parameters::choose_parameter; + using parameters::get_parameter; typedef typename Point_set_processing_3::GetPointMap::type PointMap; - PointMap point_map = choose_param(get_param(np, internal_np::point_map), PointMap()); + PointMap point_map = choose_parameter(get_parameter(np, internal_np::point_map), PointMap()); return write_las_points_with_properties (stream, points, make_las_point_writer(point_map)); } diff --git a/Point_set_processing_3/include/CGAL/IO/write_off_points.h b/Point_set_processing_3/include/CGAL/IO/write_off_points.h index 3f9ebfd728d..395b3924df1 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 @@ -68,7 +68,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; @@ -77,8 +78,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 6da878abb1b..68e3b761f03 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 @@ -429,7 +429,8 @@ write_ply_points( const PointRange& points, const NamedParameters& np) { - using boost::choose_param; + using parameters::choose_parameter; + using parameters::get_parameter; // basic geometric types typedef typename Point_set_processing_3::GetPointMap::type PointMap; @@ -438,8 +439,8 @@ write_ply_points( bool has_normals = !(boost::is_same::NoMap>::value); - PointMap point_map = choose_param(get_param(np, internal_np::point_map), PointMap()); - NormalMap normal_map = choose_param(get_param(np, internal_np::normal_map), NormalMap()); + PointMap point_map = choose_parameter(get_parameter(np, internal_np::point_map), PointMap()); + NormalMap normal_map = choose_parameter(get_parameter(np, internal_np::normal_map), NormalMap()); if (has_normals) return write_ply_points_with_properties( diff --git a/Point_set_processing_3/include/CGAL/IO/write_xyz_points.h b/Point_set_processing_3/include/CGAL/IO/write_xyz_points.h index 7ff6cf06b0c..6c7554af64e 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 @@ -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 4c0d896f1fb..8437688ef94 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 @@ -444,7 +444,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; @@ -459,8 +460,8 @@ bilateral_smooth_point_set( typedef typename std::vector > Pwns; typedef typename Kernel::FT FT; - double sharpness_angle = choose_param(get_param(np, internal_np::sharpness_angle), 30.); - const cpp11::function& callback = choose_param(get_param(np, internal_np::callback), + double sharpness_angle = choose_parameter(get_parameter(np, internal_np::sharpness_angle), 30.); + const cpp11::function& callback = choose_parameter(get_parameter(np, internal_np::callback), cpp11::function()); CGAL_point_set_processing_precondition(points.begin() != points.end()); @@ -473,8 +474,8 @@ bilateral_smooth_point_set( typedef CGAL::Orthogonal_k_neighbor_search Neighbor_search; typedef typename Neighbor_search::Tree Tree; - PointMap point_map = choose_param(get_param(np, internal_np::point_map), PointMap()); - NormalMap normal_map = choose_param(get_param(np, internal_np::normal_map), NormalMap()); + PointMap point_map = choose_parameter(get_parameter(np, internal_np::point_map), PointMap()); + NormalMap normal_map = choose_parameter(get_parameter(np, internal_np::normal_map), NormalMap()); // copy points and normals Pwns pwns; diff --git a/Point_set_processing_3/include/CGAL/compute_average_spacing.h b/Point_set_processing_3/include/CGAL/compute_average_spacing.h index b557ac389d4..78cced92c2d 100644 --- a/Point_set_processing_3/include/CGAL/compute_average_spacing.h +++ b/Point_set_processing_3/include/CGAL/compute_average_spacing.h @@ -196,7 +196,8 @@ compute_average_spacing( 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::const_type PointMap; @@ -204,8 +205,8 @@ compute_average_spacing( typedef typename Kernel::Point_3 Point; - PointMap point_map = choose_param(get_param(np, internal_np::point_map), PointMap()); - const cpp11::function& callback = choose_param(get_param(np, internal_np::callback), + PointMap point_map = choose_parameter(get_parameter(np, internal_np::point_map), PointMap()); + const cpp11::function& callback = choose_parameter(get_parameter(np, internal_np::callback), cpp11::function()); // types for K nearest neighbors search structure diff --git a/Point_set_processing_3/include/CGAL/edge_aware_upsample_point_set.h b/Point_set_processing_3/include/CGAL/edge_aware_upsample_point_set.h index 0c468cab86f..f3d26015eac 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 @@ -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 6243bfc4307..86a858f6928 100644 --- a/Point_set_processing_3/include/CGAL/estimate_scale.h +++ b/Point_set_processing_3/include/CGAL/estimate_scale.h @@ -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 2dcb7ab6c7e..69f2bcba033 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 @@ -208,11 +208,12 @@ grid_simplify_point_set( double epsilon, const NamedParameters& np) { - using boost::choose_param; + using parameters::choose_parameter; + using parameters::get_parameter; typedef typename Point_set_processing_3::GetPointMap::const_type PointMap; - PointMap point_map = choose_param(get_param(np, internal_np::point_map), PointMap()); - const cpp11::function& callback = choose_param(get_param(np, internal_np::callback), + PointMap point_map = choose_parameter(get_parameter(np, internal_np::point_map), PointMap()); + const cpp11::function& callback = choose_parameter(get_parameter(np, internal_np::callback), cpp11::function()); // actual type of input points diff --git a/Point_set_processing_3/include/CGAL/hierarchy_simplify_point_set.h b/Point_set_processing_3/include/CGAL/hierarchy_simplify_point_set.h index 15580c55cdb..82bbbb96bb6 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 @@ -161,7 +161,8 @@ namespace CGAL { hierarchy_simplify_point_set (PointRange& points, const NamedParameters& np) { - using boost::choose_param; + using parameters::choose_parameter; + using parameters::get_parameter; // basic geometric types typedef typename Point_set_processing_3::GetPointMap::type PointMap; @@ -172,10 +173,10 @@ namespace CGAL { typedef typename Kernel::Vector_3 Vector; typedef typename Kernel::FT FT; - PointMap point_map = choose_param(get_param(np, internal_np::point_map), PointMap()); - unsigned int size = choose_param(get_param(np, internal_np::size), 10); - double var_max = choose_param(get_param(np, internal_np::maximum_variation), 1./3.); - const cpp11::function& callback = choose_param(get_param(np, internal_np::callback), + PointMap point_map = choose_parameter(get_parameter(np, internal_np::point_map), PointMap()); + unsigned int size = choose_parameter(get_parameter(np, internal_np::size), 10); + double var_max = choose_parameter(get_parameter(np, internal_np::maximum_variation), 1./3.); + const cpp11::function& callback = choose_parameter(get_parameter(np, internal_np::callback), cpp11::function()); typedef typename std::iterator_traits::value_type Input_type; diff --git a/Point_set_processing_3/include/CGAL/jet_estimate_normals.h b/Point_set_processing_3/include/CGAL/jet_estimate_normals.h index 362bf0abf19..eaa72b0c4e9 100644 --- a/Point_set_processing_3/include/CGAL/jet_estimate_normals.h +++ b/Point_set_processing_3/include/CGAL/jet_estimate_normals.h @@ -212,7 +212,8 @@ jet_estimate_normals( unsigned int k, const NamedParameters& np) { - using boost::choose_param; + using parameters::choose_parameter; + using parameters::get_parameter; CGAL_TRACE("Calls jet_estimate_normals()\n"); @@ -229,10 +230,10 @@ jet_estimate_normals( typename GetSvdTraits::NoTraits>::value), "Error: no SVD traits"); - PointMap point_map = choose_param(get_param(np, internal_np::point_map), PointMap()); - NormalMap normal_map = choose_param(get_param(np, internal_np::normal_map), NormalMap()); - unsigned int degree_fitting = choose_param(get_param(np, internal_np::degree_fitting), 2); - const cpp11::function& callback = choose_param(get_param(np, internal_np::callback), + PointMap point_map = choose_parameter(get_parameter(np, internal_np::point_map), PointMap()); + NormalMap normal_map = choose_parameter(get_parameter(np, internal_np::normal_map), NormalMap()); + unsigned int degree_fitting = choose_parameter(get_parameter(np, internal_np::degree_fitting), 2); + const cpp11::function& callback = choose_parameter(get_parameter(np, internal_np::callback), cpp11::function()); typedef typename Kernel::Point_3 Point; diff --git a/Point_set_processing_3/include/CGAL/jet_smooth_point_set.h b/Point_set_processing_3/include/CGAL/jet_smooth_point_set.h index e9054ba2147..2de27622ff5 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 @@ -216,7 +216,8 @@ jet_smooth_point_set( unsigned int k, const NamedParameters& np) { - using boost::choose_param; + using parameters::choose_parameter; + using parameters::get_parameter; // basic geometric types typedef typename Point_set_processing_3::GetPointMap::type PointMap; @@ -227,10 +228,10 @@ jet_smooth_point_set( typename GetSvdTraits::NoTraits>::value), "Error: no SVD traits"); - PointMap point_map = choose_param(get_param(np, internal_np::point_map), PointMap()); - unsigned int degree_fitting = choose_param(get_param(np, internal_np::degree_fitting), 2); - unsigned int degree_monge = choose_param(get_param(np, internal_np::degree_monge), 2); - const cpp11::function& callback = choose_param(get_param(np, internal_np::callback), + PointMap point_map = choose_parameter(get_parameter(np, internal_np::point_map), PointMap()); + unsigned int degree_fitting = choose_parameter(get_parameter(np, internal_np::degree_fitting), 2); + unsigned int degree_monge = choose_parameter(get_parameter(np, internal_np::degree_monge), 2); + const cpp11::function& callback = choose_parameter(get_parameter(np, internal_np::callback), cpp11::function()); typedef typename Kernel::Point_3 Point; diff --git a/Point_set_processing_3/include/CGAL/mst_orient_normals.h b/Point_set_processing_3/include/CGAL/mst_orient_normals.h index f441f209de9..77d848ea239 100644 --- a/Point_set_processing_3/include/CGAL/mst_orient_normals.h +++ b/Point_set_processing_3/include/CGAL/mst_orient_normals.h @@ -539,7 +539,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; @@ -550,8 +552,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()); Kernel kernel; // Bring private stuff to scope diff --git a/Point_set_processing_3/include/CGAL/pca_estimate_normals.h b/Point_set_processing_3/include/CGAL/pca_estimate_normals.h index 68da25df8d8..220389d6118 100644 --- a/Point_set_processing_3/include/CGAL/pca_estimate_normals.h +++ b/Point_set_processing_3/include/CGAL/pca_estimate_normals.h @@ -199,7 +199,9 @@ pca_estimate_normals( unsigned int k, const NamedParameters& np) { - using boost::choose_param; + using parameters::choose_parameter; + using parameters::get_parameter; + CGAL_TRACE("Calls pca_estimate_normals()\n"); // basic geometric types @@ -211,9 +213,9 @@ pca_estimate_normals( typename Point_set_processing_3::GetNormalMap::NoMap>::value), "Error: no normal map"); - PointMap point_map = choose_param(get_param(np, internal_np::point_map), PointMap()); - NormalMap normal_map = choose_param(get_param(np, internal_np::normal_map), NormalMap()); - const cpp11::function& callback = choose_param(get_param(np, internal_np::callback), + PointMap point_map = choose_parameter(get_parameter(np, internal_np::point_map), PointMap()); + NormalMap normal_map = choose_parameter(get_parameter(np, internal_np::normal_map), NormalMap()); + const cpp11::function& callback = choose_parameter(get_parameter(np, internal_np::callback), cpp11::function()); typedef typename Kernel::Point_3 Point; diff --git a/Point_set_processing_3/include/CGAL/remove_outliers.h b/Point_set_processing_3/include/CGAL/remove_outliers.h index 3300d2c6696..77f2779dee5 100644 --- a/Point_set_processing_3/include/CGAL/remove_outliers.h +++ b/Point_set_processing_3/include/CGAL/remove_outliers.h @@ -162,16 +162,17 @@ remove_outliers( unsigned int k, const NamedParameters& np) { - using boost::choose_param; + using parameters::choose_parameter; + using parameters::get_parameter; // geometric types typedef typename Point_set_processing_3::GetPointMap::type PointMap; typedef typename Point_set_processing_3::GetK::Kernel Kernel; - PointMap point_map = choose_param(get_param(np, internal_np::point_map), PointMap()); - double threshold_percent = choose_param(get_param(np, internal_np::threshold_percent), 10.); - double threshold_distance = choose_param(get_param(np, internal_np::threshold_distance), 0.); - const cpp11::function& callback = choose_param(get_param(np, internal_np::callback), + PointMap point_map = choose_parameter(get_parameter(np, internal_np::point_map), PointMap()); + double threshold_percent = choose_parameter(get_parameter(np, internal_np::threshold_percent), 10.); + double threshold_distance = choose_parameter(get_parameter(np, internal_np::threshold_distance), 0.); + const cpp11::function& callback = choose_parameter(get_parameter(np, internal_np::callback), cpp11::function()); typedef typename Kernel::FT FT; diff --git a/Point_set_processing_3/include/CGAL/structure_point_set.h b/Point_set_processing_3/include/CGAL/structure_point_set.h index 3721e82f110..7534d6d503d 100644 --- a/Point_set_processing_3/include/CGAL/structure_point_set.h +++ b/Point_set_processing_3/include/CGAL/structure_point_set.h @@ -235,7 +235,8 @@ public: double epsilon, const NamedParameters& np) { - using boost::choose_param; + using parameters::choose_parameter; + using parameters::get_parameter; // basic geometric types typedef typename Point_set_processing_3::GetPointMap::type PointMap; @@ -250,11 +251,11 @@ public: typename Point_set_processing_3::GetPlaneIndexMap::NoMap>::value), "Error: no plane index map"); - PointMap point_map = choose_param(get_param(np, internal_np::point_map), PointMap()); - NormalMap normal_map = choose_param(get_param(np, internal_np::normal_map), NormalMap()); - PlaneMap plane_map = choose_param(get_param(np, internal_np::plane_map), PlaneMap()); - PlaneIndexMap index_map = choose_param(get_param(np, internal_np::plane_index_map), PlaneIndexMap()); - double attraction_factor = choose_param(get_param(np, internal_np::attraction_factor), 3.); + PointMap point_map = choose_parameter(get_parameter(np, internal_np::point_map), PointMap()); + NormalMap normal_map = choose_parameter(get_parameter(np, internal_np::normal_map), NormalMap()); + PlaneMap plane_map = choose_parameter(get_parameter(np, internal_np::plane_map), PlaneMap()); + PlaneIndexMap index_map = choose_parameter(get_parameter(np, internal_np::plane_index_map), PlaneIndexMap()); + double attraction_factor = choose_parameter(get_parameter(np, internal_np::attraction_factor), 3.); m_points.reserve(points.size()); m_normals.reserve(points.size()); @@ -1553,7 +1554,8 @@ structure_point_set (const PointRange& points, double epsilon, const NamedParameters& np) { - using boost::choose_param; + using parameters::choose_parameter; + using parameters::get_parameter; typedef typename Point_set_processing_3::GetK::Kernel Kernel; diff --git a/Point_set_processing_3/include/CGAL/vcm_estimate_normals.h b/Point_set_processing_3/include/CGAL/vcm_estimate_normals.h index ef01e0a3b64..8efb91adfbe 100644 --- a/Point_set_processing_3/include/CGAL/vcm_estimate_normals.h +++ b/Point_set_processing_3/include/CGAL/vcm_estimate_normals.h @@ -265,12 +265,14 @@ compute_vcm (const PointRange& points, double convolution_radius, const NamedParameters& np) { - using boost::choose_param; + using parameters::choose_parameter; + using parameters::get_parameter; + // basic geometric types typedef typename Point_set_processing_3::GetPointMap::type PointMap; typedef typename Point_set_processing_3::GetK::Kernel Kernel; - PointMap point_map = choose_param(get_param(np, internal_np::point_map), PointMap()); + PointMap point_map = choose_parameter(get_parameter(np, internal_np::point_map), PointMap()); Kernel kernel; // First, compute the VCM for each point @@ -345,7 +347,9 @@ vcm_estimate_normals_internal (PointRange& points, int nb_neighbors_convolve = -1 ///< number of neighbors used during the convolution. ) { - using boost::choose_param; + using parameters::choose_parameter; + using parameters::get_parameter; + // basic geometric types typedef typename Point_set_processing_3::GetPointMap::type PointMap; typedef typename Point_set_processing_3::GetNormalMap::type NormalMap; @@ -356,8 +360,8 @@ vcm_estimate_normals_internal (PointRange& points, typename Point_set_processing_3::GetNormalMap::NoMap>::value), "Error: no normal map"); - PointMap point_map = choose_param(get_param(np, internal_np::point_map), PointMap()); - NormalMap normal_map = choose_param(get_param(np, internal_np::normal_map), NormalMap()); + PointMap point_map = choose_parameter(get_parameter(np, internal_np::point_map), PointMap()); + NormalMap normal_map = choose_parameter(get_parameter(np, internal_np::normal_map), NormalMap()); typedef cpp11::array Covariance; diff --git a/Point_set_processing_3/include/CGAL/wlop_simplify_and_regularize_point_set.h b/Point_set_processing_3/include/CGAL/wlop_simplify_and_regularize_point_set.h index 3d9c0f43c52..7e78e9e1ed8 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 @@ -472,18 +472,19 @@ wlop_simplify_and_regularize_point_set( const NamedParameters& np ) { - using boost::choose_param; + using parameters::choose_parameter; + using parameters::get_parameter; // basic geometric types typedef typename Point_set_processing_3::GetPointMap::type PointMap; typedef typename Point_set_processing_3::GetK::Kernel Kernel; - PointMap point_map = choose_param(get_param(np, internal_np::point_map), PointMap()); - double select_percentage = choose_param(get_param(np, internal_np::select_percentage), 5.); - double radius = choose_param(get_param(np, internal_np::neighbor_radius), -1); - unsigned int iter_number = choose_param(get_param(np, internal_np::number_of_iterations), 35); - bool require_uniform_sampling = choose_param(get_param(np, internal_np::require_uniform_sampling), false); - const cpp11::function& callback = choose_param(get_param(np, internal_np::callback), + PointMap point_map = choose_parameter(get_parameter(np, internal_np::point_map), PointMap()); + double select_percentage = choose_parameter(get_parameter(np, internal_np::select_percentage), 5.); + double radius = choose_parameter(get_parameter(np, internal_np::neighbor_radius), -1); + unsigned int iter_number = choose_parameter(get_parameter(np, internal_np::number_of_iterations), 35); + bool require_uniform_sampling = choose_parameter(get_parameter(np, internal_np::require_uniform_sampling), false); + const cpp11::function& callback = choose_parameter(get_parameter(np, internal_np::callback), cpp11::function()); typedef typename Kernel::Point_3 Point; diff --git a/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/bbox.h b/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/bbox.h index 0b471886c80..e79ddb723e9 100644 --- a/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/bbox.h +++ b/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/bbox.h @@ -66,14 +66,14 @@ namespace CGAL { CGAL::Bbox_3 bbox(const PolygonMesh& pmesh, const CGAL_PMP_NP_CLASS& np) { - using boost::choose_param; - using boost::get_param; + using parameters::choose_parameter; + using parameters::get_parameter; typename GetVertexPointMap::const_type - vpm = choose_param(get_param(np, internal_np::vertex_point), + vpm = choose_parameter(get_parameter(np, internal_np::vertex_point), get_const_property_map(CGAL::vertex_point, pmesh)); typedef typename GetGeomTraits::type GT; - GT gt = choose_param(get_param(np, internal_np::geom_traits), GT()); + GT gt = choose_parameter(get_parameter(np, internal_np::geom_traits), GT()); typename GT::Construct_bbox_3 get_bbox = gt.construct_bbox_3_object(); typedef typename boost::graph_traits::vertex_descriptor vertex_descriptor; @@ -116,14 +116,14 @@ namespace CGAL { const PolygonMesh& pmesh, const NamedParameters& np) { - using boost::choose_param; - using boost::get_param; + using parameters::choose_parameter; + using parameters::get_parameter; typename GetVertexPointMap::const_type - vpm = choose_param(get_param(np, internal_np::vertex_point), + vpm = choose_parameter(get_parameter(np, internal_np::vertex_point), get_const_property_map(CGAL::vertex_point, pmesh)); typedef typename GetGeomTraits::type GT; - GT gt = choose_param(get_param(np, internal_np::geom_traits), GT()); + GT gt = choose_parameter(get_parameter(np, internal_np::geom_traits), GT()); typename GT::Construct_bbox_3 get_bbox = gt.construct_bbox_3_object(); return get_bbox( get(vpm, vd) ); @@ -159,14 +159,14 @@ namespace CGAL { const PolygonMesh& pmesh, const NamedParameters& np) { - using boost::choose_param; - using boost::get_param; + using parameters::choose_parameter; + using parameters::get_parameter; typename GetVertexPointMap::const_type - vpm = choose_param(get_param(np, internal_np::vertex_point), + vpm = choose_parameter(get_parameter(np, internal_np::vertex_point), get_const_property_map(CGAL::vertex_point, pmesh)); typedef typename GetGeomTraits::type GT; - GT gt = choose_param(get_param(np, internal_np::geom_traits), GT()); + GT gt = choose_parameter(get_parameter(np, internal_np::geom_traits), GT()); typename GT::Construct_bbox_3 get_bbox = gt.construct_bbox_3_object(); return get_bbox( get(vpm, source(ed, pmesh)) ) + @@ -203,14 +203,14 @@ namespace CGAL { const PolygonMesh& pmesh, const NamedParameters& np) { - using boost::choose_param; - using boost::get_param; + using parameters::choose_parameter; + using parameters::get_parameter; typename GetVertexPointMap::const_type - vpm = choose_param(get_param(np, internal_np::vertex_point), + vpm = choose_parameter(get_parameter(np, internal_np::vertex_point), get_const_property_map(CGAL::vertex_point, pmesh)); typedef typename GetGeomTraits::type GT; - GT gt = choose_param(get_param(np, internal_np::geom_traits), GT()); + GT gt = choose_parameter(get_parameter(np, internal_np::geom_traits), GT()); typename GT::Construct_bbox_3 get_bbox = gt.construct_bbox_3_object(); typedef typename boost::graph_traits::halfedge_descriptor halfedge_descriptor; diff --git a/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/border.h b/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/border.h index 6c30cb6d077..33c244de776 100644 --- a/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/border.h +++ b/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/border.h @@ -200,8 +200,8 @@ namespace Polygon_mesh_processing { } //face index map given as a named parameter, or as an internal property map - FIMap fim = boost::choose_param(get_param(np, internal_np::face_index), - get_const_property_map(CGAL::face_index, pmesh)); + FIMap fim = parameters::choose_parameter(parameters::get_parameter(np, internal_np::face_index), + get_const_property_map(CGAL::face_index, pmesh)); return internal::border_halfedges_impl(faces, fim, out, pmesh, np); } diff --git a/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/clip.h b/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/clip.h index b1ae69fd22c..8f4988e1722 100644 --- a/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/clip.h +++ b/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/clip.h @@ -64,7 +64,7 @@ clip_open_impl( TriangleMesh& tm, // vector of clipper triangles Clipper_triangles clipper_triangles; clipper_triangles.reserve( num_faces(clipper) ); - Vpm vpm_c = boost::choose_param(boost::get_param(np_c, internal_np::vertex_point), + Vpm vpm_c = parameters::choose_parameter(parameters::get_parameter(np_c, internal_np::vertex_point), get_property_map(vertex_point, clipper)); BOOST_FOREACH(face_descriptor f, faces(clipper)) { @@ -94,9 +94,9 @@ clip_open_impl( TriangleMesh& tm, typedef typename GetFaceIndexMap::type Fid_map; - Fid_map fid_map = boost::choose_param(boost::get_param(np_tm, internal_np::face_index), + Fid_map fid_map = parameters::choose_parameter(parameters::get_parameter(np_tm, internal_np::face_index), get_property_map(boost::face_index, tm)); - Vpm vpm1 = boost::choose_param(boost::get_param(np_tm, internal_np::vertex_point), + Vpm vpm1 = parameters::choose_parameter(parameters::get_parameter(np_tm, internal_np::vertex_point), get_property_map(vertex_point, tm)); typedef CGAL::dynamic_vertex_property_t Vid_tag; @@ -150,7 +150,7 @@ clip_open_impl( TriangleMesh& tm, { // A patch with no vertex incident to a non-constrained edges // is a coplanar patch: drop it or keep it! - if (!boost::choose_param(boost::get_param(np_tm, internal_np::use_compact_clipper), true)) + if (!parameters::choose_parameter(parameters::get_parameter(np_tm, internal_np::use_compact_clipper), true)) { for (std::size_t cc_id = cc_not_handled.find_first(); cc_id < cc_not_handled.npos; @@ -201,7 +201,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)); @@ -451,7 +451,7 @@ clip( TriangleMesh& tm, const NamedParameters2& np_c) { const bool close = - 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 (close && 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 8a9d9847f7b..e10aaefac6f 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 @@ -132,14 +132,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; @@ -230,18 +230,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::face_descriptor s , FaceOutputIterator out , const NamedParameters& np) { - using boost::choose_param; - using boost::get_param; + using parameters::choose_parameter; + using parameters::get_parameter; - typedef typename boost::lookup_named_param_def < + typedef typename internal_np::Lookup_named_param_def < internal_np::edge_is_constrained_t, NamedParameters, internal::No_constraint//default > ::type EdgeConstraintMap; EdgeConstraintMap ecmap - = choose_param(get_param(np, internal_np::edge_is_constrained), + = choose_parameter(get_parameter(np, internal_np::edge_is_constrained), internal::No_constraint()); typedef typename boost::graph_traits::face_descriptor face_descriptor; @@ -213,16 +213,16 @@ connected_components(const PolygonMesh& pmesh, FaceComponentMap fcm, const NamedParameters& np) { - using boost::choose_param; - using boost::get_param; + using parameters::choose_parameter; + using parameters::get_parameter; - typedef typename boost::lookup_named_param_def < + typedef typename internal_np::Lookup_named_param_def < internal_np::edge_is_constrained_t, NamedParameters, internal::No_constraint//default > ::type EdgeConstraintMap; EdgeConstraintMap ecmap - = choose_param(get_param(np, internal_np::edge_is_constrained), + = choose_parameter(get_parameter(np, internal_np::edge_is_constrained), internal::No_constraint()); typedef Dual Dual; @@ -234,7 +234,7 @@ connected_components(const PolygonMesh& pmesh, internal::No_border(pmesh, ecmap)); typename GetFaceIndexMap::const_type - fimap = choose_param(get_param(np, internal_np::face_index), + fimap = choose_parameter(get_parameter(np, internal_np::face_index), get_const_property_map(boost::face_index, pmesh)); return boost::connected_components(finite_dual, @@ -296,12 +296,12 @@ std::size_t keep_largest_connected_components(PolygonMesh& pmesh typedef PolygonMesh PM; typedef typename boost::graph_traits::face_descriptor face_descriptor; - using boost::choose_param; - using boost::get_param; + using parameters::choose_parameter; + using parameters::get_parameter; //FaceIndexMap typedef typename GetFaceIndexMap::type FaceIndexMap; - FaceIndexMap fimap = choose_param(get_param(np, internal_np::face_index), + FaceIndexMap fimap = choose_parameter(get_parameter(np, internal_np::face_index), get_property_map(boost::face_index, pmesh)); //vector_property_map @@ -379,12 +379,12 @@ std::size_t keep_large_connected_components(PolygonMesh& pmesh typedef PolygonMesh PM; typedef typename boost::graph_traits::face_descriptor face_descriptor; - using boost::choose_param; - using boost::get_param; + using parameters::choose_parameter; + using parameters::get_parameter; //FaceIndexMap typedef typename GetFaceIndexMap::type FaceIndexMap; - FaceIndexMap fim = choose_param(get_param(np, internal_np::face_index), + FaceIndexMap fim = choose_parameter(get_parameter(np, internal_np::face_index), get_property_map(boost::face_index, pmesh)); //vector_property_map @@ -433,8 +433,8 @@ void keep_or_remove_connected_components(PolygonMesh& pmesh , const NamedParameters& np) { typedef PolygonMesh PM; - using boost::choose_param; - using boost::get_param; + using parameters::choose_parameter; + using parameters::get_parameter; typedef typename boost::graph_traits::face_descriptor face_descriptor; typedef typename boost::graph_traits::face_iterator face_iterator; @@ -446,7 +446,7 @@ void keep_or_remove_connected_components(PolygonMesh& pmesh //VertexIndexMap typedef typename GetVertexIndexMap::type VertexIndexMap; - VertexIndexMap vim = choose_param(get_param(np, internal_np::vertex_index), + VertexIndexMap vim = choose_parameter(get_parameter(np, internal_np::vertex_index), get_const_property_map(boost::vertex_index, pmesh)); std::set cc_to_keep; @@ -683,12 +683,12 @@ void remove_connected_components(PolygonMesh& pmesh if (components_to_remove.empty()) return; typedef PolygonMesh PM; typedef typename boost::graph_traits::face_descriptor face_descriptor; - using boost::choose_param; - using boost::get_param; + using parameters::choose_parameter; + using parameters::get_parameter; //FaceIndexMap typedef typename GetFaceIndexMap::type FaceIndexMap; - FaceIndexMap fim = choose_param(get_param(np, internal_np::face_index), + FaceIndexMap fim = choose_parameter(get_parameter(np, internal_np::face_index), get_property_map(boost::face_index, pmesh)); //vector_property_map @@ -741,12 +741,12 @@ void keep_connected_components(PolygonMesh& pmesh typedef PolygonMesh PM; typedef typename boost::graph_traits::face_descriptor face_descriptor; - using boost::choose_param; - using boost::get_param; + using parameters::choose_parameter; + using parameters::get_parameter; //FaceIndexMap typedef typename GetFaceIndexMap::type FaceIndexMap; - FaceIndexMap fim = choose_param(get_param(np, internal_np::face_index), + FaceIndexMap fim = choose_parameter(get_parameter(np, internal_np::face_index), get_property_map(boost::face_index, pmesh)); //vector_property_map diff --git a/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/corefinement.h b/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/corefinement.h index 20127c0e8fb..c889ad02f37 100644 --- a/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/corefinement.h +++ b/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/corefinement.h @@ -193,10 +193,10 @@ bool does_bound_a_volume(const TriangleMesh& tm, const NamedParameters& np) if (!is_closed(tm)) return false; if (!is_triangle_mesh(tm)) return false; - Vpm vpm = boost::choose_param(boost::get_param(np, internal_np::vertex_point), + Vpm vpm = parameters::choose_parameter(parameters::get_parameter(np, internal_np::vertex_point), get_const_property_map(boost::vertex_point, tm)); - Fid_map fid_map = boost::choose_param(boost::get_param(np, internal_np::face_index), + Fid_map fid_map = parameters::choose_parameter(parameters::get_parameter(np, internal_np::face_index), get_const_property_map(boost::face_index, tm)); std::vector face_cc(num_faces(tm), std::size_t(-1)); @@ -249,13 +249,13 @@ bool does_bound_a_volume(const TriangleMesh& tm) /// \endcond #define CGAL_COREF_SET_OUTPUT_EDGE_MARK_MAP(I) \ - typedef typename boost::lookup_named_param_def < \ + typedef typename internal_np::Lookup_named_param_def < \ internal_np::edge_is_constrained_t, \ NamedParametersOut##I, \ Corefinement::No_mark \ > ::type Ecm_out_##I; \ Ecm_out_##I ecm_out_##I = \ - boost::choose_param( boost::get_param(cpp11::get(nps_out), internal_np::edge_is_constrained), \ + parameters::choose_parameter( parameters::get_parameter(cpp11::get(nps_out), internal_np::edge_is_constrained), \ Corefinement::No_mark() ); @@ -361,7 +361,7 @@ corefine_and_compute_boolean_operations( NamedParametersOut3>& nps_out) { const bool throw_on_self_intersection = - boost::choose_param(boost::get_param(np1, internal_np::throw_on_self_intersection), false); + parameters::choose_parameter(parameters::get_parameter(np1, internal_np::throw_on_self_intersection), false); // Vertex point maps //for input meshes @@ -374,10 +374,10 @@ corefine_and_compute_boolean_operations( static const bool same_vpm = (boost::is_same::value); ) CGAL_static_assertion(same_vpm); - Vpm vpm1 = boost::choose_param(boost::get_param(np1, internal_np::vertex_point), + Vpm vpm1 = parameters::choose_parameter(parameters::get_parameter(np1, internal_np::vertex_point), get_property_map(boost::vertex_point, tm1)); - Vpm vpm2 = boost::choose_param(boost::get_param(np2, internal_np::vertex_point), + Vpm vpm2 = parameters::choose_parameter(parameters::get_parameter(np2, internal_np::vertex_point), get_property_map(boost::vertex_point, tm2)); typedef typename boost::property_traits::value_type Point_3; @@ -495,21 +495,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; @@ -534,17 +534,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 @@ -828,7 +828,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; @@ -874,12 +874,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 @@ -932,27 +932,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() ) ); @@ -1007,28 +1007,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 330e348277b..74af08bf617 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 @@ -147,11 +147,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; @@ -284,10 +284,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)); } @@ -363,7 +363,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 } @@ -438,7 +438,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 4f078731928..217f6e37f6e 100644 --- a/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/distance.h +++ b/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/distance.h @@ -341,32 +341,32 @@ sample_triangle_mesh(const TriangleMesh& tm, typedef typename GT::halfedge_descriptor halfedge_descriptor; typedef typename GT::edge_descriptor edge_descriptor; - using boost::choose_param; - using boost::get_param; - using boost::is_default_param; + using parameters::choose_parameter; + using parameters::get_parameter; + using parameters::is_default_parameter; - Vpm pmap = choose_param(get_param(np, internal_np::vertex_point), + Vpm pmap = choose_parameter(get_parameter(np, internal_np::vertex_point), get_const_property_map(vertex_point, tm)); typedef Creator_uniform_3 Creator; - Geom_traits geomtraits = choose_param(get_param(np, internal_np::geom_traits), Geom_traits()); + Geom_traits geomtraits = choose_parameter(get_parameter(np, internal_np::geom_traits), Geom_traits()); - bool use_rs = choose_param(get_param(np, internal_np::random_uniform_sampling), true); - bool use_gs = choose_param(get_param(np, internal_np::grid_sampling), false); - bool use_ms = choose_param(get_param(np, internal_np::monte_carlo_sampling), false); + bool use_rs = choose_parameter(get_parameter(np, internal_np::random_uniform_sampling), true); + bool use_gs = choose_parameter(get_parameter(np, internal_np::grid_sampling), false); + bool use_ms = choose_parameter(get_parameter(np, internal_np::monte_carlo_sampling), false); if (use_gs || use_ms) - if (is_default_param(get_param(np, internal_np::random_uniform_sampling))) + if (is_default_parameter(get_parameter(np, internal_np::random_uniform_sampling))) use_rs=false; - bool smpl_vrtcs = choose_param(get_param(np, internal_np::do_sample_vertices), true); - bool smpl_dgs = choose_param(get_param(np, internal_np::do_sample_edges), true); - bool smpl_fcs = choose_param(get_param(np, internal_np::do_sample_faces), true); + bool smpl_vrtcs = choose_parameter(get_parameter(np, internal_np::do_sample_vertices), true); + bool smpl_dgs = choose_parameter(get_parameter(np, internal_np::do_sample_edges), true); + bool smpl_fcs = choose_parameter(get_parameter(np, internal_np::do_sample_faces), true); - double nb_pts_a_u = choose_param(get_param(np, internal_np::nb_points_per_area_unit), 0.); - double nb_pts_l_u = choose_param(get_param(np, internal_np::nb_points_per_distance_unit), 0.); + double nb_pts_a_u = choose_parameter(get_parameter(np, internal_np::nb_points_per_area_unit), 0.); + double nb_pts_l_u = choose_parameter(get_parameter(np, internal_np::nb_points_per_distance_unit), 0.); // sample vertices if (smpl_vrtcs) @@ -381,7 +381,7 @@ sample_triangle_mesh(const TriangleMesh& tm, // grid sampling if (use_gs) { - double grid_spacing_ = choose_param(get_param(np, internal_np::grid_spacing), 0.); + double grid_spacing_ = choose_parameter(get_parameter(np, internal_np::grid_spacing), 0.); if (grid_spacing_==0.) { // set grid spacing to the shortest edge length @@ -408,9 +408,9 @@ sample_triangle_mesh(const TriangleMesh& tm, double min_edge_length = (std::numeric_limits::max)(); std::size_t nb_points_per_face = - choose_param(get_param(np, internal_np::number_of_points_per_face), 0); + choose_parameter(get_parameter(np, internal_np::number_of_points_per_face), 0); std::size_t nb_points_per_edge = - choose_param(get_param(np, internal_np::number_of_points_per_edge), 0); + choose_parameter(get_parameter(np, internal_np::number_of_points_per_edge), 0); if ((nb_points_per_face == 0 && nb_pts_a_u ==0.) || (nb_points_per_edge == 0 && nb_pts_l_u ==0.) ) @@ -489,7 +489,7 @@ sample_triangle_mesh(const TriangleMesh& tm, // sample faces if(smpl_fcs) { - std::size_t nb_points = choose_param(get_param(np, internal_np::number_of_points_on_faces), 0); + std::size_t nb_points = choose_parameter(get_parameter(np, internal_np::number_of_points_on_faces), 0); Random_points_in_triangle_mesh_3 g(tm, pmap); if (nb_points == 0) { @@ -505,7 +505,7 @@ sample_triangle_mesh(const TriangleMesh& tm, if (smpl_dgs) { std::size_t nb_points = - choose_param(get_param(np, internal_np::number_of_points_on_edges), 0); + choose_parameter(get_parameter(np, internal_np::number_of_points_on_edges), 0); Random_points_on_edge_list_graph_3 g(tm, pmap); if (nb_points == 0) { @@ -631,7 +631,7 @@ double approximate_Hausdorff_distance( const TriangleMesh& tm1, NamedParameters1>::type Geom_traits; return approximate_Hausdorff_distance( - tm1, tm2, np1, choose_param(get_param(np2, internal_np::vertex_point), + tm1, tm2, np1, parameters::choose_parameter(parameters::get_parameter(np2, internal_np::vertex_point), get_const_property_map(vertex_point, tm2))); } @@ -688,7 +688,7 @@ double max_distance_to_triangle_mesh(const PointRange& points, NamedParameters>::type Geom_traits; return approximate_Hausdorff_distance - (points,tm,choose_param(get_param(np, internal_np::vertex_point), + (points,tm,parameters::choose_parameter(parameters::get_parameter(np, internal_np::vertex_point), get_const_property_map(vertex_point, tm))); } @@ -735,8 +735,8 @@ double approximate_max_distance_to_point_set(const TriangleMesh& tm, typename GT::halfedge_descriptor hd(halfedge(f,tm)); for(int i=0; i<3; ++i) { - points[i] = get(choose_param(get_param(np, internal_np::vertex_point), - get_const_property_map(vertex_point, tm)), + points[i] = get(parameters::choose_parameter(parameters::get_parameter(np, internal_np::vertex_point), + get_const_property_map(vertex_point, tm)), target(hd, tm)); hd = next(hd, tm); } diff --git a/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/extrude.h b/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/extrude.h index aecf3c39b92..695f63e9de8 100644 --- a/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/extrude.h +++ b/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/extrude.h @@ -176,9 +176,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; @@ -269,7 +272,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 54019ea09c6..f8e01182c4c 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 212bf6e6191..e441688fb70 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 @@ -1070,7 +1070,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/intersection.h b/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/intersection.h index 2977cdaef06..f27a4a70382 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)); @@ -425,9 +425,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< @@ -453,7 +453,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( @@ -707,7 +707,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); @@ -1486,18 +1486,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(), @@ -1570,12 +1570,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; @@ -1593,7 +1593,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) @@ -1668,7 +1668,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; @@ -1679,12 +1679,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); @@ -1728,9 +1726,8 @@ surface_self_intersection(const TriangleMesh& tm, typedef typename GetVertexPointMap::const_type Vpm; - Vpm vpm = choose_const_pmap(get_param(np, internal_np::vertex_point), - tm, - vertex_point); + Vpm vpm = parameters::choose_parameter(parameters::get_parameter(np, internal_np::vertex_point), + get_const_property_map(CGAL::vertex_point, tm)); // surface intersection algorithm call typedef Corefinement::Default_surface_intersection_visitor::const_type - vpm = choose_param(get_param(np, internal_np::vertex_point), + vpm = choose_parameter(get_parameter(np, internal_np::vertex_point), get_const_property_map(CGAL::vertex_point, pmesh)); return CGAL::approximate_sqrt(CGAL::squared_distance(get(vpm, source(h, pmesh)), @@ -318,13 +318,13 @@ public: , const TriangleMesh& tmesh , const CGAL_PMP_NP_CLASS& np) { - using boost::choose_param; - using boost::get_param; + using parameters::choose_parameter; + using parameters::get_parameter; CGAL_precondition(boost::graph_traits::null_face() != f); typename GetVertexPointMap::const_type - vpm = choose_param(get_param(np, internal_np::vertex_point), + vpm = choose_parameter(get_parameter(np, internal_np::vertex_point), get_const_property_map(CGAL::vertex_point, tmesh)); typedef typename boost::graph_traits::halfedge_descriptor halfedge_descriptor; @@ -501,11 +501,11 @@ volume(const TriangleMesh& tmesh, const CGAL_PMP_NP_CLASS& np) CGAL_assertion(is_triangle_mesh(tmesh)); CGAL_assertion(is_closed(tmesh)); - using boost::choose_param; - using boost::get_param; + using parameters::choose_parameter; + using parameters::get_parameter; typename GetVertexPointMap::const_type - vpm = choose_param(get_param(np, internal_np::vertex_point), + vpm = choose_parameter(get_parameter(np, internal_np::vertex_point), get_const_property_map(CGAL::vertex_point, tmesh)); typename GetGeomTraits::type::Point_3 origin(0, 0, 0); diff --git a/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/orientation.h b/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/orientation.h index c2b32d54d63..486ba067c67 100644 --- a/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/orientation.h +++ b/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/orientation.h @@ -70,18 +70,18 @@ namespace internal{ const PolygonMesh& pmesh, const NamedParameters& np) { - using boost::choose_param; - using boost::get_param; + using parameters::choose_parameter; + using parameters::get_parameter; CGAL_assertion(halfedge(v_max, pmesh)!=boost::graph_traits::null_halfedge()); //VertexPointMap typedef typename GetVertexPointMap::const_type VPMap; - VPMap vpmap = choose_param(get_param(np, internal_np::vertex_point), + VPMap vpmap = choose_parameter(get_parameter(np, internal_np::vertex_point), get_const_property_map(vertex_point, pmesh)); //Kernel typedef typename GetGeomTraits::type GT; - GT gt = choose_param(get_param(np, internal_np::geom_traits), GT()); + GT gt = choose_parameter(get_parameter(np, internal_np::geom_traits), GT()); //among the incoming edges of `v_max`, find one edge `e` with the minimal slope typedef typename boost::graph_traits::halfedge_descriptor halfedge_descriptor; @@ -183,16 +183,16 @@ bool is_outward_oriented(const PolygonMesh& pmesh, if (faces(pmesh).first == faces(pmesh).second) return true; - using boost::choose_param; - using boost::get_param; + using parameters::choose_parameter; + using parameters::get_parameter; //VertexPointMap typedef typename GetVertexPointMap::const_type VPMap; - VPMap vpmap = choose_param(get_param(np, internal_np::vertex_point), + VPMap vpmap = choose_parameter(get_parameter(np, internal_np::vertex_point), get_const_property_map(vertex_point, pmesh)); //Kernel typedef typename GetGeomTraits::type GT; - GT gt = choose_param(get_param(np, internal_np::geom_traits), GT()); + GT gt = choose_parameter(get_parameter(np, internal_np::geom_traits), GT()); //find the vertex with maximal z coordinate internal::Compare_vertex_points_z_3 less_z(vpmap, gt); @@ -483,16 +483,16 @@ void orient(TriangleMesh& tm, const NamedParameters& np) CGAL_assertion(is_valid_polygon_mesh(tm)); CGAL_assertion(is_closed(tm)); - using boost::choose_param; - using boost::get_param; + using parameters::choose_parameter; + using parameters::get_parameter; - bool orient_outward = choose_param( - get_param(np, internal_np::outward_orientation),true); + bool orient_outward = choose_parameter( + get_parameter(np, internal_np::outward_orientation),true); - Vpm vpm = choose_param(get_param(np, internal_np::vertex_point), + Vpm vpm = choose_parameter(get_parameter(np, internal_np::vertex_point), get_const_property_map(boost::vertex_point, tm)); - Fid_map fid_map = choose_param(get_param(np, internal_np::face_index), + Fid_map fid_map = choose_parameter(get_parameter(np, internal_np::face_index), get_const_property_map(boost::face_index, tm)); std::vector face_cc(num_faces(tm), std::size_t(-1)); @@ -590,16 +590,16 @@ void orient_to_bound_a_volume(TriangleMesh& tm, if (!is_closed(tm)) return; if (!is_triangle_mesh(tm)) return; - using boost::choose_param; - using boost::get_param; + using parameters::choose_parameter; + using parameters::get_parameter; - bool orient_outward = choose_param( - get_param(np, internal_np::outward_orientation),true); + bool orient_outward = choose_parameter( + get_parameter(np, internal_np::outward_orientation),true); - Vpm vpm = choose_param(get_param(np, internal_np::vertex_point), + Vpm vpm = choose_parameter(get_parameter(np, internal_np::vertex_point), get_const_property_map(boost::vertex_point, tm)); - Fid_map fid_map = choose_param(get_param(np, internal_np::face_index), + Fid_map fid_map = choose_parameter(get_parameter(np, internal_np::face_index), get_const_property_map(boost::face_index, tm)); std::vector face_cc(num_faces(tm), std::size_t(-1)); diff --git a/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/random_perturbation.h b/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/random_perturbation.h index ea7362e1a95..868411e2428 100644 --- a/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/random_perturbation.h +++ b/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/random_perturbation.h @@ -151,8 +151,8 @@ void random_perturbation(VertexRange vertices , const NamedParameters& np) { typedef TriangleMesh PM; - using boost::get_param; - using boost::choose_param; + using parameters::get_parameter; + using parameters::choose_parameter; typedef typename boost::graph_traits::vertex_descriptor vertex_descriptor; @@ -165,22 +165,22 @@ void random_perturbation(VertexRange vertices #endif typedef typename GetGeomTraits::type GT; - GT gt = choose_param(get_param(np, internal_np::geom_traits), GT()); + GT gt = choose_parameter(get_parameter(np, internal_np::geom_traits), GT()); typedef typename GetVertexPointMap::type VPMap; - VPMap vpmap = choose_param(get_param(np, internal_np::vertex_point), + VPMap vpmap = choose_parameter(get_parameter(np, internal_np::vertex_point), get_property_map(vertex_point, tmesh)); - typedef typename boost::lookup_named_param_def < + typedef typename internal_np::Lookup_named_param_def < internal_np::vertex_is_constrained_t, NamedParameters, internal::No_constraint_pmap//default > ::type VCMap; - VCMap vcmap = choose_param(get_param(np, internal_np::vertex_is_constrained), + VCMap vcmap = choose_parameter(get_parameter(np, internal_np::vertex_is_constrained), internal::No_constraint_pmap()); - 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 d87cd651b6a..b2d06bcee5a 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,44 +160,44 @@ 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; 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, internal::No_constraint_pmap//default > ::type ECMap; - ECMap ecmap = choose_param(get_param(np, internal_np::edge_is_constrained) + ECMap ecmap = choose_parameter(get_parameter(np, internal_np::edge_is_constrained) , internal::No_constraint_pmap()); - typedef typename boost::lookup_named_param_def < + typedef typename internal_np::Lookup_named_param_def < internal_np::vertex_is_constrained_t, NamedParameters, internal::No_constraint_pmap//default > ::type VCMap; - VCMap vcmap = choose_param(get_param(np, internal_np::vertex_is_constrained), + VCMap vcmap = choose_parameter(get_parameter(np, internal_np::vertex_is_constrained), internal::No_constraint_pmap()); - 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 @@ -235,10 +235,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; @@ -259,8 +259,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 @@ -336,24 +336,24 @@ 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; 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, internal::No_constraint_pmap//default > ::type ECMap; - ECMap ecmap = choose_param(get_param(np, internal_np::edge_is_constrained), + ECMap ecmap = choose_parameter(get_parameter(np, internal_np::edge_is_constrained), internal::No_constraint_pmap()); typename internal::Incremental_remesher GT; @@ -383,10 +383,10 @@ std::size_t remove_null_edges( 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()); std::size_t nb_deg_faces = 0; @@ -699,8 +699,8 @@ std::size_t remove_degenerate_faces(TriangleMesh& tmesh, { CGAL_assertion(CGAL::is_triangle_mesh(tmesh)); - using boost::get_param; - using boost::choose_param; + using parameters::get_parameter; + using parameters::choose_parameter; typedef TriangleMesh TM; typedef typename boost::graph_traits GT; @@ -710,10 +710,10 @@ std::size_t remove_degenerate_faces(TriangleMesh& tmesh, typedef typename GT::vertex_descriptor vertex_descriptor; typedef typename GetVertexPointMap::type VertexPointMap; - VertexPointMap vpmap = choose_param(get_param(np, internal_np::vertex_point), + VertexPointMap vpmap = choose_parameter(get_parameter(np, internal_np::vertex_point), get_property_map(vertex_point, tmesh)); typedef typename GetGeomTraits::type Traits; - Traits traits = choose_param(get_param(np, internal_np::geom_traits), Traits()); + Traits traits = choose_parameter(get_parameter(np, internal_np::geom_traits), Traits()); typedef typename boost::property_traits::value_type Point_3; typedef typename boost::property_traits::reference Point_ref; @@ -1881,12 +1881,12 @@ bool remove_self_intersections(TriangleMesh& tm, const NamedParameters& np) // named parameter extraction typedef typename GetVertexPointMap::type VertexPointMap; - VertexPointMap vpm = boost::choose_param(boost::get_param(np, internal_np::vertex_point), + VertexPointMap vpm = parameters::choose_parameter(parameters::get_parameter(np, internal_np::vertex_point), get_property_map(vertex_point, tm)); - const int max_steps = boost::choose_param(boost::get_param(np, internal_np::number_of_iterations), 7); - bool verbose = boost::choose_param(boost::get_param(np, internal_np::verbosity_level), 0) > 0; - bool preserve_genus = boost::choose_param(boost::get_param(np, internal_np::preserve_genus), true); + const int max_steps = parameters::choose_parameter(parameters::get_parameter(np, internal_np::number_of_iterations), 7); + bool verbose = parameters::choose_parameter(parameters::get_parameter(np, internal_np::verbosity_level), 0) > 0; + bool preserve_genus = parameters::choose_parameter(parameters::get_parameter(np, internal_np::preserve_genus), true); if (verbose) std::cout << "DEBUG: Starting remove_self_intersections, is_valid(tm)? " << is_valid_polygon_mesh(tm) << "\n"; diff --git a/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/self_intersections.h b/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/self_intersections.h index 230870511b8..8a89cafb6d7 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 @@ -341,8 +341,8 @@ self_intersections( const FaceRange& face_range, ); typedef typename GetVertexPointMap::const_type VertexPointMap; - VertexPointMap vpmap = boost::choose_param(get_param(np, internal_np::vertex_point), - get_const_property_map(boost::vertex_point, tmesh)); + VertexPointMap vpmap = parameters::choose_parameter(parameters::get_parameter(np, internal_np::vertex_point), + get_const_property_map(boost::vertex_point, tmesh)); BOOST_FOREACH(face_descriptor f, face_range) { @@ -367,7 +367,7 @@ self_intersections( const FaceRange& face_range, typedef typename GetGeomTraits::type GeomTraits; CGAL::internal::Intersect_facets intersect_facets(tmesh, out, vpmap, - boost::choose_param(get_param(np, internal_np::geom_traits), GeomTraits())); + parameters::choose_parameter(parameters::get_parameter(np, internal_np::geom_traits), GeomTraits())); std::ptrdiff_t cutoff = 2000; CGAL::box_self_intersection_d(box_ptr.begin(), box_ptr.end(),intersect_facets,cutoff); diff --git a/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/stitch_borders.h b/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/stitch_borders.h index 17ee46b260b..b4ea510e6d8 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 @@ -177,14 +177,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); } @@ -591,8 +591,8 @@ template void stitch_borders(PolygonMesh& pmesh, const CGAL_PMP_NP_CLASS& np) { - using boost::choose_param; - using boost::get_param; + using parameters::choose_parameter; + using parameters::get_parameter; typedef typename boost::graph_traits::halfedge_descriptor halfedge_descriptor; std::vector< std::pair > hedge_pairs_to_stitch; typedef typename GetVertexPointMap::const_type VPMap; - VPMap vpm = choose_param(get_param(np, internal_np::vertex_point), + VPMap vpm = choose_parameter(get_parameter(np, internal_np::vertex_point), get_const_property_map(vertex_point, pmesh)); internal::collect_duplicated_stitchable_boundary_edges(pmesh, 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 efff419092c..00cda8a35e9 100644 --- a/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/transform.h +++ b/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/transform.h @@ -54,8 +54,8 @@ void transform(const Transformation& transformation, const NamedParameters& np) { typedef typename GetVertexPointMap::type VPMap; - VPMap vpm = choose_param(get_param(np, internal_np::vertex_point), - get_property_map(vertex_point, mesh)); + VPMap vpm = parameters::choose_parameter(parameters::get_parameter(np, internal_np::vertex_point), + get_property_map(vertex_point, mesh)); BOOST_FOREACH(typename boost::graph_traits::vertex_descriptor vd, vertices(mesh)) { diff --git a/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/triangulate_faces.h b/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/triangulate_faces.h index eab0c07aa06..282c491bd3a 100644 --- a/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/triangulate_faces.h +++ b/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/triangulate_faces.h @@ -431,20 +431,20 @@ bool triangulate_face(typename boost::graph_traits::face_descriptor PolygonMesh& pmesh, const NamedParameters& np) { - using boost::choose_param; - using boost::get_param; + using parameters::choose_parameter; + using parameters::get_parameter; //VertexPointMap typedef typename GetVertexPointMap::type VPMap; - VPMap vpmap = choose_param(get_param(np, internal_np::vertex_point), + VPMap vpmap = choose_parameter(get_parameter(np, internal_np::vertex_point), get_property_map(vertex_point, pmesh)); //Kernel typedef typename GetGeomTraits::type Kernel; - Kernel traits = choose_param(get_param(np, internal_np::geom_traits), Kernel()); + Kernel traits = choose_parameter(get_parameter(np, internal_np::geom_traits), Kernel()); //Option - bool use_cdt = choose_param(get_param(np, internal_np::use_delaunay_triangulation), true); + bool use_cdt = choose_parameter(get_parameter(np, internal_np::use_delaunay_triangulation), true); internal::Triangulate_modifier modifier(vpmap, traits); return modifier.triangulate_face(f, pmesh, use_cdt); @@ -486,20 +486,20 @@ bool triangulate_faces(FaceRange face_range, PolygonMesh& pmesh, const NamedParameters& np) { - using boost::choose_param; - using boost::get_param; + using parameters::choose_parameter; + using parameters::get_parameter; //VertexPointMap typedef typename GetVertexPointMap::type VPMap; - VPMap vpmap = choose_param(get_param(np, internal_np::vertex_point), + VPMap vpmap = choose_parameter(get_parameter(np, internal_np::vertex_point), get_property_map(vertex_point, pmesh)); //Kernel typedef typename GetGeomTraits::type Kernel; - Kernel traits = choose_param(get_param(np, internal_np::geom_traits), Kernel()); + Kernel traits = choose_parameter(get_parameter(np, internal_np::geom_traits), Kernel()); //Option - bool use_cdt = choose_param(get_param(np, internal_np::use_delaunay_triangulation), true); + bool use_cdt = choose_parameter(get_parameter(np, internal_np::use_delaunay_triangulation), true); internal::Triangulate_modifier modifier(vpmap, traits); return modifier(face_range, pmesh, use_cdt); diff --git a/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/triangulate_hole.h b/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/triangulate_hole.h index 24c2983604b..5b72abe0c9d 100644 --- a/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/triangulate_hole.h +++ b/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/triangulate_hole.h @@ -88,14 +88,14 @@ namespace Polygon_mesh_processing { OutputIterator out, const NamedParameters& np) { - using boost::choose_param; - using boost::get_param; + using parameters::choose_parameter; + using parameters::get_parameter; bool use_dt3 = #ifdef CGAL_HOLE_FILLING_DO_NOT_USE_DT3 false; #else - choose_param(get_param(np, internal_np::use_delaunay_triangulation), true); + choose_parameter(get_parameter(np, internal_np::use_delaunay_triangulation), true); #endif CGAL_precondition(face(border_halfedge, pmesh) == boost::graph_traits::null_face()); @@ -103,9 +103,9 @@ namespace Polygon_mesh_processing { return internal::triangulate_hole_polygon_mesh(pmesh, border_halfedge, out, - choose_param(get_param(np, internal_np::vertex_point), get_property_map(vertex_point, pmesh)), + choose_parameter(get_parameter(np, internal_np::vertex_point), get_property_map(vertex_point, pmesh)), use_dt3, - choose_param(get_param(np, internal_np::geom_traits), typename GetGeomTraits::type())) + choose_parameter(get_parameter(np, internal_np::geom_traits), typename GetGeomTraits::type())) .first; } @@ -333,14 +333,14 @@ namespace Polygon_mesh_processing { OutputIterator out, const NamedParameters& np) { - using boost::choose_param; - using boost::get_param; + using parameters::choose_parameter; + using parameters::get_parameter; bool use_dt3 = #ifdef CGAL_HOLE_FILLING_DO_NOT_USE_DT3 false; #else - choose_param(get_param(np, internal_np::use_delaunay_triangulation), true); + choose_parameter(get_parameter(np, internal_np::use_delaunay_triangulation), true); #endif typedef CGAL::internal::Weight_min_max_dihedral_and_area Weight; @@ -360,7 +360,7 @@ namespace Polygon_mesh_processing { triangulate_hole_polyline(points, third_points, tracer, WC(), use_dt3, - choose_param(get_param(np, internal_np::geom_traits), + choose_parameter(get_parameter(np, internal_np::geom_traits), typename CGAL::Kernel_traits::Kernel())); CGAL_assertion(holes.empty()); diff --git a/Polygon_mesh_processing/test/Polygon_mesh_processing/test_orient_cc.cpp b/Polygon_mesh_processing/test/Polygon_mesh_processing/test_orient_cc.cpp index 78e66369cbb..0dddec56099 100644 --- a/Polygon_mesh_processing/test/Polygon_mesh_processing/test_orient_cc.cpp +++ b/Polygon_mesh_processing/test/Polygon_mesh_processing/test_orient_cc.cpp @@ -22,11 +22,14 @@ bool test_orientation(TriangleMesh& tm, bool is_positive, const NamedParameters& typedef typename CGAL::Polygon_mesh_processing::GetFaceIndexMap::const_type Fid_map; - Vpm vpm = boost::choose_param(get_param(np, CGAL::internal_np::vertex_point), - CGAL::get_const_property_map(boost::vertex_point, tm)); + using CGAL::parameters::choose_parameter; + using CGAL::parameters::get_parameter; + + Vpm vpm = choose_parameter(get_parameter(np, CGAL::internal_np::vertex_point), + CGAL::get_const_property_map(boost::vertex_point, tm)); - Fid_map fid_map = boost::choose_param(get_param(np, CGAL::internal_np::face_index), - CGAL::get_const_property_map(boost::face_index, tm)); + Fid_map fid_map = choose_parameter(get_parameter(np, CGAL::internal_np::face_index), + CGAL::get_const_property_map(boost::face_index, tm)); std::vector face_cc(num_faces(tm), std::size_t(-1)); diff --git a/Polyhedron/demo/Polyhedron/Plugins/PMP/Inside_out_plugin.cpp b/Polyhedron/demo/Polyhedron/Plugins/PMP/Inside_out_plugin.cpp index aac56db2864..6b9ad96d183 100644 --- a/Polyhedron/demo/Polyhedron/Plugins/PMP/Inside_out_plugin.cpp +++ b/Polyhedron/demo/Polyhedron/Plugins/PMP/Inside_out_plugin.cpp @@ -137,9 +137,9 @@ void Polyhedron_demo_inside_out_plugin::on_actionOrientCC_triggered() Polyhedron* pMesh = poly_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); poly_item->invalidateOpenGLBuffers(); } } @@ -147,9 +147,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_IO/include/CGAL/IO/Polyhedron_iostream.h b/Polyhedron_IO/include/CGAL/IO/Polyhedron_iostream.h index e8173637eda..9d58faadf32 100644 --- a/Polyhedron_IO/include/CGAL/IO/Polyhedron_iostream.h +++ b/Polyhedron_IO/include/CGAL/IO/Polyhedron_iostream.h @@ -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/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 e144842f73a..26b55c5f67a 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 @@ -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 7d2235b1b73..51119a06f73 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 @@ -125,13 +125,13 @@ void CatmullClark_subdivision(PolygonMesh& pmesh, int step = 1) { **/ 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++) @@ -170,13 +170,13 @@ void Loop_subdivision(PolygonMesh& pmesh, int step = 1) { **/ 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++) @@ -215,13 +215,13 @@ void DooSabin_subdivision(PolygonMesh& pmesh, int step = 1) { **/ 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++) @@ -265,13 +265,13 @@ void Sqrt3_subdivision(PolygonMesh& pmesh, int step = 1) { **/ 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 1e49d913e9b..9eb49843597 100644 --- a/Surface_mesh/include/CGAL/Surface_mesh/Surface_mesh.h +++ b/Surface_mesh/include/CGAL/Surface_mesh/Surface_mesh.h @@ -2099,13 +2099,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; @@ -2190,8 +2193,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_simplification/include/CGAL/Surface_mesh_simplification/edge_collapse.h b/Surface_mesh_simplification/include/CGAL/Surface_mesh_simplification/edge_collapse.h index 09db7ab2890..38563ddbada 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 @@ -105,9 +105,8 @@ int edge_collapse ( TM& aSurface , cgal_bgl_named_params 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,13 +114,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_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()) ); } @@ -131,9 +130,8 @@ int edge_collapse ( TM& aSurface , cgal_bgl_named_params 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()) ); } From 03436594677322075efe26301d838af09b9e5f84 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?S=C3=A9bastien=20Loriot?= Date: Sun, 14 Jul 2019 22:46:46 +0200 Subject: [PATCH 2/7] add script to ease the update to the new CGAL np --- Scripts/developer_scripts/update_to_CGAL_np.sh | 15 +++++++++++++++ 1 file changed, 15 insertions(+) create mode 100644 Scripts/developer_scripts/update_to_CGAL_np.sh 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..16ee673181a --- /dev/null +++ b/Scripts/developer_scripts/update_to_CGAL_np.sh @@ -0,0 +1,15 @@ +#!/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 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 From 560c77f567ad1f51354bcf6266eff62aa2a95f5b Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?S=C3=A9bastien=20Loriot?= Date: Sun, 14 Jul 2019 22:54:16 +0200 Subject: [PATCH 3/7] rename named function parameter class --- .../include/CGAL/graph_traits_Arrangement_2.h | 2 +- .../CGAL/graph_traits_dual_arrangement_2.h | 2 +- ...aph_traits_dual_arrangement_on_surface_2.h | 2 +- ...al_arrangement_on_surface_with_history_2.h | 2 +- ...h_traits_dual_arrangement_with_history_2.h | 2 +- .../CGAL/boost/graph/Face_filtered_graph.h | 2 +- .../boost/graph/METIS/partition_dual_graph.h | 2 +- .../CGAL/boost/graph/METIS/partition_graph.h | 2 +- ...n_params.h => Named_function_parameters.h} | 34 +++++++++---------- .../CGAL/boost/graph/copy_face_graph.h | 8 ++--- .../boost/graph/dijkstra_shortest_paths.h | 2 +- .../CGAL/boost/graph/graph_traits_OpenMesh.h | 2 +- BGL/include/CGAL/boost/graph/io.h | 2 +- .../CGAL/boost/graph/named_params_helper.h | 6 ++-- BGL/test/BGL/test_cgal_bgl_named_params.cpp | 2 +- .../boost/graph/graph_traits_HalfedgeDS.h | 2 +- .../surface_mesh/IO_off.cpp | 2 +- Point_set_3/include/CGAL/Point_set_3.h | 14 ++++---- .../include/CGAL/IO/read_las_points.h | 2 +- .../include/CGAL/IO/read_off_points.h | 2 +- .../include/CGAL/IO/read_ply_points.h | 2 +- .../include/CGAL/IO/read_xyz_points.h | 2 +- .../include/CGAL/IO/write_ply_points.h | 2 +- .../include/CGAL/IO/write_xyz_points.h | 2 +- .../include/CGAL/bilateral_smooth_point_set.h | 2 +- .../include/CGAL/compute_average_spacing.h | 2 +- .../CGAL/edge_aware_upsample_point_set.h | 2 +- .../include/CGAL/estimate_scale.h | 2 +- .../include/CGAL/grid_simplify_point_set.h | 2 +- .../CGAL/hierarchy_simplify_point_set.h | 2 +- .../include/CGAL/jet_estimate_normals.h | 2 +- .../include/CGAL/jet_smooth_point_set.h | 2 +- .../include/CGAL/mst_orient_normals.h | 2 +- .../include/CGAL/pca_estimate_normals.h | 2 +- .../include/CGAL/random_simplify_point_set.h | 2 +- .../include/CGAL/remove_outliers.h | 2 +- .../include/CGAL/structure_point_set.h | 2 +- .../include/CGAL/vcm_estimate_normals.h | 2 +- .../wlop_simplify_and_regularize_point_set.h | 2 +- .../connected_components.h | 2 +- .../CGAL/Polygon_mesh_processing/extrude.h | 2 +- .../internal/named_function_params.h | 2 +- .../Polygon_mesh_processing/intersection.h | 2 +- .../self_intersections.h | 2 +- .../demo/Polyhedron/include/Point_set_3.h | 12 +++---- .../include/CGAL/IO/Polyhedron_iostream.h | 2 +- .../CGAL/IO/generic_print_polyhedron.h | 2 +- .../developer_scripts/update_to_CGAL_np.sh | 2 ++ .../subdivision_hosts_3.h | 2 +- .../subdivision_methods_3.h | 2 +- .../include/CGAL/Surface_mesh/Surface_mesh.h | 2 +- .../boost/graph/graph_traits_Surface_mesh.h | 2 +- .../Alpha_expansion_graph_cut.h | 2 +- .../edge_collapse.h | 6 ++-- ...its_Constrained_Delaunay_triangulation_2.h | 2 +- ...graph_traits_Constrained_triangulation_2.h | 2 +- ..._traits_Constrained_triangulation_plus_2.h | 2 +- .../graph_traits_Delaunay_triangulation_2.h | 2 +- .../graph_traits_Regular_triangulation_2.h | 2 +- .../graph/graph_traits_Triangulation_2.h | 2 +- ...ph_traits_Triangulation_data_structure_2.h | 2 +- .../graph_traits_Triangulation_hierarchy_2.h | 2 +- 62 files changed, 97 insertions(+), 95 deletions(-) rename BGL/include/CGAL/boost/graph/{named_function_params.h => Named_function_parameters.h} (84%) 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 b4fbdbdb4b2..cff29691149 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 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 c7f22c5831f..32e99bb34ff 100644 --- a/BGL/include/CGAL/boost/graph/METIS/partition_dual_graph.h +++ b/BGL/include/CGAL/boost/graph/METIS/partition_dual_graph.h @@ -26,7 +26,7 @@ #include #include #include -#include +#include #include #include diff --git a/BGL/include/CGAL/boost/graph/METIS/partition_graph.h b/BGL/include/CGAL/boost/graph/METIS/partition_graph.h index 5218268a4ba..48875922720 100644 --- a/BGL/include/CGAL/boost/graph/METIS/partition_graph.h +++ b/BGL/include/CGAL/boost/graph/METIS/partition_graph.h @@ -24,7 +24,7 @@ #include #include #include -#include +#include #include #include diff --git a/BGL/include/CGAL/boost/graph/named_function_params.h b/BGL/include/CGAL/boost/graph/Named_function_parameters.h similarity index 84% rename from BGL/include/CGAL/boost/graph/named_function_params.h rename to BGL/include/CGAL/boost/graph/Named_function_parameters.h index 90b3e0c9575..cd1527a68b0 100644 --- a/BGL/include/CGAL/boost/graph/named_function_params.h +++ b/BGL/include/CGAL/boost/graph/Named_function_parameters.h @@ -27,7 +27,7 @@ #include #define CGAL_BGL_NP_TEMPLATE_PARAMETERS T, typename Tag, typename Base -#define CGAL_BGL_NP_CLASS CGAL::cgal_bgl_named_params +#define CGAL_BGL_NP_CLASS CGAL::Named_function_parameters namespace CGAL { @@ -136,19 +136,19 @@ get_parameter_impl(const Named_params_impl& np, Query_tag tag) template -struct cgal_bgl_named_params +struct Named_function_parameters : internal_np::Named_params_impl { typedef internal_np::Named_params_impl base; - typedef cgal_bgl_named_params self; + typedef Named_function_parameters self; - cgal_bgl_named_params(T v = T()) : base(v) {} - cgal_bgl_named_params(T v, const Base& b) : base(v, b) {} + Named_function_parameters(T v = T()) : base(v) {} + Named_function_parameters(T v, const Base& b) : base(v, b) {} - cgal_bgl_named_params + Named_function_parameters all_default() const { - typedef cgal_bgl_named_params Params; + typedef Named_function_parameters Params; return Params(*this); } @@ -156,10 +156,10 @@ struct cgal_bgl_named_params // used to concatenate several parameters #define CGAL_add_named_parameter(X, Y, Z) \ template \ - cgal_bgl_named_params \ + Named_function_parameters \ Z(const K& k) const \ { \ - typedef cgal_bgl_named_params Params;\ + typedef Named_function_parameters Params;\ return Params(k, *this); \ } #include @@ -168,28 +168,28 @@ struct cgal_bgl_named_params namespace parameters { -cgal_bgl_named_params +Named_function_parameters inline all_default() { - typedef cgal_bgl_named_params Params; + typedef Named_function_parameters Params; return Params(); } template -cgal_bgl_named_params -inline no_parameters(cgal_bgl_named_params) +Named_function_parameters +inline no_parameters(Named_function_parameters) { - typedef cgal_bgl_named_params Params; + typedef Named_function_parameters Params; return Params(); } // define free functions for named parameters #define CGAL_add_named_parameter(X, Y, Z) \ template \ - cgal_bgl_named_params \ + Named_function_parameters \ Z(K const& p) \ { \ - typedef cgal_bgl_named_params Params;\ + typedef Named_function_parameters Params;\ return Params(p); \ } #include @@ -198,7 +198,7 @@ inline no_parameters(cgal_bgl_named_params) // function to extract a parameter template typename internal_np::Get_param, Query_tag>::type -get_parameter(const cgal_bgl_named_params& np, Query_tag tag) +get_parameter(const Named_function_parameters& np, Query_tag tag) { return internal_np::get_parameter_impl(static_cast&>(np), tag); } diff --git a/BGL/include/CGAL/boost/graph/copy_face_graph.h b/BGL/include/CGAL/boost/graph/copy_face_graph.h index 838d0ee5a0a..f221ba45ba6 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 @@ -328,8 +328,8 @@ 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 @@ -361,7 +361,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 431bf45455a..84c2551bb40 100644 --- a/BGL/include/CGAL/boost/graph/io.h +++ b/BGL/include/CGAL/boost/graph/io.h @@ -33,7 +33,7 @@ #include #include #include -#include +#include namespace CGAL { /*! diff --git a/BGL/include/CGAL/boost/graph/named_params_helper.h b/BGL/include/CGAL/boost/graph/named_params_helper.h index 712e0946da8..8c08af7a69e 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 @@ -146,7 +146,7 @@ namespace CGAL { }; template, + typename NamedParametersGT = Named_function_parameters, typename NamedParametersVPM = NamedParametersGT > class GetGeomTraits { @@ -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(); diff --git a/BGL/test/BGL/test_cgal_bgl_named_params.cpp b/BGL/test/BGL/test_cgal_bgl_named_params.cpp index 77a6549dca9..92226344997 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 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/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 659a84f5a01..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 =========================================================== diff --git a/Point_set_3/include/CGAL/Point_set_3.h b/Point_set_3/include/CGAL/Point_set_3.h index e93d857a58b..01c0ac7ea01 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 @@ -855,13 +855,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 @@ -1198,13 +1198,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/include/CGAL/IO/read_las_points.h b/Point_set_processing_3/include/CGAL/IO/read_las_points.h index 576c1a87cb8..3943d1e48ae 100644 --- a/Point_set_processing_3/include/CGAL/IO/read_las_points.h +++ b/Point_set_processing_3/include/CGAL/IO/read_las_points.h @@ -35,7 +35,7 @@ #include #include -#include +#include #include #include 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 e0486840f98..6a077e86a7a 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 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 30348fc9000..d80f3864fc1 100644 --- a/Point_set_processing_3/include/CGAL/IO/read_ply_points.h +++ b/Point_set_processing_3/include/CGAL/IO/read_ply_points.h @@ -36,7 +36,7 @@ #include #include -#include +#include #include #include 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 5ef24a364a5..aeb268b6f75 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 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 68e3b761f03..48a02e08977 100644 --- a/Point_set_processing_3/include/CGAL/IO/write_ply_points.h +++ b/Point_set_processing_3/include/CGAL/IO/write_ply_points.h @@ -35,7 +35,7 @@ #include #include -#include +#include #include #include 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 6c7554af64e..1841dce9929 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 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 8437688ef94..9076077818c 100644 --- a/Point_set_processing_3/include/CGAL/bilateral_smooth_point_set.h +++ b/Point_set_processing_3/include/CGAL/bilateral_smooth_point_set.h @@ -33,7 +33,7 @@ #include #include -#include +#include #include #include 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 78cced92c2d..72d3608ca07 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 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 f3d26015eac..ccabf21f918 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 diff --git a/Point_set_processing_3/include/CGAL/estimate_scale.h b/Point_set_processing_3/include/CGAL/estimate_scale.h index 86a858f6928..01846f2a2cb 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 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 69f2bcba033..e78762c5cd5 100644 --- a/Point_set_processing_3/include/CGAL/grid_simplify_point_set.h +++ b/Point_set_processing_3/include/CGAL/grid_simplify_point_set.h @@ -33,7 +33,7 @@ #include #include -#include +#include #include #include 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 82bbbb96bb6..b5d3de3ede9 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 { 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 eaa72b0c4e9..ebc66c1b24e 100644 --- a/Point_set_processing_3/include/CGAL/jet_estimate_normals.h +++ b/Point_set_processing_3/include/CGAL/jet_estimate_normals.h @@ -34,7 +34,7 @@ #include #include -#include +#include #include #include 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 2de27622ff5..d7a520285cc 100644 --- a/Point_set_processing_3/include/CGAL/jet_smooth_point_set.h +++ b/Point_set_processing_3/include/CGAL/jet_smooth_point_set.h @@ -33,7 +33,7 @@ #include #include -#include +#include #include #include 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 77d848ea239..1ce8b74bc4f 100644 --- a/Point_set_processing_3/include/CGAL/mst_orient_normals.h +++ b/Point_set_processing_3/include/CGAL/mst_orient_normals.h @@ -35,7 +35,7 @@ #include #include -#include +#include #include #include 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 220389d6118..ae1d11f05d8 100644 --- a/Point_set_processing_3/include/CGAL/pca_estimate_normals.h +++ b/Point_set_processing_3/include/CGAL/pca_estimate_normals.h @@ -35,7 +35,7 @@ #include #include -#include +#include #include #include 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 b8137129d57..353c2c16a62 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 77f2779dee5..dbd3dd54ba0 100644 --- a/Point_set_processing_3/include/CGAL/remove_outliers.h +++ b/Point_set_processing_3/include/CGAL/remove_outliers.h @@ -31,7 +31,7 @@ #include #include -#include +#include #include #include 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 7534d6d503d..be295e59d5d 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 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 8efb91adfbe..4d6d5f11159 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 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 7e78e9e1ed8..b00bc57961a 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 diff --git a/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/connected_components.h b/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/connected_components.h index 6fac483289b..35b6943731e 100644 --- a/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/connected_components.h +++ b/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/connected_components.h @@ -29,7 +29,7 @@ #include #include -#include +#include #include #include #include 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 695f63e9de8..16f2544fee7 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 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 f27a4a70382..1b575939b5e 100644 --- a/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/intersection.h +++ b/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/intersection.h @@ -1609,7 +1609,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); } 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 8a89cafb6d7..ae5df41a9fe 100644 --- a/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/self_intersections.h +++ b/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/self_intersections.h @@ -273,7 +273,7 @@ self_intersections(const TriangleMesh& tmesh #ifdef DOXYGEN_RUNNING , const NamedParameters& np) #else - , const cgal_bgl_named_params& np) + , const Named_function_parameters& np) #endif { return self_intersections(faces(tmesh), tmesh, out, np); diff --git a/Polyhedron/demo/Polyhedron/include/Point_set_3.h b/Polyhedron/demo/Polyhedron/include/Point_set_3.h index 8697f75c2cf..c616054544c 100644 --- a/Polyhedron/demo/Polyhedron/include/Point_set_3.h +++ b/Polyhedron/demo/Polyhedron/include/Point_set_3.h @@ -477,13 +477,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 @@ -570,13 +570,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 9d58faadf32..a0aad3117c6 100644 --- a/Polyhedron_IO/include/CGAL/IO/Polyhedron_iostream.h +++ b/Polyhedron_IO/include/CGAL/IO/Polyhedron_iostream.h @@ -29,7 +29,7 @@ #include #include #include -#include +#include #include namespace CGAL { diff --git a/Polyhedron_IO/include/CGAL/IO/generic_print_polyhedron.h b/Polyhedron_IO/include/CGAL/IO/generic_print_polyhedron.h index eae9c811ca0..3eb28ea1a5a 100644 --- a/Polyhedron_IO/include/CGAL/IO/generic_print_polyhedron.h +++ b/Polyhedron_IO/include/CGAL/IO/generic_print_polyhedron.h @@ -24,7 +24,7 @@ #include -#include +#include #include #include #include diff --git a/Scripts/developer_scripts/update_to_CGAL_np.sh b/Scripts/developer_scripts/update_to_CGAL_np.sh index 16ee673181a..5e437b461e3 100644 --- a/Scripts/developer_scripts/update_to_CGAL_np.sh +++ b/Scripts/developer_scripts/update_to_CGAL_np.sh @@ -5,6 +5,8 @@ ack -l --cpp boost::param_not_found | xargs sed -i 's/boost::param_not_found/int 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' 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 26b55c5f67a..cbd5379639c 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 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 51119a06f73..bd26f92897d 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 diff --git a/Surface_mesh/include/CGAL/Surface_mesh/Surface_mesh.h b/Surface_mesh/include/CGAL/Surface_mesh/Surface_mesh.h index 9eb49843597..def780ac178 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 { diff --git a/Surface_mesh/include/CGAL/boost/graph/graph_traits_Surface_mesh.h b/Surface_mesh/include/CGAL/boost/graph/graph_traits_Surface_mesh.h index f42cd99887e..34d6fdeaeca 100644 --- a/Surface_mesh/include/CGAL/boost/graph/graph_traits_Surface_mesh.h +++ b/Surface_mesh/include/CGAL/boost/graph/graph_traits_Surface_mesh.h @@ -26,7 +26,7 @@ #include // include this to avoid a VC15 warning -#include +#include #include #include diff --git a/Surface_mesh_segmentation/include/CGAL/internal/Surface_mesh_segmentation/Alpha_expansion_graph_cut.h b/Surface_mesh_segmentation/include/CGAL/internal/Surface_mesh_segmentation/Alpha_expansion_graph_cut.h index 17b8a2c53c8..bda22c32d48 100644 --- a/Surface_mesh_segmentation/include/CGAL/internal/Surface_mesh_segmentation/Alpha_expansion_graph_cut.h +++ b/Surface_mesh_segmentation/include/CGAL/internal/Surface_mesh_segmentation/Alpha_expansion_graph_cut.h @@ -47,7 +47,7 @@ #endif #include -#include +#include #include #ifdef CGAL_DO_NOT_USE_BOYKOV_KOLMOGOROV_MAXFLOW_SOFTWARE diff --git a/Surface_mesh_simplification/include/CGAL/Surface_mesh_simplification/edge_collapse.h b/Surface_mesh_simplification/include/CGAL/Surface_mesh_simplification/edge_collapse.h index 38563ddbada..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,7 +102,7 @@ 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 parameters::choose_parameter; @@ -127,7 +127,7 @@ int edge_collapse ( TM& aSurface template int edge_collapse ( TM& aSurface , ShouldStop const& aShould_stop - , cgal_bgl_named_params const& aParams + , Named_function_parameters const& aParams ) { using parameters::choose_parameter; diff --git a/Triangulation_2/include/CGAL/boost/graph/graph_traits_Constrained_Delaunay_triangulation_2.h b/Triangulation_2/include/CGAL/boost/graph/graph_traits_Constrained_Delaunay_triangulation_2.h index 9c9180d3135..af848b05868 100644 --- a/Triangulation_2/include/CGAL/boost/graph/graph_traits_Constrained_Delaunay_triangulation_2.h +++ b/Triangulation_2/include/CGAL/boost/graph/graph_traits_Constrained_Delaunay_triangulation_2.h @@ -22,7 +22,7 @@ #define CGAL_GRAPH_TRAITS_CONSTRAINED_DELAUNAY_TRIANGULATION_2_H // include this to avoid a VC15 warning -#include +#include #include #include diff --git a/Triangulation_2/include/CGAL/boost/graph/graph_traits_Constrained_triangulation_2.h b/Triangulation_2/include/CGAL/boost/graph/graph_traits_Constrained_triangulation_2.h index f235ef1e975..71c2595be71 100644 --- a/Triangulation_2/include/CGAL/boost/graph/graph_traits_Constrained_triangulation_2.h +++ b/Triangulation_2/include/CGAL/boost/graph/graph_traits_Constrained_triangulation_2.h @@ -22,7 +22,7 @@ #define CGAL_GRAPH_TRAITS_CONSTRAINED_TRIANGULATION_2_H // include this to avoid a VC15 warning -#include +#include #include #include diff --git a/Triangulation_2/include/CGAL/boost/graph/graph_traits_Constrained_triangulation_plus_2.h b/Triangulation_2/include/CGAL/boost/graph/graph_traits_Constrained_triangulation_plus_2.h index 5d35c80e748..86830b254e4 100644 --- a/Triangulation_2/include/CGAL/boost/graph/graph_traits_Constrained_triangulation_plus_2.h +++ b/Triangulation_2/include/CGAL/boost/graph/graph_traits_Constrained_triangulation_plus_2.h @@ -22,7 +22,7 @@ #define CGAL_GRAPH_TRAITS_CONSTRAINED_TRIANGULATION_PLUS_2_H // include this to avoid a VC15 warning -#include +#include #include #include diff --git a/Triangulation_2/include/CGAL/boost/graph/graph_traits_Delaunay_triangulation_2.h b/Triangulation_2/include/CGAL/boost/graph/graph_traits_Delaunay_triangulation_2.h index 4ce347b7e6f..868b4c365db 100644 --- a/Triangulation_2/include/CGAL/boost/graph/graph_traits_Delaunay_triangulation_2.h +++ b/Triangulation_2/include/CGAL/boost/graph/graph_traits_Delaunay_triangulation_2.h @@ -22,7 +22,7 @@ #define CGAL_GRAPH_TRAITS_DELAUNAY_TRIANGULATION_2_H // include this to avoid a VC15 warning -#include +#include #include #include diff --git a/Triangulation_2/include/CGAL/boost/graph/graph_traits_Regular_triangulation_2.h b/Triangulation_2/include/CGAL/boost/graph/graph_traits_Regular_triangulation_2.h index 6c5fc6c41c6..e2900ca5d3d 100644 --- a/Triangulation_2/include/CGAL/boost/graph/graph_traits_Regular_triangulation_2.h +++ b/Triangulation_2/include/CGAL/boost/graph/graph_traits_Regular_triangulation_2.h @@ -22,7 +22,7 @@ #define CGAL_GRAPH_TRAITS_REGULAR_TRIANGULATION_2_H // include this to avoid a VC15 warning -#include +#include #include #include diff --git a/Triangulation_2/include/CGAL/boost/graph/graph_traits_Triangulation_2.h b/Triangulation_2/include/CGAL/boost/graph/graph_traits_Triangulation_2.h index 0a901850a6d..9d5685647e0 100644 --- a/Triangulation_2/include/CGAL/boost/graph/graph_traits_Triangulation_2.h +++ b/Triangulation_2/include/CGAL/boost/graph/graph_traits_Triangulation_2.h @@ -24,7 +24,7 @@ #include // include this to avoid a VC15 warning -#include +#include #include #include #include diff --git a/Triangulation_2/include/CGAL/boost/graph/graph_traits_Triangulation_data_structure_2.h b/Triangulation_2/include/CGAL/boost/graph/graph_traits_Triangulation_data_structure_2.h index 4a79b2f69ef..fee7dcc69b2 100644 --- a/Triangulation_2/include/CGAL/boost/graph/graph_traits_Triangulation_data_structure_2.h +++ b/Triangulation_2/include/CGAL/boost/graph/graph_traits_Triangulation_data_structure_2.h @@ -24,7 +24,7 @@ #include // include this to avoid a VC15 warning -#include +#include #include #include diff --git a/Triangulation_2/include/CGAL/boost/graph/graph_traits_Triangulation_hierarchy_2.h b/Triangulation_2/include/CGAL/boost/graph/graph_traits_Triangulation_hierarchy_2.h index dd24d64a7ae..615b81d3640 100644 --- a/Triangulation_2/include/CGAL/boost/graph/graph_traits_Triangulation_hierarchy_2.h +++ b/Triangulation_2/include/CGAL/boost/graph/graph_traits_Triangulation_hierarchy_2.h @@ -22,7 +22,7 @@ #define CGAL_GRAPH_TRAITS_TRIANGULATION_HIERARCHY_2_H // include this to avoid a VC15 warning -#include +#include #include #include From adff92f8f872218a57c737d57150c0d402f3b366 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?S=C3=A9bastien=20Loriot?= Date: Mon, 15 Jul 2019 08:49:12 +0200 Subject: [PATCH 4/7] missing namespace --- .../CGAL/boost/graph/Face_filtered_graph.h | 18 +++++++++--------- 1 file changed, 9 insertions(+), 9 deletions(-) diff --git a/BGL/include/CGAL/boost/graph/Face_filtered_graph.h b/BGL/include/CGAL/boost/graph/Face_filtered_graph.h index cff29691149..90a12e4c34a 100644 --- a/BGL/include/CGAL/boost/graph/Face_filtered_graph.h +++ b/BGL/include/CGAL/boost/graph/Face_filtered_graph.h @@ -148,9 +148,9 @@ struct Face_filtered_graph #endif ) : _graph(const_cast(graph)) - , fimap(parameters::choose_parameter(get_parameter(np, internal_np::face_index), get_const_property_map(face_index, graph))) - , vimap(parameters::choose_parameter(get_parameter(np, internal_np::vertex_index), get_const_property_map(boost::vertex_index, graph))) - , himap(parameters::choose_parameter(get_parameter(np, internal_np::halfedge_index), get_const_property_map(halfedge_index, graph))) + , fimap(parameters::choose_parameter(parameters::get_parameter(np, internal_np::face_index), get_const_property_map(face_index, graph))) + , vimap(parameters::choose_parameter(parameters::get_parameter(np, internal_np::vertex_index), get_const_property_map(boost::vertex_index, graph))) + , himap(parameters::choose_parameter(parameters::get_parameter(np, internal_np::halfedge_index), get_const_property_map(halfedge_index, graph))) { set_selected_faces(selected_face_patch_indices, face_patch_index_map); } @@ -203,9 +203,9 @@ struct Face_filtered_graph const CGAL_BGL_NP_CLASS& np ) : _graph(const_cast(graph)) - , fimap(parameters::choose_parameter(get_parameter(np, internal_np::face_index), get_const_property_map(face_index, graph))) - , vimap(parameters::choose_parameter(get_parameter(np, internal_np::vertex_index), get_const_property_map(boost::vertex_index, graph))) - , himap(parameters::choose_parameter(get_parameter(np, internal_np::halfedge_index), get_const_property_map(halfedge_index, graph))) + , fimap(parameters::choose_parameter(parameters::get_parameter(np, internal_np::face_index), get_const_property_map(face_index, graph))) + , vimap(parameters::choose_parameter(parameters::get_parameter(np, internal_np::vertex_index), get_const_property_map(boost::vertex_index, graph))) + , himap(parameters::choose_parameter(parameters::get_parameter(np, internal_np::halfedge_index), get_const_property_map(halfedge_index, graph))) { set_selected_faces(selected_face_patch_index, face_patch_index_map); } @@ -248,9 +248,9 @@ struct Face_filtered_graph const FaceRange& selected_faces, const CGAL_BGL_NP_CLASS& np) : _graph(const_cast(graph)) - , fimap(parameters::choose_parameter(get_parameter(np, internal_np::face_index), get_const_property_map(face_index, graph))) - , vimap(parameters::choose_parameter(get_parameter(np, internal_np::vertex_index), get_const_property_map(boost::vertex_index, graph))) - , himap(parameters::choose_parameter(get_parameter(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); } From 4ca465a81fd36d26ce22711fdbca106a4637bc49 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?S=C3=A9bastien=20Loriot?= Date: Mon, 15 Jul 2019 10:49:24 +0200 Subject: [PATCH 5/7] try to please clang --- .../doc/Point_set_processing_3/Doxyfile.in | 4 +++- .../include/CGAL/compute_average_spacing.h | 15 ++++++++++----- 2 files changed, 13 insertions(+), 6 deletions(-) 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/compute_average_spacing.h b/Point_set_processing_3/include/CGAL/compute_average_spacing.h index 72d3608ca07..3e22a3abdc2 100644 --- a/Point_set_processing_3/include/CGAL/compute_average_spacing.h +++ b/Point_set_processing_3/include/CGAL/compute_average_spacing.h @@ -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,24 +189,24 @@ 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 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; From ae44cf3ff9a11ec247cac6c8478a6e74a43f0d8b Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Mael=20Rouxel-Labb=C3=A9?= Date: Tue, 23 Jul 2019 11:58:21 +0200 Subject: [PATCH 6/7] Do not return a const& for Named Parameters' default values Since 'd' is in general some default constructed value, things can get weird, for example with default constructed std::function --- BGL/include/CGAL/boost/graph/Named_function_parameters.h | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/BGL/include/CGAL/boost/graph/Named_function_parameters.h b/BGL/include/CGAL/boost/graph/Named_function_parameters.h index cd1527a68b0..055bfeebc36 100644 --- a/BGL/include/CGAL/boost/graph/Named_function_parameters.h +++ b/BGL/include/CGAL/boost/graph/Named_function_parameters.h @@ -204,8 +204,7 @@ get_parameter(const Named_function_parameters& np, Query_tag tag) } template -const D& -choose_parameter(const internal_np::Param_not_found&, const D& d) +D choose_parameter(const internal_np::Param_not_found&, const D& d) { return d; } From aa47744c366965317fda6f27f6fb640e64413300 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?S=C3=A9bastien=20Loriot?= Date: Sun, 28 Jul 2019 22:30:17 +0200 Subject: [PATCH 7/7] update the usage for the new CGAL named function parameters --- BGL/include/CGAL/boost/graph/io.h | 39 +++++++---- .../CGAL/boost/graph/named_params_helper.h | 4 +- .../CGAL/Polygon_mesh_processing/clip.h | 2 +- .../Polygon_mesh_processing/corefinement.h | 4 +- .../merge_border_vertices.h | 7 +- .../CGAL/Polygon_mesh_processing/remesh.h | 4 +- .../CGAL/Polygon_mesh_processing/repair.h | 18 +++--- .../repair_polygon_soup.h | 26 ++++---- .../shape_predicates.h | 32 +++++----- .../Polygon_mesh_processing/stitch_borders.h | 6 +- .../Rigid_triangle_mesh_collision_detection.h | 10 +-- .../approximate_triangle_mesh.h | 64 +++++++++---------- .../CGAL/Variational_shape_approximation.h | 56 ++++++++-------- 13 files changed, 143 insertions(+), 129 deletions(-) diff --git a/BGL/include/CGAL/boost/graph/io.h b/BGL/include/CGAL/boost/graph/io.h index fb89e6e3b0a..6b079f81c71 100644 --- a/BGL/include/CGAL/boost/graph/io.h +++ b/BGL/include/CGAL/boost/graph/io.h @@ -55,10 +55,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; @@ -148,7 +151,7 @@ bool write_off(std::ostream& os, typename Polygon_mesh_processing::GetVertexPointMap::const_type vpm = choose_parameter(get_parameter(np, internal_np::vertex_point), - get_const_property_map(CGAL::vertex_point, g)); + get_const_property_map(CGAL::vertex_point, g)); vertices_size_type nv = static_cast(std::distance(vertices(g).first, vertices(g).second)); faces_size_type nf = static_cast(std::distance(faces(g).first, faces(g).second)); @@ -273,7 +276,7 @@ bool read_off(std::istream& is, typedef typename boost::property_traits::value_type Point_3; Vpm vpm = choose_parameter(get_parameter(np, internal_np::vertex_point), - get_property_map(CGAL::vertex_point, g)); + get_property_map(CGAL::vertex_point, g)); vertices_size_type nv, nvf; faces_size_type nf; int ignore; @@ -379,7 +382,7 @@ bool write_inp(std::ostream& os, using parameters::get_parameter; VPM vpm = choose_parameter(get_parameter(np, internal_np::vertex_point), - get_const_property_map(CGAL::vertex_point, g)); + get_const_property_map(CGAL::vertex_point, g)); os << "*Part, name=" << name << "\n*Node\n"; boost::container::flat_map reindex; @@ -425,8 +428,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; @@ -460,8 +465,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\""; @@ -549,8 +556,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; @@ -592,8 +601,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; @@ -662,7 +673,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_params_helper.h b/BGL/include/CGAL/boost/graph/named_params_helper.h index be68585bec2..bf8c2c606da 100644 --- a/BGL/include/CGAL/boost/graph/named_params_helper.h +++ b/BGL/include/CGAL/boost/graph/named_params_helper.h @@ -331,7 +331,7 @@ namespace CGAL { >::Kernel Default_kernel; public: - typedef typename boost::lookup_named_param_def < + typedef typename internal_np::Lookup_named_param_def < internal_np::geom_traits_t, NamedParameters, Default_kernel @@ -421,7 +421,7 @@ namespace CGAL { public: typedef DummyConstrainedMap NoMap; - typedef typename boost::lookup_named_param_def < + typedef typename internal_np::Lookup_named_param_def < internal_np::point_is_constrained_t, NamedParameters, DummyConstrainedMap //default 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 269da38f7ba..3c3a5e84b10 100644 --- a/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/clip.h +++ b/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/clip.h @@ -334,7 +334,7 @@ clip( TriangleMesh& tm, const NamedParameters2& np_c) { const bool clip_volume = - boost::choose_parameter(boost::get_parameter(np_tm, internal_np::clip_volume), false); + parameters::choose_parameter(parameters::get_parameter(np_tm, internal_np::clip_volume), false); if (clip_volume && is_closed(tm)) return corefine_and_compute_intersection(tm, clipper, tm, np_tm, np_c); 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 4159605e3c8..1feeba75968 100644 --- a/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/corefinement.h +++ b/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/corefinement.h @@ -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); } 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 d4600321959..7ff7a73d84f 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/remesh.h b/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/remesh.h index a738cbaada0..62479ad4912 100644 --- a/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/remesh.h +++ b/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/remesh.h @@ -163,7 +163,7 @@ void isotropic_remeshing(const FaceRange& faces 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_parameter(get_parameter(np, internal_np::vertex_point), @@ -341,7 +341,7 @@ void split_long_edges(const EdgeRange& edges using parameters::get_parameter; typedef typename GetGeomTraits::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_parameter(get_parameter(np, internal_np::vertex_point), 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 381bbb94fe8..a34cc5db2e0 100644 --- a/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/repair.h +++ b/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/repair.h @@ -1784,18 +1784,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; @@ -1916,20 +1916,20 @@ template std::size_t duplicate_non_manifold_vertices(PolygonMesh& pm, const NamedParameters& np) { - using boost::get_param; - using boost::choose_param; + using parameters::get_parameter; + using parameters::choose_parameter; typedef boost::graph_traits GT; typedef typename GT::vertex_descriptor vertex_descriptor; typedef typename GT::halfedge_descriptor halfedge_descriptor; - typedef typename boost::lookup_named_param_def < + typedef typename internal_np::Lookup_named_param_def < internal_np::output_iterator_t, NamedParameters, Emptyset_iterator > ::type Output_iterator; Output_iterator out - = choose_param(get_param(np, internal_np::output_iterator), + = choose_parameter(get_parameter(np, internal_np::output_iterator), Emptyset_iterator()); internal::Vertex_collector dmap; 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 28f0719b11a..13b930afcb5 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 @@ -69,7 +69,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< @@ -517,11 +517,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; @@ -908,13 +908,13 @@ std::size_t merge_duplicate_polygons_in_polygon_soup(const PointRange& points, PolygonRange& polygons, const NamedParameters& np) { - using boost::get_param; - using boost::choose_param; + using parameters::get_parameter; + using parameters::choose_parameter; typedef typename internal::Polygon_types::P_ID P_ID; - const bool erase_all_duplicates = choose_param(get_param(np, internal_np::erase_all_duplicates), false); - const bool same_orientation = choose_param(get_param(np, internal_np::require_same_orientation), false); + const bool erase_all_duplicates = choose_parameter(get_parameter(np, internal_np::erase_all_duplicates), false); + const bool same_orientation = choose_parameter(get_parameter(np, internal_np::require_same_orientation), false); #ifdef CGAL_PMP_REPAIR_POLYGON_SOUP_VERBOSE_PP std::cout << "Only polygons with the same orientation are duplicates: " << std::boolalpha << same_orientation << std::endl; @@ -922,7 +922,7 @@ std::size_t merge_duplicate_polygons_in_polygon_soup(const PointRange& points, #endif typedef typename internal::GetPolygonGeomTraits::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); @@ -1065,11 +1065,11 @@ void repair_polygon_soup(PointRange& points, PolygonRange& polygons, const NamedParameters& np) { - using boost::get_param; - using boost::choose_param; + using parameters::get_parameter; + using parameters::choose_parameter; typedef typename internal::GetPolygonGeomTraits::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/shape_predicates.h b/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/shape_predicates.h index c1f0b7c040b..bd863a5109a 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 @@ -75,15 +75,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))); } @@ -128,15 +128,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); @@ -187,17 +187,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; @@ -289,18 +289,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 230e4c0659c..85e1334fc75 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 @@ -551,13 +551,13 @@ template std::size_t stitch_boundary_cycles(PolygonMesh& pm, const NamedParameters& np) { - using boost::choose_param; - using boost::get_param; + using parameters::choose_parameter; + using parameters::get_parameter; typedef typename boost::graph_traits::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::vector boundary_cycles; 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 71bc10f7f23..123080398a3 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/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 6d2f8c2ec0d..6dd715ff50a 100644 --- a/Surface_mesh_approximation/include/CGAL/Variational_shape_approximation.h +++ b/Surface_mesh_approximation/include/CGAL/Variational_shape_approximation.h @@ -45,7 +45,7 @@ #include #include -#include +#include #include #include @@ -323,17 +323,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) { @@ -798,14 +798,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); @@ -861,19 +861,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) ); } /*! @@ -897,7 +897,7 @@ public: /*! * @brief dummy function for named parameters. */ - void proxy_map(boost::param_not_found) const {} + void proxy_map(internal_np::Param_not_found) const {} /*! * @brief gets the face region of the specified proxy. @@ -929,7 +929,7 @@ public: /*! * @brief dummy function for named parameters. */ - void proxies(boost::param_not_found) const {} + void proxies(internal_np::Param_not_found) const {} /*! * @brief gets the wrapped proxies. @@ -956,7 +956,7 @@ public: /*! * @brief dummy function for named parameters. */ - void anchor_points(boost::param_not_found) const {} + void anchor_points(internal_np::Param_not_found) const {} /*! * @brief gets the anchor vertices. @@ -984,7 +984,7 @@ public: /*! * @brief dummy function for named parameters. */ - void indexed_triangles(boost::param_not_found) const {} + void indexed_triangles(internal_np::Param_not_found) const {} /*! * @brief gets the indexed boundary polygon approximation.
" ALIASES += "cgalNPEnd=