Merge last trunk modifications

persistence file reader Python interface
persistence_graphical_tools improvement (max_plots and max_barcodes, and from a persistence file)



git-svn-id: svn+ssh://scm.gforge.inria.fr/svnroot/gudhi/branches/persistence_diagram_improvement@2604 636b058d-ea47-450e-bf9e-a15bfbe3eedb

Former-commit-id: db80333d4f34151be0c32024af597d90d221a97f

6 files changed, 345 insertions, 1 deletions

diff --git a/src/common/test/CMakeLists.txt b/src/common/test/CMakeLists.txt
index 5aa426d7..de3e765a 100644
--- a/src/common/test/CMakeLists.txt
+++ b/src/common/test/CMakeLists.txt
@@ -9,10 +9,17 @@ target_link_libraries(Common_test_points_off_reader ${Boost_UNIT_TEST_FRAMEWORK_
 add_executable ( Common_test_distance_matrix_reader test_distance_matrix_reader.cpp )
 target_link_libraries(Common_test_distance_matrix_reader ${Boost_UNIT_TEST_FRAMEWORK_LIBRARY})
 
+add_executable ( Common_test_persistence_intervals_reader test_persistence_intervals_reader.cpp )
+target_link_libraries(Common_test_persistence_intervals_reader ${Boost_UNIT_TEST_FRAMEWORK_LIBRARY})
+
 # 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}/)
 file(COPY "${CMAKE_SOURCE_DIR}/data/distance_matrix/lower_triangular_distance_matrix.csv" DESTINATION ${CMAKE_CURRENT_BINARY_DIR}/)
 file(COPY "${CMAKE_SOURCE_DIR}/data/distance_matrix/full_square_distance_matrix.csv" DESTINATION ${CMAKE_CURRENT_BINARY_DIR}/)
+file(COPY "${CMAKE_SOURCE_DIR}/src/common/test/persistence_intervals_with_dimension.pers" DESTINATION ${CMAKE_CURRENT_BINARY_DIR}/)
+file(COPY "${CMAKE_SOURCE_DIR}/src/common/test/persistence_intervals_with_field.pers" DESTINATION ${CMAKE_CURRENT_BINARY_DIR}/)
+file(COPY "${CMAKE_SOURCE_DIR}/src/common/test/persistence_intervals_without_dimension.pers" DESTINATION ${CMAKE_CURRENT_BINARY_DIR}/)
 
 gudhi_add_coverage_test(Common_test_points_off_reader)
 gudhi_add_coverage_test(Common_test_distance_matrix_reader)
+gudhi_add_coverage_test(Common_test_persistence_intervals_reader)
diff --git a/src/common/test/README b/src/common/test/README
index f2a7eb5a..a8e6efe9 100644
--- a/src/common/test/README
+++ b/src/common/test/README
@@ -7,7 +7,7 @@ make
 To launch with details:
 ***********************
 
-./dtoffrw_UT --report_level=detailed --log_level=all 
+./Common_test_points_off_reader --report_level=detailed --log_level=all
 
    ==> echo $? returns 0 in case of success (non-zero otherwise)
 
diff --git a/src/common/test/persistence_intervals_with_dimension.pers b/src/common/test/persistence_intervals_with_dimension.pers
new file mode 100644
index 00000000..406748c8
--- /dev/null
+++ b/src/common/test/persistence_intervals_with_dimension.pers
@@ -0,0 +1,5 @@
+# Simple persistence diagram with dimension
+0 2.7 3.7
+1 9.6 14.
+3 34.2 34.974
+1 3. inf
diff --git a/src/common/test/persistence_intervals_with_field.pers b/src/common/test/persistence_intervals_with_field.pers
new file mode 100644
index 00000000..41dd9f1e
--- /dev/null
+++ b/src/common/test/persistence_intervals_with_field.pers
@@ -0,0 +1,4 @@
+3 0 2.7 3.7
+3 1 9.6 14.
+3 3 34.2 34.974
+3 1 3. inf
diff --git a/src/common/test/persistence_intervals_without_dimension.pers b/src/common/test/persistence_intervals_without_dimension.pers
new file mode 100644
index 00000000..76fa27f3
--- /dev/null
+++ b/src/common/test/persistence_intervals_without_dimension.pers
@@ -0,0 +1,7 @@
+# Simple persistence diagram without dimension
+2.7 3.7
+9.6 14.
+# Another comment
+34.2 34.974
+3. inf
+# End of file
diff --git a/src/common/test/test_persistence_intervals_reader.cpp b/src/common/test/test_persistence_intervals_reader.cpp
new file mode 100644
index 00000000..a06fff1e
--- /dev/null
+++ b/src/common/test/test_persistence_intervals_reader.cpp
@@ -0,0 +1,321 @@
+/*    This file is part of the Gudhi Library. The Gudhi library
+ *    (Geometric Understanding in Higher Dimensions) is a generic C++
+ *    library for computational topology.
+ *
+ *    Author(s):       Vincent Rouvreau
+ *
+ *    Copyright (C) 2017  INRIA
+ *
+ *    This program is free software: you can redistribute it and/or modify
+ *    it under the terms of the GNU General Public License as published by
+ *    the Free Software Foundation, either version 3 of the License, or
+ *    (at your option) any later version.
+ *
+ *    This program is distributed in the hope that it will be useful,
+ *    but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *    GNU General Public License for more details.
+ *
+ *    You should have received a copy of the GNU General Public License
+ *    along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <gudhi/reader_utils.h>
+
+#include <iostream>
+#include <vector>
+#include <utility>  // for pair
+#include <tuple>
+#include <limits>  // for inf
+
+#define BOOST_TEST_DYN_LINK
+#define BOOST_TEST_MODULE "persistence_intervals_reader"
+#include <boost/test/unit_test.hpp>
+
+using Persistence_intervals_by_dimension = std::map<int, std::vector<std::pair<double, double>>>;
+using Persistence_intervals = std::vector<std::pair<double, double>>;
+// Test files with only 2 parameters (persistence birth and death) per line in file
+BOOST_AUTO_TEST_CASE( persistence_intervals_without_dimension )
+{
+  Persistence_intervals_by_dimension expected_intervals_by_dimension;
+  expected_intervals_by_dimension[-1].push_back(std::make_pair(2.7, 3.7));
+  expected_intervals_by_dimension[-1].push_back(std::make_pair(9.6, 14.));
+  expected_intervals_by_dimension[-1].push_back(std::make_pair(34.2, 34.974));
+  expected_intervals_by_dimension[-1].push_back(std::make_pair(3., std::numeric_limits<double>::infinity()));
+
+  Persistence_intervals_by_dimension persistence_intervals_by_dimension =
+      read_persistence_intervals_grouped_by_dimension("persistence_intervals_without_dimension.pers");
+
+  std::cout << "\nread_persistence_intervals_grouped_by_dimension - expected\n";
+  for (auto map_iter : expected_intervals_by_dimension) {
+    std::cout << "key=" << map_iter.first;
+    for (auto vec_iter : map_iter.second)
+      std::cout << " [" << vec_iter.first << " ," << vec_iter.second << "] ";
+  }
+
+  std::cout << "\nread_persistence_intervals_grouped_by_dimension - read\n";
+  for (auto map_iter : persistence_intervals_by_dimension) {
+    std::cout << "key=" << map_iter.first;
+    for (auto vec_iter : map_iter.second)
+      std::cout << " [" << vec_iter.first << " ," << vec_iter.second << "] ";
+  }
+
+  BOOST_CHECK(persistence_intervals_by_dimension == expected_intervals_by_dimension);
+
+  Persistence_intervals expected_intervals_in_dimension;
+  expected_intervals_in_dimension.push_back(std::make_pair(2.7, 3.7));
+  expected_intervals_in_dimension.push_back(std::make_pair(9.6, 14.));
+  expected_intervals_in_dimension.push_back(std::make_pair(34.2, 34.974));
+  expected_intervals_in_dimension.push_back(std::make_pair(3., std::numeric_limits<double>::infinity()));
+
+  Persistence_intervals persistence_intervals_in_dimension =
+      read_persistence_intervals_in_dimension("persistence_intervals_without_dimension.pers");
+
+  std::cout << "\nread_persistence_intervals_in_dimension - expected\n";
+  for (auto vec_iter : expected_intervals_in_dimension)
+    std::cout << " [" << vec_iter.first << " ," << vec_iter.second << "] ";
+
+  std::cout << "\nread_persistence_intervals_in_dimension - read\n";
+  for (auto vec_iter : expected_intervals_in_dimension)
+    std::cout << " [" << vec_iter.first << " ," << vec_iter.second << "] ";
+
+  BOOST_CHECK(persistence_intervals_in_dimension == expected_intervals_in_dimension);
+
+  expected_intervals_in_dimension.clear();
+  persistence_intervals_in_dimension =
+        read_persistence_intervals_in_dimension("persistence_intervals_without_dimension.pers", 0);
+  BOOST_CHECK(persistence_intervals_in_dimension == expected_intervals_in_dimension);
+
+  expected_intervals_in_dimension.clear();
+  persistence_intervals_in_dimension =
+        read_persistence_intervals_in_dimension("persistence_intervals_without_dimension.pers", 1);
+  BOOST_CHECK(persistence_intervals_in_dimension == expected_intervals_in_dimension);
+
+  expected_intervals_in_dimension.clear();
+  persistence_intervals_in_dimension =
+        read_persistence_intervals_in_dimension("persistence_intervals_without_dimension.pers", 2);
+  BOOST_CHECK(persistence_intervals_in_dimension == expected_intervals_in_dimension);
+
+  expected_intervals_in_dimension.clear();
+  persistence_intervals_in_dimension =
+        read_persistence_intervals_in_dimension("persistence_intervals_without_dimension.pers", 3);
+  BOOST_CHECK(persistence_intervals_in_dimension == expected_intervals_in_dimension);
+
+}
+// Test files with 3 parameters (dimension birth death) per line in file
+BOOST_AUTO_TEST_CASE( persistence_intervals_with_dimension )
+{
+  Persistence_intervals_by_dimension expected_intervals_by_dimension;
+  expected_intervals_by_dimension[0].push_back(std::make_pair(2.7, 3.7));
+  expected_intervals_by_dimension[1].push_back(std::make_pair(9.6, 14.));
+  expected_intervals_by_dimension[3].push_back(std::make_pair(34.2, 34.974));
+  expected_intervals_by_dimension[1].push_back(std::make_pair(3., std::numeric_limits<double>::infinity()));
+
+  Persistence_intervals_by_dimension persistence_intervals_by_dimension =
+      read_persistence_intervals_grouped_by_dimension("persistence_intervals_with_dimension.pers");
+
+  std::cout << "\nread_persistence_intervals_grouped_by_dimension - expected\n";
+  for (auto map_iter : expected_intervals_by_dimension) {
+    std::cout << "key=" << map_iter.first;
+    for (auto vec_iter : map_iter.second)
+      std::cout << " [" << vec_iter.first << " ," << vec_iter.second << "] ";
+  }
+
+  std::cout << "\nread_persistence_intervals_grouped_by_dimension - read\n";
+  for (auto map_iter : persistence_intervals_by_dimension) {
+    std::cout << "key=" << map_iter.first;
+    for (auto vec_iter : map_iter.second)
+      std::cout << " [" << vec_iter.first << " ," << vec_iter.second << "] ";
+  }
+
+  BOOST_CHECK(persistence_intervals_by_dimension == expected_intervals_by_dimension);
+
+  Persistence_intervals expected_intervals_in_dimension;
+  expected_intervals_in_dimension.push_back(std::make_pair(2.7, 3.7));
+  expected_intervals_in_dimension.push_back(std::make_pair(9.6, 14.));
+  expected_intervals_in_dimension.push_back(std::make_pair(34.2, 34.974));
+  expected_intervals_in_dimension.push_back(std::make_pair(3., std::numeric_limits<double>::infinity()));
+
+  Persistence_intervals persistence_intervals_in_dimension =
+      read_persistence_intervals_in_dimension("persistence_intervals_with_dimension.pers");
+
+  std::cout << "\nread_persistence_intervals_in_dimension - expected\n";
+  for (auto vec_iter : expected_intervals_in_dimension)
+    std::cout << " [" << vec_iter.first << " ," << vec_iter.second << "] ";
+
+  std::cout << "\nread_persistence_intervals_in_dimension - read\n";
+  for (auto vec_iter : persistence_intervals_in_dimension)
+    std::cout << " [" << vec_iter.first << " ," << vec_iter.second << "] ";
+
+  BOOST_CHECK(persistence_intervals_in_dimension == expected_intervals_in_dimension);
+
+  expected_intervals_in_dimension.clear();
+  expected_intervals_in_dimension.push_back(std::make_pair(2.7, 3.7));
+  persistence_intervals_in_dimension =
+        read_persistence_intervals_in_dimension("persistence_intervals_with_dimension.pers", 0);
+
+  std::cout << "\nread_persistence_intervals_in_dimension 0 - expected\n";
+  for (auto vec_iter : expected_intervals_in_dimension)
+    std::cout << " [" << vec_iter.first << " ," << vec_iter.second << "] ";
+
+  std::cout << "\nread_persistence_intervals_in_dimension 0 - read\n";
+  for (auto vec_iter : persistence_intervals_in_dimension)
+    std::cout << " [" << vec_iter.first << " ," << vec_iter.second << "] ";
+
+  BOOST_CHECK(persistence_intervals_in_dimension == expected_intervals_in_dimension);
+
+  expected_intervals_in_dimension.clear();
+  expected_intervals_in_dimension.push_back(std::make_pair(9.6, 14.));
+  expected_intervals_in_dimension.push_back(std::make_pair(3., std::numeric_limits<double>::infinity()));
+  persistence_intervals_in_dimension =
+        read_persistence_intervals_in_dimension("persistence_intervals_with_dimension.pers", 1);
+
+  std::cout << "\nread_persistence_intervals_in_dimension 1 - expected\n";
+  for (auto vec_iter : expected_intervals_in_dimension)
+    std::cout << " [" << vec_iter.first << " ," << vec_iter.second << "] ";
+
+  std::cout << "\nread_persistence_intervals_in_dimension 1 - read\n";
+  for (auto vec_iter : persistence_intervals_in_dimension)
+    std::cout << " [" << vec_iter.first << " ," << vec_iter.second << "] ";
+
+  BOOST_CHECK(persistence_intervals_in_dimension == expected_intervals_in_dimension);
+
+  expected_intervals_in_dimension.clear();
+  persistence_intervals_in_dimension =
+        read_persistence_intervals_in_dimension("persistence_intervals_with_dimension.pers", 2);
+
+  std::cout << "\nread_persistence_intervals_in_dimension 2 - expected\n";
+  for (auto vec_iter : expected_intervals_in_dimension)
+    std::cout << " [" << vec_iter.first << " ," << vec_iter.second << "] ";
+
+  std::cout << "\nread_persistence_intervals_in_dimension 2 - read\n";
+  for (auto vec_iter : persistence_intervals_in_dimension)
+    std::cout << " [" << vec_iter.first << " ," << vec_iter.second << "] ";
+
+  BOOST_CHECK(persistence_intervals_in_dimension == expected_intervals_in_dimension);
+
+  expected_intervals_in_dimension.clear();
+  expected_intervals_in_dimension.push_back(std::make_pair(34.2, 34.974));
+  persistence_intervals_in_dimension =
+        read_persistence_intervals_in_dimension("persistence_intervals_with_dimension.pers", 3);
+
+  std::cout << "\nread_persistence_intervals_in_dimension 3 - expected\n";
+  for (auto vec_iter : expected_intervals_in_dimension)
+    std::cout << " [" << vec_iter.first << " ," << vec_iter.second << "] ";
+
+  std::cout << "\nread_persistence_intervals_in_dimension 3 - read\n";
+  for (auto vec_iter : persistence_intervals_in_dimension)
+    std::cout << " [" << vec_iter.first << " ," << vec_iter.second << "] ";
+
+  BOOST_CHECK(persistence_intervals_in_dimension == expected_intervals_in_dimension);
+
+}
+
+// Test files with 4 parameters (field dimension birth death) per line in file
+BOOST_AUTO_TEST_CASE( persistence_intervals_with_field )
+{
+  Persistence_intervals_by_dimension expected_intervals_by_dimension;
+  expected_intervals_by_dimension[0].push_back(std::make_pair(2.7, 3.7));
+  expected_intervals_by_dimension[1].push_back(std::make_pair(9.6, 14.));
+  expected_intervals_by_dimension[3].push_back(std::make_pair(34.2, 34.974));
+  expected_intervals_by_dimension[1].push_back(std::make_pair(3., std::numeric_limits<double>::infinity()));
+
+  Persistence_intervals_by_dimension persistence_intervals_by_dimension =
+      read_persistence_intervals_grouped_by_dimension("persistence_intervals_with_field.pers");
+
+  std::cout << "\nread_persistence_intervals_grouped_by_dimension - expected\n";
+  for (auto map_iter : expected_intervals_by_dimension) {
+    std::cout << "key=" << map_iter.first;
+    for (auto vec_iter : map_iter.second)
+      std::cout << " [" << vec_iter.first << " ," << vec_iter.second << "] ";
+  }
+
+  std::cout << "\nread_persistence_intervals_grouped_by_dimension - read\n";
+  for (auto map_iter : persistence_intervals_by_dimension) {
+    std::cout << "key=" << map_iter.first;
+    for (auto vec_iter : map_iter.second)
+      std::cout << " [" << vec_iter.first << " ," << vec_iter.second << "] ";
+  }
+
+  BOOST_CHECK(persistence_intervals_by_dimension == expected_intervals_by_dimension);
+
+  Persistence_intervals expected_intervals_in_dimension;
+  expected_intervals_in_dimension.push_back(std::make_pair(2.7, 3.7));
+  expected_intervals_in_dimension.push_back(std::make_pair(9.6, 14.));
+  expected_intervals_in_dimension.push_back(std::make_pair(34.2, 34.974));
+  expected_intervals_in_dimension.push_back(std::make_pair(3., std::numeric_limits<double>::infinity()));
+
+  Persistence_intervals persistence_intervals_in_dimension =
+      read_persistence_intervals_in_dimension("persistence_intervals_with_field.pers");
+
+  std::cout << "\nread_persistence_intervals_in_dimension - expected\n";
+  for (auto vec_iter : expected_intervals_in_dimension)
+    std::cout << " [" << vec_iter.first << " ," << vec_iter.second << "] ";
+
+  std::cout << "\nread_persistence_intervals_in_dimension - read\n";
+  for (auto vec_iter : persistence_intervals_in_dimension)
+    std::cout << " [" << vec_iter.first << " ," << vec_iter.second << "] ";
+
+  BOOST_CHECK(persistence_intervals_in_dimension == expected_intervals_in_dimension);
+
+  expected_intervals_in_dimension.clear();
+  expected_intervals_in_dimension.push_back(std::make_pair(2.7, 3.7));
+  persistence_intervals_in_dimension =
+        read_persistence_intervals_in_dimension("persistence_intervals_with_field.pers", 0);
+
+  std::cout << "\nread_persistence_intervals_in_dimension 0 - expected\n";
+  for (auto vec_iter : expected_intervals_in_dimension)
+    std::cout << " [" << vec_iter.first << " ," << vec_iter.second << "] ";
+
+  std::cout << "\nread_persistence_intervals_in_dimension 0 - read\n";
+  for (auto vec_iter : persistence_intervals_in_dimension)
+    std::cout << " [" << vec_iter.first << " ," << vec_iter.second << "] ";
+
+  BOOST_CHECK(persistence_intervals_in_dimension == expected_intervals_in_dimension);
+
+  expected_intervals_in_dimension.clear();
+  expected_intervals_in_dimension.push_back(std::make_pair(9.6, 14.));
+  expected_intervals_in_dimension.push_back(std::make_pair(3., std::numeric_limits<double>::infinity()));
+  persistence_intervals_in_dimension =
+        read_persistence_intervals_in_dimension("persistence_intervals_with_field.pers", 1);
+
+  std::cout << "\nread_persistence_intervals_in_dimension 1 - expected\n";
+  for (auto vec_iter : expected_intervals_in_dimension)
+    std::cout << " [" << vec_iter.first << " ," << vec_iter.second << "] ";
+
+  std::cout << "\nread_persistence_intervals_in_dimension 1 - read\n";
+  for (auto vec_iter : persistence_intervals_in_dimension)
+    std::cout << " [" << vec_iter.first << " ," << vec_iter.second << "] ";
+
+  BOOST_CHECK(persistence_intervals_in_dimension == expected_intervals_in_dimension);
+
+  expected_intervals_in_dimension.clear();
+  persistence_intervals_in_dimension =
+        read_persistence_intervals_in_dimension("persistence_intervals_with_field.pers", 2);
+
+  std::cout << "\nread_persistence_intervals_in_dimension 2 - expected\n";
+  for (auto vec_iter : expected_intervals_in_dimension)
+    std::cout << " [" << vec_iter.first << " ," << vec_iter.second << "] ";
+
+  std::cout << "\nread_persistence_intervals_in_dimension 2 - read\n";
+  for (auto vec_iter : persistence_intervals_in_dimension)
+    std::cout << " [" << vec_iter.first << " ," << vec_iter.second << "] ";
+
+  BOOST_CHECK(persistence_intervals_in_dimension == expected_intervals_in_dimension);
+
+  expected_intervals_in_dimension.clear();
+  expected_intervals_in_dimension.push_back(std::make_pair(34.2, 34.974));
+  persistence_intervals_in_dimension =
+        read_persistence_intervals_in_dimension("persistence_intervals_with_field.pers", 3);
+
+  std::cout << "\nread_persistence_intervals_in_dimension 3 - expected\n";
+  for (auto vec_iter : expected_intervals_in_dimension)
+    std::cout << " [" << vec_iter.first << " ," << vec_iter.second << "] ";
+
+  std::cout << "\nread_persistence_intervals_in_dimension 3 - read\n";
+  for (auto vec_iter : persistence_intervals_in_dimension)
+    std::cout << " [" << vec_iter.first << " ," << vec_iter.second << "] ";
+
+  BOOST_CHECK(persistence_intervals_in_dimension == expected_intervals_in_dimension);
+
+}