merge doc

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

Former-commit-id: f50f6eda2f484864be2bf27960a58dbbbaba9793

3 files changed, 35 insertions, 39 deletions

diff --git a/src/Contraction/include/gudhi/Edge_contraction.h b/src/Contraction/include/gudhi/Edge_contraction.h
index 94638415..5dcdbeb2 100644
--- a/src/Contraction/include/gudhi/Edge_contraction.h
+++ b/src/Contraction/include/gudhi/Edge_contraction.h
@@ -44,23 +44,23 @@ namespace contraction{
 \section Introduction
 
 The purpose of this package is to offer a user-friendly interface for edge contraction simplification of huge simplicial complexes.
-It uses the \ref skbl data-structure whose size remains small  during simplification 
-of most used geometrical complexes in topological data analysis such as the Rips or the Delaunay complexes (much lower than the total number of simplices in practice).
+It uses the \ref skbl data-structure whose size remains small  during simplification  
+of  most used geometrical complexes of topological data analysis such as the Rips or the Delaunay complexes. In practice, the 
+size of this data-structure is even uch lower than the total number of simplices.
 
 The edge contraction operation consists in identifying two vertices of a simplicial complex. 
-Several algorithms have been developed in computer graphics that allows to reduce efficiently the size of a
-simplicial complex while preserving its geometry 
-\cite Garland \cite Lindstrom.
-These approaches can be extended to higher-dimensional simplicial complexes. 
+A lot of algorithms have been developed in computer graphics that allows to reduce efficiently the size of 2-dimensional simplicial complexes
+ while preserving its geometry (for instance see \cite Garland \cite Lindstrom).
+These approaches can be extended to higher-dimensional simplicial complexes.
 The main advantage of using the Skeleton-Blocker data structure for edge contraction is that when the number of blockers is small, 
-most operations needed (link computation, edge contraction and so on) have polynomial complexity regarding the size the graph. 
-The simplification can be done without enumerating the set of simplices that is often non tracktable in high-dimension and is then very efficient
+the operations needed for edge contraction algorithms have polynomial complexity regarding the size the graph. 
+Therefore, the simplification can be done without enumerating the set of simplices that is often non tracktable in high-dimension and is then very efficient
 (sub-linear with regards to the number of simplices in practice).
 
-A typical application of this package for homology group computation and is illustrated in the next figure where a Rips is built uppon a set of high-dimensional points and
+A typical application of this package is homology group computation. It is illustrated in the next figure where a Rips complex is built uppon a set of high-dimensional points and
 simplified with edge contractions.
-It has initially a big number of simplices (around 20 millions) but simplifying it to a much reduced form with 15 vertices (and 714 simplices) takes only few seconds on a desktop machine (see the example bellow).
-One can then compute homology group with a simplicial complex of less than one hundred simplices instead of running the homology algorithm on the much bigger initial set of 
+It has initially a big number of simplices (around 20 millions) but simplifying it to a much reduced form with only 15 vertices (and 714 simplices) takes only few seconds on a desktop machine (see the example bellow).
+One can then compute homology group with a simplicial complex having very few simplices instead of running the homology algorithm on the much bigger initial set of 
 simplices which would take much more time and memory.
 
 
@@ -68,7 +68,7 @@ simplices which would take much more time and memory.
 
 \section Design
 
-This class design is policy based and heavily inspired from the similar edge collapse package of CGAL http://doc.cgal.org/latest/Surface_mesh_simplification/index.html (which is restricted to 2D triangulations).
+This class design is policy based and heavily inspired from the similar edge collapse package of CGAL http://doc.cgal.org/latest/Surface_mesh_simplification/index.html (which is however restricted to 2D triangulations).
 
 
 \subsection Policies
@@ -77,7 +77,7 @@ Four policies can be customized in this package:
 
 \li Cost_policy: specify how much cost an edge contraction of a given edge. The edge with lowest cost is iteratively picked and contracted if valid.
 \li Valid_contraction_policy: specify if a given edge contraction is valid. For instance, this policy can check the link condition which ensures that the homotopy type is preserved afer the edge contraction.
-\li Placement_policy: every time an edge is contracted, its points are merge to one point specified by this policy. This may be the middle of the edge of some more sofisticated point such as the minimum of a cost as in 
+\li Placement_policy: every time an edge is contracted, its points are merge to one point specified by this policy. This may be the middle of the edge of some more sophisticated point such as the minimum of a cost as in 
 \cite Garland.
 
 
@@ -86,27 +86,27 @@ Four policies can be customized in this package:
 A visitor which implements the class Contraction_visitor gets called at several key moments
 during the simplification:
 
-\li when the algorithms starts or ends
-\li when an edge is seen for the first time
-\li when an edge is considered for an edge contraction
-\li before and after an edge is contracted
+\li when the algorithms starts or ends,
+\li when an edge is seen for the first time,
+\li when an edge is considered for an edge contraction,
+\li before and after an edge is contracted.
 
 This allows to implements most of edge contraction based algorithm with this 
-package. 
+package without having to change the main simplification source code.
 
 
 \section Performance 
 
 The next figure shows the computation time to reduce a random 2-sphere to a single tetrahedron with 
-this package and with the CGAL equivalent package (to is specific to 2-manifold simplicial complexes).
+this package and with the CGAL equivalent package.
 Despite this package is able to deal with \a arbitrary simplicial complexes (any dimensions, manifold or non manifold),
-it is still \a 65% times faster than CGAL package which is focused on 2-manifold. 
+it is still \a 65% times faster than the CGAL package which is focused on 2-manifold. 
 The main reason is that few blockers appears during the simplification and hence,
 the algorithm only have to deal with the graph and not higher-dimensional simplices
 (in this case triangles). However, we recall that higher-dimensional simplices are \a implicitely 
-stored in the \ref skbl data-structure and hence, if one has to store nodes
-to simplices in an external map if storing information on simplices such 
-as orientation is needed.
+stored in the \ref skbl data-structure. Hence, one has to store
+simplices in an external map if some information needs to be associated with them (information that could be a filtration value or 
+an orientation for instance).
 
 
 \image html "sphere_contraction.png" "Time in seconds to simplify random 2-spheres to a tetrahedron" width=10cm
@@ -114,8 +114,8 @@ as orientation is needed.
 \section Example
 
  
-This example loads points in an off file and build the Rips complex with an user provided parameter. It then simplifies the build Rips complex
-while ensuring that homotopy type is preserved during the contraction (edge are contracted only when the link condition is valid).
+This example loads points from an OFF file and builds the Rips complex with an user provided parameter. It then simplifies the built Rips complex
+while ensuring its homotopy type is preserved during the contraction (edge are contracted only when the link condition is valid).
 
   \code{.cpp}
 #include <boost/timer/timer.hpp>
diff --git a/src/Skeleton_blocker/include/gudhi/Skeleton_blocker.h b/src/Skeleton_blocker/include/gudhi/Skeleton_blocker.h
index e67323e5..77f59e35 100644
--- a/src/Skeleton_blocker/include/gudhi/Skeleton_blocker.h
+++ b/src/Skeleton_blocker/include/gudhi/Skeleton_blocker.h
@@ -41,10 +41,9 @@ namespace skbl{
 \author David Salinas
 
 \section Introduction
-The Skeleton-Blocker data-structure had been introduced in the two papers 
-\cite socg_blockers_2011,\cite blockers2012. 
-It proposes a light encoding for simplicial complexes by storing only an *implicit* representation of its
-simplices.
+The Skeleton-Blocker data-structure proposes a light encoding for simplicial complexes by storing only an *implicit* representation of its
+simplices 
+\cite socg_blockers_2011,\cite blockers2012.
 Intuitively, it just stores the 1-skeleton of a simplicial complex with a graph and the set of its "missing faces" that
 is very small in practice (see next section for a formal definition).
 This data-structure handles all  simplicial complexes operations such as
@@ -60,7 +59,7 @@ An abstract simplex is a finite non-empty set and its dimension is its number of
 Whenever \f$\tau \subset \sigma\f$ and \f$\tau \neq \emptyset \f$, \f$ \tau \f$ is called a face of 
 \f$ \sigma\f$  and \f$ \sigma\f$ is called a coface of \f$ \tau \f$ . Furthermore,
 when \f$ \tau \neq \sigma\f$ we say that \f$ \tau\f$ is a proper-face of \f$ \sigma\f$.
-An abstract simplicial complex is a set of simplices that contains all the faces of their simplices.
+An abstract simplicial complex is a set of simplices that contains all the faces of its simplices.
 The 1-skeleton of a simplicial complex (or its graph) consists of its elements of dimension lower than 2.
 
 *\image html "ds_representation.png" "Skeleton-blocker representation" width=20cm
@@ -81,8 +80,8 @@ In practice, the set of blockers of a simplicial complex
 remains also small when simplifying a Rips complex with edge contractions 
 but also for most of the simplicial complexes used in topological data-analysis such as Delaunay, Cech or Witness complexes. 
 For instance, the numbers of blockers is depicted for random 3-dimensional spheres embedded into \f$R^4\f$ 
-in next figure. Storing the graph and blockers of such simplicial complex is much compact in this case than storing 
-its simplices.
+in next figure. Storing the graph and blockers of such simplicial complexes is much compact in this case than storing 
+their simplices.
 
 
 *\image html "blockers_curve.png" "Number of blockers of random triangulations of 3-spheres" width=10cm
@@ -94,7 +93,7 @@ its simplices.
 
 \subsection Overview
 
-Four classes are implemented for simplicial complex in this representation namely (most user will just need to use Skeleton_blocker_geometric_complex)
+Four classes are implemented for simplicial complex in this representation namely (most user will just need to use Skeleton_blocker_geometric_complex):
 
 \li Skeleton_blocker_complex : a simplicial complex with basic operations such as vertex/edge/simplex enumeration and construction
 \li Skeleton_blocker_link_complex : the link of a simplex in a parent complex. It is represented as a sub complex
@@ -181,7 +180,7 @@ The Euler Characteristic is 1
 
 \subsection Acknowledgements
 The author wishes to thank Dominique Attali and André Lieutier for 
-their collaboration to write the two initial papers about this data-structure
+their collaboration to write the two initial papers (cite socg_blockers_2011,\cite blockers2012) about this data-structure
  and also Dominique for leaving him use a prototype. 
 
 
diff --git a/src/common/doc/main_page.h b/src/common/doc/main_page.h
index b573f4d0..b2c8bca5 100644
--- a/src/common/doc/main_page.h
+++ b/src/common/doc/main_page.h
@@ -10,11 +10,9 @@ state-of-the-art algorithms and data structures for computational topology.
 
 The current release of the library allows to use several data-structures for simplicial complexes :
 simplex tree, Hasse diagram or skeleton-blocker. Several  operations can then be done on top of these
-representations such a persistent homology computation or simplification.
-
+representations such as persistent homology computation or simplification. 
 All data-structures are generic and several of their aspects (such as stored elements, policies) 
 can be parameterized via template classes.
-
 We refer to 
 \cite gudhilibrary_ICMS14
 for a detailed description of the design of the library.
@@ -23,13 +21,12 @@ for a detailed description of the design of the library.
 \section compiling Compiling
 
 The library uses c++11 and requires Boost with version 1.48.0 or more recent :  http://www.boost.org/.
+It is a multiplaform library and compiles on Linux, Mac OSX and Visual Studio 2013. 
 
-The library compiles in Linux and Mac OSX.
 
 \subsection gmp GMP:
 The multi-field persistent homology algorithm requires GMP which is a free library for arbitrary-precision
 arithmetic, operating on signed integers, rational numbers, and floating point numbers
-
 The following examples require The GNU Multiple Precision Arithmetic Library (GMP) http://gmplib.org/
 and will not be built if GMP is not installed:
   - Persistent_cohomology/rips_multifield_persistence