Merge pull request #4083 from sloriot/CGAL-named_function_parameters

Named function parameters

Arrangement_on_surface_2/include/CGAL/graph_traits_Arrangement_2.h

@@ -33,7 +33,7 @@
  */
 
 // include this to avoid a VC15 warning
-#include <CGAL/boost/graph/named_function_params.h>
+#include <CGAL/boost/graph/Named_function_parameters.h>
 
 #include <boost/graph/graph_concepts.hpp>
 #include <CGAL/boost/iterator/counting_iterator.hpp>

Arrangement_on_surface_2/include/CGAL/graph_traits_dual_arrangement_2.h

@@ -34,7 +34,7 @@
  */
 
 // include this to avoid a VC15 warning
-#include <CGAL/boost/graph/named_function_params.h>
+#include <CGAL/boost/graph/Named_function_parameters.h>
 
 #include <CGAL/Arrangement_2.h>
 #include <CGAL/Arrangement_2/graph_traits_dual.h>

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 <CGAL/boost/graph/named_function_params.h>
+#include <CGAL/boost/graph/Named_function_parameters.h>
 
 #include <CGAL/Arrangement_on_surface_2.h>
 #include <CGAL/Arrangement_2/graph_traits_dual.h>

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 <CGAL/boost/graph/named_function_params.h>
+#include <CGAL/boost/graph/Named_function_parameters.h>
 
 #include <CGAL/Arrangement_on_surface_with_history_2.h>
 #include <CGAL/Arrangement_2/graph_traits_dual.h>

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 <CGAL/boost/graph/named_function_params.h>
+#include <CGAL/boost/graph/Named_function_parameters.h>
 
 #include <CGAL/Arrangement_with_history_2.h>
 #include <CGAL/Arrangement_2/graph_traits_dual.h>

BGL/include/CGAL/boost/graph/Face_filtered_graph.h

@@ -24,7 +24,7 @@
 #include <CGAL/assertions.h>
 #include <CGAL/boost/graph/properties.h>
 #include <CGAL/boost/graph/iterator.h>
-#include <CGAL/boost/graph/named_function_params.h>
+#include <CGAL/boost/graph/Named_function_parameters.h>
 #include <CGAL/boost/graph/helpers.h>
 #include <CGAL/Dynamic_property_map.h>
 #include <CGAL/assertions.h>
@@ -148,9 +148,9 @@ struct Face_filtered_graph
                            #endif
                              )
     : _graph(const_cast<Graph&>(graph))
-    , fimap(boost::choose_param(get_param(np, internal_np::face_index), get_const_property_map(face_index, graph)))
+    , fimap(parameters::choose_parameter(parameters::get_parameter(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)))
+    , vimap(parameters::choose_parameter(parameters::get_parameter(np, internal_np::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)))
+    , 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&>(graph))
-    , fimap(boost::choose_param(get_param(np, internal_np::face_index), get_const_property_map(face_index, graph)))
+    , fimap(parameters::choose_parameter(parameters::get_parameter(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)))
+    , vimap(parameters::choose_parameter(parameters::get_parameter(np, internal_np::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)))
+    , 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&>(graph))
-    , fimap(boost::choose_param(get_param(np, internal_np::face_index), get_const_property_map(face_index, graph)))
+    , fimap(parameters::choose_parameter(parameters::get_parameter(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)))
+    , vimap(parameters::choose_parameter(parameters::get_parameter(np, internal_np::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)))
+    , himap(parameters::choose_parameter(parameters::get_parameter(np, internal_np::halfedge_index), get_const_property_map(halfedge_index, graph)))
   {
     set_selected_faces(selected_faces);
   }

BGL/include/CGAL/boost/graph/METIS/partition_dual_graph.h

@@ -26,7 +26,7 @@
 #include <CGAL/boost/graph/copy_face_graph.h>
 #include <CGAL/boost/graph/Face_filtered_graph.h>
 #include <CGAL/boost/graph/helpers.h>
-#include <CGAL/boost/graph/named_function_params.h>
+#include <CGAL/boost/graph/Named_function_parameters.h>
 #include <CGAL/boost/graph/named_params_helper.h>
 
 #include <CGAL/assertions.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 parameters::choose_parameter;
-  using boost::get_param;
+  using parameters::get_parameter;
 
   typedef typename boost::graph_traits<TriangleMesh>::vertex_descriptor   vertex_descriptor;
   typedef typename boost::graph_traits<TriangleMesh>::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<TriangleMesh, NamedParameters>::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<idx_t>(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));
+  vo(tm, indices, npart, get_parameter(np, internal_np::vertex_partition_id));
-  fo(tm, epart, get_param(np, internal_np::face_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<typename TriangleMesh, typename NamedParameters>
 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<typename TriangleMesh, typename NamedParameters>
 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<typename TriangleMesh>

BGL/include/CGAL/boost/graph/METIS/partition_graph.h

@@ -24,7 +24,7 @@
 #include <CGAL/boost/graph/copy_face_graph.h>
 #include <CGAL/boost/graph/Face_filtered_graph.h>
 #include <CGAL/boost/graph/helpers.h>
-#include <CGAL/boost/graph/named_function_params.h>
+#include <CGAL/boost/graph/Named_function_parameters.h>
 #include <CGAL/boost/graph/named_params_helper.h>
 
 #include <CGAL/assertions.h>
@@ -44,7 +44,7 @@ struct Output_vertex_partition_ids
 {
   template<typename TriangleMesh, typename Indices>
   void operator()(const TriangleMesh&, const Indices,
-                  idx_t const * const, boost::param_not_found) { }
+                  idx_t const * const, internal_np::Param_not_found) { }
 
   template<typename TriangleMesh,
            typename Indices,
@@ -64,7 +64,7 @@ struct Output_face_partition_ids
 {
   template<typename TriangleMesh>
   void operator()(const TriangleMesh&,
-                  idx_t const * const, boost::param_not_found) { }
+                  idx_t const * const, internal_np::Param_not_found) { }
 
   template<typename TriangleMesh, typename FacePartitionIDPmap>
   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 parameters::choose_parameter;
-  using boost::get_param;
+  using parameters::get_parameter;
 
   typedef typename boost::graph_traits<TriangleMesh>::vertex_descriptor   vertex_descriptor;
   typedef typename boost::graph_traits<TriangleMesh>::halfedge_descriptor halfedge_descriptor;
@@ -95,7 +95,7 @@ void partition_graph(const TriangleMesh& tm,
 
   //Vertex index map
   typedef typename CGAL::Polygon_mesh_processing::GetVertexIndexMap<TriangleMesh, NamedParameters>::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<idx_t>(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));
+  vo(tm, indices, npart, get_parameter(np, internal_np::vertex_partition_id));
-  fo(tm, epart, get_param(np, internal_np::face_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<typename TriangleMesh, typename NamedParameters>
 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<typename TriangleMesh, typename NamedParameters>
 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<typename TriangleMesh>

BGL/include/CGAL/boost/graph/Named_function_parameters.h

@@ -0,0 +1,237 @@
+// Copyright (c) 2019  GeometryFactory (France).  All rights reserved.
+//
+// This file is part of CGAL (www.cgal.org); you can redistribute it and/or
+// modify it under the terms of the GNU Lesser General Public License as
+// published by the Free Software Foundation; either version 3 of the License,
+// or (at your option) any later version.
+//
+// Licensees holding a valid commercial license may use this file in
+// accordance with the commercial license agreement provided with the software.
+//
+// This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
+// WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
+//
+// $URL$
+// $Id$
+// SPDX-License-Identifier: LGPL-3.0+
+//
+//
+// Author(s)     : Sebastien Loriot
+
+#ifndef CGAL_BOOST_GRAPH_NAMED_FUNCTION_PARAMS_H
+#define CGAL_BOOST_GRAPH_NAMED_FUNCTION_PARAMS_H
+
+#include <CGAL/basic.h>
+
+#include <boost/type_traits/is_same.hpp>
+#include <boost/mpl/if.hpp>
+
+#define CGAL_BGL_NP_TEMPLATE_PARAMETERS T, typename Tag, typename Base
+#define CGAL_BGL_NP_CLASS CGAL::Named_function_parameters<T,Tag,Base>
+
+
+namespace CGAL {
+namespace internal_np{
+
+struct No_property {};
+struct Param_not_found {};
+
+enum all_default_t { all_default };
+
+// define enum types and values for new named parameters
+#define CGAL_add_named_parameter(X, Y, Z)            \
+  enum X { Y };
+#include <CGAL/boost/graph/parameters_interface.h>
+#undef CGAL_add_named_parameter
+
+template <typename T, typename Tag, typename Base>
+struct Named_params_impl : Base
+{
+  T v; // copy of the parameter
+  Named_params_impl(T v, const Base& b)
+    : Base(b)
+    , v(v)
+  {}
+};
+
+// partial specialization for base class of the recursive nesting
+template <typename T, typename Tag>
+struct Named_params_impl<T, Tag, No_property>
+{
+  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 <typename NP, typename Query_tag>
+struct Get_param;
+
+template< typename T, typename Tag, typename Query_tag>
+struct Get_param< Named_params_impl<T, Tag, No_property>, Query_tag >
+{
+  typedef Param_not_found type;
+};
+
+template< typename T, typename Tag, typename Base>
+struct Get_param< Named_params_impl<T, Tag, Base>, Tag >
+{
+  typedef T type;
+};
+
+template< typename T, typename Tag>
+struct Get_param< Named_params_impl<T, Tag, No_property>, Tag >
+{
+  typedef T type;
+};
+
+
+template< typename T, typename Tag, typename Base, typename Query_tag>
+struct Get_param< Named_params_impl<T,Tag,Base>, Query_tag>
+{
+  typedef typename Get_param<typename Base::base, Query_tag>::type type;
+};
+
+// helper to choose the default
+template <typename Query_tag, typename NP, typename D>
+struct Lookup_named_param_def
+{
+  typedef typename internal_np::Get_param<typename NP::base, Query_tag>::type NP_type;
+
+  typedef typename boost::mpl::if_<
+    boost::is_same<NP_type, internal_np::Param_not_found>,
+    D, NP_type>::type
+  type;
+};
+
+// helper function to extract the value from a named parameter pack given a query tag
+template <typename T, typename Tag, typename Base>
+T get_parameter_impl(const Named_params_impl<T, Tag, Base>& np, Tag)
+{
+  return np.v;
+}
+
+template< typename T, typename Tag, typename Query_tag>
+Param_not_found get_parameter_impl(const Named_params_impl<T, Tag, No_property>&, Query_tag)
+{
+  return Param_not_found();
+}
+
+template< typename T, typename Tag>
+T get_parameter_impl(const Named_params_impl<T, Tag, No_property>& np, Tag)
+{
+  return np.v;
+};
+
+template <typename T, typename Tag, typename Base, typename Query_tag>
+typename Get_param<Named_params_impl<T, Tag, Base>, Query_tag>::type
+get_parameter_impl(const Named_params_impl<T, Tag, Base>& np, Query_tag tag)
+{
+  CGAL_static_assertion( (!boost::is_same<Query_tag, Tag>::value) );
+  return get_parameter_impl(static_cast<const typename Base::base&>(np), tag);
+}
+
+} // end of internal_np namespace
+
+
+template <typename T, typename Tag, typename Base = internal_np::No_property>
+struct Named_function_parameters
+  : internal_np::Named_params_impl<T, Tag, Base>
+{
+  typedef internal_np::Named_params_impl<T, Tag, Base> base;
+  typedef Named_function_parameters<T, Tag, Base> self;
+
+  Named_function_parameters(T v = T()) : base(v) {}
+  Named_function_parameters(T v, const Base& b) : base(v, b) {}
+
+  Named_function_parameters<bool, internal_np::all_default_t, self>
+  all_default() const
+  {
+    typedef Named_function_parameters<bool, internal_np::all_default_t, self> Params;
+    return Params(*this);
+  }
+
+// create the functions for new named parameters and the one imported boost
+// used to concatenate several parameters
+#define CGAL_add_named_parameter(X, Y, Z)                          \
+  template<typename K>                                           \
+  Named_function_parameters<K, internal_np::X, self>                  \
+  Z(const K& k) const                                            \
+  {                                                              \
+    typedef Named_function_parameters<K, internal_np::X, self> Params;\
+    return Params(k, *this);                                     \
+  }
+#include <CGAL/boost/graph/parameters_interface.h>
+#undef CGAL_add_named_parameter
+};
+
+namespace parameters {
+
+Named_function_parameters<bool, internal_np::all_default_t>
+inline all_default()
+{
+  typedef Named_function_parameters<bool, internal_np::all_default_t> Params;
+  return Params();
+}
+
+template <typename T, typename Tag, typename Base>
+Named_function_parameters<T,Tag,Base>
+inline no_parameters(Named_function_parameters<T,Tag,Base>)
+{
+  typedef Named_function_parameters<T,Tag,Base> Params;
+  return Params();
+}
+
+// define free functions for named parameters
+#define CGAL_add_named_parameter(X, Y, Z)        \
+  template <typename K>                        \
+  Named_function_parameters<K, internal_np::X>                  \
+  Z(K const& p)                                \
+  {                                            \
+    typedef Named_function_parameters<K, internal_np::X> Params;\
+    return Params(p);                          \
+  }
+#include <CGAL/boost/graph/parameters_interface.h>
+#undef CGAL_add_named_parameter
+
+// function to extract a parameter
+template <typename T, typename Tag, typename Base, typename Query_tag>
+typename internal_np::Get_param<internal_np::Named_params_impl<T, Tag, Base>, Query_tag>::type
+get_parameter(const Named_function_parameters<T, Tag, Base>& np, Query_tag tag)
+{
+  return internal_np::get_parameter_impl(static_cast<const internal_np::Named_params_impl<T, Tag, Base>&>(np), tag);
+}
+
+template <typename D>
+D choose_parameter(const internal_np::Param_not_found&, const D& d)
+{
+  return d;
+}
+
+template <typename T, typename D>
+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 <class T>
+bool is_default_parameter(const T&)
+{
+  return false;
+}
+
+} // end of parameters namespace
+
+} //namespace CGAL
+
+
+
+
+#endif // CGAL_BOOST_GRAPH_NAMED_FUNCTION_PARAMS_HPP

BGL/include/CGAL/boost/graph/boost_parameters_interface.h

@@ -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)

BGL/include/CGAL/boost/graph/copy_face_graph.h

@@ -29,7 +29,7 @@
 #include <CGAL/boost/graph/Euler_operations.h>
 #include <CGAL/boost/graph/iterator.h>
 #include <CGAL/boost/graph/helpers.h>
-#include <CGAL/boost/graph/named_function_params.h>
+#include <CGAL/boost/graph/Named_function_parameters.h>
 #include <CGAL/boost/graph/named_params_helper.h>
 #include <CGAL/property_map.h>
 #include <boost/unordered_map.hpp>
@@ -244,7 +244,7 @@ boost::function_output_iterator<Output_iterator_functor<PMAP> > make_functor(PMA
   return boost::make_function_output_iterator(Output_iterator_functor<PMAP>(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();
 }
@@ -328,26 +328,27 @@ template <typename SourceMesh, typename TargetMesh,
           >
 void copy_face_graph(const SourceMesh& sm, TargetMesh& tm,
                      #ifndef DOXYGEN_RUNNING
-                     const CGAL::cgal_bgl_named_params<T1,Tag1,Base1>& np1,
+                     const CGAL::Named_function_parameters<T1,Tag1,Base1>& np1,
-                     const CGAL::cgal_bgl_named_params<T2,Tag2,Base2>& np2
+                     const CGAL::Named_function_parameters<T2,Tag2,Base2>& np2
                      #else
                      const NamedParameters1& np1,
                      const NamedParameters2& np2
                      #endif
                      )
 {
-  using boost::choose_param;
+  using parameters::choose_parameter;
+  using parameters::get_parameter;
   internal::copy_face_graph(sm, tm,
                             CGAL::graph_has_property<SourceMesh,boost::halfedge_index_t>(),
-                            choose_param(get_param(np1, internal_np::vertex_to_vertex_output_iterator),
+                            choose_parameter(get_parameter(np1, internal_np::vertex_to_vertex_output_iterator),
-                                         impl::make_functor(get_param(np1, internal_np::vertex_to_vertex_map))),
+                                         impl::make_functor(get_parameter(np1, internal_np::vertex_to_vertex_map))),
-                            choose_param(get_param(np1, internal_np::halfedge_to_halfedge_output_iterator),
+                            choose_parameter(get_parameter(np1, internal_np::halfedge_to_halfedge_output_iterator),
-                                         impl::make_functor(get_param(np1, internal_np::halfedge_to_halfedge_map))),
+                                         impl::make_functor(get_parameter(np1, internal_np::halfedge_to_halfedge_map))),
-                            choose_param(get_param(np1, internal_np::face_to_face_output_iterator),
+                            choose_parameter(get_parameter(np1, internal_np::face_to_face_output_iterator),
-                                         impl::make_functor(get_param(np1, internal_np::face_to_face_map))),
+                                         impl::make_functor(get_parameter(np1, internal_np::face_to_face_map))),
-                            choose_param(get_param(np1, internal_np::vertex_point),
+                            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)));
 }
 
@@ -360,7 +361,7 @@ void copy_face_graph(const SourceMesh& sm, TargetMesh& tm)
 template <typename SourceMesh, typename TargetMesh, 
           typename T, typename Tag, typename Base >
 void copy_face_graph(const SourceMesh& sm, TargetMesh& tm, 
-                     const CGAL::cgal_bgl_named_params<T,Tag,Base>& np)
+                     const CGAL::Named_function_parameters<T,Tag,Base>& np)
 {
   copy_face_graph(sm, tm, np, parameters::all_default());
 }

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 <CGAL/boost/graph/named_function_params.h>
+#include <CGAL/boost/graph/Named_function_parameters.h>
 
 #include <boost/version.hpp>
 #include <climits>

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 <CGAL/boost/graph/named_function_params.h>
+#include <CGAL/boost/graph/Named_function_parameters.h>
 
 #include <boost/graph/graph_traits.hpp>
 #include <boost/graph/properties.hpp>

BGL/include/CGAL/boost/graph/io.h

@@ -33,7 +33,7 @@
 #include <CGAL/boost/graph/Euler_operations.h>
 #include <CGAL/boost/graph/helpers.h>
 #include <CGAL/boost/graph/named_params_helper.h>
-#include <CGAL/boost/graph/named_function_params.h>
+#include <CGAL/boost/graph/Named_function_parameters.h>
 
 namespace CGAL {
 /*!
@@ -59,8 +59,11 @@ bool write_off(std::ostream& os,
   typedef typename boost::graph_traits<FaceGraph>::vertices_size_type vertices_size_type;
   typedef typename boost::graph_traits<FaceGraph>::faces_size_type faces_size_type;
 
+  using parameters::choose_parameter;
+  using parameters::get_parameter;
+  
   typename Polygon_mesh_processing::GetVertexPointMap<FaceGraph, 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, g));
   vertices_size_type nv = static_cast<vertices_size_type>(std::distance(vertices(g).first, vertices(g).second));
   faces_size_type nf = static_cast<faces_size_type>(std::distance(faces(g).first, faces(g).second));
@@ -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<FaceGraph>::vertex_descriptor vertex_descriptor;
   typedef typename boost::graph_traits<FaceGraph>::vertices_size_type vertices_size_type;
@@ -183,7 +188,7 @@ bool read_off(std::istream& is,
   typedef typename Polygon_mesh_processing::GetVertexPointMap<FaceGraph, NamedParameters>::type Vpm;
   typedef  typename boost::property_traits<Vpm>::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<FaceGraph, NamedParameters>::const_type VPM;
   typedef typename boost::property_traits<VPM>::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";

BGL/include/CGAL/boost/graph/named_function_params.h

@@ -1,205 +0,0 @@
-//=======================================================================
-// Copyright 1997, 1998, 1999, 2000 University of Notre Dame.
-// Authors: Andrew Lumsdaine, Lie-Quan Lee, Jeremy G. Siek
-//
-// This file is part of the Boost Graph Library
-//
-// Distributed under the Boost Software License, Version 1.0. (See
-// accompanying file LICENSE_1_0.txt or copy at
-// http://www.boost.org/LICENSE_1_0.txt)
-//=======================================================================
-// Copyright (c) 2007  GeometryFactory (France).  All rights reserved.
-//
-// $URL$
-// $Id$
-// SPDX-License-Identifier: BSL-1.0
-//
-// Author(s)     : Andreas Fabri, Fernando Cacciola
-
-#ifndef CGAL_BOOST_GRAPH_NAMED_FUNCTION_PARAMS_H
-#define CGAL_BOOST_GRAPH_NAMED_FUNCTION_PARAMS_H
-
-#include <CGAL/disable_warnings.h>
-
-#include <CGAL/basic.h>
-
-#include <CGAL/boost/graph/properties.h>
-#if defined(BOOST_MSVC)
-#  pragma warning(push)
-#  pragma warning(disable:4172) // returning address of local variable or temporary
-#endif
-
-#include <boost/graph/named_function_params.hpp>
-
-#if defined(BOOST_MSVC)
-#  pragma warning(pop)
-#endif
-
-
-#include <boost/type_traits/is_same.hpp>
-#include <boost/version.hpp>
-
-// 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 <typename Tag, typename Args, typename Def>
-  struct lookup_named_param_def {
-    typedef Def type;
-    static const Def& get(const Args&, const Def& def) {return def;}
-  };
-
-  template <typename T, typename Tag, typename Base, typename Def>
-  struct lookup_named_param_def<Tag, bgl_named_params<T, Tag, Base>, Def> {
-    typedef T type;
-    static const type& get(const bgl_named_params<T, Tag, Base>& p, const Def&) {
-      return p.m_value;
-    }
-  };
-
-  template <typename Tag1, typename T, typename Tag, typename Base, typename Def>
-  struct lookup_named_param_def<Tag1, bgl_named_params<T, Tag, Base>, Def> {
-    typedef typename lookup_named_param_def<Tag1, Base, Def>::type type;
-    static const type& get(const bgl_named_params<T, Tag, Base>& p, const Def& def) {
-      return lookup_named_param_def<Tag1, Base, Def>::get(p.m_base, def);
-    }
-  };
-} //end of namespace boost
-#endif
-
-#define CGAL_BGL_NP_TEMPLATE_PARAMETERS T, typename Tag, typename Base
-#define CGAL_BGL_NP_CLASS CGAL::cgal_bgl_named_params<T,Tag,Base>
-
-namespace CGAL {
-namespace internal_np{
-enum all_default_t { all_default }; //cannot use macro because it takes no argument
-
-// for uniformity we import them in this namespace. Note that
-// it is an import so that if we use the named parameter function
-// from boost it will work
-using boost::vertex_index_t;
-using boost::vertex_index;
-using boost::graph_visitor_t;
-using boost::graph_visitor;
-
-// define enum types and values for new named parameters
-#define CGAL_add_named_parameter(X, Y, Z)            \
-  enum X { Y };
-#include <CGAL/boost/graph/parameters_interface.h>
-#undef CGAL_add_named_parameter
-
-}//internal_np
-
-  template <typename T, typename Tag, typename Base = boost::no_property>
-  struct cgal_bgl_named_params : boost::bgl_named_params<T, Tag, Base>
-  {
-    typedef boost::bgl_named_params<T, Tag, Base> 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<bool, internal_np::all_default_t, self>
-    all_default() const
-    {
-      typedef cgal_bgl_named_params<bool, internal_np::all_default_t, self> Params;
-      return Params(*this);
-    }
-
-// create the functions for new named parameters and the one imported boost
-// used to concatenate several parameters
-#define CGAL_add_named_parameter(X, Y, Z)                          \
-  template<typename K>                                           \
-  cgal_bgl_named_params<K, internal_np::X, self>                  \
-  Z(const K& k) const                                            \
-  {                                                              \
-    typedef cgal_bgl_named_params<K, internal_np::X, self> Params;\
-    return Params(k, *this);                                     \
-  }
-#include <CGAL/boost/graph/parameters_interface.h>
-#include <CGAL/boost/graph/boost_parameters_interface.h>
-#undef CGAL_add_named_parameter
-  };
-
-namespace parameters {
-
-  cgal_bgl_named_params<bool, internal_np::all_default_t>
-  inline all_default()
-  {
-    typedef cgal_bgl_named_params<bool, internal_np::all_default_t> Params;
-    return Params();
-  }
-
-
-  template <typename T, typename Tag, typename Base>
-  cgal_bgl_named_params<T,Tag,Base>
-  inline no_parameters(cgal_bgl_named_params<T,Tag,Base>)
-  {
-    typedef cgal_bgl_named_params<T,Tag,Base> Params;
-    return Params();
-  }
-
-// define free functions for named parameters
-#define CGAL_add_named_parameter(X, Y, Z)        \
-  template <typename K>                        \
-  cgal_bgl_named_params<K, internal_np::X>                  \
-  Z(K const& p)                                \
-  {                                            \
-    typedef cgal_bgl_named_params<K, internal_np::X> Params;\
-    return Params(p);                          \
-  }
-#include <CGAL/boost/graph/parameters_interface.h>
-#include <CGAL/boost/graph/boost_parameters_interface.h>
-#undef CGAL_add_named_parameter
-
-  } // namespace parameters
-
-} //namespace CGAL
-
-// partial specializations hate inheritance and we need to repeat
-// those here. this is rather fragile.
-namespace boost {
-
-#if BOOST_VERSION < 105100
-template <class Tag1, class Tag2, class T1, class Base>
-inline
-typename property_value< CGAL::cgal_bgl_named_params<T1,Tag1,Base>, Tag2>::type
-get_param(const CGAL::cgal_bgl_named_params<T1,Tag1,Base>& p, Tag2 tag2)
-{
-  enum { match = detail::same_property<Tag1,Tag2>::value };
-  typedef typename
-    boost::property_value< CGAL::cgal_bgl_named_params<T1,Tag1,Base>, Tag2>::type T2;
-  T2* t2 = 0;
-  typedef detail::property_value_dispatch<match> Dispatcher;
-  return Dispatcher::const_get_value(p, t2, tag2);
-}
-#endif
-
-
-template <typename T, typename Tag, typename Base, typename Def>
-struct lookup_named_param_def<Tag, CGAL::cgal_bgl_named_params<T, Tag, Base>, Def> {
-  typedef T type;
-  static const type& get(const bgl_named_params<T, Tag, Base>& p, const Def&) {
-    return p.m_value;
-  }
-};
-
-template <typename Tag1, typename T, typename Tag, typename Base, typename Def>
-struct lookup_named_param_def<Tag1, CGAL::cgal_bgl_named_params<T, Tag, Base>, Def> {
-  typedef typename lookup_named_param_def<Tag1, Base, Def>::type type;
-  static const type& get(const bgl_named_params<T, Tag, Base>& p, const Def& def) {
-    return lookup_named_param_def<Tag1, Base, Def>::get(p.m_base, def);
-  }
-};
-} // boost
-
-#include <CGAL/enable_warnings.h>
-
-#endif // CGAL_BOOST_GRAPH_NAMED_FUNCTION_PARAMS_HPP

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 <CGAL/boost/graph/named_function_params.h>
+#include <CGAL/boost/graph/Named_function_parameters.h>
 
 #include <CGAL/Kernel_traits.h>
 #include <CGAL/Origin.h>
@@ -30,7 +30,7 @@
 #include <boost/mpl/has_xxx.hpp>
 
 #include <boost/type_traits/is_same.hpp>
-#include <boost/version.hpp>
+
 
 namespace CGAL {
 
@@ -123,12 +123,12 @@ namespace CGAL {
     typedef typename property_map_selector<PolygonMesh, boost::vertex_point_t>::type
     DefaultVPMap;
   public:
-    typedef typename boost::lookup_named_param_def<
+    typedef typename internal_np::Lookup_named_param_def<
     internal_np::vertex_point_t,
     NamedParameters,
     DefaultVPMap
     > ::type  type;
-    typedef typename boost::lookup_named_param_def<
+    typedef typename internal_np::Lookup_named_param_def<
       internal_np::vertex_point_t,
       NamedParameters,
       DefaultVPMap_const
@@ -146,28 +146,28 @@ namespace CGAL {
   };
 
   template<typename PolygonMesh,
-           typename NamedParametersGT = cgal_bgl_named_params<bool, internal_np::all_default_t>,
+           typename NamedParametersGT = Named_function_parameters<bool, internal_np::all_default_t>,
            typename NamedParametersVPM = NamedParametersGT >
   class GetGeomTraits
   {
     typedef typename CGAL::graph_has_property<PolygonMesh, boost::vertex_point_t>::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<boost::param_not_found, NP_vpm>::value
+    typedef typename boost::mpl::if_c< Has_internal_pmap::value || !boost::is_same<internal_np::Param_not_found, NP_vpm>::value
                                      , typename GetK<PolygonMesh, NamedParametersVPM>::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<PolygonMesh, boost::face_index_t>::type DefaultMap;
     typedef typename property_map_selector<PolygonMesh, boost::face_index_t>::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<PolygonMesh, boost::vertex_index_t>::type DefaultMap;
   public:
-    typedef typename boost::lookup_named_param_def <
+    typedef typename internal_np::Lookup_named_param_def <
     internal_np::vertex_index_t,
     NamedParameters,
     DefaultMap
@@ -222,7 +222,7 @@ namespace CGAL {
 
   public:
     typedef DummyNormalPmap NoMap;
-    typedef typename boost::lookup_named_param_def <
+    typedef typename internal_np::Lookup_named_param_def <
       internal_np::face_normal_t,
       NamedParameters,
       DummyNormalPmap//default
@@ -249,7 +249,7 @@ namespace CGAL {
     namespace parameters
     {
       template <typename PointRange>
-      cgal_bgl_named_params<bool, internal_np::all_default_t>
+      Named_function_parameters<bool, internal_np::all_default_t>
       inline all_default(const PointRange&)
       {
         return CGAL::parameters::all_default();
@@ -268,13 +268,13 @@ namespace CGAL {
       typedef typename CGAL::Identity_property_map<Point> 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<Point> 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<Plane> 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<FT, dim>
@@ -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)

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)

BGL/test/BGL/test_cgal_bgl_named_params.cpp

@@ -1,4 +1,4 @@
-#include <CGAL/boost/graph/named_function_params.h>
+#include <CGAL/boost/graph/Named_function_parameters.h>
 #include <CGAL/assertions.h>
 #include <boost/type_traits/is_same.hpp>
 
@@ -22,161 +22,157 @@ void check_same_type(T)
 template<class NamedParameters>
 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_parameter(np, CGAL::internal_np::vertex_index).v == 0);
-  assert(get_param(np, CGAL::internal_np::halfedge_index).v == 3);
+  assert(get_parameter(np, CGAL::internal_np::graph_visitor).v == 1);
-  assert(get_param(np, CGAL::internal_np::edge_index).v == 4);
+  assert(get_parameter(np, CGAL::internal_np::vertex_point).v == 2);
-  assert(get_param(np, CGAL::internal_np::face_index).v == 5);
+  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_parameter(np, CGAL::internal_np::edge_is_constrained).v == 6);
-  assert(get_param(np, CGAL::internal_np::first_index).v == 7);
+  assert(get_parameter(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::number_of_iterations).v == 8);
 
-  assert(get_param(np, CGAL::internal_np::METIS_options).v == 800000001);
+  assert(get_parameter(np, CGAL::internal_np::METIS_options).v == 800000001);
-  assert(get_param(np, CGAL::internal_np::vertex_partition_id).v == 800000002);
+  assert(get_parameter(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::face_partition_id).v == 800000003);
   
-  assert(get_param(np, CGAL::internal_np::vertex_to_vertex_output_iterator).v == 800000004);
+  assert(get_parameter(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_parameter(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::face_to_face_output_iterator).v == 800000006);
   
-  assert(get_param(np, CGAL::internal_np::vertex_to_vertex_map).v == 800000007);
+  assert(get_parameter(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_parameter(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::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_parameter(np, CGAL::internal_np::geom_traits).v == 10);
-  assert(get_param(np, CGAL::internal_np::vertex_incident_patches).v == 11);
+  assert(get_parameter(np, CGAL::internal_np::vertex_incident_patches).v == 11);
-  assert(get_param(np, CGAL::internal_np::density_control_factor).v == 12);
+  assert(get_parameter(np, CGAL::internal_np::density_control_factor).v == 12);
-  assert(get_param(np, CGAL::internal_np::use_delaunay_triangulation).v == 13);
+  assert(get_parameter(np, CGAL::internal_np::use_delaunay_triangulation).v == 13);
-  assert(get_param(np, CGAL::internal_np::fairing_continuity).v == 14);
+  assert(get_parameter(np, CGAL::internal_np::fairing_continuity).v == 14);
-  assert(get_param(np, CGAL::internal_np::sparse_linear_solver).v == 15);
+  assert(get_parameter(np, CGAL::internal_np::sparse_linear_solver).v == 15);
-  assert(get_param(np, CGAL::internal_np::number_of_relaxation_steps).v == 16);
+  assert(get_parameter(np, CGAL::internal_np::number_of_relaxation_steps).v == 16);
-  assert(get_param(np, CGAL::internal_np::protect_constraints).v == 17);
+  assert(get_parameter(np, CGAL::internal_np::protect_constraints).v == 17);
-  assert(get_param(np, CGAL::internal_np::relax_constraints).v == 18);
+  assert(get_parameter(np, CGAL::internal_np::relax_constraints).v == 18);
-  assert(get_param(np, CGAL::internal_np::collapse_constraints).v == 43);
+  assert(get_parameter(np, CGAL::internal_np::collapse_constraints).v == 43);
-  assert(get_param(np, CGAL::internal_np::vertex_is_constrained).v == 19);
+  assert(get_parameter(np, CGAL::internal_np::vertex_is_constrained).v == 19);
-  assert(get_param(np, CGAL::internal_np::face_patch).v == 20);
+  assert(get_parameter(np, CGAL::internal_np::face_patch).v == 20);
-  assert(get_param(np, CGAL::internal_np::random_uniform_sampling).v == 21);
+  assert(get_parameter(np, CGAL::internal_np::random_uniform_sampling).v == 21);
-  assert(get_param(np, CGAL::internal_np::grid_sampling).v == 22);
+  assert(get_parameter(np, CGAL::internal_np::grid_sampling).v == 22);
-  assert(get_param(np, CGAL::internal_np::monte_carlo_sampling).v == 23);
+  assert(get_parameter(np, CGAL::internal_np::monte_carlo_sampling).v == 23);
-  assert(get_param(np, CGAL::internal_np::do_sample_edges).v == 24);
+  assert(get_parameter(np, CGAL::internal_np::do_sample_edges).v == 24);
-  assert(get_param(np, CGAL::internal_np::do_sample_vertices).v == 25);
+  assert(get_parameter(np, CGAL::internal_np::do_sample_vertices).v == 25);
-  assert(get_param(np, CGAL::internal_np::do_sample_faces).v == 26);
+  assert(get_parameter(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_parameter(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_parameter(np, CGAL::internal_np::number_of_points_per_face).v == 28);
-  assert(get_param(np, CGAL::internal_np::grid_spacing).v == 29);
+  assert(get_parameter(np, CGAL::internal_np::grid_spacing).v == 29);
-  assert(get_param(np, CGAL::internal_np::number_of_points_per_edge).v == 30);
+  assert(get_parameter(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_parameter(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_parameter(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_parameter(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_parameter(np, CGAL::internal_np::throw_on_self_intersection).v == 43);
-  assert(get_param(np, CGAL::internal_np::clip_volume).v == 44);
+  assert(get_parameter(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::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_parameter(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_placement_policy).v == 35);
 
     // To-be-documented named parameters
-  assert(get_param(np, CGAL::internal_np::face_normal).v == 36);
+  assert(get_parameter(np, CGAL::internal_np::face_normal).v == 36);
-  assert(get_param(np, CGAL::internal_np::random_seed).v == 37);
+  assert(get_parameter(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::do_project).v == 38);
 
     // Internal named parameters
-  assert(get_param(np, CGAL::internal_np::weight_calculator).v == 39);
+  assert(get_parameter(np, CGAL::internal_np::weight_calculator).v == 39);
-  assert(get_param(np, CGAL::internal_np::preserve_genus).v == 40);
+  assert(get_parameter(np, CGAL::internal_np::preserve_genus).v == 40);
-  assert(get_param(np, CGAL::internal_np::verbosity_level).v == 41);
+  assert(get_parameter(np, CGAL::internal_np::verbosity_level).v == 41);
-  assert(get_param(np, CGAL::internal_np::projection_functor).v == 42);
+  assert(get_parameter(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::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<0>(get_parameter(np, CGAL::internal_np::vertex_index));
-  check_same_type<3>(get_param(np, CGAL::internal_np::halfedge_index));
+  check_same_type<1>(get_parameter(np, CGAL::internal_np::graph_visitor));
-  check_same_type<4>(get_param(np, CGAL::internal_np::edge_index));
+  check_same_type<2>(get_parameter(np, CGAL::internal_np::vertex_point));
-  check_same_type<5>(get_param(np, CGAL::internal_np::face_index));
+  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<6>(get_parameter(np, CGAL::internal_np::edge_is_constrained));
-  check_same_type<7>(get_param(np, CGAL::internal_np::first_index));
+  check_same_type<7>(get_parameter(np, CGAL::internal_np::first_index));
-  check_same_type<8>(get_param(np, CGAL::internal_np::number_of_iterations));
+  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<800000001>(get_parameter(np, CGAL::internal_np::METIS_options));
-  check_same_type<800000002>(get_param(np, CGAL::internal_np::vertex_partition_id));
+  check_same_type<800000002>(get_parameter(np, CGAL::internal_np::vertex_partition_id));
-  check_same_type<800000003>(get_param(np, CGAL::internal_np::face_partition_id));
+  check_same_type<800000003>(get_parameter(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<800000004>(get_parameter(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<800000005>(get_parameter(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<800000006>(get_parameter(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<800000007>(get_parameter(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<800000008>(get_parameter(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<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<10>(get_parameter(np, CGAL::internal_np::geom_traits));
-  check_same_type<11>(get_param(np, CGAL::internal_np::vertex_incident_patches));
+  check_same_type<11>(get_parameter(np, CGAL::internal_np::vertex_incident_patches));
-  check_same_type<12>(get_param(np, CGAL::internal_np::density_control_factor));
+  check_same_type<12>(get_parameter(np, CGAL::internal_np::density_control_factor));
-  check_same_type<13>(get_param(np, CGAL::internal_np::use_delaunay_triangulation));
+  check_same_type<13>(get_parameter(np, CGAL::internal_np::use_delaunay_triangulation));
-  check_same_type<14>(get_param(np, CGAL::internal_np::fairing_continuity));
+  check_same_type<14>(get_parameter(np, CGAL::internal_np::fairing_continuity));
-  check_same_type<15>(get_param(np, CGAL::internal_np::sparse_linear_solver));
+  check_same_type<15>(get_parameter(np, CGAL::internal_np::sparse_linear_solver));
-  check_same_type<16>(get_param(np, CGAL::internal_np::number_of_relaxation_steps));
+  check_same_type<16>(get_parameter(np, CGAL::internal_np::number_of_relaxation_steps));
-  check_same_type<17>(get_param(np, CGAL::internal_np::protect_constraints));
+  check_same_type<17>(get_parameter(np, CGAL::internal_np::protect_constraints));
-  check_same_type<18>(get_param(np, CGAL::internal_np::relax_constraints));
+  check_same_type<18>(get_parameter(np, CGAL::internal_np::relax_constraints));
-  check_same_type<43>(get_param(np, CGAL::internal_np::collapse_constraints));
+  check_same_type<43>(get_parameter(np, CGAL::internal_np::collapse_constraints));
-  check_same_type<19>(get_param(np, CGAL::internal_np::vertex_is_constrained));
+  check_same_type<19>(get_parameter(np, CGAL::internal_np::vertex_is_constrained));
-  check_same_type<20>(get_param(np, CGAL::internal_np::face_patch));
+  check_same_type<20>(get_parameter(np, CGAL::internal_np::face_patch));
-  check_same_type<21>(get_param(np, CGAL::internal_np::random_uniform_sampling));
+  check_same_type<21>(get_parameter(np, CGAL::internal_np::random_uniform_sampling));
-  check_same_type<22>(get_param(np, CGAL::internal_np::grid_sampling));
+  check_same_type<22>(get_parameter(np, CGAL::internal_np::grid_sampling));
-  check_same_type<23>(get_param(np, CGAL::internal_np::monte_carlo_sampling));
+  check_same_type<23>(get_parameter(np, CGAL::internal_np::monte_carlo_sampling));
-  check_same_type<24>(get_param(np, CGAL::internal_np::do_sample_edges));
+  check_same_type<24>(get_parameter(np, CGAL::internal_np::do_sample_edges));
-  check_same_type<25>(get_param(np, CGAL::internal_np::do_sample_vertices));
+  check_same_type<25>(get_parameter(np, CGAL::internal_np::do_sample_vertices));
-  check_same_type<26>(get_param(np, CGAL::internal_np::do_sample_faces));
+  check_same_type<26>(get_parameter(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<27>(get_parameter(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<28>(get_parameter(np, CGAL::internal_np::number_of_points_per_face));
-  check_same_type<29>(get_param(np, CGAL::internal_np::grid_spacing));
+  check_same_type<29>(get_parameter(np, CGAL::internal_np::grid_spacing));
-  check_same_type<30>(get_param(np, CGAL::internal_np::number_of_points_per_edge));
+  check_same_type<30>(get_parameter(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<31>(get_parameter(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<32>(get_parameter(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<33>(get_parameter(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<43>(get_parameter(np, CGAL::internal_np::throw_on_self_intersection));
-  check_same_type<44>(get_param(np, CGAL::internal_np::clip_volume));
+  check_same_type<44>(get_parameter(np, CGAL::internal_np::clip_volume));
-  check_same_type<45>(get_param(np, CGAL::internal_np::use_compact_clipper));
+  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<34>(get_parameter(np, CGAL::internal_np::get_cost_policy));
-  check_same_type<35>(get_param(np, CGAL::internal_np::get_placement_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<36>(get_parameter(np, CGAL::internal_np::face_normal));
-  check_same_type<37>(get_param(np, CGAL::internal_np::random_seed));
+  check_same_type<37>(get_parameter(np, CGAL::internal_np::random_seed));
-  check_same_type<38>(get_param(np, CGAL::internal_np::do_project));
+  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<39>(get_parameter(np, CGAL::internal_np::weight_calculator));
-  check_same_type<40>(get_param(np, CGAL::internal_np::preserve_genus));
+  check_same_type<40>(get_parameter(np, CGAL::internal_np::preserve_genus));
-  check_same_type<41>(get_param(np, CGAL::internal_np::verbosity_level));
+  check_same_type<41>(get_parameter(np, CGAL::internal_np::verbosity_level));
-  check_same_type<42>(get_param(np, CGAL::internal_np::projection_functor));
+  check_same_type<42>(get_parameter(np, CGAL::internal_np::projection_functor));
-  check_same_type<46>(get_param(np, CGAL::internal_np::apply_per_connected_component));
+  check_same_type<46>(get_parameter(np, CGAL::internal_np::apply_per_connected_component));
 }
 
 int main()

Classification/include/CGAL/Classification/classify.h

@@ -27,6 +27,7 @@
 #include <CGAL/internal/Surface_mesh_segmentation/Alpha_expansion_graph_cut.h>
 #include <CGAL/Bbox_3.h>
 #include <CGAL/Classification/Label_set.h>
+#include <CGAL/property_map.h>
 
 #ifdef CGAL_LINKED_WITH_TBB
 #include <tbb/parallel_for.h>

HalfedgeDS/include/CGAL/boost/graph/graph_traits_HalfedgeDS.h

@@ -24,7 +24,7 @@
 #include <functional>
 
 // include this to avoid a VC15 warning
-#include <CGAL/boost/graph/named_function_params.h>
+#include <CGAL/boost/graph/Named_function_parameters.h>
 
 #include <boost/config.hpp>
 #include <boost/iterator/iterator_adaptor.hpp>

HalfedgeDS/include/CGAL/boost/graph/graph_traits_HalfedgeDS_default.h

@@ -22,6 +22,7 @@
 #define CGAL_GRAPH_TRAITS_HALFEDGEDS_DEFAULT_H
 
 #include <CGAL/boost/graph/graph_traits_HalfedgeDS.h>
+#include <CGAL/boost/graph/properties.h>
 #include <CGAL/Iterator_range.h>
 #include <CGAL/HalfedgeDS_decorator.h>
 #include <CGAL/HalfedgeDS_default.h>

Linear_cell_complex/benchmark/Linear_cell_complex_2/surface_mesh/IO_off.cpp

@@ -24,7 +24,7 @@
 
 #include "IO.h"
 #include <stdio.h>
-#include <CGAL/boost/graph/named_function_params.h>
+#include <CGAL/boost/graph/Named_function_parameters.h>
 #include <CGAL/boost/graph/named_params_helper.h>
 
 //== IMPLEMENTATION ===========================================================
@@ -55,7 +55,7 @@ bool read_off_ascii(Surface_mesh& mesh,
     Vec2f                t;
     Surface_mesh::Vertex v;
     typename CGAL::Polygon_mesh_processing::GetVertexPointMap<Surface_mesh, NamedParameters>::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<Normal>("v:normal");
     if (has_texcoords) texcoords = mesh.vertex_property<Texture_coordinate>("v:texcoord");
     typename CGAL::Polygon_mesh_processing::GetVertexPointMap<Surface_mesh, NamedParameters>::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));
 
 

Point_set_3/include/CGAL/Point_set_3.h

@@ -31,7 +31,7 @@
 
 #include <CGAL/demangle.h>
 
-#include <CGAL/boost/graph/named_function_params.h>
+#include <CGAL/boost/graph/Named_function_parameters.h>
 #include <CGAL/boost/graph/named_params_helper.h>
 
 
@@ -855,13 +855,13 @@ public:
 #ifdef DOXYGEN_RUNNING
   unspecified_type
 #else
-  cgal_bgl_named_params
+  Named_function_parameters
   <typename Kernel_traits<Point>::Kernel,
    internal_np::geom_traits_t,
-   cgal_bgl_named_params
+   Named_function_parameters
    <typename CGAL::Point_set_3<Point, Vector>::template Property_map<Vector>,
     internal_np::normal_t,
-    cgal_bgl_named_params
+    Named_function_parameters
     <typename CGAL::Point_set_3<Point, Vector>::template Property_map<Point>,
      internal_np::point_t> > >
 #endif
@@ -1198,13 +1198,13 @@ namespace Point_set_processing_3
   namespace parameters
   {
     template <typename Point, typename Vector>
-    cgal_bgl_named_params
+    Named_function_parameters
     <typename Kernel_traits<Point>::Kernel,
      internal_np::geom_traits_t,
-     cgal_bgl_named_params
+     Named_function_parameters
      <typename CGAL::Point_set_3<Point, Vector>::template Property_map<Vector>,
       internal_np::normal_t,
-      cgal_bgl_named_params
+      Named_function_parameters
       <typename CGAL::Point_set_3<Point, Vector>::template Property_map<Point>,
        internal_np::point_t> > >
     inline all_default(const CGAL::Point_set_3<Point, Vector>& ps)

Point_set_processing_3/doc/Point_set_processing_3/Doxyfile.in

@@ -15,3 +15,5 @@ ALIASES += "cgalNPTableEnd=</table> </dd> </dl>"
 ALIASES += "cgalNPBegin{1}=<tr><td class=\"paramname\">\1 </td><td>"
 ALIASES += "cgalNPEnd=</td></tr>"
 
+EXPAND_AS_DEFINED      = CGAL_BGL_NP_TEMPLATE_PARAMETERS \
+                        CGAL_BGL_NP_CLASS

Point_set_processing_3/include/CGAL/IO/read_las_points.h

@@ -35,7 +35,7 @@
 #include <CGAL/point_set_processing_assertions.h>
 #include <CGAL/Kernel_traits.h>
 
-#include <CGAL/boost/graph/named_function_params.h>
+#include <CGAL/boost/graph/Named_function_parameters.h>
 #include <CGAL/boost/graph/named_params_helper.h>
 
 #include <boost/version.hpp>
@@ -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<OutputIteratorValueType> PointRange;
   
   typedef typename Point_set_processing_3::GetPointMap<PointRange, CGAL_BGL_NP_CLASS>::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));

Point_set_processing_3/include/CGAL/IO/read_off_points.h

@@ -31,7 +31,7 @@
 #include <CGAL/point_set_processing_assertions.h>
 #include <CGAL/Kernel_traits.h>
 
-#include <CGAL/boost/graph/named_function_params.h>
+#include <CGAL/boost/graph/Named_function_parameters.h>
 #include <CGAL/boost/graph/named_params_helper.h>
 
 #include <iostream>
@@ -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<OutputIteratorValueType> PointRange;
   
@@ -97,8 +98,8 @@ read_off_points(
   bool has_normals = !(boost::is_same<NormalMap,
                        typename Point_set_processing_3::GetNormalMap<PointRange, CGAL_BGL_NP_CLASS>::NoMap>::value);
 
-  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());
-  NormalMap normal_map = choose_param(get_param(np, internal_np::normal_map), NormalMap());
+  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<OutputIterator>::type Enriched_point;

Point_set_processing_3/include/CGAL/IO/read_ply_points.h

@@ -36,7 +36,7 @@
 #include <CGAL/Kernel_traits.h>
 #include <CGAL/IO/io.h>
 
-#include <CGAL/boost/graph/named_function_params.h>
+#include <CGAL/boost/graph/Named_function_parameters.h>
 #include <CGAL/boost/graph/named_params_helper.h>
 
 #include <boost/version.hpp>
@@ -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<OutputIteratorValueType> PointRange;
   
@@ -874,8 +875,8 @@ bool read_ply_points(std::istream& stream,
   bool has_normals = !(boost::is_same<NormalMap,
                        typename Point_set_processing_3::GetNormalMap<PointRange, CGAL_BGL_NP_CLASS>::NoMap>::value);
 
-  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());
-  NormalMap normal_map = choose_param(get_param(np, internal_np::normal_map), NormalMap());
+  NormalMap normal_map = choose_parameter(get_parameter(np, internal_np::normal_map), NormalMap());
 
   if (has_normals)
     return read_ply_points_with_properties (stream, output,

Point_set_processing_3/include/CGAL/IO/read_xyz_points.h

@@ -30,7 +30,7 @@
 #include <CGAL/Origin.h>
 #include <CGAL/Kernel_traits.h>
 
-#include <CGAL/boost/graph/named_function_params.h>
+#include <CGAL/boost/graph/Named_function_parameters.h>
 #include <CGAL/boost/graph/named_params_helper.h>
 
 #include <iostream>
@@ -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<OutputIteratorValueType> PointRange;
   
@@ -96,8 +97,8 @@ read_xyz_points(
   bool has_normals = !(boost::is_same<NormalMap,
                        typename Point_set_processing_3::GetNormalMap<PointRange, CGAL_BGL_NP_CLASS>::NoMap>::value);
 
-  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());
-  NormalMap normal_map = choose_param(get_param(np, internal_np::normal_map), NormalMap());
+  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<OutputIterator>::type Enriched_point;

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<PointRange, NamedParameters>::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));
 }

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<PointRange, NamedParameters>::type PointMap;
@@ -77,8 +78,8 @@ write_off_points(
   bool has_normals = !(boost::is_same<NormalMap,
                        typename Point_set_processing_3::GetNormalMap<PointRange, NamedParameters>::NoMap>::value);
 
-  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());
-  NormalMap normal_map = choose_param(get_param(np, internal_np::normal_map), NormalMap());
+  NormalMap normal_map = choose_parameter(get_parameter(np, internal_np::normal_map), NormalMap());
   
   CGAL_point_set_processing_precondition(points.begin() != points.end());
 

Point_set_processing_3/include/CGAL/IO/write_ply_points.h

@@ -35,7 +35,7 @@
 #include <CGAL/IO/read_ply_points.h>
 #include <CGAL/Iterator_range.h>
 
-#include <CGAL/boost/graph/named_function_params.h>
+#include <CGAL/boost/graph/Named_function_parameters.h>
 #include <CGAL/boost/graph/named_params_helper.h>
 
 #include <boost/version.hpp>
@@ -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<PointRange, NamedParameters>::type PointMap;
@@ -438,8 +439,8 @@ write_ply_points(
   bool has_normals = !(boost::is_same<NormalMap,
                        typename Point_set_processing_3::GetNormalMap<PointRange, NamedParameters>::NoMap>::value);
 
-  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());
-  NormalMap normal_map = choose_param(get_param(np, internal_np::normal_map), NormalMap());
+  NormalMap normal_map = choose_parameter(get_parameter(np, internal_np::normal_map), NormalMap());
   
   if (has_normals)
     return write_ply_points_with_properties(

Point_set_processing_3/include/CGAL/IO/write_xyz_points.h

@@ -29,7 +29,7 @@
 #include <CGAL/Kernel_traits.h>
 #include <CGAL/Iterator_range.h>
 
-#include <CGAL/boost/graph/named_function_params.h>
+#include <CGAL/boost/graph/Named_function_parameters.h>
 #include <CGAL/boost/graph/named_params_helper.h>
 
 #include <iostream>
@@ -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<PointRange, NamedParameters>::type PointMap;
@@ -80,8 +81,8 @@ write_xyz_points(
   bool has_normals = !(boost::is_same<NormalMap,
                        typename Point_set_processing_3::GetNormalMap<PointRange, NamedParameters>::NoMap>::value);
 
-  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());
-  NormalMap normal_map = choose_param(get_param(np, internal_np::normal_map), NormalMap());
+  NormalMap normal_map = choose_parameter(get_parameter(np, internal_np::normal_map), NormalMap());
   
   CGAL_point_set_processing_precondition(points.begin() != points.end());
 

Point_set_processing_3/include/CGAL/bilateral_smooth_point_set.h

@@ -33,7 +33,7 @@
 #include <CGAL/squared_distance_3.h>
 #include <CGAL/function.h>
 
-#include <CGAL/boost/graph/named_function_params.h>
+#include <CGAL/boost/graph/Named_function_parameters.h>
 #include <CGAL/boost/graph/named_params_helper.h>
 
 #include <iterator>
@@ -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<PointRange, NamedParameters>::type PointMap;
@@ -459,8 +460,8 @@ bilateral_smooth_point_set(
   typedef typename std::vector<Pwn,CGAL_PSP3_DEFAULT_ALLOCATOR<Pwn> > Pwns;
   typedef typename Kernel::FT FT;
   
-  double sharpness_angle = choose_param(get_param(np, internal_np::sharpness_angle), 30.);
+  double sharpness_angle = choose_parameter(get_parameter(np, internal_np::sharpness_angle), 30.);
-  const cpp11::function<bool(double)>& callback = choose_param(get_param(np, internal_np::callback),
+  const cpp11::function<bool(double)>& callback = choose_parameter(get_parameter(np, internal_np::callback),
                                                                cpp11::function<bool(double)>());
   
   CGAL_point_set_processing_precondition(points.begin() != points.end());
@@ -473,8 +474,8 @@ bilateral_smooth_point_set(
   typedef CGAL::Orthogonal_k_neighbor_search<Tree_traits> Neighbor_search;
   typedef typename Neighbor_search::Tree Tree;
 
-  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());
-  NormalMap normal_map = choose_param(get_param(np, internal_np::normal_map), NormalMap());
+  NormalMap normal_map = choose_parameter(get_parameter(np, internal_np::normal_map), NormalMap());
 
   // copy points and normals
   Pwns pwns;

Point_set_processing_3/include/CGAL/compute_average_spacing.h

@@ -33,7 +33,7 @@
 #include <CGAL/assertions.h>
 #include <CGAL/function.h>
 
-#include <CGAL/boost/graph/named_function_params.h>
+#include <CGAL/boost/graph/Named_function_parameters.h>
 #include <CGAL/boost/graph/named_params_helper.h>
 
 #include <iterator>
@@ -46,6 +46,11 @@
 #include <tbb/scalable_allocator.h>
 #endif // CGAL_LINKED_WITH_TBB
 
+#ifdef DOXYGEN_RUNNING
+#define CGAL_BGL_NP_TEMPLATE_PARAMETERS NamedParameters
+#define CGAL_BGL_NP_CLASS NamedParameters
+#endif
+
 namespace CGAL {
 
 
@@ -184,28 +189,29 @@ compute_average_spacing(const typename Kernel::Point_3& query, ///< 3D point who
 */
 template <typename ConcurrencyTag,
 	  typename PointRange,
-          typename NamedParameters
+          typename CGAL_BGL_NP_TEMPLATE_PARAMETERS
 >
 #ifdef DOXYGEN_RUNNING
   FT
 #else
-  typename Point_set_processing_3::GetK<PointRange, NamedParameters>::Kernel::FT
+  typename Point_set_processing_3::GetK<PointRange, CGAL_BGL_NP_CLASS>::Kernel::FT
 #endif
 compute_average_spacing(
   const PointRange& points,
   unsigned int k,
-  const NamedParameters& np)
+  const CGAL_BGL_NP_CLASS& np)
 {
-  using boost::choose_param;
+  using parameters::choose_parameter;
+  using parameters::get_parameter;
 
   // basic geometric types
-  typedef typename Point_set_processing_3::GetPointMap<PointRange, NamedParameters>::const_type PointMap;
+  typedef typename Point_set_processing_3::GetPointMap<PointRange, CGAL_BGL_NP_CLASS>::const_type PointMap;
-  typedef typename Point_set_processing_3::GetK<PointRange, NamedParameters>::Kernel Kernel;
+  typedef typename Point_set_processing_3::GetK<PointRange, CGAL_BGL_NP_CLASS>::Kernel Kernel;
 
   typedef typename Kernel::Point_3 Point;
 
-  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());
-  const cpp11::function<bool(double)>& callback = choose_param(get_param(np, internal_np::callback),
+  const cpp11::function<bool(double)>& callback = choose_parameter(get_parameter(np, internal_np::callback),
                                                                cpp11::function<bool(double)>());
   
   // types for K nearest neighbors search structure

Point_set_processing_3/include/CGAL/edge_aware_upsample_point_set.h

@@ -32,7 +32,7 @@
 #include <CGAL/Memory_sizer.h>
 #include <CGAL/compute_average_spacing.h>
 
-#include <CGAL/boost/graph/named_function_params.h>
+#include <CGAL/boost/graph/Named_function_parameters.h>
 #include <CGAL/boost/graph/named_params_helper.h>
 
 #include <iterator>
@@ -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<PointRange, NamedParameters>::type PointMap;
@@ -344,12 +345,12 @@ edge_aware_upsample_point_set(
   typedef typename Kernel::FT FT;
   typedef typename rich_grid_internal::Rich_point<Kernel> Rich_point;
 
-  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());
-  NormalMap normal_map = choose_param(get_param(np, internal_np::normal_map), NormalMap());
+  NormalMap normal_map = choose_parameter(get_parameter(np, internal_np::normal_map), NormalMap());
-  double sharpness_angle = choose_param(get_param(np, internal_np::sharpness_angle), 30.);
+  double sharpness_angle = choose_parameter(get_parameter(np, internal_np::sharpness_angle), 30.);
-  double edge_sensitivity = choose_param(get_param(np, internal_np::edge_sensitivity), 1);
+  double edge_sensitivity = choose_parameter(get_parameter(np, internal_np::edge_sensitivity), 1);
-  double neighbor_radius = choose_param(get_param(np, internal_np::neighbor_radius), -1);
+  double neighbor_radius = choose_parameter(get_parameter(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);
+  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;

Point_set_processing_3/include/CGAL/estimate_scale.h

@@ -36,7 +36,7 @@
 #include <CGAL/random_simplify_point_set.h>
 #include <CGAL/Point_set_2.h>
 
-#include <CGAL/boost/graph/named_function_params.h>
+#include <CGAL/boost/graph/Named_function_parameters.h>
 #include <CGAL/boost/graph/named_params_helper.h>
 
 #include <fstream>
@@ -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<PointRange, NamedParameters>::const_type PointMap;
   typedef typename Point_set_processing_3::GetQueryPointMap<QueryPointRange, NamedParameters>::const_type QueryPointMap;
   typedef typename Point_set_processing_3::GetK<PointRange, NamedParameters>::Kernel Kernel;
 
   typedef typename boost::property_traits<PointMap>::value_type Point_d;
 
-  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());
-  QueryPointMap query_point_map = choose_param(get_param(np, internal_np::query_point_map), QueryPointMap());
+  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<Kernel, Point_d> 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<PointRange, NamedParameters>::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<std::size_t> 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<PointRange, NamedParameters>::const_type PointMap;
   typedef typename Point_set_processing_3::GetQueryPointMap<QueryPointRange, NamedParameters>::const_type QueryPointMap;
   typedef typename Point_set_processing_3::GetK<PointRange, NamedParameters>::Kernel Kernel;
 
   typedef typename boost::property_traits<PointMap>::value_type Point_d;
 
-  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());
-  QueryPointMap query_point_map = choose_param(get_param(np, internal_np::query_point_map), QueryPointMap());
+  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<Kernel, Point_d> 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<double> scales;
   typedef typename Point_set_processing_3::GetPointMap<PointRange, NamedParameters>::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]);

Point_set_processing_3/include/CGAL/grid_simplify_point_set.h

@@ -33,7 +33,7 @@
 #include <CGAL/function.h>
 #include <boost/functional/hash.hpp>
 
-#include <CGAL/boost/graph/named_function_params.h>
+#include <CGAL/boost/graph/Named_function_parameters.h>
 #include <CGAL/boost/graph/named_params_helper.h>
 
 #include <iterator>
@@ -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<PointRange, NamedParameters>::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());
-  const cpp11::function<bool(double)>& callback = choose_param(get_param(np, internal_np::callback),
+  const cpp11::function<bool(double)>& callback = choose_parameter(get_parameter(np, internal_np::callback),
                                                                cpp11::function<bool(double)>());
 
   // actual type of input points

Point_set_processing_3/include/CGAL/hierarchy_simplify_point_set.h

@@ -41,7 +41,7 @@
 #include <CGAL/Iterator_range.h>
 #include <CGAL/function.h>
 
-#include <CGAL/boost/graph/named_function_params.h>
+#include <CGAL/boost/graph/Named_function_parameters.h>
 #include <CGAL/boost/graph/named_params_helper.h>
 
 namespace CGAL {
@@ -161,7 +161,8 @@ namespace CGAL {
   hierarchy_simplify_point_set (PointRange& points,
                                 const NamedParameters& np)
   {
-    using boost::choose_param;
+    using parameters::choose_parameter;
+    using parameters::get_parameter;
   
     // basic geometric types
     typedef typename Point_set_processing_3::GetPointMap<PointRange, NamedParameters>::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());
+    PointMap point_map = choose_parameter(get_parameter(np, internal_np::point_map), PointMap());
-    unsigned int size = choose_param(get_param(np, internal_np::size), 10);
+    unsigned int size = choose_parameter(get_parameter(np, internal_np::size), 10);
-    double var_max = choose_param(get_param(np, internal_np::maximum_variation), 1./3.);
+    double var_max = choose_parameter(get_parameter(np, internal_np::maximum_variation), 1./3.);
-    const cpp11::function<bool(double)>& callback = choose_param(get_param(np, internal_np::callback),
+    const cpp11::function<bool(double)>& callback = choose_parameter(get_parameter(np, internal_np::callback),
                                                                  cpp11::function<bool(double)>());
 
     typedef typename std::iterator_traits<typename PointRange::iterator>::value_type Input_type;

Point_set_processing_3/include/CGAL/jet_estimate_normals.h

@@ -34,7 +34,7 @@
 #include <CGAL/Memory_sizer.h>
 #include <CGAL/function.h>
 
-#include <CGAL/boost/graph/named_function_params.h>
+#include <CGAL/boost/graph/Named_function_parameters.h>
 #include <CGAL/boost/graph/named_params_helper.h>
 
 #include <iterator>
@@ -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<NamedParameters>::NoTraits>::value),
                             "Error: no SVD traits");
 
-  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());
-  NormalMap normal_map = choose_param(get_param(np, internal_np::normal_map), NormalMap());
+  NormalMap normal_map = choose_parameter(get_parameter(np, internal_np::normal_map), NormalMap());
-  unsigned int degree_fitting = choose_param(get_param(np, internal_np::degree_fitting), 2);
+  unsigned int degree_fitting = choose_parameter(get_parameter(np, internal_np::degree_fitting), 2);
-  const cpp11::function<bool(double)>& callback = choose_param(get_param(np, internal_np::callback),
+  const cpp11::function<bool(double)>& callback = choose_parameter(get_parameter(np, internal_np::callback),
                                                                cpp11::function<bool(double)>());
 
   typedef typename Kernel::Point_3 Point;

Point_set_processing_3/include/CGAL/jet_smooth_point_set.h

@@ -33,7 +33,7 @@
 #include <CGAL/point_set_processing_assertions.h>
 #include <CGAL/function.h>
 
-#include <CGAL/boost/graph/named_function_params.h>
+#include <CGAL/boost/graph/Named_function_parameters.h>
 #include <CGAL/boost/graph/named_params_helper.h>
 
 #include <iterator>
@@ -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<PointRange, NamedParameters>::type PointMap;
@@ -227,10 +228,10 @@ jet_smooth_point_set(
                               typename GetSvdTraits<NamedParameters>::NoTraits>::value),
                             "Error: no SVD traits");
 
-  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());
-  unsigned int degree_fitting = choose_param(get_param(np, internal_np::degree_fitting), 2);
+  unsigned int degree_fitting = choose_parameter(get_parameter(np, internal_np::degree_fitting), 2);
-  unsigned int degree_monge = choose_param(get_param(np, internal_np::degree_monge), 2);
+  unsigned int degree_monge = choose_parameter(get_parameter(np, internal_np::degree_monge), 2);
-  const cpp11::function<bool(double)>& callback = choose_param(get_param(np, internal_np::callback),
+  const cpp11::function<bool(double)>& callback = choose_parameter(get_parameter(np, internal_np::callback),
                                                                cpp11::function<bool(double)>());
 
   typedef typename Kernel::Point_3 Point;

Point_set_processing_3/include/CGAL/mst_orient_normals.h

@@ -35,7 +35,7 @@
 #include <CGAL/point_set_processing_assertions.h>
 #include <CGAL/use.h>
 
-#include <CGAL/boost/graph/named_function_params.h>
+#include <CGAL/boost/graph/Named_function_parameters.h>
 #include <CGAL/boost/graph/named_params_helper.h>
 
 #include <iterator>
@@ -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<PointRange, NamedParameters>::type PointMap;
@@ -550,8 +552,8 @@ mst_orient_normals(
                                 typename Point_set_processing_3::GetNormalMap<PointRange, NamedParameters>::NoMap>::value),
                               "Error: no normal map");
 
-    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());
-    NormalMap normal_map = choose_param(get_param(np, internal_np::normal_map), NormalMap());
+    NormalMap normal_map = choose_parameter(get_parameter(np, internal_np::normal_map), NormalMap());
     Kernel kernel;
 
   // Bring private stuff to scope

Point_set_processing_3/include/CGAL/pca_estimate_normals.h

@@ -35,7 +35,7 @@
 #include <CGAL/Memory_sizer.h>
 #include <CGAL/function.h>
 
-#include <CGAL/boost/graph/named_function_params.h>
+#include <CGAL/boost/graph/Named_function_parameters.h>
 #include <CGAL/boost/graph/named_params_helper.h>
 
 #include <iterator>
@@ -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<PointRange, NamedParameters>::NoMap>::value),
                             "Error: no normal map");
 
-  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());
-  NormalMap normal_map = choose_param(get_param(np, internal_np::normal_map), NormalMap());
+  NormalMap normal_map = choose_parameter(get_parameter(np, internal_np::normal_map), NormalMap());
-  const cpp11::function<bool(double)>& callback = choose_param(get_param(np, internal_np::callback),
+  const cpp11::function<bool(double)>& callback = choose_parameter(get_parameter(np, internal_np::callback),
                                                                cpp11::function<bool(double)>());
 
   typedef typename Kernel::Point_3 Point;

Point_set_processing_3/include/CGAL/random_simplify_point_set.h

@@ -31,7 +31,7 @@
 #include <CGAL/point_set_processing_assertions.h>
 #include <CGAL/Iterator_range.h>
 
-#include <CGAL/boost/graph/named_function_params.h>
+#include <CGAL/boost/graph/Named_function_parameters.h>
 #include <CGAL/boost/graph/named_params_helper.h>
 
 #include <iterator>

Point_set_processing_3/include/CGAL/remove_outliers.h

@@ -31,7 +31,7 @@
 #include <CGAL/point_set_processing_assertions.h>
 #include <CGAL/function.h>
 
-#include <CGAL/boost/graph/named_function_params.h>
+#include <CGAL/boost/graph/Named_function_parameters.h>
 #include <CGAL/boost/graph/named_params_helper.h>
 
 #include <iterator>
@@ -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<PointRange, NamedParameters>::type PointMap;
   typedef typename Point_set_processing_3::GetK<PointRange, NamedParameters>::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());
-  double threshold_percent = choose_param(get_param(np, internal_np::threshold_percent), 10.);
+  double threshold_percent = choose_parameter(get_parameter(np, internal_np::threshold_percent), 10.);
-  double threshold_distance = choose_param(get_param(np, internal_np::threshold_distance), 0.);
+  double threshold_distance = choose_parameter(get_parameter(np, internal_np::threshold_distance), 0.);
-  const cpp11::function<bool(double)>& callback = choose_param(get_param(np, internal_np::callback),
+  const cpp11::function<bool(double)>& callback = choose_parameter(get_parameter(np, internal_np::callback),
                                                                cpp11::function<bool(double)>());
   
   typedef typename Kernel::FT FT;

Point_set_processing_3/include/CGAL/structure_point_set.h

@@ -42,7 +42,7 @@
 #include <CGAL/Delaunay_triangulation_3.h>
 #include <CGAL/Triangulation_vertex_base_with_info_3.h>
 
-#include <CGAL/boost/graph/named_function_params.h>
+#include <CGAL/boost/graph/Named_function_parameters.h>
 #include <CGAL/boost/graph/named_params_helper.h>
 
 #include <boost/iterator/counting_iterator.hpp>
@@ -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<PointRange, NamedParameters>::type PointMap;
@@ -250,11 +251,11 @@ public:
                                 typename Point_set_processing_3::GetPlaneIndexMap<NamedParameters>::NoMap>::value),
                               "Error: no plane index map");
 
-    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());
-    NormalMap normal_map = choose_param(get_param(np, internal_np::normal_map), NormalMap());
+    NormalMap normal_map = choose_parameter(get_parameter(np, internal_np::normal_map), NormalMap());
-    PlaneMap plane_map = choose_param(get_param(np, internal_np::plane_map), PlaneMap());
+    PlaneMap plane_map = choose_parameter(get_parameter(np, internal_np::plane_map), PlaneMap());
-    PlaneIndexMap index_map = choose_param(get_param(np, internal_np::plane_index_map), PlaneIndexMap());
+    PlaneIndexMap index_map = choose_parameter(get_parameter(np, internal_np::plane_index_map), PlaneIndexMap());
-    double attraction_factor = choose_param(get_param(np, internal_np::attraction_factor), 3.);
+    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<PointRange, NamedParameters>::Kernel Kernel;
 

Point_set_processing_3/include/CGAL/vcm_estimate_normals.h

@@ -38,7 +38,7 @@
 #include <CGAL/Orthogonal_k_neighbor_search.h>
 #include <CGAL/Fuzzy_sphere.h>
 
-#include <CGAL/boost/graph/named_function_params.h>
+#include <CGAL/boost/graph/Named_function_parameters.h>
 #include <CGAL/boost/graph/named_params_helper.h>
 
 #include <CGAL/Default_diagonalize_traits.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<PointRange, NamedParameters>::type PointMap;
     typedef typename Point_set_processing_3::GetK<PointRange, NamedParameters>::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<PointRange, NamedParameters>::type PointMap;
     typedef typename Point_set_processing_3::GetNormalMap<PointRange, NamedParameters>::type NormalMap;
@@ -356,8 +360,8 @@ vcm_estimate_normals_internal (PointRange& points,
                                 typename Point_set_processing_3::GetNormalMap<PointRange, NamedParameters>::NoMap>::value),
                               "Error: no normal map");
 
-    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());
-    NormalMap normal_map = choose_param(get_param(np, internal_np::normal_map), NormalMap());
+    NormalMap normal_map = choose_parameter(get_parameter(np, internal_np::normal_map), NormalMap());
     
     typedef cpp11::array<double, 6> Covariance;
     

Point_set_processing_3/include/CGAL/wlop_simplify_and_regularize_point_set.h

@@ -32,7 +32,7 @@
 #include <CGAL/Memory_sizer.h>
 #include <CGAL/compute_average_spacing.h>
 
-#include <CGAL/boost/graph/named_function_params.h>
+#include <CGAL/boost/graph/Named_function_parameters.h>
 #include <CGAL/boost/graph/named_params_helper.h>
 #include <CGAL/algorithm.h>
 #include <iterator>
@@ -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<PointRange, NamedParameters>::type PointMap;
   typedef typename Point_set_processing_3::GetK<PointRange, NamedParameters>::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());
-  double select_percentage = choose_param(get_param(np, internal_np::select_percentage), 5.);
+  double select_percentage = choose_parameter(get_parameter(np, internal_np::select_percentage), 5.);
-  double radius = choose_param(get_param(np, internal_np::neighbor_radius), -1);
+  double radius = choose_parameter(get_parameter(np, internal_np::neighbor_radius), -1);
-  unsigned int iter_number = choose_param(get_param(np, internal_np::number_of_iterations), 35);
+  unsigned int iter_number = choose_parameter(get_parameter(np, internal_np::number_of_iterations), 35);
-  bool require_uniform_sampling = choose_param(get_param(np, internal_np::require_uniform_sampling), false);
+  bool require_uniform_sampling = choose_parameter(get_parameter(np, internal_np::require_uniform_sampling), false);
-  const cpp11::function<bool(double)>& callback = choose_param(get_param(np, internal_np::callback),
+  const cpp11::function<bool(double)>& callback = choose_parameter(get_parameter(np, internal_np::callback),
                                                                cpp11::function<bool(double)>());
 
   typedef typename Kernel::Point_3   Point;

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 parameters::choose_parameter;
-      using boost::get_param;
+      using parameters::get_parameter;
       typename GetVertexPointMap<PolygonMesh, CGAL_PMP_NP_CLASS>::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<PolygonMesh, CGAL_PMP_NP_CLASS>::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<PolygonMesh>::vertex_descriptor vertex_descriptor;
@@ -116,14 +116,14 @@ namespace CGAL {
                              const PolygonMesh& pmesh,
                              const NamedParameters& np)
     {
-      using boost::choose_param;
+      using parameters::choose_parameter;
-      using boost::get_param;
+      using parameters::get_parameter;
       typename GetVertexPointMap<PolygonMesh, 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, pmesh));
 
       typedef typename GetGeomTraits<PolygonMesh, NamedParameters>::type GT;
-      GT gt = choose_param(get_param(np, internal_np::geom_traits), GT());
+      GT gt = choose_parameter(get_parameter(np, internal_np::geom_traits), GT());
       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 parameters::choose_parameter;
-      using boost::get_param;
+      using parameters::get_parameter;
       typename GetVertexPointMap<PolygonMesh, 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, pmesh));
 
       typedef typename GetGeomTraits<PolygonMesh, NamedParameters>::type GT;
-      GT gt = choose_param(get_param(np, internal_np::geom_traits), GT());
+      GT gt = choose_parameter(get_parameter(np, internal_np::geom_traits), GT());
       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 parameters::choose_parameter;
-      using boost::get_param;
+      using parameters::get_parameter;
       typename GetVertexPointMap<PolygonMesh, 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, pmesh));
 
       typedef typename GetGeomTraits<PolygonMesh, NamedParameters>::type GT;
-      GT gt = choose_param(get_param(np, internal_np::geom_traits), GT());
+      GT gt = choose_parameter(get_parameter(np, internal_np::geom_traits), GT());
       typename GT::Construct_bbox_3 get_bbox = gt.construct_bbox_3_object();
 
       typedef typename boost::graph_traits<PolygonMesh>::halfedge_descriptor halfedge_descriptor;

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),
+    FIMap fim = parameters::choose_parameter(parameters::get_parameter(np, internal_np::face_index),
-                                    get_const_property_map(CGAL::face_index, pmesh));
+                                             get_const_property_map(CGAL::face_index, pmesh));
 
     return internal::border_halfedges_impl(faces, fim, out, pmesh, np);
   }

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<TriangleMesh,
                                    NamedParameters1>::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<std::size_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<TriangleMesh,
                                      NamedParameters>::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);

Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/compute_normal.h

@@ -132,14 +132,14 @@ compute_face_normal(typename boost::graph_traits<PolygonMesh>::face_descriptor f
                     , const PolygonMesh& pmesh
                     , const NamedParameters& np)
 {
-  using boost::choose_param;
+  using parameters::choose_parameter;
-  using boost::get_param;
+  using parameters::get_parameter;
 
   typedef typename GetGeomTraits<PolygonMesh, NamedParameters>::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<PolygonMesh, NamedParameters>::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<PolygonMesh>::vertex_descript
                       const NamedParameters& np
                       )
 {
-  using boost::choose_param;
+  using parameters::choose_parameter;
+  using parameters::get_parameter;
 
   typedef typename GetGeomTraits<PolygonMesh, NamedParameters>::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<PolygonMesh, NamedParameters>::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<FaceNormalMap,
                       DefaultMap

Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/connected_components.h

@@ -29,7 +29,7 @@
 #include<set>
 #include<vector>
 
-#include <CGAL/boost/graph/named_function_params.h>
+#include <CGAL/boost/graph/Named_function_parameters.h>
 #include <CGAL/boost/graph/helpers.h>
 #include <boost/graph/graph_traits.hpp>
 #include <boost/foreach.hpp>
@@ -133,16 +133,16 @@ connected_component(typename boost::graph_traits<PolygonMesh>::face_descriptor s
                     , FaceOutputIterator out
                     , const NamedParameters& np)
 {
-  using boost::choose_param;
+  using parameters::choose_parameter;
-  using boost::get_param;
+  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<PolygonMesh>//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<PolygonMesh>());
 
   typedef typename boost::graph_traits<PolygonMesh>::face_descriptor face_descriptor;
@@ -213,16 +213,16 @@ connected_components(const PolygonMesh& pmesh,
                      FaceComponentMap fcm,
                      const NamedParameters& np)
 {
-  using boost::choose_param;
+  using parameters::choose_parameter;
-  using boost::get_param;
+  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<PolygonMesh>//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<PolygonMesh>());
 
   typedef Dual<PolygonMesh>                              Dual;
@@ -234,7 +234,7 @@ connected_components(const PolygonMesh& pmesh,
     internal::No_border<PolygonMesh, EdgeConstraintMap>(pmesh, ecmap));
 
   typename GetFaceIndexMap<PolygonMesh, NamedParameters>::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<PM>::face_descriptor face_descriptor;
 
-  using boost::choose_param;
+  using parameters::choose_parameter;
-  using boost::get_param;
+  using parameters::get_parameter;
 
   //FaceIndexMap
   typedef typename GetFaceIndexMap<PM, NamedParameters>::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<PM>::face_descriptor face_descriptor;
 
-  using boost::choose_param;
+  using parameters::choose_parameter;
-  using boost::get_param;
+  using parameters::get_parameter;
 
   //FaceIndexMap
   typedef typename GetFaceIndexMap<PM, NamedParameters>::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 parameters::choose_parameter;
-  using boost::get_param;
+  using parameters::get_parameter;
 
   typedef typename boost::graph_traits<PolygonMesh>::face_descriptor   face_descriptor;
   typedef typename boost::graph_traits<PolygonMesh>::face_iterator     face_iterator;
@@ -446,7 +446,7 @@ void keep_or_remove_connected_components(PolygonMesh& pmesh
 
   //VertexIndexMap
   typedef typename GetVertexIndexMap<PM, NamedParameters>::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<std::size_t> 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<PM>::face_descriptor face_descriptor;
-  using boost::choose_param;
+  using parameters::choose_parameter;
-  using boost::get_param;
+  using parameters::get_parameter;
 
   //FaceIndexMap
   typedef typename GetFaceIndexMap<PM, CGAL_PMP_NP_CLASS>::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<PM>::face_descriptor face_descriptor;
 
-  using boost::choose_param;
+  using parameters::choose_parameter;
-  using boost::get_param;
+  using parameters::get_parameter;
 
   //FaceIndexMap
   typedef typename GetFaceIndexMap<PM, CGAL_PMP_NP_CLASS>::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

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<std::size_t> 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<TriangleMesh> \
   > ::type Ecm_out_##I; \
     Ecm_out_##I ecm_out_##I = \
-      boost::choose_param( boost::get_param(cpp11::get<I>(nps_out), internal_np::edge_is_constrained),  \
+      parameters::choose_parameter( parameters::get_parameter(cpp11::get<I>(nps_out), internal_np::edge_is_constrained),  \
                            Corefinement::No_mark<TriangleMesh>() );
 
 
@@ -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<Vpm,Vpm2>::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<Vpm>::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<TriangleMesh>//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<TriangleMesh>//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<TriangleMesh>() );
-  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<TriangleMesh>() );
 
   typedef Corefinement::Ecm_bind<TriangleMesh, Ecm1, Ecm2> Ecm_in;
@@ -534,17 +534,17 @@ corefine_and_compute_boolean_operations(
     static const bool same_fidmap = (boost::is_same<Fid_map,Fid_map2>::value);)
   CGAL_static_assertion(same_fidmap);
 
-  Fid_map fid_map1 = boost::choose_param(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<TriangleMesh>//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<TriangleMesh>() ) );
 
   // 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<TriangleMesh,
@@ -840,28 +840,28 @@ corefine_and_compute_difference(      TriangleMesh& tm1,
     static const bool same_vpm = (boost::is_same<Vpm,Vpm2>::value);)
   CGAL_static_assertion(same_vpm);
 
-  Vpm vpm1 = boost::choose_param(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<TriangleMesh>//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<TriangleMesh>//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<TriangleMesh>() );
-  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<TriangleMesh>() );
 
   typedef Corefinement::Ecm_bind<TriangleMesh, Ecm1, Ecm2> 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<TriangleMesh>//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<TriangleMesh>() ) );
 
 // surface intersection algorithm call
@@ -932,27 +932,27 @@ namespace experimental {
   typedef typename GetVertexPointMap<TriangleMesh,
                                      NamedParameters>::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<TriangleMesh>//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<TriangleMesh>() );
 
 // 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<TriangleMesh>//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<TriangleMesh>() ) );
 
 
@@ -1007,28 +1007,28 @@ namespace experimental {
 // Vertex point maps
   typedef typename GetVertexPointMap<TriangleMesh,
                                      NamedParameters>::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<TriangleMesh,
                                    NamedParameters>::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<TriangleMesh>//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<TriangleMesh>() );
 // 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<TriangleMesh>//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<TriangleMesh>() ) );
 
 // surface intersection algorithm call

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<PolygonMesh, NamedParameters>::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<int>(
-          boost::choose_param(get_param(np, internal_np::first_index),
+          parameters::choose_parameter(parameters::get_parameter(np, internal_np::first_index),
           1));
 
   internal::PatchIdMapWrapper<PatchIdMap,
@@ -214,7 +214,7 @@ template<typename GT,
  void sharp_call(PolygonMesh& pmesh,
                  FT& angle_in_deg,
                  EIFMap edge_is_feature_map,
-                 const boost::param_not_found&)
+                 const internal_np::Param_not_found&)
 {
   typedef typename boost::graph_traits<PolygonMesh>::edge_descriptor     edge_descriptor;
   typedef typename boost::graph_traits<PolygonMesh>::halfedge_descriptor halfedge_descriptor;
@@ -284,10 +284,10 @@ void detect_sharp_edges(PolygonMesh& pmesh,
 {
   //extract types from NPs
   typedef typename GetGeomTraits<PolygonMesh, NamedParameters>::type GT;
-  typedef typename GetGeomTraits<PolygonMesh, GT>::type::FT          FT;
+  typedef typename GT::FT          FT;
 
   internal::sharp_call<GT, FT>(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<typename PolygonMesh,
            typename PIDMap,
            typename EIFMap>
-  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;
 }

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 parameters::choose_parameter;
-  using boost::get_param;
+  using parameters::get_parameter;
-  using boost::is_default_param;
+  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<typename Geom_traits::FT,
                             typename Geom_traits::Point_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_rs = choose_parameter(get_parameter(np, internal_np::random_uniform_sampling), true);
-  bool use_gs = choose_param(get_param(np, internal_np::grid_sampling), false);
+  bool use_gs = choose_parameter(get_parameter(np, internal_np::grid_sampling), false);
-  bool use_ms = choose_param(get_param(np, internal_np::monte_carlo_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_vrtcs = choose_parameter(get_parameter(np, internal_np::do_sample_vertices), true);
-  bool smpl_dgs = choose_param(get_param(np, internal_np::do_sample_edges), true);
+  bool smpl_dgs = choose_parameter(get_parameter(np, internal_np::do_sample_edges), true);
-  bool smpl_fcs = choose_param(get_param(np, internal_np::do_sample_faces), 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_a_u = choose_parameter(get_parameter(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_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<double>::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<TriangleMesh, Vpm, Creator> 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<TriangleMesh, Vpm, Creator> 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<Concurrency_tag, Geom_traits>(
-    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<Concurrency_tag, Geom_traits>
-     (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),
+      points[i] = get(parameters::choose_parameter(parameters::get_parameter(np, internal_np::vertex_point),
-                                   get_const_property_map(vertex_point, tm)),
+                                                   get_const_property_map(vertex_point, tm)),
                       target(hd, tm));
       hd = next(hd, tm);
     }

Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/extrude.h

@@ -28,7 +28,7 @@
 
 #include <CGAL/Polygon_mesh_processing/orientation.h>
 #include <CGAL/boost/graph/named_params_helper.h>
-#include <CGAL/boost/graph/named_function_params.h>
+#include <CGAL/boost/graph/Named_function_parameters.h>
 #include <CGAL/boost/graph/copy_face_graph.h>
 #include <CGAL/Kernel_traits.h>
 #include <CGAL/boost/graph/Euler_operations.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<std::pair<input_vertex_descriptor, output_vertex_descriptor> > 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<

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 parameters::get_parameter;
-    using boost::choose_param;
+    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<TriangleMesh, VPMap>
       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_parameter(get_parameter(np, internal_np::sparse_linear_solver), Default_solver()),
-      choose_param(get_param(np, internal_np::weight_calculator), Default_Weight_calculator(tmesh, vpmap_)),
+      choose_parameter(get_parameter(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::fairing_continuity), 1),
       vpmap_
       );
   }

Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/internal/Corefinement/face_graph_utils.h

@@ -206,8 +206,8 @@ boost::optional< typename TweakedGetVertexPointMap<PT, NP, PM>::type >
 get_vpm(const NP& np, boost::optional<PM*> opm, boost::true_type)
 {
   if (boost::none == opm) return boost::none;
-  return boost::choose_param(
+  return parameters::choose_parameter(
-           boost::get_param(np, internal_np::vertex_point),
+           parameters::get_parameter(np, internal_np::vertex_point),
            get_property_map(boost::vertex_point, *(*opm)) );
 }
 

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

Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/internal/named_function_params.h

@@ -25,7 +25,7 @@
 #include <CGAL/license/Polygon_mesh_processing/core.h>
 
 
-#include <CGAL/boost/graph/named_function_params.h>
+#include <CGAL/boost/graph/Named_function_parameters.h>
 
 #define CGAL_PMP_NP_TEMPLATE_PARAMETERS CGAL_BGL_NP_TEMPLATE_PARAMETERS
 #define CGAL_PMP_NP_CLASS CGAL_BGL_NP_CLASS

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 parameters::get_parameter;
-  using boost::choose_param;
+  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<TM, NamedParameters1>::const_type VertexPointMap1;
   typedef typename GetVertexPointMap<TM, NamedParameters2>::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<TM, NamedParameters1>::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<TM,
                             GeomTraits,
@@ -520,8 +520,8 @@ compute_face_polyline_intersection( const FaceRange& face_range,
                OutputIterator out,
                const NamedParameters& np)
 {
-  using boost::choose_param;
+  using parameters::choose_parameter;
-  using boost::get_param;
+  using parameters::get_parameter;
 
   CGAL_precondition(CGAL::is_triangle_mesh(tm));
 
@@ -529,8 +529,8 @@ compute_face_polyline_intersection( const FaceRange& face_range,
   typedef typename boost::graph_traits<TM>::face_descriptor face_descriptor;
   typedef typename GetVertexPointMap<TM, NamedParameters>::const_type VertexPointMap;
 
-  VertexPointMap vpmap = choose_param(get_param(np, internal_np::vertex_point),
+  VertexPointMap vpmap = choose_parameter(get_parameter(np, internal_np::vertex_point),
-                                      get_const_property_map(boost::vertex_point, tm));
+                                          get_const_property_map(boost::vertex_point, tm));
   typedef typename boost::property_traits<VertexPointMap>::value_type Point;
   CGAL_static_assertion(
         (boost::is_same<Point,
@@ -575,7 +575,7 @@ compute_face_polyline_intersection( const FaceRange& face_range,
 
   // compute intersections filtered out by boxes
   typedef typename GetGeomTraits<TM, NamedParameters>::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<TM,
                                     GeomTraits,
@@ -644,8 +644,8 @@ compute_face_polylines_intersection(const FaceRange& face_range,
                                     OutputIterator out,
                                     const NamedParameters& np)
 {
-  using boost::choose_param;
+  using parameters::choose_parameter;
-  using boost::get_param;
+  using parameters::get_parameter;
 
   CGAL_precondition(CGAL::is_triangle_mesh(tm));
 
@@ -653,8 +653,8 @@ compute_face_polylines_intersection(const FaceRange& face_range,
   typedef typename boost::graph_traits<TM>::face_descriptor face_descriptor;
   typedef typename GetVertexPointMap<TM, NamedParameters>::const_type VertexPointMap;
 
-  VertexPointMap vpmap = choose_param(get_param(np, internal_np::vertex_point),
+  VertexPointMap vpmap = choose_parameter(get_parameter(np, internal_np::vertex_point),
-                                      get_const_property_map(boost::vertex_point, tm));
+                                          get_const_property_map(boost::vertex_point, tm));
   typedef typename boost::property_traits<VertexPointMap>::value_type Point;
   typedef typename boost::range_value<PolylineRange>::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<TM, NamedParameters>::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<TM,
                                      GeomTraits,
@@ -1205,11 +1205,11 @@ bool do_intersect(const TriangleMesh& tm1,
                   const NamedParameters1& np1,
                   const NamedParameters2& np2)
 {
-  using boost::choose_param;
+  using parameters::choose_parameter;
-  using boost::get_param;
+  using parameters::get_parameter;
 
-  bool test_overlap =  choose_param(get_param(np1, internal_np::overlap_test),false) ||
+  bool test_overlap =  choose_parameter(get_parameter(np1, internal_np::overlap_test),false) ||
-                       choose_param(get_param(np2, internal_np::overlap_test),false);
+                       choose_parameter(get_parameter(np2, internal_np::overlap_test),false);
 
   CGAL_precondition(CGAL::is_triangle_mesh(tm1));
   CGAL_precondition(CGAL::is_triangle_mesh(tm2));
@@ -1228,12 +1228,12 @@ bool do_intersect(const TriangleMesh& tm1,
   {
     typedef typename GetVertexPointMap<TriangleMesh, NamedParameters1>::const_type VertexPointMap1;
     typedef typename GetVertexPointMap<TriangleMesh, NamedParameters2>::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<TriangleMesh, NamedParameters1>::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<class Mesh_box>
   void operator()(const Mesh_box* b1, const Mesh_box* b2)
   {
-    using boost::choose_param;
+    using parameters::choose_parameter;
-    using boost::get_param;
+    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),
+    VPM vpm1 = choose_parameter(get_parameter(*(nps.begin() + mesh_id_1), internal_np::vertex_point),
-                            get_const_property_map(CGAL::vertex_point, *b1->info()));
+                                get_const_property_map(CGAL::vertex_point, *b1->info()));
 
-    VPM vpm2 = choose_param(get_param(*(nps.begin() + mesh_id_2), internal_np::vertex_point),
+    VPM vpm2 = choose_parameter(get_parameter(*(nps.begin() + mesh_id_2), internal_np::vertex_point),
-                            get_const_property_map(CGAL::vertex_point, *b2->info()));
+                                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 parameters::choose_parameter;
-  using boost::get_param;
+  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<double, 3, TriangleMeshIterator> Mesh_box;
   std::vector<Mesh_box> boxes;
@@ -1593,7 +1593,7 @@ OutputIterator intersecting_meshes(const TriangleMeshRange& range,
   typedef typename boost::range_value<NamedParametersRange>::type NP_rng;
   typedef typename boost::range_value<TriangleMeshRange>::type TriangleMesh;
   typedef typename GetGeomTraits<TriangleMesh, NamedParameters, NP_rng>::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)
@@ -1609,7 +1609,7 @@ OutputIterator intersecting_meshes(const TriangleMeshRange& range,
                                          OutputIterator out,
                                          NamedParameters np)
 {
-  std::vector<cgal_bgl_named_params<bool, internal_np::all_default_t> >nps(
+  std::vector<Named_function_parameters<bool, internal_np::all_default_t> >nps(
     std::distance(range.begin(), range.end()), parameters::all_default());
   return intersecting_meshes(range, out, np, nps);
 }
@@ -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<TriangleMesh,
                                      NamedParameters1>::const_type Vpm;
@@ -1679,12 +1679,10 @@ surface_intersection(const TriangleMesh& tm1,
     static const bool same_vpm = (boost::is_same<Vpm,Vpm2>::value);)
   CGAL_static_assertion(same_vpm);
 
-  Vpm vpm1 = choose_const_pmap(get_param(np1, internal_np::vertex_point),
+  Vpm vpm1 = parameters::choose_parameter(parameters::get_parameter(np1, internal_np::vertex_point),
-                               tm1,
+                                          get_const_property_map(CGAL::vertex_point, tm1));
-                               vertex_point);
+  Vpm vpm2 = parameters::choose_parameter(parameters::get_parameter(np2, internal_np::vertex_point),
-  Vpm vpm2 = choose_const_pmap(get_param(np2, internal_np::vertex_point),
+                                          get_const_property_map(CGAL::vertex_point, tm2));
-                               tm2,
-                               vertex_point);
 
   Corefinement::Intersection_of_triangle_meshes<TriangleMesh,Vpm>
     functor(tm1, tm2, vpm1, vpm2);
@@ -1728,9 +1726,8 @@ surface_self_intersection(const TriangleMesh& tm,
   typedef typename GetVertexPointMap<TriangleMesh,
                                      NamedParameters>::const_type Vpm;
 
-  Vpm vpm = choose_const_pmap(get_param(np, internal_np::vertex_point),
+  Vpm vpm = parameters::choose_parameter(parameters::get_parameter(np, internal_np::vertex_point),
-                              tm,
+                                          get_const_property_map(CGAL::vertex_point, tm));
-                              vertex_point);
 
 // surface intersection algorithm call
   typedef Corefinement::Default_surface_intersection_visitor<TriangleMesh,

Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/measure.h

@@ -99,11 +99,11 @@ public:
               , const PolygonMesh& pmesh
               , const NamedParameters& np)
   {
-    using boost::choose_param;
+    using parameters::choose_parameter;
-    using boost::get_param;
+    using parameters::get_parameter;
 
     typename GetVertexPointMap<PolygonMesh, 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, 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 parameters::choose_parameter;
-    using boost::get_param;
+    using parameters::get_parameter;
 
     CGAL_precondition(boost::graph_traits<TriangleMesh>::null_face() != f);
 
     typename GetVertexPointMap<TriangleMesh, CGAL_PMP_NP_CLASS>::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<TriangleMesh>::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 parameters::choose_parameter;
-  using boost::get_param;
+  using parameters::get_parameter;
 
   typename GetVertexPointMap<TriangleMesh, CGAL_PMP_NP_CLASS>::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<TriangleMesh, CGAL_PMP_NP_CLASS>::type::Point_3
     origin(0, 0, 0);

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 parameters::choose_parameter;
-    using boost::get_param;
+    using parameters::get_parameter;
 
     CGAL_assertion(halfedge(v_max, pmesh)!=boost::graph_traits<PolygonMesh>::null_halfedge());
 
     //VertexPointMap
     typedef typename GetVertexPointMap<PolygonMesh, NamedParameters>::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<PolygonMesh, NamedParameters>::type GT;
-    GT gt = choose_param(get_param(np, internal_np::geom_traits), GT());
+    GT gt = choose_parameter(get_parameter(np, internal_np::geom_traits), GT());
 
     //among the incoming edges of `v_max`, find one edge `e` with the minimal slope
     typedef typename boost::graph_traits<PolygonMesh>::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 parameters::choose_parameter;
-  using boost::get_param;
+  using parameters::get_parameter;
 
   //VertexPointMap
   typedef typename GetVertexPointMap<PolygonMesh, NamedParameters>::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<PolygonMesh, NamedParameters>::type GT;
-  GT gt = choose_param(get_param(np, internal_np::geom_traits), GT());
+  GT gt = choose_parameter(get_parameter(np, internal_np::geom_traits), GT());
 
   //find the vertex with maximal z coordinate
   internal::Compare_vertex_points_z_3<GT, VPMap> 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 parameters::choose_parameter;
-  using boost::get_param;
+  using parameters::get_parameter;
 
-  bool orient_outward = choose_param(
+  bool orient_outward = choose_parameter(
-                          get_param(np, internal_np::outward_orientation),true);
+                          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<std::size_t> 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 parameters::choose_parameter;
-  using boost::get_param;
+  using parameters::get_parameter;
 
-  bool orient_outward = choose_param(
+  bool orient_outward = choose_parameter(
-                          get_param(np, internal_np::outward_orientation),true);
+                          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<std::size_t> face_cc(num_faces(tm), std::size_t(-1));

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 parameters::get_parameter;
-  using boost::choose_param;
+  using parameters::choose_parameter;
 
   typedef typename boost::graph_traits<PM>::vertex_descriptor vertex_descriptor;
 
@@ -165,22 +165,22 @@ void random_perturbation(VertexRange vertices
 #endif
 
   typedef typename GetGeomTraits<PM, NamedParameters>::type GT;
-  GT gt = choose_param(get_param(np, internal_np::geom_traits), GT());
+  GT gt = choose_parameter(get_parameter(np, internal_np::geom_traits), GT());
 
   typedef typename GetVertexPointMap<PM, NamedParameters>::type VPMap;
-  VPMap vpmap = choose_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<vertex_descriptor>//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<vertex_descriptor>());
 
-  unsigned int seed = choose_param(get_param(np, internal_np::random_seed), -1);
+  unsigned int seed = choose_parameter(get_parameter(np, internal_np::random_seed), -1);
-  bool do_project = choose_param(get_param(np, internal_np::do_project), true);
+  bool do_project = choose_parameter(get_parameter(np, internal_np::do_project), true);
 
   CGAL::Random rng = (seed == unsigned(-1)) ? CGAL::Random() : CGAL::Random(seed);
 

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 parameters::choose_parameter;
-    using boost::get_param;
+    using parameters::get_parameter;
 
     CGAL_precondition(is_triangle_mesh(tmesh) );
 
     typedef typename GetVertexPointMap<TriangleMesh,NamedParameters>::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<TriangleMesh, VPmap> 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);
   }
 

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<PM>::vertex_descriptor vertex_descriptor;
   typedef typename boost::graph_traits<PM>::edge_descriptor edge_descriptor;
-  using boost::get_param;
+  using parameters::get_parameter;
-  using boost::choose_param;
+  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<PM, NamedParameters>::type GT;
 
   typedef typename GetVertexPointMap<PM, NamedParameters>::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<PM, NamedParameters>::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<edge_descriptor>//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<edge_descriptor>());
 
-  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<vertex_descriptor>//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<vertex_descriptor>());
 
-  bool protect = choose_param(get_param(np, internal_np::protect_constraints), false);
+  bool protect = choose_parameter(get_parameter(np, internal_np::protect_constraints), false);
-  typedef typename boost::lookup_named_param_def <
+  typedef typename internal_np::Lookup_named_param_def <
       internal_np::face_patch_t,
       NamedParameters,
       internal::Connected_components_pmap<PM, FIMap>//default
     > ::type FPMap;
-  FPMap fpmap = choose_param(
+  FPMap fpmap = choose_parameter(
-    get_param(np, internal_np::face_patch),
+    get_parameter(np, internal_np::face_patch),
     internal::Connected_components_pmap<PM, FIMap>(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);
+  bool collapse_constraints = choose_parameter(get_parameter(np, internal_np::collapse_constraints), true);
-  unsigned int nb_iterations = choose_param(get_param(np, internal_np::number_of_iterations), 1);
+  unsigned int nb_iterations = choose_parameter(get_parameter(np, internal_np::number_of_iterations), 1);
-  bool smoothing_1d = choose_param(get_param(np, internal_np::relax_constraints), false);
+  bool smoothing_1d = choose_parameter(get_parameter(np, internal_np::relax_constraints), false);
-  unsigned int nb_laplacian = choose_param(get_param(np, internal_np::number_of_relaxation_steps), 1);
+  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) )
+    if ( choose_parameter(get_parameter(np, internal_np::do_project), true) )
-      remesher.project_to_surface(get_param(np, internal_np::projection_functor));
+      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<PM>::edge_descriptor edge_descriptor;
   typedef typename boost::graph_traits<PM>::vertex_descriptor vertex_descriptor;
-  using boost::choose_param;
+  using parameters::choose_parameter;
-  using boost::get_param;
+  using parameters::get_parameter;
 
   typedef typename GetGeomTraits<PM, NamedParameters>::type GT;
   typedef typename GetVertexPointMap<PM, NamedParameters>::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<PM, NamedParameters>::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<edge_descriptor>//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<edge_descriptor>());
   
   typename internal::Incremental_remesher<PM, VPMap, GT, ECMap,

Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/repair.h

@@ -372,8 +372,8 @@ std::size_t remove_null_edges(
 {
   CGAL_assertion(CGAL::is_triangle_mesh(tmesh));
 
-  using boost::get_param;
+  using parameters::get_parameter;
-  using boost::choose_param;
+  using parameters::choose_parameter;
 
   typedef TriangleMesh TM;
   typedef typename boost::graph_traits<TriangleMesh> GT;
@@ -383,10 +383,10 @@ std::size_t remove_null_edges(
   typedef typename GT::vertex_descriptor vertex_descriptor;
 
   typedef typename GetVertexPointMap<TM, NamedParameters>::type VertexPointMap;
-  VertexPointMap vpmap = choose_param(get_param(np, internal_np::vertex_point),
+  VertexPointMap vpmap = choose_parameter(get_parameter(np, internal_np::vertex_point),
                                       get_property_map(vertex_point, tmesh));
   typedef typename GetGeomTraits<TM, NamedParameters>::type Traits;
-  Traits traits = choose_param(get_param(np, 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 parameters::get_parameter;
-  using boost::choose_param;
+  using parameters::choose_parameter;
 
   typedef TriangleMesh TM;
   typedef typename boost::graph_traits<TriangleMesh> GT;
@@ -710,10 +710,10 @@ std::size_t remove_degenerate_faces(TriangleMesh& tmesh,
   typedef typename GT::vertex_descriptor vertex_descriptor;
 
   typedef typename GetVertexPointMap<TM, NamedParameters>::type VertexPointMap;
-  VertexPointMap vpmap = choose_param(get_param(np, internal_np::vertex_point),
+  VertexPointMap vpmap = choose_parameter(get_parameter(np, internal_np::vertex_point),
                                       get_property_map(vertex_point, tmesh));
   typedef typename GetGeomTraits<TM, NamedParameters>::type Traits;
-  Traits traits = choose_param(get_param(np, internal_np::geom_traits), Traits());
+  Traits traits = choose_parameter(get_parameter(np, internal_np::geom_traits), Traits());
 
   typedef typename boost::property_traits<VertexPointMap>::value_type Point_3;
   typedef typename boost::property_traits<VertexPointMap>::reference Point_ref;
@@ -1881,12 +1881,12 @@ bool remove_self_intersections(TriangleMesh& tm, const NamedParameters& np)
 
   // named parameter extraction
   typedef typename GetVertexPointMap<TriangleMesh, NamedParameters>::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);
+  const int max_steps = parameters::choose_parameter(parameters::get_parameter(np, internal_np::number_of_iterations), 7);
-  bool verbose = boost::choose_param(boost::get_param(np, internal_np::verbosity_level), 0) > 0;
+  bool verbose = parameters::choose_parameter(parameters::get_parameter(np, internal_np::verbosity_level), 0) > 0;
-  bool preserve_genus = boost::choose_param(boost::get_param(np, internal_np::preserve_genus), true);
+  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";

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<P,T,R>& np)
+                 , const Named_function_parameters<P,T,R>& np)
 #endif
 {
   return self_intersections(faces(tmesh), tmesh, out, np);
@@ -341,8 +341,8 @@ self_intersections( const FaceRange& face_range,
   );
 
   typedef typename GetVertexPointMap<TM, NamedParameters>::const_type VertexPointMap;
-  VertexPointMap vpmap = boost::choose_param(get_param(np, internal_np::vertex_point),
+  VertexPointMap vpmap = parameters::choose_parameter(parameters::get_parameter(np, internal_np::vertex_point),
-                                             get_const_property_map(boost::vertex_point, tmesh));
+                                                      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<TM, NamedParameters>::type GeomTraits;
   CGAL::internal::Intersect_facets<TM,GeomTraits,Box,OutputIterator,VertexPointMap>
     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);

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<std::vector<halfedge_descriptor> > border_edges_per_cc;
-  bool per_cc = boost::choose_param(get_param(np, internal_np::apply_per_connected_component),
+  bool per_cc = parameters::choose_parameter(parameters::get_parameter(np, internal_np::apply_per_connected_component),
-                                       false);
+                                             false);
   if(per_cc)
   {
     cc = get(Face_property_tag(), pmesh);
     typedef typename GetFaceIndexMap<PM, CGAL_PMP_NP_CLASS>::const_type FIMap;
-    FIMap fim = boost::choose_param(get_param(np, internal_np::face_index),
+    FIMap fim = parameters::choose_parameter(parameters::get_parameter(np, internal_np::face_index),
-                             get_const_property_map(face_index, pmesh));
+                                             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 <typename PolygonMesh,
 void stitch_borders(PolygonMesh& pmesh,
                     const HalfedgePairsRange& hedge_pairs_to_stitch)
 {
-  using boost::choose_param;
+  using parameters::choose_parameter;
-  using boost::get_param;
+  using parameters::get_parameter;
 
   internal::stitch_borders_impl(pmesh, hedge_pairs_to_stitch);
 }
@@ -626,15 +626,15 @@ void stitch_borders(PolygonMesh& pmesh,
 template <typename PolygonMesh, class CGAL_PMP_NP_TEMPLATE_PARAMETERS>
 void stitch_borders(PolygonMesh& pmesh, const CGAL_PMP_NP_CLASS& np)
 {
-  using boost::choose_param;
+  using parameters::choose_parameter;
-  using boost::get_param;
+  using parameters::get_parameter;
 
   typedef typename boost::graph_traits<PolygonMesh>::halfedge_descriptor
     halfedge_descriptor;
   std::vector< std::pair<halfedge_descriptor, halfedge_descriptor> > hedge_pairs_to_stitch;
 
   typedef typename GetVertexPointMap<PolygonMesh, CGAL_PMP_NP_CLASS>::const_type VPMap;
-  VPMap vpm = choose_param(get_param(np, 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,

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<PolygonMesh, NamedParameters>::type VPMap;
-  VPMap vpm = choose_param(get_param(np, internal_np::vertex_point),
+  VPMap vpm = parameters::choose_parameter(parameters::get_parameter(np, internal_np::vertex_point),
-                           get_property_map(vertex_point, mesh));
+                                           get_property_map(vertex_point, mesh));
   
   BOOST_FOREACH(typename boost::graph_traits<PolygonMesh>::vertex_descriptor vd, vertices(mesh))
   {

Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/triangulate_faces.h

@@ -431,20 +431,20 @@ bool triangulate_face(typename boost::graph_traits<PolygonMesh>::face_descriptor
                       PolygonMesh& pmesh,
                       const NamedParameters& np)
 {
-  using boost::choose_param;
+  using parameters::choose_parameter;
-  using boost::get_param;
+  using parameters::get_parameter;
 
   //VertexPointMap
   typedef typename GetVertexPointMap<PolygonMesh, NamedParameters>::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<PolygonMesh, NamedParameters>::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<PolygonMesh, VPMap, Kernel> 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 parameters::choose_parameter;
-  using boost::get_param;
+  using parameters::get_parameter;
 
   //VertexPointMap
   typedef typename GetVertexPointMap<PolygonMesh, NamedParameters>::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<PolygonMesh, NamedParameters>::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<PolygonMesh, VPMap, Kernel> modifier(vpmap, traits);
   return modifier(face_range, pmesh, use_cdt);

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 parameters::choose_parameter;
-    using boost::get_param;
+    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<PolygonMesh>::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<PolygonMesh,NamedParameters>::type()))
+      choose_parameter(get_parameter(np, internal_np::geom_traits), typename GetGeomTraits<PolygonMesh,NamedParameters>::type()))
       .first;
   }
 
@@ -333,14 +333,14 @@ namespace Polygon_mesh_processing {
                             OutputIterator out,
                             const NamedParameters& np)
   {
-    using boost::choose_param;
+    using parameters::choose_parameter;
-    using boost::get_param;
+    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<Point>::Kernel()));
 
     CGAL_assertion(holes.empty());

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<TriangleMesh,
       NamedParameters>::const_type Fid_map;
 
-  Vpm vpm = boost::choose_param(get_param(np, CGAL::internal_np::vertex_point),
+  using CGAL::parameters::choose_parameter;
-                                CGAL::get_const_property_map(boost::vertex_point, tm));
+  using CGAL::parameters::get_parameter;
   
-  Fid_map fid_map = boost::choose_param(get_param(np, CGAL::internal_np::face_index),
+  Vpm vpm = choose_parameter(get_parameter(np, CGAL::internal_np::vertex_point),
-                                        CGAL::get_const_property_map(boost::face_index, tm));
+                             CGAL::get_const_property_map(boost::vertex_point, 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<std::size_t> face_cc(num_faces(tm), std::size_t(-1));
 

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();
       }
     }

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
   <Kernel,
    CGAL::internal_np::geom_traits_t,
-   CGAL::cgal_bgl_named_params
+   CGAL::Named_function_parameters
    <typename Base::template Property_map<Vector>,
     CGAL::internal_np::normal_t,
-    CGAL::cgal_bgl_named_params
+    CGAL::Named_function_parameters
     <typename Base::template Property_map<Point>,
      CGAL::internal_np::point_t> > >
   inline parameters() const
@@ -570,13 +570,13 @@ namespace Point_set_processing_3
   namespace parameters
   {
     template <typename Kernel>
-    cgal_bgl_named_params
+    Named_function_parameters
     <Kernel,
      internal_np::geom_traits_t,
-     cgal_bgl_named_params
+     Named_function_parameters
      <typename ::Point_set_3<Kernel>::template Property_map<typename Kernel::Vector_3>,
       internal_np::normal_t,
-      cgal_bgl_named_params
+      Named_function_parameters
       <typename ::Point_set_3<Kernel>::template Property_map<typename Kernel::Point_3>,
        internal_np::point_t> > >
     inline all_default(const ::Point_set_3<Kernel>& ps)

Polyhedron_IO/include/CGAL/IO/Polyhedron_iostream.h

@@ -29,7 +29,7 @@
 #include <CGAL/IO/print_OFF.h>
 #include <CGAL/IO/scan_OFF.h>
 #include <CGAL/boost/graph/named_params_helper.h>
-#include <CGAL/boost/graph/named_function_params.h>
+#include <CGAL/boost/graph/Named_function_parameters.h>
 #include <iostream>
 
 namespace CGAL {
@@ -41,11 +41,14 @@ template < class Traits,
            class HDS, class Alloc, class NamedParameters>
 bool
 write_off( std::ostream& out, const Polyhedron_3<Traits,Items,HDS,Alloc>& 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<Polyhedron_3<Traits,Items,HDS,Alloc>, 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<Traits,Items,HDS,Alloc>& P,
          NamedParameters np) {
     // reads a polyhedron from `in' and appends it to P.
-  typedef typename CGAL::Polygon_mesh_processing::GetVertexPointMap<Polyhedron_3<Traits,Items,HDS,Alloc>, NamedParameters>::type Vpm;
+    typedef typename CGAL::Polygon_mesh_processing::GetVertexPointMap<Polyhedron_3<Traits,Items,HDS,Alloc>, NamedParameters>::type Vpm;
-      Vpm vpm = choose_param(get_param(np, internal_np::vertex_point),
+    using parameters::choose_parameter;
-                               get_property_map(CGAL::vertex_point, P));
+    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<Polyhedron_3<Traits,Items,HDS,Alloc> >::vertex_descriptor Vertex;
       typename property_map_selector<Polyhedron_3<Traits,Items,HDS,Alloc>, boost::vertex_point_t>::type

Polyhedron_IO/include/CGAL/IO/generic_print_polyhedron.h

@@ -24,7 +24,7 @@
 
 #include <CGAL/license/Polyhedron.h>
 
-#include <CGAL/boost/graph/named_function_params.h>
+#include <CGAL/boost/graph/Named_function_parameters.h>
 #include <CGAL/boost/graph/named_params_helper.h>
 #include <CGAL/property_map.h>
 #include <boost/graph/graph_traits.hpp>

Scripts/developer_scripts/update_to_CGAL_np.sh

@@ -0,0 +1,17 @@
+#!/bin/bash
+
+ack -l --cpp boost::lookup_named_param_def | xargs sed -i 's/boost::lookup_named_param_def/internal_np::Lookup_named_param_def/g'
+ack -l --cpp boost::param_not_found | xargs sed -i 's/boost::param_not_found/internal_np::Param_not_found/g'
+ack -l --cpp boost::is_default_param | xargs sed -i 's/boost::is_default_param/parameters::is_default_parameter/g'
+ack -l --cpp boost::get_param | xargs sed -i 's/boost::get_param/parameters::get_parameter/g'
+ack -l --cpp boost::choose_param | xargs sed -i 's/boost::choose_param/parameters::choose_parameter/g'
+ack -l --cpp cgal_bgl_named_params | xargs sed -i 's/cgal_bgl_named_params/Named_function_parameters/g'
+
+
+ack -l --cpp choose_param | xargs sed -i -E 's/choose_param[ ]*\(/choose_parameter(/g'
+ack -l --cpp get_param | xargs sed -i -E 's/get_param[ ]*\(/get_parameter(/g'
+ack -l --cpp is_default_param | xargs sed -i -E 's/is_default_param[ ]*\(/is_default_parameter(/g'
+
+ack vertex_index_t | grep get_param
+
+git checkout BGL/include/CGAL/boost/graph/dijkstra_shortest_paths.hpp

Subdivision_method_3/include/CGAL/Subdivision_method_3/subdivision_hosts_3.h

@@ -31,7 +31,7 @@
 
 #include <CGAL/circulator.h>
 
-#include <CGAL/boost/graph/named_function_params.h>
+#include <CGAL/boost/graph/Named_function_parameters.h>
 #include <CGAL/boost/graph/named_params_helper.h>
 
 #include <CGAL/Subdivision_method_3/internal/subdivision_hosts_impl_3.h>
@@ -84,14 +84,14 @@ void PQQ(PolygonMesh& pmesh, Mask mask, int step = 1) {
 template <class PolygonMesh, class Mask, class NamedParameters>
 void PQQ(PolygonMesh& pmesh, Mask mask, const NamedParameters& np) {
   // todo:  static assert that PolygonMesh == Mask::PolygonMesh
-  using boost::choose_param;
+  using parameters::choose_parameter;
-  using boost::get_param;
+  using parameters::get_parameter;
 
   typedef typename Polygon_mesh_processing::GetVertexPointMap<PolygonMesh, NamedParameters>::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 <class PolygonMesh, class Mask, class NamedParameters>
 void PTQ(PolygonMesh& pmesh, Mask mask, const NamedParameters& np) {
   // todo:  static assert that PolygonMesh == Mask::PolygonMesh
-  using boost::choose_param;
+  using parameters::choose_parameter;
-  using boost::get_param;
+  using parameters::get_parameter;
 
   typedef typename Polygon_mesh_processing::GetVertexPointMap<PolygonMesh, NamedParameters>::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 <class PolygonMesh, class Mask, class NamedParameters>
 void DQQ(PolygonMesh& pmesh, Mask mask, const NamedParameters& np) {
   // todo:  static assert that PolygonMesh == Mask::PolygonMesh
-  using boost::choose_param;
+  using parameters::choose_parameter;
-  using boost::get_param;
+  using parameters::get_parameter;
 
   typedef typename Polygon_mesh_processing::GetVertexPointMap<PolygonMesh, NamedParameters>::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 <class PolygonMesh, class Mask, class NamedParameters>
 void Sqrt3(PolygonMesh& pmesh, Mask mask, const NamedParameters& np) {
   // todo:  static assert that PolygonMesh == Mask::PolygonMesh
-  using boost::choose_param;
+  using parameters::choose_parameter;
-  using boost::get_param;
+  using parameters::get_parameter;
 
   typedef typename Polygon_mesh_processing::GetVertexPointMap<PolygonMesh, NamedParameters>::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));
 }

Subdivision_method_3/include/CGAL/Subdivision_method_3/subdivision_methods_3.h

@@ -29,7 +29,7 @@
 
 #include <CGAL/circulator.h>
 
-#include <CGAL/boost/graph/named_function_params.h>
+#include <CGAL/boost/graph/Named_function_parameters.h>
 #include <CGAL/boost/graph/named_params_helper.h>
 
 #include <CGAL/Subdivision_method_3/subdivision_hosts_3.h>
@@ -125,13 +125,13 @@ void CatmullClark_subdivision(PolygonMesh& pmesh, int step = 1) {
  **/
 template <class PolygonMesh, class NamedParameters>
 void CatmullClark_subdivision(PolygonMesh& pmesh, const NamedParameters& np) {
-  using boost::choose_param;
+  using parameters::choose_parameter;
-  using boost::get_param;
+  using parameters::get_parameter;
   typedef typename Polygon_mesh_processing::GetVertexPointMap<PolygonMesh, NamedParameters>::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<PolygonMesh,Vpm> mask(&pmesh, vpm);
 
   for(unsigned int i = 0; i < step; i++)
@@ -170,13 +170,13 @@ void Loop_subdivision(PolygonMesh& pmesh, int step = 1) {
  **/
 template <class PolygonMesh, class NamedParameters>
 void Loop_subdivision(PolygonMesh& pmesh, const NamedParameters& np) {
-  using boost::choose_param;
+  using parameters::choose_parameter;
-  using boost::get_param;
+  using parameters::get_parameter;
   typedef typename Polygon_mesh_processing::GetVertexPointMap<PolygonMesh, NamedParameters>::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<PolygonMesh,Vpm> mask(&pmesh, vpm);
 
   for(unsigned int i = 0; i < step; i++)
@@ -215,13 +215,13 @@ void DooSabin_subdivision(PolygonMesh& pmesh, int step = 1) {
  **/
 template <class PolygonMesh, class NamedParameters>
 void DooSabin_subdivision(PolygonMesh& pmesh, const NamedParameters& np) {
-  using boost::choose_param;
+  using parameters::choose_parameter;
-  using boost::get_param;
+  using parameters::get_parameter;
   typedef typename Polygon_mesh_processing::GetVertexPointMap<PolygonMesh, NamedParameters>::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<PolygonMesh,Vpm> mask(&pmesh, vpm);
 
   for(unsigned int i = 0; i < step; i++)
@@ -265,13 +265,13 @@ void Sqrt3_subdivision(PolygonMesh& pmesh, int step = 1) {
  **/
 template <class PolygonMesh, class NamedParameters>
 void Sqrt3_subdivision(PolygonMesh& pmesh, const NamedParameters& np) {
-  using boost::choose_param;
+  using parameters::choose_parameter;
-  using boost::get_param;
+  using parameters::get_parameter;
   typedef typename Polygon_mesh_processing::GetVertexPointMap<PolygonMesh, NamedParameters>::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<PolygonMesh,Vpm> mask(&pmesh, vpm);
 
   for(unsigned int i = 0; i < step; i++)

Surface_mesh/include/CGAL/Surface_mesh/Surface_mesh.h

@@ -56,7 +56,7 @@
 #include <CGAL/IO/File_scanner_OFF.h>
 #include <CGAL/Handle_hash_function.h>
 #include <CGAL/boost/graph/named_params_helper.h>
-#include <CGAL/boost/graph/named_function_params.h>
+#include <CGAL/boost/graph/Named_function_parameters.h>
 
 namespace CGAL {
 
@@ -2099,13 +2099,16 @@ private: //------------------------------------------------------- private data
     bool has_fcolors;
     boost::tie(fcolors, has_fcolors) = sm.template property_map<typename Mesh::Face_index, CGAL::Color >("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<int> reindex;
     typename Polygon_mesh_processing::GetVertexPointMap<Surface_mesh<P>, 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<Surface_mesh<P>, 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;

Surface_mesh/include/CGAL/boost/graph/graph_traits_Surface_mesh.h

@@ -26,7 +26,7 @@
 #include <CGAL/license/Surface_mesh.h>
 
 // include this to avoid a VC15 warning
-#include <CGAL/boost/graph/named_function_params.h>
+#include <CGAL/boost/graph/Named_function_parameters.h>
 
 #include <boost/graph/graph_traits.hpp>
 #include <boost/graph/properties.hpp>

Surface_mesh_segmentation/include/CGAL/internal/Surface_mesh_segmentation/Alpha_expansion_graph_cut.h

@@ -47,7 +47,7 @@
 #endif
 #include <CGAL/trace.h>
 
-#include <CGAL/boost/graph/named_function_params.h>
+#include <CGAL/boost/graph/Named_function_parameters.h>
 
 #include <boost/version.hpp>
 #ifdef CGAL_DO_NOT_USE_BOYKOV_KOLMOGOROV_MAXFLOW_SOFTWARE

Surface_mesh_simplification/include/CGAL/Surface_mesh_simplification/edge_collapse.h

@@ -24,7 +24,7 @@
 
 
 #include <CGAL/boost/graph/properties.h>
-#include <CGAL/boost/graph/named_function_params.h>
+#include <CGAL/boost/graph/Named_function_parameters.h>
 
 #include <CGAL/Surface_mesh_simplification/Detail/Edge_collapse.h>
 #include <CGAL/Surface_mesh_simplification/Detail/Common.h>
@@ -102,12 +102,11 @@ struct Dummy_visitor
 template<class TM, class ShouldStop, class P, class T, class R>
 int edge_collapse ( TM& aSurface
                   , ShouldStop const& aShould_stop
-                  , cgal_bgl_named_params<P,T,R> const& aParams 
+                  , Named_function_parameters<P,T,R> const& aParams 
                   ) 
 {
-  using boost::choose_param ;
+  using parameters::choose_parameter;
-  using boost::choose_const_pmap ;
+  using parameters::get_parameter;
-  using boost::get_param ;
   
   LindstromTurk_params lPolicyParams ;
   
@@ -115,25 +114,24 @@ int edge_collapse ( TM& aSurface
 
   return edge_collapse(aSurface
                       ,aShould_stop
-                      ,choose_const_pmap(get_param(aParams,internal_np::vertex_index),aSurface,boost::vertex_index)
+                      ,choose_parameter(get_parameter(aParams,internal_np::vertex_index), get_const_property_map(boost::vertex_index, aSurface))
-                      ,choose_pmap(get_param(aParams,internal_np::vertex_point),aSurface,boost::vertex_point)
+                      ,choose_parameter(get_parameter(aParams,internal_np::vertex_point),get_property_map(vertex_point, aSurface))
-                      ,choose_const_pmap(get_param(aParams,internal_np::halfedge_index),aSurface,boost::halfedge_index)
+                      ,choose_parameter(get_parameter(aParams,internal_np::halfedge_index),get_const_property_map(boost::halfedge_index, aSurface))
-                       ,choose_param     (get_param(aParams,internal_np::edge_is_constrained),No_constrained_edge_map<TM>())
+                      ,choose_parameter(get_parameter(aParams,internal_np::edge_is_constrained),No_constrained_edge_map<TM>())
-                       ,choose_param     (get_param(aParams,internal_np::get_cost_policy), LindstromTurk_cost<TM>())
+                      ,choose_parameter(get_parameter(aParams,internal_np::get_cost_policy), LindstromTurk_cost<TM>())
-                       ,choose_param     (get_param(aParams,internal_np::get_placement_policy), LindstromTurk_placement<TM>())
+                      ,choose_parameter(get_parameter(aParams,internal_np::get_placement_policy), LindstromTurk_placement<TM>())
-                      ,choose_param     (get_param(aParams,vis), Dummy_visitor())
+                      ,choose_parameter(get_parameter(aParams,vis), Dummy_visitor())
                       );
 
 }
   template<class TM, class ShouldStop, class GT, class P, class T, class R>
 int edge_collapse ( TM& aSurface
                   , ShouldStop const& aShould_stop
-                  , cgal_bgl_named_params<P,T,R> const& aParams 
+                  , Named_function_parameters<P,T,R> const& aParams 
                   ) 
 {
-  using boost::choose_param ;
+  using parameters::choose_parameter;
-  using boost::choose_const_pmap ;
+  using parameters::get_parameter;
-  using boost::get_param ;
   
   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_parameter(get_parameter(aParams,internal_np::vertex_index), get_const_property_map(boost::vertex_index, aSurface))
-                      ,choose_const_pmap(get_param(aParams,internal_np::vertex_point),aSurface,boost::vertex_point)
+                      ,choose_parameter(get_parameter(aParams,internal_np::vertex_point),get_property_map(vertex_point, aSurface))
-                      ,choose_const_pmap(get_param(aParams,internal_np::halfedge_index),aSurface,boost::halfedge_index)
+                      ,choose_parameter(get_parameter(aParams,internal_np::halfedge_index),get_const_property_map(boost::halfedge_index, aSurface))
-                      ,choose_param     (get_param(aParams,internal_np::edge_is_constrained),No_constrained_edge_map<TM>())
+                      ,choose_parameter(get_parameter(aParams,internal_np::edge_is_constrained),No_constrained_edge_map<TM>())
-                      ,choose_param     (get_param(aParams,internal_np::get_cost_policy), LindstromTurk_cost<TM>())
+                      ,choose_parameter(get_parameter(aParams,internal_np::get_cost_policy), LindstromTurk_cost<TM>())
-                      ,choose_param     (get_param(aParams,internal_np::get_placement_policy), LindstromTurk_placement<TM>())
+                      ,choose_parameter(get_parameter(aParams,internal_np::get_placement_policy), LindstromTurk_placement<TM>())
-                      ,choose_param     (get_param(aParams,vis), Dummy_visitor())
+                      ,choose_parameter(get_parameter(aParams,vis), Dummy_visitor())
                       );
 
 }

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 <CGAL/boost/graph/named_function_params.h>
+#include <CGAL/boost/graph/Named_function_parameters.h>
 
 #include <boost/config.hpp>
 #include <boost/iterator_adaptors.hpp>

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 <CGAL/boost/graph/named_function_params.h>
+#include <CGAL/boost/graph/Named_function_parameters.h>
 
 #include <boost/config.hpp>
 #include <boost/iterator_adaptors.hpp>

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 <CGAL/boost/graph/named_function_params.h>
+#include <CGAL/boost/graph/Named_function_parameters.h>
 
 #include <boost/config.hpp>
 #include <boost/iterator_adaptors.hpp>

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 <CGAL/boost/graph/named_function_params.h>
+#include <CGAL/boost/graph/Named_function_parameters.h>
 
 #include <boost/config.hpp>
 #include <boost/iterator_adaptors.hpp>

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 <CGAL/boost/graph/named_function_params.h>
+#include <CGAL/boost/graph/Named_function_parameters.h>
 
 #include <boost/config.hpp>
 #include <boost/iterator_adaptors.hpp>

Triangulation_2/include/CGAL/boost/graph/graph_traits_Triangulation_2.h

@@ -24,7 +24,7 @@
 #include <functional>
 
 // include this to avoid a VC15 warning
-#include <CGAL/boost/graph/named_function_params.h>
+#include <CGAL/boost/graph/Named_function_parameters.h>
 #include <CGAL/boost/graph/graph_traits_Triangulation_data_structure_2.h>
 #include <boost/config.hpp>
 #include <boost/iterator_adaptors.hpp>

Triangulation_2/include/CGAL/boost/graph/graph_traits_Triangulation_data_structure_2.h

@@ -24,7 +24,7 @@
 #include <functional>
 
 // include this to avoid a VC15 warning
-#include <CGAL/boost/graph/named_function_params.h>
+#include <CGAL/boost/graph/Named_function_parameters.h>
 
 #include <boost/config.hpp>
 #include <boost/iterator_adaptors.hpp>

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 <CGAL/boost/graph/named_function_params.h>
+#include <CGAL/boost/graph/Named_function_parameters.h>
 
 #include <boost/config.hpp>
 #include <boost/iterator_adaptors.hpp>