Update tutorial from review

Documentation/doc/Documentation/Tutorials/Tutorial_reconstruction.txt

@@ -5,19 +5,19 @@ namespace CGAL {
 
 /*!
 
-\page tuto_reconstruction Surface Reconstruction
+\page tuto_reconstruction Surface Reconstruction from Point Clouds
 \cgalAutoToc
 
 \author Simon Giraudot
 
-Surface reconstruction from point clouds is a core topic of
+Surface reconstruction from point clouds is a core topic in geometry
-geometry. It is an ill-posed problem: there is an infinite number of
+processing \cgalCite{cgal:btsag-asosr-16}. It is an ill-posed problem:
-surfaces that can match a single point cloud and a point cloud does
+there is an infinite number of surfaces that approximate a single
-not define a surface in itself. Thus additional assumptions and
+point cloud and a point cloud does not define a surface in
-constraints must be defined by the user and reconstruction can be
+itself. Thus additional assumptions and constraints must be defined by
-achieved in many different ways. This tutorials explains how to use
+the user and reconstruction can be achieved in many different
-the different algorithms of \cgal to perform reconstruction in the
+ways. This tutorials provides guidances on how to use the different
-most relevant way.
+algorithms of \cgal to effectively perform surface reconstruction.
 
 \section TutorialsReconstruction_algorithms Which algorithm should I use?
 
@@ -29,7 +29,7 @@ most relevant way.
 
 
 Because reconstruction is an ill-posed problem, it must be regularized
-via priori knowledge. Differences in prior leads to different
+via prior knowledge. Differences in prior leads to different
 algorithms, and choosing one or the other of these methods is
 dependent on these priors. For example, Poisson always generates
 closed shapes (bounding a volume) and requires normals but does not
@@ -60,14 +60,15 @@ From left to right: original point cloud; Poisson; advancing front; scale space.
 \cgalFigureEnd
 
 More information on these different methods can be found on their
-respective manual pages and in section \ref TutorialsReconstruction_reconstruction.
+respective manual pages and in Section \ref TutorialsReconstruction_reconstruction.
 
 \section TutorialsReconstruction_overview Pipeline Overview
 
 This tutorial aims at providing a more comprehensive view of the
-possibilities offered by \cgal for treating point clouds for surface
+possibilities offered by \cgal for dealing with point clouds, for
-reconstruction purposes. The following diagram shows an overview (not
+surface reconstruction purposes. The following diagram shows an
-exhaustive) of typical reconstruction steps using \cgal tools.
+overview (not exhaustive) of common reconstruction steps using \cgal
+tools.
 
 
 \image html reconstruction.svg "Pipeline Overview" 
@@ -79,26 +80,24 @@ We now review some of these steps in more details.
 
 The reconstruction algorithms in \cgal take a range of iterators on a
 container as input and use property maps to access the points (and the
-normals if they are needed). Points are typically stored in plain text
+normals when they are required). Points are typically stored in plain
-format (denoted as 'XYZ' format), each point separated by a newline
+text format (denoted as 'XYZ' format) where each point is separated by
-character and each coordinate separated by a white space. Other
+a newline character and each coordinate separated by a white
-formats available are 'OFF' and 'PLY'. \cgal provides functions to
+space. Other formats available are 'OFF' and 'PLY'. \cgal provides
-read such formats:
+functions to read such formats:
 
 - `read_xyz_points()`
-- `read_xyz_points_and_normals()`
 - `read_off_points()`
-- `read_off_points_and_normals()`
 - `read_ply_points()`
-- `read_ply_points_and_normals()`
+- `read_ply_points_with_properties()` to read additional PLY properties
 
 \cgal also provides a dedicated container `CGAL::Point_set_3` to
 handle point sets with additional properties such as normal
-vectors. In that case, property maps are easily handled as shown in
+vectors. In this case, property maps are easily handled as shown in
 the following sections. This structure also handles the stream
 operator to read point sets in any of the formats previously
-described. Using this method is pretty straightforward, as can be seen
+described. Using this method yields substantially shorter code, as can
-on the following example:
+be seen on the following example:
 
 \snippet Poisson_surface_reconstruction_3/tutorial_example.cpp Reading input
 
@@ -106,7 +105,7 @@ on the following example:
 
 Because reconstruction algorithms have some specific requirements that
 point clouds do not always meet, some preprocessing might be necessary
-to get the best results.
+to yield the best results.
 
 Note that this _preprocessing_ step is optional: when the input point
 cloud has no imperfections, reconstruction can be applied to it
@@ -127,12 +126,12 @@ smoothing); simplified point cloud (grid simplification).
 
 \subsection TutorialsReconstruction_preprocessing_outliers Outlier removal
 
-Some acquisition techniques generate points which are far away from the
+Some acquisition techniques generate points which are far away from
-surface have no relevance for reconstruction. They are usually
+the surface. These points, commonly referred to as "outliers", have no
-referred to as 'outliers'. Using the \cgal reconstruction algorithms
+relevance for reconstruction. Using the \cgal reconstruction
-on outlier-ridden point clouds produce overly distorted output, it is
+algorithms on outlier-ridden point clouds produce overly distorted
-therefore strongly advised to filter these outliers _before_
+output, it is therefore strongly advised to filter these outliers
-performing reconstruction.
+_before_ performing reconstruction.
 
 \snippet Poisson_surface_reconstruction_3/tutorial_example.cpp Outlier removal
 
@@ -147,10 +146,11 @@ algorithms which, in general, only handle small variations of sampling
 density.
 
 \cgal provides several simplification algorithms. In addition to
-reducing the size of the input and therefore decreasing computation
+reducing the size of the input point cloud and therefore decreasing
-time, some of them can help making the input more uniform. This is the
+computation time, some of them can help making the input more
-case of the function `grid_simplify_point_set()` which defines a grid
+uniform. This is the case of the function `grid_simplify_point_set()`
-of a user-specified size and only keeps one point per cell.
+which defines a grid of a user-specified size and keeps one point per
+occupied cell.
 
 \snippet Poisson_surface_reconstruction_3/tutorial_example.cpp Simplification
 
@@ -161,8 +161,8 @@ Although reconstructions via 'Poisson' or 'Scale space' handle noise
 internally, one may want to get tighter control over the smoothing
 step. For example, a slightly noisy point cloud can benefit from some
 reliable smoothing algorithms and be reconstructed via 'Advancing
-front' which provides interesting output properties (oriented mesh
+front' which provides relevant properties (oriented mesh with
-with boundaries).
+boundaries).
 
 Two functions are provided to smooth a noisy point cloud with a good
 approximation (i.e. without degrading curvature, for example):
@@ -175,7 +175,7 @@ These functions directly modify the container:
 \snippet Poisson_surface_reconstruction_3/tutorial_example.cpp Smoothing
 
 
-\subsection TutorialsReconstruction_preprocessing_normal Normal Estimation
+\subsection TutorialsReconstruction_preprocessing_normal Normal Estimation and Orientation
 
 \ref Chapter_Poisson_Surface_Reconstruction "Poisson Surface Reconstruction"
 requires points with oriented normal vectors. To apply the algorithm
@@ -199,7 +199,7 @@ consistent.
 
 \subsection TutorialsReconstruction_reconstruction_poisson Poisson
 
-Poisson reconstruction consists in computing an indicator function
+Poisson reconstruction consists in computing an implicit function
 whose gradient matches the input normal vector field: this indicator
 function has opposite signs inside and outside of the inferred shape
 (hence the need for closed shapes). This method thus requires normals
@@ -228,7 +228,7 @@ which describe the triangular facets of the reconstruction: it uses a
 priority queue to sequentially pick the Delaunay facet the most likely
 to be part of the surface, based on a size criterion (to favor the
 small facets) and an angle criterion (to favor smoothness). Its main
-asset is to generate oriented manifold surfaces with boundaries:
+virtue is to generate oriented manifold surfaces with boundaries:
 contrary to Poisson, it does not require normals and is not bound to
 reconstruct closed shapes. However, it requires preprocessing if the
 point cloud is noisy.

Documentation/doc/biblio/cgal_manual.bib

@@ -1757,6 +1757,21 @@ ABSTRACT = {We present the first complete, exact and efficient C++ implementatio
   pages=""
 }
 
+@article{cgal:btsag-asosr-16,
+  TITLE = {{A Survey of Surface Reconstruction from Point Clouds}},
+  AUTHOR = {Berger, Matthew and Tagliasacchi, Andrea and Seversky, Lee and Alliez, Pierre and Guennebaud, Gael and Levine, Joshua and Sharf, Andrei and Silva, Claudio},
+  URL = {https://hal.inria.fr/hal-01348404},
+  JOURNAL = {{Computer Graphics Forum}},
+  PUBLISHER = {{Wiley}},
+  PAGES = {27},
+  YEAR = {2016},
+  DOI = {10.1111/cgf.12802},
+  PDF = {https://hal.inria.fr/hal-01348404/file/survey-author.pdf},
+  HAL_ID = {hal-01348404},
+  HAL_VERSION = {v2}
+}
+
+
 @TechReport{ cgal:pabl-cco-07,
 	author 	    = {Poudret, M. and Arnould, A. and Bertrand, Y. and Lienhardt, P.},
 	title 	    = {Cartes Combinatoires Ouvertes.},