From bcb59d7db42dc45cd89172c7fc9e30aa6b94c64b Mon Sep 17 00:00:00 2001 From: Lingjie Zhu Date: Mon, 28 Aug 2017 19:05:48 +0800 Subject: [PATCH] rearrange seeding by number --- .../vsa_timing_benchmark.cpp | 15 +- .../vsa_class_interface_example.cpp | 2 +- .../vsa_metric_example.cpp | 2 +- .../include/CGAL/VSA_approximation.h | 163 ++++++++++-------- .../include/CGAL/vsa_mesh_approximation.h | 18 +- .../vsa_class_interface_test.cpp | 2 +- .../vsa_error_decrease_test.cpp | 2 +- .../vsa_metric_test.cpp | 2 +- 8 files changed, 103 insertions(+), 103 deletions(-) diff --git a/Surface_mesh_approximation/benchmark/Surface_mesh_approximation/vsa_timing_benchmark.cpp b/Surface_mesh_approximation/benchmark/Surface_mesh_approximation/vsa_timing_benchmark.cpp index 363c79278fc..61502e00996 100644 --- a/Surface_mesh_approximation/benchmark/Surface_mesh_approximation/vsa_timing_benchmark.cpp +++ b/Surface_mesh_approximation/benchmark/Surface_mesh_approximation/vsa_timing_benchmark.cpp @@ -64,19 +64,8 @@ int main(int argc, char *argv[]) std::cerr << "start initialization" << std::endl; t0.reset(); t0.start(); - switch(init) { - case 0: - l21_vsa.seed_random(num_proxies); - break; - case 1: - l21_vsa.seed_incremental(num_proxies, 5); - break; - case 2: - l21_vsa.seed_hierarchical(num_proxies, 5); - break; - default: - return 1; - } + l21_vsa.seeding_by_number( + static_cast(init), num_proxies); t0.stop(); std::cerr << "initialization time " << t0.time() << " sec." << std::endl; diff --git a/Surface_mesh_approximation/examples/Surface_mesh_approximation/vsa_class_interface_example.cpp b/Surface_mesh_approximation/examples/Surface_mesh_approximation/vsa_class_interface_example.cpp index 09ca7ee24a1..97ec4c0e720 100644 --- a/Surface_mesh_approximation/examples/Surface_mesh_approximation/vsa_class_interface_example.cpp +++ b/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.seed_random(100); + l21_approx.seeding_by_number(L21VSA::RandomInit, 100); // run the iteration to minimize the error for (std::size_t i = 0; i < 30; ++i) diff --git a/Surface_mesh_approximation/examples/Surface_mesh_approximation/vsa_metric_example.cpp b/Surface_mesh_approximation/examples/Surface_mesh_approximation/vsa_metric_example.cpp index ec0fb35114d..910957e6a5f 100644 --- a/Surface_mesh_approximation/examples/Surface_mesh_approximation/vsa_metric_example.cpp +++ b/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.seed_hierarchical(200, 5); + compact_approx.seeding_by_number(CompactVSA::HierarchicalInit, 200); for (std::size_t i = 0; i < 30; ++i) compact_approx.run_one_step(); diff --git a/Surface_mesh_approximation/include/CGAL/VSA_approximation.h b/Surface_mesh_approximation/include/CGAL/VSA_approximation.h index 902b2e1d6c9..5c984eecaac 100644 --- a/Surface_mesh_approximation/include/CGAL/VSA_approximation.h +++ b/Surface_mesh_approximation/include/CGAL/VSA_approximation.h @@ -310,81 +310,26 @@ public: } /*! - * @brief Random initialize proxies. - * @param num_seed number of proxies seed - * @return number of proxies initialized - */ - std::size_t seed_random(const std::size_t num_seed) { - proxies.clear(); - if (num_faces(*m_pmesh) < num_seed) - return 0; - - const std::size_t interval = num_faces(*m_pmesh) / num_seed; - std::size_t index = 0; - BOOST_FOREACH(face_descriptor f, faces(*m_pmesh)) { - if ((index++) % interval == 0) { - proxies.push_back(fit_new_proxy(f)); - } - if (proxies.size() >= num_seed) - break; - } - return proxies.size(); - } - - /*! - * @brief Incremental initialize proxies. - * @param num_seed number of proxies seed + * @brief Seeding by targeted number of proxies. + * @param method seeding method + * @param num_seed target number of proxies seed * @param num_iterations number of iterations of coarse re-fitting - * before each incremental proxy insertion * @return number of proxies initialized */ - std::size_t seed_incremental(const std::size_t num_seed, + std::size_t seeding_by_number( + const Initialization method, + const std::size_t num_seed, const std::size_t num_iterations = 5) { - proxies.clear(); - if (num_faces(*m_pmesh) < num_seed) - return 0; - - // initialize a proxy and the proxy map to prepare for the insertion - proxies.push_back(fit_new_proxy(*(faces(*m_pmesh).first))); - BOOST_FOREACH(face_descriptor f, faces(*m_pmesh)) - fproxy_map[f] = 0; - - insert_proxy_furthest(num_seed - 1, num_iterations); - return proxies.size(); - } - - /*! - * @brief Hierarchical initialize proxies. - * @param num_seed number of proxies seed - * @param num_iterations number of iterations of coarse re-fitting - * before each hierarchical proxy insertion - * @return number of proxies initialized - */ - std::size_t seed_hierarchical(const std::size_t num_seed, - const std::size_t num_iterations = 5) { - proxies.clear(); - if (num_faces(*m_pmesh) < num_seed) - return 0; - - // initialize 2 proxy - typename boost::graph_traits::face_iterator - fitr = faces(*m_pmesh).first; - proxies.push_back(fit_new_proxy(*fitr)); - proxies.push_back(fit_new_proxy(*(++fitr))); - - while (proxies.size() < num_seed) { - for (std::size_t i = 0; i < num_iterations; ++i) { - partition(); - fit(); - } - - // add proxies by error diffusion - const std::size_t num_proxies = proxies.size(); - const std::size_t num_proxies_to_be_added = - (num_proxies * 2 < num_seed) ? num_proxies : (num_seed - num_proxies); - insert_proxy_hierarchical(num_proxies_to_be_added); + switch (method) { + case RandomInit: + return seed_random(num_seed); + case IncrementalInit: + return seed_incremental(num_seed, num_iterations); + case HierarchicalInit: + return seed_hierarchical(num_seed, num_iterations); + default: + return 0; } - return proxies.size(); } /*! @@ -862,6 +807,84 @@ public: // private member functions private: + /*! + * @brief Random initialize proxies. + * @param num_seed number of proxies seed + * @return number of proxies initialized + */ + std::size_t seed_random(const std::size_t num_seed) { + proxies.clear(); + if (num_faces(*m_pmesh) < num_seed) + return 0; + + const std::size_t interval = num_faces(*m_pmesh) / num_seed; + std::size_t index = 0; + BOOST_FOREACH(face_descriptor f, faces(*m_pmesh)) { + if ((index++) % interval == 0) { + proxies.push_back(fit_new_proxy(f)); + } + if (proxies.size() >= num_seed) + break; + } + return proxies.size(); + } + + /*! + * @brief Incremental initialize proxies. + * @param num_seed number of proxies seed + * @param num_iterations number of iterations of coarse re-fitting + * before each incremental proxy insertion + * @return number of proxies initialized + */ + std::size_t seed_incremental(const std::size_t num_seed, + const std::size_t num_iterations = 5) { + proxies.clear(); + if (num_faces(*m_pmesh) < num_seed) + return 0; + + // initialize a proxy and the proxy map to prepare for the insertion + proxies.push_back(fit_new_proxy(*(faces(*m_pmesh).first))); + BOOST_FOREACH(face_descriptor f, faces(*m_pmesh)) + fproxy_map[f] = 0; + + insert_proxy_furthest(num_seed - 1, num_iterations); + return proxies.size(); + } + + /*! + * @brief Hierarchical initialize proxies. + * @param num_seed number of proxies seed + * @param num_iterations number of iterations of coarse re-fitting + * before each hierarchical proxy insertion + * @return number of proxies initialized + */ + std::size_t seed_hierarchical(const std::size_t num_seed, + const std::size_t num_iterations = 5) { + proxies.clear(); + if (num_faces(*m_pmesh) < num_seed) + return 0; + + // initialize 2 proxy + typename boost::graph_traits::face_iterator + fitr = faces(*m_pmesh).first; + proxies.push_back(fit_new_proxy(*fitr)); + proxies.push_back(fit_new_proxy(*(++fitr))); + + while (proxies.size() < num_seed) { + for (std::size_t i = 0; i < num_iterations; ++i) { + partition(); + fit(); + } + + // add proxies by error diffusion + const std::size_t num_proxies = proxies.size(); + const std::size_t num_proxies_to_be_added = + (num_proxies * 2 < num_seed) ? num_proxies : (num_seed - num_proxies); + insert_proxy_hierarchical(num_proxies_to_be_added); + } + return proxies.size(); + } + /*! * @brief Initialize by targeted error drop. * @param target_drop targeted error drop to initial state, usually in range (0, 1) diff --git a/Surface_mesh_approximation/include/CGAL/vsa_mesh_approximation.h b/Surface_mesh_approximation/include/CGAL/vsa_mesh_approximation.h index 284160a58e0..016cb6a9709 100644 --- a/Surface_mesh_approximation/include/CGAL/vsa_mesh_approximation.h +++ b/Surface_mesh_approximation/include/CGAL/vsa_mesh_approximation.h @@ -92,21 +92,9 @@ bool vsa_mesh_approximation(const TriangleMesh &tm_in, std::size_t num_iterations = choose_param(get_param(np, internal_np::number_of_iterations), 10); std::cout << "#px = " << num_proxies << ", #itr = " << num_iterations << std::endl; - std::size_t init = choose_param(get_param(np, internal_np::init_method), 0); - switch (static_cast(init)) { - case VSAL21::RandomInit: - vsa_l21.seed_random(num_proxies); - break; - case VSAL21::IncrementalInit: - vsa_l21.seed_incremental(num_proxies, 5); - break; - case VSAL21::HierarchicalInit: - vsa_l21.seed_hierarchical(num_proxies, 5); - break; - default: - std::cout << "Error: invalid initialization method parameter." << std::endl; - return false; - } + int init = choose_param(get_param(np, internal_np::init_method), 0); + vsa_l21.seeding_by_number( + static_cast(init), num_proxies, 5); for (std::size_t i = 0; i < num_iterations; ++i) vsa_l21.run_one_step(); diff --git a/Surface_mesh_approximation/test/Surface_mesh_approximation/vsa_class_interface_test.cpp b/Surface_mesh_approximation/test/Surface_mesh_approximation/vsa_class_interface_test.cpp index 92ff1e3e4e6..d00005090ca 100644 --- a/Surface_mesh_approximation/test/Surface_mesh_approximation/vsa_class_interface_test.cpp +++ b/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.seed_random(10); + l2_approx.seeding_by_number(L2VSA::RandomInit, 10); for (std::size_t i = 0; i < 10; ++i) l2_approx.run_one_step(); if (l2_approx.get_proxies_size() != 10) diff --git a/Surface_mesh_approximation/test/Surface_mesh_approximation/vsa_error_decrease_test.cpp b/Surface_mesh_approximation/test/Surface_mesh_approximation/vsa_error_decrease_test.cpp index bc0208c6cd1..cf7e145e636 100644 --- a/Surface_mesh_approximation/test/Surface_mesh_approximation/vsa_error_decrease_test.cpp +++ b/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.seed_random(100); + vsa_l21.seeding_by_number(L21VSA::RandomInit, 100); std::vector error; for (std::size_t i = 0; i < 30; ++i) error.push_back(vsa_l21.run_one_step()); diff --git a/Surface_mesh_approximation/test/Surface_mesh_approximation/vsa_metric_test.cpp b/Surface_mesh_approximation/test/Surface_mesh_approximation/vsa_metric_test.cpp index f6b401b630e..2d250c8a7a6 100644 --- a/Surface_mesh_approximation/test/Surface_mesh_approximation/vsa_metric_test.cpp +++ b/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.seed_random(20); + compact_approx.seeding_by_number(CompactVSA::RandomInit, 20); for (std::size_t i = 0; i < 20; ++i) compact_approx.run_one_step(); if (compact_approx.get_proxies_size() != 20)