From 7afd5cfa01045e52f2b69935b61418beee19f2db Mon Sep 17 00:00:00 2001 From: vrouvrea Date: Thu, 13 Oct 2016 08:25:56 +0000 Subject: Fix cpplint git-svn-id: svn+ssh://scm.gforge.inria.fr/svnroot/gudhi/trunk@1725 636b058d-ea47-450e-bf9e-a15bfbe3eedb Former-commit-id: d56056e39c28b013ef71b87aae055502bd86314e --- src/Alpha_complex/include/gudhi/Alpha_complex.h | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'src/Alpha_complex') diff --git a/src/Alpha_complex/include/gudhi/Alpha_complex.h b/src/Alpha_complex/include/gudhi/Alpha_complex.h index f2a222c1..1ce6267d 100644 --- a/src/Alpha_complex/include/gudhi/Alpha_complex.h +++ b/src/Alpha_complex/include/gudhi/Alpha_complex.h @@ -191,7 +191,7 @@ class Alpha_complex { typedef boost::iterator_property_map::iterator, CGAL::Identity_property_map> Point_property_map; typedef CGAL::Spatial_sort_traits_adapter_d Search_traits_d; - + CGAL::spatial_sort(indices.begin(), indices.end(), Search_traits_d(std::begin(point_cloud))); typename Delaunay_triangulation::Full_cell_handle hint; -- cgit v1.2.3 From b024f27b957920fc59375b0accc521855782248a Mon Sep 17 00:00:00 2001 From: vrouvrea Date: Thu, 13 Oct 2016 15:15:37 +0000 Subject: This test fails on Win 32 and 64 git-svn-id: svn+ssh://scm.gforge.inria.fr/svnroot/gudhi/trunk@1726 636b058d-ea47-450e-bf9e-a15bfbe3eedb Former-commit-id: 3f5820af954fb6185d938b3e67bc533954b41f7f --- src/Alpha_complex/test/Alpha_complex_unit_test.cpp | 3 +++ 1 file changed, 3 insertions(+) (limited to 'src/Alpha_complex') diff --git a/src/Alpha_complex/test/Alpha_complex_unit_test.cpp b/src/Alpha_complex/test/Alpha_complex_unit_test.cpp index fc53eeeb..c3be0715 100644 --- a/src/Alpha_complex/test/Alpha_complex_unit_test.cpp +++ b/src/Alpha_complex/test/Alpha_complex_unit_test.cpp @@ -236,6 +236,8 @@ BOOST_AUTO_TEST_CASE(Alpha_complex_from_points) { } +// This test crashes on Windows (32 and 64)) +#ifndef _WIN32 BOOST_AUTO_TEST_CASE(Alpha_complex_from_empty_points) { // ---------------------------------------------------------------------------- // Init of a list of points @@ -264,3 +266,4 @@ BOOST_AUTO_TEST_CASE(Alpha_complex_from_empty_points) { // Test to the limit BOOST_CHECK_THROW (alpha_complex_from_points.get_point(0), std::out_of_range); } +#endif -- cgit v1.2.3 From 1839d09009b10ce3c62770e082a4d7816d991e14 Mon Sep 17 00:00:00 2001 From: vrouvrea Date: Fri, 14 Oct 2016 08:51:18 +0000 Subject: Fix Alpha complex UT for limit case git-svn-id: svn+ssh://scm.gforge.inria.fr/svnroot/gudhi/trunk@1727 636b058d-ea47-450e-bf9e-a15bfbe3eedb Former-commit-id: 2c5c93e0a4d78fc2441de966aebac72ba9419da8 --- src/Alpha_complex/include/gudhi/Alpha_complex.h | 82 ++++++++++++---------- src/Alpha_complex/test/Alpha_complex_unit_test.cpp | 79 +++++++++++++-------- 2 files changed, 94 insertions(+), 67 deletions(-) (limited to 'src/Alpha_complex') diff --git a/src/Alpha_complex/include/gudhi/Alpha_complex.h b/src/Alpha_complex/include/gudhi/Alpha_complex.h index 1ce6267d..9d5a9bad 100644 --- a/src/Alpha_complex/include/gudhi/Alpha_complex.h +++ b/src/Alpha_complex/include/gudhi/Alpha_complex.h @@ -171,35 +171,58 @@ class Alpha_complex { return vertex_handle_to_iterator_.at(vertex)->point(); } + /** \brief number_of_vertices returns the number of vertices (same as the number of points). + * + * @return The number of vertices. + */ + const std::size_t number_of_vertices() const { + return vertex_handle_to_iterator_.size(); + } + private: template void init_from_range(const InputPointRange& points) { auto first = std::begin(points); auto last = std::end(points); - // point_dimension function initialization - Point_Dimension point_dimension = kernel_.point_dimension_d_object(); - - // Delaunay triangulation is point dimension. - triangulation_ = new Delaunay_triangulation(point_dimension(*first)); - - std::vector point_cloud(first, last); - // Creates a vector {0, 1, ..., N-1} - std::vector indices(boost::counting_iterator(0), - boost::counting_iterator(point_cloud.size())); - - typedef boost::iterator_property_map::iterator, - CGAL::Identity_property_map> Point_property_map; - typedef CGAL::Spatial_sort_traits_adapter_d Search_traits_d; - - CGAL::spatial_sort(indices.begin(), indices.end(), Search_traits_d(std::begin(point_cloud))); - - typename Delaunay_triangulation::Full_cell_handle hint; - for (auto index : indices) { - typename Delaunay_triangulation::Vertex_handle pos = triangulation_->insert(point_cloud[index], hint); - // Save index value as data to retrieve it after insertion - pos->data() = index; - hint = pos->full_cell(); + if (first != last) { + // point_dimension function initialization + Point_Dimension point_dimension = kernel_.point_dimension_d_object(); + + // Delaunay triangulation is point dimension. + triangulation_ = new Delaunay_triangulation(point_dimension(*first)); + + std::vector point_cloud(first, last); + + // Creates a vector {0, 1, ..., N-1} + std::vector indices(boost::counting_iterator(0), + boost::counting_iterator(point_cloud.size())); + + typedef boost::iterator_property_map::iterator, + CGAL::Identity_property_map> Point_property_map; + typedef CGAL::Spatial_sort_traits_adapter_d Search_traits_d; + + CGAL::spatial_sort(indices.begin(), indices.end(), Search_traits_d(std::begin(point_cloud))); + + typename Delaunay_triangulation::Full_cell_handle hint; + for (auto index : indices) { + typename Delaunay_triangulation::Vertex_handle pos = triangulation_->insert(point_cloud[index], hint); + // Save index value as data to retrieve it after insertion + pos->data() = index; + hint = pos->full_cell(); + } + // -------------------------------------------------------------------------------------------- + // double map to retrieve simplex tree vertex handles from CGAL vertex iterator and vice versa + // Loop on triangulation vertices list + for (CGAL_vertex_iterator vit = triangulation_->vertices_begin(); vit != triangulation_->vertices_end(); ++vit) { + if (!triangulation_->is_infinite(*vit)) { +#ifdef DEBUG_TRACES + std::cout << "Vertex insertion - " << vit->data() << " -> " << vit->point() << std::endl; +#endif // DEBUG_TRACES + vertex_handle_to_iterator_.emplace(vit->data(), vit); + } + } + // -------------------------------------------------------------------------------------------- } } @@ -247,19 +270,6 @@ class Alpha_complex { complex.set_dimension(triangulation_->maximal_dimension()); - // -------------------------------------------------------------------------------------------- - // double map to retrieve simplex tree vertex handles from CGAL vertex iterator and vice versa - // Loop on triangulation vertices list - for (CGAL_vertex_iterator vit = triangulation_->vertices_begin(); vit != triangulation_->vertices_end(); ++vit) { - if (!triangulation_->is_infinite(*vit)) { -#ifdef DEBUG_TRACES - std::cout << "Vertex insertion - " << vit->data() << " -> " << vit->point() << std::endl; -#endif // DEBUG_TRACES - vertex_handle_to_iterator_.emplace(vit->data(), vit); - } - } - // -------------------------------------------------------------------------------------------- - // -------------------------------------------------------------------------------------------- // Simplex_tree construction from loop on triangulation finite full cells list if (triangulation_->number_of_vertices() > 0) { diff --git a/src/Alpha_complex/test/Alpha_complex_unit_test.cpp b/src/Alpha_complex/test/Alpha_complex_unit_test.cpp index c3be0715..7380547f 100644 --- a/src/Alpha_complex/test/Alpha_complex_unit_test.cpp +++ b/src/Alpha_complex/test/Alpha_complex_unit_test.cpp @@ -36,12 +36,17 @@ // to construct a simplex_tree from Delaunay_triangulation #include #include +#include // Use dynamic_dimension_tag for the user to be able to set dimension typedef CGAL::Epick_d< CGAL::Dynamic_dimension_tag > Kernel_d; +// Use static dimension_tag for the user not to be able to set dimension +typedef CGAL::Epick_d< CGAL::Dimension_tag<2> > Kernel_s; // The triangulation uses the default instantiation of the TriangulationDataStructure template parameter -BOOST_AUTO_TEST_CASE(ALPHA_DOC_OFF_file) { +typedef boost::mpl::list list_of_kernel_variants; + +BOOST_AUTO_TEST_CASE_TEMPLATE(Alpha_complex_from_OFF_file, TestedKernel, list_of_kernel_variants) { // ---------------------------------------------------------------------------- // // Init of an alpha-complex from a OFF file @@ -52,7 +57,11 @@ BOOST_AUTO_TEST_CASE(ALPHA_DOC_OFF_file) { std::cout << "========== OFF FILE NAME = " << off_file_name << " - alpha²=" << max_alpha_square_value << "==========" << std::endl; - Gudhi::alpha_complex::Alpha_complex alpha_complex_from_file(off_file_name); + Gudhi::alpha_complex::Alpha_complex alpha_complex_from_file(off_file_name); + + std::cout << "alpha_complex_from_points.number_of_vertices()=" << alpha_complex_from_file.number_of_vertices() + << std::endl; + BOOST_CHECK(alpha_complex_from_file.number_of_vertices() == 7); Gudhi::Simplex_tree<> simplex_tree_60; BOOST_CHECK(alpha_complex_from_file.create_complex(simplex_tree_60, max_alpha_square_value)); @@ -60,6 +69,10 @@ BOOST_AUTO_TEST_CASE(ALPHA_DOC_OFF_file) { std::cout << "simplex_tree_60.dimension()=" << simplex_tree_60.dimension() << std::endl; BOOST_CHECK(simplex_tree_60.dimension() == 2); + std::cout << "alpha_complex_from_points.number_of_vertices()=" << alpha_complex_from_file.number_of_vertices() + << std::endl; + BOOST_CHECK(alpha_complex_from_file.number_of_vertices() == 7); + std::cout << "simplex_tree_60.num_vertices()=" << simplex_tree_60.num_vertices() << std::endl; BOOST_CHECK(simplex_tree_60.num_vertices() == 7); @@ -87,13 +100,12 @@ bool are_almost_the_same(float a, float b) { return std::fabs(a - b) < std::numeric_limits::epsilon(); } -// Use dynamic_dimension_tag for the user to be able to set dimension -typedef CGAL::Epick_d< CGAL::Dimension_tag<4> > Kernel_s; -typedef Kernel_s::Point_d Point; -typedef std::vector Vector_of_points; - +// Use static dimension_tag for the user not to be able to set dimension +typedef CGAL::Epick_d< CGAL::Dimension_tag<4> > Kernel_4; +typedef Kernel_4::Point_d Point_4; +typedef std::vector Vector_4_Points; -bool is_point_in_list(Vector_of_points points_list, Point point) { +bool is_point_in_list(Vector_4_Points points_list, Point_4 point) { for (auto& point_in_list : points_list) { if (point_in_list == point) { return true; // point found @@ -106,26 +118,30 @@ BOOST_AUTO_TEST_CASE(Alpha_complex_from_points) { // ---------------------------------------------------------------------------- // Init of a list of points // ---------------------------------------------------------------------------- - Vector_of_points points; + Vector_4_Points points; std::vector coords = { 0.0, 0.0, 0.0, 1.0 }; - points.push_back(Point(coords.begin(), coords.end())); + points.push_back(Point_4(coords.begin(), coords.end())); coords = { 0.0, 0.0, 1.0, 0.0 }; - points.push_back(Point(coords.begin(), coords.end())); + points.push_back(Point_4(coords.begin(), coords.end())); coords = { 0.0, 1.0, 0.0, 0.0 }; - points.push_back(Point(coords.begin(), coords.end())); + points.push_back(Point_4(coords.begin(), coords.end())); coords = { 1.0, 0.0, 0.0, 0.0 }; - points.push_back(Point(coords.begin(), coords.end())); + points.push_back(Point_4(coords.begin(), coords.end())); // ---------------------------------------------------------------------------- // Init of an alpha complex from the list of points // ---------------------------------------------------------------------------- - Gudhi::alpha_complex::Alpha_complex alpha_complex_from_points(points); + Gudhi::alpha_complex::Alpha_complex alpha_complex_from_points(points); std::cout << "========== Alpha_complex_from_points ==========" << std::endl; Gudhi::Simplex_tree<> simplex_tree; BOOST_CHECK(alpha_complex_from_points.create_complex(simplex_tree)); + std::cout << "alpha_complex_from_points.number_of_vertices()=" << alpha_complex_from_points.number_of_vertices() + << std::endl; + BOOST_CHECK(alpha_complex_from_points.number_of_vertices() == points.size()); + // Another way to check num_simplices std::cout << "Iterator on alpha complex simplices in the filtration order, with [filtration value]:" << std::endl; int num_simplices = 0; @@ -167,22 +183,22 @@ BOOST_AUTO_TEST_CASE(Alpha_complex_from_points) { } } - Point p0 = alpha_complex_from_points.get_point(0); + Point_4 p0 = alpha_complex_from_points.get_point(0); std::cout << "alpha_complex_from_points.get_point(0)=" << p0 << std::endl; BOOST_CHECK(4 == p0.dimension()); BOOST_CHECK(is_point_in_list(points, p0)); - Point p1 = alpha_complex_from_points.get_point(1); + Point_4 p1 = alpha_complex_from_points.get_point(1); std::cout << "alpha_complex_from_points.get_point(1)=" << p1 << std::endl; BOOST_CHECK(4 == p1.dimension()); BOOST_CHECK(is_point_in_list(points, p1)); - Point p2 = alpha_complex_from_points.get_point(2); + Point_4 p2 = alpha_complex_from_points.get_point(2); std::cout << "alpha_complex_from_points.get_point(2)=" << p2 << std::endl; BOOST_CHECK(4 == p2.dimension()); BOOST_CHECK(is_point_in_list(points, p2)); - Point p3 = alpha_complex_from_points.get_point(3); + Point_4 p3 = alpha_complex_from_points.get_point(3); std::cout << "alpha_complex_from_points.get_point(3)=" << p3 << std::endl; BOOST_CHECK(4 == p3.dimension()); BOOST_CHECK(is_point_in_list(points, p3)); @@ -236,34 +252,35 @@ BOOST_AUTO_TEST_CASE(Alpha_complex_from_points) { } -// This test crashes on Windows (32 and 64)) -#ifndef _WIN32 -BOOST_AUTO_TEST_CASE(Alpha_complex_from_empty_points) { +BOOST_AUTO_TEST_CASE_TEMPLATE(Alpha_complex_from_empty_points, TestedKernel, list_of_kernel_variants) { + std::cout << "========== Alpha_complex_from_empty_points ==========" << std::endl; + // ---------------------------------------------------------------------------- - // Init of a list of points + // Init of an empty list of points // ---------------------------------------------------------------------------- - Vector_of_points points; + std::vector points; // ---------------------------------------------------------------------------- // Init of an alpha complex from the list of points // ---------------------------------------------------------------------------- - Gudhi::alpha_complex::Alpha_complex alpha_complex_from_points(points); + Gudhi::alpha_complex::Alpha_complex alpha_complex_from_points(points); - std::cout << "========== Alpha_complex_from_empty_points ==========" << std::endl; + // Test to the limit + BOOST_CHECK_THROW (alpha_complex_from_points.get_point(0), std::out_of_range); Gudhi::Simplex_tree<> simplex_tree; - BOOST_CHECK(alpha_complex_from_points.create_complex(simplex_tree)); + BOOST_CHECK(!alpha_complex_from_points.create_complex(simplex_tree)); + std::cout << "alpha_complex_from_points.number_of_vertices()=" << alpha_complex_from_points.number_of_vertices() + << std::endl; + BOOST_CHECK(alpha_complex_from_points.number_of_vertices() == points.size()); + std::cout << "simplex_tree.num_simplices()=" << simplex_tree.num_simplices() << std::endl; BOOST_CHECK(simplex_tree.num_simplices() == 0); std::cout << "simplex_tree.dimension()=" << simplex_tree.dimension() << std::endl; - BOOST_CHECK(simplex_tree.dimension() == 4); + BOOST_CHECK(simplex_tree.dimension() == -1); std::cout << "simplex_tree.num_vertices()=" << simplex_tree.num_vertices() << std::endl; BOOST_CHECK(simplex_tree.num_vertices() == 0); - - // Test to the limit - BOOST_CHECK_THROW (alpha_complex_from_points.get_point(0), std::out_of_range); } -#endif -- cgit v1.2.3