Moved alphashapedoc.off in data/points

Moved Delaunay triangulation OFF files read and write in src/common
Delaunay triangulation OFF files read and write documentation, examples and tests


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

Former-commit-id: e03902736a79436e97dbf77a88504f3faa8bd9c6

2 files changed, 447 insertions, 152 deletions

diff --git a/src/common/include/gudhi/Delaunay_triangulation_off_io.h b/src/common/include/gudhi/Delaunay_triangulation_off_io.h
new file mode 100644
index 00000000..de5fa2af
--- /dev/null
+++ b/src/common/include/gudhi/Delaunay_triangulation_off_io.h
@@ -0,0 +1,308 @@
+/*    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) 2015  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/>.
+ */
+#ifndef SRC_ALPHA_SHAPES_INCLUDE_GUDHI_ALPHA_SHAPES_DELAUNAY_TRIANGULATION_OFF_IO_H_
+#define SRC_ALPHA_SHAPES_INCLUDE_GUDHI_ALPHA_SHAPES_DELAUNAY_TRIANGULATION_OFF_IO_H_
+
+#include <string>
+#include <vector>
+#include <fstream>
+#include <map>
+
+#include "gudhi/Off_reader.h"
+
+namespace Gudhi {
+
+/** \brief OFF file visitor implementation according to Off_reader in order to construct a CGAL Delaunay triangulation.
+ * 
+ * For more informations on CGAL Delaunay triangulation, please refer to the corresponding chapter in page
+ *  http://doc.cgal.org/latest/Triangulation/
+ */
+template<typename Complex>
+class Delaunay_triangulation_off_visitor_reader {
+ private:
+  Complex* _complex;
+  typedef typename Complex::Point Point;
+
+ public:
+
+  // TODO(VR) : Pass a Complex as a parameter is required, even if not used. Otherwise, compilation is KO.
+
+  /** \brief Delaunay_triangulation_off_visitor_reader constructor
+   *
+   * @param[in] _complex_ptr pointer on a Delaunay triangulation.
+   */
+  Delaunay_triangulation_off_visitor_reader(Complex* _complex_ptr)
+      : _complex(nullptr) { }
+
+  /** \brief Off_reader visitor init implementation. 
+   * 
+   * The init parameters are set from OFF file header.
+   * Dimension value is required in order to construct Delaunay triangulation.
+   *
+   * @param[in] dim space dimension of vertices.
+   * @param[in] num_vertices number of vertices in the OFF file (not used).
+   * @param[in] num_faces number of faces in the OFF file (not used).
+   * @param[in] num_edges number of edges in the OFF file (not used).
+   */
+  void init(int dim, int num_vertices, int num_faces, int num_edges) {
+#ifdef DEBUG_TRACES
+    std::cout << "Delaunay_triangulation_off_visitor_reader::init - dim=" << dim << " - num_vertices=" <<
+        num_vertices << " - num_faces=" << num_faces << " - num_edges=" << num_edges << std::endl;
+#endif  // DEBUG_TRACES
+    if (num_faces > 0) {
+      std::cerr << "Delaunay_triangulation_off_visitor_reader::init faces are not taken into account from OFF " <<
+          "file for Delaunay triangulation - faces are computed." << std::endl;
+    }
+    if (num_edges > 0) {
+      std::cerr << "Delaunay_triangulation_off_visitor_reader::init edges are not taken into account from OFF " <<
+          "file for Delaunay triangulation - edges are computed." << std::endl;
+    }
+    // Complex construction with dimension from file
+    _complex = new Complex(dim);
+  }
+
+  /** \brief Off_reader visitor point implementation. 
+   * 
+   * The point function is called on each vertex line from OFF file.
+   * This function inserts the vertex in the Delaunay triangulation.
+   *
+   * @param[in] point vector of vertex coordinates.
+   */
+  void point(const std::vector<double>& point) {
+#ifdef DEBUG_TRACES
+    std::cout << "Delaunay_triangulation_off_visitor_reader::point ";
+    for (auto coordinate : point) {
+      std::cout << coordinate << " | ";
+    }
+    std::cout << std::endl;
+#endif  // DEBUG_TRACES
+    _complex->insert(Point(point.size(), point.begin(), point.end()));
+  }
+
+  // Off_reader visitor maximal_face implementation - not used
+  void maximal_face(const std::vector<int>& face) {
+    // For Delaunay Triangulation, only points are read
+  }
+
+  // Off_reader visitor done implementation - not used
+  void done() {
+    // Nothing to be done on end of OFF file read
+  }
+
+  /** \brief Returns the constructed Delaunay triangulation.
+   *
+   * @return A pointer on the Delaunay triangulation.
+   * 
+   * @warning The returned pointer can be nullptr.
+   */
+  Complex* get_complex() const {
+    return _complex;
+  }
+};
+
+/** \brief OFF file reader implementation in order to construct a Delaunay triangulation.
+ * 
+ * This class is using the Delaunay_triangulation_off_visitor_reader to visit the OFF file according to Off_reader.
+ * 
+ * For more informations on CGAL Delaunay triangulation, please refer to the corresponding chapter in page
+ *  http://doc.cgal.org/latest/Triangulation/
+ * 
+ * \section Example
+ *
+ * This example loads points from an OFF file and builds the Delaunay triangulation.
+ * Then, it is asked to display the number of vertices and finites full cells from the Delaunay triangulation.
+ * 
+ * \include Delaunay_triangulation_off_rw.cpp
+ * 
+ * When launching:
+ * 
+ * \code $> ./dtoffrw ../../data/points/alphashapedoc.off triangulated.off
+ * \endcode
+ *
+ * the program output is:
+ * 
+ * \include dtoffrw_alphashapedoc_result.txt
+ */
+template<typename Complex>
+class Delaunay_triangulation_off_reader {
+ public:
+
+  /** \brief Reads the OFF file and constructs the Delaunay triangulation from the points
+   * that are in the OFF file.
+   *
+   * @param[in] name_file OFF file to read.
+   *
+   * @warning Check with is_valid() function to see if read operation was successful.
+   */
+  Delaunay_triangulation_off_reader(const std::string & name_file)
+  : valid_(false) {
+    std::ifstream stream(name_file);
+    if (stream.is_open()) {
+      Delaunay_triangulation_off_visitor_reader<Complex> off_visitor(_complex);
+      Off_reader off_reader(stream);
+      valid_ = off_reader.read(off_visitor);
+      if (valid_) {
+        _complex = off_visitor.get_complex();
+        if (_complex == nullptr) {
+          std::cerr << "Delaunay_triangulation_off_reader::Delaunay_triangulation_off_reader off_visitor returns an empty pointer" << std::endl;
+          valid_ = false;
+        }
+      }
+    } else {
+      std::cerr << "Delaunay_triangulation_off_reader::Delaunay_triangulation_off_reader could not open file " <<
+          name_file << std::endl;
+    }
+
+  }
+
+  /** \brief Returns if the OFF file read operation was successful or not.
+   *
+   * @return OFF file read status.
+   */
+  bool is_valid() const {
+    return valid_;
+  }
+
+  /** \brief Returns the constructed Delaunay triangulation.
+   *
+   * @return A pointer on the Delaunay triangulation.
+   * 
+   * @warning The returned pointer can be nullptr.
+   */
+  Complex* get_complex() const {
+    if (valid_)
+      return _complex;
+    return nullptr;
+
+  }
+
+ private:
+  /** \brief OFF file read status.*/
+  bool valid_;
+  /** \brief A pointer on the Delaunay triangulation.*/
+  Complex* _complex;
+};
+
+/** \brief OFF file writer from a Delaunay triangulation.
+ * 
+ * This class constructs the OFF file header according to http://www.geomview.org/docs/html/OFF.html
+ * 
+ * The header is followed by the list of points coordinates (Delaunay triangulation vertices)
+ * 
+ * And finally is followed by the list of faces (Delaunay triangulation finite full cells)
+ * 
+ * For more informations on CGAL Delaunay triangulation, please refer to the corresponding chapter in page
+ * http://doc.cgal.org/latest/Triangulation/
+ * 
+ * \section Example
+ *
+ * This example loads points from an OFF file and builds the Delaunay triangulation.
+ * Then, the Delaunay triangulation is saved in a new file including the triangulation as a list of faces.
+ * 
+ * \include Delaunay_triangulation_off_rw.cpp
+ * 
+ * When launching:
+ * 
+ * \code $> ./dtoffrw ../../data/points/alphashapedoc.off triangulated.off
+ * \endcode
+ *
+ * The result will be an OFF file of dimension 2 with the 7 points from alphashapedoc.off followed by the 6
+ * triangulations of dimension 3 (the first value on each faces):
+ * \include dtoffrw_alphashapedoc_result.off
+ */
+template<typename Complex>
+class Delaunay_triangulation_off_writer {
+ public:
+  typedef typename Complex::Point Point;
+
+  /** \brief Writes the OFF file from the Delaunay triangulation
+   *
+   * @param[in] name_file OFF file to write.
+   * @param[in] complex_ptr pointer on a Delaunay triangulation.
+   *
+   * @warning Check with is_valid() function to see if write operation was successful.
+   */
+  Delaunay_triangulation_off_writer(const std::string & name_file, Complex* complex_ptr)
+      : valid_(false) {
+    std::ofstream stream(name_file);
+    if (stream.is_open()) {
+      if (complex_ptr->current_dimension() == 3) {
+        // OFF header
+        stream << "OFF" << std::endl;
+        // no endl on next line - don't know why...
+        stream << complex_ptr->number_of_vertices() << " " << complex_ptr->number_of_finite_full_cells() << " 0";
+      } else {
+        // nOFF header
+        stream << "nOFF" << std::endl;
+        // no endl on next line - don't know why...
+        stream << complex_ptr->current_dimension() << " " << complex_ptr->number_of_vertices() << " " <<
+            complex_ptr->number_of_finite_full_cells() << " 0";
+
+      }
+
+      // bimap to retrieve vertex handles from points and vice versa
+      std::map< Point, int > points_to_vh;
+      // Start to insert at default handle value
+      int vertex_handle = int();
+
+      // Points list
+      for (auto vit = complex_ptr->vertices_begin(); vit != complex_ptr->vertices_end(); ++vit) {
+        for (auto Coord = vit->point().cartesian_begin(); Coord != vit->point().cartesian_end(); ++Coord) {
+          stream << *Coord << " ";
+        }
+        stream << std::endl;
+        points_to_vh[vit->point()] = vertex_handle;
+        vertex_handle++;
+      }
+
+      for (auto cit = complex_ptr->finite_full_cells_begin(); cit != complex_ptr->finite_full_cells_end(); ++cit) {
+        std::vector<int> vertexVector;
+        stream << std::distance(cit->vertices_begin(), cit->vertices_end()) << " ";
+        for (auto vit = cit->vertices_begin(); vit != cit->vertices_end(); ++vit) {
+          stream << points_to_vh[(*vit)->point()] << " ";
+        }
+        stream << std::endl;
+      }
+      stream.close();
+      valid_ = true;
+    } else {
+      std::cerr << "Delaunay_triangulation_off_writer::Delaunay_triangulation_off_writer could not open file " <<
+          name_file << std::endl;
+    }
+  }
+  
+  /** \brief Returns if the OFF write operation was successful or not.
+   *
+   * @return OFF file write status.
+   */
+  bool is_valid() const {
+    return valid_;
+  }
+
+ private:
+  /* \brief OFF file write status. */
+  bool valid_;
+};
+
+} // namespace Gudhi
+
+#endif  // SRC_ALPHA_SHAPES_INCLUDE_GUDHI_ALPHA_SHAPES_DELAUNAY_TRIANGULATION_OFF_IO_H_
diff --git a/src/common/include/gudhi/Off_reader.h b/src/common/include/gudhi/Off_reader.h
index 618d1b4d..a8abb507 100644
--- a/src/common/include/gudhi/Off_reader.h
+++ b/src/common/include/gudhi/Off_reader.h
@@ -36,163 +36,150 @@
 
 namespace Gudhi {
 
-/**
- * Read an off file and calls a visitor methods while reading it.
- * An off file must have its first/snd line in this format :
- * OFF
- * num_vert num_faces num_edges
- *
- * A noff file must have its first/snd line in this format :
- * nOFF
- * dim num_vert num_faces num_edges
- *
- * The number of edges num_edges is optional and can be left to zero.
+/** \brief OFF file reader top class visitor. 
+ * 
+ * OFF file must be conform to format described here : 
+ * http://www.geomview.org/docs/html/OFF.html
  */
-class Off_reader{
-public:
-	Off_reader(std::ifstream& stream):stream_(stream){
-	}
-//	Off_reader(const std::string& name):stream_(name){
-//		if(!stream_.is_open())
-//			std::cerr <<"could not open file \n";
-//	}
-
-	~Off_reader(){
-		stream_.close();
-	}
-
-	/**
-	 * read an off file and calls the following methods :
-	 * void init(int dim,int num_vertices,int num_faces,int num_edges); //num_edges may not be set
-	 * void point(const std::vector<double>& point);
-	 * void maximal_face(const std::list<int>& face);
-	 * void done();
-	 * of the visitor when reading a point or a maximal face.
-	 */
-	template<typename OffVisitor>
-	bool read(OffVisitor& off_visitor){
-		bool success_read_off_preambule = read_off_preambule(off_visitor);
-		if(!success_read_off_preambule) {
-			std::cerr <<"could not read off preambule\n";
-			return false;
-		}
-
-		bool success_read_off_points = read_off_points(off_visitor);
-		if(!success_read_off_points) {
-			std::cerr <<"could not read off points\n";
-			return false;
-		}
-
-		bool success_read_off_faces = read_off_faces(off_visitor);
-		if(!success_read_off_faces) {
-			std::cerr <<"could not read off faces\n";
-			return false;
-		}
-
-		off_visitor.done();
-		return success_read_off_preambule && success_read_off_points && success_read_off_faces;
-	}
-
-private:
-	std::ifstream& stream_;
-
-	struct Off_info{
-		int dim;
-		int num_vertices;
-		int num_edges;
-		int num_faces;
-	};
-
-	Off_info off_info_;
-
-	template<typename OffVisitor>
-	bool read_off_preambule(OffVisitor& off_visitor){
-		std::string line;
-		if(!goto_next_uncomment_line(line)) return false;
-
-		bool is_off_file = (line.find("OFF") != std::string::npos);
-		bool is_noff_file = (line.find("nOFF") != std::string::npos);
-
-    	if(!is_off_file && !is_noff_file) {
-    		std::cerr << line<<std::endl;
-    		std::cerr << "missing off header\n";
-    		return false;
-    	}
-
-    	if(!goto_next_uncomment_line(line)) return false;
-    	std::istringstream iss(line);
-   		if((is_off_file) && (!is_noff_file)) {
-	  		off_info_.dim = 3;
-	  		if(!(iss >> off_info_.num_vertices >> off_info_.num_faces >> off_info_.num_edges)){
-	  			std::cerr << "incorrect number of vertices/faces/edges\n";
-	  			return false;
-	  		}
-		}
-		else
-			if(!(iss >> off_info_.dim >> off_info_.num_vertices >> off_info_.num_faces >> off_info_.num_edges)){
-				std::cerr << "incorrect number of vertices/faces/edges\n";
-				return false;
-			}
-   		off_visitor.init(off_info_.dim,off_info_.num_vertices,off_info_.num_faces,off_info_.num_edges);
-
-   		return true;
-	}
-
-	bool goto_next_uncomment_line(std::string& uncomment_line){
-		uncomment_line.clear();
-		do
-			std::getline(stream_, uncomment_line);
-    	while(uncomment_line[0] == '%');// || uncomment_line.empty());
-		return (uncomment_line.size()>0 && uncomment_line[0] != '%');
-	}
-
-
-	template<typename OffVisitor>
-	bool read_off_points(OffVisitor& visitor){
-		int num_vertices_to_read = off_info_.num_vertices;
-		while(num_vertices_to_read--){
-			std::string line;
-			if(!goto_next_uncomment_line(line)) return false;
-			std::vector<double> point;
-			std::istringstream iss(line);
-			point.assign(std::istream_iterator<double>(iss),std::istream_iterator<double>());
-//			if(point.size() != off_info_.dim) return false;
-			visitor.point(point);
-		}
-		return true;
-	}
-
-	template<typename OffVisitor>
-	bool read_off_faces(OffVisitor& visitor){
-		std::string line;
-		while(goto_next_uncomment_line(line)){
-			std::istringstream iss(line);
-			int num_face_vertices;
-			iss >> num_face_vertices;
-			std::vector<int> face;
-			face.assign(std::istream_iterator<int>(iss),std::istream_iterator<int>());
-			if(!face.size() == off_info_.num_vertices) return false;
-			visitor.maximal_face(face);
-		}
-		return true;
-	}
+class Off_reader {
+ public:
+
+  Off_reader(std::ifstream& stream) : stream_(stream) { }
+
+  ~Off_reader() {
+    stream_.close();
+  }
+
+  /** \brief
+   * Read an OFF file and calls the following methods :
+   * 
+   * <CODE>void init(int dim,int num_vertices,int num_faces,int num_edges);  // from file header - num_edges may not be set
+   * 
+   * void point(const std::vector<double>& point);  // for each point read
+   * 
+   * void maximal_face(const std::list<int>& face);  // for each face read
+   * 
+   * void done();  // upon file read is finished</CODE>
+   * 
+   * of the visitor when reading a point or a maximal face. Edges are not taken into account.
+   */
+  template<typename OffVisitor>
+  bool read(OffVisitor& off_visitor) {
+    bool success_read_off_preambule = read_off_preambule(off_visitor);
+    if (!success_read_off_preambule) {
+      std::cerr << "could not read off preambule\n";
+      return false;
+    }
+
+    bool success_read_off_points = read_off_points(off_visitor);
+    if (!success_read_off_points) {
+      std::cerr << "could not read off points\n";
+      return false;
+    }
+
+    bool success_read_off_faces = read_off_faces(off_visitor);
+    if (!success_read_off_faces) {
+      std::cerr << "could not read off faces\n";
+      return false;
+    }
+
+    off_visitor.done();
+    return success_read_off_preambule && success_read_off_points && success_read_off_faces;
+  }
+
+ private:
+  std::ifstream& stream_;
+
+  struct Off_info {
+    int dim;
+    int num_vertices;
+    int num_edges;
+    int num_faces;
+  };
+
+  Off_info off_info_;
+
+  template<typename OffVisitor>
+  bool read_off_preambule(OffVisitor& off_visitor) {
+    std::string line;
+    if (!goto_next_uncomment_line(line)) return false;
+
+    bool is_off_file = (line.find("OFF") != std::string::npos);
+    bool is_noff_file = (line.find("nOFF") != std::string::npos);
+
+    if (!is_off_file && !is_noff_file) {
+      std::cerr << line << std::endl;
+      std::cerr << "missing off header\n";
+      return false;
+    }
+
+    if (!goto_next_uncomment_line(line)) return false;
+    std::istringstream iss(line);
+    if ((is_off_file) && (!is_noff_file)) {
+      off_info_.dim = 3;
+      if (!(iss >> off_info_.num_vertices >> off_info_.num_faces >> off_info_.num_edges)) {
+        std::cerr << "incorrect number of vertices/faces/edges\n";
+        return false;
+      }
+    } else
+      if (!(iss >> off_info_.dim >> off_info_.num_vertices >> off_info_.num_faces >> off_info_.num_edges)) {
+      std::cerr << "incorrect number of vertices/faces/edges\n";
+      return false;
+    }
+    off_visitor.init(off_info_.dim, off_info_.num_vertices, off_info_.num_faces, off_info_.num_edges);
+
+    return true;
+  }
+
+  bool goto_next_uncomment_line(std::string& uncomment_line) {
+    uncomment_line.clear();
+    do
+      std::getline(stream_, uncomment_line); while (uncomment_line[0] == '%');
+    return (uncomment_line.size() > 0 && uncomment_line[0] != '%');
+  }
+
+  template<typename OffVisitor>
+  bool read_off_points(OffVisitor& visitor) {
+    int num_vertices_to_read = off_info_.num_vertices;
+    while (num_vertices_to_read--) {
+      std::string line;
+      if (!goto_next_uncomment_line(line)) return false;
+      std::vector<double> point;
+      std::istringstream iss(line);
+      point.assign(std::istream_iterator<double>(iss), std::istream_iterator<double>());
+      //			if(point.size() != off_info_.dim) return false;
+      visitor.point(point);
+    }
+    return true;
+  }
+
+  template<typename OffVisitor>
+  bool read_off_faces(OffVisitor& visitor) {
+    std::string line;
+    while (goto_next_uncomment_line(line)) {
+      std::istringstream iss(line);
+      int num_face_vertices;
+      iss >> num_face_vertices;
+      std::vector<int> face;
+      face.assign(std::istream_iterator<int>(iss), std::istream_iterator<int>());
+      if (!face.size() == off_info_.num_vertices) return false;
+      visitor.maximal_face(face);
+    }
+    return true;
+  }
 };
 
-
 template<typename OFFVisitor>
-void read_off(const std::string& name_file_off,OFFVisitor& vis){
-	std::ifstream stream(name_file_off);
-	if(!stream.is_open())
-		std::cerr <<"could not open file \n";
-	else{
-		Off_reader off_reader(stream);
-		off_reader.read(vis);
-	}
+void read_off(const std::string& name_file_off, OFFVisitor& vis) {
+  std::ifstream stream(name_file_off);
+  if (!stream.is_open())
+    std::cerr << "could not open file \n";
+  else {
+    Off_reader off_reader(stream);
+    off_reader.read(vis);
+  }
 }
 
-
-
 }  // namespace Gudhi
 
-
-#endif /* GUDHI_OFF_READER_H_ */
+#endif  // GUDHI_OFF_READER_H_