renaming helper struct to Vector_matching_point

updates following review

Author: soesau

BGL/include/CGAL/boost/graph/named_params_helper.h

@@ -359,17 +359,17 @@ struct GetPolygonSoupGeomTraits
 
 namespace internal {
 template <class Point, int d = CGAL::Ambient_dimension<Point>::value>
-struct Vector {
+struct Vector_matching_point {
   typedef typename Kernel_traits<Point>::Kernel::Vector_d type;
 };
 
 template <class Point>
-struct Vector<Point, 2> {
+struct Vector_matching_point<Point, 2> {
   typedef typename Kernel_traits<Point>::Kernel::Vector_2 type;
 };
 
 template <class Point>
-struct Vector<Point, 3> {
+struct Vector_matching_point<Point, 3> {
   typedef typename Kernel_traits<Point>::Kernel::Vector_3 type;
 };
 }
@@ -397,7 +397,7 @@ struct Point_set_processing_3_np_helper
 
   typedef typename Geom_traits::FT FT; // public
 
-  typedef Constant_property_map<Value_type, typename internal::Vector<Point>::type> DummyNormalMap;
+  typedef Constant_property_map<Value_type, typename internal::Vector_matching_point<Point>::type> DummyNormalMap;
   typedef typename Default::Get<NormalMap, DummyNormalMap>::type DefaultNMap;
 
   typedef typename internal_np::Lookup_named_param_def<

Point_set_processing_3/doc/Point_set_processing_3/Point_set_processing_3.txt

@@ -676,7 +676,7 @@ the Weighted Locally Optimal Projection (WLOP) algorithm \cgalCite{wlop-2009}.
 
 Function `poisson_eliminate()` is a greedy down sampling method that generates
 a subset of the input points with Poisson disk property. This is an implementation of the
-Sample Elimination for Generating Poisson Disk Sample Sets \cgalCite{cgal:y-sefpdss}.
+<em>Sample Elimination for Generating Poisson Disk Sample Sets</em> method \cgalCite{cgal:y-sefpdss}.
 
 
 \subsection Point_set_processing_3Example_grid_simplification Grid Simplification Example
@@ -769,11 +769,11 @@ The Poisson sample elimination has the following parameters:
 double(*func)(const Point &p, const Point &n, double squared_distance, double r_max)
 \endcode
 The default weight is \f$\left(1 - \frac{d_{p,n}}{2r_{max}}\right)^8\f$ with \f$d_{p,n}\f$ being the distance between the point p and its neighbor n.
-- \f$r_{max}\f$: The \f$r_{max}\f$ parameter specifies the radius of the neighborhood, i.e., the neighboring points that are used to calculate the weight of a point. \f$r_{max}\f$ has to be provided if a custom *weight_function* is used. Only points within a distance of \f$r_{max}\f$ are used to calculate the weight of a point. A large value can thus cause a large running time. The default is calculated based in the bounding volume \f$V\f$ of the input points, the *dimensions* parameter and the number of input points \f$N\f$:
+- \f$r_{max}\f$: The \f$r_{max}\f$ parameter specifies the radius of the neighborhood, i.e., the neighboring points that are used to calculate the weight of a point. \f$r_{max}\f$ has to be provided if a custom *weight_function* is used. Only points within a distance of \f$r_{max}\f$ are used to calculate the weight of a point. A large value can thus cause a large running time. The default is calculated based in the bounding volume \f$V\f$ of the input points, the *dimension* parameter and the number of input points \f$N\f$:
 
-\f$dimensions = 2:\qquad\f$ \f$r_{max} = \sqrt{\frac{V}{2\sqrt{3}N}}\f$
+\f$\mathrm{dimension} = 2:\qquad\f$ \f$r_{max} = \sqrt{\frac{V}{2\sqrt{3}N}}\f$
 
-\f$dimensions = 3:\qquad\f$ \f$r_{max} = \sqrt{\frac{V}{4\sqrt{2}N}}\f$
+\f$\mathrm{dimension} = 3:\qquad\f$ \f$r_{max} = \sqrt{\frac{V}{4\sqrt{2}N}}\f$
 
 - *progressive*: The output points of the function can be reordered to be progressive. A progressive ordering will increase the running time by a factor of at most 2 as the function is internally applied several times on increasingly smaller subsets. The default value is false.
 

Point_set_processing_3/include/CGAL/poisson_eliminate.h

@@ -30,27 +30,27 @@ namespace CGAL {
 
 namespace internal {
 
-double get_maximum_radius(std::size_t dimensions, std::size_t sample_size, double domain_size) {
+double get_maximum_radius(std::size_t dimension, std::size_t sample_size, double domain_size) {
   double sampleArea = domain_size / double(sample_size);
   double r_max;
-  switch (dimensions) {
+  switch (dimension) {
   case 2: r_max = CGAL::sqrt(sampleArea / (2.0 * CGAL::sqrt(3.0))); break;
   case 3: r_max = std::pow(sampleArea / (4.0 * CGAL::sqrt(2.0)), 1.0 / 3.0); break;
   default:
     double c;
     std::size_t d_start;
-    if ((dimensions & 1)) {
+    if ((dimension & 1)) {
       c = 2.0;
       d_start = 3;
     }
     else {
       c = CGAL_PI;
       d_start = 4;
     }
-    for (std::size_t d = d_start; d <= dimensions; d += 2)
+    for (std::size_t d = d_start; d <= dimension; d += 2)
       c *= 2.0 * CGAL_PI / double(d);
 
-    r_max = std::pow(sampleArea / c, 1.0 / double(dimensions));
+    r_max = std::pow(sampleArea / c, 1.0 / double(dimension));
     break;
   }
   return r_max;