Merge last trunk modifications

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

Former-commit-id: 96af633598ea1efa65ce9b78742628722f469d9e

5 files changed, 438 insertions, 313 deletions

diff --git a/src/cython/CMakeLists.txt b/src/cython/CMakeLists.txt
index 8f1dec76..1849a6ec 100644
--- a/src/cython/CMakeLists.txt
+++ b/src/cython/CMakeLists.txt
@@ -16,17 +16,51 @@ endfunction( add_gudhi_cython_lib )
 
 # THE_TEST is the python test file name (without .py extension) containing tests functions
 function( add_gudhi_py_test THE_TEST )
-  # use ${PYTHON_EXECUTABLE} -B, otherwise a __pycache__ directory is created in sources by python
-  # use py.test no cache provider, otherwise a .cache file is created in sources by py.test
-  add_test(NAME ${THE_TEST}_py_test
-           WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
-           COMMAND ${PYTHON_EXECUTABLE} -B -m pytest -p no:cacheprovider ${CMAKE_CURRENT_SOURCE_DIR}/test/${THE_TEST}.py)
+  if(PYTEST_FOUND)
+    # use ${PYTHON_EXECUTABLE} -B, otherwise a __pycache__ directory is created in sources by python
+    # use py.test no cache provider, otherwise a .cache file is created in sources by py.test
+    add_test(NAME ${THE_TEST}_py_test
+             WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
+             COMMAND ${PYTHON_EXECUTABLE} -B -m pytest -p no:cacheprovider ${CMAKE_CURRENT_SOURCE_DIR}/test/${THE_TEST}.py)
+  endif()
 endfunction( add_gudhi_py_test )
 
+# Set gudhi.__debug_info__
+# WARNING : to be done before gudhi.pyx.in configure_file
+function( add_gudhi_debug_info DEBUG_INFO )
+  set(GUDHI_CYTHON_DEBUG_INFO "${GUDHI_CYTHON_DEBUG_INFO}    \"${DEBUG_INFO}\\n\" \\\n" PARENT_SCOPE)
+endfunction( add_gudhi_debug_info )
+
 
 if(CYTHON_FOUND)
-  message("++ ${PYTHON_EXECUTABLE} v.${PYTHON_VERSION_STRING} - Cython is ${CYTHON_EXECUTABLE} - Sphinx is ${SPHINX_PATH}")
+  set(GUDHI_CYTHON_MODULES "${GUDHI_CYTHON_MODULES}off_reader;")
+  set(GUDHI_CYTHON_MODULES "${GUDHI_CYTHON_MODULES}simplex_tree;")
+  set(GUDHI_CYTHON_MODULES "${GUDHI_CYTHON_MODULES}rips_complex;")
+  set(GUDHI_CYTHON_MODULES "${GUDHI_CYTHON_MODULES}cubical_complex;")
+  set(GUDHI_CYTHON_MODULES "${GUDHI_CYTHON_MODULES}periodic_cubical_complex;")
+  set(GUDHI_CYTHON_MODULES "${GUDHI_CYTHON_MODULES}persistence_graphical_tools;")
+  set(GUDHI_CYTHON_MODULES "${GUDHI_CYTHON_MODULES}reader_utils;")
+  set(GUDHI_CYTHON_MODULES "${GUDHI_CYTHON_MODULES}witness_complex;")
+  set(GUDHI_CYTHON_MODULES "${GUDHI_CYTHON_MODULES}strong_witness_complex;")
+
+  add_gudhi_debug_info("Python version ${PYTHON_VERSION_STRING}")
+  add_gudhi_debug_info("Cython version ${CYTHON_VERSION}")
+  if(PYTEST_FOUND)
+    add_gudhi_debug_info("Pytest version ${PYTEST_VERSION}")
+  endif()
+  if(MATPLOTLIB_FOUND)
+    add_gudhi_debug_info("Matplotlib version ${MATPLOTLIB_VERSION}")
+  endif()
+  if(NUMPY_FOUND)
+    add_gudhi_debug_info("Numpy version ${NUMPY_VERSION}")
+  endif()
+  if(MATPLOTLIB_FOUND AND NUMPY_FOUND)
+    set(GUDHI_CYTHON_MODULES "${GUDHI_CYTHON_MODULES}persistence_graphical_tools;")
+  else()
+      set(GUDHI_CYTHON_MISSING_MODULES "${GUDHI_CYTHON_MODULES}persistence_graphical_tools;")
+  endif()
 
+  message("++ ${PYTHON_EXECUTABLE} v.${PYTHON_VERSION_STRING} - Cython is ${CYTHON_VERSION} - Sphinx is ${SPHINX_PATH}")
   set(GUDHI_CYTHON_EXTRA_COMPILE_ARGS "${GUDHI_CYTHON_EXTRA_COMPILE_ARGS}'-DBOOST_RESULT_OF_USE_DECLTYPE', ")
   set(GUDHI_CYTHON_EXTRA_COMPILE_ARGS "${GUDHI_CYTHON_EXTRA_COMPILE_ARGS}'-DBOOST_ALL_NO_LIB', ")
   set(GUDHI_CYTHON_EXTRA_COMPILE_ARGS "${GUDHI_CYTHON_EXTRA_COMPILE_ARGS}'-DBOOST_SYSTEM_NO_DEPRECATED', ")
@@ -49,25 +83,49 @@ if(CYTHON_FOUND)
   endif()
 
   if (EIGEN3_FOUND)
+    add_gudhi_debug_info("Eigen3 version ${EIGEN3_VERSION}")
     # No problem, even if no CGAL found
     set(GUDHI_CYTHON_EXTRA_COMPILE_ARGS "${GUDHI_CYTHON_EXTRA_COMPILE_ARGS}'-DCGAL_EIGEN3_ENABLED', ")
   endif (EIGEN3_FOUND)
 
   if (NOT CGAL_VERSION VERSION_LESS 4.8.1)
     set(GUDHI_CYTHON_BOTTLENECK_DISTANCE "include '${CMAKE_CURRENT_SOURCE_DIR}/cython/bottleneck_distance.pyx'")
+    set(GUDHI_CYTHON_MODULES "${GUDHI_CYTHON_MODULES}bottleneck_distance;")
     set(GUDHI_CYTHON_NERVE_GIC "include '${CMAKE_CURRENT_SOURCE_DIR}/cython/nerve_gic.pyx'")
-  endif (NOT CGAL_VERSION VERSION_LESS 4.8.1)
+    set(GUDHI_CYTHON_MODULES "${GUDHI_CYTHON_MODULES}nerve_gic;")
+  else()
+    set(GUDHI_CYTHON_MISSING_MODULES "${GUDHI_CYTHON_MISSING_MODULES}bottleneck_distance;")
+    set(GUDHI_CYTHON_MISSING_MODULES "${GUDHI_CYTHON_MISSING_MODULES}nerve_gic;")
+  endif ()
   if (NOT CGAL_WITH_EIGEN3_VERSION VERSION_LESS 4.8.1)
     set(GUDHI_CYTHON_SUBSAMPLING "include '${CMAKE_CURRENT_SOURCE_DIR}/cython/subsampling.pyx'")
+    set(GUDHI_CYTHON_MODULES "${GUDHI_CYTHON_MODULES}subsampling;")
     set(GUDHI_CYTHON_TANGENTIAL_COMPLEX "include '${CMAKE_CURRENT_SOURCE_DIR}/cython/tangential_complex.pyx'")
-  endif (NOT CGAL_WITH_EIGEN3_VERSION VERSION_LESS 4.8.1)
+    set(GUDHI_CYTHON_MODULES "${GUDHI_CYTHON_MODULES}tangential_complex;")
+  else()
+    set(GUDHI_CYTHON_MISSING_MODULES "${GUDHI_CYTHON_MISSING_MODULES}subsampling;")
+    set(GUDHI_CYTHON_MISSING_MODULES "${GUDHI_CYTHON_MISSING_MODULES}tangential_complex;")
+  endif ()
   if (NOT CGAL_WITH_EIGEN3_VERSION VERSION_LESS 4.7.0)
     set(GUDHI_CYTHON_ALPHA_COMPLEX "include '${CMAKE_CURRENT_SOURCE_DIR}/cython/alpha_complex.pyx'")
-  endif (NOT CGAL_WITH_EIGEN3_VERSION VERSION_LESS 4.7.0)
+    set(GUDHI_CYTHON_MODULES "${GUDHI_CYTHON_MODULES}alpha_complex;")
+  else()
+    set(GUDHI_CYTHON_MISSING_MODULES "${GUDHI_CYTHON_MISSING_MODULES}alpha_complex;")
+  endif ()
   if (NOT CGAL_WITH_EIGEN3_VERSION VERSION_LESS 4.6.0)
     set(GUDHI_CYTHON_EUCLIDEAN_WITNESS_COMPLEX
         "include '${CMAKE_CURRENT_SOURCE_DIR}/cython/euclidean_witness_complex.pyx'\ninclude '${CMAKE_CURRENT_SOURCE_DIR}/cython/euclidean_strong_witness_complex.pyx'\n")
-  endif (NOT CGAL_WITH_EIGEN3_VERSION VERSION_LESS 4.6.0)
+    set(GUDHI_CYTHON_MODULES "${GUDHI_CYTHON_MODULES}euclidean_witness_complex;")
+    set(GUDHI_CYTHON_MODULES "${GUDHI_CYTHON_MODULES}euclidean_strong_witness_complex;")
+  else()
+    set(GUDHI_CYTHON_MISSING_MODULES "${GUDHI_CYTHON_MISSING_MODULES}euclidean_witness_complex;")
+    set(GUDHI_CYTHON_MISSING_MODULES "${GUDHI_CYTHON_MISSING_MODULES}euclidean_strong_witness_complex;")
+  endif ()
+
+  add_gudhi_debug_info("Installed modules are: ${GUDHI_CYTHON_MODULES}")
+  if(GUDHI_CYTHON_MISSING_MODULES)
+    add_gudhi_debug_info("Missing modules are: ${GUDHI_CYTHON_MISSING_MODULES}")
+  endif()
 
   if(CGAL_FOUND)
     can_cgal_use_cxx11_thread_local()
@@ -77,8 +135,10 @@ if(CYTHON_FOUND)
     endif()
     # Add CGAL compilation args
     if(CGAL_HEADER_ONLY)
+      add_gudhi_debug_info("CGAL header only version ${CGAL_VERSION}")
       set(GUDHI_CYTHON_EXTRA_COMPILE_ARGS "${GUDHI_CYTHON_EXTRA_COMPILE_ARGS}'-DCGAL_HEADER_ONLY', ")
     else(CGAL_HEADER_ONLY)
+      add_gudhi_debug_info("CGAL version ${CGAL_VERSION}")
       add_gudhi_cython_lib(${CGAL_LIBRARY})
       set(GUDHI_CYTHON_LIBRARY_DIRS "${GUDHI_CYTHON_LIBRARY_DIRS}'${CGAL_LIBRARIES_DIR}', ")
       # If CGAL is not header only, CGAL library may link with boost system,
@@ -87,10 +147,12 @@ if(CYTHON_FOUND)
     endif(CGAL_HEADER_ONLY)
     # GMP and GMPXX are not required, but if present, CGAL will link with them.
     if(GMP_FOUND)
+      add_gudhi_debug_info("GMP_LIBRARIES = ${GMP_LIBRARIES}")
       set(GUDHI_CYTHON_EXTRA_COMPILE_ARGS "${GUDHI_CYTHON_EXTRA_COMPILE_ARGS}'-DCGAL_USE_GMP', ")
       add_gudhi_cython_lib(${GMP_LIBRARIES})
       set(GUDHI_CYTHON_LIBRARY_DIRS "${GUDHI_CYTHON_LIBRARY_DIRS}'${GMP_LIBRARIES_DIR}', ")
       if(GMPXX_FOUND)
+        add_gudhi_debug_info("GMPXX_LIBRARIES = ${GMPXX_LIBRARIES}")
         set(GUDHI_CYTHON_EXTRA_COMPILE_ARGS "${GUDHI_CYTHON_EXTRA_COMPILE_ARGS}'-DCGAL_USE_GMPXX', ")
         add_gudhi_cython_lib(${GMPXX_LIBRARIES})
         set(GUDHI_CYTHON_LIBRARY_DIRS "${GUDHI_CYTHON_LIBRARY_DIRS}'${GMPXX_LIBRARIES_DIR}', ")
@@ -112,6 +174,7 @@ if(CYTHON_FOUND)
   set(GUDHI_CYTHON_INCLUDE_DIRS "${GUDHI_CYTHON_INCLUDE_DIRS}'${CMAKE_SOURCE_DIR}/${GUDHI_CYTHON_PATH}/include', ")
 
   if (TBB_FOUND AND WITH_GUDHI_USE_TBB)
+    add_gudhi_debug_info("TBB version ${TBB_INTERFACE_VERSION} found and used")
     set(GUDHI_CYTHON_EXTRA_COMPILE_ARGS "${GUDHI_CYTHON_EXTRA_COMPILE_ARGS}'-DGUDHI_USE_TBB', ")
     add_gudhi_cython_lib(${TBB_RELEASE_LIBRARY})
     add_gudhi_cython_lib(${TBB_MALLOC_RELEASE_LIBRARY})
@@ -152,27 +215,29 @@ if(CYTHON_FOUND)
              ${PYTHON_EXECUTABLE} "${CMAKE_CURRENT_SOURCE_DIR}/example/alpha_rips_persistence_bottleneck_distance.py"
              -f ${CMAKE_SOURCE_DIR}/data/points/tore3D_300.off -t 0.15 -d 3)
 
-    # Tangential
-    add_test(NAME tangential_complex_plain_homology_from_off_file_example_py_test
-             WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
-             COMMAND ${CMAKE_COMMAND} -E env "PYTHONPATH=${CMAKE_CURRENT_BINARY_DIR}"
-             ${PYTHON_EXECUTABLE} "${CMAKE_CURRENT_SOURCE_DIR}/example/tangential_complex_plain_homology_from_off_file_example.py"
-             --no-diagram -i 2 -f ${CMAKE_SOURCE_DIR}/data/points/tore3D_300.off)
-
-    add_gudhi_py_test(test_tangential_complex)
-
-    # Witness complex AND Subsampling
-    add_test(NAME euclidean_strong_witness_complex_diagram_persistence_from_off_file_example_py_test
-             WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
-             COMMAND ${CMAKE_COMMAND} -E env "PYTHONPATH=${CMAKE_CURRENT_BINARY_DIR}"
-             ${PYTHON_EXECUTABLE} "${CMAKE_CURRENT_SOURCE_DIR}/example/euclidean_strong_witness_complex_diagram_persistence_from_off_file_example.py"
-             --no-diagram -f ${CMAKE_SOURCE_DIR}/data/points/tore3D_300.off -a 1.0 -n 20 -d 2)
-
-    add_test(NAME euclidean_witness_complex_diagram_persistence_from_off_file_example_py_test
-             WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
-             COMMAND ${CMAKE_COMMAND} -E env "PYTHONPATH=${CMAKE_CURRENT_BINARY_DIR}"
-             ${PYTHON_EXECUTABLE} "${CMAKE_CURRENT_SOURCE_DIR}/example/euclidean_witness_complex_diagram_persistence_from_off_file_example.py"
-             --no-diagram -f ${CMAKE_SOURCE_DIR}/data/points/tore3D_300.off -a 1.0 -n 20 -d 2)
+    if(MATPLOTLIB_FOUND AND NUMPY_FOUND)
+      # Tangential
+      add_test(NAME tangential_complex_plain_homology_from_off_file_example_py_test
+               WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
+               COMMAND ${CMAKE_COMMAND} -E env "PYTHONPATH=${CMAKE_CURRENT_BINARY_DIR}"
+               ${PYTHON_EXECUTABLE} "${CMAKE_CURRENT_SOURCE_DIR}/example/tangential_complex_plain_homology_from_off_file_example.py"
+               --no-diagram -i 2 -f ${CMAKE_SOURCE_DIR}/data/points/tore3D_300.off)
+
+      add_gudhi_py_test(test_tangential_complex)
+
+      # Witness complex AND Subsampling
+      add_test(NAME euclidean_strong_witness_complex_diagram_persistence_from_off_file_example_py_test
+               WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
+               COMMAND ${CMAKE_COMMAND} -E env "PYTHONPATH=${CMAKE_CURRENT_BINARY_DIR}"
+               ${PYTHON_EXECUTABLE} "${CMAKE_CURRENT_SOURCE_DIR}/example/euclidean_strong_witness_complex_diagram_persistence_from_off_file_example.py"
+               --no-diagram -f ${CMAKE_SOURCE_DIR}/data/points/tore3D_300.off -a 1.0 -n 20 -d 2)
+
+      add_test(NAME euclidean_witness_complex_diagram_persistence_from_off_file_example_py_test
+               WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
+               COMMAND ${CMAKE_COMMAND} -E env "PYTHONPATH=${CMAKE_CURRENT_BINARY_DIR}"
+               ${PYTHON_EXECUTABLE} "${CMAKE_CURRENT_SOURCE_DIR}/example/euclidean_witness_complex_diagram_persistence_from_off_file_example.py"
+               --no-diagram -f ${CMAKE_SOURCE_DIR}/data/points/tore3D_300.off -a 1.0 -n 20 -d 2)
+    endif()
 
     # Subsampling
     add_gudhi_py_test(test_subsampling)
@@ -226,11 +291,13 @@ if(CYTHON_FOUND)
              COMMAND ${CMAKE_COMMAND} -E env "PYTHONPATH=${CMAKE_CURRENT_BINARY_DIR}"
              ${PYTHON_EXECUTABLE} "${CMAKE_CURRENT_SOURCE_DIR}/example/alpha_complex_from_points_example.py")
 
-    add_test(NAME alpha_complex_diagram_persistence_from_off_file_example_py_test
+    if(MATPLOTLIB_FOUND AND NUMPY_FOUND)
+      add_test(NAME alpha_complex_diagram_persistence_from_off_file_example_py_test
              WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
              COMMAND ${CMAKE_COMMAND} -E env "PYTHONPATH=${CMAKE_CURRENT_BINARY_DIR}"
              ${PYTHON_EXECUTABLE} "${CMAKE_CURRENT_SOURCE_DIR}/example/alpha_complex_diagram_persistence_from_off_file_example.py"
              --no-diagram -f ${CMAKE_SOURCE_DIR}/data/points/tore3D_300.off -a 0.6)
+    endif()
 
     add_gudhi_py_test(test_alpha_complex)
 
@@ -249,26 +316,30 @@ if(CYTHON_FOUND)
            ${PYTHON_EXECUTABLE} "${CMAKE_CURRENT_SOURCE_DIR}/example/periodic_cubical_complex_barcode_persistence_from_perseus_file_example.py"
            --no-barcode -f ${CMAKE_SOURCE_DIR}/data/bitmap/CubicalTwoSphere.txt)
 
-  add_test(NAME random_cubical_complex_persistence_example_py_test
-           WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
-           COMMAND ${CMAKE_COMMAND} -E env "PYTHONPATH=${CMAKE_CURRENT_BINARY_DIR}"
-           ${PYTHON_EXECUTABLE} "${CMAKE_CURRENT_SOURCE_DIR}/example/random_cubical_complex_persistence_example.py"
-           10 10 10)
+  if(NUMPY_FOUND)
+    add_test(NAME random_cubical_complex_persistence_example_py_test
+             WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
+             COMMAND ${CMAKE_COMMAND} -E env "PYTHONPATH=${CMAKE_CURRENT_BINARY_DIR}"
+             ${PYTHON_EXECUTABLE} "${CMAKE_CURRENT_SOURCE_DIR}/example/random_cubical_complex_persistence_example.py"
+             10 10 10)
+  endif()
 
   add_gudhi_py_test(test_cubical_complex)
 
   # Rips
-  add_test(NAME rips_complex_diagram_persistence_from_distance_matrix_file_example_py_test
-           WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
-           COMMAND ${CMAKE_COMMAND} -E env "PYTHONPATH=${CMAKE_CURRENT_BINARY_DIR}"
-           ${PYTHON_EXECUTABLE} "${CMAKE_CURRENT_SOURCE_DIR}/example/rips_complex_diagram_persistence_from_distance_matrix_file_example.py"
-           --no-diagram -f ${CMAKE_SOURCE_DIR}/data/distance_matrix/lower_triangular_distance_matrix.csv -e 12.0 -d 3)
-
-  add_test(NAME rips_complex_diagram_persistence_from_off_file_example_py_test
-           WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
-           COMMAND ${CMAKE_COMMAND} -E env "PYTHONPATH=${CMAKE_CURRENT_BINARY_DIR}"
-           ${PYTHON_EXECUTABLE} ${CMAKE_CURRENT_SOURCE_DIR}/example/rips_complex_diagram_persistence_from_off_file_example.py
-           --no-diagram -f ${CMAKE_SOURCE_DIR}/data/points/tore3D_300.off  -e 0.25 -d 3)
+  if(MATPLOTLIB_FOUND AND NUMPY_FOUND)
+    add_test(NAME rips_complex_diagram_persistence_from_distance_matrix_file_example_py_test
+             WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
+             COMMAND ${CMAKE_COMMAND} -E env "PYTHONPATH=${CMAKE_CURRENT_BINARY_DIR}"
+             ${PYTHON_EXECUTABLE} "${CMAKE_CURRENT_SOURCE_DIR}/example/rips_complex_diagram_persistence_from_distance_matrix_file_example.py"
+             --no-diagram -f ${CMAKE_SOURCE_DIR}/data/distance_matrix/lower_triangular_distance_matrix.csv -e 12.0 -d 3)
+    
+    add_test(NAME rips_complex_diagram_persistence_from_off_file_example_py_test
+             WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
+             COMMAND ${CMAKE_COMMAND} -E env "PYTHONPATH=${CMAKE_CURRENT_BINARY_DIR}"
+             ${PYTHON_EXECUTABLE} ${CMAKE_CURRENT_SOURCE_DIR}/example/rips_complex_diagram_persistence_from_off_file_example.py
+             --no-diagram -f ${CMAKE_SOURCE_DIR}/data/points/tore3D_300.off  -e 0.25 -d 3)
+  endif()
 
   add_test(NAME rips_complex_from_points_example_py_test
            WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
@@ -297,7 +368,7 @@ if(CYTHON_FOUND)
   add_gudhi_py_test(test_reader_utils)
 
   # Documentation generation is available through sphinx - requires all modules
-  if(SPHINX_PATH AND NOT CGAL_WITH_EIGEN3_VERSION VERSION_LESS 4.8.1)
+  if(SPHINX_PATH AND MATPLOTLIB_FOUND AND NUMPY_FOUND AND NOT CGAL_WITH_EIGEN3_VERSION VERSION_LESS 4.8.1)
     set (GUDHI_SPHINX_MESSAGE "Generating API documentation with Sphinx in ${CMAKE_CURRENT_BINARY_DIR}/sphinx/")
     # User warning - Sphinx is a static pages generator, and configured to work fine with user_version
     # Images and biblio warnings because not found on developper version
@@ -317,5 +388,5 @@ if(CYTHON_FOUND)
              COMMAND ${CMAKE_COMMAND} -E env "PYTHONPATH=${CMAKE_CURRENT_BINARY_DIR}"
              ${SPHINX_PATH} -b doctest ${CMAKE_CURRENT_SOURCE_DIR}/doc ${CMAKE_CURRENT_BINARY_DIR}/doctest)
 
-  endif(SPHINX_PATH AND NOT CGAL_WITH_EIGEN3_VERSION VERSION_LESS 4.8.1)
+  endif()
 endif(CYTHON_FOUND)
diff --git a/src/cython/cython/persistence_graphical_tools.py b/src/cython/cython/persistence_graphical_tools.py
index 7f604368..e172c65b 100755
--- a/src/cython/cython/persistence_graphical_tools.py
+++ b/src/cython/cython/persistence_graphical_tools.py
@@ -1,10 +1,3 @@
-import matplotlib.pyplot as plt
-import matplotlib.patches as mpatches
-import numpy as np
-from scipy.stats import kde
-import os
-import math
-
 """This file is part of the Gudhi Library. The Gudhi library
    (Geometric Understanding in Higher Dimensions) is a generic C++
    library for computational topology.
@@ -31,255 +24,268 @@ __author__ = "Vincent Rouvreau, Bertrand Michel"
 __copyright__ = "Copyright (C) 2016 Inria"
 __license__ = "GPL v3"
 
-def __min_birth_max_death(persistence, band=0.):
-    """This function returns (min_birth, max_death) from the persistence.
-
-    :param persistence: The persistence to plot.
-    :type persistence: list of tuples(dimension, tuple(birth, death)).
-    :param band: band
-    :type band: float.
-    :returns: (float, float) -- (min_birth, max_death).
-    """
-    # Look for minimum birth date and maximum death date for plot optimisation
-    max_death = 0
-    min_birth = persistence[0][1][0]
-    for interval in reversed(persistence):
-        if float(interval[1][1]) != float('inf'):
-            if float(interval[1][1]) > max_death:
-                max_death = float(interval[1][1])
-        if float(interval[1][0]) > max_death:
-            max_death = float(interval[1][0])
-        if float(interval[1][0]) < min_birth:
-            min_birth = float(interval[1][0])
-    if band > 0.:
-        max_death += band
-    return (min_birth, max_death)
+try:
+    import matplotlib.pyplot as plt
+    import matplotlib.patches as mpatches
+    import numpy as np
+    from scipy.stats import kde
+    import os
+    import math
+
+    def __min_birth_max_death(persistence, band=0.):
+        """This function returns (min_birth, max_death) from the persistence.
+
+        :param persistence: The persistence to plot.
+        :type persistence: list of tuples(dimension, tuple(birth, death)).
+        :param band: band
+        :type band: float.
+        :returns: (float, float) -- (min_birth, max_death).
+        """
+        # Look for minimum birth date and maximum death date for plot optimisation
+        max_death = 0
+        min_birth = persistence[0][1][0]
+        for interval in reversed(persistence):
+            if float(interval[1][1]) != float('inf'):
+                if float(interval[1][1]) > max_death:
+                    max_death = float(interval[1][1])
+            if float(interval[1][0]) > max_death:
+                max_death = float(interval[1][0])
+            if float(interval[1][0]) < min_birth:
+                min_birth = float(interval[1][0])
+        if band > 0.:
+            max_death += band
+        return (min_birth, max_death)
 
-"""
-Only 13 colors for the palette
-"""
-palette = ['#ff0000', '#00ff00', '#0000ff', '#00ffff', '#ff00ff', '#ffff00',
-           '#000000', '#880000', '#008800', '#000088', '#888800', '#880088',
-           '#008888']
- 
-def plot_persistence_barcode(persistence=[], persistence_file='', alpha=0.6,
-        max_barcodes=1000, inf_delta=0.1, legend=False):
-    """This function plots the persistence bar code from persistence values list
-    or from a :doc:`persistence file <fileformats>`.
-
-    :param persistence: Persistence values list.
-    :type persistence: list of tuples(dimension, tuple(birth, death)).
-    :param persistence_file: A :doc:`persistence file <fileformats>` style name
-        (reset persistence if both are set).
-    :type persistence_file: string
-    :param alpha: barcode transparency value (0.0 transparent through 1.0 opaque - default is 0.6).
-    :type alpha: float.
-    :param max_barcodes: number of maximal barcodes to be displayed.
-        Set it to 0 to see all, Default value is 1000.
-        (persistence will be sorted by life time if max_barcodes is set)
-    :type max_barcodes: int.
-    :param inf_delta: Infinity is placed at ((max_death - min_birth) x inf_delta).
-        A reasonable value is between 0.05 and 0.5 - default is 0.1.
-    :type inf_delta: float.
-    :param legend: Display the dimension color legend (default is False).
-    :type legend: boolean.
-    :returns: A matplotlib object containing horizontal bar plot of persistence
-        (launch `show()` method on it to display it).
-    """
-    if persistence_file is not '':
-        if os.path.isfile(persistence_file):
-            # Reset persistence
-            persistence = []
-            diag = read_persistence_intervals_grouped_by_dimension(persistence_file=persistence_file)
-            for key in diag.keys():
-                for persistence_interval in diag[key]:
-                    persistence.append((key, persistence_interval))
-        else:
-            print("file " + persistence_file + " not found.")
-            return None
-
-    if max_barcodes > 0 and max_barcodes < len(persistence):
-        # Sort by life time, then takes only the max_plots elements
-        persistence = sorted(persistence, key=lambda life_time: life_time[1][1]-life_time[1][0], reverse=True)[:max_barcodes]
-
-    persistence = sorted(persistence, key=lambda birth: birth[1][0])
-
-    (min_birth, max_death) = __min_birth_max_death(persistence)
-    ind = 0
-    delta = ((max_death - min_birth) * inf_delta)
-    # Replace infinity values with max_death + delta for bar code to be more
-    # readable
-    infinity = max_death + delta
-    axis_start = min_birth - delta
-    # Draw horizontal bars in loop
-    for interval in reversed(persistence):
-        if float(interval[1][1]) != float('inf'):
-            # Finite death case
-            plt.barh(ind, (interval[1][1] - interval[1][0]), height=0.8,
-                     left = interval[1][0], alpha=alpha,
-                     color = palette[interval[0]],
-                     linewidth=0)
-        else:
-            # Infinite death case for diagram to be nicer
-            plt.barh(ind, (infinity - interval[1][0]), height=0.8,
-                     left = interval[1][0], alpha=alpha,
-                     color = palette[interval[0]],
-                     linewidth=0)
-        ind = ind + 1
-
-    if legend:
-        dimensions = list(set(item[0] for item in persistence))
-        plt.legend(handles=[mpatches.Patch(color=palette[dim],
-                                           label=str(dim)) for dim in dimensions],
-                   loc='lower right')
-    plt.title('Persistence barcode')
-    # Ends plot on infinity value and starts a little bit before min_birth
-    plt.axis([axis_start, infinity, 0, ind])
-    return plt
-
-def plot_persistence_diagram(persistence=[], persistence_file='', alpha=0.6,
-        band=0., max_plots=1000, inf_delta=0.1, legend=False):
-    """This function plots the persistence diagram from persistence values list
-    or from a :doc:`persistence file <fileformats>`.
-
-    :param persistence: Persistence values list.
-    :type persistence: list of tuples(dimension, tuple(birth, death)).
-    :param persistence_file: A :doc:`persistence file <fileformats>` style name
-        (reset persistence if both are set).
-    :type persistence_file: string
-    :param alpha: plot transparency value (0.0 transparent through 1.0 opaque - default is 0.6).
-    :type alpha: float.
-    :param band: band (not displayed if :math:`\leq` 0. - default is 0.)
-    :type band: float.
-    :param max_plots: number of maximal plots to be displayed
-        Set it to 0 to see all, Default value is 1000.
-        (persistence will be sorted by life time if max_plots is set)
-    :type max_plots: int.
-    :param inf_delta: Infinity is placed at ((max_death - min_birth) x inf_delta).
-        A reasonable value is between 0.05 and 0.5 - default is 0.1.
-    :type inf_delta: float.
-    :param legend: Display the dimension color legend (default is False).
-    :type legend: boolean.
-    :returns: A matplotlib object containing diagram plot of persistence
-        (launch `show()` method on it to display it).
     """
-    if persistence_file is not '':
-        if os.path.isfile(persistence_file):
-            # Reset persistence
-            persistence = []
-            diag = read_persistence_intervals_grouped_by_dimension(persistence_file=persistence_file)
-            for key in diag.keys():
-                for persistence_interval in diag[key]:
-                    persistence.append((key, persistence_interval))
-        else:
-            print("file " + persistence_file + " not found.")
-            return None
-
-    if max_plots > 0 and max_plots < len(persistence):
-        # Sort by life time, then takes only the max_plots elements
-        persistence = sorted(persistence, key=lambda life_time: life_time[1][1]-life_time[1][0], reverse=True)[:max_plots]
-
-    (min_birth, max_death) = __min_birth_max_death(persistence, band)
-    delta = ((max_death - min_birth) * inf_delta)
-    # Replace infinity values with max_death + delta for diagram to be more
-    # readable
-    infinity = max_death + delta
-    axis_start = min_birth - delta
-
-    # line display of equation : birth = death
-    x = np.linspace(axis_start, infinity, 1000)
-    # infinity line and text
-    plt.plot(x, x, color='k', linewidth=1.0)
-    plt.plot(x, [infinity] * len(x), linewidth=1.0, color='k', alpha=alpha)
-    plt.text(axis_start, infinity, r'$\infty$', color='k', alpha=alpha)
-    # bootstrap band
-    if band > 0.:
-        plt.fill_between(x, x, x+band, alpha=alpha, facecolor='red')
-
-    # Draw points in loop
-    for interval in reversed(persistence):
-        if float(interval[1][1]) != float('inf'):
-            # Finite death case
-            plt.scatter(interval[1][0], interval[1][1], alpha=alpha,
-                        color = palette[interval[0]])
-        else:
-            # Infinite death case for diagram to be nicer
-            plt.scatter(interval[1][0], infinity, alpha=alpha,
-                        color = palette[interval[0]])
-
-    if legend:
-        dimensions = list(set(item[0] for item in persistence))
-        plt.legend(handles=[mpatches.Patch(color=palette[dim], label=str(dim)) for dim in dimensions])
-
-    plt.title('Persistence diagram')
-    plt.xlabel('Birth')
-    plt.ylabel('Death')
-    # Ends plot on infinity value and starts a little bit before min_birth
-    plt.axis([axis_start, infinity, axis_start, infinity + delta])
-    return plt
-
-def plot_persistence_density(persistence=[], persistence_file='', nbins=300,
-                             max_plots=1000, cmap=plt.cm.hot_r, legend=False):
-    """This function plots the persistence density from persistence values list
-    or from a :doc:`persistence file <fileformats>`. Be aware that this
-    function does not distinguish the dimension, it is up to you to select the
-    required one.
-
-    :param persistence: Persistence values list.
-    :type persistence: list of tuples(dimension, tuple(birth, death)).
-    :param persistence_file: A :doc:`persistence file <fileformats>` style name
-        (reset persistence if both are set).
-    :type persistence_file: string
-    :param nbins: Evaluate a gaussian kde on a regular grid of nbins x nbins
-        over data extents (default is 300)
-    :type nbins: int.
-    :param max_plots: number of maximal plots to be displayed
-        Set it to 0 to see all, Default value is 1000.
-        (persistence will be sorted by life time if max_plots is set)
-    :type max_plots: int.
-    :param cmap: A matplotlib colormap (default is matplotlib.pyplot.cm.hot_r).
-    :type cmap: cf. matplotlib colormap.
-    :param legend: Display the color bar values (default is False).
-    :type legend: boolean.
-    :returns: A matplotlib object containing diagram plot of persistence
-        (launch `show()` method on it to display it).
+    Only 13 colors for the palette
     """
-    if persistence_file is not '':
-        if os.path.isfile(persistence_file):
-            # Reset persistence
-            persistence = []
-            diag = read_persistence_intervals_grouped_by_dimension(persistence_file=persistence_file)
-            for key in diag.keys():
-                for persistence_interval in diag[key]:
-                    persistence.append((key, persistence_interval))
-        else:
-            print("file " + persistence_file + " not found.")
-            return None
-
-    if max_plots > 0 and max_plots < len(persistence):
-        # Sort by life time, then takes only the max_plots elements
-        persistence = sorted(persistence, key=lambda life_time: life_time[1][1]-life_time[1][0], reverse=True)[:max_plots]
-
-    # Set as numpy array birth and death (remove undefined values - inf and NaN)
-    birth = np.asarray([(interval[1][0]) for interval in persistence if (math.isfinite(interval[1][1]) and math.isfinite(interval[1][0]))])
-    death = np.asarray([(interval[1][1]) for interval in persistence if (math.isfinite(interval[1][1]) and math.isfinite(interval[1][0]))])
-
-    # line display of equation : birth = death
-    x = np.linspace(death.min(), birth.max(), 1000)
-    plt.plot(x, x, color='k', linewidth=1.0)
-
-    # Evaluate a gaussian kde on a regular grid of nbins x nbins over data extents
-    k = kde.gaussian_kde([birth,death])
-    xi, yi = np.mgrid[birth.min():birth.max():nbins*1j, death.min():death.max():nbins*1j]
-    zi = k(np.vstack([xi.flatten(), yi.flatten()]))
-
-    # Make the plot
-    plt.pcolormesh(xi, yi, zi.reshape(xi.shape), cmap=cmap)
-
-    if legend:
-        plt.colorbar()
-
-    plt.title('Persistence density')
-    plt.xlabel('Birth')
-    plt.ylabel('Death')
-    return plt
+    palette = ['#ff0000', '#00ff00', '#0000ff', '#00ffff', '#ff00ff', '#ffff00',
+               '#000000', '#880000', '#008800', '#000088', '#888800', '#880088',
+               '#008888']
+
+    def plot_persistence_barcode(persistence=[], persistence_file='', alpha=0.6,
+            max_barcodes=1000, inf_delta=0.1, legend=False):
+        """This function plots the persistence bar code from persistence values list
+        or from a :doc:`persistence file <fileformats>`.
+
+        :param persistence: Persistence values list.
+        :type persistence: list of tuples(dimension, tuple(birth, death)).
+        :param persistence_file: A :doc:`persistence file <fileformats>` style name
+            (reset persistence if both are set).
+        :type persistence_file: string
+        :param alpha: barcode transparency value (0.0 transparent through 1.0 opaque - default is 0.6).
+        :type alpha: float.
+        :param max_barcodes: number of maximal barcodes to be displayed.
+            Set it to 0 to see all, Default value is 1000.
+            (persistence will be sorted by life time if max_barcodes is set)
+        :type max_barcodes: int.
+        :param inf_delta: Infinity is placed at ((max_death - min_birth) x inf_delta).
+            A reasonable value is between 0.05 and 0.5 - default is 0.1.
+        :type inf_delta: float.
+        :param legend: Display the dimension color legend (default is False).
+        :type legend: boolean.
+        :returns: A matplotlib object containing horizontal bar plot of persistence
+            (launch `show()` method on it to display it).
+        """
+        if persistence_file is not '':
+            if os.path.isfile(persistence_file):
+                # Reset persistence
+                persistence = []
+                diag = read_persistence_intervals_grouped_by_dimension(persistence_file=persistence_file)
+                for key in diag.keys():
+                    for persistence_interval in diag[key]:
+                        persistence.append((key, persistence_interval))
+            else:
+                print("file " + persistence_file + " not found.")
+                return None
+
+        if max_barcodes > 0 and max_barcodes < len(persistence):
+            # Sort by life time, then takes only the max_plots elements
+            persistence = sorted(persistence, key=lambda life_time: life_time[1][1]-life_time[1][0], reverse=True)[:max_barcodes]
+
+        persistence = sorted(persistence, key=lambda birth: birth[1][0])
+
+        (min_birth, max_death) = __min_birth_max_death(persistence)
+        ind = 0
+        delta = ((max_death - min_birth) * inf_delta)
+        # Replace infinity values with max_death + delta for bar code to be more
+        # readable
+        infinity = max_death + delta
+        axis_start = min_birth - delta
+        # Draw horizontal bars in loop
+        for interval in reversed(persistence):
+            if float(interval[1][1]) != float('inf'):
+                # Finite death case
+                plt.barh(ind, (interval[1][1] - interval[1][0]), height=0.8,
+                         left = interval[1][0], alpha=alpha,
+                         color = palette[interval[0]],
+                         linewidth=0)
+            else:
+                # Infinite death case for diagram to be nicer
+                plt.barh(ind, (infinity - interval[1][0]), height=0.8,
+                         left = interval[1][0], alpha=alpha,
+                         color = palette[interval[0]],
+                         linewidth=0)
+            ind = ind + 1
+
+        if legend:
+            dimensions = list(set(item[0] for item in persistence))
+            plt.legend(handles=[mpatches.Patch(color=palette[dim],
+                                               label=str(dim)) for dim in dimensions],
+                       loc='lower right')
+        plt.title('Persistence barcode')
+        # Ends plot on infinity value and starts a little bit before min_birth
+        plt.axis([axis_start, infinity, 0, ind])
+        return plt
+
+    def plot_persistence_diagram(persistence=[], persistence_file='', alpha=0.6,
+            band=0., max_plots=1000, inf_delta=0.1, legend=False):
+        """This function plots the persistence diagram from persistence values list
+        or from a :doc:`persistence file <fileformats>`.
+
+        :param persistence: Persistence values list.
+        :type persistence: list of tuples(dimension, tuple(birth, death)).
+        :param persistence_file: A :doc:`persistence file <fileformats>` style name
+            (reset persistence if both are set).
+        :type persistence_file: string
+        :param alpha: plot transparency value (0.0 transparent through 1.0 opaque - default is 0.6).
+        :type alpha: float.
+        :param band: band (not displayed if :math:`\leq` 0. - default is 0.)
+        :type band: float.
+        :param max_plots: number of maximal plots to be displayed
+            Set it to 0 to see all, Default value is 1000.
+            (persistence will be sorted by life time if max_plots is set)
+        :type max_plots: int.
+        :param inf_delta: Infinity is placed at ((max_death - min_birth) x inf_delta).
+            A reasonable value is between 0.05 and 0.5 - default is 0.1.
+        :type inf_delta: float.
+        :param legend: Display the dimension color legend (default is False).
+        :type legend: boolean.
+        :returns: A matplotlib object containing diagram plot of persistence
+            (launch `show()` method on it to display it).
+        """
+        if persistence_file is not '':
+            if os.path.isfile(persistence_file):
+                # Reset persistence
+                persistence = []
+                diag = read_persistence_intervals_grouped_by_dimension(persistence_file=persistence_file)
+                for key in diag.keys():
+                    for persistence_interval in diag[key]:
+                        persistence.append((key, persistence_interval))
+            else:
+                print("file " + persistence_file + " not found.")
+                return None
+
+        if max_plots > 0 and max_plots < len(persistence):
+            # Sort by life time, then takes only the max_plots elements
+            persistence = sorted(persistence, key=lambda life_time: life_time[1][1]-life_time[1][0], reverse=True)[:max_plots]
+
+        (min_birth, max_death) = __min_birth_max_death(persistence, band)
+        delta = ((max_death - min_birth) * inf_delta)
+        # Replace infinity values with max_death + delta for diagram to be more
+        # readable
+        infinity = max_death + delta
+        axis_start = min_birth - delta
+
+        # line display of equation : birth = death
+        x = np.linspace(axis_start, infinity, 1000)
+        # infinity line and text
+        plt.plot(x, x, color='k', linewidth=1.0)
+        plt.plot(x, [infinity] * len(x), linewidth=1.0, color='k', alpha=alpha)
+        plt.text(axis_start, infinity, r'$\infty$', color='k', alpha=alpha)
+        # bootstrap band
+        if band > 0.:
+            plt.fill_between(x, x, x+band, alpha=alpha, facecolor='red')
+
+        # Draw points in loop
+        for interval in reversed(persistence):
+            if float(interval[1][1]) != float('inf'):
+                # Finite death case
+                plt.scatter(interval[1][0], interval[1][1], alpha=alpha,
+                            color = palette[interval[0]])
+            else:
+                # Infinite death case for diagram to be nicer
+                plt.scatter(interval[1][0], infinity, alpha=alpha,
+                            color = palette[interval[0]])
+            ind = ind + 1
+
+        if legend:
+            dimensions = list(set(item[0] for item in persistence))
+            plt.legend(handles=[mpatches.Patch(color=palette[dim], label=str(dim)) for dim in dimensions])
+
+        plt.title('Persistence diagram')
+        plt.xlabel('Birth')
+        plt.ylabel('Death')
+        # Ends plot on infinity value and starts a little bit before min_birth
+        plt.axis([axis_start, infinity, axis_start, infinity + delta])
+        return plt
+
+    def plot_persistence_density(persistence=[], persistence_file='', nbins=300,
+                                 max_plots=1000, cmap=plt.cm.hot_r, legend=False):
+        """This function plots the persistence density from persistence values list
+        or from a :doc:`persistence file <fileformats>`. Be aware that this
+        function does not distinguish the dimension, it is up to you to select the
+        required one.
+
+        :param persistence: Persistence values list.
+        :type persistence: list of tuples(dimension, tuple(birth, death)).
+        :param persistence_file: A :doc:`persistence file <fileformats>` style name
+            (reset persistence if both are set).
+        :type persistence_file: string
+        :param nbins: Evaluate a gaussian kde on a regular grid of nbins x nbins
+            over data extents (default is 300)
+        :type nbins: int.
+        :param max_plots: number of maximal plots to be displayed
+            Set it to 0 to see all, Default value is 1000.
+            (persistence will be sorted by life time if max_plots is set)
+        :type max_plots: int.
+        :param cmap: A matplotlib colormap (default is matplotlib.pyplot.cm.hot_r).
+        :type cmap: cf. matplotlib colormap.
+        :param legend: Display the color bar values (default is False).
+        :type legend: boolean.
+        :returns: A matplotlib object containing diagram plot of persistence
+            (launch `show()` method on it to display it).
+        """
+        if persistence_file is not '':
+            if os.path.isfile(persistence_file):
+                # Reset persistence
+                persistence = []
+                diag = read_persistence_intervals_grouped_by_dimension(persistence_file=persistence_file)
+                for key in diag.keys():
+                    for persistence_interval in diag[key]:
+                        persistence.append((key, persistence_interval))
+            else:
+                print("file " + persistence_file + " not found.")
+                return None
+
+        if max_plots > 0 and max_plots < len(persistence):
+            # Sort by life time, then takes only the max_plots elements
+            persistence = sorted(persistence, key=lambda life_time: life_time[1][1]-life_time[1][0], reverse=True)[:max_plots]
+
+        # Set as numpy array birth and death (remove undefined values - inf and NaN)
+        birth = np.asarray([(interval[1][0]) for interval in persistence if (math.isfinite(interval[1][1]) and math.isfinite(interval[1][0]))])
+        death = np.asarray([(interval[1][1]) for interval in persistence if (math.isfinite(interval[1][1]) and math.isfinite(interval[1][0]))])
+
+        # line display of equation : birth = death
+        x = np.linspace(death.min(), birth.max(), 1000)
+        plt.plot(x, x, color='k', linewidth=1.0)
+
+        # Evaluate a gaussian kde on a regular grid of nbins x nbins over data extents
+        k = kde.gaussian_kde([birth,death])
+        xi, yi = np.mgrid[birth.min():birth.max():nbins*1j, death.min():death.max():nbins*1j]
+        zi = k(np.vstack([xi.flatten(), yi.flatten()]))
+
+        # Make the plot
+        plt.pcolormesh(xi, yi, zi.reshape(xi.shape), cmap=cmap)
+
+        if legend:
+            plt.colorbar()
+
+        plt.title('Persistence density')
+        plt.xlabel('Birth')
+        plt.ylabel('Death')
+        return plt
+
+except ImportError:
+    # Continue in case of import error, functions won't be available
+    pass
diff --git a/src/cython/doc/installation.rst b/src/cython/doc/installation.rst
index ff6c7273..ef2f7af2 100644
--- a/src/cython/doc/installation.rst
+++ b/src/cython/doc/installation.rst
@@ -47,9 +47,61 @@ following command in a terminal:
     export PYTHONPATH='$PYTHONPATH:/path-to-gudhi/build/cython'
     ctest -R py_test
 
-If tests fail, please try to :code:`import gudhi` and check the errors.
+Debugging issues
+================
+
+If tests fail, please check your PYTHONPATH and try to :code:`import gudhi`
+and check the errors.
 The problem can come from a third-party library bad link or installation.
 
+If :code:`import gudhi` succeeds, please have a look to debug informations:
+
+.. code-block:: python
+
+    import gudhi
+    print(gudhi.__debug_info__)
+
+You shall have something like:
+
+.. code-block:: none
+
+    Python version 2.7.15
+    Cython version 0.26.1
+    Eigen3 version 3.1.1
+    Installed modules are: off_reader;simplex_tree;rips_complex;cubical_complex;periodic_cubical_complex;
+        persistence_graphical_tools;reader_utils;witness_complex;strong_witness_complex;alpha_complex;
+        euclidean_witness_complex;euclidean_strong_witness_complex;
+    Missing modules are: bottleneck_distance;nerve_gic;subsampling;tangential_complex;persistence_graphical_tools;
+    CGAL version 4.7.1000
+    GMP_LIBRARIES = /usr/lib/x86_64-linux-gnu/libgmp.so
+    GMPXX_LIBRARIES = /usr/lib/x86_64-linux-gnu/libgmpxx.so
+    TBB version 9107 found and used
+
+Here, you can see that bottleneck_distance, nerve_gic, subsampling and
+tangential_complex are missing because of the CGAL version.
+persistence_graphical_tools is not available as numpy and matplotlib are not
+available.
+Unitary tests cannot be run as pytest is missing.
+
+A complete configuration would be :
+
+.. code-block:: none
+
+    Python version 3.6.5
+    Cython version 0.28.2
+    Pytest version 3.3.2
+    Matplotlib version 2.2.2
+    Numpy version 1.14.5
+    Eigen3 version 3.3.4
+    Installed modules are: off_reader;simplex_tree;rips_complex;cubical_complex;periodic_cubical_complex;
+        persistence_graphical_tools;reader_utils;witness_complex;strong_witness_complex;persistence_graphical_tools;
+        bottleneck_distance;nerve_gic;subsampling;tangential_complex;alpha_complex;euclidean_witness_complex;
+        euclidean_strong_witness_complex;
+    CGAL header only version 4.11.0
+    GMP_LIBRARIES = /usr/lib/x86_64-linux-gnu/libgmp.so
+    GMPXX_LIBRARIES = /usr/lib/x86_64-linux-gnu/libgmpxx.so
+    TBB version 9107 found and used
+
 Documentation
 =============
 
diff --git a/src/cython/gudhi.pyx.in b/src/cython/gudhi.pyx.in
index 56a72b04..0d4b966b 100644
--- a/src/cython/gudhi.pyx.in
+++ b/src/cython/gudhi.pyx.in
@@ -26,6 +26,7 @@ __license__ = "GPL v3"
 __version__ = "@GUDHI_VERSION@"
 # This variable is used by doctest to find files
 __root_source_dir__ = "@CMAKE_SOURCE_DIR@"
+__debug_info__ = @GUDHI_CYTHON_DEBUG_INFO@
 
 include '@CMAKE_CURRENT_SOURCE_DIR@/cython/off_reader.pyx'
 include '@CMAKE_CURRENT_SOURCE_DIR@/cython/simplex_tree.pyx'
diff --git a/src/cython/setup.py.in b/src/cython/setup.py.in
index 22b2954e..4037aab6 100644
--- a/src/cython/setup.py.in
+++ b/src/cython/setup.py.in
@@ -46,10 +46,5 @@ setup(
     version='@GUDHI_VERSION@',
     url='http://gudhi.gforge.inria.fr/',
     ext_modules = cythonize(gudhi),
-    install_requires = [
-        "matplotlib",
-        "numpy",
-        "scipy",
-        "cython",
-        ],
+    install_requires = ["cython",],
 )