Remove Rips_edge_list and review the interfaces

1 files changed, 89 insertions, 70 deletions

diff --git a/src/Collapse/test/collapse_unit_test.cpp b/src/Collapse/test/collapse_unit_test.cpp
index 3a07e088..1bec3810 100644
--- a/src/Collapse/test/collapse_unit_test.cpp
+++ b/src/Collapse/test/collapse_unit_test.cpp
@@ -8,67 +8,77 @@
  *      - YYYY/MM Author: Description of the modification
  */
 
-#include <iostream>
-#include <tuple>
-#include <vector>
-#include <array>
 
 #define BOOST_TEST_DYN_LINK
 #define BOOST_TEST_MODULE "collapse"
 #include <boost/test/unit_test.hpp>
 #include <boost/mpl/list.hpp>
 
-#include "gudhi/Flag_complex_sparse_matrix.h"
+#include <gudhi/Flag_complex_sparse_matrix.h>
+#include <gudhi/distance_functions.h>
+#include <gudhi/graph_simplicial_complex.h>
+
+#include <iostream>
+#include <tuple>
+#include <vector>
+#include <array>
+#include <cmath>
 
 using Filtration_value = float;
 using Vertex_handle = short;
-using Filtered_edge = std::tuple<Filtration_value, Vertex_handle, Vertex_handle>;
-using Filtered_sorted_edge_list = std::vector<Filtered_edge>;
 using Flag_complex_sparse_matrix = Gudhi::collapse::Flag_complex_sparse_matrix<Vertex_handle, Filtration_value>;
+using Filtered_edge = Flag_complex_sparse_matrix::Filtered_edge;
+using Filtered_edge_list = std::vector<Filtered_edge>;
 
-bool find_edge_in_list(const Filtered_edge& edge, const Filtered_sorted_edge_list& edge_list) {
+template<typename Filtered_edge_range>
+bool find_edge_in_list(const Filtered_edge& edge, const Filtered_edge_range& edge_list) {
   for (auto edge_from_list : edge_list) {
     if (edge_from_list == edge)
       return true;
   }
   return false;
 }
-/*
-void trace_and_check_collapse(const Filtered_sorted_edge_list& edges, const Filtered_sorted_edge_list& removed_edges) {
-  std::cout << "BEFORE COLLAPSE - Total number of edges: " << edges.size() << std::endl;
-  BOOST_CHECK(edges.size() > 0);
-  for (auto edge : edges) {
-    std::cout << "f[" << std::get<1>(edge) << ", " << std::get<2>(edge) << "] = " << std::get<0>(edge) << std::endl;
+
+template<typename Filtered_edge_range>
+void trace_and_check_collapse(const Filtered_edge_range& filtered_edges, const Filtered_edge_list& removed_edges) {
+  std::cout << "BEFORE COLLAPSE - Total number of edges: " << filtered_edges.size() << std::endl;
+  BOOST_CHECK(filtered_edges.size() > 0);
+  for (auto filtered_edge : filtered_edges) {
+    auto edge = std::get<0>(filtered_edge);
+    std::cout << "f[" << std::get<0>(edge) << ", " << std::get<1>(edge) << "] = " << std::get<1>(filtered_edge) << std::endl;
   }
 
   std::cout << "COLLAPSE - keep edges: " << std::endl;
-  Flag_complex_sparse_matrix flag_complex_sparse_matrix(edges);
-  Filtered_sorted_edge_list collapse_edges;
+  Flag_complex_sparse_matrix flag_complex_sparse_matrix(filtered_edges);
+  Filtered_edge_list collapse_edges;
   flag_complex_sparse_matrix.filtered_edge_collapse(
     [&collapse_edges](std::pair<Vertex_handle, Vertex_handle> edge, Filtration_value filtration) {
       std::cout << "f[" << std::get<0>(edge) << ", " << std::get<1>(edge) << "] = " << filtration << std::endl;
-        collapse_edges.push_back({filtration, std::get<0>(edge), std::get<1>(edge)});
+        collapse_edges.push_back({edge, filtration});
       });
   std::cout << "AFTER COLLAPSE - Total number of edges: " << collapse_edges.size() << std::endl;
-  BOOST_CHECK(collapse_edges.size() <= edges.size());
-  for (auto edge_from_collapse : collapse_edges) {
-    std::cout << "f[" << std::get<1>(edge_from_collapse) << ", " << std::get<2>(edge_from_collapse) << "] = "
-              << std::get<0>(edge_from_collapse) << std::endl;
+  BOOST_CHECK(collapse_edges.size() <= filtered_edges.size());
+  for (auto filtered_edge_from_collapse : collapse_edges) {
+    auto edge_from_collapse = std::get<0>(filtered_edge_from_collapse);
+    std::cout << "f[" << std::get<0>(edge_from_collapse) << ", " << std::get<1>(edge_from_collapse) << "] = "
+              << std::get<1>(filtered_edge_from_collapse) << std::endl;
     // Check each edge from collapse is in the input
-    BOOST_CHECK(find_edge_in_list(edge_from_collapse, edges));
+    BOOST_CHECK(find_edge_in_list(filtered_edge_from_collapse, filtered_edges));
   }
 
   std::cout << "CHECK COLLAPSE - Total number of removed edges: " << removed_edges.size() << std::endl;
-  for (auto removed_edge : removed_edges) {
-    std::cout << "f[" << std::get<1>(removed_edge) << ", " << std::get<2>(removed_edge) << "] = "
-              << std::get<0>(removed_edge) << std::endl;
+  for (auto removed_filtered_edge : removed_edges) {
+    auto removed_edge = std::get<0>(removed_filtered_edge);
+    std::cout << "f[" << std::get<0>(removed_edge) << ", " << std::get<1>(removed_edge) << "] = "
+              << std::get<1>(removed_filtered_edge) << std::endl;
     // Check each removed edge from collapse is in the input
-    BOOST_CHECK(!find_edge_in_list(removed_edge, collapse_edges));
+    BOOST_CHECK(!find_edge_in_list(removed_filtered_edge, collapse_edges));
   }
 
 }
 
 BOOST_AUTO_TEST_CASE(collapse) {
+  std::cout << "***** COLLAPSE *****" << std::endl;
   //  1   2
   //  o---o
   //  |   |
@@ -76,7 +86,7 @@ BOOST_AUTO_TEST_CASE(collapse) {
   //  |   |
   //  o---o
   //  0   3
-  Filtered_sorted_edge_list edges {{1., 0, 1}, {1., 1, 2}, {1., 2, 3}, {1., 3, 0}};
+  Filtered_edge_list edges {{{0, 1}, 1.}, {{1, 2}, 1.}, {{2, 3}, 1.}, {{3, 0}, 1.}};
   trace_and_check_collapse(edges, {});
   
   //  1   2
@@ -86,9 +96,9 @@ BOOST_AUTO_TEST_CASE(collapse) {
   //  |/ \|
   //  o---o
   //  0   3
-  edges.push_back({2., 0, 2});
-  edges.push_back({2., 1, 3});
-  trace_and_check_collapse(edges, {{2., 1, 3}});
+  edges.push_back({{0, 2}, 2.});
+  edges.push_back({{1, 3}, 2.});
+  trace_and_check_collapse(edges, {{{1, 3}, 2.}});
 
   //  1   2   4
   //  o---o---o
@@ -97,10 +107,10 @@ BOOST_AUTO_TEST_CASE(collapse) {
   //  |/ \|   |
   //  o---o---o
   //  0   3   5
-  edges.push_back({3., 2, 4});
-  edges.push_back({3., 4, 5});
-  edges.push_back({3., 5, 3});
-  trace_and_check_collapse(edges, {{2., 1, 3}});
+  edges.push_back({{2, 4}, 3.});
+  edges.push_back({{4, 5}, 3.});
+  edges.push_back({{5, 3}, 3.});
+  trace_and_check_collapse(edges, {{{1, 3}, 2.}});
 
   //  1   2   4
   //  o---o---o
@@ -109,9 +119,9 @@ BOOST_AUTO_TEST_CASE(collapse) {
   //  |/ \|/ \|
   //  o---o---o
   //  0   3   5
-  edges.push_back({4., 2, 5});
-  edges.push_back({4., 4, 3});
-  trace_and_check_collapse(edges, {{2., 1, 3}, {4., 4, 3}});
+  edges.push_back({{2, 5}, 4.});
+  edges.push_back({{4, 3}, 4.});
+  trace_and_check_collapse(edges, {{{1, 3}, 2.}, {{4, 3}, 4.}});
 
   //  1   2   4
   //  o---o---o
@@ -120,13 +130,27 @@ BOOST_AUTO_TEST_CASE(collapse) {
   //  |/ \|/ \|
   //  o---o---o
   //  0   3   5
-  edges.push_back({5., 1, 5});
-  edges.push_back({5., 0, 4});
-  trace_and_check_collapse(edges, {{2., 1, 3}, {4., 4, 3}, {5., 0, 4}});
-}*/
+  edges.push_back({{1, 5}, 5.});
+  edges.push_back({{0, 4}, 5.});
+  trace_and_check_collapse(edges, {{{1, 3}, 2.}, {{4, 3}, 4.}, {{0, 4}, 5.}});
+}
+
+BOOST_AUTO_TEST_CASE(collapse_from_array) {
+  std::cout << "***** COLLAPSE FROM ARRAY *****" << std::endl;
+  //  1   2
+  //  o---o
+  //  |\ /|
+  //  | x |
+  //  |/ \|
+  //  o---o
+  //  0   3
+  std::array<Filtered_edge, 6> f_edge_array = {{{{0, 1}, 1.}, {{1, 2}, 1.}, {{2, 3}, 1.}, {{3, 0}, 1.}, {{0, 2}, 2.}, {{1, 3}, 2.}}};
+  trace_and_check_collapse(f_edge_array, {{{1, 3}, 2.}});
+}
 
 
-BOOST_AUTO_TEST_CASE(collapse_from_distance_matrix) {
+BOOST_AUTO_TEST_CASE(collapse_from_proximity_graph) {
+  std::cout << "***** COLLAPSE FROM PROXIMITY GRAPH *****" << std::endl;
   //  1   2
   //  o---o
   //  |\ /|
@@ -134,39 +158,34 @@ BOOST_AUTO_TEST_CASE(collapse_from_distance_matrix) {
   //  |/ \|
   //  o---o
   //  0   3
-  // Lower diagonal distance matrix
-  std::array<std::array<double, 4>, 4> distance_matrix = {{{0., 0., 0., 0.},
-                                                           {1., 0., 0., 0.},
-                                                           {2., 1., 0., 0.},
-                                                           {1., 2., 1., 0.} }};
-  
-  std::cout << "COLLAPSE - keep edges: " << std::endl;
-  Flag_complex_sparse_matrix flag_complex_sparse_matrix(distance_matrix);
-  Filtered_sorted_edge_list collapse_edges;
+  std::vector<std::vector<Filtration_value>> point_cloud = {{0., 0.},
+                                                 {0., 1.},
+                                                 {1., 0.},
+                                                 {1., 1.} };
+
+  Filtration_value threshold = std::numeric_limits<Filtration_value>::infinity();
+  using Proximity_graph = Flag_complex_sparse_matrix::Proximity_graph;
+  Proximity_graph proximity_graph = Gudhi::compute_proximity_graph<Flag_complex_sparse_matrix>(point_cloud,
+                                                                                               threshold,
+                                                                                               Gudhi::Euclidean_distance());
+  Flag_complex_sparse_matrix flag_complex_sparse_matrix(proximity_graph);
+  Filtered_edge_list collapse_edges;
   flag_complex_sparse_matrix.filtered_edge_collapse(
     [&collapse_edges](std::pair<Vertex_handle, Vertex_handle> edge, Filtration_value filtration) {
       std::cout << "f[" << std::get<0>(edge) << ", " << std::get<1>(edge) << "] = " << filtration << std::endl;
-        collapse_edges.push_back({filtration, std::get<0>(edge), std::get<1>(edge)});
+        collapse_edges.push_back({edge, filtration});
       });
-  std::cout << "AFTER COLLAPSE - Total number of edges: " << collapse_edges.size() << std::endl;
   BOOST_CHECK(collapse_edges.size() == 5);
 
-  Filtered_sorted_edge_list edges {{1., 0, 1}, {1., 1, 2}, {1., 2, 3}, {1., 0, 3}, {2., 0, 2}, {2., 1, 3}};
-  
-  for (auto edge_from_collapse : collapse_edges) {
-    std::cout << "f[" << std::get<1>(edge_from_collapse) << ", " << std::get<2>(edge_from_collapse) << "] = "
-              << std::get<0>(edge_from_collapse) << std::endl;
-    // Check each edge from collapse is in the input
-    BOOST_CHECK(find_edge_in_list(edge_from_collapse, edges));
-  }
-
-  Filtered_sorted_edge_list removed_edges {{2., 1, 3}};
-  
-  std::cout << "CHECK COLLAPSE - Total number of removed edges: " << removed_edges.size() << std::endl;
-  for (auto removed_edge : removed_edges) {
-    std::cout << "f[" << std::get<1>(removed_edge) << ", " << std::get<2>(removed_edge) << "] = "
-              << std::get<0>(removed_edge) << std::endl;
-    // Check each removed edge from collapse is in the input
-    BOOST_CHECK(!find_edge_in_list(removed_edge, collapse_edges));
+  std::size_t filtration_is_edge_length_nb = 0;
+  std::size_t filtration_is_diagonal_length_nb = 0;
+  float epsilon = std::numeric_limits<Filtration_value>::epsilon();
+  for (auto filtered_edge : collapse_edges) {
+    if (std::get<1>(filtered_edge) == 1.)
+      filtration_is_edge_length_nb++;
+    if (std::fabs(std::get<1>(filtered_edge) - std::sqrt(2.)) <= epsilon)
+      filtration_is_diagonal_length_nb++;
   }
+  BOOST_CHECK(filtration_is_edge_length_nb == 4);
+  BOOST_CHECK(filtration_is_diagonal_length_nb == 1);
 }
\ No newline at end of file