https://gitlab.inria.fr/GUDHI/gudhi-devel/issues/32 - [Cmake - Qt5] CMake outputs an error when Qt5 is not installed

Modify/add cmake messages for missing modules


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

Former-commit-id: 37e1035f7c27ce994e05386801d72959696de7d4

7 files changed, 434 insertions, 369 deletions

diff --git a/CMakeLists.txt b/CMakeLists.txt
index afacede9..d61df992 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -6,6 +6,10 @@ include(CMakeGUDHIVersion.txt)
 
 list(APPEND CMAKE_MODULE_PATH "${CMAKE_SOURCE_DIR}/src/cmake/modules/")
 
+# Reset cache
+set(GUDHI_MODULES "" CACHE INTERNAL "GUDHI_MODULES")
+set(GUDHI_MISSING_MODULES "" CACHE INTERNAL "GUDHI_MISSING_MODULES")
+
 # This variable is used by Cython CMakeLists.txt and by GUDHI_third_party_libraries to know its path
 set(GUDHI_CYTHON_PATH "src/cython")
 
@@ -37,8 +41,6 @@ add_gudhi_module(Tangential_complex)
 add_gudhi_module(Witness_complex)
 add_gudhi_module(Nerve_GIC)
 
-message("++ GUDHI_MODULES list is:\"${GUDHI_MODULES}\"")
-
 # Include module CMake subdirectories
 # GUDHI_SUB_DIRECTORIES is managed in CMAKE_MODULE_PATH/GUDHI_modules.cmake
 foreach(GUDHI_MODULE ${GUDHI_MODULES})
@@ -54,9 +56,15 @@ add_subdirectory(src/GudhUI)
 if (WITH_GUDHI_PYTHON)
   # specific for cython module
   add_subdirectory(${GUDHI_CYTHON_PATH})
+else()
+  message("++ Python module will not be compiled because WITH_GUDHI_PYTHON is set to OFF")
+  set(GUDHI_MISSING_MODULES ${GUDHI_MISSING_MODULES} "python")
 endif()
 
 # For "make user_version" - Requires GUDHI_modules to be performed
 include(GUDHI_user_version_target)
 # For "make doxygen" - Requires GUDHI_USER_VERSION_DIR to be set - Done in GUDHI_user_version_target for dev version
 include(GUDHI_doxygen_target)
+
+message("++ GUDHI_MODULES list is:\"${GUDHI_MODULES}\"")
+message("++ GUDHI_MISSING_MODULES list is:\"${GUDHI_MISSING_MODULES}\"")
diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt
index 6c446104..b40d506a 100644
--- a/src/CMakeLists.txt
+++ b/src/CMakeLists.txt
@@ -6,6 +6,9 @@ include(CMakeGUDHIVersion.txt)
 
 list(APPEND CMAKE_MODULE_PATH "${CMAKE_SOURCE_DIR}/cmake/modules/")
 
+set(GUDHI_MODULES "" CACHE INTERNAL "GUDHI_MODULES")
+set(GUDHI_MISSING_MODULES "" CACHE INTERNAL "GUDHI_MISSING_MODULES")
+
 # This variable is used by Cython CMakeLists.txt and by GUDHI_third_party_libraries to know its path
 set(GUDHI_CYTHON_PATH "cython")
 
@@ -35,8 +38,6 @@ add_gudhi_module(Tangential_complex)
 add_gudhi_module(Witness_complex)
 add_gudhi_module(Nerve_GIC)
 
-message("++ GUDHI_MODULES list is:\"${GUDHI_MODULES}\"")
-
 # For "make doxygen" - Requires GUDHI_USER_VERSION_DIR to be set
 set(GUDHI_USER_VERSION_DIR ${CMAKE_SOURCE_DIR})
 include(GUDHI_doxygen_target)
@@ -60,7 +61,14 @@ add_subdirectory(GudhUI)
 if (WITH_GUDHI_PYTHON)
   # specific for cython module
   add_subdirectory(${GUDHI_CYTHON_PATH})
+else()
+  message("++ Python module will not be compiled because WITH_GUDHI_PYTHON is set to OFF")
+  set(GUDHI_MISSING_MODULES ${GUDHI_MISSING_MODULES} "python")
 endif()
+
+message("++ GUDHI_MODULES list is:\"${GUDHI_MODULES}\"")
+message("++ GUDHI_MISSING_MODULES list is:\"${GUDHI_MISSING_MODULES}\"")
+
 #---------------------------------------------------------------------------------------
 
 #---------------------------------------------------------------------------------------
diff --git a/src/GudhUI/CMakeLists.txt b/src/GudhUI/CMakeLists.txt
index b357b8f7..0945e758 100644
--- a/src/GudhUI/CMakeLists.txt
+++ b/src/GudhUI/CMakeLists.txt
@@ -1,40 +1,55 @@
 project(GudhUI)
 
 # Need to find OpenGL first as find_package(Qt5) tries to #include"GL/gl.h" on some platforms
-find_package(OpenGL)
+find_package(OpenGL QUIET)
 
 if (OPENGL_FOUND)
-  find_package(Qt5 COMPONENTS Widgets Xml OpenGL)
-  find_package(QGLViewer)
-  
-  if ( CGAL_FOUND AND Qt5_FOUND AND QGLVIEWER_FOUND AND NOT CGAL_VERSION VERSION_EQUAL 4.8.0)
-  
-    set(CMAKE_AUTOMOC ON)
-    set(CMAKE_AUTOUIC ON)
-    set(CMAKE_INCLUDE_CURRENT_DIR ON)
-  
-    SET(Boost_USE_STATIC_LIBS ON)
-    SET(Boost_USE_MULTITHREAD OFF)
-    include_directories (${QGLVIEWER_INCLUDE_DIR})
-   
-    add_executable  ( GudhUI 
-      gui/gudhui.cpp
-      gui/MainWindow.cpp
-      gui/Menu_k_nearest_neighbors.cpp	
-      gui/Menu_uniform_neighbors.cpp
-      gui/Menu_edge_contraction.cpp  
-      gui/Menu_persistence.cpp
-      view/Viewer_instructor.cpp				
-      view/Viewer.cpp
-    )	
-    target_link_libraries( GudhUI Qt5::Widgets Qt5::Xml Qt5::OpenGL )
-    target_link_libraries( GudhUI ${QGLVIEWER_LIBRARIES} )
-    target_link_libraries( GudhUI ${OPENGL_gl_LIBRARY} ${OPENGL_glu_LIBRARY} )	
-    if (TBB_FOUND)
-      target_link_libraries( GudhUI ${TBB_LIBRARIES})
+  find_package(Qt5 COMPONENTS Widgets Xml OpenGL QUIET)
+  if (Qt5_FOUND)
+    find_package(QGLViewer QUIET)
+    if ( QGLVIEWER_FOUND)
+
+      if ( CGAL_FOUND AND NOT CGAL_VERSION VERSION_EQUAL 4.8.0)
+        set(CMAKE_AUTOMOC ON)
+        set(CMAKE_AUTOUIC ON)
+        set(CMAKE_INCLUDE_CURRENT_DIR ON)
+
+        SET(Boost_USE_STATIC_LIBS ON)
+        SET(Boost_USE_MULTITHREAD OFF)
+        include_directories (${QGLVIEWER_INCLUDE_DIR})
+
+        add_executable  ( GudhUI
+          gui/gudhui.cpp
+          gui/MainWindow.cpp
+          gui/Menu_k_nearest_neighbors.cpp
+          gui/Menu_uniform_neighbors.cpp
+          gui/Menu_edge_contraction.cpp
+          gui/Menu_persistence.cpp
+          view/Viewer_instructor.cpp
+          view/Viewer.cpp
+        )
+        target_link_libraries( GudhUI Qt5::Widgets Qt5::Xml Qt5::OpenGL )
+        target_link_libraries( GudhUI ${QGLVIEWER_LIBRARIES} )
+        target_link_libraries( GudhUI ${OPENGL_gl_LIBRARY} ${OPENGL_glu_LIBRARY} )
+        if (TBB_FOUND)
+          target_link_libraries( GudhUI ${TBB_LIBRARIES})
+        endif()
+
+        install(TARGETS GudhUI DESTINATION bin)
+        set(GUDHI_MODULES ${GUDHI_MODULES} "GudhUI" CACHE INTERNAL "GUDHI_MODULES")
+      else()
+        message("++ GudhUI will not be compiled because CGAL < 4.8.0 or not found")
+        set(GUDHI_MISSING_MODULES ${GUDHI_MISSING_MODULES} "GudhUI" CACHE INTERNAL "GUDHI_MISSING_MODULES")
+      endif()
+    else()
+      message("++ GudhUI will not be compiled because QGLViewer is not found")
+      set(GUDHI_MISSING_MODULES ${GUDHI_MISSING_MODULES} "GudhUI" CACHE INTERNAL "GUDHI_MISSING_MODULES")
     endif()
-  
-    install(TARGETS GudhUI DESTINATION bin)
-  
+  else()
+    message("++ GudhUI will not be compiled because Qt5 COMPONENTS Widgets Xml OpenGL are not found")
+    set(GUDHI_MISSING_MODULES ${GUDHI_MISSING_MODULES} "GudhUI" CACHE INTERNAL "GUDHI_MISSING_MODULES")
   endif()
-endif(OPENGL_FOUND)
+else()
+  message("++ GudhUI will not be compiled because OpenGL is not found")
+  set(GUDHI_MISSING_MODULES ${GUDHI_MISSING_MODULES} "GudhUI" CACHE INTERNAL "GUDHI_MISSING_MODULES")
+endif()
diff --git a/src/cmake/modules/GUDHI_doxygen_target.cmake b/src/cmake/modules/GUDHI_doxygen_target.cmake
index 9e10e566..7a84c4e0 100644
--- a/src/cmake/modules/GUDHI_doxygen_target.cmake
+++ b/src/cmake/modules/GUDHI_doxygen_target.cmake
@@ -1,7 +1,7 @@
 # add a target to generate API documentation with Doxygen
-find_package(Doxygen)
+find_package(Doxygen QUIET)
 if(DOXYGEN_FOUND)
-  # configure_file(${CMAKE_CURRENT_SOURCE_DIR}/Doxyfile.in ${CMAKE_CURRENT_BINARY_DIR}/Doxyfile @ONLY)
+  set(GUDHI_MODULES ${GUDHI_MODULES} "cpp-documentation" CACHE INTERNAL "GUDHI_MODULES")
 
   # starting from cmake 3.9 the usage of DOXYGEN_EXECUTABLE is deprecated
   if(TARGET Doxygen::doxygen)
@@ -16,4 +16,6 @@ if(DOXYGEN_FOUND)
     # In dev version, doxygen target depends on user_version target. Not existing in user version
     add_dependencies(doxygen user_version)
   endif()
-endif(DOXYGEN_FOUND)
+else()
+  set(GUDHI_MISSING_MODULES ${GUDHI_MISSING_MODULES} "cpp-documentation" CACHE INTERNAL "GUDHI_MISSING_MODULES")
+endif()
diff --git a/src/cmake/modules/GUDHI_modules.cmake b/src/cmake/modules/GUDHI_modules.cmake
index f95d0c34..aab1dd08 100644
--- a/src/cmake/modules/GUDHI_modules.cmake
+++ b/src/cmake/modules/GUDHI_modules.cmake
@@ -1,11 +1,12 @@
 # A function to add a new module in GUDHI
 
-set(GUDHI_MODULES "")
 set(GUDHI_MODULES_FULL_LIST "")
 function(add_gudhi_module file_path)
   option("WITH_MODULE_GUDHI_${file_path}" "Activate/desactivate ${file_path} compilation and installation" ON)
   if (WITH_MODULE_GUDHI_${file_path})
-    set(GUDHI_MODULES ${GUDHI_MODULES} ${file_path} PARENT_SCOPE)
+    set(GUDHI_MODULES ${GUDHI_MODULES} ${file_path} CACHE INTERNAL "GUDHI_MODULES")
+  else()
+    set(GUDHI_MISSING_MODULES ${GUDHI_MISSING_MODULES} ${file_path} CACHE INTERNAL "GUDHI_MISSING_MODULES")
   endif()
   # Required by user_version
   set(GUDHI_MODULES_FULL_LIST ${GUDHI_MODULES_FULL_LIST} ${file_path} PARENT_SCOPE)
diff --git a/src/cmake/modules/GUDHI_third_party_libraries.cmake b/src/cmake/modules/GUDHI_third_party_libraries.cmake
index f03c2177..122754d5 100644
--- a/src/cmake/modules/GUDHI_third_party_libraries.cmake
+++ b/src/cmake/modules/GUDHI_third_party_libraries.cmake
@@ -21,11 +21,11 @@ endif()
 # A fix would be to use https://cmake.org/cmake/help/v3.1/prop_gbl/CMAKE_CXX_KNOWN_FEATURES.html
 # or even better https://cmake.org/cmake/help/v3.1/variable/CMAKE_CXX_STANDARD.html
 # but it implies to use cmake version 3.1 at least.
-find_package(CGAL)
+find_package(CGAL QUIET)
 
 # Only CGAL versions > 4.4 supports what Gudhi uses from CGAL
 if (CGAL_VERSION VERSION_LESS 4.4.0)
-  message("CGAL version ${CGAL_VERSION} is considered too old to be used by Gudhi.")
+  message("++ CGAL version ${CGAL_VERSION} is considered too old to be used by Gudhi.")
   unset(CGAL_FOUND)
 endif()
 if(CGAL_FOUND)
diff --git a/src/cython/CMakeLists.txt b/src/cython/CMakeLists.txt
index 09ea28f1..8fcd6cbf 100644
--- a/src/cython/CMakeLists.txt
+++ b/src/cython/CMakeLists.txt
@@ -31,375 +31,406 @@ 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)
-  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)
+if(PYTHONINTERP_FOUND)
+  if(CYTHON_FOUND)
+    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;")
-  else()
-      set(GUDHI_CYTHON_MISSING_MODULES "${GUDHI_CYTHON_MODULES}persistence_graphical_tools;")
-  endif()
+    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', ")
-
-  # Gudhi and CGAL compilation option
-  if(MSVC)
-    set(GUDHI_CYTHON_EXTRA_COMPILE_ARGS "${GUDHI_CYTHON_EXTRA_COMPILE_ARGS}'/fp:strict', ")
-  else(MSVC)
-    set(GUDHI_CYTHON_EXTRA_COMPILE_ARGS "${GUDHI_CYTHON_EXTRA_COMPILE_ARGS}'-std=c++11', ")
-  endif(MSVC)
-  if(CMAKE_COMPILER_IS_GNUCXX)
-    set(GUDHI_CYTHON_EXTRA_COMPILE_ARGS "${GUDHI_CYTHON_EXTRA_COMPILE_ARGS}'-frounding-math', ")
-  endif(CMAKE_COMPILER_IS_GNUCXX)
-  if (CMAKE_CXX_COMPILER_ID MATCHES Intel)
-    set(GUDHI_CYTHON_EXTRA_COMPILE_ARGS "${GUDHI_CYTHON_EXTRA_COMPILE_ARGS}'-fp-model strict', ")
-  endif(CMAKE_CXX_COMPILER_ID MATCHES Intel)
-  if (DEBUG_TRACES)
-    # For programs to be more verbose
-    set(GUDHI_CYTHON_EXTRA_COMPILE_ARGS "${GUDHI_CYTHON_EXTRA_COMPILE_ARGS}'-DDEBUG_TRACES', ")
-  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', ")
+
+    # Gudhi and CGAL compilation option
+    if(MSVC)
+      set(GUDHI_CYTHON_EXTRA_COMPILE_ARGS "${GUDHI_CYTHON_EXTRA_COMPILE_ARGS}'/fp:strict', ")
+    else(MSVC)
+      set(GUDHI_CYTHON_EXTRA_COMPILE_ARGS "${GUDHI_CYTHON_EXTRA_COMPILE_ARGS}'-std=c++11', ")
+    endif(MSVC)
+    if(CMAKE_COMPILER_IS_GNUCXX)
+      set(GUDHI_CYTHON_EXTRA_COMPILE_ARGS "${GUDHI_CYTHON_EXTRA_COMPILE_ARGS}'-frounding-math', ")
+    endif(CMAKE_COMPILER_IS_GNUCXX)
+    if (CMAKE_CXX_COMPILER_ID MATCHES Intel)
+      set(GUDHI_CYTHON_EXTRA_COMPILE_ARGS "${GUDHI_CYTHON_EXTRA_COMPILE_ARGS}'-fp-model strict', ")
+    endif(CMAKE_CXX_COMPILER_ID MATCHES Intel)
+    if (DEBUG_TRACES)
+      # For programs to be more verbose
+      set(GUDHI_CYTHON_EXTRA_COMPILE_ARGS "${GUDHI_CYTHON_EXTRA_COMPILE_ARGS}'-DDEBUG_TRACES', ")
+    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'")
-    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'")
-    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'")
-    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")
-    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 (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'")
+      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'")
+      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'")
+      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")
+      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 ()
 
-  if(CGAL_FOUND)
-    can_cgal_use_cxx11_thread_local()
-    if (NOT CGAL_CAN_USE_CXX11_THREAD_LOCAL_RESULT)
-      if(CMAKE_BUILD_TYPE MATCHES Debug)
-        add_gudhi_cython_lib("${Boost_THREAD_LIBRARY_DEBUG}")
-      else()
-        add_gudhi_cython_lib("${Boost_THREAD_LIBRARY_RELEASE}")
-      endif()
-      set(GUDHI_CYTHON_LIBRARY_DIRS "${GUDHI_CYTHON_LIBRARY_DIRS}'${Boost_LIBRARY_DIRS}', ")
+    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()
-    # 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,
+
+    if(CGAL_FOUND)
+      can_cgal_use_cxx11_thread_local()
+      if (NOT CGAL_CAN_USE_CXX11_THREAD_LOCAL_RESULT)
+        if(CMAKE_BUILD_TYPE MATCHES Debug)
+          add_gudhi_cython_lib("${Boost_THREAD_LIBRARY_DEBUG}")
+        else()
+          add_gudhi_cython_lib("${Boost_THREAD_LIBRARY_RELEASE}")
+        endif()
+        set(GUDHI_CYTHON_LIBRARY_DIRS "${GUDHI_CYTHON_LIBRARY_DIRS}'${Boost_LIBRARY_DIRS}', ")
+      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,
+        if(CMAKE_BUILD_TYPE MATCHES Debug)
+          add_gudhi_cython_lib("${Boost_SYSTEM_LIBRARY_DEBUG}")
+        else()
+          add_gudhi_cython_lib("${Boost_SYSTEM_LIBRARY_RELEASE}")
+        endif()
+        set(GUDHI_CYTHON_LIBRARY_DIRS "${GUDHI_CYTHON_LIBRARY_DIRS}'${Boost_LIBRARY_DIRS}', ")
+      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}', ")
+        endif(GMPXX_FOUND)
+      endif(GMP_FOUND)
+    endif(CGAL_FOUND)
+
+    # Specific for Mac
+    if (${CMAKE_SYSTEM_NAME} MATCHES "Darwin")
+        set(GUDHI_CYTHON_EXTRA_COMPILE_ARGS "${GUDHI_CYTHON_EXTRA_COMPILE_ARGS}'-mmacosx-version-min=10.12', ")
+        set(GUDHI_CYTHON_EXTRA_LINK_ARGS "${GUDHI_CYTHON_EXTRA_LINK_ARGS}'-mmacosx-version-min=10.12', ")
+    endif(${CMAKE_SYSTEM_NAME} MATCHES "Darwin")
+
+    # Loop on INCLUDE_DIRECTORIES PROPERTY
+    get_property(GUDHI_INCLUDE_DIRECTORIES DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR} PROPERTY INCLUDE_DIRECTORIES)
+    foreach(GUDHI_INCLUDE_DIRECTORY ${GUDHI_INCLUDE_DIRECTORIES})
+      set(GUDHI_CYTHON_INCLUDE_DIRS "${GUDHI_CYTHON_INCLUDE_DIRS}'${GUDHI_INCLUDE_DIRECTORY}', ")
+    endforeach()
+    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', ")
       if(CMAKE_BUILD_TYPE MATCHES Debug)
-        add_gudhi_cython_lib("${Boost_SYSTEM_LIBRARY_DEBUG}")
+        add_gudhi_cython_lib("${TBB_DEBUG_LIBRARY}")
+        add_gudhi_cython_lib("${TBB_MALLOC_DEBUG_LIBRARY}")
       else()
-        add_gudhi_cython_lib("${Boost_SYSTEM_LIBRARY_RELEASE}")
+        add_gudhi_cython_lib("${TBB_RELEASE_LIBRARY}")
+        add_gudhi_cython_lib("${TBB_MALLOC_RELEASE_LIBRARY}")
       endif()
-      set(GUDHI_CYTHON_LIBRARY_DIRS "${GUDHI_CYTHON_LIBRARY_DIRS}'${Boost_LIBRARY_DIRS}', ")
-    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}', ")
-      endif(GMPXX_FOUND)
-    endif(GMP_FOUND)
-  endif(CGAL_FOUND)
-
-  # Specific for Mac
-  if (${CMAKE_SYSTEM_NAME} MATCHES "Darwin")
-      set(GUDHI_CYTHON_EXTRA_COMPILE_ARGS "${GUDHI_CYTHON_EXTRA_COMPILE_ARGS}'-mmacosx-version-min=10.12', ")
-      set(GUDHI_CYTHON_EXTRA_LINK_ARGS "${GUDHI_CYTHON_EXTRA_LINK_ARGS}'-mmacosx-version-min=10.12', ")
-  endif(${CMAKE_SYSTEM_NAME} MATCHES "Darwin")
-
-  # Loop on INCLUDE_DIRECTORIES PROPERTY
-  get_property(GUDHI_INCLUDE_DIRECTORIES DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR} PROPERTY INCLUDE_DIRECTORIES)
-  foreach(GUDHI_INCLUDE_DIRECTORY ${GUDHI_INCLUDE_DIRECTORIES})
-    set(GUDHI_CYTHON_INCLUDE_DIRS "${GUDHI_CYTHON_INCLUDE_DIRS}'${GUDHI_INCLUDE_DIRECTORY}', ")
-  endforeach()
-  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', ")
-    if(CMAKE_BUILD_TYPE MATCHES Debug)
-      add_gudhi_cython_lib("${TBB_DEBUG_LIBRARY}")
-      add_gudhi_cython_lib("${TBB_MALLOC_DEBUG_LIBRARY}")
-    else()
-      add_gudhi_cython_lib("${TBB_RELEASE_LIBRARY}")
-      add_gudhi_cython_lib("${TBB_MALLOC_RELEASE_LIBRARY}")
+      set(GUDHI_CYTHON_LIBRARY_DIRS "${GUDHI_CYTHON_LIBRARY_DIRS}'${TBB_LIBRARY_DIRS}', ")
+      set(GUDHI_CYTHON_INCLUDE_DIRS "${GUDHI_CYTHON_INCLUDE_DIRS}'${TBB_INCLUDE_DIRS}', ")
     endif()
-    set(GUDHI_CYTHON_LIBRARY_DIRS "${GUDHI_CYTHON_LIBRARY_DIRS}'${TBB_LIBRARY_DIRS}', ")
-    set(GUDHI_CYTHON_INCLUDE_DIRS "${GUDHI_CYTHON_INCLUDE_DIRS}'${TBB_INCLUDE_DIRS}', ")
-  endif()
 
-  if(UNIX)
-    set( GUDHI_CYTHON_RUNTIME_LIBRARY_DIRS "${GUDHI_CYTHON_LIBRARY_DIRS}")
-  endif(UNIX)
-
-  # Generate setup.py file to cythonize Gudhi - This file must be named setup.py by convention
-  configure_file(setup.py.in "${CMAKE_CURRENT_BINARY_DIR}/setup.py" @ONLY)
-  # Generate gudhi.pyx - Gudhi cython file
-  configure_file(gudhi.pyx.in "${CMAKE_CURRENT_BINARY_DIR}/gudhi.pyx" @ONLY)
-
-  add_custom_command(
-      OUTPUT gudhi.so
-      WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
-      COMMAND ${PYTHON_EXECUTABLE} "${CMAKE_CURRENT_BINARY_DIR}/setup.py" "build_ext" "--inplace")
-
-  add_custom_target(cython ALL DEPENDS gudhi.so
-                    COMMENT "Do not forget to add ${CMAKE_CURRENT_BINARY_DIR}/ to your PYTHONPATH before using examples or tests")
-
-  # For installation purpose
-  # TODO(VR) : files matching pattern mechanism is copying all cython directory
-  install(DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}" DESTINATION "${PYTHON_SITE_PACKAGES}/" FILES_MATCHING
-      PATTERN "*.so"
-      PATTERN "*.dylib"
-      PATTERN "*.pyd")
-
-  # Test examples
-  if (NOT CGAL_WITH_EIGEN3_VERSION VERSION_LESS 4.8.1)
-    # Bottleneck and Alpha
-    add_test(NAME alpha_rips_persistence_bottleneck_distance_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_rips_persistence_bottleneck_distance.py"
-             -f ${CMAKE_SOURCE_DIR}/data/points/tore3D_300.off -t 0.15 -d 3)
+    if(UNIX)
+      set( GUDHI_CYTHON_RUNTIME_LIBRARY_DIRS "${GUDHI_CYTHON_LIBRARY_DIRS}")
+    endif(UNIX)
+
+    # Generate setup.py file to cythonize Gudhi - This file must be named setup.py by convention
+    configure_file(setup.py.in "${CMAKE_CURRENT_BINARY_DIR}/setup.py" @ONLY)
+    # Generate gudhi.pyx - Gudhi cython file
+    configure_file(gudhi.pyx.in "${CMAKE_CURRENT_BINARY_DIR}/gudhi.pyx" @ONLY)
+
+    add_custom_command(
+        OUTPUT gudhi.so
+        WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
+        COMMAND ${PYTHON_EXECUTABLE} "${CMAKE_CURRENT_BINARY_DIR}/setup.py" "build_ext" "--inplace")
+
+    add_custom_target(cython ALL DEPENDS gudhi.so
+                      COMMENT "Do not forget to add ${CMAKE_CURRENT_BINARY_DIR}/ to your PYTHONPATH before using examples or tests")
+
+    # For installation purpose
+    # TODO(VR) : files matching pattern mechanism is copying all cython directory
+    install(DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}" DESTINATION "${PYTHON_SITE_PACKAGES}/" FILES_MATCHING
+        PATTERN "*.so"
+        PATTERN "*.dylib"
+        PATTERN "*.pyd")
+
+    # Test examples
+    if (NOT CGAL_WITH_EIGEN3_VERSION VERSION_LESS 4.8.1)
+      # Bottleneck and Alpha
+      add_test(NAME alpha_rips_persistence_bottleneck_distance_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_rips_persistence_bottleneck_distance.py"
+               -f ${CMAKE_SOURCE_DIR}/data/points/tore3D_300.off -t 0.15 -d 3)
+
+      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()
 
-    if(MATPLOTLIB_FOUND AND NUMPY_FOUND)
-      # Tangential
-      add_test(NAME tangential_complex_plain_homology_from_off_file_example_py_test
+      # Subsampling
+      add_gudhi_py_test(test_subsampling)
+
+    endif (NOT CGAL_WITH_EIGEN3_VERSION VERSION_LESS 4.8.1)
+    if (NOT CGAL_VERSION VERSION_LESS 4.8.1)
+      # Bottleneck
+      add_test(NAME bottleneck_basic_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)
+               ${PYTHON_EXECUTABLE} "${CMAKE_CURRENT_SOURCE_DIR}/example/bottleneck_basic_example.py")
 
-      add_gudhi_py_test(test_tangential_complex)
+      add_gudhi_py_test(test_bottleneck_distance)
 
-      # Witness complex AND Subsampling
-      add_test(NAME euclidean_strong_witness_complex_diagram_persistence_from_off_file_example_py_test
+      # Cover complex
+      file(COPY ${CMAKE_SOURCE_DIR}/data/points/human.off DESTINATION ${CMAKE_CURRENT_BINARY_DIR}/)
+      file(COPY ${CMAKE_SOURCE_DIR}/data/points/COIL_database/lucky_cat.off DESTINATION ${CMAKE_CURRENT_BINARY_DIR}/)
+      file(COPY ${CMAKE_SOURCE_DIR}/data/points/COIL_database/lucky_cat_PCA1 DESTINATION ${CMAKE_CURRENT_BINARY_DIR}/)
+      add_test(NAME cover_complex_nerve_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)
+               ${PYTHON_EXECUTABLE} "${CMAKE_CURRENT_SOURCE_DIR}/example/nerve_of_a_covering.py"
+               -f human.off -c 2 -r 10 -g 0.3)
 
-      add_test(NAME euclidean_witness_complex_diagram_persistence_from_off_file_example_py_test
+      add_test(NAME cover_complex_coordinate_gic_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()
+               ${PYTHON_EXECUTABLE} "${CMAKE_CURRENT_SOURCE_DIR}/example/coordinate_graph_induced_complex.py"
+               -f human.off -c 0 -v)
 
-    # Subsampling
-    add_gudhi_py_test(test_subsampling)
+      add_test(NAME cover_complex_functional_gic_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/functional_graph_induced_complex.py"
+               -o lucky_cat.off
+               -f lucky_cat_PCA1 -v)
 
-  endif (NOT CGAL_WITH_EIGEN3_VERSION VERSION_LESS 4.8.1)
-  if (NOT CGAL_VERSION VERSION_LESS 4.8.1)
-    # Bottleneck
-    add_test(NAME bottleneck_basic_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/bottleneck_basic_example.py")
+      add_test(NAME cover_complex_voronoi_gic_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/voronoi_graph_induced_complex.py"
+               -f human.off -n 700 -v)
 
-    add_gudhi_py_test(test_bottleneck_distance)
+      add_gudhi_py_test(test_cover_complex)
+    endif (NOT CGAL_VERSION VERSION_LESS 4.8.1)
 
-    # Cover complex
-    file(COPY ${CMAKE_SOURCE_DIR}/data/points/human.off DESTINATION ${CMAKE_CURRENT_BINARY_DIR}/)
-    file(COPY ${CMAKE_SOURCE_DIR}/data/points/COIL_database/lucky_cat.off DESTINATION ${CMAKE_CURRENT_BINARY_DIR}/)
-    file(COPY ${CMAKE_SOURCE_DIR}/data/points/COIL_database/lucky_cat_PCA1 DESTINATION ${CMAKE_CURRENT_BINARY_DIR}/)
-    add_test(NAME cover_complex_nerve_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/nerve_of_a_covering.py"
-             -f human.off -c 2 -r 10 -g 0.3)
+    if (NOT CGAL_WITH_EIGEN3_VERSION VERSION_LESS 4.7.0)
+      # Alpha
+      add_test(NAME alpha_complex_from_points_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_from_points_example.py")
 
-    add_test(NAME cover_complex_coordinate_gic_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/coordinate_graph_induced_complex.py"
-             -f human.off -c 0 -v)
+      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_test(NAME cover_complex_functional_gic_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/functional_graph_induced_complex.py"
-             -o lucky_cat.off
-             -f lucky_cat_PCA1 -v)
+      add_gudhi_py_test(test_alpha_complex)
 
-    add_test(NAME cover_complex_voronoi_gic_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/voronoi_graph_induced_complex.py"
-             -f human.off -n 700 -v)
+    endif (NOT CGAL_WITH_EIGEN3_VERSION VERSION_LESS 4.7.0)
 
-    add_gudhi_py_test(test_cover_complex)
-  endif (NOT CGAL_VERSION VERSION_LESS 4.8.1)
+    if (NOT CGAL_WITH_EIGEN3_VERSION VERSION_LESS 4.6.0)
+      # Euclidean witness
+      add_gudhi_py_test(test_euclidean_witness_complex)
 
-  if (NOT CGAL_WITH_EIGEN3_VERSION VERSION_LESS 4.7.0)
-    # Alpha
-    add_test(NAME alpha_complex_from_points_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_from_points_example.py")
+    endif (NOT CGAL_WITH_EIGEN3_VERSION VERSION_LESS 4.6.0)
 
-    if(MATPLOTLIB_FOUND AND NUMPY_FOUND)
-      add_test(NAME alpha_complex_diagram_persistence_from_off_file_example_py_test
+    # Cubical
+    add_test(NAME periodic_cubical_complex_barcode_persistence_from_perseus_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)
+             ${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)
 
-  endif (NOT CGAL_WITH_EIGEN3_VERSION VERSION_LESS 4.7.0)
+    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()
 
-  if (NOT CGAL_WITH_EIGEN3_VERSION VERSION_LESS 4.6.0)
-    # Euclidean witness
-    add_gudhi_py_test(test_euclidean_witness_complex)
+    add_gudhi_py_test(test_cubical_complex)
 
-  endif (NOT CGAL_WITH_EIGEN3_VERSION VERSION_LESS 4.6.0)
+    # Rips
+    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)
 
-  # Cubical
-  add_test(NAME periodic_cubical_complex_barcode_persistence_from_perseus_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/periodic_cubical_complex_barcode_persistence_from_perseus_file_example.py"
-           --no-barcode -f ${CMAKE_SOURCE_DIR}/data/bitmap/CubicalTwoSphere.txt)
+      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()
 
-  if(NUMPY_FOUND)
-    add_test(NAME random_cubical_complex_persistence_example_py_test
+    add_test(NAME rips_complex_from_points_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()
+             ${PYTHON_EXECUTABLE} ${CMAKE_CURRENT_SOURCE_DIR}/example/rips_complex_from_points_example.py)
 
-  add_gudhi_py_test(test_cubical_complex)
+    add_gudhi_py_test(test_rips_complex)
 
-  # Rips
-  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
+    # Simplex tree
+    add_test(NAME simplex_tree_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}
-           COMMAND ${CMAKE_COMMAND} -E env "PYTHONPATH=${CMAKE_CURRENT_BINARY_DIR}"
-           ${PYTHON_EXECUTABLE} ${CMAKE_CURRENT_SOURCE_DIR}/example/rips_complex_from_points_example.py)
-
-  add_gudhi_py_test(test_rips_complex)
-
-  # Simplex tree
-  add_test(NAME simplex_tree_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/simplex_tree_example.py)
-
-  add_gudhi_py_test(test_simplex_tree)
+             ${PYTHON_EXECUTABLE} ${CMAKE_CURRENT_SOURCE_DIR}/example/simplex_tree_example.py)
 
-  # Witness
-  add_test(NAME witness_complex_from_nearest_landmark_table_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/witness_complex_from_nearest_landmark_table.py)
+    add_gudhi_py_test(test_simplex_tree)
 
-  add_gudhi_py_test(test_witness_complex)
-
-  # Reader utils
-  add_gudhi_py_test(test_reader_utils)
-
-  # Documentation generation is available through sphinx - requires all modules
-  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
-    if (GUDHI_CYTHON_PATH STREQUAL "src/cython")
-      set (GUDHI_SPHINX_MESSAGE "${GUDHI_SPHINX_MESSAGE} \n WARNING : Sphinx is configured for user version, you run it on developper version. Images and biblio will miss")
-    endif()
-    # sphinx target requires gudhi.so, because conf.py reads gudhi version from it
-    add_custom_target(sphinx
-        WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/doc
-        COMMAND ${CMAKE_COMMAND} -E env "PYTHONPATH=${CMAKE_CURRENT_BINARY_DIR}"
-        ${SPHINX_PATH} -b html ${CMAKE_CURRENT_SOURCE_DIR}/doc ${CMAKE_CURRENT_BINARY_DIR}/sphinx
-        DEPENDS "${CMAKE_CURRENT_BINARY_DIR}/gudhi.so"
-        COMMENT "${GUDHI_SPHINX_MESSAGE}" VERBATIM)
-
-    add_test(NAME sphinx_py_test
+    # Witness
+    add_test(NAME witness_complex_from_nearest_landmark_table_py_test
              WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
              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()
-endif(CYTHON_FOUND)
+             ${PYTHON_EXECUTABLE} ${CMAKE_CURRENT_SOURCE_DIR}/example/witness_complex_from_nearest_landmark_table.py)
+
+    add_gudhi_py_test(test_witness_complex)
+
+    # Reader utils
+    add_gudhi_py_test(test_reader_utils)
+
+    # Documentation generation is available through sphinx - requires all modules
+    if(SPHINX_PATH)
+      if(MATPLOTLIB_FOUND)
+        if(NUMPY_FOUND)
+          if(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
+            if (GUDHI_CYTHON_PATH STREQUAL "src/cython")
+              set (GUDHI_SPHINX_MESSAGE "${GUDHI_SPHINX_MESSAGE} \n WARNING : Sphinx is configured for user version, you run it on developper version. Images and biblio will miss")
+            endif()
+            # sphinx target requires gudhi.so, because conf.py reads gudhi version from it
+            add_custom_target(sphinx
+                WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/doc
+                COMMAND ${CMAKE_COMMAND} -E env "PYTHONPATH=${CMAKE_CURRENT_BINARY_DIR}"
+                ${SPHINX_PATH} -b html ${CMAKE_CURRENT_SOURCE_DIR}/doc ${CMAKE_CURRENT_BINARY_DIR}/sphinx
+                DEPENDS "${CMAKE_CURRENT_BINARY_DIR}/gudhi.so"
+                COMMENT "${GUDHI_SPHINX_MESSAGE}" VERBATIM)
+
+            add_test(NAME sphinx_py_test
+                     WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
+                     COMMAND ${CMAKE_COMMAND} -E env "PYTHONPATH=${CMAKE_CURRENT_BINARY_DIR}"
+                     ${SPHINX_PATH} -b doctest ${CMAKE_CURRENT_SOURCE_DIR}/doc ${CMAKE_CURRENT_BINARY_DIR}/doctest)
+
+            # Set missing or not modules
+            set(GUDHI_MODULES ${GUDHI_MODULES} "python-documentation" CACHE INTERNAL "GUDHI_MODULES")
+          else(NOT CGAL_WITH_EIGEN3_VERSION VERSION_LESS 4.8.1)
+            message("++ Python documentation module will not be compiled because it requires a CGAL with Eigen3 version greater or equal than 4.8.1")
+            set(GUDHI_MISSING_MODULES ${GUDHI_MISSING_MODULES} "python-documentation" CACHE INTERNAL "GUDHI_MISSING_MODULES")
+          endif(NOT CGAL_WITH_EIGEN3_VERSION VERSION_LESS 4.8.1)
+        else(NUMPY_FOUND)
+          message("++ Python module will not be compiled because numpy was not found")
+          set(GUDHI_MISSING_MODULES ${GUDHI_MISSING_MODULES} "python-documentation" CACHE INTERNAL "GUDHI_MISSING_MODULES")
+        endif(NUMPY_FOUND)
+      else(MATPLOTLIB_FOUND)
+        message("++ Python module will not be compiled because matplotlib was not found")
+        set(GUDHI_MISSING_MODULES ${GUDHI_MISSING_MODULES} "python-documentation" CACHE INTERNAL "GUDHI_MISSING_MODULES")
+      endif(MATPLOTLIB_FOUND)
+    else(SPHINX_PATH)
+      message("++ Python module will not be compiled because sphinx and sphinxcontrib-bibtex were not found")
+      set(GUDHI_MISSING_MODULES ${GUDHI_MISSING_MODULES} "python-documentation" CACHE INTERNAL "GUDHI_MISSING_MODULES")
+    endif(SPHINX_PATH)
+
+
+    # Set missing or not modules
+    set(GUDHI_MODULES ${GUDHI_MODULES} "python" CACHE INTERNAL "GUDHI_MODULES")
+  else(CYTHON_FOUND)
+    message("++ Python module will not be compiled because cython was not found")
+    set(GUDHI_MISSING_MODULES ${GUDHI_MISSING_MODULES} "python" CACHE INTERNAL "GUDHI_MISSING_MODULES")
+  endif(CYTHON_FOUND)
+else(PYTHONINTERP_FOUND)
+  message("++ Python module will not be compiled because no Python interpreter was found")
+  set(GUDHI_MISSING_MODULES ${GUDHI_MISSING_MODULES} "python" CACHE INTERNAL "GUDHI_MISSING_MODULES")
+endif(PYTHONINTERP_FOUND)