use_default_values() -> default_values()

BGL/doc/BGL/NamedParameters.txt

@@ -24,7 +24,7 @@ The named parameters in the snippet use the tags `predecessor_map` and `distance
 and they are concatenated using the dot operator.<BR>
 
 A similar mechanism was introduced in \cgal, with the small difference that the named parameters
-tag live in the `CGAL::parameters::` namespace and `CGAL::parameters::use_default_values()` can be used to indicate
+tag live in the `CGAL::parameters::` namespace and `CGAL::parameters::default_values()` can be used to indicate
 that default values of optional named parameters must be used.
 As in the \bgl, named parameters in \cgal are also concatenated using
 the dot operator, and a typical usage is thus:
@@ -40,7 +40,7 @@ CGAL::copy_face_graph(g1, g2);
 CGAL::copy_face_graph(g1, g2,
                       CGAL::parameters::vertex_point_map(vpm)  //parameter for g1
                       .vertex_to_vertex_map(v2v),              //other parameter for g1
-                      CGAL::parameters::use_default_values());        //parameter for g2
+                      CGAL::parameters::default_values());        //parameter for g2
 \endcode
 */
 

BGL/doc/BGL/PackageDescription.txt

@@ -683,7 +683,7 @@ user might encounter.
 
 - `CGAL::set_triangulation_ids()`
 
-- `CGAL::parameters::use_default_values()`
+- `CGAL::parameters::default_values()`
 
 \cgalCRPSection{Iterators}
 - `CGAL::Halfedge_around_source_iterator`

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

@@ -149,7 +149,7 @@ struct Face_filtered_graph
    */
   template <class CGAL_BGL_NP_TEMPLATE_PARAMETERS>
   Face_filtered_graph(const Graph& graph,
-                      const CGAL_BGL_NP_CLASS& np = parameters::use_default_values())
+                      const CGAL_BGL_NP_CLASS& np = parameters::default_values())
     : _graph(const_cast<Graph&>(graph))
     , fimap(CGAL::get_initialized_face_index_map(graph, np))
     , vimap(CGAL::get_initialized_vertex_index_map(graph, np))

BGL/include/CGAL/boost/graph/IO/GOCAD.h

@@ -112,7 +112,7 @@ template <typename Graph,
 bool read_GOCAD(std::istream& is,
                 std::pair<std::string, std::string>& name_and_color,
                 Graph& g,
-                const CGAL_BGL_NP_CLASS& np = parameters::use_default_values()
+                const CGAL_BGL_NP_CLASS& np = parameters::default_values()
 #ifndef DOXYGEN_RUNNING
                 , typename boost::disable_if<internal::is_Point_set_or_Range_or_Iterator<Graph> >::type* = nullptr
 #endif
@@ -134,7 +134,7 @@ bool read_GOCAD(std::istream& is,
 /// \cond SKIP_IN_MANUAL
 
 template <typename Graph, typename CGAL_BGL_NP_TEMPLATE_PARAMETERS>
-bool read_GOCAD(std::istream& is, Graph& g, const CGAL_BGL_NP_CLASS& np = parameters::use_default_values(),
+bool read_GOCAD(std::istream& is, Graph& g, const CGAL_BGL_NP_CLASS& np = parameters::default_values(),
                 typename boost::disable_if<internal::is_Point_set_or_Range_or_Iterator<Graph> >::type* = nullptr)
 {
   std::pair<std::string, std::string> dummy;
@@ -186,7 +186,7 @@ template <typename Graph,
 bool read_GOCAD(const std::string& fname,
                 std::pair<std::string, std::string>& name_and_color,
                 Graph& g,
-                const CGAL_BGL_NP_CLASS& np = parameters::use_default_values()
+                const CGAL_BGL_NP_CLASS& np = parameters::default_values()
 #ifndef DOXYGEN_RUNNING
                 , typename boost::disable_if<internal::is_Point_set_or_Range_or_Iterator<Graph> >::type* = nullptr
 #endif
@@ -200,7 +200,7 @@ bool read_GOCAD(const std::string& fname,
 /// \cond SKIP_IN_MANUAL
 
 template <typename Graph, typename CGAL_BGL_NP_TEMPLATE_PARAMETERS>
-bool read_GOCAD(const std::string& fname, Graph& g, const CGAL_BGL_NP_CLASS& np = parameters::use_default_values(),
+bool read_GOCAD(const std::string& fname, Graph& g, const CGAL_BGL_NP_CLASS& np = parameters::default_values(),
                 typename boost::disable_if<internal::is_Point_set_or_Range_or_Iterator<Graph> >::type* = nullptr)
 {
   std::pair<std::string, std::string> dummy;
@@ -249,7 +249,7 @@ template <typename Graph,
 bool write_GOCAD(std::ostream& os,
                  const char* name,
                  const Graph& g,
-                 const CGAL_BGL_NP_CLASS& np = parameters::use_default_values()
+                 const CGAL_BGL_NP_CLASS& np = parameters::default_values()
 #ifndef DOXYGEN_RUNNING
                  , typename boost::disable_if<internal::is_Point_set_or_Range_or_Iterator<Graph> >::type* = nullptr
 #endif
@@ -345,7 +345,7 @@ template <typename Graph,
           typename CGAL_BGL_NP_TEMPLATE_PARAMETERS>
 bool write_GOCAD(std::ostream& os,
                  const Graph& g,
-                 const CGAL_BGL_NP_CLASS& np = parameters::use_default_values()
+                 const CGAL_BGL_NP_CLASS& np = parameters::default_values()
 #ifndef DOXYGEN_RUNNING
                  , typename boost::disable_if<internal::is_Point_set_or_Range_or_Iterator<Graph> >::type* = nullptr
 #endif
@@ -390,7 +390,7 @@ template <typename Graph,
           typename CGAL_BGL_NP_TEMPLATE_PARAMETERS>
 bool write_GOCAD(const std::string& fname,
                  const Graph& g,
-                 const CGAL_BGL_NP_CLASS& np = parameters::use_default_values()
+                 const CGAL_BGL_NP_CLASS& np = parameters::default_values()
 #ifndef DOXYGEN_RUNNING
                  , typename boost::disable_if<internal::is_Point_set_or_Range_or_Iterator<Graph> >::type* = nullptr
 #endif

BGL/include/CGAL/boost/graph/IO/Generic_facegraph_builder.h

@@ -39,7 +39,7 @@ public:
   Generic_facegraph_builder(std::istream& in_) : m_is(in_) { }
 
   template <typename NamedParameters = parameters::Default_named_parameters>
-  bool operator()(Graph& g, const NamedParameters& np = parameters::use_default_values())
+  bool operator()(Graph& g, const NamedParameters& np = parameters::default_values())
   {
     typedef typename GetK<Graph, NamedParameters>::Kernel                              Kernel;
     typedef typename Kernel::Vector_3                                                  Vector;

BGL/include/CGAL/boost/graph/IO/Generic_facegraph_printer.h

@@ -90,7 +90,7 @@ public:
 
   template <typename NamedParameters = parameters::Default_named_parameters>
   bool operator()(const Graph& g,
-                  const NamedParameters& np = parameters::use_default_values())
+                  const NamedParameters& np = parameters::default_values())
   {
     typedef typename GetVertexPointMap<Graph, NamedParameters>::const_type         VPM;
     typedef typename boost::property_traits<VPM>::reference                        Point_ref;

BGL/include/CGAL/boost/graph/IO/INP.h

@@ -32,7 +32,7 @@ bool write_INP(std::ostream& os,
                const std::string& name,
                const std::string& type,
                const Graph& g,
-               const CGAL_BGL_NP_CLASS& np = parameters::use_default_values())
+               const CGAL_BGL_NP_CLASS& np = parameters::default_values())
 {
   typedef typename boost::graph_traits<Graph>::vertex_descriptor                  vertex_descriptor;
   typedef typename boost::graph_traits<Graph>::face_descriptor                    face_descriptor;
@@ -80,7 +80,7 @@ template <typename Graph, typename CGAL_BGL_NP_TEMPLATE_PARAMETERS>
 bool write_INP(const std::string& fname,
                const std::string& type,
                const Graph& g,
-               const CGAL_BGL_NP_CLASS& np = parameters::use_default_values() )
+               const CGAL_BGL_NP_CLASS& np = parameters::default_values() )
 {
   std::ofstream os(fname);
   return write_INP(os, fname, type, g, np);
@@ -92,7 +92,7 @@ CGAL_DEPRECATED bool write_inp(std::ostream& os,
                const FaceGraph& g,
                std::string name,
                std::string type,
-               const NamedParameters& np = parameters::use_default_values())
+               const NamedParameters& np = parameters::default_values())
 {
   return write_INP(os, name, type, g, np);
 }

BGL/include/CGAL/boost/graph/IO/OBJ.h

@@ -107,7 +107,7 @@ template <typename Graph,
           typename CGAL_BGL_NP_TEMPLATE_PARAMETERS>
 bool read_OBJ(std::istream& is,
               Graph& g,
-              const CGAL_BGL_NP_CLASS& np = parameters::use_default_values()
+              const CGAL_BGL_NP_CLASS& np = parameters::default_values()
 #ifndef DOXYGEN_RUNNING
               , typename boost::disable_if<internal::is_Point_set_or_Range_or_Iterator<Graph> >::type* = nullptr
 #endif
@@ -163,7 +163,7 @@ template <typename Graph,
           typename CGAL_BGL_NP_TEMPLATE_PARAMETERS>
 bool read_OBJ(const std::string& fname,
               Graph& g,
-              const CGAL_BGL_NP_CLASS& np = parameters::use_default_values()
+              const CGAL_BGL_NP_CLASS& np = parameters::default_values()
 #ifndef DOXYGEN_RUNNING
               , typename boost::disable_if<internal::is_Point_set_or_Range_or_Iterator<Graph> >::type* = nullptr
 #endif
@@ -215,7 +215,7 @@ template <typename Graph,
           typename CGAL_BGL_NP_TEMPLATE_PARAMETERS>
 bool write_OBJ(std::ostream& os,
                const Graph& g,
-               const CGAL_BGL_NP_CLASS& np = parameters::use_default_values()
+               const CGAL_BGL_NP_CLASS& np = parameters::default_values()
 #ifndef DOXYGEN_RUNNING
                , typename boost::disable_if<internal::is_Point_set_or_Range_or_Iterator<Graph> >::type* = nullptr
 #endif
@@ -261,7 +261,7 @@ template <typename Graph,
           typename CGAL_BGL_NP_TEMPLATE_PARAMETERS>
 bool write_OBJ(const std::string& fname,
                const Graph& g,
-               const CGAL_BGL_NP_CLASS& np = parameters::use_default_values()
+               const CGAL_BGL_NP_CLASS& np = parameters::default_values()
 #ifndef DOXYGEN_RUNNING
                , typename boost::disable_if<internal::is_Point_set_or_Range_or_Iterator<Graph> >::type* = nullptr
 #endif

BGL/include/CGAL/boost/graph/IO/OFF.h

@@ -153,7 +153,7 @@ template <typename Graph,
           typename CGAL_BGL_NP_TEMPLATE_PARAMETERS>
 bool read_OFF(std::istream& is,
               Graph& g,
-              const CGAL_BGL_NP_CLASS& np = parameters::use_default_values()
+              const CGAL_BGL_NP_CLASS& np = parameters::default_values()
 #ifndef DOXYGEN_RUNNING
               , typename boost::disable_if<internal::is_Point_set_or_Range_or_Iterator<Graph> >::type* = nullptr
 #endif
@@ -237,7 +237,7 @@ template <typename Graph,
           typename CGAL_BGL_NP_TEMPLATE_PARAMETERS>
 bool read_OFF(const std::string& fname,
               Graph& g,
-              const CGAL_BGL_NP_CLASS& np = parameters::use_default_values()
+              const CGAL_BGL_NP_CLASS& np = parameters::default_values()
 #ifndef DOXYGEN_RUNNING
               , typename boost::disable_if<internal::is_Point_set_or_Range_or_Iterator<Graph> >::type* = nullptr
 #endif
@@ -257,7 +257,7 @@ bool read_OFF(const std::string& fname,
  \deprecated This function is deprecated since \cgal 5.3, `CGAL::IO::read_OFF()` should be used instead.
 */
 template <typename Graph, typename CGAL_BGL_NP_TEMPLATE_PARAMETERS>
-CGAL_DEPRECATED bool read_off(std::istream& is, Graph& g, const CGAL_BGL_NP_CLASS& np = parameters::use_default_values())
+CGAL_DEPRECATED bool read_off(std::istream& is, Graph& g, const CGAL_BGL_NP_CLASS& np = parameters::default_values())
 {
   return IO::read_OFF(is, g, np);
 }
@@ -268,7 +268,7 @@ CGAL_DEPRECATED bool read_off(std::istream& is, Graph& g, const CGAL_BGL_NP_CLAS
 \deprecated This function is deprecated since \cgal 5.3, `CGAL::IO::read_OFF()` should be used instead.
 */
 template <typename Graph, typename CGAL_BGL_NP_TEMPLATE_PARAMETERS>
-CGAL_DEPRECATED bool read_off(const char* fname, Graph& g, const CGAL_BGL_NP_CLASS& np = parameters::use_default_values())
+CGAL_DEPRECATED bool read_off(const char* fname, Graph& g, const CGAL_BGL_NP_CLASS& np = parameters::default_values())
 {
  return IO::read_OFF(fname, g, np);
 }
@@ -358,7 +358,7 @@ template <typename Graph,
           typename CGAL_BGL_NP_TEMPLATE_PARAMETERS>
 bool write_OFF(std::ostream& os,
                const Graph& g,
-               const CGAL_BGL_NP_CLASS& np = parameters::use_default_values()
+               const CGAL_BGL_NP_CLASS& np = parameters::default_values()
 #ifndef DOXYGEN_RUNNING
                , typename boost::disable_if<internal::is_Point_set_or_Range_or_Iterator<Graph> >::type* = nullptr
 #endif
@@ -432,7 +432,7 @@ template <typename Graph,
           typename CGAL_BGL_NP_TEMPLATE_PARAMETERS>
 bool write_OFF(const std::string& fname,
                const Graph& g,
-               const CGAL_BGL_NP_CLASS& np = parameters::use_default_values()
+               const CGAL_BGL_NP_CLASS& np = parameters::default_values()
 #ifndef DOXYGEN_RUNNING
                , typename boost::disable_if<internal::is_Point_set_or_Range_or_Iterator<Graph> >::type* = nullptr
 #endif
@@ -458,7 +458,7 @@ bool write_OFF(const std::string& fname,
  \deprecated This function is deprecated since \cgal 5.3, `CGAL::IO::write_OFF()` should be used instead.
 */
 template <typename Graph, typename CGAL_BGL_NP_TEMPLATE_PARAMETERS>
-CGAL_DEPRECATED bool write_off(std::ostream& os, const Graph& g, const CGAL_BGL_NP_CLASS& np = parameters::use_default_values())
+CGAL_DEPRECATED bool write_off(std::ostream& os, const Graph& g, const CGAL_BGL_NP_CLASS& np = parameters::default_values())
 {
   return IO::write_OFF(os, g, np);
 }
@@ -469,7 +469,7 @@ CGAL_DEPRECATED bool write_off(std::ostream& os, const Graph& g, const CGAL_BGL_
 \deprecated This function is deprecated since \cgal 5.3, `CGAL::IO::write_OFF()` should be used instead.
 */
 template <typename Graph, typename CGAL_BGL_NP_TEMPLATE_PARAMETERS>
-CGAL_DEPRECATED bool write_off(const char* fname, const Graph& g, const CGAL_BGL_NP_CLASS& np = parameters::use_default_values())
+CGAL_DEPRECATED bool write_off(const char* fname, const Graph& g, const CGAL_BGL_NP_CLASS& np = parameters::default_values())
 {
  return IO::write_OFF(fname, g, np);
 }

BGL/include/CGAL/boost/graph/IO/PLY.h

@@ -61,7 +61,7 @@ public:
 template <typename Graph, typename CGAL_BGL_NP_TEMPLATE_PARAMETERS>
 bool read_PLY_BGL(std::istream& is,
                   Graph& g,
-                  const CGAL_BGL_NP_CLASS& np = parameters::use_default_values())
+                  const CGAL_BGL_NP_CLASS& np = parameters::default_values())
 {
   typedef typename CGAL::GetVertexPointMap<Graph, CGAL_BGL_NP_CLASS>::type      VPM;
   typedef typename boost::property_traits<VPM>::value_type                      Point;
@@ -134,7 +134,7 @@ template <typename Graph,
           typename CGAL_BGL_NP_TEMPLATE_PARAMETERS>
 bool read_PLY(std::istream& is,
               Graph& g,
-              const CGAL_BGL_NP_CLASS& np = parameters::use_default_values()
+              const CGAL_BGL_NP_CLASS& np = parameters::default_values()
 #ifndef DOXYGEN_RUNNING
               , typename boost::disable_if<internal::is_Point_set_or_Range_or_Iterator<Graph> >::type* = nullptr
 #endif
@@ -209,7 +209,7 @@ template <typename Graph,
           typename CGAL_BGL_NP_TEMPLATE_PARAMETERS>
 bool read_PLY(const std::string& fname,
               Graph& g,
-              const CGAL_BGL_NP_CLASS& np = parameters::use_default_values()
+              const CGAL_BGL_NP_CLASS& np = parameters::default_values()
 #ifndef DOXYGEN_RUNNING
               , typename boost::disable_if<internal::is_Point_set_or_Range_or_Iterator<Graph> >::type* = nullptr
 #endif
@@ -296,7 +296,7 @@ template <typename Graph, typename CGAL_BGL_NP_TEMPLATE_PARAMETERS>
 bool write_PLY(std::ostream& os,
                const Graph& g,
                const std::string& comments,
-               const CGAL_BGL_NP_CLASS& np = parameters::use_default_values()
+               const CGAL_BGL_NP_CLASS& np = parameters::default_values()
 #ifndef DOXYGEN_RUNNING
                , typename boost::disable_if<internal::is_Point_set_or_Range_or_Iterator<Graph> >::type* = nullptr
 #endif
@@ -420,7 +420,7 @@ bool write_PLY(std::ostream& os,
 /// \cond SKIP_IN_MANUAL
 
 template <typename Graph, typename CGAL_BGL_NP_TEMPLATE_PARAMETERS>
-bool write_PLY(std::ostream& os, const Graph& g, const CGAL_BGL_NP_CLASS& np = parameters::use_default_values(),
+bool write_PLY(std::ostream& os, const Graph& g, const CGAL_BGL_NP_CLASS& np = parameters::default_values(),
                typename boost::disable_if<internal::is_Point_set_or_Range_or_Iterator<Graph> >::type* = nullptr)
 {
   return write_PLY(os, g, std::string(), np);
@@ -492,7 +492,7 @@ template <typename Graph, typename CGAL_BGL_NP_TEMPLATE_PARAMETERS>
 bool write_PLY(const std::string& fname,
                const Graph& g,
                const std::string& comments,
-               const CGAL_BGL_NP_CLASS& np = parameters::use_default_values()
+               const CGAL_BGL_NP_CLASS& np = parameters::default_values()
 #ifndef DOXYGEN_RUNNING
                , typename boost::disable_if<internal::is_Point_set_or_Range_or_Iterator<Graph> >::type* = nullptr
 #endif
@@ -517,7 +517,7 @@ bool write_PLY(const std::string& fname,
 /// \cond SKIP_IN_MANUAL
 
 template <typename Graph, typename CGAL_BGL_NP_TEMPLATE_PARAMETERS>
-bool write_PLY(const std::string& fname, const Graph& g, const CGAL_BGL_NP_CLASS& np = parameters::use_default_values(),
+bool write_PLY(const std::string& fname, const Graph& g, const CGAL_BGL_NP_CLASS& np = parameters::default_values(),
                typename boost::disable_if<internal::is_Point_set_or_Range_or_Iterator<Graph> >::type* = nullptr)
 {
   return write_PLY(fname, g, std::string(), np);

BGL/include/CGAL/boost/graph/IO/STL.h

@@ -158,7 +158,7 @@ bool read_STL(std::istream& is,
 template <typename Graph, typename CGAL_BGL_NP_TEMPLATE_PARAMETERS>
 bool read_STL(const std::string& fname,
               Graph& g, const
-              CGAL_BGL_NP_CLASS& np = parameters::use_default_values())
+              CGAL_BGL_NP_CLASS& np = parameters::default_values())
 {
   using parameters::choose_parameter;
   using parameters::get_parameter;
@@ -230,7 +230,7 @@ bool read_STL(const std::string& fname,
 template <typename Graph, typename CGAL_BGL_NP_TEMPLATE_PARAMETERS>
 bool write_STL(std::ostream& os,
                const Graph& g,
-               const CGAL_BGL_NP_CLASS& np = parameters::use_default_values())
+               const CGAL_BGL_NP_CLASS& np = parameters::default_values())
 {
   typedef typename boost::graph_traits<Graph>::halfedge_descriptor                  halfedge_descriptor;
   typedef typename boost::graph_traits<Graph>::face_descriptor                      face_descriptor;
@@ -345,7 +345,7 @@ bool write_STL(std::ostream& os,
   \sa Overloads of this function for specific models of the concept `FaceGraph`.
 */
 template <typename Graph, typename CGAL_BGL_NP_TEMPLATE_PARAMETERS>
-bool write_STL(const std::string& fname, const Graph& g, const CGAL_BGL_NP_CLASS& np = parameters::use_default_values())
+bool write_STL(const std::string& fname, const Graph& g, const CGAL_BGL_NP_CLASS& np = parameters::default_values())
 {
   const bool binary = CGAL::parameters::choose_parameter(CGAL::parameters::get_parameter(np, internal_np::use_binary_mode), true);
   if(binary)

BGL/include/CGAL/boost/graph/IO/VTK.h

@@ -143,7 +143,7 @@ template<typename Graph,
          typename CGAL_BGL_NP_TEMPLATE_PARAMETERS>
 bool read_VTP(const std::string& fname,
               Graph& g,
-              const CGAL_BGL_NP_CLASS& np = parameters::use_default_values())
+              const CGAL_BGL_NP_CLASS& np = parameters::default_values())
 {
   std::ifstream test(fname);
   if(!test.good())
@@ -415,7 +415,7 @@ void write_polys_points(std::ostream& os,
 template<typename Graph, typename CGAL_BGL_NP_TEMPLATE_PARAMETERS>
 bool write_VTP(std::ostream& os,
                const Graph& g,
-               const CGAL_BGL_NP_CLASS& np = parameters::use_default_values())
+               const CGAL_BGL_NP_CLASS& np = parameters::default_values())
 {
   using parameters::get_parameter;
   using parameters::choose_parameter;
@@ -512,7 +512,7 @@ bool write_VTP(std::ostream& os,
  * \returns `true` if writing was successful, `false` otherwise.
  */
 template<typename Graph, typename CGAL_BGL_NP_TEMPLATE_PARAMETERS>
-bool write_VTP(const std::string& fname, const Graph& g, const CGAL_BGL_NP_CLASS& np = parameters::use_default_values())
+bool write_VTP(const std::string& fname, const Graph& g, const CGAL_BGL_NP_CLASS& np = parameters::default_values())
 {
   const bool binary = CGAL::parameters::choose_parameter(CGAL::parameters::get_parameter(np, internal_np::use_binary_mode), true);
   std::ofstream os;
@@ -537,7 +537,7 @@ bool write_VTP(const std::string& fname, const Graph& g, const CGAL_BGL_NP_CLASS
  \deprecated This function is deprecated since \cgal 5.3, `CGAL::IO::write_VTP()` should be used instead.
 */
 template <typename Graph, typename CGAL_BGL_NP_TEMPLATE_PARAMETERS>
-CGAL_DEPRECATED bool write_vtp(std::ostream& os, const Graph& g, const CGAL_BGL_NP_CLASS& np = parameters::use_default_values())
+CGAL_DEPRECATED bool write_vtp(std::ostream& os, const Graph& g, const CGAL_BGL_NP_CLASS& np = parameters::default_values())
 {
   return IO::write_VTP(os, g, np);
 }

BGL/include/CGAL/boost/graph/IO/WRL.h

@@ -64,7 +64,7 @@ namespace IO {
 template <typename Graph, typename CGAL_BGL_NP_TEMPLATE_PARAMETERS>
 bool write_WRL(std::ostream& os,
                const Graph& g,
-               const CGAL_BGL_NP_CLASS& np = parameters::use_default_values())
+               const CGAL_BGL_NP_CLASS& np = parameters::default_values())
 {
   CGAL::VRML_2_ostream vos(os);
   internal::Generic_facegraph_printer<CGAL::VRML_2_ostream, Graph, CGAL::File_writer_VRML_2> printer(vos);
@@ -103,7 +103,7 @@ bool write_WRL(std::ostream& os,
   \returns `true` if writing was successful, `false` otherwise.
 */
 template <typename Graph, typename CGAL_BGL_NP_TEMPLATE_PARAMETERS>
-bool write_WRL(const std::string& fname, const Graph& g, const CGAL_BGL_NP_CLASS& np = parameters::use_default_values())
+bool write_WRL(const std::string& fname, const Graph& g, const CGAL_BGL_NP_CLASS& np = parameters::default_values())
 {
   std::ofstream os(fname);
   return write_WRL(os, g, np);
@@ -119,7 +119,7 @@ bool write_WRL(const std::string& fname, const Graph& g, const CGAL_BGL_NP_CLASS
  \deprecated This function is deprecated since \cgal 5.3, `CGAL::IO::write_WRL()` should be used instead.
 */
 template <typename Graph, typename CGAL_BGL_NP_TEMPLATE_PARAMETERS>
-CGAL_DEPRECATED bool write_wrl(std::ostream& os, const Graph& g, const CGAL_BGL_NP_CLASS& np = parameters::use_default_values())
+CGAL_DEPRECATED bool write_wrl(std::ostream& os, const Graph& g, const CGAL_BGL_NP_CLASS& np = parameters::default_values())
 {
   return IO::write_WRL(os, g, np);
 }

BGL/include/CGAL/boost/graph/IO/polygon_mesh_io.h

@@ -39,7 +39,7 @@ namespace IO {
 template <class Graph, typename NamedParameters = parameters::Default_named_parameters>
 bool read_polygon_mesh(std::istream& is,
                        Graph& g,
-                       const NamedParameters& np = parameters::use_default_values())
+                       const NamedParameters& np = parameters::default_values())
 {
   bool ok = false;
   ok = read_OFF(is, g, np, false);
@@ -122,7 +122,7 @@ bool read_polygon_mesh(std::istream& is,
 template <class Graph, typename NamedParameters = parameters::Default_named_parameters>
 bool read_polygon_mesh(const std::string& fname,
                        Graph& g,
-                       const NamedParameters& np = parameters::use_default_values())
+                       const NamedParameters& np = parameters::default_values())
 {
   const bool verbose = parameters::choose_parameter(parameters::get_parameter(np, internal_np::verbose), false);
 
@@ -215,7 +215,7 @@ bool read_polygon_mesh(const std::string& fname,
 template <class Graph, typename NamedParameters = parameters::Default_named_parameters>
 bool write_polygon_mesh(const std::string& fname,
                         Graph& g,
-                        const NamedParameters& np = parameters::use_default_values())
+                        const NamedParameters& np = parameters::default_values())
 {
   const bool verbose = parameters::choose_parameter(parameters::get_parameter(np, internal_np::verbose), false);
 

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

@@ -185,7 +185,7 @@ void partition_dual_graph(const TriangleMesh& tm, int nparts,
 /// \pre `tm` is a pure triangular surface mesh: there are no edges
 ///       without at least one incident face
 template<typename TriangleMesh, typename NamedParameters = parameters::Default_named_parameters>
-void partition_dual_graph(const TriangleMesh& tm, int nparts, const NamedParameters& np = parameters::use_default_values())
+void partition_dual_graph(const TriangleMesh& tm, int nparts, const NamedParameters& np = parameters::default_values())
 {
   using parameters::get_parameter;
 

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

@@ -218,7 +218,7 @@ void partition_graph(const TriangleMesh& tm, int nparts,
 /// \pre `tm` is a pure triangular surface mesh: there are no edges
 ///       without at least one incident face
 template<typename TriangleMesh, typename NamedParameters = parameters::Default_named_parameters>
-void partition_graph(const TriangleMesh& tm, int nparts, const NamedParameters& np = parameters::use_default_values())
+void partition_graph(const TriangleMesh& tm, int nparts, const NamedParameters& np = parameters::default_values())
 {
   using parameters::get_parameter;
 

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

@@ -513,7 +513,7 @@ double alpha_expansion_graphcut (const InputGraph& input_graph,
                                  EdgeCostMap edge_cost_map,
                                  VertexLabelCostMap vertex_label_cost_map,
                                  VertexLabelMap vertex_label_map,
-                                 const NamedParameters& np = parameters::use_default_values())
+                                 const NamedParameters& np = parameters::default_values())
 {
   using parameters::choose_parameter;
   using parameters::get_parameter;

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

@@ -355,8 +355,8 @@ template <typename SourceMesh, typename TargetMesh,
           typename NamedParameters2 = parameters::Default_named_parameters
           >
 void copy_face_graph(const SourceMesh& sm, TargetMesh& tm,
-                     const NamedParameters1& np1 =  parameters::use_default_values(),
+                     const NamedParameters1& np1 =  parameters::default_values(),
-                     const NamedParameters2& np2 = parameters::use_default_values()
+                     const NamedParameters2& np2 = parameters::default_values()
                      )
 {
   using parameters::choose_parameter;

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

@@ -224,7 +224,7 @@ typename BGL::internal::GetInitializedIndexMap<CGAL::internal_np::DTYPE##_index_
                                                CGAL::dynamic_##DTYPE##_property_t<STYPE>,          \
                                                Graph, NamedParameters>::const_type                 \
 get_initialized_##DTYPE##_index_map(const Graph& g,                                                \
-                                    const NamedParameters& np = parameters::use_default_values())  \
+                                    const NamedParameters& np = parameters::default_values())  \
 {                                                                                                  \
   typedef BGL::internal::GetInitializedIndexMap<CGAL::internal_np::DTYPE##_index_t,                \
                                                 boost::DTYPE##_index_t,                            \
@@ -243,7 +243,7 @@ typename BGL::internal::GetInitializedIndexMap<CGAL::internal_np::DTYPE##_index_
                                                CGAL::dynamic_##DTYPE##_property_t<STYPE>,          \
                                                Graph, NamedParameters>::type                       \
 get_initialized_##DTYPE##_index_map(Graph& g,                                                      \
-                                    const NamedParameters& np = parameters::use_default_values())  \
+                                    const NamedParameters& np = parameters::default_values())  \
 {                                                                                                  \
   typedef BGL::internal::GetInitializedIndexMap<CGAL::internal_np::DTYPE##_index_t,                \
                                                 boost::DTYPE##_index_t,                            \

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

@@ -504,7 +504,7 @@ regularize_face_selection_borders(
   TriangleMesh& mesh,
   IsSelectedMap is_selected,
   double weight,
-  const NamedParameters& np = parameters::use_default_values())
+  const NamedParameters& np = parameters::default_values())
 {
   using parameters::choose_parameter;
   using parameters::get_parameter;

BGL/test/BGL/test_Face_filtered_graph.cpp

@@ -278,7 +278,7 @@ void test_index_property_maps(const Graph& g)
 
   typedef typename boost::graph_traits<Graph>::face_descriptor g_face_descriptor;
   std::map<g_face_descriptor, std::size_t> map;
-  PMP::connected_components(g, boost::make_assoc_property_map(map), CGAL::parameters::use_default_values());
+  PMP::connected_components(g, boost::make_assoc_property_map(map), CGAL::parameters::default_values());
   Adapter fg(g, -1, boost::make_assoc_property_map(map));
   assert(is_empty(fg));
 

Convex_hull_3/include/CGAL/convex_hull_3.h

@@ -1063,7 +1063,7 @@ void convex_hull_3(InputIterator first, InputIterator beyond,
 template <class VertexListGraph, class PolygonMesh, class NamedParameters = parameters::Default_named_parameters>
 void convex_hull_3(const VertexListGraph& g,
                    PolygonMesh& pm,
-                   const NamedParameters& np = parameters::use_default_values())
+                   const NamedParameters& np = parameters::default_values())
 {
   using CGAL::parameters::choose_parameter;
   using CGAL::parameters::get_parameter;

Convex_hull_3/test/Convex_hull_3/test_ch_3_ambiguity.cpp

@@ -23,7 +23,7 @@ int main(int argc, char* argv[])
 
   Surface_mesh chull;
   // compute convex hull
-  auto np = CGAL::parameters::use_default_values();
+  auto np = CGAL::parameters::default_values();
   CGAL::convex_hull_3(poly, chull, np);
   std::cout << "The convex hull contains " << chull.number_of_vertices() << " vertices" << std::endl;
   return 0;

Optimal_bounding_box/include/CGAL/Optimal_bounding_box/oriented_bounding_box.h

@@ -315,7 +315,7 @@ template <typename PointRange,
           typename NamedParameters = parameters::Default_named_parameters>
 void oriented_bounding_box(const PointRange& points,
                            Output& out,
-                           const NamedParameters& np = parameters::use_default_values()
+                           const NamedParameters& np = parameters::default_values()
 #ifndef DOXYGEN_RUNNING
                            , typename boost::enable_if<
                                typename boost::has_range_iterator<PointRange>
@@ -416,7 +416,7 @@ template <typename PolygonMesh,
           typename NamedParameters = parameters::Default_named_parameters>
 void oriented_bounding_box(const PolygonMesh& pmesh,
                            Output& out,
-                           const NamedParameters& np = parameters::use_default_values()
+                           const NamedParameters& np = parameters::default_values()
 #ifndef DOXYGEN_RUNNING
                            , typename boost::disable_if<
                               typename boost::has_range_iterator<PolygonMesh>

Point_set_3/include/CGAL/Point_set_3/IO.h

@@ -121,7 +121,7 @@ namespace IO {
 template <typename Point, typename Vector, typename CGAL_BGL_NP_TEMPLATE_PARAMETERS>
 bool read_point_set(const std::string& fname,
                     CGAL::Point_set_3<Point, Vector>& ps,
-                    const CGAL_BGL_NP_CLASS& np = parameters::use_default_values())
+                    const CGAL_BGL_NP_CLASS& np = parameters::default_values())
 {
   const std::string ext = internal::get_file_extension(fname);
 
@@ -214,7 +214,7 @@ namespace IO {
 template <typename Point, typename Vector, typename CGAL_BGL_NP_TEMPLATE_PARAMETERS>
 bool write_point_set(const std::string& fname,
                      CGAL::Point_set_3<Point, Vector>& ps,
-                     const CGAL_BGL_NP_CLASS& np = parameters::use_default_values())
+                     const CGAL_BGL_NP_CLASS& np = parameters::default_values())
 {
   const std::string ext = internal::get_file_extension(fname);
 

Point_set_3/include/CGAL/Point_set_3/IO/OFF.h

@@ -143,7 +143,7 @@ namespace IO {
 template <typename Point, typename Vector, typename CGAL_BGL_NP_TEMPLATE_PARAMETERS>
 bool write_OFF(std::ostream& os,
                const CGAL::Point_set_3<Point, Vector>& point_set,
-               const CGAL_BGL_NP_CLASS& np = parameters::use_default_values())
+               const CGAL_BGL_NP_CLASS& np = parameters::default_values())
 {
   if(point_set.has_normal_map())
     return Point_set_processing_3::internal::write_OFF_PSP(os, point_set,
@@ -180,7 +180,7 @@ bool write_OFF(std::ostream& os,
   \return `true` if the writing was successful, `false` otherwise.
 */
 template <typename Point, typename Vector, typename CGAL_BGL_NP_TEMPLATE_PARAMETERS>
-bool write_OFF(const std::string& fname, const CGAL::Point_set_3<Point, Vector>& point_set, const CGAL_BGL_NP_CLASS& np = parameters::use_default_values())
+bool write_OFF(const std::string& fname, const CGAL::Point_set_3<Point, Vector>& point_set, const CGAL_BGL_NP_CLASS& np = parameters::default_values())
 {
   std::ofstream os(fname);
   return write_OFF(os, point_set, np);

Point_set_3/include/CGAL/Point_set_3/IO/PLY.h

@@ -337,7 +337,7 @@ template <typename Point, typename Vector, typename CGAL_BGL_NP_TEMPLATE_PARAMET
 bool read_PLY(const std::string& fname,
               CGAL::Point_set_3<Point, Vector>& point_set,
               std::string& comments,
-              const CGAL_BGL_NP_CLASS& np = parameters::use_default_values())
+              const CGAL_BGL_NP_CLASS& np = parameters::default_values())
 {
   const bool binary = CGAL::parameters::choose_parameter(CGAL::parameters::get_parameter(np, internal_np::use_binary_mode), true);
   if(binary)
@@ -356,7 +356,7 @@ bool read_PLY(const std::string& fname,
 
 /// \cond SKIP_IN_MANUAL
 template <typename Point, typename Vector, typename CGAL_BGL_NP_TEMPLATE_PARAMETERS>
-bool read_PLY(const std::string& fname, CGAL::Point_set_3<Point, Vector>& point_set, const CGAL_BGL_NP_CLASS& np = parameters::use_default_values())
+bool read_PLY(const std::string& fname, CGAL::Point_set_3<Point, Vector>& point_set, const CGAL_BGL_NP_CLASS& np = parameters::default_values())
 {
   std::string unused_comments;
   return read_PLY(fname, point_set, unused_comments, np);
@@ -450,7 +450,7 @@ template <typename Point, typename Vector, typename CGAL_BGL_NP_TEMPLATE_PARAMET
 bool write_PLY(std::ostream& os,
                const CGAL::Point_set_3<Point, Vector>& point_set,
                const std::string& comments,
-               const CGAL_BGL_NP_CLASS& np = parameters::use_default_values())
+               const CGAL_BGL_NP_CLASS& np = parameters::default_values())
 {
   typedef CGAL::Point_set_3<Point, Vector> Point_set;
   typedef typename Point_set::Index Index;
@@ -664,7 +664,7 @@ bool write_PLY(std::ostream& os,
 /// \cond SKIP_IN_MANUAL
 
 template <typename Point, typename Vector, typename CGAL_BGL_NP_TEMPLATE_PARAMETERS>
-bool write_PLY(std::ostream& os, const CGAL::Point_set_3<Point, Vector>& point_set, const CGAL_BGL_NP_CLASS& np = parameters::use_default_values())
+bool write_PLY(std::ostream& os, const CGAL::Point_set_3<Point, Vector>& point_set, const CGAL_BGL_NP_CLASS& np = parameters::default_values())
 {
   return write_PLY(os, point_set, std::string(), np);
 }
@@ -733,7 +733,7 @@ bool write_PLY(const std::string& fname,
 /// \cond SKIP_IN_MANUAL
 
 template <typename Point, typename Vector, typename CGAL_BGL_NP_TEMPLATE_PARAMETERS>
-bool write_PLY(const std::string& fname, const CGAL::Point_set_3<Point, Vector>& point_set, const CGAL_BGL_NP_CLASS& np = parameters::use_default_values())
+bool write_PLY(const std::string& fname, const CGAL::Point_set_3<Point, Vector>& point_set, const CGAL_BGL_NP_CLASS& np = parameters::default_values())
 {
   return write_PLY(fname, point_set, std::string(), np);
 }

Point_set_3/include/CGAL/Point_set_3/IO/XYZ.h

@@ -141,7 +141,7 @@ namespace IO {
 template <typename Point, typename Vector, typename CGAL_BGL_NP_TEMPLATE_PARAMETERS>
 bool write_XYZ(std::ostream& os,
                const CGAL::Point_set_3<Point, Vector>& point_set,
-               const CGAL_BGL_NP_CLASS& np = parameters::use_default_values())
+               const CGAL_BGL_NP_CLASS& np = parameters::default_values())
 {
   if(point_set.has_normal_map())
     return Point_set_processing_3::internal::write_XYZ_PSP(os, point_set,
@@ -177,7 +177,7 @@ bool write_XYZ(std::ostream& os,
   \return `true` if the writing was successful, `false` otherwise.
  */
 template <typename Point, typename Vector, typename CGAL_BGL_NP_TEMPLATE_PARAMETERS>
-bool write_XYZ(const std::string& fname, const CGAL::Point_set_3<Point, Vector>& point_set, const CGAL_BGL_NP_CLASS& np = parameters::use_default_values())
+bool write_XYZ(const std::string& fname, const CGAL::Point_set_3<Point, Vector>& point_set, const CGAL_BGL_NP_CLASS& np = parameters::default_values())
 {
   std::ofstream os(fname);
   return write_XYZ(os, point_set, np);

Point_set_processing_3/include/CGAL/IO/read_las_points.h

@@ -459,7 +459,7 @@ template <typename OutputIteratorValueType,
           typename CGAL_BGL_NP_TEMPLATE_PARAMETERS>
 bool read_LAS(std::istream& is,
               PointOutputIterator output,
-              const CGAL_BGL_NP_CLASS& np = parameters::use_default_values())
+              const CGAL_BGL_NP_CLASS& np = parameters::default_values())
 {
   using parameters::choose_parameter;
   using parameters::get_parameter;
@@ -475,7 +475,7 @@ bool read_LAS(std::istream& is,
 /// \cond SKIP_IN_MANUAL
 
 template <typename OutputIterator, typename CGAL_BGL_NP_TEMPLATE_PARAMETERS>
-bool read_LAS(std::istream& is, OutputIterator output, const CGAL_BGL_NP_CLASS& np = parameters::use_default_values(),
+bool read_LAS(std::istream& is, OutputIterator output, const CGAL_BGL_NP_CLASS& np = parameters::default_values(),
               typename std::enable_if<CGAL::is_iterator<OutputIterator>::value>::type* = nullptr)
 {
   return read_LAS<typename value_type_traits<OutputIterator>::type>(is, output, np);
@@ -523,7 +523,7 @@ template <typename OutputIteratorValueType,
           typename CGAL_BGL_NP_TEMPLATE_PARAMETERS>
 bool read_LAS(const std::string& filename,
               PointOutputIterator output,
-              const CGAL_BGL_NP_CLASS& np = parameters::use_default_values())
+              const CGAL_BGL_NP_CLASS& np = parameters::default_values())
 {
   std::ifstream is(filename, std::ios::binary);
   CGAL::IO::set_mode(is, CGAL::IO::BINARY);
@@ -533,7 +533,7 @@ bool read_LAS(const std::string& filename,
 /// \cond SKIP_IN_MANUAL
 
 template <typename OutputIterator,typename CGAL_BGL_NP_TEMPLATE_PARAMETERS>
-bool read_LAS(const std::string& fname, OutputIterator output, const CGAL_BGL_NP_CLASS& np = parameters::use_default_values())
+bool read_LAS(const std::string& fname, OutputIterator output, const CGAL_BGL_NP_CLASS& np = parameters::default_values())
 {
   std::ifstream is(fname, std::ios::binary);
   CGAL::IO::set_mode(is, CGAL::IO::BINARY);
@@ -613,7 +613,7 @@ template <typename OutputIteratorValueType,
           typename CGAL_BGL_NP_TEMPLATE_PARAMETERS>
 CGAL_DEPRECATED bool read_las_points(std::istream& is,
                                      OutputIterator output,
-                                     const CGAL_BGL_NP_CLASS& np = parameters::use_default_values())
+                                     const CGAL_BGL_NP_CLASS& np = parameters::default_values())
 {
   using parameters::choose_parameter;
   using parameters::get_parameter;
@@ -629,7 +629,7 @@ CGAL_DEPRECATED bool read_las_points(std::istream& is,
 
 // variant with default output iterator value type
 template <typename OutputIterator, typename CGAL_BGL_NP_TEMPLATE_PARAMETERS>
-CGAL_DEPRECATED bool read_las_points(std::istream& is, OutputIterator output, const CGAL_BGL_NP_CLASS& np = parameters::use_default_values())
+CGAL_DEPRECATED bool read_las_points(std::istream& is, OutputIterator output, const CGAL_BGL_NP_CLASS& np = parameters::default_values())
 {
   return IO::read_LAS<typename value_type_traits<OutputIterator>::type>(is, output, np);
 }

Point_set_processing_3/include/CGAL/IO/read_off_points.h

@@ -80,7 +80,7 @@ template <typename OutputIteratorValueType,
           typename CGAL_BGL_NP_TEMPLATE_PARAMETERS>
 bool read_OFF(std::istream& is,
               PointOutputIterator output,
-              const CGAL_BGL_NP_CLASS& np = parameters::use_default_values()
+              const CGAL_BGL_NP_CLASS& np = parameters::default_values()
 #ifndef DOXYGEN_RUNNING
               , typename std::enable_if<CGAL::is_iterator<PointOutputIterator>::value>::type* = nullptr
 #endif
@@ -242,7 +242,7 @@ template <typename OutputIteratorValueType,
           typename CGAL_BGL_NP_TEMPLATE_PARAMETERS>
 bool read_OFF(const std::string& fname,
               PointOutputIterator output,
-              const CGAL_BGL_NP_CLASS& np = parameters::use_default_values()
+              const CGAL_BGL_NP_CLASS& np = parameters::default_values()
 #ifndef DOXYGEN_RUNNING
               , typename std::enable_if<CGAL::is_iterator<PointOutputIterator>::value>::type* = nullptr
 #endif
@@ -257,14 +257,14 @@ bool read_OFF(const std::string& fname,
 // variants with default output iterator value type
 template <typename OutputIterator,
           typename CGAL_BGL_NP_TEMPLATE_PARAMETERS>
-bool read_OFF(std::istream& is, OutputIterator output, const CGAL_BGL_NP_CLASS& np = parameters::use_default_values(),
+bool read_OFF(std::istream& is, OutputIterator output, const CGAL_BGL_NP_CLASS& np = parameters::default_values(),
               typename std::enable_if<CGAL::is_iterator<OutputIterator>::value>::type* = nullptr)
 {
   return read_OFF<typename value_type_traits<OutputIterator>::type>(is, output, np);
 }
 
 template <typename OutputIterator,typename CGAL_BGL_NP_TEMPLATE_PARAMETERS>
-bool read_OFF(const std::string& fname, OutputIterator output, const CGAL_BGL_NP_CLASS& np = parameters::use_default_values(),
+bool read_OFF(const std::string& fname, OutputIterator output, const CGAL_BGL_NP_CLASS& np = parameters::default_values(),
               typename std::enable_if<CGAL::is_iterator<OutputIterator>::value>::type* = nullptr)
 {
   std::ifstream is(fname);
@@ -425,7 +425,7 @@ template <typename OutputIteratorValueType,
           typename CGAL_BGL_NP_TEMPLATE_PARAMETERS>
 CGAL_DEPRECATED bool read_off_points(std::istream& is,
                                      OutputIterator output,
-                                     const CGAL_BGL_NP_CLASS& np = parameters::use_default_values())
+                                     const CGAL_BGL_NP_CLASS& np = parameters::default_values())
 {
   return IO::read_OFF(is, output, np);
 }
@@ -440,7 +440,7 @@ CGAL_DEPRECATED bool read_off_points(std::istream& is, OutputIterator output)
 
 // variant with default output iterator value type
 template <typename OutputIterator, typename CGAL_BGL_NP_TEMPLATE_PARAMETERS>
-CGAL_DEPRECATED bool read_off_points(std::istream& is, OutputIterator output, const CGAL_BGL_NP_CLASS& np = parameters::use_default_values())
+CGAL_DEPRECATED bool read_off_points(std::istream& is, OutputIterator output, const CGAL_BGL_NP_CLASS& np = parameters::default_values())
 {
   return IO::read_OFF(is, output, np);
 }

Point_set_processing_3/include/CGAL/IO/read_ply_points.h

@@ -242,7 +242,7 @@ template <typename OutputIteratorValueType,
           typename CGAL_BGL_NP_TEMPLATE_PARAMETERS>
 bool read_PLY(std::istream& is,
               PointOutputIterator output,
-              const CGAL_BGL_NP_CLASS& np = parameters::use_default_values()
+              const CGAL_BGL_NP_CLASS& np = parameters::default_values()
 #ifndef DOXYGEN_RUNNING
               , typename std::enable_if<CGAL::is_iterator<PointOutputIterator>::value>::type* = nullptr
 #endif
@@ -324,7 +324,7 @@ template <typename OutputIteratorValueType,
           typename CGAL_BGL_NP_TEMPLATE_PARAMETERS>
 bool read_PLY(const std::string& fname,
               PointOutputIterator output,
-              const CGAL_BGL_NP_CLASS& np = parameters::use_default_values()
+              const CGAL_BGL_NP_CLASS& np = parameters::default_values()
 #ifndef DOXYGEN_RUNNING
               , typename std::enable_if<CGAL::is_iterator<PointOutputIterator>::value>::type* = nullptr
 #endif
@@ -349,14 +349,14 @@ bool read_PLY(const std::string& fname,
 
 // variants with default output iterator value type
 template <typename OutputIterator, typename CGAL_BGL_NP_TEMPLATE_PARAMETERS>
-bool read_PLY(std::istream& is, OutputIterator output, const CGAL_BGL_NP_CLASS& np = parameters::use_default_values(),
+bool read_PLY(std::istream& is, OutputIterator output, const CGAL_BGL_NP_CLASS& np = parameters::default_values(),
               typename std::enable_if<CGAL::is_iterator<OutputIterator>::value>::type* = nullptr)
 {
   return read_PLY<typename value_type_traits<OutputIterator>::type>(is, output, np);
 }
 
 template <typename OutputIterator,typename CGAL_BGL_NP_TEMPLATE_PARAMETERS>
-bool read_PLY(const std::string& fname, OutputIterator output, const CGAL_BGL_NP_CLASS& np = parameters::use_default_values(),
+bool read_PLY(const std::string& fname, OutputIterator output, const CGAL_BGL_NP_CLASS& np = parameters::default_values(),
               typename std::enable_if<CGAL::is_iterator<OutputIterator>::value>::type* = nullptr)
 {
   return read_PLY<typename value_type_traits<OutputIterator>::type>(fname, output, np);
@@ -459,7 +459,7 @@ CGAL_DEPRECATED bool read_ply_points_with_properties(std::istream& is, OutputIte
                \link PkgPointSetProcessing3IOPly `CGAL::IO::read_PLY()` \endlink should be used instead.
   */
 template <typename OutputIteratorValueType, typename OutputIterator, typename CGAL_BGL_NP_TEMPLATE_PARAMETERS>
-CGAL_DEPRECATED bool read_ply_points(std::istream& is, OutputIterator output, const CGAL_BGL_NP_CLASS& np = parameters::use_default_values())
+CGAL_DEPRECATED bool read_ply_points(std::istream& is, OutputIterator output, const CGAL_BGL_NP_CLASS& np = parameters::default_values())
 {
   return IO::read_PLY(is, output, np);
 }
@@ -476,7 +476,7 @@ CGAL_DEPRECATED bool read_ply_points_with_properties(std::istream& is, OutputIte
 // variant with default output iterator value type
 template <typename OutputIterator,
           typename CGAL_BGL_NP_TEMPLATE_PARAMETERS>
-CGAL_DEPRECATED bool read_ply_points(std::istream& is, OutputIterator output, const CGAL_BGL_NP_CLASS& np = parameters::use_default_values())
+CGAL_DEPRECATED bool read_ply_points(std::istream& is, OutputIterator output, const CGAL_BGL_NP_CLASS& np = parameters::default_values())
 {
   return IO::read_PLY<typename value_type_traits<OutputIterator>::type>(is, output, np);
 }

Point_set_processing_3/include/CGAL/IO/read_points.h

@@ -88,7 +88,7 @@ template <typename OutputIteratorValueType,
           typename NamedParameters = parameters::Default_named_parameters>
 bool read_points(const std::string& fname,
                  PointOutputIterator output,
-                 const NamedParameters& np = parameters::use_default_values())
+                 const NamedParameters& np = parameters::default_values())
 {
   const std::string ext = internal::get_file_extension(fname);
 
@@ -110,7 +110,7 @@ bool read_points(const std::string& fname,
 
 // variant with default OutputIteratorType
 template <typename OutputIterator, typename NamedParameters = parameters::Default_named_parameters>
-bool read_points(const std::string& fname, OutputIterator output, const NamedParameters& np = parameters::use_default_values())
+bool read_points(const std::string& fname, OutputIterator output, const NamedParameters& np = parameters::default_values())
 {
   return read_points<typename value_type_traits<OutputIterator>::type>(fname, output, np);
 }

Point_set_processing_3/include/CGAL/IO/read_xyz_points.h

@@ -77,7 +77,7 @@ template <typename OutputIteratorValueType,
           typename CGAL_BGL_NP_TEMPLATE_PARAMETERS>
 bool read_XYZ(std::istream& is,
               OutputIterator output,
-              const CGAL_BGL_NP_CLASS& np = parameters::use_default_values())
+              const CGAL_BGL_NP_CLASS& np = parameters::default_values())
 {
   using parameters::choose_parameter;
   using parameters::get_parameter;
@@ -226,7 +226,7 @@ template <typename OutputIteratorValueType,
            typename CGAL_BGL_NP_TEMPLATE_PARAMETERS>
 bool read_XYZ(const std::string& fname,
               OutputIterator output,
-              const CGAL_BGL_NP_CLASS& np = parameters::use_default_values())
+              const CGAL_BGL_NP_CLASS& np = parameters::default_values())
 {
   std::ifstream is(fname);
   return read_XYZ<OutputIteratorValueType>(is, output, np);
@@ -236,14 +236,14 @@ bool read_XYZ(const std::string& fname,
 
 // variants with default output iterator value type
 template <typename OutputIterator, typename CGAL_BGL_NP_TEMPLATE_PARAMETERS>
-bool read_XYZ(std::istream& is, OutputIterator output, const CGAL_BGL_NP_CLASS& np = parameters::use_default_values(),
+bool read_XYZ(std::istream& is, OutputIterator output, const CGAL_BGL_NP_CLASS& np = parameters::default_values(),
               typename std::enable_if<CGAL::is_iterator<OutputIterator>::value>::type* = nullptr)
 {
   return read_XYZ<typename value_type_traits<OutputIterator>::type>(is, output, np);
 }
 
 template <typename OutputIterator,typename CGAL_BGL_NP_TEMPLATE_PARAMETERS>
-bool read_XYZ(const std::string& fname, OutputIterator output, const CGAL_BGL_NP_CLASS& np = parameters::use_default_values())
+bool read_XYZ(const std::string& fname, OutputIterator output, const CGAL_BGL_NP_CLASS& np = parameters::default_values())
 {
   std::ifstream is(fname);
   return read_XYZ<typename value_type_traits<OutputIterator>::type>(is, output, np);
@@ -409,7 +409,7 @@ template <typename OutputIteratorValueType,
           typename CGAL_BGL_NP_TEMPLATE_PARAMETERS>
 CGAL_DEPRECATED bool read_xyz_points(std::istream& is,
                                      OutputIterator output,
-                                     const CGAL_BGL_NP_CLASS& np = parameters::use_default_values())
+                                     const CGAL_BGL_NP_CLASS& np = parameters::default_values())
 {
   return IO::read_XYZ(is, output, np);
 }
@@ -419,7 +419,7 @@ template <typename OutputIterator,
           typename CGAL_BGL_NP_TEMPLATE_PARAMETERS>
 CGAL_DEPRECATED bool read_xyz_points(std::istream& is,
                                      OutputIterator output,
-                                     const CGAL_BGL_NP_CLASS& np = parameters::use_default_values())
+                                     const CGAL_BGL_NP_CLASS& np = parameters::default_values())
 {
   return IO::read_XYZ<typename value_type_traits<OutputIterator>::type>(is, output, np);
 }

Point_set_processing_3/include/CGAL/IO/write_las_points.h

@@ -280,7 +280,7 @@ bool write_LAS_with_properties(std::ostream& os, ///< output stream.
 template <typename PointRange, typename CGAL_BGL_NP_TEMPLATE_PARAMETERS>
 bool write_LAS(std::ostream& os,
                const PointRange& points,
-               const CGAL_BGL_NP_CLASS& np = parameters::use_default_values()
+               const CGAL_BGL_NP_CLASS& np = parameters::default_values()
 #ifndef DOXYGEN_RUNNING
                , typename boost::enable_if<internal::is_Range<PointRange> >::type* = nullptr
 #endif
@@ -335,7 +335,7 @@ bool write_LAS(std::ostream& os,
 template <typename PointRange, typename CGAL_BGL_NP_TEMPLATE_PARAMETERS>
 bool write_LAS(const std::string& filename,
                const PointRange& points,
-               const CGAL_BGL_NP_CLASS& np = parameters::use_default_values()
+               const CGAL_BGL_NP_CLASS& np = parameters::default_values()
 #ifndef DOXYGEN_RUNNING
                , typename boost::enable_if<internal::is_Range<PointRange> >::type* = nullptr
 #endif
@@ -403,7 +403,7 @@ CGAL_DEPRECATED bool write_las_points_with_properties(std::ostream& os,
   \deprecated This function is deprecated since \cgal 5.3, `CGAL::IO::write_LAS()` should be used instead.
 */
 template <typename PointRange, typename CGAL_BGL_NP_TEMPLATE_PARAMETERS>
-bool write_las_points(std::ostream& os, const PointRange& points, const CGAL_BGL_NP_CLASS& np = parameters::use_default_values())
+bool write_las_points(std::ostream& os, const PointRange& points, const CGAL_BGL_NP_CLASS& np = parameters::default_values())
 {
   return IO::write_LAS(os, points, np);
 }

Point_set_processing_3/include/CGAL/IO/write_off_points.h

@@ -37,7 +37,7 @@ namespace internal {
 template <typename PointRange, typename CGAL_BGL_NP_TEMPLATE_PARAMETERS>
 bool write_OFF_PSP(std::ostream& os,
                    const PointRange& points,
-                   const CGAL_BGL_NP_CLASS& np = CGAL::parameters::use_default_values())
+                   const CGAL_BGL_NP_CLASS& np = CGAL::parameters::default_values())
 {
   using CGAL::parameters::choose_parameter;
   using CGAL::parameters::get_parameter;
@@ -133,7 +133,7 @@ namespace IO {
 template <typename PointRange, typename CGAL_BGL_NP_TEMPLATE_PARAMETERS>
 bool write_OFF(std::ostream& os,
                const PointRange& points,
-               const CGAL_BGL_NP_CLASS& np = parameters::use_default_values()
+               const CGAL_BGL_NP_CLASS& np = parameters::default_values()
 #ifndef DOXYGEN_RUNNING
                , typename boost::enable_if<internal::is_Range<PointRange> >::type* = nullptr
 #endif
@@ -189,7 +189,7 @@ template <typename PointRange,
           typename CGAL_BGL_NP_TEMPLATE_PARAMETERS>
 bool write_OFF(const std::string& filename,
                const PointRange& points,
-               const CGAL_BGL_NP_CLASS& np = parameters::use_default_values()
+               const CGAL_BGL_NP_CLASS& np = parameters::default_values()
 #ifndef DOXYGEN_RUNNING
                , typename boost::enable_if<internal::is_Range<PointRange> >::type* = nullptr
 #endif
@@ -302,7 +302,7 @@ bool write_off_points(std::ostream& os, ///< output stream.
               \link PkgPointSetProcessing3IOOff `CGAL::IO::write_OFF()` \endlink should be used instead.
 */
 template <typename PointRange, typename CGAL_BGL_NP_TEMPLATE_PARAMETERS>
-CGAL_DEPRECATED bool write_off_points(std::ostream& os, const PointRange& points, const CGAL_BGL_NP_CLASS& np = parameters::use_default_values())
+CGAL_DEPRECATED bool write_off_points(std::ostream& os, const PointRange& points, const CGAL_BGL_NP_CLASS& np = parameters::default_values())
 {
   return IO::write_OFF(os, points, np);
 }

Point_set_processing_3/include/CGAL/IO/write_ply_points.h

@@ -187,7 +187,7 @@ template <typename PointRange,
 template <typename PointRange, typename CGAL_BGL_NP_TEMPLATE_PARAMETERS>
 bool write_PLY(std::ostream& os,
                const PointRange& points,
-               const CGAL_BGL_NP_CLASS& np = parameters::use_default_values()
+               const CGAL_BGL_NP_CLASS& np = parameters::default_values()
 #ifndef DOXYGEN_RUNNING
                , typename boost::enable_if<internal::is_Range<PointRange> >::type* = nullptr
 #endif
@@ -275,7 +275,7 @@ bool write_PLY(std::ostream& os,
 template <typename PointRange, typename CGAL_BGL_NP_TEMPLATE_PARAMETERS>
 bool write_PLY(const std::string& filename,
                const PointRange& points,
-               const CGAL_BGL_NP_CLASS& np = parameters::use_default_values()
+               const CGAL_BGL_NP_CLASS& np = parameters::default_values()
 #ifndef DOXYGEN_RUNNING
                , typename boost::enable_if<internal::is_Range<PointRange> >::type* = nullptr
 #endif
@@ -375,7 +375,7 @@ CGAL_DEPRECATED bool write_ply_points_with_properties(std::ostream& os, ///< out
             \link PkgPointSetProcessing3IOPly `CGAL::IO::write_PLY()` \endlink should be used instead.
 */
 template <typename PointRange, typename CGAL_BGL_NP_TEMPLATE_PARAMETERS>
-CGAL_DEPRECATED bool write_ply_points(std::ostream& os, const PointRange& points, const CGAL_BGL_NP_CLASS& np = parameters::use_default_values())
+CGAL_DEPRECATED bool write_ply_points(std::ostream& os, const PointRange& points, const CGAL_BGL_NP_CLASS& np = parameters::default_values())
 {
   return IO::write_PLY(os, points, np);
 }

Point_set_processing_3/include/CGAL/IO/write_points.h

@@ -91,7 +91,7 @@ namespace IO {
 template <typename PointRange, typename CGAL_BGL_NP_TEMPLATE_PARAMETERS>
 bool write_points(const std::string& fname,
                   const PointRange& points,
-                  const CGAL_BGL_NP_CLASS& np = parameters::use_default_values(),
+                  const CGAL_BGL_NP_CLASS& np = parameters::default_values(),
 #ifndef DOXYGEN_RUNNING
                   typename boost::enable_if<internal::is_Range<PointRange> >::type* = nullptr
 #endif

Point_set_processing_3/include/CGAL/IO/write_xyz_points.h

@@ -37,7 +37,7 @@ namespace internal {
 template <typename PointRange, typename CGAL_BGL_NP_TEMPLATE_PARAMETERS>
 bool write_XYZ_PSP(std::ostream& os,
                    const PointRange& points,
-                   const CGAL_BGL_NP_CLASS& np = CGAL::parameters::use_default_values())
+                   const CGAL_BGL_NP_CLASS& np = CGAL::parameters::default_values())
 {
   using CGAL::parameters::choose_parameter;
   using CGAL::parameters::get_parameter;
@@ -125,7 +125,7 @@ namespace IO {
 template <typename PointRange, typename CGAL_BGL_NP_TEMPLATE_PARAMETERS>
 bool write_XYZ(std::ostream& os,
                const PointRange& points,
-               const CGAL_BGL_NP_CLASS& np = parameters::use_default_values()
+               const CGAL_BGL_NP_CLASS& np = parameters::default_values()
 #ifndef DOXYGEN_RUNNING
                , typename boost::enable_if<internal::is_Range<PointRange> >::type* = nullptr
 #endif
@@ -178,7 +178,7 @@ bool write_XYZ(std::ostream& os,
 template <typename PointRange, typename CGAL_BGL_NP_TEMPLATE_PARAMETERS>
 bool write_XYZ(const std::string& filename,
                const PointRange& points,
-               const CGAL_BGL_NP_CLASS& np = parameters::use_default_values()
+               const CGAL_BGL_NP_CLASS& np = parameters::default_values()
 #ifndef DOXYGEN_RUNNING
                , typename boost::enable_if<internal::is_Range<PointRange> >::type* = nullptr
 #endif
@@ -288,7 +288,7 @@ bool write_xyz_points(std::ostream& os, ///< output stream.
               \link PkgPointSetProcessing3IOXyz `CGAL::write_XYZ()` \endlink should be used instead.
 */
 template <typename PointRange, typename CGAL_BGL_NP_TEMPLATE_PARAMETERS>
-CGAL_DEPRECATED bool write_xyz_points(std::ostream& os, const PointRange& points, const CGAL_BGL_NP_CLASS& np = parameters::use_default_values())
+CGAL_DEPRECATED bool write_xyz_points(std::ostream& os, const PointRange& points, const CGAL_BGL_NP_CLASS& np = parameters::default_values())
 {
   return IO::write_XYZ(os, points, np);
 }

Point_set_processing_3/include/CGAL/OpenGR/compute_registration_transformation.h

@@ -296,8 +296,8 @@ std::pair<typename Point_set_processing_3_np_helper<PointRange1, NamedParameters
   ::Geom_traits::Aff_transformation_3, double>
 #endif
 compute_registration_transformation (const PointRange1& point_set_1, const PointRange2& point_set_2,
-                                     const NamedParameters1& np1 = parameters::use_default_values(),
+                                     const NamedParameters1& np1 = parameters::default_values(),
-                                     const NamedParameters2& np2 = parameters::use_default_values())
+                                     const NamedParameters2& np2 = parameters::default_values())
 {
   namespace GR = gr;
   using parameters::choose_parameter;

Point_set_processing_3/include/CGAL/OpenGR/register_point_sets.h

@@ -210,8 +210,8 @@ template <class PointRange1, class PointRange2,
           class NamedParameters2 = parameters::Default_named_parameters>
 double
 register_point_sets (const PointRange1& point_set_1, PointRange2& point_set_2,
-                     const NamedParameters1& np1 = parameters::use_default_values(),
+                     const NamedParameters1& np1 = parameters::default_values(),
-                     const NamedParameters2& np2 = parameters::use_default_values())
+                     const NamedParameters2& np2 = parameters::default_values())
 {
   namespace GR = gr;
   using parameters::choose_parameter;

Point_set_processing_3/include/CGAL/bilateral_smooth_point_set.h

@@ -263,7 +263,7 @@ double
 bilateral_smooth_point_set(
   PointRange& points,
   unsigned int k,
-  const NamedParameters& np = parameters::use_default_values())
+  const NamedParameters& np = parameters::default_values())
 {
   using parameters::choose_parameter;
   using parameters::get_parameter;

Point_set_processing_3/include/CGAL/cluster_point_set.h

@@ -131,7 +131,7 @@ CGAL::Emptyset_iterator get_adjacencies (const NamedParameters&, CGAL::Emptyset_
 template <typename PointRange, typename ClusterMap, typename NamedParameters = parameters::Default_named_parameters>
 std::size_t cluster_point_set (PointRange& points,
                                ClusterMap cluster_map,
-                               const NamedParameters& np = parameters::use_default_values())
+                               const NamedParameters& np = parameters::default_values())
 {
   using parameters::choose_parameter;
   using parameters::get_parameter;

Point_set_processing_3/include/CGAL/compute_average_spacing.h

@@ -155,7 +155,7 @@ template <typename ConcurrencyTag,
 compute_average_spacing(
   const PointRange& points,
   unsigned int k,
-  const CGAL_BGL_NP_CLASS& np = parameters::use_default_values())
+  const CGAL_BGL_NP_CLASS& np = parameters::default_values())
 {
   using parameters::choose_parameter;
   using parameters::get_parameter;

Point_set_processing_3/include/CGAL/edge_aware_upsample_point_set.h

@@ -355,7 +355,7 @@ OutputIterator
 edge_aware_upsample_point_set(
   const PointRange& points,
   OutputIterator output,
-  const NamedParameters& np = parameters::use_default_values())
+  const NamedParameters& np = parameters::default_values())
 {
   using parameters::choose_parameter;
   using parameters::get_parameter;

Point_set_processing_3/include/CGAL/estimate_scale.h

@@ -489,7 +489,7 @@ estimate_local_k_neighbor_scales(
   const PointRange& points,
   const QueryPointRange& queries,
   OutputIterator output,
-  const NamedParameters& np = parameters::use_default_values())
+  const NamedParameters& np = parameters::default_values())
 {
   using parameters::choose_parameter;
   using parameters::get_parameter;
@@ -558,7 +558,7 @@ template <typename PointRange,
 std::size_t
 estimate_global_k_neighbor_scale(
   const PointRange& points,
-  const NamedParameters& np = parameters::use_default_values())
+  const NamedParameters& np = parameters::default_values())
 {
   using parameters::choose_parameter;
   using parameters::get_parameter;
@@ -631,7 +631,7 @@ estimate_local_range_scales(
   const PointRange& points,
   const QueryPointRange& queries,
   OutputIterator output,
-  const NamedParameters& np = parameters::use_default_values())
+  const NamedParameters& np = parameters::default_values())
 {
   using parameters::choose_parameter;
   using parameters::get_parameter;
@@ -707,7 +707,7 @@ template <typename PointRange,
 #endif
 estimate_global_range_scale(
   const PointRange& points,
-  const NamedParameters& np = parameters::use_default_values())
+  const NamedParameters& np = parameters::default_values())
 {
   using parameters::choose_parameter;
   using parameters::get_parameter;

Point_set_processing_3/include/CGAL/grid_simplify_point_set.h

@@ -212,7 +212,7 @@ typename PointRange::iterator
 grid_simplify_point_set(
   PointRange& points,
   double epsilon,
-  const NamedParameters& np = parameters::use_default_values())
+  const NamedParameters& np = parameters::default_values())
 {
   using parameters::choose_parameter;
   using parameters::get_parameter;

Point_set_processing_3/include/CGAL/hierarchy_simplify_point_set.h

@@ -179,7 +179,7 @@ namespace CGAL {
             typename NamedParameters = parameters::Default_named_parameters>
   typename PointRange::iterator
   hierarchy_simplify_point_set (PointRange& points,
-                                const NamedParameters& np = parameters::use_default_values())
+                                const NamedParameters& np = parameters::default_values())
   {
     using parameters::choose_parameter;
     using parameters::get_parameter;

Point_set_processing_3/include/CGAL/jet_estimate_normals.h

@@ -179,7 +179,7 @@ void
 jet_estimate_normals(
   PointRange& points,
   unsigned int k,
-  const NamedParameters& np = parameters::use_default_values())
+  const NamedParameters& np = parameters::default_values())
 {
   using parameters::choose_parameter;
   using parameters::get_parameter;

Point_set_processing_3/include/CGAL/jet_smooth_point_set.h

@@ -188,7 +188,7 @@ void
 jet_smooth_point_set(
   PointRange& points,
   unsigned int k,
-  const NamedParameters& np = parameters::use_default_values())
+  const NamedParameters& np = parameters::default_values())
 {
   using parameters::choose_parameter;
   using parameters::get_parameter;

Point_set_processing_3/include/CGAL/mst_orient_normals.h

@@ -604,7 +604,7 @@ typename PointRange::iterator
 mst_orient_normals(
   PointRange& points,
   unsigned int k,
-  const NamedParameters& np = parameters::use_default_values())
+  const NamedParameters& np = parameters::default_values())
 {
     using parameters::choose_parameter;
     using parameters::get_parameter;

Point_set_processing_3/include/CGAL/pca_estimate_normals.h

@@ -154,7 +154,7 @@ void
 pca_estimate_normals(
   PointRange& points,
   unsigned int k,
-  const NamedParameters& np = parameters::use_default_values())
+  const NamedParameters& np = parameters::default_values())
 {
   using parameters::choose_parameter;
   using parameters::get_parameter;

Point_set_processing_3/include/CGAL/pointmatcher/compute_registration_transformation.h

@@ -592,8 +592,8 @@ std::pair<typename Point_set_processing_3_np_helper<PointRange1, NamedParameters
   ::Geom_traits::Aff_transformation_3, bool>
 #endif
 compute_registration_transformation (const PointRange1& point_set_1, const PointRange2& point_set_2,
-                                     const NamedParameters1& np1 = parameters::use_default_values(),
+                                     const NamedParameters1& np1 = parameters::default_values(),
-                                     const NamedParameters2& np2 = parameters::use_default_values())
+                                     const NamedParameters2& np2 = parameters::default_values())
 {
   using parameters::choose_parameter;
   using parameters::get_parameter;

Point_set_processing_3/include/CGAL/pointmatcher/register_point_sets.h

@@ -229,8 +229,8 @@ template <class PointRange1, class PointRange2,
           class NamedParameters2 = parameters::Default_named_parameters>
 bool
 register_point_sets (const PointRange1& point_set_1, PointRange2& point_set_2,
-                     const NamedParameters1& np1 = parameters::use_default_values(),
+                     const NamedParameters1& np1 = parameters::default_values(),
-                     const NamedParameters2& np2 = parameters::use_default_values())
+                     const NamedParameters2& np2 = parameters::default_values())
 {
   typedef typename Point_set_processing_3_np_helper<PointRange1, NamedParameters1>::Geom_traits Kernel;
 

Point_set_processing_3/include/CGAL/remove_outliers.h

@@ -176,7 +176,7 @@ typename PointRange::iterator
 remove_outliers(
   PointRange& points,
   unsigned int k,
-  const NamedParameters& np = parameters::use_default_values())
+  const NamedParameters& np = parameters::default_values())
 {
   using parameters::choose_parameter;
   using parameters::get_parameter;

Point_set_processing_3/include/CGAL/scanline_orient_normals.h

@@ -457,7 +457,7 @@ void orient_scanline (Iterator begin, Iterator end,
    \cgalNamedParamsEnd
 */
 template <typename PointRange, typename NamedParameters = parameters::Default_named_parameters>
-void scanline_orient_normals (PointRange& points, const NamedParameters& np = parameters::use_default_values())
+void scanline_orient_normals (PointRange& points, const NamedParameters& np = parameters::default_values())
 {
   using parameters::choose_parameter;
   using parameters::get_parameter;

Point_set_processing_3/include/CGAL/vcm_estimate_normals.h

@@ -263,7 +263,7 @@ compute_vcm (const PointRange& points,
              std::vector< std::array<double, 6> > &ccov,
              double offset_radius,
              double convolution_radius,
-             const NamedParameters& np = parameters::use_default_values())
+             const NamedParameters& np = parameters::default_values())
 {
     using parameters::choose_parameter;
     using parameters::get_parameter;
@@ -430,7 +430,7 @@ void
 vcm_estimate_normals (PointRange& points,
                       double offset_radius,
                       double convolution_radius,
-                      const NamedParameters& np = parameters::use_default_values()
+                      const NamedParameters& np = parameters::default_values()
 )
 {
   vcm_estimate_normals_internal(points, offset_radius, convolution_radius, np);
@@ -489,7 +489,7 @@ void
 vcm_estimate_normals (PointRange& points,
                       double offset_radius,
                       unsigned int k,
-                      const NamedParameters& np = parameters::use_default_values()
+                      const NamedParameters& np = parameters::default_values()
 )
 {
   vcm_estimate_normals_internal(points, offset_radius, 0, np, k);

Point_set_processing_3/include/CGAL/wlop_simplify_and_regularize_point_set.h

@@ -434,7 +434,7 @@ OutputIterator
 wlop_simplify_and_regularize_point_set(
   PointRange& points,
   OutputIterator output,
-  const NamedParameters& np = parameters::use_default_values()
+  const NamedParameters& np = parameters::default_values()
 )
 {
   using parameters::choose_parameter;

Polygon_mesh_processing/examples/Polygon_mesh_processing/corefinement_difference_remeshed.cpp

@@ -56,8 +56,8 @@ int main(int argc, char* argv[])
     PMP::corefine_and_compute_difference(mesh1,
                                          mesh2,
                                          mesh1,
-                                         params::use_default_values(), // default parameters for mesh1
+                                         params::default_values(), // default parameters for mesh1
-                                         params::use_default_values(), // default parameters for mesh2
+                                         params::default_values(), // default parameters for mesh2
                                          params::edge_is_constrained_map(is_constrained_map));
 
   if (valid_difference)

Polygon_mesh_processing/examples/Polygon_mesh_processing/corefinement_mesh_union_and_intersection.cpp

@@ -36,13 +36,13 @@ int main(int argc, char* argv[])
     PMP::corefine_and_compute_boolean_operations(
       mesh1, mesh2,
       output,
-      params::use_default_values(), // mesh1 named parameters
+      params::default_values(), // mesh1 named parameters
-      params::use_default_values(), // mesh2 named parameters
+      params::default_values(), // mesh2 named parameters
       std::make_tuple(
         params::vertex_point_map(get(boost::vertex_point, out_union)), // named parameters for out_union
         params::vertex_point_map(get(boost::vertex_point, out_intersection)), // named parameters for out_intersection
-        params::use_default_values(), // named parameters for mesh1-mesh2 not used
+        params::default_values(), // named parameters for mesh1-mesh2 not used
-        params::use_default_values() )// named parameters for mesh2-mesh1 not used)
+        params::default_values() )// named parameters for mesh2-mesh1 not used)
     );
 
   if (res[PMP::Corefinement::UNION])

Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/IO/polygon_mesh_io.h

@@ -87,7 +87,7 @@ namespace IO {
 template <typename PolygonMesh, typename NamedParameters = parameters::Default_named_parameters>
 bool read_polygon_mesh(const std::string& fname,
                        PolygonMesh& g,
-                       const NamedParameters& np = parameters::use_default_values())
+                       const NamedParameters& np = parameters::default_values())
 {
   namespace PMP = CGAL::Polygon_mesh_processing;
 
@@ -125,7 +125,7 @@ bool read_polygon_mesh(const std::string& fname,
     return false;
   }
 
-  PMP::polygon_soup_to_polygon_mesh(points, faces, g, parameters::use_default_values(), np);
+  PMP::polygon_soup_to_polygon_mesh(points, faces, g, parameters::default_values(), np);
 
   return true;
 }

Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/bbox.h

@@ -59,7 +59,7 @@ namespace CGAL {
     */
     template<typename PolygonMesh, typename NamedParameters = parameters::Default_named_parameters>
     CGAL::Bbox_3 bbox(const PolygonMesh& pmesh,
-                      const NamedParameters& np = parameters::use_default_values())
+                      const NamedParameters& np = parameters::default_values())
     {
       using CGAL::parameters::choose_parameter;
       using CGAL::parameters::get_parameter;
@@ -116,7 +116,7 @@ namespace CGAL {
     template<typename PolygonMesh, typename NamedParameters = parameters::Default_named_parameters>
     CGAL::Bbox_3 vertex_bbox(typename boost::graph_traits<PolygonMesh>::vertex_descriptor vd,
                              const PolygonMesh& pmesh,
-                             const NamedParameters& np = parameters::use_default_values())
+                             const NamedParameters& np = parameters::default_values())
     {
       using parameters::choose_parameter;
       using parameters::get_parameter;
@@ -165,7 +165,7 @@ namespace CGAL {
     template<typename PolygonMesh, typename NamedParameters = parameters::Default_named_parameters>
     CGAL::Bbox_3 edge_bbox(typename boost::graph_traits<PolygonMesh>::edge_descriptor ed,
                            const PolygonMesh& pmesh,
-                           const NamedParameters& np = parameters::use_default_values())
+                           const NamedParameters& np = parameters::default_values())
     {
       using parameters::choose_parameter;
       using parameters::get_parameter;
@@ -217,7 +217,7 @@ namespace CGAL {
     template<typename PolygonMesh, typename NamedParameters = parameters::Default_named_parameters>
     CGAL::Bbox_3 face_bbox(typename boost::graph_traits<PolygonMesh>::face_descriptor fd,
                            const PolygonMesh& pmesh,
-                           const NamedParameters& np = parameters::use_default_values())
+                           const NamedParameters& np = parameters::default_values())
     {
       using parameters::choose_parameter;
       using parameters::get_parameter;

Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/border.h

@@ -181,7 +181,7 @@ std::size_t border_size(typename boost::graph_traits<PolygonMesh>::halfedge_desc
   HalfedgeOutputIterator border_halfedges(const FaceRange& face_range
                                   , const PolygonMesh& pmesh
                                   , HalfedgeOutputIterator out
-                                  , const NamedParameters& np = parameters::use_default_values())
+                                  , const NamedParameters& np = parameters::default_values())
   {
     if (face_range.empty())
       return out;

Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/clip.h

@@ -600,8 +600,8 @@ template <class TriangleMesh,
 bool
 clip(TriangleMesh& tm,
      TriangleMesh& clipper,
-     const NamedParameters1& np_tm = parameters::use_default_values(),
+     const NamedParameters1& np_tm = parameters::default_values(),
-     const NamedParameters2& np_c = parameters::use_default_values())
+     const NamedParameters2& np_c = parameters::default_values())
 {
   if (parameters::choose_parameter(parameters::get_parameter(np_c, internal_np::do_not_modify), false))
   {
@@ -700,7 +700,7 @@ bool clip(TriangleMesh& tm,
 #else
           const typename GetGeomTraits<TriangleMesh, NamedParameters>::type::Plane_3& plane,
 #endif
-          const NamedParameters& np = parameters::use_default_values())
+          const NamedParameters& np = parameters::default_values())
 {
   using parameters::get_parameter;
   using parameters::choose_parameter;
@@ -717,7 +717,7 @@ bool clip(TriangleMesh& tm,
   bbox=CGAL::Bbox_3(bbox.xmin()-xd, bbox.ymin()-yd, bbox.zmin()-zd,
                     bbox.xmax()+xd, bbox.ymax()+yd, bbox.zmax()+zd);
   TriangleMesh clipper;
-  Oriented_side os = internal::clip_to_bbox(plane, bbox, clipper, parameters::use_default_values());
+  Oriented_side os = internal::clip_to_bbox(plane, bbox, clipper, parameters::default_values());
   switch(os)
   {
     case ON_NEGATIVE_SIDE:
@@ -803,7 +803,7 @@ bool clip(TriangleMesh& tm,
 #else
           const typename GetGeomTraits<TriangleMesh, NamedParameters>::type::Iso_cuboid_3& iso_cuboid,
 #endif
-          const NamedParameters& np = parameters::use_default_values())
+          const NamedParameters& np = parameters::default_values())
 {
   using parameters::get_parameter;
   using parameters::choose_parameter;
@@ -880,8 +880,8 @@ template <class TriangleMesh,
           class NamedParameters2 = parameters::Default_named_parameters>
 void split(TriangleMesh& tm,
            TriangleMesh& splitter,
-           const NamedParameters1& np_tm = parameters::use_default_values(),
+           const NamedParameters1& np_tm = parameters::default_values(),
-           const NamedParameters2& np_s = parameters::use_default_values())
+           const NamedParameters2& np_s = parameters::default_values())
 {
   namespace PMP = CGAL::Polygon_mesh_processing;
 
@@ -971,7 +971,7 @@ void split(TriangleMesh& tm,
 #else
            const typename GetGeomTraits<TriangleMesh, NamedParameters>::type::Plane_3& plane,
 #endif
-           const NamedParameters& np = parameters::use_default_values())
+           const NamedParameters& np = parameters::default_values())
 {
   using parameters::get_parameter;
   using parameters::choose_parameter;
@@ -987,7 +987,7 @@ void split(TriangleMesh& tm,
                       bbox.xmax()+xd, bbox.ymax()+yd, bbox.zmax()+zd);
 
   TriangleMesh splitter;
-  CGAL::Oriented_side os = PMP::internal::clip_to_bbox(plane, bbox, splitter, CGAL::parameters::use_default_values());
+  CGAL::Oriented_side os = PMP::internal::clip_to_bbox(plane, bbox, splitter, CGAL::parameters::default_values());
 
   if(os == CGAL::ON_ORIENTED_BOUNDARY)
   {
@@ -1074,7 +1074,7 @@ void split(TriangleMesh& tm,
            #else
            const typename GetGeomTraits<TriangleMesh, NamedParameters>::type::Iso_cuboid_3& iso_cuboid,
            #endif
-           const NamedParameters& np = parameters::use_default_values())
+           const NamedParameters& np = parameters::default_values())
 {
   using parameters::get_parameter;
   using parameters::choose_parameter;

Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/compute_normal.h

@@ -164,7 +164,7 @@ typename GetGeomTraits<PolygonMesh, NamedParameters>::type::Vector_3
 #endif
 compute_face_normal(typename boost::graph_traits<PolygonMesh>::face_descriptor f,
                     const PolygonMesh& pmesh,
-                    const NamedParameters& np = parameters::use_default_values())
+                    const NamedParameters& np = parameters::default_values())
 {
   using parameters::choose_parameter;
   using parameters::get_parameter;
@@ -225,7 +225,7 @@ compute_face_normal(typename boost::graph_traits<PolygonMesh>::face_descriptor f
 template <typename PolygonMesh, typename Face_normal_map, typename NamedParameters = parameters::Default_named_parameters>
 void compute_face_normals(const PolygonMesh& pmesh,
                           Face_normal_map face_normals,
-                          const NamedParameters& np = parameters::use_default_values())
+                          const NamedParameters& np = parameters::default_values())
 {
   typedef typename GetGeomTraits<PolygonMesh,NamedParameters>::type Kernel;
 
@@ -646,7 +646,7 @@ typename GetGeomTraits<PolygonMesh, NamedParameters>::type::Vector_3
 #endif
 compute_vertex_normal(typename boost::graph_traits<PolygonMesh>::vertex_descriptor v,
                       const PolygonMesh& pmesh,
-                      const NamedParameters& np = parameters::use_default_values())
+                      const NamedParameters& np = parameters::default_values())
 {
   using parameters::choose_parameter;
   using parameters::is_default_parameter;
@@ -759,7 +759,7 @@ compute_vertex_normal(typename boost::graph_traits<PolygonMesh>::vertex_descript
 template <typename PolygonMesh, typename VertexNormalMap, typename NamedParameters = parameters::Default_named_parameters>
 void compute_vertex_normals(const PolygonMesh& pmesh,
                             VertexNormalMap vertex_normals,
-                            const NamedParameters& np = parameters::use_default_values())
+                            const NamedParameters& np = parameters::default_values())
 {
   using parameters::choose_parameter;
   using parameters::is_default_parameter;
@@ -856,7 +856,7 @@ template <typename PolygonMesh,
 void compute_normals(const PolygonMesh& pmesh,
                      VertexNormalMap vertex_normals,
                      FaceNormalMap face_normals,
-                     const NamedParameters& np = parameters::use_default_values())
+                     const NamedParameters& np = parameters::default_values())
 {
   compute_face_normals(pmesh, face_normals, np);
   compute_vertex_normals(pmesh, vertex_normals, np.face_normal_map(face_normals));

Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/connected_components.h

@@ -123,7 +123,7 @@ FaceOutputIterator
 connected_component(typename boost::graph_traits<PolygonMesh>::face_descriptor seed_face
                     , const PolygonMesh& pmesh
                     , FaceOutputIterator out
-                    , const NamedParameters& np = parameters::use_default_values())
+                    , const NamedParameters& np = parameters::default_values())
 {
   using parameters::choose_parameter;
   using parameters::get_parameter;
@@ -200,7 +200,7 @@ template <typename PolygonMesh
 typename boost::property_traits<FaceComponentMap>::value_type
 connected_components(const PolygonMesh& pmesh,
                      FaceComponentMap fcm,
-                     const NamedParameters& np = parameters::use_default_values())
+                     const NamedParameters& np = parameters::default_values())
 {
   using parameters::choose_parameter;
   using parameters::get_parameter;
@@ -261,7 +261,7 @@ template <typename PolygonMesh
 void keep_connected_components(PolygonMesh& pmesh
                               , const ComponentRange& components_to_keep
                               , const FaceComponentMap& fcm
-                              , const NamedParameters& np = parameters::use_default_values());
+                              , const NamedParameters& np = parameters::default_values());
 
 namespace internal {
 
@@ -300,7 +300,7 @@ namespace internal {
 template <typename PolygonMesh,
           typename CGAL_BGL_NP_TEMPLATE_PARAMETERS>
 std::size_t number_of_connected_components(const PolygonMesh& pmesh,
-                                           const CGAL_BGL_NP_CLASS& np = parameters::use_default_values())
+                                           const CGAL_BGL_NP_CLASS& np = parameters::default_values())
 {
   typedef typename boost::graph_traits<PolygonMesh>::faces_size_type                faces_size_type;
   typedef CGAL::dynamic_face_property_t<faces_size_type>                            Face_property_tag;
@@ -380,7 +380,7 @@ template <typename PolygonMesh,
           typename NamedParameters = parameters::Default_named_parameters>
 std::size_t keep_largest_connected_components(PolygonMesh& pmesh,
                                               std::size_t nb_components_to_keep,
-                                              const NamedParameters& np = parameters::use_default_values())
+                                              const NamedParameters& np = parameters::default_values())
 {
   typedef PolygonMesh                                                   PM;
   typedef typename boost::graph_traits<PM>::face_descriptor             face_descriptor;
@@ -527,7 +527,7 @@ template <typename PolygonMesh,
           typename NamedParameters = parameters::Default_named_parameters>
 std::size_t keep_large_connected_components(PolygonMesh& pmesh,
                                             const ThresholdValueType threshold_value,
-                                            const NamedParameters& np = parameters::use_default_values())
+                                            const NamedParameters& np = parameters::default_values())
 {
   typedef PolygonMesh                                                     PM;
   typedef typename boost::graph_traits<PM>::face_descriptor               face_descriptor;
@@ -605,7 +605,7 @@ void keep_or_remove_connected_components(PolygonMesh& pmesh
                                         , const ComponentRange& components_to_keep
                                         , const FaceComponentMap& fcm
                                         , bool  keep
-                                        , const NamedParameters& np = parameters::use_default_values())
+                                        , const NamedParameters& np = parameters::default_values())
 {
   using parameters::choose_parameter;
   using parameters::get_parameter;
@@ -822,7 +822,7 @@ template <typename PolygonMesh
 void remove_connected_components(PolygonMesh& pmesh
                                 , const ComponentRange& components_to_remove
                                 , const FaceComponentMap& fcm
-                                , const NamedParameters& np = parameters::use_default_values())
+                                , const NamedParameters& np = parameters::default_values())
 {
   if (components_to_remove.empty()) return;
   keep_or_remove_connected_components(pmesh, components_to_remove, fcm, false, np);
@@ -874,7 +874,7 @@ template <typename PolygonMesh
         , typename CGAL_BGL_NP_TEMPLATE_PARAMETERS>
 void remove_connected_components(PolygonMesh& pmesh
                                 , const FaceRange& components_to_remove
-                                , const CGAL_BGL_NP_CLASS& np = parameters::use_default_values())
+                                , const CGAL_BGL_NP_CLASS& np = parameters::default_values())
 {
   using parameters::choose_parameter;
   using parameters::get_parameter;
@@ -944,7 +944,7 @@ template <typename PolygonMesh
         , typename CGAL_BGL_NP_TEMPLATE_PARAMETERS>
 void keep_connected_components(PolygonMesh& pmesh
                              , const FaceRange& components_to_keep
-                             , const CGAL_BGL_NP_CLASS& np = parameters::use_default_values())
+                             , const CGAL_BGL_NP_CLASS& np = parameters::default_values())
 {
   typedef PolygonMesh PM;
   typedef typename boost::graph_traits<PM>::face_descriptor face_descriptor;
@@ -1084,7 +1084,7 @@ void split_connected_components_impl(FIMap fim,
 template <class PolygonMesh, class PolygonMeshRange, class NamedParameters = parameters::Default_named_parameters>
 void split_connected_components(const PolygonMesh& pmesh,
                                 PolygonMeshRange& cc_meshes,
-                                const NamedParameters& np = parameters::use_default_values())
+                                const NamedParameters& np = parameters::default_values())
 {
   typedef Static_boolean_property_map<
     typename boost::graph_traits<PolygonMesh>::edge_descriptor, false> Default_ecm;

Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/corefinement.h

@@ -186,8 +186,8 @@ corefine_and_compute_boolean_operations(
         TriangleMesh& tm1,
         TriangleMesh& tm2,
   const std::array< boost::optional<TriangleMesh*>,4>& output,
-  const NamedParameters1& np1 = parameters::use_default_values(),
+  const NamedParameters1& np1 = parameters::default_values(),
-  const NamedParameters2& np2 = parameters::use_default_values(),
+  const NamedParameters2& np2 = parameters::default_values(),
   const std::tuple<NamedParametersOut0,
                    NamedParametersOut1,
                    NamedParametersOut2,
@@ -517,9 +517,9 @@ bool
 corefine_and_compute_union(      TriangleMesh& tm1,
                                  TriangleMesh& tm2,
                                  TriangleMesh& tm_out,
-                           const NamedParameters1& np1 = parameters::use_default_values(),
+                           const NamedParameters1& np1 = parameters::default_values(),
-                           const NamedParameters2& np2 = parameters::use_default_values(),
+                           const NamedParameters2& np2 = parameters::default_values(),
-                           const NamedParametersOut& np_out = parameters::use_default_values())
+                           const NamedParametersOut& np_out = parameters::default_values())
 {
   using namespace CGAL::parameters;
   std::array< boost::optional<TriangleMesh*>,4> output;
@@ -528,9 +528,9 @@ corefine_and_compute_union(      TriangleMesh& tm1,
   return
    corefine_and_compute_boolean_operations(tm1, tm2, output, np1, np2,
                                            std::make_tuple(np_out,
-                                                             parameters::use_default_values(),
+                                                             parameters::default_values(),
-                                                             parameters::use_default_values(),
+                                                             parameters::default_values(),
-                                                             parameters::use_default_values()))
+                                                             parameters::default_values()))
                                                                 [Corefinement::UNION];
 }
 
@@ -549,9 +549,9 @@ bool
 corefine_and_compute_intersection(      TriangleMesh& tm1,
                                         TriangleMesh& tm2,
                                         TriangleMesh& tm_out,
-                                  const NamedParameters1& np1 = parameters::use_default_values(),
+                                  const NamedParameters1& np1 = parameters::default_values(),
-                                  const NamedParameters2& np2 = parameters::use_default_values(),
+                                  const NamedParameters2& np2 = parameters::default_values(),
-                                  const NamedParametersOut& np_out = parameters::use_default_values())
+                                  const NamedParametersOut& np_out = parameters::default_values())
 {
   using namespace CGAL::parameters;
   std::array< boost::optional<TriangleMesh*>,4> output;
@@ -559,10 +559,10 @@ corefine_and_compute_intersection(      TriangleMesh& tm1,
 
   return
     corefine_and_compute_boolean_operations(tm1, tm2, output, np1, np2,
-                                            std::make_tuple(parameters::use_default_values(),
+                                            std::make_tuple(parameters::default_values(),
                                                               np_out,
-                                                              parameters::use_default_values(),
+                                                              parameters::default_values(),
-                                                              parameters::use_default_values()))
+                                                              parameters::default_values()))
                                                                 [Corefinement::INTERSECTION];
 }
 
@@ -581,9 +581,9 @@ bool
 corefine_and_compute_difference(      TriangleMesh& tm1,
                                       TriangleMesh& tm2,
                                       TriangleMesh& tm_out,
-                                const NamedParameters1& np1 = parameters::use_default_values(),
+                                const NamedParameters1& np1 = parameters::default_values(),
-                                const NamedParameters2& np2 = parameters::use_default_values(),
+                                const NamedParameters2& np2 = parameters::default_values(),
-                                const NamedParametersOut& np_out = parameters::use_default_values())
+                                const NamedParametersOut& np_out = parameters::default_values())
 {
   using namespace CGAL::parameters;
   using namespace CGAL::Polygon_mesh_processing::Corefinement;
@@ -592,10 +592,10 @@ corefine_and_compute_difference(      TriangleMesh& tm1,
 
   return
     corefine_and_compute_boolean_operations(tm1, tm2, output, np1, np2,
-                                            std::make_tuple(parameters::use_default_values(),
+                                            std::make_tuple(parameters::default_values(),
-                                                              parameters::use_default_values(),
+                                                              parameters::default_values(),
                                                               np_out,
-                                                              parameters::use_default_values()))
+                                                              parameters::default_values()))
                                                                 [TM1_MINUS_TM2];
 }
 
@@ -667,8 +667,8 @@ template <class TriangleMesh,
 void
 corefine(      TriangleMesh& tm1,
                TriangleMesh& tm2,
-         const NamedParameters1& np1 = parameters::use_default_values(),
+         const NamedParameters1& np1 = parameters::default_values(),
-         const NamedParameters2& np2 = parameters::use_default_values())
+         const NamedParameters2& np2 = parameters::default_values())
 {
   using parameters::choose_parameter;
   using parameters::get_parameter;
@@ -808,7 +808,7 @@ template <class TriangleMesh,
           class NamedParameters = parameters::Default_named_parameters>
 void
 autorefine(      TriangleMesh& tm,
-           const NamedParameters& np = parameters::use_default_values())
+           const NamedParameters& np = parameters::default_values())
 {
   using parameters::choose_parameter;
   using parameters::get_parameter;
@@ -901,7 +901,7 @@ template <class TriangleMesh,
           class NamedParameters = parameters::Default_named_parameters>
 bool
 autorefine_and_remove_self_intersections(      TriangleMesh& tm,
-                                         const NamedParameters& np = parameters::use_default_values())
+                                         const NamedParameters& np = parameters::default_values())
 {
   using parameters::choose_parameter;
   using parameters::get_parameter;

Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/detect_features.h

@@ -149,7 +149,7 @@ typename boost::graph_traits<PolygonMesh>::faces_size_type
 detect_surface_patches(const PolygonMesh& p,
                        PatchIdMap patch_id_map,
                        EdgeIsFeatureMap eif,
-                       const NamedParameters& np = parameters::use_default_values())
+                       const NamedParameters& np = parameters::default_values())
 {
   int offset = static_cast<int>(
           parameters::choose_parameter(parameters::get_parameter(np, internal_np::first_index), 1));
@@ -275,7 +275,7 @@ void detect_sharp_edges(const PolygonMesh& pmesh,
                         typename GetGeomTraits<PolygonMesh, NamedParameters>::type::FT angle_in_deg,
 #endif
                         EdgeIsFeatureMap edge_is_feature_map,
-                        const NamedParameters& np = parameters::use_default_values())
+                        const NamedParameters& np = parameters::default_values())
 {
   using parameters::choose_parameter;
   using parameters::get_parameter;
@@ -453,7 +453,7 @@ sharp_edges_segmentation(const PolygonMesh& pmesh,
 #endif
                          EdgeIsFeatureMap edge_is_feature_map,
                          PatchIdMap patch_id_map,
-                         const NamedParameters& np = parameters::use_default_values())
+                         const NamedParameters& np = parameters::default_values())
 {
   detect_sharp_edges(pmesh, angle_in_deg, edge_is_feature_map, np);
 

Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/distance.h

@@ -856,7 +856,7 @@ template<class PointOutputIterator, class TriangleMesh, class NamedParameters =
 PointOutputIterator
 sample_triangle_mesh(const TriangleMesh& tm,
                      PointOutputIterator out,
-                     const NamedParameters& np = parameters::use_default_values())
+                     const NamedParameters& np = parameters::default_values())
 {
   typedef typename GetGeomTraits<TriangleMesh, NamedParameters>::type             GeomTraits;
   typedef typename GetVertexPointMap<TriangleMesh, NamedParameters>::const_type   Vpm;
@@ -982,7 +982,7 @@ PointOutputIterator
 sample_triangle_soup(const PointRange& points,
                      const TriangleRange& triangles,
                      PointOutputIterator out,
-                     const NamedParameters& np = parameters::use_default_values())
+                     const NamedParameters& np = parameters::default_values())
 {
   typedef typename PointRange::value_type         Point_3;
   typedef typename Kernel_traits<Point_3>::Kernel GeomTraits;
@@ -1087,7 +1087,7 @@ double approximate_Hausdorff_distance(
  *   \cgalParamNEnd
  * \cgalNamedParamsEnd
  *
- * The function `CGAL::parameters::use_default_values()` can be used to indicate to use the default values
+ * The function `CGAL::parameters::default_values()` can be used to indicate to use the default values
  * for `np1` and specify custom values for `np2`.
  */
 template< class Concurrency_tag,
@@ -1096,8 +1096,8 @@ template< class Concurrency_tag,
           class NamedParameters2 = parameters::Default_named_parameters>
 double approximate_Hausdorff_distance( const TriangleMesh& tm1,
                                        const TriangleMesh& tm2,
-                                       const NamedParameters1& np1 = parameters::use_default_values(),
+                                       const NamedParameters1& np1 = parameters::default_values(),
-                                       const NamedParameters2& np2 = parameters::use_default_values())
+                                       const NamedParameters2& np2 = parameters::default_values())
 {
   typedef typename GetGeomTraits<TriangleMesh,
                                  NamedParameters1>::type GeomTraits;
@@ -1120,8 +1120,8 @@ template< class Concurrency_tag,
 double approximate_symmetric_Hausdorff_distance(
   const TriangleMesh& tm1,
   const TriangleMesh& tm2,
-  const NamedParameters1& np1 = parameters::use_default_values(),
+  const NamedParameters1& np1 = parameters::default_values(),
-  const NamedParameters2& np2 = parameters::use_default_values())
+  const NamedParameters2& np2 = parameters::default_values())
 {
   return (std::max)(
     approximate_Hausdorff_distance<Concurrency_tag>(tm1,tm2,np1,np2),
@@ -1165,7 +1165,7 @@ template< class Concurrency_tag,
           class NamedParameters = parameters::Default_named_parameters>
 double max_distance_to_triangle_mesh(const PointRange& points,
                                      const TriangleMesh& tm,
-                                     const NamedParameters& np = parameters::use_default_values())
+                                     const NamedParameters& np = parameters::default_values())
 {
   typedef typename GetGeomTraits<TriangleMesh,
                                  NamedParameters>::type GeomTraits;
@@ -1214,7 +1214,7 @@ template< class TriangleMesh,
 double approximate_max_distance_to_point_set(const TriangleMesh& tm,
                                              const PointRange& points,
                                              const double precision,
-                                             const NamedParameters& np = parameters::use_default_values())
+                                             const NamedParameters& np = parameters::default_values())
 {
   typedef typename GetGeomTraits<TriangleMesh,
                                  NamedParameters>::type GeomTraits;
@@ -2294,8 +2294,8 @@ double bounded_error_Hausdorff_distance(
   const TriangleMesh1& tm1,
   const TriangleMesh2& tm2,
   const double error_bound = 0.0001,
-  const NamedParameters1& np1 = parameters::use_default_values(),
+  const NamedParameters1& np1 = parameters::default_values(),
-  const NamedParameters2& np2 = parameters::use_default_values())
+  const NamedParameters2& np2 = parameters::default_values())
 {
   CGAL_assertion_code(
     const bool is_triangle = is_triangle_mesh(tm1) && is_triangle_mesh(tm2));
@@ -2348,8 +2348,8 @@ double bounded_error_symmetric_Hausdorff_distance(
   const TriangleMesh1& tm1,
   const TriangleMesh2& tm2,
   const double error_bound,
-  const NamedParameters1& np1 = parameters::use_default_values(),
+  const NamedParameters1& np1 = parameters::default_values(),
-  const NamedParameters2& np2 = parameters::use_default_values())
+  const NamedParameters2& np2 = parameters::default_values())
 {
   CGAL_assertion_code(
     const bool is_triangle = is_triangle_mesh(tm1) && is_triangle_mesh(tm2));
@@ -2418,8 +2418,8 @@ bool is_Hausdorff_distance_larger(
   const TriangleMesh2& tm2,
   const double distance_bound,
   const double error_bound,
-  const NamedParameters1& np1 = parameters::use_default_values(),
+  const NamedParameters1& np1 = parameters::default_values(),
-  const NamedParameters2& np2 = parameters::use_default_values())
+  const NamedParameters2& np2 = parameters::default_values())
 {
   CGAL_assertion_code(
     const bool is_triangle = is_triangle_mesh(tm1) && is_triangle_mesh(tm2));
@@ -2478,8 +2478,8 @@ double bounded_error_Hausdorff_distance_naive(
   const TriangleMesh1& tm1,
   const TriangleMesh2& tm2,
   const double error_bound,
-  const NamedParameters1& np1 = parameters::use_default_values(),
+  const NamedParameters1& np1 = parameters::default_values(),
-  const NamedParameters2& np2 = parameters::use_default_values())
+  const NamedParameters2& np2 = parameters::default_values())
 {
   CGAL_assertion_code(
     const bool is_triangle = is_triangle_mesh(tm1) && is_triangle_mesh(tm2));

Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/extrude.h

@@ -165,8 +165,8 @@ void extrude_mesh(const InputMesh& input,
                   OutputMesh& output,
                   const BottomFunctor& bot,
                   const TopFunctor& top,
-                  const CGAL_BGL_NP_CLASS_1& np_in = parameters::use_default_values(),
+                  const CGAL_BGL_NP_CLASS_1& np_in = parameters::default_values(),
-                  const CGAL_BGL_NP_CLASS_2& np_out = parameters::use_default_values())
+                  const CGAL_BGL_NP_CLASS_2& np_out = parameters::default_values())
 {
   typedef typename boost::graph_traits<InputMesh>::vertex_descriptor input_vertex_descriptor;
   typedef typename boost::graph_traits<InputMesh>::halfedge_descriptor input_halfedge_descriptor;
@@ -285,8 +285,8 @@ void extrude_mesh(const InputMesh& input,
                   #else
                   typename GetGeomTraits<OutputMesh, CGAL_BGL_NP_CLASS_2>::type::Vector_3 v,
                   #endif
-                  const CGAL_BGL_NP_CLASS_1& np_in = parameters::use_default_values(),
+                  const CGAL_BGL_NP_CLASS_1& np_in = parameters::default_values(),
-                  const CGAL_BGL_NP_CLASS_2& np_out = parameters::use_default_values())
+                  const CGAL_BGL_NP_CLASS_2& np_out = parameters::default_values())
 {
   typedef typename GetVertexPointMap < OutputMesh, CGAL_BGL_NP_CLASS_2>::type VPMap;
   VPMap output_vpm = parameters::choose_parameter(parameters::get_parameter(np_out, internal_np::vertex_point),

Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/fair.h

@@ -127,7 +127,7 @@ namespace internal {
            typename NamedParameters = parameters::Default_named_parameters>
   bool fair(TriangleMesh& tmesh,
             const VertexRange& vertices,
-            const NamedParameters& np = parameters::use_default_values())
+            const NamedParameters& np = parameters::default_values())
   {
     using parameters::get_parameter;
     using parameters::choose_parameter;

Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/internal/Snapping/helper.h

@@ -47,7 +47,7 @@ void assign_tolerance_with_local_edge_length_bound(const HalfedgeRange& halfedge
                                                    ToleranceMap& tolerance_map,
                                                    const typename GetGeomTraits<PolygonMesh, NamedParameters>::type::FT tolerance,
                                                    PolygonMesh& mesh,
-                                                   const NamedParameters& np = parameters::use_default_values())
+                                                   const NamedParameters& np = parameters::default_values())
 {
   typedef typename boost::graph_traits<PolygonMesh>::vertex_descriptor                vertex_descriptor;
   typedef typename boost::graph_traits<PolygonMesh>::halfedge_descriptor              halfedge_descriptor;

Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/internal/Snapping/snap.h

@@ -1297,8 +1297,8 @@ std::size_t snap_borders(TriangleMesh& tm_A,
                          ToleranceMap_A tolerance_map_A,
                          TriangleMesh& tm_B,
                          ToleranceMap_B tolerance_map_B,
-                         const NamedParameters_A& np_A = parameters::use_default_values(),
+                         const NamedParameters_A& np_A = parameters::default_values(),
-                         const NamedParameters_B& np_B = parameters::use_default_values())
+                         const NamedParameters_B& np_B = parameters::default_values())
 {
   typedef typename boost::graph_traits<TriangleMesh>::halfedge_descriptor        halfedge_descriptor;
 
@@ -1318,8 +1318,8 @@ template <typename ConcurrencyTag = CGAL::Sequential_tag,
           typename NamedParameters_B = parameters::Default_named_parameters>
 std::size_t snap_borders(TriangleMesh& tm_A,
                          TriangleMesh& tm_B,
-                         const NamedParameters_A& np_A = parameters::use_default_values(),
+                         const NamedParameters_A& np_A = parameters::default_values(),
-                         const NamedParameters_B& np_B = parameters::use_default_values())
+                         const NamedParameters_B& np_B = parameters::default_values())
 {
   typedef typename boost::graph_traits<TriangleMesh>::halfedge_descriptor        halfedge_descriptor;
 
@@ -1355,7 +1355,7 @@ template <typename ConcurrencyTag = CGAL::Sequential_tag,
           typename CGAL_BGL_NP_TEMPLATE_PARAMETERS>
 std::size_t snap_borders(TriangleMesh& tm,
                          ToleranceMap tolerance_map,
-                         const CGAL_BGL_NP_CLASS& np = parameters::use_default_values())
+                         const CGAL_BGL_NP_CLASS& np = parameters::default_values())
 {
   typedef typename boost::graph_traits<TriangleMesh>::halfedge_descriptor        halfedge_descriptor;
 
@@ -1371,7 +1371,7 @@ template <typename ConcurrencyTag = CGAL::Sequential_tag,
           typename TriangleMesh,
           typename CGAL_BGL_NP_TEMPLATE_PARAMETERS>
 std::size_t snap_borders(TriangleMesh& tm,
-                         const CGAL_BGL_NP_CLASS& np = parameters::use_default_values())
+                         const CGAL_BGL_NP_CLASS& np = parameters::default_values())
 {
   typedef typename boost::graph_traits<TriangleMesh>::halfedge_descriptor        halfedge_descriptor;
 

Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/internal/Snapping/snap_vertices.h

@@ -1204,8 +1204,8 @@ std::size_t snap_vertices(const HalfedgeRange_A& halfedge_range_A,
                           const HalfedgeRange_B& halfedge_range_B,
                           PolygonMesh& tm_B,
                           ToleranceMap_B tolerance_map_B,
-                          const NamedParameters_A& np_A = parameters::use_default_values(),
+                          const NamedParameters_A& np_A = parameters::default_values(),
-                          const NamedParameters_B& np_B = parameters::use_default_values())
+                          const NamedParameters_B& np_B = parameters::default_values())
 {
   CGAL::Emptyset_iterator unused_output_iterator;
 
@@ -1224,8 +1224,8 @@ std::size_t snap_vertices(const HalfedgeRange_A& halfedge_range_A,
                           PolygonMesh& tm_A,
                           const HalfedgeRange_B& halfedge_range_B,
                           PolygonMesh& tm_B,
-                          const CGAL_BGL_NP_CLASS_1& np_A=parameters::use_default_values(),
+                          const CGAL_BGL_NP_CLASS_1& np_A=parameters::default_values(),
-                          const CGAL_BGL_NP_CLASS_2& np_B=parameters::use_default_values())
+                          const CGAL_BGL_NP_CLASS_2& np_B=parameters::default_values())
 {
   typedef typename GetGeomTraits<PolygonMesh, CGAL_BGL_NP_CLASS_1>::type              GT;
   typedef typename GT::FT                                                             FT;

Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/internal/simplify_polyline.h

@@ -33,8 +33,8 @@ template <typename PointRangeIn, typename PointRangeOut,
 void simplify_polyline(const PointRangeIn& input,
                              PointRangeOut& output,
                        const double max_squared_frechet_distance,
-                       const NamedParametersIn& np_in = parameters::use_default_values(),
+                       const NamedParametersIn& np_in = parameters::default_values(),
-                       const NamedParametersOut& np_out = parameters::use_default_values())
+                       const NamedParametersOut& np_out = parameters::default_values())
 {
   using parameters::choose_parameter;
   using parameters::get_parameter;

Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/intersection.h

@@ -1255,8 +1255,8 @@ template <class TriangleMesh,
           class NamedParameters2 = parameters::Default_named_parameters>
 bool do_intersect(const TriangleMesh& tm1,
                   const TriangleMesh& tm2,
-                  const NamedParameters1& np1 = parameters::use_default_values(),
+                  const NamedParameters1& np1 = parameters::default_values(),
-                  const NamedParameters2& np2 = parameters::use_default_values()
+                  const NamedParameters2& np2 = parameters::default_values()
 #ifndef DOXYGEN_RUNNING
                   , const typename boost::disable_if<
                                     typename boost::has_range_const_iterator<TriangleMesh>::type
@@ -1340,7 +1340,7 @@ template <class TriangleMesh,
           class NamedParameters = parameters::Default_named_parameters>
 bool do_intersect(const TriangleMesh& tm,
                   const PolylineRange& polylines,
-                  const NamedParameters& np = parameters::use_default_values()
+                  const NamedParameters& np = parameters::default_values()
 #ifndef DOXYGEN_RUNNING
                 , const typename boost::enable_if<
                     typename boost::has_range_iterator<
@@ -1405,7 +1405,7 @@ template <class TriangleMesh,
           class NamedParameters = parameters::Default_named_parameters>
 bool do_intersect(const TriangleMesh& tm,
                   const Polyline& polyline,
-                  const NamedParameters& np = parameters::use_default_values()
+                  const NamedParameters& np = parameters::default_values()
 #ifndef DOXYGEN_RUNNING
                 , const typename boost::disable_if<
                     typename boost::has_range_iterator<
@@ -1642,7 +1642,7 @@ OutputIterator intersecting_meshes(const TriangleMeshRange& range,
                                    const NamedParameters& np)
 {
   std::vector<parameters::Default_named_parameters> nps(
-    std::distance(range.begin(), range.end()), parameters::use_default_values());
+    std::distance(range.begin(), range.end()), parameters::default_values());
   return intersecting_meshes(range, out, np, nps);
 }
 
@@ -1650,7 +1650,7 @@ template <class TriangleMeshRange, class OutputIterator>
 OutputIterator intersecting_meshes(const TriangleMeshRange& range,
                                          OutputIterator out)
 {
-  return intersecting_meshes(range, out, parameters::use_default_values());
+  return intersecting_meshes(range, out, parameters::default_values());
 }
 
 /**
@@ -1705,8 +1705,8 @@ OutputIterator
 surface_intersection(const TriangleMesh& tm1,
                      const TriangleMesh& tm2,
                      OutputIterator polyline_output,
-                     const NamedParameters1& np1 = parameters::use_default_values(),
+                     const NamedParameters1& np1 = parameters::default_values(),
-                     const NamedParameters2& np2 = parameters::use_default_values())
+                     const NamedParameters2& np2 = parameters::default_values())
 {
   const bool throw_on_self_intersection =
     parameters::choose_parameter(parameters::get_parameter(np1, internal_np::throw_on_self_intersection), false);
@@ -1766,7 +1766,7 @@ template <class OutputIterator,
 OutputIterator
 surface_self_intersection(const TriangleMesh& tm,
                          OutputIterator polyline_output,
-                         const NamedParameters& np = parameters::use_default_values())
+                         const NamedParameters& np = parameters::default_values())
 {
 // Vertex point maps
   typedef typename GetVertexPointMap<TriangleMesh, NamedParameters>::const_type VPM;

Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/locate.h

@@ -596,7 +596,7 @@ construct_point(const std::pair<typename boost::graph_traits<TriangleMesh>::face
                                 std::array<FT, 3> >& loc,
 #endif
                 const TriangleMesh& tm,
-                const NamedParameters& np = parameters::use_default_values())
+                const NamedParameters& np = parameters::default_values())
 {
   typedef typename boost::graph_traits<TriangleMesh>::halfedge_descriptor        halfedge_descriptor;
   typedef typename GetGeomTraits<TriangleMesh, NamedParameters>::type            Geom_traits;
@@ -1107,7 +1107,7 @@ locate_in_face(const typename internal::Location_traits<TriangleMesh, NamedParam
 #endif
                const typename boost::graph_traits<TriangleMesh>::face_descriptor fd,
                const TriangleMesh& tm,
-               const NamedParameters& np = parameters::use_default_values())
+               const NamedParameters& np = parameters::default_values())
 {
   typedef typename boost::graph_traits<TriangleMesh>::vertex_descriptor          vertex_descriptor;
 
@@ -1577,7 +1577,7 @@ build_AABB_tree(const TriangleMesh& tm,
                     typename GetGeomTraits<TriangleMesh, NamedParameters>::type,
 #endif
                     CGAL::AABB_face_graph_triangle_primitive<TriangleMesh, Point3VPM> > >& outTree,
-                const NamedParameters& np = parameters::use_default_values())
+                const NamedParameters& np = parameters::default_values())
 {
   typedef typename GetVertexPointMap<TriangleMesh, NamedParameters>::const_type     VertexPointMap;
 
@@ -1654,7 +1654,7 @@ locate_with_AABB_tree(const typename internal::Location_traits<TriangleMesh, Nam
                                 CGAL::AABB_face_graph_triangle_primitive<TriangleMesh, Point3VPM> > >& tree,
 #endif
                       const TriangleMesh& tm,
-                      const NamedParameters& np = parameters::use_default_values())
+                      const NamedParameters& np = parameters::default_values())
 {
   typedef typename internal::Location_traits<TriangleMesh, NamedParameters>::Point         Point;
   typedef internal::Point_to_Point_3<TriangleMesh, Point>                                  P_to_P3;
@@ -1738,7 +1738,7 @@ typename internal::Location_traits<TriangleMesh, NamedParameters>::Face_location
 locate(const typename internal::Location_traits<TriangleMesh, NamedParameters>::Point& p,
 #endif
        const TriangleMesh& tm,
-       const NamedParameters& np = parameters::use_default_values())
+       const NamedParameters& np = parameters::default_values())
 {
   // Wrap the input VPM with a one converting to 3D (costs nothing if the input VPM
   // already has value type Kernel::Point_3)
@@ -1831,7 +1831,7 @@ locate_with_AABB_tree(const typename internal::Location_traits<TriangleMesh, Nam
                       > >& tree,
 #endif
                       const TriangleMesh& tm,
-                      const NamedParameters& np = parameters::use_default_values())
+                      const NamedParameters& np = parameters::default_values())
 {
   typedef typename GetGeomTraits<TriangleMesh, NamedParameters>::type                        Geom_traits;
 
@@ -1956,7 +1956,7 @@ typename internal::Location_traits<TriangleMesh>::Face_location
 locate(const typename internal::Location_traits<TriangleMesh, NamedParameters>::Ray& ray,
 #endif
        const TriangleMesh& tm,
-       const NamedParameters& np = parameters::use_default_values())
+       const NamedParameters& np = parameters::default_values())
 {
   typedef typename GetVertexPointMap<TriangleMesh, NamedParameters>::const_type     VertexPointMap;
 

Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/manifoldness.h

@@ -429,7 +429,7 @@ OutputIterator non_manifold_vertices(const PolygonMesh& pm,
 /// \return the number of vertices created.
 template <typename PolygonMesh, typename NamedParameters = parameters::Default_named_parameters>
 std::size_t duplicate_non_manifold_vertices(PolygonMesh& pm,
-                                            const NamedParameters& np = parameters::use_default_values())
+                                            const NamedParameters& np = parameters::default_values())
 {
   using parameters::get_parameter;
   using parameters::choose_parameter;

Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/measure.h

@@ -105,7 +105,7 @@ typename GetGeomTraits<PolygonMesh, NamedParameters>::type::FT
 #endif
 edge_length(typename boost::graph_traits<PolygonMesh>::halfedge_descriptor h,
             const PolygonMesh& pmesh,
-            const NamedParameters& np = parameters::use_default_values())
+            const NamedParameters& np = parameters::default_values())
 {
   typedef typename GetGeomTraits<PolygonMesh, NamedParameters>::type Geom_traits;
 
@@ -130,7 +130,7 @@ template<typename PolygonMesh,
 typename GetGeomTraits<PolygonMesh, NamedParameters>::type::FT
 edge_length(typename boost::graph_traits<PolygonMesh>::edge_descriptor e,
             const PolygonMesh& pmesh,
-            const NamedParameters& np = parameters::use_default_values())
+            const NamedParameters& np = parameters::default_values())
 {
   return edge_length(halfedge(e, pmesh), pmesh, np);
 }
@@ -180,7 +180,7 @@ typename GetGeomTraits<PolygonMesh, NamedParameters>::type::FT
 #endif
 squared_edge_length(typename boost::graph_traits<PolygonMesh>::halfedge_descriptor h,
                     const PolygonMesh& pmesh,
-                    const NamedParameters& np = parameters::use_default_values())
+                    const NamedParameters& np = parameters::default_values())
 {
   typedef typename GetGeomTraits<PolygonMesh, NamedParameters>::type Geom_traits;
 
@@ -206,7 +206,7 @@ template<typename PolygonMesh,
 typename GetGeomTraits<PolygonMesh, NamedParameters>::type::FT
 squared_edge_length(typename boost::graph_traits<PolygonMesh>::edge_descriptor e,
                     const PolygonMesh& pmesh,
-                    const NamedParameters& np = parameters::use_default_values())
+                    const NamedParameters& np = parameters::default_values())
 {
   return squared_edge_length(halfedge(e, pmesh), pmesh, np);
 }
@@ -260,7 +260,7 @@ typename GetGeomTraits<PolygonMesh, NamedParameters>::type::FT
 #endif
 face_border_length(typename boost::graph_traits<PolygonMesh>::halfedge_descriptor h,
                    const PolygonMesh& pmesh,
-                   const NamedParameters& np = parameters::use_default_values())
+                   const NamedParameters& np = parameters::default_values())
 {
   typename GetGeomTraits<PolygonMesh, NamedParameters>::type::FT result = 0;
 
@@ -320,7 +320,7 @@ std::pair<typename boost::graph_traits<PolygonMesh>::halfedge_descriptor,
 typename GetGeomTraits<PolygonMesh, NamedParameters>::type::FT>
 #endif
 longest_border(const PolygonMesh& pmesh,
-               const NamedParameters& np = parameters::use_default_values())
+               const NamedParameters& np = parameters::default_values())
 {
   typedef typename CGAL::Kernel_traits<
             typename property_map_value<PolygonMesh, CGAL::vertex_point_t>::type>::Kernel::FT  FT;
@@ -405,7 +405,7 @@ typename GetGeomTraits<TriangleMesh, CGAL_BGL_NP_CLASS>::type::FT
 #endif
 face_area(typename boost::graph_traits<TriangleMesh>::face_descriptor f,
           const TriangleMesh& tmesh,
-          const CGAL_BGL_NP_CLASS& np = parameters::use_default_values())
+          const CGAL_BGL_NP_CLASS& np = parameters::default_values())
 {
   using parameters::choose_parameter;
   using parameters::get_parameter;
@@ -477,7 +477,7 @@ typename GetGeomTraits<TriangleMesh, CGAL_BGL_NP_CLASS>::type::FT
 #endif
 squared_face_area(typename boost::graph_traits<TriangleMesh>::face_descriptor f,
                   const TriangleMesh& tmesh,
-                  const CGAL_BGL_NP_CLASS& np = parameters::use_default_values())
+                  const CGAL_BGL_NP_CLASS& np = parameters::default_values())
 {
   using parameters::choose_parameter;
   using parameters::get_parameter;
@@ -554,7 +554,7 @@ typename GetGeomTraits<TriangleMesh, CGAL_BGL_NP_CLASS>::type::FT
 #endif
 area(FaceRange face_range,
      const TriangleMesh& tmesh,
-     const CGAL_BGL_NP_CLASS& np = parameters::use_default_values())
+     const CGAL_BGL_NP_CLASS& np = parameters::default_values())
 {
   typedef typename boost::graph_traits<TriangleMesh>::face_descriptor face_descriptor;
 
@@ -613,7 +613,7 @@ FT
 #else
 typename GetGeomTraits<TriangleMesh, CGAL_BGL_NP_CLASS>::type::FT
 #endif
-area(const TriangleMesh& tmesh, const CGAL_BGL_NP_CLASS& np = parameters::use_default_values())
+area(const TriangleMesh& tmesh, const CGAL_BGL_NP_CLASS& np = parameters::default_values())
 {
   return area(faces(tmesh), tmesh, np);
 }
@@ -661,7 +661,7 @@ FT
 typename GetGeomTraits<TriangleMesh, CGAL_BGL_NP_CLASS>::type::FT
 #endif
 volume(const TriangleMesh& tmesh,
-       const CGAL_BGL_NP_CLASS& np = parameters::use_default_values())
+       const CGAL_BGL_NP_CLASS& np = parameters::default_values())
 {
   CGAL_assertion(is_triangle_mesh(tmesh));
   CGAL_assertion(is_closed(tmesh));
@@ -735,7 +735,7 @@ typename GetGeomTraits<TriangleMesh, CGAL_BGL_NP_CLASS>::type::FT
 #endif
 face_aspect_ratio(typename boost::graph_traits<TriangleMesh>::face_descriptor f,
                   const TriangleMesh& tmesh,
-                  const CGAL_BGL_NP_CLASS& np = parameters::use_default_values())
+                  const CGAL_BGL_NP_CLASS& np = parameters::default_values())
 {
   CGAL_precondition(is_triangle(f, tmesh));
 
@@ -839,7 +839,7 @@ Point_3
 #else
 typename GetGeomTraits<TriangleMesh, CGAL_BGL_NP_CLASS>::type::Point_3
 #endif
-centroid(const TriangleMesh& tmesh, const CGAL_BGL_NP_CLASS& np = parameters::use_default_values())
+centroid(const TriangleMesh& tmesh, const CGAL_BGL_NP_CLASS& np = parameters::default_values())
 {
   // See: http://www2.imperial.ac.uk/~rn/centroid.pdf
 
@@ -960,8 +960,8 @@ template< typename PolygonMesh1,
           typename NamedParameters2 = parameters::Default_named_parameters >
 void match_faces(const PolygonMesh1& m1, const PolygonMesh2& m2,
                  FacePairOutputIterator common, FaceOutputIterator1 m1_only, FaceOutputIterator2 m2_only,
-                 const NamedParameters1& np1 = parameters::use_default_values(),
+                 const NamedParameters1& np1 = parameters::default_values(),
-                 const NamedParameters2& np2 = parameters::use_default_values())
+                 const NamedParameters2& np2 = parameters::default_values())
 {
   typedef typename GetVertexPointMap<PolygonMesh1, NamedParameters1>::const_type            VPMap1;
   typedef typename GetVertexPointMap<PolygonMesh2, NamedParameters2>::const_type            VPMap2;

Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/merge_border_vertices.h

@@ -281,7 +281,7 @@ template <class PolygonMesh, class NamedParameters = parameters::Default_named_p
 void merge_duplicated_vertices_in_boundary_cycle(
         typename boost::graph_traits<PolygonMesh>::halfedge_descriptor h,
         PolygonMesh& pm,
-        const NamedParameters& np = parameters::use_default_values())
+        const NamedParameters& np = parameters::default_values())
 {
   typedef typename boost::graph_traits<PolygonMesh>::halfedge_descriptor halfedge_descriptor;
   typedef typename GetVertexPointMap<PolygonMesh, NamedParameters>::const_type Vpm;
@@ -335,7 +335,7 @@ void merge_duplicated_vertices_in_boundary_cycle(
 /// \sa `merge_duplicated_vertices_in_boundary_cycle()`
 template <class PolygonMesh, class NamedParameters = parameters::Default_named_parameters>
 void merge_duplicated_vertices_in_boundary_cycles(      PolygonMesh& pm,
-                                                  const NamedParameters& np = parameters::use_default_values())
+                                                  const NamedParameters& np = parameters::default_values())
 {
   typedef typename boost::graph_traits<PolygonMesh>::halfedge_descriptor halfedge_descriptor;
 

Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/orient_polygon_soup.h

@@ -525,7 +525,7 @@ struct Polygon_soup_orienter
 template <class PointRange, class PolygonRange, class NamedParameters = parameters::Default_named_parameters>
 bool orient_polygon_soup(PointRange& points,
                          PolygonRange& polygons,
-                         const NamedParameters& np = parameters::use_default_values())
+                         const NamedParameters& np = parameters::default_values())
 {
   using parameters::choose_parameter;
   using parameters::get_parameter;

Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/orient_polygon_soup_extension.h

@@ -124,7 +124,7 @@ orient_triangle_soup_with_reference_triangle_mesh(
     const TriangleMesh& tm_ref,
     PointRange& points,
     TriangleRange& triangles,
-    const NamedParameters& np = parameters::use_default_values())
+    const NamedParameters& np = parameters::default_values())
 {
   namespace PMP = CGAL::Polygon_mesh_processing;
 

Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/orientation.h

@@ -183,7 +183,7 @@ namespace internal{
  */
 template<typename TriangleMesh, typename NamedParameters = parameters::Default_named_parameters>
 bool is_outward_oriented(const TriangleMesh& tm,
-                         const NamedParameters& np = parameters::use_default_values())
+                         const NamedParameters& np = parameters::default_values())
 {
   CGAL_warning(CGAL::is_closed(tm));
   CGAL_warning(CGAL::is_triangle_mesh(tm));
@@ -396,7 +396,7 @@ void reverse_face_orientations(const FaceRange& face_range, PolygonMesh& pmesh)
 */
 template<class TriangleMesh, class NamedParameters = parameters::Default_named_parameters>
 void orient(TriangleMesh& tm,
-            const NamedParameters& np = parameters::use_default_values())
+            const NamedParameters& np = parameters::default_values())
 {
   typedef boost::graph_traits<TriangleMesh>                                        Graph_traits;
   typedef typename Graph_traits::vertex_descriptor                                 vertex_descriptor;
@@ -798,7 +798,7 @@ template <class TriangleMesh, class VolumeFaceIndexMap, class NamedParameters =
 std::size_t
 volume_connected_components(const TriangleMesh& tm,
                                   VolumeFaceIndexMap volume_id_map,
-                            const NamedParameters& np = parameters::use_default_values())
+                            const NamedParameters& np = parameters::default_values())
 {
   CGAL_precondition(is_triangle_mesh(tm));
   CGAL_precondition(is_closed(tm));
@@ -1253,7 +1253,7 @@ volume_connected_components(const TriangleMesh& tm,
  * \see `CGAL::Polygon_mesh_processing::orient_to_bound_a_volume()`
  */
 template <class TriangleMesh, class NamedParameters = parameters::Default_named_parameters>
-bool does_bound_a_volume(const TriangleMesh& tm, const NamedParameters& np = parameters::use_default_values())
+bool does_bound_a_volume(const TriangleMesh& tm, const NamedParameters& np = parameters::default_values())
 {
   typedef boost::graph_traits<TriangleMesh> GT;
   typedef typename GT::face_descriptor face_descriptor;
@@ -1319,7 +1319,7 @@ bool does_bound_a_volume(const TriangleMesh& tm, const NamedParameters& np = par
  */
 template <class TriangleMesh, class NamedParameters = parameters::Default_named_parameters>
 void orient_to_bound_a_volume(TriangleMesh& tm,
-                              const NamedParameters& np = parameters::use_default_values())
+                              const NamedParameters& np = parameters::default_values())
 {
   typedef boost::graph_traits<TriangleMesh>                                        Graph_traits;
   typedef typename Graph_traits::face_descriptor                                   face_descriptor;
@@ -1424,7 +1424,7 @@ void orient_to_bound_a_volume(TriangleMesh& tm,
  */
 template <class PolygonMesh, class NamedParameters = parameters::Default_named_parameters>
 void merge_reversible_connected_components(PolygonMesh& pm,
-                                           const NamedParameters& np = parameters::use_default_values())
+                                           const NamedParameters& np = parameters::default_values())
 {
   typedef boost::graph_traits<PolygonMesh> GrT;
   typedef typename GrT::face_descriptor face_descriptor;

Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/polygon_mesh_to_polygon_soup.h

@@ -72,7 +72,7 @@ template<typename PolygonMesh,
 void polygon_mesh_to_polygon_soup(const PolygonMesh& mesh,
                                   PointRange& points,
                                   PolygonRange& polygons,
-                                  const NamedParameters& np = parameters::use_default_values())
+                                  const NamedParameters& np = parameters::default_values())
 {
   typedef typename boost::graph_traits<PolygonMesh>::vertex_descriptor              vertex_descriptor;
   typedef typename boost::graph_traits<PolygonMesh>::halfedge_descriptor            halfedge_descriptor;

Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/polygon_soup_to_polygon_mesh.h

@@ -273,8 +273,8 @@ template<typename PolygonMesh,
 void polygon_soup_to_polygon_mesh(const PointRange& points,
                                   const PolygonRange& polygons,
                                   PolygonMesh& out,
-                                  const NamedParameters_PS& np_ps = parameters::use_default_values(),
+                                  const NamedParameters_PS& np_ps = parameters::default_values(),
-                                  const NamedParameters_PM& np_pm = parameters::use_default_values())
+                                  const NamedParameters_PM& np_pm = parameters::default_values())
 {
   CGAL_precondition_msg(is_polygon_soup_a_polygon_mesh(polygons),
                         "Input soup needs to define a valid polygon mesh! See is_polygon_soup_a_polygon_mesh() for further information.");

Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/random_perturbation.h

@@ -156,7 +156,7 @@ template<typename VertexRange, typename TriangleMesh, typename NamedParameters =
 void random_perturbation(VertexRange vertices
                        , TriangleMesh& tmesh
                        , const double& perturbation_max_size
-                       , const NamedParameters& np = parameters::use_default_values())
+                       , const NamedParameters& np = parameters::default_values())
 {
   typedef TriangleMesh PM;
   using parameters::get_parameter;
@@ -215,7 +215,7 @@ void random_perturbation(VertexRange vertices
 template<typename TriangleMesh, typename NamedParameters = parameters::Default_named_parameters>
 void random_perturbation(TriangleMesh& tmesh
                        , const double& perturbation_max_size
-                       , const NamedParameters& np = parameters::use_default_values())
+                       , const NamedParameters& np = parameters::default_values())
 {
   random_perturbation(vertices(tmesh), tmesh, perturbation_max_size, np);
 }

Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/refine.h

@@ -78,7 +78,7 @@ namespace Polygon_mesh_processing {
            const FaceRange& faces,
            FaceOutputIterator faces_out,
            VertexOutputIterator vertices_out,
-           const NamedParameters& np = parameters::use_default_values())
+           const NamedParameters& np = parameters::default_values())
   {
     using parameters::choose_parameter;
     using parameters::get_parameter;

Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/remesh.h

@@ -196,7 +196,7 @@ template<typename PolygonMesh
 void isotropic_remeshing(const FaceRange& faces
                        , const double& target_edge_length
                        , PolygonMesh& pmesh
-                       , const NamedParameters& np = parameters::use_default_values())
+                       , const NamedParameters& np = parameters::default_values())
 {
   if (boost::begin(faces)==boost::end(faces))
     return;
@@ -394,7 +394,7 @@ template<typename PolygonMesh
 void split_long_edges(const EdgeRange& edges
                     , const double& max_length
                     , PolygonMesh& pmesh
-                    , const NamedParameters& np = parameters::use_default_values())
+                    , const NamedParameters& np = parameters::default_values())
 {
   typedef PolygonMesh PM;
   typedef typename boost::graph_traits<PM>::edge_descriptor edge_descriptor;

Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/repair.h

@@ -150,7 +150,7 @@ std::size_t remove_isolated_vertices(PolygonMesh& pmesh)
 template <typename TriangleMesh,
           typename NamedParameters = parameters::Default_named_parameters>
 std::size_t remove_connected_components_of_negligible_size(TriangleMesh& tmesh,
-                                                           const NamedParameters& np = parameters::use_default_values())
+                                                           const NamedParameters& np = parameters::default_values())
 {
   using parameters::choose_parameter;
   using parameters::is_default_parameter;

Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/repair_degeneracies.h

@@ -535,7 +535,7 @@ bool remove_almost_degenerate_faces(const FaceRange& face_range,
                                     const double cap_threshold,
                                     const double needle_threshold,
                                     const double collapse_length_threshold,
-                                    const NamedParameters& np = parameters::use_default_values())
+                                    const NamedParameters& np = parameters::default_values())
 {
   using CGAL::parameters::choose_parameter;
   using CGAL::parameters::get_parameter;
@@ -913,7 +913,7 @@ bool remove_almost_degenerate_faces(TriangleMesh& tmesh,
                                     const double cap_threshold,
                                     const double needle_threshold,
                                     const double collapse_length_threshold,
-                                    const CGAL_BGL_NP_CLASS& np = parameters::use_default_values())
+                                    const CGAL_BGL_NP_CLASS& np = parameters::default_values())
 {
   return remove_almost_degenerate_faces(faces(tmesh), tmesh, cap_threshold, needle_threshold,
                                         collapse_length_threshold, np);
@@ -1206,7 +1206,7 @@ template <typename EdgeRange, typename TriangleMesh, typename FaceSet, typename
 bool remove_degenerate_edges(const EdgeRange& edge_range,
                              TriangleMesh& tmesh,
                              FaceSet& face_set,
-                             const NamedParameters& np = parameters::use_default_values())
+                             const NamedParameters& np = parameters::default_values())
 {
   CGAL_assertion(CGAL::is_triangle_mesh(tmesh));
   CGAL_assertion(CGAL::is_valid_polygon_mesh(tmesh));
@@ -1708,7 +1708,7 @@ bool remove_degenerate_edges(const EdgeRange& edge_range,
 template <typename EdgeRange, typename TriangleMesh, typename CGAL_BGL_NP_TEMPLATE_PARAMETERS>
 bool remove_degenerate_edges(const EdgeRange& edge_range,
                              TriangleMesh& tmesh,
-                             const CGAL_BGL_NP_CLASS& np = parameters::use_default_values())
+                             const CGAL_BGL_NP_CLASS& np = parameters::default_values())
 {
   std::set<typename boost::graph_traits<TriangleMesh>::face_descriptor> face_set;
   return remove_degenerate_edges(edge_range, tmesh, face_set, np);
@@ -1716,7 +1716,7 @@ bool remove_degenerate_edges(const EdgeRange& edge_range,
 
 template <typename TriangleMesh, typename CGAL_BGL_NP_TEMPLATE_PARAMETERS>
 bool remove_degenerate_edges(TriangleMesh& tmesh,
-                             const CGAL_BGL_NP_CLASS& np = parameters::use_default_values())
+                             const CGAL_BGL_NP_CLASS& np = parameters::default_values())
 {
   std::set<typename boost::graph_traits<TriangleMesh>::face_descriptor> face_set;
   return remove_degenerate_edges(edges(tmesh), tmesh, face_set, np);
@@ -1766,7 +1766,7 @@ bool remove_degenerate_edges(TriangleMesh& tmesh,
 template <typename FaceRange, typename TriangleMesh, typename NamedParameters = parameters::Default_named_parameters>
 bool remove_degenerate_faces(const FaceRange& face_range,
                              TriangleMesh& tmesh,
-                             const NamedParameters& np = parameters::use_default_values())
+                             const NamedParameters& np = parameters::default_values())
 {
   CGAL_assertion(CGAL::is_triangle_mesh(tmesh));
   CGAL_assertion(CGAL::is_valid_polygon_mesh(tmesh));
@@ -2581,7 +2581,7 @@ bool remove_degenerate_faces(const FaceRange& face_range,
 
 template <typename TriangleMesh, typename CGAL_BGL_NP_TEMPLATE_PARAMETERS>
 bool remove_degenerate_faces(TriangleMesh& tmesh,
-                             const CGAL_BGL_NP_CLASS& np = parameters::use_default_values())
+                             const CGAL_BGL_NP_CLASS& np = parameters::default_values())
 {
   return remove_degenerate_faces(faces(tmesh), tmesh, np);
 }

Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/repair_polygon_soup.h

@@ -477,7 +477,7 @@ std::size_t remove_isolated_points_in_polygon_soup(PointRange& points,
 template <typename PointRange, typename PolygonRange, typename NamedParameters = parameters::Default_named_parameters>
 std::size_t merge_duplicate_points_in_polygon_soup(PointRange& points,
                                                    PolygonRange& polygons,
-                                                   const NamedParameters& np = parameters::use_default_values())
+                                                   const NamedParameters& np = parameters::default_values())
 {
   typedef typename internal::Polygon_types<PointRange, PolygonRange>::P_ID        P_ID;
   typedef typename internal::Polygon_types<PointRange, PolygonRange>::Point_3     Point_3;
@@ -876,7 +876,7 @@ DuplicateOutputIterator collect_duplicate_polygons(const PointRange& points,
 template <typename PointRange, typename PolygonRange, typename NamedParameters = parameters::Default_named_parameters>
 std::size_t merge_duplicate_polygons_in_polygon_soup(const PointRange& points,
                                                      PolygonRange& polygons,
-                                                     const NamedParameters& np = parameters::use_default_values())
+                                                     const NamedParameters& np = parameters::default_values())
 {
   using parameters::get_parameter;
   using parameters::choose_parameter;
@@ -1032,7 +1032,7 @@ std::size_t merge_duplicate_polygons_in_polygon_soup(const PointRange& points,
 template <typename PointRange, typename PolygonRange, typename NamedParameters = parameters::Default_named_parameters>
 void repair_polygon_soup(PointRange& points,
                          PolygonRange& polygons,
-                         const NamedParameters& np = parameters::use_default_values())
+                         const NamedParameters& np = parameters::default_values())
 {
   using parameters::get_parameter;
   using parameters::choose_parameter;

Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/repair_self_intersections.h

@@ -1959,7 +1959,7 @@ struct Remove_self_intersection_default_visitor
 template <typename FaceRange, typename TriangleMesh, typename NamedParameters = parameters::Default_named_parameters>
 bool remove_self_intersections(const FaceRange& face_range,
                                TriangleMesh& tmesh,
-                               const NamedParameters& np = parameters::use_default_values())
+                               const NamedParameters& np = parameters::default_values())
 {
   using parameters::choose_parameter;
   using parameters::get_parameter;
@@ -2105,7 +2105,7 @@ bool remove_self_intersections(const FaceRange& face_range,
 }
 
 template <typename TriangleMesh, typename CGAL_BGL_NP_TEMPLATE_PARAMETERS>
-bool remove_self_intersections(TriangleMesh& tmesh, const CGAL_BGL_NP_CLASS& np = parameters::use_default_values())
+bool remove_self_intersections(TriangleMesh& tmesh, const CGAL_BGL_NP_CLASS& np = parameters::default_values())
 {
   return remove_self_intersections(faces(tmesh), tmesh, np);
 }

Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/self_intersections.h

@@ -461,7 +461,7 @@ FacePairOutputIterator
 self_intersections(const FaceRange& face_range,
                    const TriangleMesh& tmesh,
                          FacePairOutputIterator out,
-                   const NamedParameters& np = parameters::use_default_values())
+                   const NamedParameters& np = parameters::default_values())
 {
   return internal::self_intersections_impl<ConcurrencyTag>(face_range, tmesh, out, false /*don't throw*/, np);
 }
@@ -524,7 +524,7 @@ template <class ConcurrencyTag = Sequential_tag,
 FacePairOutputIterator
 self_intersections(const TriangleMesh& tmesh,
                          FacePairOutputIterator out,
-                   const CGAL_BGL_NP_CLASS& np = parameters::use_default_values())
+                   const CGAL_BGL_NP_CLASS& np = parameters::default_values())
 {
   return self_intersections<ConcurrencyTag>(faces(tmesh), tmesh, out, np);
 }
@@ -570,7 +570,7 @@ template <class ConcurrencyTag = Sequential_tag,
           class NamedParameters = parameters::Default_named_parameters>
 bool does_self_intersect(const FaceRange& face_range,
                          const TriangleMesh& tmesh,
-                         const NamedParameters& np = parameters::use_default_values())
+                         const NamedParameters& np = parameters::default_values())
 {
   CGAL_precondition(CGAL::is_triangle_mesh(tmesh));
 
@@ -634,7 +634,7 @@ template <class ConcurrencyTag = Sequential_tag,
           class TriangleMesh,
           class CGAL_BGL_NP_TEMPLATE_PARAMETERS>
 bool does_self_intersect(const TriangleMesh& tmesh,
-                         const CGAL_BGL_NP_CLASS& np = parameters::use_default_values())
+                         const CGAL_BGL_NP_CLASS& np = parameters::default_values())
 {
   return does_self_intersect<ConcurrencyTag>(faces(tmesh), tmesh, np);
 }

Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/shape_predicates.h

@@ -69,7 +69,7 @@ namespace Polygon_mesh_processing {
 template <typename PolygonMesh, typename NamedParameters = parameters::Default_named_parameters>
 bool is_degenerate_edge(typename boost::graph_traits<PolygonMesh>::edge_descriptor e,
                         const PolygonMesh& pm,
-                        const NamedParameters& np = parameters::use_default_values())
+                        const NamedParameters& np = parameters::default_values())
 {
   using parameters::get_parameter;
   using parameters::choose_parameter;
@@ -118,7 +118,7 @@ template <typename EdgeRange, typename TriangleMesh, typename OutputIterator, ty
 OutputIterator degenerate_edges(const EdgeRange& edges,
                                 const TriangleMesh& tm,
                                 OutputIterator out,
-                                const CGAL_BGL_NP_CLASS& np = parameters::use_default_values())
+                                const CGAL_BGL_NP_CLASS& np = parameters::default_values())
 {
   typedef typename boost::graph_traits<TriangleMesh>::edge_descriptor edge_descriptor;
 
@@ -137,7 +137,7 @@ OutputIterator degenerate_edges(const EdgeRange& edges,
 template <typename TriangleMesh, typename OutputIterator, typename CGAL_BGL_NP_TEMPLATE_PARAMETERS>
 OutputIterator degenerate_edges(const TriangleMesh& tm,
                                 OutputIterator out,
-                                const CGAL_BGL_NP_CLASS& np = parameters::use_default_values()
+                                const CGAL_BGL_NP_CLASS& np = parameters::default_values()
                                )
 {
   return degenerate_edges(edges(tm), tm, out, np);
@@ -177,7 +177,7 @@ OutputIterator degenerate_edges(const TriangleMesh& tm,
 template <typename TriangleMesh, typename NamedParameters = parameters::Default_named_parameters>
 bool is_degenerate_triangle_face(typename boost::graph_traits<TriangleMesh>::face_descriptor f,
                                  const TriangleMesh& tm,
-                                 const NamedParameters& np = parameters::use_default_values())
+                                 const NamedParameters& np = parameters::default_values())
 {
   CGAL_precondition(CGAL::is_triangle(halfedge(f, tm), tm));
 
@@ -233,7 +233,7 @@ template <typename FaceRange, typename TriangleMesh, typename OutputIterator, ty
 OutputIterator degenerate_faces(const FaceRange& faces,
                                 const TriangleMesh& tm,
                                 OutputIterator out,
-                                const CGAL_BGL_NP_CLASS& np = parameters::use_default_values())
+                                const CGAL_BGL_NP_CLASS& np = parameters::default_values())
 {
   typedef typename boost::graph_traits<TriangleMesh>::face_descriptor face_descriptor;
 
@@ -253,7 +253,7 @@ OutputIterator degenerate_faces(const FaceRange& faces,
 template <typename TriangleMesh, typename OutputIterator, typename CGAL_BGL_NP_TEMPLATE_PARAMETERS>
 OutputIterator degenerate_faces(const TriangleMesh& tm,
                                 OutputIterator out,
-                                const CGAL_BGL_NP_CLASS& np = parameters::use_default_values()
+                                const CGAL_BGL_NP_CLASS& np = parameters::default_values()
                                 )
 {
   return degenerate_faces(faces(tm), tm, out, np);
@@ -295,7 +295,7 @@ typename boost::graph_traits<TriangleMesh>::halfedge_descriptor
 is_needle_triangle_face(typename boost::graph_traits<TriangleMesh>::face_descriptor f,
                         const TriangleMesh& tm,
                         const double threshold,
-                        const NamedParameters& np = parameters::use_default_values())
+                        const NamedParameters& np = parameters::default_values())
 {
   CGAL_precondition(threshold >= 1.);
   CGAL_precondition(f != boost::graph_traits<TriangleMesh>::null_face());
@@ -393,7 +393,7 @@ typename boost::graph_traits<TriangleMesh>::halfedge_descriptor
 is_cap_triangle_face(typename boost::graph_traits<TriangleMesh>::face_descriptor f,
                      const TriangleMesh& tm,
                      const double threshold,
-                     const NamedParameters& np = parameters::use_default_values())
+                     const NamedParameters& np = parameters::default_values())
 {
   CGAL_precondition(f != boost::graph_traits<TriangleMesh>::null_face());
   CGAL_precondition(CGAL::is_triangle(halfedge(f, tm), tm));

Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/smooth_mesh.h

@@ -132,7 +132,7 @@ namespace Polygon_mesh_processing {
 template<typename TriangleMesh, typename FaceRange, typename NamedParameters = parameters::Default_named_parameters>
 void smooth_mesh(const FaceRange& faces,
                  TriangleMesh& tmesh,
-                 const NamedParameters& np = parameters::use_default_values())
+                 const NamedParameters& np = parameters::default_values())
 {
   typedef typename boost::graph_traits<TriangleMesh>::vertex_descriptor               vertex_descriptor;
   typedef typename boost::graph_traits<TriangleMesh>::halfedge_descriptor             halfedge_descriptor;
@@ -325,7 +325,7 @@ void smooth_mesh(const FaceRange& faces,
 
 ///\cond SKIP_IN_MANUAL
 template <typename TriangleMesh, typename CGAL_BGL_NP_TEMPLATE_PARAMETERS>
-void smooth_mesh(TriangleMesh& tmesh, const CGAL_BGL_NP_CLASS& np = parameters::use_default_values())
+void smooth_mesh(TriangleMesh& tmesh, const CGAL_BGL_NP_CLASS& np = parameters::default_values())
 {
   smooth_mesh(faces(tmesh), tmesh, np);
 }

Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/smooth_shape.h

@@ -99,7 +99,7 @@ template<typename TriangleMesh, typename FaceRange, typename NamedParameters = p
 void smooth_shape(const FaceRange& faces,
                   TriangleMesh& tmesh,
                   const double time,
-                  const NamedParameters& np = parameters::use_default_values())
+                  const NamedParameters& np = parameters::default_values())
 {
   if(std::begin(faces) == std::end(faces))
     return;
@@ -200,7 +200,7 @@ void smooth_shape(const FaceRange& faces,
 template <typename TriangleMesh, typename CGAL_BGL_NP_TEMPLATE_PARAMETERS>
 void smooth_shape(TriangleMesh& tmesh,
                   const double time,
-                  const CGAL_BGL_NP_CLASS& np = parameters::use_default_values())
+                  const CGAL_BGL_NP_CLASS& np = parameters::default_values())
 {
   smooth_shape(faces(tmesh), tmesh, time, np);
 }

Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/stitch_borders.h

@@ -1117,7 +1117,7 @@ std::size_t stitch_boundary_cycle(const typename boost::graph_traits<PolygonMesh
 template <typename PolygonMesh, typename CGAL_BGL_NP_TEMPLATE_PARAMETERS>
 std::size_t stitch_boundary_cycle(const typename boost::graph_traits<PolygonMesh>::halfedge_descriptor h,
                                   PolygonMesh& pmesh,
-                                  const CGAL_BGL_NP_CLASS& np = parameters::use_default_values())
+                                  const CGAL_BGL_NP_CLASS& np = parameters::default_values())
 {
   internal::Dummy_cycle_rep_maintainer<PolygonMesh> dummy_maintainer(pmesh);
   return internal::stitch_boundary_cycle(h, pmesh, dummy_maintainer, np);
@@ -1178,7 +1178,7 @@ std::size_t stitch_boundary_cycles(const BorderHalfedgeRange& boundary_cycle_rep
 template <typename BorderHalfedgeRange, typename PolygonMesh, typename CGAL_BGL_NP_TEMPLATE_PARAMETERS>
 std::size_t stitch_boundary_cycles(const BorderHalfedgeRange& boundary_cycle_representatives,
                                    PolygonMesh& pmesh,
-                                   const CGAL_BGL_NP_CLASS& np = parameters::use_default_values())
+                                   const CGAL_BGL_NP_CLASS& np = parameters::default_values())
 {
   // If this API is called, we are not from stitch_borders() (otherwise there would be a maintainer)
   // so there is only one pass and we don't carea bout maintaining the cycle subset
@@ -1191,7 +1191,7 @@ std::size_t stitch_boundary_cycles(const BorderHalfedgeRange& boundary_cycle_rep
 // convenience overloads
 template <typename PolygonMesh, typename CGAL_BGL_NP_TEMPLATE_PARAMETERS>
 std::size_t stitch_boundary_cycles(PolygonMesh& pmesh,
-                                   const CGAL_BGL_NP_CLASS& np = parameters::use_default_values())
+                                   const CGAL_BGL_NP_CLASS& np = parameters::default_values())
 {
   typedef typename boost::graph_traits<PolygonMesh>::halfedge_descriptor           halfedge_descriptor;
 
@@ -1245,7 +1245,7 @@ template <typename PolygonMesh,
           typename CGAL_BGL_NP_TEMPLATE_PARAMETERS>
 std::size_t stitch_borders(PolygonMesh& pmesh,
                            const HalfedgePairsRange& hedge_pairs_to_stitch,
-                           const CGAL_BGL_NP_CLASS& np = parameters::use_default_values(),
+                           const CGAL_BGL_NP_CLASS& np = parameters::default_values(),
                            typename boost::enable_if<
                              typename boost::has_range_iterator<HalfedgePairsRange>
                            >::type* = 0)
@@ -1376,7 +1376,7 @@ std::size_t stitch_borders(const BorderHalfedgeRange& boundary_cycle_representat
 ///
 template <typename PolygonMesh, typename CGAL_BGL_NP_TEMPLATE_PARAMETERS>
 std::size_t stitch_borders(PolygonMesh& pmesh,
-                           const CGAL_BGL_NP_CLASS& np = parameters::use_default_values())
+                           const CGAL_BGL_NP_CLASS& np = parameters::default_values())
 {
   typedef typename boost::graph_traits<PolygonMesh>::halfedge_descriptor           halfedge_descriptor;
 
@@ -1438,7 +1438,7 @@ std::size_t stitch_borders(PolygonMesh& pmesh,
 template <typename BorderHalfedgeRange, typename PolygonMesh, typename CGAL_BGL_NP_TEMPLATE_PARAMETERS>
 std::size_t stitch_borders(const BorderHalfedgeRange& boundary_cycle_representatives,
                            PolygonMesh& pmesh,
-                           const CGAL_BGL_NP_CLASS& np = parameters::use_default_values()
+                           const CGAL_BGL_NP_CLASS& np = parameters::default_values()
 #ifndef DOXYGEN_RUNNING
                            , typename boost::enable_if<
                                typename boost::has_range_iterator<BorderHalfedgeRange>

Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/transform.h

@@ -47,7 +47,7 @@ namespace Polygon_mesh_processing{
 template<class Transformation, class PolygonMesh,class NamedParameters = parameters::Default_named_parameters>
 void transform(const Transformation& transformation,
                PolygonMesh& mesh,
-               const NamedParameters& np = parameters::use_default_values())
+               const NamedParameters& np = parameters::default_values())
 {
   typedef typename GetVertexPointMap<PolygonMesh, NamedParameters>::type VPMap;
   VPMap vpm = parameters::choose_parameter(parameters::get_parameter(np, internal_np::vertex_point),

Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/triangulate_faces.h

@@ -465,7 +465,7 @@ public:
 template<typename PolygonMesh, typename NamedParameters = parameters::Default_named_parameters>
 bool triangulate_face(typename boost::graph_traits<PolygonMesh>::face_descriptor f,
                       PolygonMesh& pmesh,
-                      const NamedParameters& np = parameters::use_default_values())
+                      const NamedParameters& np = parameters::default_values())
 {
   using parameters::choose_parameter;
   using parameters::get_parameter;
@@ -542,7 +542,7 @@ bool triangulate_face(typename boost::graph_traits<PolygonMesh>::face_descriptor
 template <typename FaceRange, typename PolygonMesh, typename NamedParameters = parameters::Default_named_parameters>
 bool triangulate_faces(FaceRange face_range,
                        PolygonMesh& pmesh,
-                       const NamedParameters& np = parameters::use_default_values())
+                       const NamedParameters& np = parameters::default_values())
 {
   using parameters::choose_parameter;
   using parameters::get_parameter;
@@ -613,7 +613,7 @@ bool triangulate_faces(FaceRange face_range,
 */
 template <typename PolygonMesh, typename NamedParameters = parameters::Default_named_parameters>
 bool triangulate_faces(PolygonMesh& pmesh,
-                       const NamedParameters& np = parameters::use_default_values())
+                       const NamedParameters& np = parameters::default_values())
 {
   return triangulate_faces(faces(pmesh), pmesh, np);
 }

Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/triangulate_hole.h

@@ -120,7 +120,7 @@ namespace Polygon_mesh_processing {
   triangulate_hole(PolygonMesh& pmesh,
               typename boost::graph_traits<PolygonMesh>::halfedge_descriptor border_halfedge,
               OutputIterator out,
-              const NamedParameters& np = parameters::use_default_values())
+              const NamedParameters& np = parameters::default_values())
   {
     using parameters::choose_parameter;
     using parameters::get_parameter;
@@ -279,7 +279,7 @@ namespace Polygon_mesh_processing {
       typename boost::graph_traits<PolygonMesh>::halfedge_descriptor border_halfedge,
       FaceOutputIterator face_out,
       VertexOutputIterator vertex_out,
-      const NamedParameters& np = parameters::use_default_values())
+      const NamedParameters& np = parameters::default_values())
   {
     std::vector<typename boost::graph_traits<PolygonMesh>::face_descriptor> patch;
     triangulate_hole(pmesh, border_halfedge, std::back_inserter(patch), np);
@@ -399,7 +399,7 @@ namespace Polygon_mesh_processing {
     typename boost::graph_traits<PolygonMesh>::halfedge_descriptor border_halfedge,
     FaceOutputIterator face_out,
     VertexOutputIterator vertex_out,
-    const NamedParameters& np = parameters::use_default_values())
+    const NamedParameters& np = parameters::default_values())
   {
     std::vector<typename boost::graph_traits<PolygonMesh>::vertex_descriptor> patch;
 
@@ -498,7 +498,7 @@ namespace Polygon_mesh_processing {
   triangulate_hole_polyline(const PointRange1& points,
                             const PointRange2& third_points,
                             OutputIterator out,
-                            const NamedParameters& np = parameters::use_default_values())
+                            const NamedParameters& np = parameters::default_values())
   {
     if (points.empty()) return out;
 
@@ -583,7 +583,7 @@ bool use_dt3 =
   OutputIterator
   triangulate_hole_polyline(const PointRange& points,
                             OutputIterator out,
-                            const CGAL_BGL_NP_CLASS& np = parameters::use_default_values())
+                            const CGAL_BGL_NP_CLASS& np = parameters::default_values())
   {
     typedef typename std::iterator_traits<
       typename PointRange::iterator>::value_type Point;

Polygon_mesh_processing/include/CGAL/Polyhedral_envelope.h

@@ -362,7 +362,7 @@ public:
   template <typename TriangleMesh, typename NamedParameters = parameters::Default_named_parameters>
   Polyhedral_envelope(const TriangleMesh& tmesh,
                       double epsilon,
-                      const NamedParameters& np = parameters::use_default_values())
+                      const NamedParameters& np = parameters::default_values())
   {
     using parameters::choose_parameter;
     using parameters::get_parameter;
@@ -463,7 +463,7 @@ public:
   Polyhedral_envelope(const FaceRange& face_range,
                       const TriangleMesh& tmesh,
                       double epsilon,
-                      const NamedParameters& np = parameters::use_default_values()
+                      const NamedParameters& np = parameters::default_values()
 #ifndef DOXYGEN_RUNNING
                       , typename std::enable_if<!boost::has_range_const_iterator<TriangleMesh>::value>::type* = 0
 #endif
@@ -567,7 +567,7 @@ public:
   Polyhedral_envelope(const PointRange& points,
                       const TriangleRange& triangles,
                       double epsilon,
-                      const NamedParameters& np = parameters::use_default_values()
+                      const NamedParameters& np = parameters::default_values()
 #ifndef DOXYGEN_RUNNING
                       , typename std::enable_if<boost::has_range_const_iterator<TriangleRange>::value>::type* = 0
 #endif
@@ -2223,7 +2223,7 @@ public:
   template <typename TriangleMesh, typename CGAL_BGL_NP_TEMPLATE_PARAMETERS>
   bool
   operator()(const TriangleMesh& tmesh,
-             const CGAL_BGL_NP_CLASS& np = parameters::use_default_values()
+             const CGAL_BGL_NP_CLASS& np = parameters::default_values()
 #ifndef DOXYGEN_RUNNING
              , typename std::enable_if<!boost::has_range_const_iterator<TriangleMesh>::value>::type* = 0
 #endif
@@ -2278,7 +2278,7 @@ public:
   template <typename PointRange, typename TriangleRange, typename NamedParameters = parameters::Default_named_parameters>
   bool operator()(const PointRange& points,
                   const TriangleRange& triangles,
-                  const NamedParameters& np = parameters::use_default_values()) const
+                  const NamedParameters& np = parameters::default_values()) const
   {
     using parameters::choose_parameter;
     using parameters::get_parameter;