rename seeding method enumeration

Surface_mesh_approximation/benchmark/Surface_mesh_approximation/vsa_autoinit_timing_benchmark.cpp

@@ -61,7 +61,7 @@ int main(int argc, char *argv[])
   std::cerr << "start initialization" << std::endl;
   t.start();
   l21_vsa.seeding_by_error(
-    static_cast<L21VSA::Initialization>(init), tol, iterations);
+    static_cast<L21VSA::Method>(init), tol, iterations);
   t.stop();
   std::cerr << "initialization time " << t.time() << " sec." << std::endl;
   std::cerr << "#proxies " << l21_vsa.get_proxies_size() << std::endl;

Surface_mesh_approximation/benchmark/Surface_mesh_approximation/vsa_timing_benchmark.cpp

@@ -65,7 +65,7 @@ int main(int argc, char *argv[])
   t0.reset();
   t0.start();
   l21_vsa.seeding_by_number(
-    static_cast<L21VSA::Initialization>(init), num_proxies);
+    static_cast<L21VSA::Method>(init), num_proxies);
   t0.stop();
   std::cerr << "initialization time " << t0.time() << " sec." << std::endl;
 

Surface_mesh_approximation/demo/Surface_mesh_approximation/Scene.cpp

@@ -149,7 +149,7 @@ void Scene::l21_approximation(
   std::cout << "L21 approximation..." << std::endl;
 
   m_vsa_l21.seeding_by_number(
-    static_cast<L21VSA::Initialization>(init), num_proxies);
+    static_cast<L21VSA::Method>(init), num_proxies);
   for (std::size_t i = 0; i < num_iterations; ++i)
     m_vsa_l21.run_one_step();
 
@@ -172,7 +172,7 @@ void Scene::l2_approximation(
   std::cout << "L2 approximation..." << std::endl;
 
   m_vsa_l2.seeding_by_number(
-    static_cast<L2VSA::Initialization>(init), num_proxies);
+    static_cast<L2VSA::Method>(init), num_proxies);
   for (std::size_t i = 0; i < num_iterations; ++i)
     m_vsa_l2.run_one_step();
 
@@ -195,7 +195,7 @@ void Scene::compact_approximation(
   std::cout << "Compact approximation..." << std::endl;
 
   m_vsa_compact.seeding_by_number(
-    static_cast<CompactVSA::Initialization>(init), num_proxies);
+    static_cast<CompactVSA::Method>(init), num_proxies);
   for (std::size_t i = 0; i < num_iterations; ++i)
     m_vsa_compact.run_one_step();
 

Surface_mesh_approximation/examples/Surface_mesh_approximation/vsa_class_interface_example.cpp

@@ -35,7 +35,7 @@ int main()
   l21_approx.set_metric(metric, proxy_fitting);
 
   // initialize proxies randomly on the mesh
-  l21_approx.seeding_by_number(L21VSA::RandomInit, 100);
+  l21_approx.seeding_by_number(L21VSA::Random, 100);
 
   // run the iteration to minimize the error
   for (std::size_t i = 0; i < 30; ++i)

Surface_mesh_approximation/examples/Surface_mesh_approximation/vsa_metric_example.cpp

@@ -108,7 +108,7 @@ int main()
   compact_approx.set_metric(metric, proxy_fitting);
 
   // using 200 proxies to approximate the shape
-  compact_approx.seeding_by_number(CompactVSA::HierarchicalInit, 200);
+  compact_approx.seeding_by_number(CompactVSA::Hierarchical, 200);
   for (std::size_t i = 0; i < 30; ++i)
     compact_approx.run_one_step();
 

Surface_mesh_approximation/include/CGAL/VSA_approximation.h

@@ -47,29 +47,29 @@ class VSA_approximation {
 // public typedefs
 public:
   // Default typdefs
-  /// GeomTraits typdef
+  /// Geometric trait type
   typedef typename CGAL::Default::Get<
     GeomTraits_,
     typename Kernel_traits<
       typename boost::property_traits<VertexPointMap>::value_type
     >::Kernel >::type GeomTraits;
-  /// ErrorMetric typdef
+  /// ErrorMetric type
   typedef typename CGAL::Default::Get<ErrorMetric_,
     CGAL::L21Metric<TriangleMesh, VertexPointMap, GeomTraits> >::type ErrorMetric;
-  /// ProxyFitting typdef
+  /// ProxyFitting type
   typedef typename CGAL::Default::Get<ProxyFitting_,
     CGAL::L21ProxyFitting<TriangleMesh, VertexPointMap, GeomTraits> >::type ProxyFitting;
-  /// Proxy typdef
+  /// Proxy type
   typedef typename ErrorMetric::Proxy Proxy;
 
   /// Seeding method enumeration
-  enum Initialization {
-    /// Random initialization
-    RandomInit,
-    /// Incremental initialization
-    IncrementalInit,
-    /// Hierarchical initialization
-    HierarchicalInit
+  enum Method {
+    /// Random seeding
+    Random,
+    /// Incremental seeding
+    Incremental,
+    /// Hierarchical seeding
+    Hierarchical
   };
 
 // private typedefs and data member
@@ -318,15 +318,15 @@ class VSA_approximation {
    * @return number of proxies initialized
    */
   std::size_t seeding_by_number(
-    const Initialization method,
+    const Method method,
     const std::size_t num_seed,
     const std::size_t num_iterations = 5) {
     switch (method) {
-      case RandomInit:
+      case Random:
         return seed_random(num_seed);
-      case IncrementalInit:
+      case Incremental:
         return seed_incremental(num_seed, num_iterations);
-      case HierarchicalInit:
+      case Hierarchical:
         return seed_hierarchical(num_seed, num_iterations);
       default:
         return 0;
@@ -341,15 +341,15 @@ class VSA_approximation {
    * @return number of proxies initialized
    */
   std::size_t seeding_by_error(
-    const Initialization method,
+    const Method method,
     const FT target_drop,
     const std::size_t num_iterations = 5) {
     switch (method) {
-      case RandomInit:
+      case Random:
         return seed_error_random(target_drop, num_iterations);
-      case IncrementalInit:
+      case Incremental:
         return seed_error_incremental(target_drop, num_iterations);
-      case HierarchicalInit:
+      case Hierarchical:
         return seed_error_hierarchical(target_drop, num_iterations);
       default:
         return 0;

Surface_mesh_approximation/include/CGAL/vsa_mesh_approximation.h

@@ -94,7 +94,7 @@ bool vsa_mesh_approximation(const TriangleMesh &tm_in,
 
   int init = choose_param(get_param(np, internal_np::init_method), 0);
   vsa_l21.seeding_by_number(
-    static_cast<typename VSAL21::Initialization>(init), num_proxies, 5);
+    static_cast<typename VSAL21::Method>(init), num_proxies, 5);
   for (std::size_t i = 0; i < num_iterations; ++i)
     vsa_l21.run_one_step();
 

Surface_mesh_approximation/test/Surface_mesh_approximation/vsa_class_interface_test.cpp

@@ -53,7 +53,7 @@ int main()
 
   // random init and run
   std::cout << "random init and run" << std::endl;
-  l2_approx.seeding_by_number(L2VSA::RandomInit, 10);
+  l2_approx.seeding_by_number(L2VSA::Random, 10);
   for (std::size_t i = 0; i < 10; ++i)
     l2_approx.run_one_step();
   if (l2_approx.get_proxies_size() != 10)
@@ -124,7 +124,7 @@ int main()
   l2_approx.rebuild();
   if (l2_approx.get_proxies_size() != 0)
     return EXIT_FAILURE;
-  l2_approx.seeding_by_error(L2VSA::HierarchicalInit, drop, iterations);
+  l2_approx.seeding_by_error(L2VSA::Hierarchical, drop, iterations);
   for (std::size_t i = 0; i < 10; ++i)
     l2_approx.run_one_step();
   std::cout << "#proxies " << l2_approx.get_proxies_size() << std::endl;
@@ -133,7 +133,7 @@ int main()
   l2_approx.rebuild();
   if (l2_approx.get_proxies_size() != 0)
     return EXIT_FAILURE;
-  l2_approx.seeding_by_error(L2VSA::IncrementalInit, drop, iterations);
+  l2_approx.seeding_by_error(L2VSA::Incremental, drop, iterations);
   for (std::size_t i = 0; i < 10; ++i)
     l2_approx.run_one_step();
   std::cout << "#proxies " << l2_approx.get_proxies_size() << std::endl;

Surface_mesh_approximation/test/Surface_mesh_approximation/vsa_correctness_test.cpp

@@ -39,7 +39,7 @@ bool test_shape(const char *file_name, const std::size_t target_num_proxies)
   const FT drop(1e-8);
   const std::size_t num_iterations = 20;
   const std::size_t inner_iterations = 10;
-  vsa_l21.seeding_by_error(L21VSA::IncrementalInit, drop, inner_iterations);
+  vsa_l21.seeding_by_error(L21VSA::Incremental, drop, inner_iterations);
   for (std::size_t i = 0; i < num_iterations; ++i)
     vsa_l21.run_one_step();
   if (vsa_l21.get_proxies_size() != target_num_proxies) {

Surface_mesh_approximation/test/Surface_mesh_approximation/vsa_error_decrease_test.cpp

@@ -51,7 +51,7 @@ int main()
   L21ProxyFitting l21_fitting(mesh);
   vsa_l21.set_metric(l21_metric, l21_fitting);
 
-  vsa_l21.seeding_by_number(L21VSA::RandomInit, 100);
+  vsa_l21.seeding_by_number(L21VSA::Random, 100);
   std::vector<FT> error;
   for (std::size_t i = 0; i < 30; ++i)
     error.push_back(vsa_l21.run_one_step());

Surface_mesh_approximation/test/Surface_mesh_approximation/vsa_metric_test.cpp

@@ -99,7 +99,7 @@ int main()
   compact_approx.set_metric(metric, proxy_fitting);
 
   std::cout << "random init and run" << std::endl;
-  compact_approx.seeding_by_number(CompactVSA::RandomInit, 20);
+  compact_approx.seeding_by_number(CompactVSA::Random, 20);
   for (std::size_t i = 0; i < 20; ++i)
     compact_approx.run_one_step();
   if (compact_approx.get_proxies_size() != 20)