Merge branch 'master' into wbary-theo

updating master in wbary-theo

6 files changed, 142 insertions, 57 deletions

diff --git a/src/Alpha_complex/test/Alpha_complex_3d_unit_test.cpp b/src/Alpha_complex/test/Alpha_complex_3d_unit_test.cpp
index 1102838a..cd698a27 100644
--- a/src/Alpha_complex/test/Alpha_complex_3d_unit_test.cpp
+++ b/src/Alpha_complex/test/Alpha_complex_3d_unit_test.cpp
@@ -56,21 +56,52 @@ BOOST_AUTO_TEST_CASE(Alpha_complex_3d_from_points) {
   // -----------------
   std::cout << "Fast alpha complex 3d" << std::endl;
 
-  Fast_alpha_complex_3d alpha_complex(get_points<Fast_alpha_complex_3d::Point_3>());
+  std::vector<Fast_alpha_complex_3d::Bare_point_3> points = get_points<Fast_alpha_complex_3d::Bare_point_3>();
+  Fast_alpha_complex_3d alpha_complex(points);
 
   Gudhi::Simplex_tree<> stree;
   alpha_complex.create_complex(stree);
 
+  for (std::size_t index = 0; index < points.size(); index++) {
+    bool found = false;
+    for (auto point : points) {
+      if (point == alpha_complex.get_point(index)) {
+        found = true;
+        break;
+      }
+    }
+    // Check all points from alpha complex are found in the input point cloud
+    BOOST_CHECK(found);
+  }
+  // Exception if we go out of range
+  BOOST_CHECK_THROW(alpha_complex.get_point(points.size()), std::out_of_range);
+
   // -----------------
   // Exact version
   // -----------------
   std::cout << "Exact alpha complex 3d" << std::endl;
 
-  Exact_alpha_complex_3d exact_alpha_complex(get_points<Exact_alpha_complex_3d::Point_3>());
+  std::vector<Exact_alpha_complex_3d::Bare_point_3> exact_points = get_points<Exact_alpha_complex_3d::Bare_point_3>();
+  Exact_alpha_complex_3d exact_alpha_complex(exact_points);
 
   Gudhi::Simplex_tree<> exact_stree;
   exact_alpha_complex.create_complex(exact_stree);
 
+  for (std::size_t index = 0; index < exact_points.size(); index++) {
+    bool found = false;
+    Exact_alpha_complex_3d::Bare_point_3 ap = exact_alpha_complex.get_point(index);
+    for (auto point : points) {
+      if ((point.x() == ap.x()) && (point.y() == ap.y()) && (point.z() == ap.z())) {
+        found = true;
+        break;
+      }
+    }
+    // Check all points from alpha complex are found in the input point cloud
+    BOOST_CHECK(found);
+  }
+  // Exception if we go out of range
+  BOOST_CHECK_THROW(exact_alpha_complex.get_point(exact_points.size()), std::out_of_range);
+
   // ---------------------
   // Compare both versions
   // ---------------------
@@ -110,11 +141,27 @@ BOOST_AUTO_TEST_CASE(Alpha_complex_3d_from_points) {
   // -----------------
   std::cout << "Safe alpha complex 3d" << std::endl;
 
-  Safe_alpha_complex_3d safe_alpha_complex(get_points<Safe_alpha_complex_3d::Point_3>());
+  std::vector<Safe_alpha_complex_3d::Bare_point_3> safe_points = get_points<Safe_alpha_complex_3d::Bare_point_3>();
+  Safe_alpha_complex_3d safe_alpha_complex(safe_points);
 
   Gudhi::Simplex_tree<> safe_stree;
   safe_alpha_complex.create_complex(safe_stree);
 
+  for (std::size_t index = 0; index < safe_points.size(); index++) {
+    bool found = false;
+    Safe_alpha_complex_3d::Bare_point_3 ap = safe_alpha_complex.get_point(index);
+    for (auto point : points) {
+      if ((point.x() == ap.x()) && (point.y() == ap.y()) && (point.z() == ap.z())) {
+        found = true;
+        break;
+      }
+    }
+    // Check all points from alpha complex are found in the input point cloud
+    BOOST_CHECK(found);
+  }
+  // Exception if we go out of range
+  BOOST_CHECK_THROW(safe_alpha_complex.get_point(safe_points.size()), std::out_of_range);
+
   // ---------------------
   // Compare both versions
   // ---------------------
diff --git a/src/Alpha_complex/test/Alpha_complex_unit_test.cpp b/src/Alpha_complex/test/Alpha_complex_unit_test.cpp
index 01e4cee3..40b3fe09 100644
--- a/src/Alpha_complex/test/Alpha_complex_unit_test.cpp
+++ b/src/Alpha_complex/test/Alpha_complex_unit_test.cpp
@@ -15,6 +15,7 @@
 
 #include <CGAL/Delaunay_triangulation.h>
 #include <CGAL/Epick_d.h>
+#include <CGAL/Epeck_d.h>
 
 #include <cmath>  // float comparison
 #include <limits>
@@ -28,12 +29,16 @@
 #include <gudhi/Unitary_tests_utils.h>
 
 // Use dynamic_dimension_tag for the user to be able to set dimension
-typedef CGAL::Epick_d< CGAL::Dynamic_dimension_tag > Kernel_d;
+typedef CGAL::Epeck_d< CGAL::Dynamic_dimension_tag > Exact_kernel_d;
 // Use static dimension_tag for the user not to be able to set dimension
-typedef CGAL::Epick_d< CGAL::Dimension_tag<3> > Kernel_s;
+typedef CGAL::Epeck_d< CGAL::Dimension_tag<3> > Exact_kernel_s;
+// Use dynamic_dimension_tag for the user to be able to set dimension
+typedef CGAL::Epick_d< CGAL::Dynamic_dimension_tag > Inexact_kernel_d;
+// Use static dimension_tag for the user not to be able to set dimension
+typedef CGAL::Epick_d< CGAL::Dimension_tag<3> > Inexact_kernel_s;
 // The triangulation uses the default instantiation of the TriangulationDataStructure template parameter
 
-typedef boost::mpl::list<Kernel_d, Kernel_s> list_of_kernel_variants;
+typedef boost::mpl::list<Exact_kernel_d, Exact_kernel_s, Inexact_kernel_d, Inexact_kernel_s> list_of_kernel_variants;
 
 BOOST_AUTO_TEST_CASE_TEMPLATE(Alpha_complex_from_OFF_file, TestedKernel, list_of_kernel_variants) {
   // ----------------------------------------------------------------------------
@@ -86,7 +91,7 @@ BOOST_AUTO_TEST_CASE_TEMPLATE(Alpha_complex_from_OFF_file, TestedKernel, list_of
 }
 
 // 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 CGAL::Epeck_d< CGAL::Dimension_tag<4> > Kernel_4;
 typedef Kernel_4::Point_d Point_4;
 typedef std::vector<Point_4> Vector_4_Points;
 
diff --git a/src/Alpha_complex/test/CMakeLists.txt b/src/Alpha_complex/test/CMakeLists.txt
index ad5b6314..0476c6d4 100644
--- a/src/Alpha_complex/test/CMakeLists.txt
+++ b/src/Alpha_complex/test/CMakeLists.txt
@@ -1,27 +1,27 @@
 project(Alpha_complex_tests)
 
-include(GUDHI_test_coverage)
+include(GUDHI_boost_test)
 if (NOT CGAL_WITH_EIGEN3_VERSION VERSION_LESS 4.11.0)
 
   # Do not forget to copy test files in current binary dir
   file(COPY "${CMAKE_SOURCE_DIR}/data/points/alphacomplexdoc.off" DESTINATION ${CMAKE_CURRENT_BINARY_DIR}/)
 
   add_executable ( Alpha_complex_test_unit Alpha_complex_unit_test.cpp )
-  target_link_libraries(Alpha_complex_test_unit ${CGAL_LIBRARY} ${Boost_UNIT_TEST_FRAMEWORK_LIBRARY})
+  target_link_libraries(Alpha_complex_test_unit ${CGAL_LIBRARY})
   if (TBB_FOUND)
     target_link_libraries(Alpha_complex_test_unit ${TBB_LIBRARIES})
   endif()
 
-  gudhi_add_coverage_test(Alpha_complex_test_unit)
+  gudhi_add_boost_test(Alpha_complex_test_unit)
 
   add_executable ( Alpha_complex_3d_test_unit Alpha_complex_3d_unit_test.cpp )
-  target_link_libraries(Alpha_complex_3d_test_unit ${CGAL_LIBRARY} ${Boost_UNIT_TEST_FRAMEWORK_LIBRARY})
+  target_link_libraries(Alpha_complex_3d_test_unit ${CGAL_LIBRARY})
   add_executable ( Weighted_alpha_complex_3d_test_unit Weighted_alpha_complex_3d_unit_test.cpp )
-  target_link_libraries(Weighted_alpha_complex_3d_test_unit ${CGAL_LIBRARY} ${Boost_UNIT_TEST_FRAMEWORK_LIBRARY})
+  target_link_libraries(Weighted_alpha_complex_3d_test_unit ${CGAL_LIBRARY})
   add_executable ( Periodic_alpha_complex_3d_test_unit Periodic_alpha_complex_3d_unit_test.cpp )
-  target_link_libraries(Periodic_alpha_complex_3d_test_unit ${CGAL_LIBRARY} ${Boost_UNIT_TEST_FRAMEWORK_LIBRARY})
+  target_link_libraries(Periodic_alpha_complex_3d_test_unit ${CGAL_LIBRARY})
   add_executable ( Weighted_periodic_alpha_complex_3d_test_unit Weighted_periodic_alpha_complex_3d_unit_test.cpp )
-  target_link_libraries(Weighted_periodic_alpha_complex_3d_test_unit ${CGAL_LIBRARY} ${Boost_UNIT_TEST_FRAMEWORK_LIBRARY})
+  target_link_libraries(Weighted_periodic_alpha_complex_3d_test_unit ${CGAL_LIBRARY})
   if (TBB_FOUND)
     target_link_libraries(Alpha_complex_3d_test_unit ${TBB_LIBRARIES})
     target_link_libraries(Weighted_alpha_complex_3d_test_unit ${TBB_LIBRARIES})
@@ -29,9 +29,9 @@ if (NOT CGAL_WITH_EIGEN3_VERSION VERSION_LESS 4.11.0)
     target_link_libraries(Weighted_periodic_alpha_complex_3d_test_unit ${TBB_LIBRARIES})
   endif()
 
-  gudhi_add_coverage_test(Alpha_complex_3d_test_unit)
-  gudhi_add_coverage_test(Weighted_alpha_complex_3d_test_unit)
-  gudhi_add_coverage_test(Periodic_alpha_complex_3d_test_unit)
-  gudhi_add_coverage_test(Weighted_periodic_alpha_complex_3d_test_unit)
+  gudhi_add_boost_test(Alpha_complex_3d_test_unit)
+  gudhi_add_boost_test(Weighted_alpha_complex_3d_test_unit)
+  gudhi_add_boost_test(Periodic_alpha_complex_3d_test_unit)
+  gudhi_add_boost_test(Weighted_periodic_alpha_complex_3d_test_unit)
 
 endif (NOT CGAL_WITH_EIGEN3_VERSION VERSION_LESS 4.11.0)
diff --git a/src/Alpha_complex/test/Periodic_alpha_complex_3d_unit_test.cpp b/src/Alpha_complex/test/Periodic_alpha_complex_3d_unit_test.cpp
index ac3791a4..731763fa 100644
--- a/src/Alpha_complex/test/Periodic_alpha_complex_3d_unit_test.cpp
+++ b/src/Alpha_complex/test/Periodic_alpha_complex_3d_unit_test.cpp
@@ -44,11 +44,11 @@ typedef boost::mpl::list<Fast_periodic_alpha_complex_3d, Safe_periodic_alpha_com
 
 BOOST_AUTO_TEST_CASE_TEMPLATE(Alpha_complex_periodic_throw, Periodic_alpha_complex_3d, periodic_variants_type_list) {
   std::cout << "Periodic alpha complex 3d exception throw" << std::endl;
-  using Point_3 = typename Periodic_alpha_complex_3d::Point_3;
-  std::vector<Point_3> p_points;
+  using Bare_point_3 = typename Periodic_alpha_complex_3d::Bare_point_3;
+  std::vector<Bare_point_3> p_points;
 
   // Not important, this is not what we want to check
-  p_points.push_back(Point_3(0.0, 0.0, 0.0));
+  p_points.push_back(Bare_point_3(0.0, 0.0, 0.0));
 
   std::cout << "Check exception throw in debug mode" << std::endl;
   // Check it throws an exception when the cuboid is not iso
@@ -73,13 +73,13 @@ BOOST_AUTO_TEST_CASE(Alpha_complex_periodic) {
   // ---------------------
   std::cout << "Fast periodic alpha complex 3d" << std::endl;
 
-  using Creator = CGAL::Creator_uniform_3<double, Fast_periodic_alpha_complex_3d::Point_3>;
+  using Creator = CGAL::Creator_uniform_3<double, Fast_periodic_alpha_complex_3d::Bare_point_3>;
   CGAL::Random random(7);
-  CGAL::Random_points_in_cube_3<Fast_periodic_alpha_complex_3d::Point_3, Creator> in_cube(1, random);
-  std::vector<Fast_periodic_alpha_complex_3d::Point_3> p_points;
+  CGAL::Random_points_in_cube_3<Fast_periodic_alpha_complex_3d::Bare_point_3, Creator> in_cube(1, random);
+  std::vector<Fast_periodic_alpha_complex_3d::Bare_point_3> p_points;
 
   for (int i = 0; i < 50; i++) {
-    Fast_periodic_alpha_complex_3d::Point_3 p = *in_cube++;
+    Fast_periodic_alpha_complex_3d::Bare_point_3 p = *in_cube++;
     p_points.push_back(p);
   }
 
@@ -88,15 +88,30 @@ BOOST_AUTO_TEST_CASE(Alpha_complex_periodic) {
   Gudhi::Simplex_tree<> stree;
   periodic_alpha_complex.create_complex(stree);
 
+  for (std::size_t index = 0; index < p_points.size(); index++) {
+    bool found = false;
+    Fast_periodic_alpha_complex_3d::Bare_point_3 ap = periodic_alpha_complex.get_point(index);
+    for (auto point : p_points) {
+      if ((point.x() == ap.x()) && (point.y() == ap.y()) && (point.z() == ap.z())) {
+        found = true;
+        break;
+      }
+    }
+    // Check all points from alpha complex are found in the input point cloud
+    BOOST_CHECK(found);
+  }
+  // Exception if we go out of range
+  BOOST_CHECK_THROW(periodic_alpha_complex.get_point(p_points.size()), std::out_of_range);
+
   // ----------------------
   // Exact periodic version
   // ----------------------
   std::cout << "Exact periodic alpha complex 3d" << std::endl;
 
-  std::vector<Exact_periodic_alpha_complex_3d::Point_3> e_p_points;
+  std::vector<Exact_periodic_alpha_complex_3d::Bare_point_3> e_p_points;
 
   for (auto p : p_points) {
-    e_p_points.push_back(Exact_periodic_alpha_complex_3d::Point_3(p[0], p[1], p[2]));
+    e_p_points.push_back(Exact_periodic_alpha_complex_3d::Bare_point_3(p[0], p[1], p[2]));
   }
 
   Exact_periodic_alpha_complex_3d exact_alpha_complex(e_p_points, -1., -1., -1., 1., 1., 1.);
@@ -142,10 +157,10 @@ BOOST_AUTO_TEST_CASE(Alpha_complex_periodic) {
   // ----------------------
   std::cout << "Safe periodic alpha complex 3d" << std::endl;
 
-  std::vector<Safe_periodic_alpha_complex_3d::Point_3> s_p_points;
+  std::vector<Safe_periodic_alpha_complex_3d::Bare_point_3> s_p_points;
 
   for (auto p : p_points) {
-    s_p_points.push_back(Safe_periodic_alpha_complex_3d::Point_3(p[0], p[1], p[2]));
+    s_p_points.push_back(Safe_periodic_alpha_complex_3d::Bare_point_3(p[0], p[1], p[2]));
   }
 
   Safe_periodic_alpha_complex_3d safe_alpha_complex(s_p_points, -1., -1., -1., 1., 1., 1.);
diff --git a/src/Alpha_complex/test/Weighted_alpha_complex_3d_unit_test.cpp b/src/Alpha_complex/test/Weighted_alpha_complex_3d_unit_test.cpp
index 44deb930..8035f6e8 100644
--- a/src/Alpha_complex/test/Weighted_alpha_complex_3d_unit_test.cpp
+++ b/src/Alpha_complex/test/Weighted_alpha_complex_3d_unit_test.cpp
@@ -43,14 +43,14 @@ typedef boost::mpl::list<Fast_weighted_alpha_complex_3d, Safe_weighted_alpha_com
 
 #ifdef GUDHI_DEBUG
 BOOST_AUTO_TEST_CASE_TEMPLATE(Alpha_complex_weighted_throw, Weighted_alpha_complex_3d, weighted_variants_type_list) {
-  using Point_3 = typename Weighted_alpha_complex_3d::Point_3;
-  std::vector<Point_3> w_points;
-  w_points.push_back(Point_3(0.0, 0.0, 0.0));
-  w_points.push_back(Point_3(0.0, 0.0, 0.2));
-  w_points.push_back(Point_3(0.2, 0.0, 0.2));
-  // w_points.push_back(Point_3(0.6, 0.6, 0.0));
-  // w_points.push_back(Point_3(0.8, 0.8, 0.2));
-  // w_points.push_back(Point_3(0.2, 0.8, 0.6));
+  using Bare_point_3 = typename Weighted_alpha_complex_3d::Bare_point_3;
+  std::vector<Bare_point_3> w_points;
+  w_points.push_back(Bare_point_3(0.0, 0.0, 0.0));
+  w_points.push_back(Bare_point_3(0.0, 0.0, 0.2));
+  w_points.push_back(Bare_point_3(0.2, 0.0, 0.2));
+  // w_points.push_back(Bare_point_3(0.6, 0.6, 0.0));
+  // w_points.push_back(Bare_point_3(0.8, 0.8, 0.2));
+  // w_points.push_back(Bare_point_3(0.2, 0.8, 0.6));
 
   // weights size is different from w_points size to make weighted Alpha_complex_3d throw in debug mode
   std::vector<double> weights = {0.01, 0.005, 0.006, 0.01, 0.009, 0.001};
@@ -62,14 +62,14 @@ BOOST_AUTO_TEST_CASE_TEMPLATE(Alpha_complex_weighted_throw, Weighted_alpha_compl
 
 BOOST_AUTO_TEST_CASE_TEMPLATE(Alpha_complex_weighted, Weighted_alpha_complex_3d, weighted_variants_type_list) {
   std::cout << "Weighted alpha complex 3d from points and weights" << std::endl;
-  using Point_3 = typename Weighted_alpha_complex_3d::Point_3;
-  std::vector<Point_3> w_points;
-  w_points.push_back(Point_3(0.0, 0.0, 0.0));
-  w_points.push_back(Point_3(0.0, 0.0, 0.2));
-  w_points.push_back(Point_3(0.2, 0.0, 0.2));
-  w_points.push_back(Point_3(0.6, 0.6, 0.0));
-  w_points.push_back(Point_3(0.8, 0.8, 0.2));
-  w_points.push_back(Point_3(0.2, 0.8, 0.6));
+  using Bare_point_3 = typename Weighted_alpha_complex_3d::Bare_point_3;
+  std::vector<Bare_point_3> w_points;
+  w_points.push_back(Bare_point_3(0.0, 0.0, 0.0));
+  w_points.push_back(Bare_point_3(0.0, 0.0, 0.2));
+  w_points.push_back(Bare_point_3(0.2, 0.0, 0.2));
+  w_points.push_back(Bare_point_3(0.6, 0.6, 0.0));
+  w_points.push_back(Bare_point_3(0.8, 0.8, 0.2));
+  w_points.push_back(Bare_point_3(0.2, 0.8, 0.6));
 
   // weights size is different from w_points size to make weighted Alpha_complex_3d throw in debug mode
   std::vector<double> weights = {0.01, 0.005, 0.006, 0.01, 0.009, 0.001};
@@ -91,6 +91,24 @@ BOOST_AUTO_TEST_CASE_TEMPLATE(Alpha_complex_weighted, Weighted_alpha_complex_3d,
   Gudhi::Simplex_tree<> stree_bis;
   alpha_complex_w_p.create_complex(stree_bis);
 
+  for (std::size_t index = 0; index < weighted_points.size(); index++) {
+    bool found = false;
+    Weighted_point_3 awp = alpha_complex_w_p.get_point(index);
+    for (auto weighted_point : weighted_points) {
+      if ((weighted_point.weight() == awp.weight()) &&
+          (weighted_point.x() == awp.x()) &&
+          (weighted_point.y() == awp.y()) &&
+          (weighted_point.z() == awp.z())) {
+        found = true;
+        break;
+      }
+    }
+    // Check all points from alpha complex are found in the input point cloud
+    BOOST_CHECK(found);
+  }
+  // Exception if we go out of range
+  BOOST_CHECK_THROW(alpha_complex_w_p.get_point(weighted_points.size()), std::out_of_range);
+
   // ---------------------
   // Compare both versions
   // ---------------------
diff --git a/src/Alpha_complex/test/Weighted_periodic_alpha_complex_3d_unit_test.cpp b/src/Alpha_complex/test/Weighted_periodic_alpha_complex_3d_unit_test.cpp
index 670c7799..b09e92d5 100644
--- a/src/Alpha_complex/test/Weighted_periodic_alpha_complex_3d_unit_test.cpp
+++ b/src/Alpha_complex/test/Weighted_periodic_alpha_complex_3d_unit_test.cpp
@@ -47,13 +47,13 @@ BOOST_AUTO_TEST_CASE_TEMPLATE(Alpha_complex_weighted_periodic_throw, Weighted_pe
                               wp_variants_type_list) {
   std::cout << "Weighted periodic alpha complex 3d exception throw" << std::endl;
 
-  using Creator = CGAL::Creator_uniform_3<double, typename Weighted_periodic_alpha_complex_3d::Point_3>;
+  using Creator = CGAL::Creator_uniform_3<double, typename Weighted_periodic_alpha_complex_3d::Bare_point_3>;
   CGAL::Random random(7);
-  CGAL::Random_points_in_cube_3<typename Weighted_periodic_alpha_complex_3d::Point_3, Creator> in_cube(1, random);
-  std::vector<typename Weighted_periodic_alpha_complex_3d::Point_3> wp_points;
+  CGAL::Random_points_in_cube_3<typename Weighted_periodic_alpha_complex_3d::Bare_point_3, Creator> in_cube(1, random);
+  std::vector<typename Weighted_periodic_alpha_complex_3d::Bare_point_3> wp_points;
 
   for (int i = 0; i < 50; i++) {
-    typename Weighted_periodic_alpha_complex_3d::Point_3 p = *in_cube++;
+    typename Weighted_periodic_alpha_complex_3d::Bare_point_3 p = *in_cube++;
     wp_points.push_back(p);
   }
   std::vector<double> p_weights;
@@ -117,13 +117,13 @@ BOOST_AUTO_TEST_CASE(Alpha_complex_weighted_periodic) {
   // ---------------------
   std::cout << "Fast weighted periodic alpha complex 3d" << std::endl;
 
-  using Creator = CGAL::Creator_uniform_3<double, Fast_weighted_periodic_alpha_complex_3d::Point_3>;
+  using Creator = CGAL::Creator_uniform_3<double, Fast_weighted_periodic_alpha_complex_3d::Bare_point_3>;
   CGAL::Random random(7);
-  CGAL::Random_points_in_cube_3<Fast_weighted_periodic_alpha_complex_3d::Point_3, Creator> in_cube(1, random);
-  std::vector<Fast_weighted_periodic_alpha_complex_3d::Point_3> p_points;
+  CGAL::Random_points_in_cube_3<Fast_weighted_periodic_alpha_complex_3d::Bare_point_3, Creator> in_cube(1, random);
+  std::vector<Fast_weighted_periodic_alpha_complex_3d::Bare_point_3> p_points;
 
   for (int i = 0; i < 50; i++) {
-    Fast_weighted_periodic_alpha_complex_3d::Point_3 p = *in_cube++;
+    Fast_weighted_periodic_alpha_complex_3d::Bare_point_3 p = *in_cube++;
     p_points.push_back(p);
   }
   std::vector<double> p_weights;
@@ -142,10 +142,10 @@ BOOST_AUTO_TEST_CASE(Alpha_complex_weighted_periodic) {
   // ----------------------
   std::cout << "Exact weighted periodic alpha complex 3d" << std::endl;
 
-  std::vector<Exact_weighted_periodic_alpha_complex_3d::Point_3> e_p_points;
+  std::vector<Exact_weighted_periodic_alpha_complex_3d::Bare_point_3> e_p_points;
 
   for (auto p : p_points) {
-    e_p_points.push_back(Exact_weighted_periodic_alpha_complex_3d::Point_3(p[0], p[1], p[2]));
+    e_p_points.push_back(Exact_weighted_periodic_alpha_complex_3d::Bare_point_3(p[0], p[1], p[2]));
   }
 
   Exact_weighted_periodic_alpha_complex_3d exact_alpha_complex(e_p_points, p_weights, -1., -1., -1., 1., 1., 1.);
@@ -191,10 +191,10 @@ BOOST_AUTO_TEST_CASE(Alpha_complex_weighted_periodic) {
   // ----------------------
   std::cout << "Safe weighted periodic alpha complex 3d" << std::endl;
 
-  std::vector<Safe_weighted_periodic_alpha_complex_3d::Point_3> s_p_points;
+  std::vector<Safe_weighted_periodic_alpha_complex_3d::Bare_point_3> s_p_points;
 
   for (auto p : p_points) {
-    s_p_points.push_back(Safe_weighted_periodic_alpha_complex_3d::Point_3(p[0], p[1], p[2]));
+    s_p_points.push_back(Safe_weighted_periodic_alpha_complex_3d::Bare_point_3(p[0], p[1], p[2]));
   }
 
   Safe_weighted_periodic_alpha_complex_3d safe_alpha_complex(s_p_points, p_weights, -1., -1., -1., 1., 1., 1.);