Apply suggestions from code review

Co-authored-by: Mael <mael.rouxel.labbe@geometryfactory.com>
Co-authored-by: Sebastien Loriot <sloriot.ml@gmail.com>

Author: 3 people

Snap_rounding_2/doc/Snap_rounding_2/PackageDescription.txt

@@ -6,12 +6,12 @@
 /// Functions to round segments or polygons safely
 /// \ingroup PkgSnapRounding2Ref
 
-/// \defgroup Snap_rounding_hot_pixel_grp Hot pixel snap rounding
-/// Classes and functions to round segments or polygons using hot pixel SR method.
+/// \defgroup Snap_rounding_hot_pixel_grp Hot Pixel Snap Rounding
+/// Classes and functions to round segments or polygons using Hot Pixel SR method.
 /// \ingroup PkgSnapRounding2Ref
 
-/// \defgroup Snap_rounding_vertical_slab_grp Vertical slab snap rounding
-/// Classes and functions to round segments or polygons using vertical slab SR method.
+/// \defgroup Snap_rounding_vertical_slab_grp Vertical Slab Snap Rounding
+/// Classes and functions to round segments or polygons using Vertical Slab SR method.
 /// \ingroup PkgSnapRounding2Ref
 
 /*!

Snap_rounding_2/doc/Snap_rounding_2/Snap_rounding_2.txt

@@ -94,15 +94,15 @@ An arrangement of segments before subdividing the segments (a), after subdividin
 We evaluate the different methods on two tests:
 In the first test, the segment endpoints are chosen uniformly and independantly in the unit box.
 In the second test, we generate perturbed copies of a given segment. This experiment is repeated several times using different input segments.
-The two pixel sizes for hot pixel snap rounding are chosen such that the rounding shift is of the same order of magnitude as the rounding induced by using `double` or `float` coordinates.
+The two pixel sizes for Hot Pixel Snap Rounding are chosen such that the rounding shift is of the same order of magnitude as the rounding induced by using `double` or `float` coordinates.
 
 The first test is standard but typically exhibits few, if any, rounding issues.
 The second test is deliberately designed to be difficult, as it produces a large number of rounding issues when rounding is performed naively.
-In these settings, vertical slab snap rounding significantly outperforms hot pixel snap rounding and remains of the same order of magnitude than computing the intersections without snap.
+In these settings, vertical slab snap rounding significantly outperforms Hot Pixel Snap Rounding and remains of the same order of magnitude than computing the intersections without snap.
 The result of our test is summarized in the next table:
 
 <center>
-| Test Case | Computing intersection<br> (Unsafe rounding) | Vertical slab SR <br> (double) | Vertical Slab SR <br> (float)  | Hot pixel SR <br>(pixel size \f$10^{-15}\f$ ) | Hot pixel SR <br>(pixel size \f$10^{-7}\f$) |
+| Test Case | Computing intersection<br> (Unsafe rounding) | Vertical Slab SR <br> (double) | Vertical Slab SR <br> (float)  | Hot Pixel SR <br>(pixel size \f$10^{-15}\f$ ) | Hot Pixel SR <br>(pixel size \f$10^{-7}\f$) |
 |-----------|-------|-------|-------|-------|-------|
 | 500 Random Segments | 0.066s | 0.213s | 0.172s | 6.14s | 3.81s |
 | 1000 Random Segments | 0.241s | 0.928s | 0.769s | 52.1s | 53.5s |
@@ -120,22 +120,19 @@ vertices is \f$O(n^3)\f$, or \f$O(n^2)\f$ if the input segments are free of inte
 
 \section Snap_rounding_2API Snap Rounding API and Examples
 
-Both algorithms can be invoked through the \ref snap_rounding_2_fct "CGAL::snap_rounding_2()" function.
-\ref snap_rounding_2_fct "CGAL::snap_rounding_2()" take a range of input segments and, by default, produces a range of polylines, each polyline corresponding to an input segment.
+Both algorithms can be invoked through the \ref snap_rounding_2_fct "CGAL::snap_rounding_2()" function, which takes a range of input segments and, by default, produces a range of polylines, each polyline corresponding to an input segment.
 Consequently, duplicate segments may appear in the output, for instance when multiple input segments collapse. When the parameter `output_unique_segments` is set to `true`,
 the polylines are decomposed into individual segments (they are represented as polylines with two points), and duplicates are removed.
 An overload also supports as input and output polygon ranges.
-By default, the Vertical Slab Snap Rounding algorithm to double precision is used. The other method or other rounding schemes can be used depending on the traits class provided.
+By default, the Vertical Slab Snap Rounding algorithm to double precision is used. Other methods or other rounding schemes can be used depending on the traits class provided.
 Specific methods also exist: `CGAL::vertical_slab_snap_rounding_2()` and `CGAL::hot_pixel_snap_rounding_2`.
 
 \subsection Float_snap_rounding_Traits Snap Rounding Traits
-
-
 When using Hot Pixel SR, the traits class must be a model of `HotPixelSnapRoundingTraits_2`. The class `Hot_pixel_snap_rounding_traits_2` is such a model.
 
-When using Vertical Slab SR, the traits class must be a model of  `VerticalSlabSnapRoundingTraits_2`. By default,
-the traits class `Double_grid_snap_rounding_traits_2`, which rounds coordinates to double precision floating point,
-is used. The package also provides `Float_grid_snap_rounding_traits_2` and `Integer_grid_snap_rounding_traits_2`, which rounds coordinates to
+When using Vertical Slab SR, the traits class must be a model of `VerticalSlabSnapRoundingTraits_2`. By default,
+the traits class `CGAL::Double_grid_snap_rounding_traits_2`, which rounds coordinates to double precision floating point,
+is used. The package also provides `CGAL::Float_grid_snap_rounding_traits_2` and `CGAL::Integer_grid_snap_rounding_traits_2`, which rounds coordinates to
 single precision floating point and integers, respectively. Other traits classes can be used to round to different representations or rounding schemes as long as
 the rounding operation preserves the order of vertices along the \f$x\f$ and \f$y\f$ directions.
 See `VerticalSlabSnapRoundingTraits_2` for more details.
@@ -160,8 +157,6 @@ The package is supplied with a graphical demo program that opens a window,
 allows the user to edit segments dynamically, applies a selected
 snap-rounding procedures, and displays the result onto the same window
 (see `<CGAL_ROOT>/GraphicsView/demo/Snap_rounding_2/Snap_rounding_2.cpp`).
-
-
 \section Snap_rounding_history Implementation History
 
 Snap Rounding and Iterative Snap Rounding was introduced by Eli Packer in 2001.

Snap_rounding_2/include/CGAL/vertical_slab_snap_rounding_2.h

@@ -464,16 +464,14 @@ void vertical_slab_snap_rounding_2_polygon(const PolygonRange  &polygons,
     Polygon_2 P;
     std::size_t idx_start = polygon_indices[polygon_idx];
     std::size_t idx_end = polygon_indices[polygon_idx+1];
-    std::size_t last_insert;
+    std::size_t last_insert = 0;
     for(std::size_t pl_idx = idx_start; pl_idx != idx_end; ++pl_idx){
       auto &pl = polylines[pl_idx];
       // The first element is not add, it is identical to the last
 
-      bool go_forward;
-      if(pl_idx == idx_start)
-        go_forward = (pl.back() == polylines[pl_idx+1].front()) || (pl.back() == polylines[pl_idx+1].back());
-      else
-        go_forward = (last_insert == pl.front());
+      bool go_forward = (pl_idx == idx_start)
+                      ? (pl.back() == polylines[pl_idx+1].front()) || (pl.back() == polylines[pl_idx+1].back())
+                      : (last_insert == pl.front());
 
       // Add the element in forward direction
       if(go_forward){