diff --git a/Mesh_3/include/CGAL/Labeled_mesh_domain_3.h b/Mesh_3/include/CGAL/Labeled_mesh_domain_3.h
index 85bb78ba7ea..95773cbb5db 100644
--- a/Mesh_3/include/CGAL/Labeled_mesh_domain_3.h
+++ b/Mesh_3/include/CGAL/Labeled_mesh_domain_3.h
@@ -437,12 +437,47 @@ public:
                        create_construct_surface_patch_index(construct_surface_patch_index_));
 
   }
+        template<typename CGAL_NP_TEMPLATE_PARAMETERS_NO_DEFAULT>
+        static Labeled_mesh_domain_3 create_gray_image_mesh_domain(const CGAL_NP_CLASS& np)
+        {
+            static_assert(!parameters::is_default_parameter<CGAL_NP_CLASS, internal_np::image_3_param_t>::value, "Value for required parameter not found");
+            using parameters::get_parameter;
+            using parameters::choose_parameter;
+            const CGAL::Image_3& image_ = get_parameter(np,internal_np::image_3_param);
+            auto iso_value_ = choose_parameter(get_parameter(np, internal_np::iso_value_param), 0);
+            auto value_outside_ = choose_parameter(get_parameter(np, internal_np::voxel_value), 0);
+            FT relative_error_bound_ = choose_parameter(get_parameter(np, internal_np::error_bound), FT(1e-3));
+            auto image_values_to_subdomain_indices_ = choose_parameter(get_parameter(np, internal_np::image_subdomain_index), Null_functor());
+            CGAL::Random* p_rng_ = choose_parameter(get_parameter(np, internal_np::rng), (CGAL::Random*)(0));
+            auto null_subdomain_index_ = choose_parameter(get_parameter(np, internal_np::null_subdomain_index_param), Null_functor());
+            auto construct_surface_patch_index_ = choose_parameter(get_parameter(np, internal_np::surface_patch_index), Null_functor());
+            namespace p = CGAL::parameters;
+            return Labeled_mesh_domain_3
+                    (create_gray_image_wrapper
+                             (image_,
+                              iso_value_,
+                              image_values_to_subdomain_indices_,
+                              value_outside_),
+                     Mesh_3::internal::compute_bounding_box(image_),
+                     p::relative_error_bound = relative_error_bound_,
+                     p::p_rng = p_rng_,
+                     p::null_subdomain_index =
+                             create_null_subdomain_index(null_subdomain_index_),
+                     p::construct_surface_patch_index =
+                             create_construct_surface_patch_index(construct_surface_patch_index_));
+
+        }
 #ifndef CGAL_NO_DEPRECATED_CODE
         template<typename... NP_Pack>
         static Labeled_mesh_domain_3 create_gray_image_mesh_domain(const CGAL::Image_3& image_, const NP_Pack& ...nps)
         {
             return create_gray_image_mesh_domain(image_, internal_np::combine_named_parameters(nps...));
         }
+        template<typename ... NP_PACK>
+        static Labeled_mesh_domain_3 create_gray_image_mesh_domain(const NP_PACK& ...nps)
+        {
+            return create_gray_image_mesh_domain(internal_np::combine_named_parameters(nps...));
+        }
 #endif //CGAL_NO_DEPRECATED_CODE
 
 
@@ -510,6 +545,55 @@ where the labeled image is used with a precomputed 3D image of weights :
             auto construct_surface_patch_index_ = choose_parameter(get_parameter(np, internal_np::surface_patch_index), Null_functor());
             CGAL::Image_3 weights_ = choose_parameter(get_parameter(np, internal_np::weights_param), CGAL::Image_3());
 
+            namespace p = CGAL::parameters;
+            if (weights_.is_valid())
+            {
+                return Labeled_mesh_domain_3
+                        (create_weighted_labeled_image_wrapper
+                                 (image_,
+                                  weights_,
+                                  image_values_to_subdomain_indices_,
+                                  value_outside_),
+                         Mesh_3::internal::compute_bounding_box(image_),
+                         p::relative_error_bound = relative_error_bound_,
+                         p::p_rng = p_rng_,
+                         p::null_subdomain_index =
+                                 create_null_subdomain_index(null_subdomain_index_),
+                         p::construct_surface_patch_index =
+                                 create_construct_surface_patch_index(construct_surface_patch_index_));
+            }
+            else
+            {
+                return Labeled_mesh_domain_3
+                        (create_labeled_image_wrapper
+                                 (image_,
+                                  image_values_to_subdomain_indices_,
+                                  value_outside_),
+                         Mesh_3::internal::compute_bounding_box(image_),
+                         p::relative_error_bound = relative_error_bound_,
+                         p::p_rng = p_rng_,
+                         p::null_subdomain_index =
+                                 create_null_subdomain_index(null_subdomain_index_),
+                         p::construct_surface_patch_index =
+                                 create_construct_surface_patch_index(construct_surface_patch_index_));
+            }
+        }
+        template<typename CGAL_NP_TEMPLATE_PARAMETERS_NO_DEFAULT>
+        static Labeled_mesh_domain_3 create_labeled_image_mesh_domain(const CGAL_NP_CLASS& np)
+        {
+            static_assert(!parameters::is_default_parameter<CGAL_NP_CLASS, internal_np::image_3_param_t>::value, "Value for required parameter not found");
+            using parameters::get_parameter;
+            using parameters::choose_parameter;
+            const CGAL::Image_3& image_ = get_parameter(np,internal_np::image_3_param);
+            auto iso_value_ = choose_parameter(get_parameter(np, internal_np::iso_value_param), FT(0));
+            auto value_outside_ = choose_parameter(get_parameter(np, internal_np::voxel_value), FT(0));
+            FT relative_error_bound_ = choose_parameter(get_parameter(np, internal_np::error_bound), FT(1e-3));
+            auto image_values_to_subdomain_indices_ = choose_parameter(get_parameter(np, internal_np::image_subdomain_index), Null_functor());
+            CGAL::Random* p_rng_ = choose_parameter(get_parameter(np, internal_np::rng), (CGAL::Random*)(0));
+            auto null_subdomain_index_ = choose_parameter(get_parameter(np, internal_np::null_subdomain_index_param), Null_functor());
+            auto construct_surface_patch_index_ = choose_parameter(get_parameter(np, internal_np::surface_patch_index), Null_functor());
+            CGAL::Image_3 weights_ = choose_parameter(get_parameter(np, internal_np::weights_param), CGAL::Image_3());
+
             namespace p = CGAL::parameters;
             if (weights_.is_valid())
             {
@@ -549,6 +633,11 @@ where the labeled image is used with a precomputed 3D image of weights :
         {
             return create_labeled_image_mesh_domain(image_, internal_np::combine_named_parameters(nps...));
         }
+        template<typename ... NP_PACK>
+        static Labeled_mesh_domain_3 create_labeled_image_mesh_domain(const NP_PACK& ...nps)
+        {
+            return create_labeled_image_mesh_domain(internal_np::combine_named_parameters(nps...));
+        }
 #endif //CGAL_NO_DEPRECATED_CODE
 
 
@@ -614,12 +703,42 @@ From the example (\ref Mesh_3/mesh_implicit_sphere_variable_size.cpp):
                        create_construct_surface_patch_index(construct_surface_patch_index_));
   }
 
+        template<typename CGAL_NP_TEMPLATE_PARAMETERS_NO_DEFAULT>
+        static Labeled_mesh_domain_3 create_implicit_mesh_domain(const CGAL_NP_CLASS& np)
+        {
+            static_assert(!parameters::is_default_parameter<CGAL_NP_CLASS, internal_np::function_param_t>::value, "Value for required parameter not found");
+            static_assert(!parameters::is_default_parameter<CGAL_NP_CLASS, internal_np::bounding_object_param_t>::value, "Value for required parameter not found");
+            using parameters::get_parameter;
+            using parameters::choose_parameter;
+            auto function_ = get_parameter(np, internal_np::function_param);
+            auto bounding_object_ = get_parameter(np, internal_np::bounding_object_param);
+            FT relative_error_bound_ = choose_parameter(get_parameter(np, internal_np::error_bound), FT(1e-3));
+            CGAL::Random* p_rng_ = choose_parameter(get_parameter(np, internal_np::rng), (CGAL::Random*)(0));
+            auto null_subdomain_index_ = choose_parameter(get_parameter(np, internal_np::null_subdomain_index_param), Null_functor());
+            auto construct_surface_patch_index_ = choose_parameter(get_parameter(np, internal_np::surface_patch_index), Null_functor());
+            namespace p = CGAL::parameters;
+            return Labeled_mesh_domain_3
+                    (make_implicit_to_labeling_function_wrapper<BGT>(function_),
+                     bounding_object_,
+                     p::relative_error_bound = relative_error_bound_,
+                     p::p_rng = p_rng_,
+                     p::null_subdomain_index =
+                             create_null_subdomain_index(null_subdomain_index_),
+                     p::construct_surface_patch_index =
+                             create_construct_surface_patch_index(construct_surface_patch_index_));
+        }
+
 #ifndef CGAL_NO_DEPRECATED_CODE
   template<typename Function, typename BoundingObject, typename... NP_Pack>
   static Labeled_mesh_domain_3 create_implicit_mesh_domain(Function function_, BoundingObject bounding_object_, const NP_Pack& ...nps)
   {
       return create_implicit_mesh_domain(function_, bounding_object_, internal_np::combine_named_parameters(nps...));
   }
+  template<typename ... NP_PACK>
+  static Labeled_mesh_domain_3 create_implicit_mesh_domain(const NP_PACK& ...nps)
+  {
+      return create_implicit_mesh_domain(internal_np::combine_named_parameters(nps...));
+  }
 #endif //CGAL_NO_DEPRECATED_CODE
 
   /// @}
diff --git a/Mesh_3/include/CGAL/Mesh_3/internal/parameters.h b/Mesh_3/include/CGAL/Mesh_3/internal/parameters.h
index 83790c0892a..48cddc5025e 100644
--- a/Mesh_3/include/CGAL/Mesh_3/internal/parameters.h
+++ b/Mesh_3/include/CGAL/Mesh_3/internal/parameters.h
@@ -1,3 +1,18 @@
+// Copyright (c) 2009 INRIA Sophia-Antipolis (France).
+// All rights reserved.
+//
+// This file is part of CGAL (www.cgal.org).
+//
+// $URL$
+// $Id$
+// SPDX-License-Identifier: GPL-3.0-or-later OR LicenseRef-Commercial
+//
+//
+//
+//
+//******************************************************************************
+// File Description : Named Function Parameters specific code
+//******************************************************************************
 #ifndef CGAL_PARAMETERS_H
 #define CGAL_PARAMETERS_H
 
diff --git a/Mesh_3/include/CGAL/exude_mesh_3.h b/Mesh_3/include/CGAL/exude_mesh_3.h
index 7b43940a626..42d79f327ba 100644
--- a/Mesh_3/include/CGAL/exude_mesh_3.h
+++ b/Mesh_3/include/CGAL/exude_mesh_3.h
@@ -108,6 +108,17 @@ Mesh_optimization_return_code exude_mesh_3(C3T3& c3t3,const CGAL_NP_CLASS& np =
 
 }
 
+template<typename CGAL_NP_TEMPLATE_PARAMETERS_NO_DEFAULT>
+Mesh_optimization_return_code exude_mesh_3(const CGAL_NP_CLASS& np)
+{
+    static_assert(!parameters::is_default_parameter<CGAL_NP_CLASS, internal_np::c3t3_param_t>::value, "Value for required parameter not found");
+    using parameters::choose_parameter;
+    using parameters::get_parameter;
+    int time_limit=choose_parameter(get_parameter(np,internal_np::maximum_running_time),0);
+    double sliver_bound= choose_parameter(get_parameter(np,internal_np::lower_sliver_bound),parameters::default_values_for_mesh_3::exude_sliver_bound);
+    auto c3t3 = get_parameter(np,internal_np::c3t3_param);
+    return exude_mesh_3_impl(c3t3,time_limit,sliver_bound);
+}
 #ifndef DOXYGEN_RUNNING
   #ifndef CGAL_NO_DEPRECATED_CODE
     template<typename C3T3, typename ... NP_PACK>
@@ -115,6 +126,14 @@ Mesh_optimization_return_code exude_mesh_3(C3T3& c3t3,const CGAL_NP_CLASS& np =
     {
         return exude_mesh_3(c3t3,internal_np::combine_named_parameters(nps...));
     }
+
+    template<typename ... NP_PACK>
+    Mesh_optimization_return_code exude_mesh_3(const NP_PACK& ...nps)
+    {
+        return exude_mesh_3(internal_np::combine_named_parameters(nps...));
+    }
+
+
   #endif //CGAL_NO_DEPRECATED_CODE
 
 
diff --git a/Mesh_3/include/CGAL/lloyd_optimize_mesh_3.h b/Mesh_3/include/CGAL/lloyd_optimize_mesh_3.h
index 1fd954b09de..10011b0599e 100644
--- a/Mesh_3/include/CGAL/lloyd_optimize_mesh_3.h
+++ b/Mesh_3/include/CGAL/lloyd_optimize_mesh_3.h
@@ -161,6 +161,24 @@ Mesh_optimization_return_code lloyd_optimize_mesh_3(C3T3& c3t3, MeshDomain& doma
     bool do_freeze = choose_parameter(get_parameter(np,internal_np::freeze),true);
     return lloyd_optimize_mesh_3_impl(c3t3, domain, time_limit, max_iterations, convergence_ratio, freeze_bound, do_freeze);
 }
+
+template<typename CGAL_NP_TEMPLATE_PARAMETERS_NO_DEFAULT>
+Mesh_optimization_return_code lloyd_optimize_mesh_3(const CGAL_NP_CLASS& np)
+{
+    static_assert(!parameters::is_default_parameter<CGAL_NP_CLASS, internal_np::c3t3_param_t>::value, "Value for required parameter not found");
+    static_assert(!parameters::is_default_parameter<CGAL_NP_CLASS, internal_np::mesh_domain_param_t>::value, "Value for required parameter not found");
+    using parameters::choose_parameter;
+    using parameters::get_parameter;
+    int max_iterations = choose_parameter(get_parameter(np, internal_np::number_of_iterations), 0);
+    const double convergence_ratio = choose_parameter(get_parameter(np, internal_np::convergence_ratio), 0.001);
+    const double freeze_bound = choose_parameter(get_parameter(np, internal_np::vertex_freeze_bound), 0.001);
+    const double time_limit = choose_parameter(get_parameter(np, internal_np::maximum_running_time), 0.);
+    bool do_freeze = choose_parameter(get_parameter(np,internal_np::freeze),true);
+    auto c3t3 = get_parameter(np,internal_np::c3t3_param);
+    auto domain = get_parameter(np,internal_np::mesh_domain_param);
+    return lloyd_optimize_mesh_3_impl(c3t3, domain, time_limit, max_iterations, convergence_ratio, freeze_bound, do_freeze);
+}
+
 #ifndef DOXYGEN_RUNNING
 #ifndef CGAL_NO_DEPRECATED_CODE
 template<typename C3T3, typename MeshDomain,typename ... NP_PACK>
@@ -168,6 +186,12 @@ Mesh_optimization_return_code lloyd_optimize_mesh_3(C3T3& c3t3,MeshDomain& domai
 {
     return lloyd_optimize_mesh_3(c3t3,domain, internal_np::combine_named_parameters(nps...));
 }
+
+template<typename ... NP_PACK>
+Mesh_optimization_return_code lloyd_optimize_mesh_3(const NP_PACK& ...nps)
+{
+    return lloyd_optimize_mesh_3(internal_np::combine_named_parameters(nps...));
+}
 #endif //CGAL_NO_DEPRECATED_CODE
 
 template <typename C3T3, typename MeshDomain>
diff --git a/Mesh_3/include/CGAL/make_mesh_3.h b/Mesh_3/include/CGAL/make_mesh_3.h
index e33f6022161..9a504bc6452 100644
--- a/Mesh_3/include/CGAL/make_mesh_3.h
+++ b/Mesh_3/include/CGAL/make_mesh_3.h
@@ -545,7 +545,6 @@ C3T3 make_mesh_3(MeshDomain& domain, MeshCriteria& criteria, const CGAL_NP_CLASS
     return c3t3;
 }
 
-
 #ifndef DOXYGEN_RUNNING
 #ifndef CGAL_NO_DEPRECATED_CODE
 template<typename C3T3, typename MeshDomain, typename MeshCriteria, typename ... NP_PACK>
@@ -554,6 +553,7 @@ C3T3 make_mesh_3(MeshDomain& domain, MeshCriteria& criteria, const NP_PACK&...np
     return make_mesh_3<C3T3>(domain, criteria, internal_np::combine_named_parameters(nps...));
 }
 
+
 #endif //CGAL_NO_DEPRECATED_CODE
 
 
diff --git a/Mesh_3/include/CGAL/odt_optimize_mesh_3.h b/Mesh_3/include/CGAL/odt_optimize_mesh_3.h
index 4b7ccde8bb1..249985e0162 100644
--- a/Mesh_3/include/CGAL/odt_optimize_mesh_3.h
+++ b/Mesh_3/include/CGAL/odt_optimize_mesh_3.h
@@ -151,6 +151,24 @@ Mesh_optimization_return_code odt_optimize_mesh_3(C3T3& c3t3, MeshDomain& domain
     bool do_freeze=choose_parameter(get_parameter(np,internal_np::freeze),true);
     return odt_optimize_mesh_3_impl(c3t3, domain, time_limit, max_iteration_number, convergence, freeze_bound, do_freeze);
 }
+
+    template<typename CGAL_NP_TEMPLATE_PARAMETERS_NO_DEFAULT>
+    Mesh_optimization_return_code odt_optimize_mesh_3(const CGAL_NP_CLASS& np)
+    {
+        static_assert(!parameters::is_default_parameter<CGAL_NP_CLASS, internal_np::c3t3_param_t>::value, "Value for required parameter not found");
+        static_assert(!parameters::is_default_parameter<CGAL_NP_CLASS, internal_np::mesh_domain_param_t>::value, "Value for required parameter not found");
+        using parameters::choose_parameter;
+        using parameters::get_parameter;
+        double time_limit=choose_parameter(get_parameter(np,internal_np::maximum_running_time),0);
+        std::size_t max_iteration_number=choose_parameter(get_parameter(np,internal_np::number_of_iterations),0);
+        double convergence=choose_parameter(get_parameter(np,internal_np::convergence_ratio),0.02);
+        double freeze_bound=choose_parameter(get_parameter(np,internal_np::vertex_freeze_bound),0.01);
+        bool do_freeze=choose_parameter(get_parameter(np,internal_np::freeze),true);
+        auto c3t3 = get_parameter(np,internal_np::c3t3_param);
+        auto domain = get_parameter(np,internal_np::mesh_domain_param);
+        return odt_optimize_mesh_3_impl(c3t3, domain, time_limit, max_iteration_number, convergence, freeze_bound, do_freeze);
+    }
+
 #ifndef DOXYGEN_RUNNING
    #ifndef CGAL_NO_DEPRECATED_CODE
    template<typename C3T3, typename MeshDomain, typename... NP_Pack>
@@ -158,6 +176,11 @@ Mesh_optimization_return_code odt_optimize_mesh_3(C3T3& c3t3, MeshDomain& domain
    {
        return odt_optimize_mesh_3(c3t3, domain, internal_np::combine_named_parameters(nps...));
    }
+    template<typename ... NP_PACK>
+    Mesh_optimization_return_code odt_optimize_mesh_3(const NP_PACK& ...nps)
+    {
+        return odt_optimize_mesh_3(internal_np::combine_named_parameters(nps...));
+    }
    #endif //CGAL_NO_DEPRECATED_CODE
 
 template <typename C3T3, typename MeshDomain>
diff --git a/Mesh_3/include/CGAL/perturb_mesh_3.h b/Mesh_3/include/CGAL/perturb_mesh_3.h
index f5c6db9e0f8..236f51c8fc8 100644
--- a/Mesh_3/include/CGAL/perturb_mesh_3.h
+++ b/Mesh_3/include/CGAL/perturb_mesh_3.h
@@ -126,6 +126,23 @@ Mesh_optimization_return_code perturb_mesh_3(C3T3& c3t3, MeshDomain& domain, con
     return perturb_mesh_3_impl(c3t3, domain, time_limit, sliver_criterion, perturbation_vector);
 }
 
+    template<typename CGAL_NP_TEMPLATE_PARAMETERS_NO_DEFAULT>
+    Mesh_optimization_return_code perturb_mesh_3(const CGAL_NP_CLASS& np)
+    {
+        static_assert(!parameters::is_default_parameter<CGAL_NP_CLASS, internal_np::c3t3_param_t>::value, "Value for required parameter not found");
+        static_assert(!parameters::is_default_parameter<CGAL_NP_CLASS, internal_np::mesh_domain_param_t>::value, "Value for required parameter not found");
+        using parameters::choose_parameter;
+        using parameters::get_parameter;
+        auto c3t3 = get_parameter(np,internal_np::c3t3_param);
+        auto domain = get_parameter(np,internal_np::mesh_domain_param);
+        double time_limit = choose_parameter(get_parameter(np,internal_np::maximum_running_time),0);
+        auto sliver_bound = choose_parameter(get_parameter(np,internal_np::lower_sliver_bound), parameters::default_values_for_mesh_3::perturb_sliver_bound);
+        auto sliver_criterion = choose_parameter(get_parameter(np, internal_np::sliver_criteria), parameters::default_values_for_mesh_3::default_sliver_criterion(c3t3,sliver_bound));
+        auto perturbation_vector = choose_parameter(get_parameter(np,internal_np::perturb_vector), default_perturbation_vector(c3t3,domain,sliver_criterion));
+        return perturb_mesh_3_impl(c3t3, domain, time_limit, sliver_criterion, perturbation_vector);
+
+    }
+
 #ifndef DOXYGEN_RUNNING
 #ifndef CGAL_NO_DEPRECATED_CODE
   template<typename C3T3, typename MeshDomain, typename ... NP_PACK>
@@ -133,6 +150,11 @@ Mesh_optimization_return_code perturb_mesh_3(C3T3& c3t3, MeshDomain& domain, con
   {
       return perturb_mesh_3(c3t3,domain, internal_np::combine_named_parameters(nps...));
   }
+    template<typename ... NP_PACK>
+    Mesh_optimization_return_code perturb_mesh_3(const NP_PACK& ...nps)
+    {
+        return perturb_mesh_3(internal_np::combine_named_parameters(nps...));
+    }
 #endif //CGAL_NO_DEPRECATED_CODE
 
 template <typename C3T3,
diff --git a/Mesh_3/include/CGAL/refine_mesh_3.h b/Mesh_3/include/CGAL/refine_mesh_3.h
index f88853bd28a..572671f6223 100644
--- a/Mesh_3/include/CGAL/refine_mesh_3.h
+++ b/Mesh_3/include/CGAL/refine_mesh_3.h
@@ -465,6 +465,38 @@ void refine_mesh_3(C3T3& c3t3, MeshDomain& domain, MeshCriteria& criteria, const
                               mesh_options_param,
                               manifold_options_param);
 }
+
+    template<typename CGAL_NP_TEMPLATE_PARAMETERS_NO_DEFAULT>
+    Mesh_optimization_return_code refine_mesh_3(const CGAL_NP_CLASS& np)
+    {
+        static_assert(!parameters::is_default_parameter<CGAL_NP_CLASS, internal_np::c3t3_param_t>::value, "Value for required parameter not found");
+        static_assert(!parameters::is_default_parameter<CGAL_NP_CLASS, internal_np::mesh_domain_param_t>::value, "Value for required parameter not found");
+        static_assert(!parameters::is_default_parameter<CGAL_NP_CLASS, internal_np::mesh_criteria_param_t>::value, "Value for required parameter not found");
+        using parameters::choose_parameter;
+        using parameters::get_parameter;
+        auto c3t3 = get_parameter(np,internal_np::c3t3_param);
+        auto domain = get_parameter(np,internal_np::mesh_domain_param);
+        auto criteria = get_parameter(np, internal_np::mesh_criteria_param);
+        parameters::internal::Exude_options exude_param = choose_parameter(get_parameter(np, internal_np::exude_options_param), parameters::exude().v);
+        parameters::internal::Perturb_options perturb_param = choose_parameter(get_parameter(np, internal_np::perturb_options_param), parameters::perturb().v);
+        parameters::internal::Odt_options odt_param = choose_parameter(get_parameter(np, internal_np::odt_options_param), parameters::no_odt().v);
+        parameters::internal::Lloyd_options lloyd_param = choose_parameter(get_parameter(np, internal_np::lloyd_options_param), parameters::no_lloyd().v);
+        parameters::Reset reset_param = choose_parameter(get_parameter(np, internal_np::reset_options_param), parameters::reset_c3t3().v);
+        parameters::internal::Mesh_3_options mesh_options_param = choose_parameter(get_parameter(np, internal_np::mesh_param), parameters::internal::Mesh_3_options());
+        parameters::internal::Manifold_options manifold_options_param = choose_parameter(get_parameter(np, internal_np::manifold_param), parameters::internal::Manifold_options());
+
+        return refine_mesh_3_impl(c3t3,
+                                  domain,
+                                  criteria,
+                                  exude_param,
+                                  perturb_param,
+                                  odt_param,
+                                  lloyd_param,
+                                  reset_param(),
+                                  mesh_options_param,
+                                  manifold_options_param);
+
+    }
 #ifndef DOXYGEN_RUNNING
 #ifndef CGAL_NO_DEPRECATED_CODE
     template<typename C3T3, typename MeshDomain, typename MeshCriteria, typename... NP_Pack>
@@ -472,6 +504,11 @@ void refine_mesh_3(C3T3& c3t3, MeshDomain& domain, MeshCriteria& criteria, const
     {
         return refine_mesh_3(c3t3, domain, criteria, internal_np::combine_named_parameters(nps...));
     }
+    template<typename ... NP_PACK>
+    void refine_mesh_3(const NP_PACK& ...nps)
+    {
+        return refine_mesh_3(internal_np::combine_named_parameters(nps...));
+    }
 #endif
 
 /**
diff --git a/Periodic_3_mesh_3/include/CGAL/optimize_periodic_3_mesh_3.h b/Periodic_3_mesh_3/include/CGAL/optimize_periodic_3_mesh_3.h
index e44d2d119f4..0a29590871f 100644
--- a/Periodic_3_mesh_3/include/CGAL/optimize_periodic_3_mesh_3.h
+++ b/Periodic_3_mesh_3/include/CGAL/optimize_periodic_3_mesh_3.h
@@ -35,13 +35,32 @@ Mesh_optimization_return_code perturb_periodic_3_mesh_3(C3T3& c3t3, MeshDomain&
     auto perturbation_vector = choose_parameter(get_parameter(np,internal_np::perturb_vector), default_perturbation_vector(c3t3,domain,sliver_criterion));
     return perturb_mesh_3_impl(c3t3, domain, time_limit, sliver_criterion, perturbation_vector);
 }
-
+template<typename CGAL_NP_TEMPLATE_PARAMETERS_NO_DEFAULT>
+Mesh_optimization_return_code perturb_periodic_3_mesh_3(const CGAL_NP_CLASS& np)
+{
+    static_assert(!parameters::is_default_parameter<CGAL_NP_CLASS, internal_np::c3t3_param_t>::value, "Value for required parameter not found");
+    static_assert(!parameters::is_default_parameter<CGAL_NP_CLASS, internal_np::mesh_domain_param_t>::value, "Value for required parameter not found");
+    using parameters::choose_parameter;
+    using parameters::get_parameter;
+    auto c3t3 = get_parameter(np,internal_np::c3t3_param);
+    auto domain = get_parameter(np,internal_np::mesh_domain_param);
+    double time_limit = choose_parameter(get_parameter(np,internal_np::maximum_running_time),0);
+    auto sliver_bound = choose_parameter(get_parameter(np,internal_np::lower_sliver_bound), parameters::default_values_for_mesh_3::perturb_sliver_bound);
+    auto sliver_criterion = choose_parameter(get_parameter(np, internal_np::sliver_criteria), parameters::default_values_for_mesh_3::default_sliver_criterion(c3t3,sliver_bound));
+    auto perturbation_vector = choose_parameter(get_parameter(np,internal_np::perturb_vector), default_perturbation_vector(c3t3,domain,sliver_criterion));
+    return perturb_mesh_3_impl(c3t3, domain, time_limit, sliver_criterion, perturbation_vector);
+}
 #ifndef CGAL_NO_DEPRECATED_CODE
 template<typename C3T3, typename MeshDomain, typename ... NP_PACK>
 Mesh_optimization_return_code perturb_periodic_3_mesh_3(C3T3& c3t3, MeshDomain& domain, const NP_PACK& ... nps)
 {
     return perturb_periodic_3_mesh_3(c3t3,domain, internal_np::combine_named_parameters(nps...));
 }
+template<typename ... NP_PACK>
+Mesh_optimization_return_code perturb_periodic_3_mesh_3(const NP_PACK& ...nps)
+{
+    return perturb_periodic_3_mesh_3(internal_np::combine_named_parameters(nps...));
+}
 #endif //CGAL_NO_DEPRECATED_CODE
 // ---------------------------------- exuder -----------------------------------
 
@@ -55,13 +74,28 @@ Mesh_optimization_return_code exude_periodic_3_mesh_3(C3T3& c3t3,const CGAL_NP_C
     return exude_mesh_3_impl(c3t3,time_limit,sliver_bound);
 
 }
-
+    template<typename CGAL_NP_TEMPLATE_PARAMETERS_NO_DEFAULT>
+    Mesh_optimization_return_code exude_periodic_3_mesh_3(const CGAL_NP_CLASS& np)
+    {
+        static_assert(!parameters::is_default_parameter<CGAL_NP_CLASS, internal_np::c3t3_param_t>::value, "Value for required parameter not found");
+        using parameters::choose_parameter;
+        using parameters::get_parameter;
+        auto c3t3 = get_parameter(np,internal_np::c3t3_param);
+        int time_limit=choose_parameter(get_parameter(np,internal_np::maximum_running_time),0);
+        double sliver_bound= choose_parameter(get_parameter(np,internal_np::lower_sliver_bound),parameters::default_values_for_mesh_3::exude_sliver_bound);
+        return exude_mesh_3_impl(c3t3,time_limit,sliver_bound);
+    }
 #ifndef CGAL_NO_DEPRECATED_CODE
 template<typename C3T3, typename ... NP_PACK>
 Mesh_optimization_return_code exude_periodic_3_mesh_3(C3T3& c3t3, const NP_PACK& ...nps)
 {
     return exude_periodic_3_mesh_3(c3t3,internal_np::combine_named_parameters(nps...));
 }
+template<typename ... NP_PACK>
+Mesh_optimization_return_code exude_periodic_3_mesh_3(const NP_PACK& ...nps)
+{
+    return exude_periodic_3_mesh_3(internal_np::combine_named_parameters(nps...));
+}
 #endif //CGAL_NO_DEPRECATED_CODE
 
 // ------------------------------ odt optimizer --------------------------------
@@ -78,13 +112,33 @@ Mesh_optimization_return_code odt_optimize_periodic_3_mesh_3(C3T3& c3t3, MeshDom
     bool do_freeze=choose_parameter(get_parameter(np,internal_np::freeze),true);
     return odt_optimize_mesh_3_impl(c3t3, domain, time_limit, max_iteration_number, convergence, freeze_bound, do_freeze);
 }
-
+    template<typename CGAL_NP_TEMPLATE_PARAMETERS_NO_DEFAULT>
+    Mesh_optimization_return_code odt_optimize_periodic_3_mesh_3(const CGAL_NP_CLASS& np)
+    {
+        static_assert(!parameters::is_default_parameter<CGAL_NP_CLASS, internal_np::c3t3_param_t>::value, "Value for required parameter not found");
+        static_assert(!parameters::is_default_parameter<CGAL_NP_CLASS, internal_np::mesh_domain_param_t>::value, "Value for required parameter not found");
+        using parameters::choose_parameter;
+        using parameters::get_parameter;
+        auto c3t3 = get_parameter(np,internal_np::c3t3_param);
+        auto domain = get_parameter(np,internal_np::mesh_domain_param);
+        double time_limit=choose_parameter(get_parameter(np,internal_np::maximum_running_time),0);
+        std::size_t max_iteration_number=choose_parameter(get_parameter(np,internal_np::number_of_iterations),0);
+        double convergence=choose_parameter(get_parameter(np,internal_np::convergence_ratio),0.02);
+        double freeze_bound=choose_parameter(get_parameter(np,internal_np::vertex_freeze_bound),0.01);
+        bool do_freeze=choose_parameter(get_parameter(np,internal_np::freeze),true);
+        return odt_optimize_mesh_3_impl(c3t3, domain, time_limit, max_iteration_number, convergence, freeze_bound, do_freeze);
+    }
 #ifndef CGAL_NO_DEPRECATED_CODE
 template<typename C3T3, typename MeshDomain, typename... NP_Pack>
 Mesh_optimization_return_code odt_optimize_periodic_3_mesh_3(C3T3& c3t3, MeshDomain& domain, const NP_Pack& ...nps)
 {
     return odt_optimize_periodic_3_mesh_3(c3t3, domain, internal_np::combine_named_parameters(nps...));
 }
+template<typename ... NP_PACK>
+Mesh_optimization_return_code odt_optimize_periodic_3_mesh_3(const NP_PACK& ...nps)
+{
+    return odt_optimize_periodic_3_mesh_3(internal_np::combine_named_parameters(nps...));
+}
 #endif //CGAL_NO_DEPRECATED_CODE
 
 
@@ -101,13 +155,33 @@ Mesh_optimization_return_code lloyd_optimize_periodic_3_mesh_3(C3T3& c3t3, MeshD
     bool do_freeze = choose_parameter(get_parameter(np,internal_np::freeze),true);
     return lloyd_optimize_mesh_3_impl(c3t3, domain, time_limit, max_iterations, convergence_ratio, freeze_bound, do_freeze);
 }
-
+    template<typename CGAL_NP_TEMPLATE_PARAMETERS_NO_DEFAULT>
+    Mesh_optimization_return_code lloyd_optimize_periodic_3_mesh_3(const CGAL_NP_CLASS& np)
+    {
+        static_assert(!parameters::is_default_parameter<CGAL_NP_CLASS, internal_np::c3t3_param_t>::value, "Value for required parameter not found");
+        static_assert(!parameters::is_default_parameter<CGAL_NP_CLASS, internal_np::mesh_domain_param_t>::value, "Value for required parameter not found");
+        using parameters::choose_parameter;
+        using parameters::get_parameter;
+        auto c3t3 = get_parameter(np,internal_np::c3t3_param);
+        auto domain = get_parameter(np,internal_np::mesh_domain_param);
+        int max_iterations = choose_parameter(get_parameter(np, internal_np::number_of_iterations), 0);
+        const double convergence_ratio = choose_parameter(get_parameter(np, internal_np::convergence_ratio), 0.001);
+        const double freeze_bound = choose_parameter(get_parameter(np, internal_np::vertex_freeze_bound), 0.001);
+        const double time_limit = choose_parameter(get_parameter(np, internal_np::maximum_running_time), 0.);
+        bool do_freeze = choose_parameter(get_parameter(np,internal_np::freeze),true);
+        return lloyd_optimize_mesh_3_impl(c3t3, domain, time_limit, max_iterations, convergence_ratio, freeze_bound, do_freeze);
+    }
 #ifndef CGAL_NO_DEPRECATED_CODE
 template<typename C3T3, typename MeshDomain,typename ... NP_PACK>
 Mesh_optimization_return_code lloyd_optimize_periodic_3_mesh_3(C3T3& c3t3,MeshDomain& domain, const NP_PACK& ...nps)
 {
     return lloyd_optimize_periodic_3_mesh_3(c3t3,domain, internal_np::combine_named_parameters(nps...));
 }
+template<typename ... NP_PACK>
+Mesh_optimization_return_code lloyd_optimize_periodic_3_mesh_3(const NP_PACK& ...nps)
+{
+    return lloyd_optimize_periodic_3_mesh_3(internal_np::combine_named_parameters(nps...));
+}
 #endif //CGAL_NO_DEPRECATED_CODE
 
 } // namespace CGAL
diff --git a/Periodic_3_mesh_3/include/CGAL/refine_periodic_3_mesh_3.h b/Periodic_3_mesh_3/include/CGAL/refine_periodic_3_mesh_3.h
index 2b4b4968221..ebada4374c8 100644
--- a/Periodic_3_mesh_3/include/CGAL/refine_periodic_3_mesh_3.h
+++ b/Periodic_3_mesh_3/include/CGAL/refine_periodic_3_mesh_3.h
@@ -322,6 +322,37 @@ void refine_periodic_3_mesh_3(C3T3& c3t3, MeshDomain& domain, MeshCriteria& crit
                               manifold_options_param);
 }
 
+    template<typename CGAL_NP_TEMPLATE_PARAMETERS_NO_DEFAULT>
+    void refine_periodic_3_mesh_3(const CGAL_NP_CLASS& np)
+    {
+        static_assert(!parameters::is_default_parameter<CGAL_NP_CLASS, internal_np::c3t3_param_t>::value, "Value for required parameter not found");
+        static_assert(!parameters::is_default_parameter<CGAL_NP_CLASS, internal_np::mesh_domain_param_t>::value, "Value for required parameter not found");
+        static_assert(!parameters::is_default_parameter<CGAL_NP_CLASS, internal_np::mesh_criteria_param_t>::value, "Value for required parameter not found");
+        using parameters::choose_parameter;
+        using parameters::get_parameter;
+        auto c3t3 = get_parameter(np,internal_np::c3t3_param);
+        auto domain = get_parameter(np,internal_np::mesh_domain_param);
+        auto criteria = get_parameter(np, internal_np::mesh_criteria_param);
+        parameters::internal::Exude_options exude_param = choose_parameter(get_parameter(np, internal_np::exude_options_param), parameters::no_exude());
+        parameters::internal::Perturb_options perturb_param = choose_parameter(get_parameter(np, internal_np::perturb_options_param), parameters::no_perturb());
+        parameters::internal::Odt_options odt_param = choose_parameter(get_parameter(np, internal_np::odt_options_param), parameters::no_odt());
+        parameters::internal::Lloyd_options lloyd_param = choose_parameter(get_parameter(np, internal_np::lloyd_options_param), parameters::no_lloyd());
+        parameters::Reset reset_param = choose_parameter(get_parameter(np, internal_np::reset_options_param), parameters::reset_c3t3());
+        parameters::internal::Mesh_3_options mesh_options_param = choose_parameter(get_parameter(np, internal_np::mesh_param), parameters::internal::Mesh_3_options());
+        parameters::internal::Manifold_options manifold_options_param = choose_parameter(get_parameter(np, internal_np::manifold_param), parameters::internal::Manifold_options());
+
+        return refine_periodic_3_mesh_3_impl(c3t3,
+                                             domain,
+                                             criteria,
+                                             exude_param,
+                                             perturb_param,
+                                             odt_param,
+                                             lloyd_param,
+                                             reset_param(),
+                                             mesh_options_param,
+                                             manifold_options_param);
+    }
+
 #ifndef DOXYGEN_RUNNING
 #ifndef CGAL_NO_DEPRECATED_CODE
     template<typename C3T3, typename MeshDomain, typename MeshCriteria, typename... NP_Pack>
@@ -329,6 +360,11 @@ void refine_periodic_3_mesh_3(C3T3& c3t3, MeshDomain& domain, MeshCriteria& crit
     {
         return refine_periodic_3_mesh_3(c3t3, domain, criteria, internal_np::combine_named_parameters(nps...));
     }
+    template<typename ... NP_PACK>
+    void refine_periodic_3_mesh_3(const NP_PACK& ...nps)
+    {
+        return refine_periodic_3_mesh_3(internal_np::combine_named_parameters(nps...));
+    }
 #endif
 /**
  * @brief This function refines the mesh c3t3 wrt domain & criteria
diff --git a/STL_Extension/include/CGAL/Named_function_parameters.h b/STL_Extension/include/CGAL/Named_function_parameters.h
index 8887e8c7889..e80affdf4a8 100644
--- a/STL_Extension/include/CGAL/Named_function_parameters.h
+++ b/STL_Extension/include/CGAL/Named_function_parameters.h
@@ -347,6 +347,9 @@ const Boost_parameter_compatibility_wrapper<internal_np::sliver_criteria_t> sliv
 const Boost_parameter_compatibility_wrapper<internal_np::perturb_vector_t> perturbation_vector;
 //Compatibility wrappers for exude_mesh_3.h
 const Boost_parameter_compatibility_wrapper<internal_np::lower_sliver_bound_t> sliver_bound;
+const Boost_parameter_compatibility_wrapper<internal_np::c3t3_param_t> c3t3_named_param;
+const Boost_parameter_compatibility_wrapper<internal_np::mesh_domain_param_t> mesh_domain;
+const Boost_parameter_compatibility_wrapper<internal_np::mesh_criteria_param_t> mesh_criteria;
 const Boost_parameter_compatibility_wrapper<internal_np::mesh_topology_number_t> mesh_topology;
 const Boost_parameter_compatibility_wrapper<internal_np::dump_after_init_prefix_param_t> dump_after_init_prefix;
 const Boost_parameter_compatibility_wrapper<internal_np::dump_after_refine_surface_prefix_param_t> dump_after_refine_surface_prefix;
@@ -368,6 +371,8 @@ const Boost_parameter_compatibility_wrapper<internal_np::mesh_param_t> mesh_opti
 const Boost_parameter_compatibility_wrapper<internal_np::manifold_param_t> manifold_options_param;
 const Boost_parameter_compatibility_wrapper<internal_np::features_option_param_t> features_param;
 
+const Boost_parameter_compatibility_wrapper<internal_np::function_param_t> function;
+const Boost_parameter_compatibility_wrapper<internal_np::bounding_object_param_t> bounding_object;
 const Boost_parameter_compatibility_wrapper<internal_np::image_3_param_t> image;
 const Boost_parameter_compatibility_wrapper<internal_np::iso_value_param_t> iso_value;
 const Boost_parameter_compatibility_wrapper<internal_np::image_subdomain_index_t> image_values_to_subdomain_indices;
diff --git a/STL_Extension/include/CGAL/STL_Extension/internal/parameters_interface.h b/STL_Extension/include/CGAL/STL_Extension/internal/parameters_interface.h
index 05abe4bb162..88e9ad94f9f 100644
--- a/STL_Extension/include/CGAL/STL_Extension/internal/parameters_interface.h
+++ b/STL_Extension/include/CGAL/STL_Extension/internal/parameters_interface.h
@@ -252,7 +252,9 @@ CGAL_add_named_parameter(i_seed_end_iterator_t, i_seed_end_iterator, i_seed_end_
 //List of named parameters used in exude_mesh_3.h
 CGAL_add_named_parameter(lower_sliver_bound_t,lower_sliver_bound,lower_sliver_bound)
 CGAL_add_named_parameter(freeze_t,freeze,freeze)
-
+CGAL_add_named_parameter(c3t3_param_t, c3t3_param, c3t3_param)
+CGAL_add_named_parameter(mesh_domain_param_t, mesh_domain_param, mesh_domain_param)
+CGAL_add_named_parameter(mesh_criteria_param_t, mesh_criteria_param, mesh_criteria_param)
 //List of named parameters used in perturb_mesh_3.h
 CGAL_add_named_parameter(sliver_criteria_t, sliver_criteria, sliver_criteria)
 CGAL_add_named_parameter(perturb_vector_t, perturb_vector, perturb_vector)
@@ -302,5 +304,5 @@ CGAL_add_named_parameter(cell_size_param_t, cell_size_param, cell_size_param)
 CGAL_add_named_parameter(cell_sizing_field_param_t, cell_sizing_field_param, cell_sizing_field_param)
 CGAL_add_named_parameter(sizing_field_param_t, sizing_field_param, sizing_field_param)
 
-
-
+CGAL_add_named_parameter(function_param_t, function_param, function_param)
+CGAL_add_named_parameter(bounding_object_param_t, bounding_object_param, bounding_object_param)
\ No newline at end of file