keep only the static version of is_default_parameter

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

@@ -76,10 +76,10 @@ public:
     using parameters::is_default_parameter;
     using parameters::get_parameter;
 
-    const bool is_vnm_requested = !(is_default_parameter(get_parameter(np, internal_np::vertex_normal_map)));
+    const bool is_vnm_requested = !(is_default_parameter<NamedParameters, internal_np::vertex_normal_map_t>());
-    const bool is_vcm_requested = !(is_default_parameter(get_parameter(np, internal_np::vertex_color_map)));
+    const bool is_vcm_requested = !(is_default_parameter<NamedParameters, internal_np::vertex_color_map_t>());
-    const bool is_vtm_requested = !(is_default_parameter(get_parameter(np, internal_np::vertex_texture_map)));
+    const bool is_vtm_requested = !(is_default_parameter<NamedParameters, internal_np::vertex_texture_map_t>());
-    const bool is_fcm_requested = !(is_default_parameter(get_parameter(np, internal_np::face_color_map)));
+    const bool is_fcm_requested = !(is_default_parameter<NamedParameters, internal_np::face_color_map_t>());
 
     std::vector<Vertex_normal> vertex_normals;
     std::vector<Vertex_color> vertex_colors;

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

@@ -122,10 +122,10 @@ public:
     VPM vpm = choose_parameter(get_parameter(np, internal_np::vertex_point),
                                get_const_property_map(CGAL::vertex_point, g));
 
-    const bool has_vertex_normals = !(is_default_parameter(get_parameter(np, internal_np::vertex_normal_map)));
+    const bool has_vertex_normals = !(is_default_parameter<NamedParameters, internal_np::vertex_normal_map_t>());
-    const bool has_vertex_colors = !(is_default_parameter(get_parameter(np, internal_np::vertex_color_map)));
+    const bool has_vertex_colors = !(is_default_parameter<NamedParameters, internal_np::vertex_color_map_t>());
-    const bool has_vertex_textures = !(is_default_parameter(get_parameter(np, internal_np::vertex_texture_map)));
+    const bool has_vertex_textures = !(is_default_parameter<NamedParameters, internal_np::vertex_texture_map_t>());
-    const bool has_face_colors = !(is_default_parameter(get_parameter(np, internal_np::face_color_map)));
+    const bool has_face_colors = !(is_default_parameter<NamedParameters, internal_np::face_color_map_t>());
 
     VNM vnm = get_parameter(np, internal_np::vertex_normal_map);
     VTM vtm = get_parameter(np, internal_np::vertex_texture_map);

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

@@ -326,8 +326,8 @@ bool write_PLY(std::ostream& os,
   VCM vcm = choose_parameter(get_parameter(np, internal_np::vertex_color_map), VCM());
   FCM fcm = choose_parameter(get_parameter(np, internal_np::face_color_map), FCM());
 
-  bool has_vcolor = !is_default_parameter(get_parameter(np, internal_np::vertex_color_map));
+  bool has_vcolor = !is_default_parameter<CGAL_BGL_NP_CLASS, internal_np::vertex_color_map_t>();
-  bool has_fcolor = !is_default_parameter(get_parameter(np, internal_np::face_color_map));
+  bool has_fcolor = !is_default_parameter<CGAL_BGL_NP_CLASS, internal_np::face_color_map_t>();
   VIMap vim = CGAL::get_initialized_vertex_index_map(g, np);
   Vpm vpm = choose_parameter(get_parameter(np, internal_np::vertex_point),
                              get_const_property_map(boost::vertex_point, g));

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

@@ -508,7 +508,7 @@ CGAL_DEF_GET_INITIALIZED_INDEX_MAP(face, typename boost::graph_traits<Graph>::fa
     using parameters::choose_parameter;
     using parameters::is_default_parameter;
 
-    if(!is_default_parameter(get_parameter(np, internal_np::stream_precision)))
+    if(!is_default_parameter<NP, internal_np::stream_precision_t>())
     {
       const int precision = choose_parameter<int>(get_parameter(np,
                               internal_np::stream_precision));

Point_set_processing_3/include/CGAL/IO/write_off_points.h

@@ -48,7 +48,7 @@ bool write_OFF_PSP(std::ostream& os,
   typedef typename NP_helper::Const_point_map PointMap;
   typedef typename NP_helper::Normal_map NormalMap;
 
-  const bool has_normals = !(is_default_parameter(get_parameter(np, internal_np::normal_map)));
+  const bool has_normals = !(is_default_parameter<CGAL_BGL_NP_CLASS, internal_np::normal_t>());
 
   PointMap point_map = NP_helper::get_const_point_map(points, np);
   NormalMap normal_map = NP_helper::get_normal_map(points, np);

Point_set_processing_3/include/CGAL/mst_orient_normals.h

@@ -665,7 +665,7 @@ mst_orient_normals(
     //   or vertex j is in the k-neighborhood of vertex i.
     Riemannian_graph riemannian_graph;
 
-    if (is_default_parameter(get_parameter(np, internal_np::point_is_constrained)))
+    if (is_default_parameter<NamedParameters, internal_np::point_is_constrained_t>())
       riemannian_graph = create_riemannian_graph(points,
                                                  point_map, normal_map, index_map,
                                                  Default_constrained_map<typename PointRange::iterator>

Point_set_processing_3/include/CGAL/structure_point_set.h

@@ -225,7 +225,7 @@ public:
   {
     using parameters::choose_parameter;
     using parameters::get_parameter;
-    using parameters::is_default_parameter_static;
+    using parameters::is_default_parameter;
 
     // basic geometric types
     typedef Point_set_processing_3_np_helper<PointRange, NamedParameters> NP_helper;
@@ -235,7 +235,7 @@ public:
     typedef typename Point_set_processing_3::GetPlaneIndexMap<NamedParameters>::type PlaneIndexMap;
 
     CGAL_static_assertion_msg(NP_helper::has_normal_map(), "Error: no normal map");
-    CGAL_static_assertion_msg((!is_default_parameter_static<NamedParameters, internal_np::plane_index_t>()),
+    CGAL_static_assertion_msg((!is_default_parameter<NamedParameters, internal_np::plane_index_t>()),
                               "Error: no plane index map");
 
     PointMap point_map = NP_helper::get_const_point_map(points, np);

Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/compute_normal.h

@@ -672,7 +672,7 @@ compute_vertex_normal(typename boost::graph_traits<PolygonMesh>::vertex_descript
   Face_vector_map default_fvmap;
   Face_normal_map face_normals = choose_parameter(get_parameter(np, internal_np::face_normal),
                                                   Default_map(default_fvmap));
-  const bool must_compute_face_normals = is_default_parameter(get_parameter(np, internal_np::face_normal));
+  const bool must_compute_face_normals = is_default_parameter<NamedParameters, internal_np::face_normal_t>();
 
 #ifdef CGAL_PMP_COMPUTE_NORMAL_DEBUG_PP
   std::cout << "<----- compute vertex normal at " << get(vpmap, v)
@@ -786,7 +786,7 @@ void compute_vertex_normals(const PolygonMesh& pmesh,
                                                        Face_normal_dmap>::type   Face_normal_map;
   Face_normal_map face_normals = choose_parameter(get_parameter(np, internal_np::face_normal),
                                                   get(Face_normal_tag(), pmesh));
-  const bool must_compute_face_normals = is_default_parameter(get_parameter(np, internal_np::face_normal));
+  const bool must_compute_face_normals = is_default_parameter<NamedParameters, internal_np::face_normal_t>();
 
   if(must_compute_face_normals)
     compute_face_normals(pmesh, face_normals, np);

Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/connected_components.h

@@ -600,12 +600,12 @@ std::size_t keep_large_connected_components(PolygonMesh& pmesh,
 template <typename PolygonMesh
         , typename ComponentRange
         , typename FaceComponentMap
-        , typename NamedParameters = parameters::Default_named_parameters>
+        , typename CGAL_BGL_NP_TEMPLATE_PARAMETERS>
 void keep_or_remove_connected_components(PolygonMesh& pmesh
                                         , const ComponentRange& components_to_keep
                                         , const FaceComponentMap& fcm
                                         , bool  keep
-                                        , const NamedParameters& np = parameters::default_values())
+                                        , const CGAL_BGL_NP_CLASS& np = parameters::default_values())
 {
   using parameters::choose_parameter;
   using parameters::get_parameter;
@@ -616,7 +616,7 @@ void keep_or_remove_connected_components(PolygonMesh& pmesh
   typedef typename boost::graph_traits<PolygonMesh>::halfedge_descriptor halfedge_descriptor;
   typedef typename boost::graph_traits<PolygonMesh>::edge_descriptor   edge_descriptor;
 
-  typedef typename GetInitializedVertexIndexMap<PolygonMesh, NamedParameters>::type VertexIndexMap;
+  typedef typename GetInitializedVertexIndexMap<PolygonMesh, CGAL_BGL_NP_CLASS>::type VertexIndexMap;
   VertexIndexMap vim = get_initialized_vertex_index_map(pmesh, np);
 
   std::set<std::size_t> cc_to_keep;
@@ -720,13 +720,13 @@ void keep_or_remove_connected_components(PolygonMesh& pmesh
   for(vertex_descriptor v: vertices(pmesh))
     if (!keep_vertex[v])
       vertices_to_remove.push_back(v);
-  if ( is_default_parameter(get_parameter(np, internal_np::vertex_is_constrained)) )
+  if ( is_default_parameter<CGAL_BGL_NP_CLASS, internal_np::vertex_is_constrained_t>() )
     for (vertex_descriptor v : vertices_to_remove)
       remove_vertex(v, pmesh);
   else
   {
    typedef typename internal_np::Lookup_named_param_def<internal_np::vertex_is_constrained_t,
-                                                        NamedParameters,
+                                                        CGAL_BGL_NP_CLASS,
                                                         Static_boolean_property_map<vertex_descriptor, false> // default (not used)
                                                          >::type Vertex_map;
     Vertex_map is_cst = choose_parameter(get_parameter(np, internal_np::vertex_is_constrained),
@@ -995,7 +995,7 @@ void split_connected_components_impl(FIMap fim,
                                 get(CGAL::dynamic_face_property_t<faces_size_type>(), tm));
 
   faces_size_type nb_patches = 0;
-  if(is_default_parameter(get_parameter(np, internal_np::face_patch)))
+  if(is_default_parameter<NamedParameters, internal_np::face_patch_t>())
   {
     nb_patches = CGAL::Polygon_mesh_processing::connected_components(
           tm, pidmap, CGAL::parameters::face_index_map(fim)

Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/distance.h

@@ -220,7 +220,7 @@ struct Triangle_structure_sampler_base
     bool use_ms = choose_parameter(get_parameter(np, internal_np::monte_carlo_sampling), false);
 
     if(use_gs || use_ms)
-      if(is_default_parameter(get_parameter(np, internal_np::random_uniform_sampling)))
+      if(is_default_parameter<NamedParameters, internal_np::random_uniform_sampling_t>())
         use_rs = false;
 
     bool smpl_vrtcs = choose_parameter(get_parameter(np, internal_np::do_sample_vertices), true);

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

@@ -1094,7 +1094,6 @@ std::size_t snap_non_conformal(HalfedgeRange& halfedge_range_A,
   >::reference                                                                    Visitor;
 
   using CGAL::parameters::choose_parameter;
-  using CGAL::parameters::is_default_parameter;
   using CGAL::parameters::get_parameter;
   using CGAL::parameters::get_parameter_reference;
 

Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/remesh.h

@@ -217,7 +217,7 @@ void isotropic_remeshing(const FaceRange& faces
 #endif
 
   static const bool need_aabb_tree =
-    parameters::is_default_parameter(get_parameter(np, internal_np::projection_functor));
+    parameters::is_default_parameter<NamedParameters, internal_np::projection_functor_t>();
 
   typedef typename GetGeomTraits<PM, NamedParameters>::type GT;
   GT gt = choose_parameter<GT>(get_parameter(np, internal_np::geom_traits));
@@ -254,7 +254,7 @@ void isotropic_remeshing(const FaceRange& faces
   FPMap fpmap = choose_parameter(
     get_parameter(np, internal_np::face_patch),
     internal::Connected_components_pmap<PM, FIMap>(faces, pmesh, ecmap, fimap,
-      parameters::is_default_parameter(get_parameter(np, internal_np::face_patch)) && (need_aabb_tree
+      parameters::is_default_parameter<NamedParameters, internal_np::face_patch_t>() && (need_aabb_tree
 #if !defined(CGAL_NO_PRECONDITIONS)
       || protect // face patch map is used to identify patch border edges to check protected edges are short enough
 #endif

Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/repair.h

@@ -175,8 +175,8 @@ std::size_t remove_connected_components_of_negligible_size(TriangleMesh& tmesh,
   FT volume_threshold = choose_parameter(get_parameter(np, internal_np::volume_threshold), FT(-1));
 
   // If no threshold is provided, compute it as a % of the bbox
-  const bool is_default_area_threshold = is_default_parameter(get_parameter(np, internal_np::area_threshold));
+  const bool is_default_area_threshold = is_default_parameter<NamedParameters, internal_np::area_threshold_t>();
-  const bool is_default_volume_threshold = is_default_parameter(get_parameter(np, internal_np::volume_threshold));
+  const bool is_default_volume_threshold = is_default_parameter<NamedParameters, internal_np::volume_threshold_t>();
 
   const bool dry_run = choose_parameter(get_parameter(np, internal_np::dry_run), false);
 

Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/self_intersections.h

@@ -249,7 +249,7 @@ self_intersections_impl(const FaceRange& face_range,
   VPM vpmap = choose_parameter(get_parameter(np, internal_np::vertex_point),
                                get_const_property_map(boost::vertex_point, tmesh));
 
-  const bool do_limit = !(is_default_parameter(get_parameter(np, internal_np::maximum_number)));
+  const bool do_limit = !(is_default_parameter<NamedParameters, internal_np::maximum_number_t>());
   const unsigned int maximum_number = choose_parameter(get_parameter(np, internal_np::maximum_number), 0);
   if(do_limit && maximum_number == 0)
   {

Polygon_mesh_processing/include/CGAL/Polyhedral_envelope.h

@@ -402,7 +402,7 @@ public:
       else
         deg_faces.insert(f);
     }
-    if (is_default_parameter(get_parameter(np, internal_np::face_epsilon_map)))
+    if (is_default_parameter<NamedParameters, internal_np::face_epsilon_map_t>())
       init(epsilon);
     else
     {
@@ -511,7 +511,7 @@ public:
         deg_faces.insert(f);
     }
 
-    if (is_default_parameter(get_parameter(np, internal_np::face_epsilon_map)))
+    if (is_default_parameter<NamedParameters, internal_np::face_epsilon_map_t>())
       init(epsilon);
     else
     {
@@ -594,7 +594,7 @@ public:
       env_faces.emplace_back(face);
     }
 
-    if (is_default_parameter(get_parameter(np, internal_np::face_epsilon_map)))
+    if (is_default_parameter<NamedParameters, internal_np::face_epsilon_map_t>())
       init(epsilon);
     else
     {

Polygon_mesh_processing/test/Polygon_mesh_processing/test_pmp_np_function.cpp

@@ -44,6 +44,9 @@ void my_function_with_named_parameters(PolygonMesh& mesh, const NamedParameters&
   //boolean NP example. Default value is `false`
   bool do_project = choose_parameter(get_parameter(np, internal_np::do_project), false);
 
+  // check is a parameter has been given by the user
+  constexpr bool do_project_is_default = is_default_parameter<NamedParameters, internal_np::do_project_t>();
+
   VCM vcm_np = choose_parameter(get_parameter(np, internal_np::vertex_is_constrained), Default_VCM());
 
 
@@ -53,10 +56,16 @@ void my_function_with_named_parameters(PolygonMesh& mesh, const NamedParameters&
     std::cout<<"vertex #"<<get(vim, v)<<" : "<<get(vpm, v)<<" : "<<get(vcm_np, v)<<std::endl;
   }
 
-  if(do_project)
+  if (!do_project_is_default)
-    std::cout<<"do project"<<std::endl;
+  {
-  else
+    if(do_project)
-      std::cout<<"don't project"<<std::endl;
+      std::cout<<"do project"<<std::endl;
+    else
+        std::cout<<"don't project"<<std::endl;
+  }
+    else
+        std::cout<<"use default for project"<<std::endl;
+
 }
 
 }

Polyhedron/include/CGAL/IO/Polyhedron_OFF_iostream.h

@@ -66,17 +66,17 @@ bool read_OFF(std::istream& in,
 
   const bool verbose = choose_parameter(get_parameter(np, internal_np::verbose), true);
 
-  if(!(is_default_parameter(get_parameter(np, internal_np::vertex_color_map))) ||
+  if(!(is_default_parameter<CGAL_BGL_NP_CLASS, internal_np::vertex_color_map_t>()) ||
-     !(is_default_parameter(get_parameter(np, internal_np::face_color_map))) ||
+     !(is_default_parameter<CGAL_BGL_NP_CLASS, internal_np::face_color_map_t>()) ||
-     !(is_default_parameter(get_parameter(np, internal_np::vertex_normal_map))) ||
+     !(is_default_parameter<CGAL_BGL_NP_CLASS, internal_np::vertex_normal_map_t>()) ||
-     !(is_default_parameter(get_parameter(np, internal_np::vertex_texture_map))))
+     !(is_default_parameter<CGAL_BGL_NP_CLASS, internal_np::vertex_texture_map_t>()))
   {
     return CGAL::IO::internal::read_OFF_BGL(in, P, np);
   }
 
   CGAL::scan_OFF(in, P, verbose);
 
-  if(!parameters::is_default_parameter(get_parameter(np, internal_np::vertex_point)))
+  if(!parameters::is_default_parameter<CGAL_BGL_NP_CLASS, internal_np::vertex_point_t>())
   {
     Def_VPM def_vpm = get_property_map(CGAL::vertex_point, P);
     VPM vpm = choose_parameter(get_parameter(np, internal_np::vertex_point),
@@ -132,10 +132,10 @@ bool write_OFF(std::ostream& out,
   using parameters::get_parameter;
   using parameters::is_default_parameter;
 
-  if(!(is_default_parameter(get_parameter(np, internal_np::vertex_color_map))) ||
+  if(!(is_default_parameter<CGAL_BGL_NP_CLASS, internal_np::vertex_color_map_t>()) ||
-     !(is_default_parameter(get_parameter(np, internal_np::face_color_map))) ||
+     !(is_default_parameter<CGAL_BGL_NP_CLASS, internal_np::face_color_map_t>()) ||
-     !(is_default_parameter(get_parameter(np, internal_np::vertex_normal_map))) ||
+     !(is_default_parameter<CGAL_BGL_NP_CLASS, internal_np::vertex_normal_map_t>()) ||
-     !(is_default_parameter(get_parameter(np, internal_np::vertex_texture_map))))
+     !(is_default_parameter<CGAL_BGL_NP_CLASS, internal_np::vertex_texture_map_t>()))
   {
     return CGAL::IO::internal::write_OFF_BGL(out, P, np);
   }

STL_Extension/include/CGAL/Named_function_parameters.h

@@ -356,19 +356,8 @@ const T& choose_parameter(const T& t)
   return t;
 }
 
-bool inline is_default_parameter(const internal_np::Param_not_found&)
-{
-  return true;
-}
-
-template <class T>
-bool is_default_parameter(const T&)
-{
-  return false;
-}
-
 template <class NP, class TAG>
-constexpr bool is_default_parameter_static()
+constexpr bool is_default_parameter()
 {
   return std::is_same< typename internal_np::Get_param<typename NP::base, TAG>::type,
                        internal_np::Param_not_found> ::value;

Shape_regularization/include/CGAL/Shape_regularization/regularize_planes.h

@@ -292,11 +292,11 @@ namespace Planes {
 
     using parameters::get_parameter;
     using parameters::choose_parameter;
-    using parameters::is_default_parameter_static;
+    using parameters::is_default_parameter;
     using PlaneIndexMap = typename CGAL::Point_set_processing_3::
       GetPlaneIndexMap<NamedParameters>::type;
 
-    CGAL_static_assertion_msg((!is_default_parameter_static<NamedParameters, internal_np::plane_index_t>()),
+    CGAL_static_assertion_msg((!is_default_parameter<NamedParameters, internal_np::plane_index_t>()),
                               "Error: no plane index map");
 
     const PlaneIndexMap index_map =

Surface_mesh/include/CGAL/Surface_mesh/IO/OFF.h

@@ -110,7 +110,7 @@ bool read_OFF_with_or_without_fcolors(std::istream& is,
 
   typename Mesh::template Property_map<Face_index, Color> fcm;
 
-  bool is_fcm_requested = !(is_default_parameter(get_parameter(np, internal_np::face_color_map)));
+  bool is_fcm_requested = !(is_default_parameter<CGAL_BGL_NP_CLASS, internal_np::face_color_map_t>());
   if(!is_fcm_requested && scanner.has_colors())
   {
     bool created;
@@ -149,7 +149,7 @@ bool read_OFF_with_or_without_vtextures(std::istream& is,
 
   typename Mesh::template Property_map<Vertex_index, Texture> vtm;
 
-  bool is_vtm_requested = !(is_default_parameter(get_parameter(np, internal_np::vertex_texture_map)));
+  bool is_vtm_requested = !(is_default_parameter<CGAL_BGL_NP_CLASS, internal_np::vertex_texture_map_t>());
   if(!is_vtm_requested && scanner.has_textures())
   {
     bool created;
@@ -187,7 +187,7 @@ bool read_OFF_with_or_without_vcolors(std::istream& is,
 
   typename Mesh::template Property_map<Vertex_index, Color> vcm;
 
-  bool is_vcm_requested = !(is_default_parameter(get_parameter(np, internal_np::vertex_color_map)));
+  bool is_vcm_requested = !(is_default_parameter<CGAL_BGL_NP_CLASS,  internal_np::vertex_color_map_t>());
   if(!is_vcm_requested && scanner.has_colors())
   {
     bool created;
@@ -226,7 +226,7 @@ bool read_OFF_with_or_without_vnormals(std::istream& is,
 
   typename Mesh::template Property_map<Vertex_index, Normal> vnm;
 
-  bool is_vnm_requested = !(is_default_parameter(get_parameter(np, internal_np::vertex_normal_map)));
+  bool is_vnm_requested = !(is_default_parameter<CGAL_BGL_NP_CLASS, internal_np::vertex_normal_map_t>());
   if(!is_vnm_requested && scanner.has_normals())
   {
     bool created;
@@ -394,7 +394,7 @@ bool write_OFF_with_or_without_fcolors(std::ostream& os,
   using parameters::is_default_parameter;
   using parameters::get_parameter;
 
-  const bool has_fcolors = !(is_default_parameter(get_parameter(np, internal_np::face_color_map)));
+  const bool has_fcolors = !(is_default_parameter<CGAL_BGL_NP_CLASS, internal_np::face_color_map_t>());
 
   typename Mesh::template Property_map<Face_index, Color> fcolors;
   bool has_internal_fcolors;
@@ -421,7 +421,7 @@ bool write_OFF_with_or_without_vtextures(std::ostream& os,
   using parameters::is_default_parameter;
   using parameters::get_parameter;
 
-  const bool has_vtextures = !(is_default_parameter(get_parameter(np, internal_np::vertex_texture_map)));
+  const bool has_vtextures = !(is_default_parameter<CGAL_BGL_NP_CLASS, internal_np::vertex_texture_map_t>());
 
   typename Mesh::template Property_map<Vertex_index, Texture> vtextures;
   bool has_internal_vtextures;
@@ -446,7 +446,7 @@ bool write_OFF_with_or_without_vcolors(std::ostream& os,
   using parameters::is_default_parameter;
   using parameters::get_parameter;
 
-  const bool has_vcolors = !(is_default_parameter(get_parameter(np, internal_np::vertex_color_map)));
+  const bool has_vcolors = !(is_default_parameter<CGAL_BGL_NP_CLASS, internal_np::vertex_color_map_t>());
 
   typename Mesh::template Property_map<Vertex_index, Color> vcolors;
   bool has_internal_vcolors;
@@ -473,7 +473,7 @@ bool write_OFF_with_or_without_vnormals(std::ostream& os,
   using parameters::is_default_parameter;
   using parameters::get_parameter;
 
-  const bool has_vnormals = !(is_default_parameter(get_parameter(np, internal_np::vertex_normal_map)));
+  const bool has_vnormals = !(is_default_parameter<CGAL_BGL_NP_CLASS, internal_np::vertex_normal_map_t>());
 
   typename Mesh::template Property_map<Vertex_index, Normal> vnormals;
   bool has_internal_vnormals;
@@ -563,7 +563,7 @@ bool write_OFF(std::ostream& os,
   using parameters::is_default_parameter;
   using parameters::get_parameter;
 
-  const bool has_vpoints = !(is_default_parameter(get_parameter(np, internal_np::vertex_point)));
+  const bool has_vpoints = !(is_default_parameter<CGAL_BGL_NP_CLASS, internal_np::vertex_point_t>());
   if(has_vpoints)
     return internal::write_OFF_with_or_without_vnormals(os, sm, np);
 

Surface_mesh_approximation/include/CGAL/Surface_mesh_approximation/approximate_triangle_mesh.h

@@ -247,21 +247,21 @@ bool approximate_triangle_mesh(const TriangleMesh &tm, const NamedParameters &np
   // get proxy map
   approx.proxy_map( get_parameter(np, internal_np::face_proxy_map) );
 
-  if (!parameters::is_default_parameter(get_parameter(np, internal_np::face_proxy_map))
+  if (!parameters::is_default_parameter<NamedParameters, internal_np::face_proxy_map_t>()
     && (vl == MAIN_STEPS || vl == VERBOSE))
     std::cout << "Filling face proxy map done." << std::endl;
 
   // get proxies
   approx.proxies( get_parameter(np, internal_np::proxies) );
 
-  if (!is_default_parameter( get_parameter(np, internal_np::proxies) )
+  if (!is_default_parameter<NamedParameters,internal_np::proxies>()
     && (vl == MAIN_STEPS || vl == VERBOSE))
     std::cout << "Get proxies done." << std::endl;
 
   // meshing
   bool is_manifold = false;
-  if (!is_default_parameter( get_parameter(np, internal_np::anchors))
+  if (!is_default_parameter<NamedParameters, internal_np::anchors_t>()
-    || !is_default_parameter( get_parameter(np, internal_np::triangles) ))
+    || !is_default_parameter<NamedParameters,internal_np::triangles_t>())
   {
     if (vl == VERBOSE) {
       const FT subdivision_ratio = choose_parameter(get_parameter(np, internal_np::subdivision_ratio), FT(5.0));
@@ -287,14 +287,14 @@ bool approximate_triangle_mesh(const TriangleMesh &tm, const NamedParameters &np
   // get anchor points
   approx.anchor_points( get_parameter(np, internal_np::anchors) );
 
-  if (!is_default_parameter( get_parameter(np, internal_np::anchors) )
+  if (!is_default_parameter<NamedParameters,internal_np::anchors_t>()
     && (vl == MAIN_STEPS || vl == VERBOSE))
     std::cout << "Get anchors done." << std::endl;
 
   // get indexed triangles
   approx.indexed_triangles( get_parameter(np, internal_np::triangles) );
 
-  if (!is_default_parameter( get_parameter(np, internal_np::triangles) )
+  if (!is_default_parameter<NamedParameters,internal_np::triangles_t>()
     && (vl == MAIN_STEPS || vl == VERBOSE))
     std::cout << "Get indexed triangles done." << std::endl;