Alpha complex documetation - 1st part

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

Former-commit-id: b64e860b0fb6d60e706784605f699349ea17a869

7 files changed, 163 insertions, 128 deletions

diff --git a/biblio/bibliography.bib b/biblio/bibliography.bib
index 3fd1c10a..859696b4 100644
--- a/biblio/bibliography.bib
+++ b/biblio/bibliography.bib
@@ -897,6 +897,22 @@ language={English}
   bibsource = {DBLP, http://dblp.uni-trier.de}
 }
 
+@ARTICLE{AlphaShapesDefinition,
+    author = {N. Akkiraju, H. Edelsbrunner, M. Facello, P. Fu, E. P. Mucke, and C. Varela},
+    title = {\href{http://pub.ist.ac.at/~edels/Papers/1995-P-06-AlphaShapesSoftware.pdf}{Alpha shapes: definition and software}},
+    journal = {Proc. Internat. Comput. Geom. Software Workshop 1995},
+    year = {1995},
+    bibsource = {http://pub.ist.ac.at}
+}
+
+@ARTICLE{AlphaShapesIntroduction,
+    author = {Kaspar Fischer},
+    title = {\href{http://www.cs.uu.nl/docs/vakken/ddm/texts/Delaunay/alphashapes.pdf}{Introduction to Alpha Shapes}},
+    journal = {Unknown},
+    year = {Unknown},
+    bibsource = {http://www.cs.uu.nl}
+}
+
 misc{buddha_stanford_scan,
  author = "",
    title = "The Stanford 3D Scanning Repository",
diff --git a/src/Alpha_complex/example/Alpha_complex_from_off.cpp b/src/Alpha_complex/example/Alpha_complex_from_off.cpp
index d129ebf7..0d7af117 100644
--- a/src/Alpha_complex/example/Alpha_complex_from_off.cpp
+++ b/src/Alpha_complex/example/Alpha_complex_from_off.cpp
@@ -1,25 +1,3 @@
-/*    This file is part of the Gudhi Library. The Gudhi library
- *    (Geometric Understanding in Higher Dimensions) is a generic C++
- *    library for computational topology.
- *
- *    Author(s):       Vincent Rouvreau
- *
- *    Copyright (C) 2014  INRIA Saclay (France)
- *
- *    This program is free software: you can redistribute it and/or modify
- *    it under the terms of the GNU General Public License as published by
- *    the Free Software Foundation, either version 3 of the License, or
- *    (at your option) any later version.
- *
- *    This program is distributed in the hope that it will be useful,
- *    but WITHOUT ANY WARRANTY; without even the implied warranty of
- *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *    GNU General Public License for more details.
- *
- *    You should have received a copy of the GNU General Public License
- *    along with this program.  If not, see <http://www.gnu.org/licenses/>.
- */
-
 // to construct a Delaunay_triangulation from a OFF file
 #include "gudhi/Delaunay_triangulation_off_io.h"
 #include "gudhi/Alpha_complex.h"
diff --git a/src/Alpha_complex/include/gudhi/Alpha_complex.h b/src/Alpha_complex/include/gudhi/Alpha_complex.h
index d25c05cb..44741e3b 100644
--- a/src/Alpha_complex/include/gudhi/Alpha_complex.h
+++ b/src/Alpha_complex/include/gudhi/Alpha_complex.h
@@ -52,17 +52,37 @@ namespace alphacomplex {
 #define Kinit(f) =k.f()
 
 /** \defgroup alpha_complex Alpha complex in dimension N
- *
- <DT>Implementations:</DT>
- Alpha complex in dimension N are a subset of Delaunay Triangulation in dimension N.
-
-
- * \author    Vincent Rouvreau
- * \version   1.0
- * \date      2015
- * \copyright GNU General Public License v3.
  * @{
+ * \author    Vincent Rouvreau
+ *
+ * \section Definition
+ * 
+ * Alpha_complex is a Simplex_tree constructed from each finite cell of a Delaunay Triangulation in dimension N.
+ * 
+ * The filtration value of each simplex is computed from the alpha value of the simplex if it is Gabriel or
+ * from the alpha value of the simplex coface that makes the simplex not Gabriel.
+ * 
+ * Please refer to \cite AlphaShapesDefinition for the alpha complex definition or to 
+ * \cite AlphaShapesIntroduction for alpha complex concept vulgarization.
+ * 
+ * \section Example
+ * 
+ * This example loads points from an OFF file, builds the Delaunay triangulation, and finally initialize the 
+ * alpha complex with it.
+ * Then, it is asked to display information about the alpha complex.
+ * 
+ * \include Alpha_complex_from_off.cpp
+ * 
+ * When launching:
+ * 
+ * \code $> ./alphaoffreader ../../data/points/alphashapedoc.off
+ * \endcode
+ *
+ * the program output is:
+ * 
+ * \include alphaoffreader_for_doc.txt
  */
+/** @} */  // end defgroup alpha_complex
 
 /**
  * \brief Alpha complex data structure.
@@ -74,89 +94,107 @@ namespace alphacomplex {
  *
  *
  */
-class Alpha_complex {
+template<typename IndexingTag = linear_indexing_tag,
+typename FiltrationValue = double,
+typename SimplexKey = int,  // must be a signed integer type
+typename VertexHandle = int  // must be a signed integer type, int convertible to it
+>
+class Alpha_complex : public Simplex_tree<> {
  private:
   // From Simplex_tree
-  /** \brief Type required to insert into a simplex_tree (with or without subfaces).*/
+  // Type required to insert into a simplex_tree (with or without subfaces).
   typedef std::vector<Vertex_handle> Vector_vertex;
 
-  /** \brief Simplex_handle type from simplex_tree.*/
-  typedef typename Gudhi::Simplex_tree<>::Simplex_handle Simplex_handle;
-  /** \brief Simplex_result is the type returned from simplex_tree insert function.*/
+  // Simplex_result is the type returned from simplex_tree insert function.
   typedef typename std::pair<Simplex_handle, bool> Simplex_result;
 
-  /** \brief Filtration_simplex_range type from simplex_tree.*/
-  typedef typename Gudhi::Simplex_tree<>::Filtration_simplex_range Filtration_simplex_range;
-
-  /** \brief Simplex_vertex_range type from simplex_tree.*/
-  typedef typename Gudhi::Simplex_tree<>::Simplex_vertex_range Simplex_vertex_range;
-  
   // From CGAL
-  /** \brief Kernel for the Delaunay_triangulation. Dimension can be set dynamically.*/
+  // Kernel for the Delaunay_triangulation. Dimension can be set dynamically.
   typedef CGAL::Epick_d< CGAL::Dynamic_dimension_tag > Kernel;
-  /** \brief Delaunay_triangulation type required to create an alpha-complex.*/
+
+  // Delaunay_triangulation type required to create an alpha-complex.
   typedef CGAL::Delaunay_triangulation<Kernel> Delaunay_triangulation;
 
   typedef typename Kernel::Compute_squared_radius_d Squared_Radius;
   typedef typename Kernel::Side_of_bounded_sphere_d Is_Gabriel;
 
-  /** \brief Type required to compute squared radius, or side of bounded sphere on a vector of points.*/
+  // Type required to compute squared radius, or side of bounded sphere on a vector of points.
   typedef std::vector<Kernel::Point_d> Vector_of_CGAL_points;
 
-  /** \brief Vertex_iterator type from CGAL.*/
+  // Vertex_iterator type from CGAL.
   typedef Delaunay_triangulation::Vertex_iterator CGAL_vertex_iterator;
 
-  /** \brief Boost bimap type to switch from CGAL vertex iterator to simplex tree vertex handle and vice versa.*/
+  // Boost bimap type to switch from CGAL vertex iterator to simplex tree vertex handle and vice versa.
   typedef boost::bimap< CGAL_vertex_iterator, Vertex_handle > Bimap_vertex;
-  
+
  private:
-  /** \brief Alpha complex is represented internally by a simplex tree.*/
-  Gudhi::Simplex_tree<> st_;
   /** \brief Boost bimap to switch from CGAL vertex iterator to simplex tree vertex handle and vice versa.*/
   Bimap_vertex cgal_simplextree;
   /** \brief Pointer on the CGAL Delaunay triangulation.*/
   Delaunay_triangulation* triangulation;
 
  public:
+  /** \brief Alpha_complex constructor from an OFF file name.
+   * Uses the Delaunay_triangulation_off_reader to construct the Delaunay triangulation required to initialize 
+   * the Alpha_complex.
+   *
+   * @param[in] off_file_name OFF file [path and] name.
+   */
   Alpha_complex(std::string& off_file_name)
-  : triangulation(nullptr) {
+      : triangulation(nullptr) {
     Gudhi::Delaunay_triangulation_off_reader<Delaunay_triangulation> off_reader(off_file_name);
     if (!off_reader.is_valid()) {
-      std::cerr << "Unable to read file " << off_file_name << std::endl;
+      std::cerr << "Alpha_complex - Unable to read file " << off_file_name << std::endl;
       exit(-1); // ----- >>
     }
     triangulation = off_reader.get_complex();
     init();
   }
 
+  /** \brief Alpha_complex constructor from a Delaunay triangulation.
+   *
+   * @param[in] triangulation_ptr Pointer on a Delaunay triangulation.
+   */
   Alpha_complex(Delaunay_triangulation* triangulation_ptr)
-  : triangulation(triangulation_ptr) {
+      : triangulation(triangulation_ptr) {
     init();
   }
 
+  /** \brief Alpha_complex destructor from a Delaunay triangulation.
+   *
+   * @warning Deletes the Delaunay triangulation.
+   */
   ~Alpha_complex() {
     delete triangulation;
   }
 
-  Filtration_simplex_range filtration_simplex_range() {
-    return st_.filtration_simplex_range();
-  }
-  
-  Simplex_vertex_range simplex_vertex_range(Simplex_handle sh) {
-    return st_.simplex_vertex_range(sh);
-  }
-  
-  /** \brief Returns the filtration value of a simplex.
-   *
-   * Called on the null_simplex, returns INFINITY. */
-  Gudhi::Simplex_tree<>::Filtration_value filtration(Simplex_handle sh) {
-    return st_.filtration(sh);
-  }
-
  private:
-
+  /** \brief Initialize the Alpha_complex from the Delaunay triangulation.
+   *
+   * @warning Delaunay triangulation must be already constructed with at least one vertex and dimension must be more 
+   * than 0.
+   * 
+   * Initialization can be launched once.
+   */
   void init() {
-    st_.set_dimension(triangulation->maximal_dimension());
+    if (triangulation == nullptr) {
+      std::cerr << "Alpha_complex init - Cannot init from a NULL triangulation" << std::endl;
+      return; // ----- >>
+    }
+    if (triangulation->number_of_vertices() < 1) {
+      std::cerr << "Alpha_complex init - Cannot init from a triangulation without vertices" << std::endl;
+      return; // ----- >>
+    }
+    if (triangulation->maximal_dimension() < 1) {
+      std::cerr << "Alpha_complex init - Cannot init from a zero-dimension triangulation" << std::endl;
+      return; // ----- >>
+    }
+    if (num_vertices() > 0) {
+      std::cerr << "Alpha_complex init - Cannot init twice" << std::endl;
+      return; // ----- >>
+    }
+    
+    set_dimension(triangulation->maximal_dimension());
 
     // --------------------------------------------------------------------------------------------
     // bimap to retrieve simplex tree vertex handles from CGAL vertex iterator and vice versa
@@ -187,7 +225,7 @@ class Alpha_complex {
       std::cout << std::endl;
 #endif  // DEBUG_TRACES
       // Insert each simplex and its subfaces in the simplex tree - filtration is NaN
-      Simplex_result insert_result = st_.insert_simplex_and_subfaces(vertexVector,
+      Simplex_result insert_result = insert_simplex_and_subfaces(vertexVector,
                                                                      std::numeric_limits<double>::quiet_NaN());
       if (!insert_result.second) {
         std::cerr << "Alpha_complex::init insert_simplex_and_subfaces failed" << std::endl;
@@ -198,16 +236,16 @@ class Alpha_complex {
     Filtration_value filtration_max = 0.0;
     // --------------------------------------------------------------------------------------------
     // ### For i : d -> 0
-    for (int decr_dim = st_.dimension(); decr_dim >= 0; decr_dim--) {
+    for (int decr_dim = dimension(); decr_dim >= 0; decr_dim--) {
       // ### Foreach Sigma of dim i
-      for (auto f_simplex : st_.skeleton_simplex_range(decr_dim)) {
-        int f_simplex_dim = st_.dimension(f_simplex);
+      for (auto f_simplex : skeleton_simplex_range(decr_dim)) {
+        int f_simplex_dim = dimension(f_simplex);
         if (decr_dim == f_simplex_dim) {
           Vector_of_CGAL_points pointVector;
 #ifdef DEBUG_TRACES
           std::cout << "Sigma of dim " << decr_dim << " is";
 #endif  // DEBUG_TRACES
-          for (auto vertex : st_.simplex_vertex_range(f_simplex)) {
+          for (auto vertex : simplex_vertex_range(f_simplex)) {
             pointVector.push_back((cgal_simplextree.right.at(vertex))->point());
 #ifdef DEBUG_TRACES
             std::cout << " " << vertex;
@@ -217,20 +255,20 @@ class Alpha_complex {
           std::cout << std::endl;
 #endif  // DEBUG_TRACES
           // ### If filt(Sigma) is NaN : filt(Sigma) = alpha(Sigma)
-          if (isnan(st_.filtration(f_simplex))) {
+          if (isnan(filtration(f_simplex))) {
             Filtration_value alpha_complex_filtration = 0.0;
             // No need to compute squared_radius on a single point - alpha is 0.0
             if (f_simplex_dim > 0) {
               // squared_radius function initialization
               Kernel k;
               Squared_Radius squared_radius Kinit(compute_squared_radius_d_object);
-              
+
               alpha_complex_filtration = squared_radius(pointVector.begin(), pointVector.end());
             }
-            st_.assign_filtration(f_simplex, alpha_complex_filtration);
+            assign_filtration(f_simplex, alpha_complex_filtration);
             filtration_max = fmax(filtration_max, alpha_complex_filtration);
 #ifdef DEBUG_TRACES
-            std::cout << "filt(Sigma) is NaN : filt(Sigma) =" << st_.filtration(f_simplex) << std::endl;
+            std::cout << "filt(Sigma) is NaN : filt(Sigma) =" << filtration(f_simplex) << std::endl;
 #endif  // DEBUG_TRACES
           }
           propagate_alpha_filtration(f_simplex, decr_dim);
@@ -242,30 +280,30 @@ class Alpha_complex {
 #ifdef DEBUG_TRACES
     std::cout << "filtration_max=" << filtration_max << std::endl;
 #endif  // DEBUG_TRACES
-    st_.set_filtration(filtration_max);
+    set_filtration(filtration_max);
   }
 
   template<typename Simplex_handle>
   void propagate_alpha_filtration(Simplex_handle f_simplex, int decr_dim) {
     // ### Foreach Tau face of Sigma
-    for (auto f_boundary : st_.boundary_simplex_range(f_simplex)) {
+    for (auto f_boundary : boundary_simplex_range(f_simplex)) {
 #ifdef DEBUG_TRACES
       std::cout << " | --------------------------------------------------" << std::endl;
       std::cout << " | Tau ";
-      for (auto vertex : st_.simplex_vertex_range(f_boundary)) {
+      for (auto vertex : simplex_vertex_range(f_boundary)) {
         std::cout << vertex << " ";
       }
       std::cout << "is a face of Sigma" << std::endl;
-      std::cout << " | isnan(filtration(Tau)=" << isnan(st_.filtration(f_boundary)) << std::endl;
+      std::cout << " | isnan(filtration(Tau)=" << isnan(filtration(f_boundary)) << std::endl;
 #endif  // DEBUG_TRACES
       // ### If filt(Tau) is not NaN
-      if (!isnan(st_.filtration(f_boundary))) {
+      if (!isnan(filtration(f_boundary))) {
         // ### filt(Tau) = fmin(filt(Tau), filt(Sigma))
-        Filtration_value alpha_complex_filtration = fmin(st_.filtration(f_boundary), st_.filtration(f_simplex));
-        st_.assign_filtration(f_boundary, alpha_complex_filtration);
+        Filtration_value alpha_complex_filtration = fmin(filtration(f_boundary), filtration(f_simplex));
+        assign_filtration(f_boundary, alpha_complex_filtration);
         // No need to check for filtration_max, alpha_complex_filtration is a min of an existing filtration value
 #ifdef DEBUG_TRACES
-        std::cout << " | filt(Tau) = fmin(filt(Tau), filt(Sigma)) = " << st_.filtration(f_boundary) << std::endl;
+        std::cout << " | filt(Tau) = fmin(filt(Tau), filt(Sigma)) = " << filtration(f_boundary) << std::endl;
 #endif  // DEBUG_TRACES
         // ### Else
       } else {
@@ -275,11 +313,11 @@ class Alpha_complex {
           // insert the Tau points in a vector for is_gabriel function
           Vector_of_CGAL_points pointVector;
           Vertex_handle vertexForGabriel = Vertex_handle();
-          for (auto vertex : st_.simplex_vertex_range(f_boundary)) {
+          for (auto vertex : simplex_vertex_range(f_boundary)) {
             pointVector.push_back((cgal_simplextree.right.at(vertex))->point());
           }
           // Retrieve the Sigma point that is not part of Tau - parameter for is_gabriel function
-          for (auto vertex : st_.simplex_vertex_range(f_simplex)) {
+          for (auto vertex : simplex_vertex_range(f_simplex)) {
             if (std::find(pointVector.begin(), pointVector.end(), (cgal_simplextree.right.at(vertex))->point())
                 == pointVector.end()) {
               // vertex is not found in Tau
@@ -300,46 +338,17 @@ class Alpha_complex {
           if ((is_gabriel(pointVector.begin(), pointVector.end(), (cgal_simplextree.right.at(vertexForGabriel))->point())
                == CGAL::ON_BOUNDED_SIDE)) {
             // ### filt(Tau) = filt(Sigma)
-            Filtration_value alpha_complex_filtration = st_.filtration(f_simplex);
-            st_.assign_filtration(f_boundary, alpha_complex_filtration);
+            Filtration_value alpha_complex_filtration = filtration(f_simplex);
+            assign_filtration(f_boundary, alpha_complex_filtration);
             // No need to check for filtration_max, alpha_complex_filtration is an existing filtration value
 #ifdef DEBUG_TRACES
-            std::cout << " | filt(Tau) = filt(Sigma) = " << st_.filtration(f_boundary) << std::endl;
+            std::cout << " | filt(Tau) = filt(Sigma) = " << filtration(f_boundary) << std::endl;
 #endif  // DEBUG_TRACES
           }
         }
       }
     }
   }
- public:
-
-  /** \brief Returns the number of vertices in the complex. */
-  size_t num_vertices() {
-    return st_.num_vertices();
-  }
-
-  /** \brief Returns the number of simplices in the complex.
-   *
-   * Does not count the empty simplex. */
-  const unsigned int& num_simplices() const {
-    return st_.num_simplices();
-  }
-
-  /** \brief Returns an upper bound on the dimension of the simplicial complex. */
-  int dimension() {
-    return st_.dimension();
-  }
-
-  /** \brief Returns an upper bound of the filtration values of the simplices. */
-  Filtration_value filtration() {
-    return st_.filtration();
-  }
-
-  friend std::ostream& operator<<(std::ostream& os, const Alpha_complex & alpha_complex) {
-    Gudhi::Simplex_tree<> st = alpha_complex.st_;
-    os << st << std::endl;
-    return os;
-  }
 };
 
 } // namespace alphacomplex
diff --git a/src/Alpha_complex/test/CMakeLists.txt b/src/Alpha_complex/test/CMakeLists.txt
index 0bd55433..79300790 100644
--- a/src/Alpha_complex/test/CMakeLists.txt
+++ b/src/Alpha_complex/test/CMakeLists.txt
@@ -16,9 +16,11 @@ if(CGAL_FOUND)
       include_directories (BEFORE "../../include")
 
       #add_definitions(-DDEBUG_TRACES)
-      add_executable ( AlphaComplexUnitTest Alpha_complex_unit_test.cpp )
-      target_link_libraries(AlphaComplexUnitTest  ${Boost_SYSTEM_LIBRARY} ${CGAL_LIBRARY} ${Boost_UNIT_TEST_FRAMEWORK_LIBRARY})
-      add_test(AlphaComplexUnitTest ${CMAKE_CURRENT_BINARY_DIR}/AlphaComplexUnitTest)
+      add_executable ( AlphaComplexUT Alpha_complex_unit_test.cpp )
+      target_link_libraries(AlphaComplexUT  ${Boost_SYSTEM_LIBRARY} ${CGAL_LIBRARY} ${Boost_UNIT_TEST_FRAMEWORK_LIBRARY})
+      add_test(AlphaComplexUT ${CMAKE_CURRENT_BINARY_DIR}/AlphaComplexUT
+      # XML format for Jenkins xUnit plugin 
+      --log_format=XML --log_sink=${CMAKE_SOURCE_DIR}/AlphaComplexUT.xml --log_level=test_suite --report_level=no)
 
     else()
       message(WARNING "Eigen3 not found. Version 3.1.0 is required for Alpha complex feature.")
diff --git a/src/Alpha_complex/test/alphaoffreader_for_doc.txt b/src/Alpha_complex/test/alphaoffreader_for_doc.txt
new file mode 100644
index 00000000..1153f097
--- /dev/null
+++ b/src/Alpha_complex/test/alphaoffreader_for_doc.txt
@@ -0,0 +1,27 @@
+Alpha complex is of dimension 2 - 25 simplices - 7 vertices.
+Iterator on alpha complex simplices in the filtration order, with [filtration value]:
+   ( 1 ) -> [0] 
+   ( 2 ) -> [0] 
+   ( 3 ) -> [0] 
+   ( 4 ) -> [0] 
+   ( 5 ) -> [0] 
+   ( 6 ) -> [0] 
+   ( 7 ) -> [0] 
+   ( 4 3 ) -> [6.25] 
+   ( 6 5 ) -> [7.25] 
+   ( 3 1 ) -> [8.5] 
+   ( 2 1 ) -> [9.25] 
+   ( 4 2 ) -> [10] 
+   ( 3 2 ) -> [11.25] 
+   ( 4 3 2 ) -> [12.5] 
+   ( 3 2 1 ) -> [12.9959] 
+   ( 7 6 ) -> [13.25] 
+   ( 5 3 ) -> [20] 
+   ( 7 5 ) -> [22.7367] 
+   ( 7 6 5 ) -> [22.7367] 
+   ( 7 4 ) -> [30.25] 
+   ( 7 3 ) -> [36.5] 
+   ( 7 4 3 ) -> [36.5] 
+   ( 7 5 3 ) -> [37.2449] 
+   ( 5 1 ) -> [59.7107] 
+   ( 5 3 1 ) -> [59.7107] 
diff --git a/src/Doxyfile b/src/Doxyfile
index 9d4bc9c8..49ec4768 100644
--- a/src/Doxyfile
+++ b/src/Doxyfile
@@ -812,8 +812,9 @@ EXCLUDE_SYMBOLS        =
 # command).
 
 EXAMPLE_PATH           = common/example \
-    common/test
-
+    common/test \
+    Alpha_complex/example \
+    Alpha_complex/test \
 # If the value of the EXAMPLE_PATH tag contains directories, you can use the
 # EXAMPLE_PATTERNS tag to specify one or more wildcard pattern (like *.cpp and
 # *.h) to filter out the source-files in the directories. If left blank all
diff --git a/src/common/test/CMakeLists.txt b/src/common/test/CMakeLists.txt
index e4ac6c7b..1b4dd6e0 100644
--- a/src/common/test/CMakeLists.txt
+++ b/src/common/test/CMakeLists.txt
@@ -23,10 +23,12 @@ if(CGAL_FOUND)
       target_link_libraries(dtoffrw_UT ${Boost_SYSTEM_LIBRARY} ${Boost_UNIT_TEST_FRAMEWORK_LIBRARY})
 
       # Unitary tests
-      add_test(dtoffrw_UT ${CMAKE_CURRENT_BINARY_DIR}/dtoffrw_UT)
+      add_test(dtoffrw_UT ${CMAKE_CURRENT_BINARY_DIR}/dtoffrw_UT
+      # XML format for Jenkins xUnit plugin 
+      --log_format=XML --log_sink=${CMAKE_SOURCE_DIR}/dtoffrw_UT.xml --log_level=test_suite --report_level=no)
 
       if (DIFF_PATH)
-        add_test(diff_files_UT ${DIFF_PATH} ${CMAKE_CURRENT_BINARY_DIR}/UT.off ${CMAKE_CURRENT_BINARY_DIR}/dtoffrw_alphashapedoc_result.off)
+        add_test(dtoffrw_diff_files_UT ${DIFF_PATH} ${CMAKE_CURRENT_BINARY_DIR}/UT.off ${CMAKE_CURRENT_BINARY_DIR}/dtoffrw_alphashapedoc_result.off)
       endif()
 
     else()