cosmetic renaming of parameters

Surface_mesh_approximation/include/CGAL/VSA/approximate_mesh.h

@@ -167,7 +167,7 @@ bool approximate_mesh(const TriangleMesh &tm, const NamedParameters &np)
 
   if (vl == CGAL::VSA::MAIN_STEPS || vl == CGAL::VSA::VERBOSE) {
     std::cout << "Approximation done."
-      << "\n#proxies = " << approx.proxies_size() << std::endl;
+      << "\n#proxies = " << approx.number_of_proxies() << std::endl;
   }
 
   // get proxy map

Surface_mesh_approximation/include/CGAL/Variational_shape_approximation.h

@@ -335,11 +335,11 @@ public:
 
     const CGAL::VSA::Seeding_method method = choose_param(
       get_param(np, internal_np::seeding_method), CGAL::VSA::HIERARCHICAL);
-    const boost::optional<std::size_t> max_nb_of_proxies = choose_param(
+    const boost::optional<std::size_t> max_nb_proxies = choose_param(
       get_param(np, internal_np::max_number_of_proxies), boost::optional<std::size_t>());
     const boost::optional<FT> min_error_drop = choose_param(
       get_param(np, internal_np::min_error_drop), boost::optional<FT>());
-    const std::size_t nb_of_relaxations = choose_param(get_param(np, internal_np::number_of_relaxations), 5);
+    const std::size_t nb_relaxations = choose_param(get_param(np, internal_np::number_of_relaxations), 5);
 
     // maximum number of proxies internally, maybe better choice?
     const std::size_t nb_px = num_faces(*m_ptm) / 3;
@@ -350,30 +350,30 @@ public:
     if (min_error_drop && *min_error_drop > FT(0.0) && *min_error_drop < FT(1.0)) {
       // as long as minimum error is specified and valid
       // maximum number of proxies always exists, no matter specified or not or out of range
-      // there is always a maximum number of proxies explicitly (max_nb_of_proxies) or implicitly (nb_px)
+      // there is always a maximum number of proxies explicitly (max_nb_proxies) or implicitly (nb_px)
       std::size_t max_nb_px_adjusted = nb_px;
-      if (max_nb_of_proxies && *max_nb_of_proxies < nb_px && *max_nb_of_proxies > 0)
+      if (max_nb_proxies && *max_nb_proxies < nb_px && *max_nb_proxies > 0)
-        max_nb_px_adjusted = *max_nb_of_proxies;
+        max_nb_px_adjusted = *max_nb_proxies;
       switch (method) {
         case VSA::RANDOM:
-          return init_random_error(max_nb_px_adjusted, *min_error_drop, nb_of_relaxations);
+          return init_random_error(max_nb_px_adjusted, *min_error_drop, nb_relaxations);
         case VSA::INCREMENTAL:
-          return init_incremental_error(max_nb_px_adjusted, *min_error_drop, nb_of_relaxations);
+          return init_incremental_error(max_nb_px_adjusted, *min_error_drop, nb_relaxations);
         case VSA::HIERARCHICAL:
-          return init_hierarchical_error(max_nb_px_adjusted, *min_error_drop, nb_of_relaxations);
+          return init_hierarchical_error(max_nb_px_adjusted, *min_error_drop, nb_relaxations);
         default:
           return 0;
       }
     }
-    else if (max_nb_of_proxies && *max_nb_of_proxies < nb_px && *max_nb_of_proxies > 0) {
+    else if (max_nb_proxies && *max_nb_proxies < nb_px && *max_nb_proxies > 0) {
-      // no valid min_error_drop provided, only max_nb_of_proxies
+      // no valid min_error_drop provided, only max_nb_proxies
       switch (method) {
         case VSA::RANDOM:
-          return init_random(*max_nb_of_proxies, nb_of_relaxations);
+          return init_random(*max_nb_proxies, nb_relaxations);
         case VSA::INCREMENTAL:
-          return init_incremental(*max_nb_of_proxies, nb_of_relaxations);
+          return init_incremental(*max_nb_proxies, nb_relaxations);
         case VSA::HIERARCHICAL:
-          return init_hierarchical(*max_nb_of_proxies, nb_of_relaxations);
+          return init_hierarchical(*max_nb_proxies, nb_relaxations);
         default:
           return 0;
       }
@@ -383,11 +383,11 @@ public:
       const FT e(0.1);
       switch (method) {
         case VSA::RANDOM:
-          return init_random_error(nb_px, e, nb_of_relaxations);
+          return init_random_error(nb_px, e, nb_relaxations);
         case VSA::INCREMENTAL:
-          return init_incremental_error(nb_px, e, nb_of_relaxations);
+          return init_incremental_error(nb_px, e, nb_relaxations);
         case VSA::HIERARCHICAL:
-          return init_hierarchical_error(nb_px, e, nb_of_relaxations);
+          return init_hierarchical_error(nb_px, e, nb_relaxations);
         default:
           return 0;
       }
@@ -396,11 +396,11 @@ public:
 
   /*!
    * @brief Runs the partitioning and fitting processes on the whole surface.
-   * @param nb_of_iterations number of iterations.
+   * @param nb_iterations number of iterations.
    * @return total fitting error
    */
-  FT run(std::size_t nb_of_iterations = 1) {
+  FT run(std::size_t nb_iterations = 1) {
-    for (std::size_t i = 0; i < nb_of_iterations; ++i) {
+    for (std::size_t i = 0; i < nb_iterations; ++i) {
       // tag the whole surface
       BOOST_FOREACH(face_descriptor f, faces(*m_ptm))
         put(m_fproxy_map, f, CGAL_VSA_INVALID_TAG);
@@ -470,18 +470,18 @@ public:
   /*!
    * @brief Adds proxies to the worst regions one by one.
    * The re-fitting is performed after each proxy is inserted.
-   * @param num_proxies number of proxies to be added
+   * @param nb_proxies number of proxies to be added
-   * @param nb_of_iterations number of re-fitting iterations
+   * @param nb_iterations number of re-fitting iterations
    * @return number of proxies added
    */
-  std::size_t add_to_furthest_proxies(const std::size_t num_proxies,
+  std::size_t add_to_furthest_proxies(const std::size_t nb_proxies,
-    const std::size_t nb_of_iterations = 5) {
+    const std::size_t nb_iterations = 5) {
     std::size_t num_added = 0;
-    while (num_added < num_proxies) {
+    while (num_added < nb_proxies) {
       if (!add_to_furthest_proxy())
         break;
       ++num_added;
-      run(nb_of_iterations);
+      run(nb_iterations);
     }
     return num_added;
   }
@@ -489,16 +489,16 @@ public:
   /*!
    * @brief Adds proxies by diffusing fitting error into current partition.
    * Each partition is added with the number of proxies in proportion to its fitting error.
-   * @param num_proxies number of proxies to be added
+   * @param nb_proxies number of proxies to be added
    * @return number of proxies successfully added
    */
-  std::size_t add_proxies_error_diffusion(const std::size_t num_proxies) {
+  std::size_t add_proxies_error_diffusion(const std::size_t nb_proxies) {
 #ifdef CGAL_SURFACE_MESH_APPROXIMATION_DEBUG
     std::cerr << "#px " << m_proxies.size() << std::endl;
 #endif
 
     const double sum_error = CGAL::to_double(compute_total_error());
-    const double avg_error = sum_error / static_cast<double>(num_proxies);
+    const double avg_error = sum_error / static_cast<double>(nb_proxies);
 
     // number of proxies to be added to each region
     std::vector<std::size_t> num_to_add(m_proxies.size(), 0);
@@ -508,7 +508,7 @@ public:
       std::cerr << "zero error, diffuse w.r.t. number of faces" << std::endl;
 #endif
       const double avg_face =
-        static_cast<double>(num_faces(*m_ptm)) / static_cast<double>(num_proxies);
+        static_cast<double>(num_faces(*m_ptm)) / static_cast<double>(nb_proxies);
       std::vector<double> px_size(m_proxies.size(), 0.0);
       BOOST_FOREACH(face_descriptor f, faces(*m_ptm))
         px_size[get(m_fproxy_map, f)] += 1.0;
@@ -561,7 +561,7 @@ public:
 
 #ifdef CGAL_SURFACE_MESH_APPROXIMATION_DEBUG
     std::cerr << "#requested/added "
-      << num_proxies << '/' << num_added << std::endl;
+      << nb_proxies << '/' << num_added << std::endl;
 #endif
 
     return num_added;
@@ -574,16 +574,16 @@ public:
    * @brief Teleports the local minimum to the worst region by combining the merging and adding processes.
    * The re-fitting is performed after each teleportation.
    * Here if we specify more than one proxy this means we teleport in a naive iterative fashion.
-   * @param num_proxies number of proxies requested to teleport.
+   * @param nb_proxies number of proxies requested to teleport.
-   * @param nb_of_iterations number of re-fitting iterations.
+   * @param nb_iterations number of re-fitting iterations.
    * @param if_force set `true` to force the teleportation (no merge test).
    * @return number of proxies teleported.
    */
-  std::size_t teleport_proxies(const std::size_t num_proxies,
+  std::size_t teleport_proxies(const std::size_t nb_proxies,
-    const std::size_t nb_of_iterations = 5,
+    const std::size_t nb_iterations = 5,
     const bool if_force = false) {
     std::size_t num_teleported = 0;
-    while (num_teleported < num_proxies) {
+    while (num_teleported < nb_proxies) {
       // find worst proxy
       std::size_t px_worst = 0;
       FT max_error = m_proxies.front().err;
@@ -629,7 +629,7 @@ public:
 
       num_teleported++;
       // coarse re-fitting
-      run(nb_of_iterations);
+      run(nb_iterations);
 
 #ifdef CGAL_SURFACE_MESH_APPROXIMATION_DEBUG
       std::cerr << "teleported" << std::endl;
@@ -752,12 +752,12 @@ public:
    * other regions are not affected.
    * @param px_idx proxy index.
    * @param n number of split sections.
-   * @param nb_of_relaxations number of relaxations within the proxy area <em>px_idx</em> after the split
+   * @param nb_relaxations number of relaxations within the proxy area <em>px_idx</em> after the split
    * @return `true` if split succeeds, and `false` otherwise.
    */
   bool split(const std::size_t px_idx,
     const std::size_t n = 2,
-    const std::size_t nb_of_relaxations = 10) {
+    const std::size_t nb_relaxations = 10) {
     if (px_idx >= m_proxies.size())
       return false;
 
@@ -789,7 +789,7 @@ public:
     }
 
     // relaxation on confined area and proxies
-    for (std::size_t i = 0; i < nb_of_relaxations; ++i) {
+    for (std::size_t i = 0; i < nb_relaxations; ++i) {
       BOOST_FOREACH(face_descriptor f, confined_area)
         put(m_fproxy_map, f, CGAL_VSA_INVALID_TAG);
 
@@ -882,7 +882,7 @@ public:
    *  \cgalParamBegin{face_proxy_map} a ReadWritePropertyMap with
    * `boost::graph_traits<TriangleMesh>::%face_descriptor` as key and `std::size_t` as value type.
    * A proxy is a set of connected faces which are placed under the same proxy patch (see \cgalFigureRef{iterations}).
-   * The proxy-ids are contiguous in range [0, number_of_proxies - 1].
+   * The proxy-ids are contiguous in range [0, number_of_proxies() - 1].
    *  \cgalParamEnd
    *  \cgalParamBegin{proxies} output iterator over proxies.
    *  \cgalParamEnd
@@ -909,6 +909,11 @@ public:
     indexed_triangles( get_param(np, internal_np::triangles) );
   }
 
+  /*!
+   * @brief returns the number of proxies.
+   */
+  std::size_t number_of_proxies() const { return m_proxies.size(); }
+
   /// @cond CGAL_DOCUMENT_INTERNAL
   /*!
    * @brief Gets the face-proxy index map.
@@ -940,12 +945,6 @@ public:
         *out++ = f;
   }
 
-  /*!
-   * @brief Gets the proxies size.
-   * @return number of proxies
-   */
-  std::size_t proxies_size() const { return m_proxies.size(); }
-
   /*!
    * @brief Gets the proxies.
    * @tparam OutputIterator output iterator with Proxy as value type
@@ -1036,19 +1035,19 @@ private:
   /*!
    * @brief Randomly initializes proxies to target number of proxies.
    * @note To ensure the randomness, call `std::srand()` beforehand.
-   * @param max_nb_of_proxies maximum number of proxies,
+   * @param max_nb_proxies maximum number of proxies,
    * should be in range (nb_connected_components, num_faces(*m_ptm))
-   * @param nb_of_iterations number of re-fitting iterations
+   * @param nb_iterations number of re-fitting iterations
    * @return number of proxies initialized
    */
-  std::size_t init_random(const std::size_t max_nb_of_proxies,
+  std::size_t init_random(const std::size_t max_nb_proxies,
-    const std::size_t nb_of_iterations) {
+    const std::size_t nb_iterations) {
     // pick from current non seed faces randomly
     std::vector<face_descriptor> picked_seeds;
-    if (random_pick_non_seed_faces(max_nb_of_proxies - m_proxies.size(), picked_seeds)) {
+    if (random_pick_non_seed_faces(max_nb_proxies - m_proxies.size(), picked_seeds)) {
       BOOST_FOREACH(face_descriptor f, picked_seeds)
         add_one_proxy_at(f);
-      run(nb_of_iterations);
+      run(nb_iterations);
     }
 
     return m_proxies.size();
@@ -1056,40 +1055,40 @@ private:
 
   /*!
    * @brief Incrementally initializes proxies to target number of proxies.
-   * @param max_nb_of_proxies maximum number of proxies,
+   * @param max_nb_proxies maximum number of proxies,
    * should be in range (nb_connected_components, num_faces(*m_ptm))
-   * @param nb_of_iterations number of re-fitting iterations
+   * @param nb_iterations number of re-fitting iterations
    * before each incremental proxy insertion
    * @return number of proxies initialized
    */
-  std::size_t init_incremental(const std::size_t max_nb_of_proxies,
+  std::size_t init_incremental(const std::size_t max_nb_proxies,
-    const std::size_t nb_of_iterations) {
+    const std::size_t nb_iterations) {
-    if (m_proxies.size() < max_nb_of_proxies)
+    if (m_proxies.size() < max_nb_proxies)
-      add_to_furthest_proxies(max_nb_of_proxies - m_proxies.size(), nb_of_iterations);
+      add_to_furthest_proxies(max_nb_proxies - m_proxies.size(), nb_iterations);
 
     return m_proxies.size();
   }
 
   /*!
    * @brief Hierarchically initializes proxies to target number of proxies.
-   * @param max_nb_of_proxies maximum number of proxies,
+   * @param max_nb_proxies maximum number of proxies,
    * should be in range (nb_connected_components, num_faces(*m_ptm))
-   * @param nb_of_iterations number of re-fitting iterations
+   * @param nb_iterations number of re-fitting iterations
    * before each hierarchical proxy insertion
    * @return number of proxies initialized
    */
-  std::size_t init_hierarchical(const std::size_t max_nb_of_proxies,
+  std::size_t init_hierarchical(const std::size_t max_nb_proxies,
-    const std::size_t nb_of_iterations) {
+    const std::size_t nb_iterations) {
-    while (m_proxies.size() < max_nb_of_proxies) {
+    while (m_proxies.size() < max_nb_proxies) {
       // try to double current number of proxies each time
       std::size_t target_px = m_proxies.size();
-      if (target_px * 2 > max_nb_of_proxies)
+      if (target_px * 2 > max_nb_proxies)
-        target_px = max_nb_of_proxies;
+        target_px = max_nb_proxies;
       else
         target_px *= 2;
       // add proxies by error diffusion
       add_proxies_error_diffusion(target_px - m_proxies.size());
-      run(nb_of_iterations);
+      run(nb_iterations);
     }
 
     return m_proxies.size();
@@ -1100,22 +1099,22 @@ private:
    * with both maximum number of proxies and minimum error drop stop criteria,
    * where the first criterion met stops the seeding.
    * @note To ensure the randomness, call `std::srand()` beforehand.
-   * @param max_nb_of_proxies maximum number of proxies, should be in range (nb_connected_components, num_faces(tm) / 3)
+   * @param max_nb_proxies maximum number of proxies, should be in range (nb_connected_components, num_faces(tm) / 3)
    * @param min_error_drop minimum error drop, should be in range (0.0, 1.0)
-   * @param nb_of_iterations number of re-fitting iterations
+   * @param nb_iterations number of re-fitting iterations
    * @return number of proxies initialized
    */
-  std::size_t init_random_error(const std::size_t max_nb_of_proxies,
+  std::size_t init_random_error(const std::size_t max_nb_proxies,
     const FT min_error_drop,
-    const std::size_t nb_of_iterations) {
+    const std::size_t nb_iterations) {
 
     const FT initial_err = compute_total_error();
     FT error_drop = min_error_drop * FT(2.0);
-    while (m_proxies.size() < max_nb_of_proxies && error_drop > min_error_drop) {
+    while (m_proxies.size() < max_nb_proxies && error_drop > min_error_drop) {
       // try to double current number of proxies each time
       const std::size_t nb_px = m_proxies.size();
       const std::size_t nb_to_add =
-        (nb_px * 2 > max_nb_of_proxies) ? max_nb_of_proxies - nb_px : nb_px;
+        (nb_px * 2 > max_nb_proxies) ? max_nb_proxies - nb_px : nb_px;
 
       // pick from current non seed faces randomly
       std::vector<face_descriptor> picked_seeds;
@@ -1124,7 +1123,7 @@ private:
 
       BOOST_FOREACH(face_descriptor f, picked_seeds)
         add_one_proxy_at(f);
-      const FT err = run(nb_of_iterations);
+      const FT err = run(nb_iterations);
       error_drop = err / initial_err;
     }
 
@@ -1135,19 +1134,19 @@ private:
    * @brief Incrementally initializes proxies
    * with both maximum number of proxies and minimum error drop stop criteria,
    * The first criterion met stops the seeding.
-   * @param max_nb_of_proxies maximum number of proxies, should be in range (nb_connected_components, num_faces(tm) / 3)
+   * @param max_nb_proxies maximum number of proxies, should be in range (nb_connected_components, num_faces(tm) / 3)
    * @param min_error_drop minimum error drop, should be in range (0.0, 1.0)
-   * @param nb_of_iterations number of re-fitting iterations
+   * @param nb_iterations number of re-fitting iterations
    * @return number of proxies initialized
    */
-  std::size_t init_incremental_error(const std::size_t max_nb_of_proxies,
+  std::size_t init_incremental_error(const std::size_t max_nb_proxies,
     const FT min_error_drop,
-    const std::size_t nb_of_iterations) {
+    const std::size_t nb_iterations) {
     const FT initial_err = compute_total_error();
     FT error_drop = min_error_drop * FT(2.0);
-    while (m_proxies.size() < max_nb_of_proxies && error_drop > min_error_drop) {
+    while (m_proxies.size() < max_nb_proxies && error_drop > min_error_drop) {
       add_to_furthest_proxy();
-      const FT err = run(nb_of_iterations);
+      const FT err = run(nb_iterations);
       error_drop = err / initial_err;
     }
 
@@ -1158,25 +1157,25 @@ private:
    * @brief Hierarchically initializes proxies
    * with both maximum number of proxies and minimum error drop stop criteria,
    * where the first criterion met stops the seeding.
-   * @param max_nb_of_proxies maximum number of proxies, should be in range (nb_connected_components, num_faces(tm) / 3)
+   * @param max_nb_proxies maximum number of proxies, should be in range (nb_connected_components, num_faces(tm) / 3)
    * @param min_error_drop minimum error drop, should be in range (0.0, 1.0)
-   * @param nb_of_iterations number of re-fitting iterations
+   * @param nb_iterations number of re-fitting iterations
    * @return number of proxies initialized
    */
-  std::size_t init_hierarchical_error(const std::size_t max_nb_of_proxies,
+  std::size_t init_hierarchical_error(const std::size_t max_nb_proxies,
     const FT min_error_drop,
-    const std::size_t nb_of_iterations) {
+    const std::size_t nb_iterations) {
     const FT initial_err = compute_total_error();
     FT error_drop = min_error_drop * FT(2.0);
-    while (m_proxies.size() < max_nb_of_proxies && error_drop > min_error_drop) {
+    while (m_proxies.size() < max_nb_proxies && error_drop > min_error_drop) {
       // try to double current number of proxies each time
       std::size_t target_px = m_proxies.size();
-      if (target_px * 2 > max_nb_of_proxies)
+      if (target_px * 2 > max_nb_proxies)
-        target_px = max_nb_of_proxies;
+        target_px = max_nb_proxies;
       else
         target_px *= 2;
       add_proxies_error_diffusion(target_px - m_proxies.size());
-      const FT err = run(nb_of_iterations);
+      const FT err = run(nb_iterations);
       error_drop = err / initial_err;
     }
 

Surface_mesh_approximation/test/Surface_mesh_approximation/vsa_class_interface_test.cpp

@@ -55,7 +55,7 @@ int main()
   approx.initialize_seeds(CGAL::parameters::seeding_method(CGAL::VSA::RANDOM)
     .max_number_of_proxies(10));
   approx.run(10);
-  if (approx.proxies_size() != 10)
+  if (approx.number_of_proxies() != 10)
     return EXIT_FAILURE;
 
   // incremental add and run to convergence
@@ -63,20 +63,20 @@ int main()
   approx.add_to_furthest_proxies(3, 5);
   if (approx.run_to_convergence(0.1))
     std::cout << "Converged." << std::endl;
-  if (approx.proxies_size() != 13)
+  if (approx.number_of_proxies() != 13)
     return EXIT_FAILURE;
 
   std::cout << "hierarchical add and run" << std::endl;
   approx.add_proxies_error_diffusion(3);
   approx.run(10);
-  if (approx.proxies_size() != 16)
+  if (approx.number_of_proxies() != 16)
     return EXIT_FAILURE;
 
   // merge and teleport the proxies from local minimal
   std::cout << "teleport" << std::endl;
   approx.teleport_proxies(3);
   approx.run(10);
-  if (approx.proxies_size() != 16)
+  if (approx.number_of_proxies() != 16)
     return EXIT_FAILURE;
 
   // split proxy 0 into 2 proxies
@@ -84,7 +84,7 @@ int main()
   std::cout << "spliting" << std::endl;
   if (!approx.split(0, 2, 10))
     return EXIT_FAILURE;
-  if (approx.proxies_size() != 17)
+  if (approx.number_of_proxies() != 17)
     return EXIT_FAILURE;
 
   // extract the approximation polyhedron
@@ -98,7 +98,7 @@ int main()
   std::cout << "get outputs" << std::endl;
   approx.proxy_map(proxy_pmap);
 
-  for (std::size_t i = 0; i < approx.proxies_size(); ++i) {
+  for (std::size_t i = 0; i < approx.number_of_proxies(); ++i) {
     std::list<Facet_handle> patch;
     approx.proxy_region(i, std::back_inserter(patch));
   }
@@ -125,14 +125,14 @@ int main()
     .min_error_drop(drop)
     .number_of_relaxations(iterations));
   approx.run(10);
-  std::cout << "#proxies " << approx.proxies_size() << std::endl;
+  std::cout << "#proxies " << approx.number_of_proxies() << std::endl;
 
   std::cout << "re-initialize and incremental seeding" << std::endl;
   approx.initialize_seeds(CGAL::parameters::seeding_method(CGAL::VSA::INCREMENTAL)
     .min_error_drop(drop)
     .number_of_relaxations(iterations));
   approx.run(10);
-  std::cout << "#proxies " << approx.proxies_size() << std::endl;
+  std::cout << "#proxies " << approx.number_of_proxies() << std::endl;
 
   // extract the approximation polyhedron
   std::cout << "meshing" << std::endl;

Surface_mesh_approximation/test/Surface_mesh_approximation/vsa_correctness_test.cpp

@@ -50,10 +50,10 @@ bool test_shape(const char *file_name, const std::size_t target_num_proxies)
     approx.run(num_iterations);
   }
 
-  if (approx.proxies_size() != target_num_proxies) {
+  if (approx.number_of_proxies() != target_num_proxies) {
     std::cout << "#targeted - #result "
       << target_num_proxies << ' '
-      << approx.proxies_size() << std::endl;
+      << approx.number_of_proxies() << std::endl;
 
     std::cout << "Failed." << std::endl;
     return false;

Surface_mesh_approximation/test/Surface_mesh_approximation/vsa_meshing_manifold_test.cpp

@@ -40,7 +40,7 @@ bool test_manifold(const char *file_name, const FT drop = FT(1e-8))
     .min_error_drop(drop)
     .number_of_relaxations(inner_iterations));
   approx.run(num_iterations);
-  std::cout << "#proxies " << approx.proxies_size() << std::endl;
+  std::cout << "#proxies " << approx.number_of_proxies() << std::endl;
 
   // meshing
   if (approx.extract_mesh(CGAL::parameters::subdivision_ratio(5.0))) {

Surface_mesh_approximation/test/Surface_mesh_approximation/vsa_metric_test.cpp

@@ -102,7 +102,7 @@ int main()
   approx.initialize_seeds(CGAL::parameters::seeding_method(CGAL::VSA::RANDOM)
     .max_number_of_proxies(20));
   approx.run(20);
-  if (approx.proxies_size() != 20)
+  if (approx.number_of_proxies() != 20)
     return EXIT_FAILURE;
 
   // extract the approximation

Surface_mesh_approximation/test/Surface_mesh_approximation/vsa_teleportation_test.cpp

@@ -69,7 +69,7 @@ int main()
   std::srand(static_cast<unsigned int>(std::time(0)));
   approx.initialize_seeds(CGAL::parameters::seeding_method(CGAL::VSA::RANDOM)
     .max_number_of_proxies(50));
-  if (approx.proxies_size() != 50)
+  if (approx.number_of_proxies() != 50)
     return EXIT_FAILURE;
   approx.run(10);