diff --git a/Generator/include/CGAL/point_generators_2.h b/Generator/include/CGAL/point_generators_2.h
index 52fc3be45fe..6738bb89e2f 100644
--- a/Generator/include/CGAL/point_generators_2.h
+++ b/Generator/include/CGAL/point_generators_2.h
@@ -546,15 +546,15 @@ void Random_points_in_triangle_2<P, Creator>::generate_point() {
 							T(to_double(_p.y())*b1+to_double(_q.y())*b2+to_double(_r.y())*b3));
 }
 
-namespace internal{
+namespace internal {
 //Functor returning Triangle_2 from Triangulation_2 Faces
 template <class T>
 class Triangle_from_face_2
 {
   typedef typename T::Triangle Triangle;
 public:
- typedef Triangle result_type;
-  Triangle_from_face_2(){}
+  typedef Triangle result_type;
+  Triangle_from_face_2() {}
 
   Triangle operator()(typename T::Face_handle face)const {
     return Triangle(face->vertex(0)->point(), face->vertex(1)->point(), face->vertex(2)->point());
@@ -563,53 +563,54 @@ public:
 }//end namespace internal
 template <class P, class T>
 class Random_points_in_triangle_mesh_2 : public Generic_random_point_generator<
-   typename T::Face_handle ,
-   internal::Triangle_from_face_2<T>,
-   Random_points_in_triangle_2<P> , P> {
+  typename T::Face_handle ,
+  internal::Triangle_from_face_2<T>,
+    Random_points_in_triangle_2<P> , P> {
 public:
- typedef Generic_random_point_generator<
- typename T::Face_handle,
- internal::Triangle_from_face_2<T>,
- Random_points_in_triangle_2<P> , P>                                 Base;
- typedef typename T::Face_handle                                     Id;
- typedef P result_type;
- typedef Random_points_in_triangle_mesh_2<P, T>                      This;
+  typedef Generic_random_point_generator<typename T::Face_handle,
+                                         internal::Triangle_from_face_2<T>,
+                                         Random_points_in_triangle_2<P>,
+                                         P>                           Base;
+  typedef typename T::Face_handle                                     Id;
+  typedef P result_type;
+  typedef Random_points_in_triangle_mesh_2<P, T>                      This;
 
 
- Random_points_in_triangle_mesh_2(  T& triangulation,Random& rnd = default_random)
-  : Base( CGAL::make_prevent_deref_range(triangulation.finite_faces_begin(),
-                                         triangulation.finite_faces_end()),
-          internal::Triangle_from_face_2<T>(),
-          typename Kernel_traits<P>::Kernel::Compute_area_2(),
-          rnd )
- {
- }
- This& operator++() {
-  Base::generate_point();
-  return *this;
- }
- This operator++(int) {
-  This tmp = *this;
-  ++(*this);
-  return tmp;
- }
+  Random_points_in_triangle_mesh_2(  T& triangulation,Random& rnd = default_random)
+    : Base( CGAL::make_prevent_deref_range(triangulation.finite_faces_begin(),
+                                           triangulation.finite_faces_end()),
+            internal::Triangle_from_face_2<T>(),
+            typename Kernel_traits<P>::Kernel::Compute_area_2(),
+            rnd )
+  {
+  }
+  This& operator++() {
+    Base::generate_point();
+    return *this;
+  }
+  This operator++(int) {
+    This tmp = *this;
+    ++(*this);
+    return tmp;
+  }
 };
 
 namespace internal
 {
+
 template<class T>
 class Deref
 {
 public:
- typedef typename std::iterator_traits<T>::value_type result_type;
-  typename std::iterator_traits<T>::value_type operator()(T triangle)const
+  typedef const T& result_type;
+  const T& operator()(const T* triangle) const
   {
     return *triangle;
   }
 };
 
 template<class A>
-struct Address_of{
+struct Address_of {
   typedef const A* result_type;
   const A* operator()(const A& a) const
   {
@@ -619,40 +620,40 @@ struct Address_of{
 
 }//namesapce internal
 
-template <class Point_2>
-class Random_points_in_triangles_2 : public Generic_random_point_generator<
-   const typename Kernel_traits<Point_2>::Kernel::Triangle_2*,
-   internal::Deref<const typename Kernel_traits<Point_2>::Kernel::Triangle_2*>,
-   Random_points_in_triangle_2<Point_2> ,
-   Point_2> {
-public:
- typedef typename Kernel_traits<Point_2>::Kernel::Triangle_2       Triangle_2;
- typedef Generic_random_point_generator<
- const typename Kernel_traits<Point_2>::Kernel::Triangle_2*,
- internal::Deref<const Triangle_2*>,
- Random_points_in_triangle_2<Point_2> ,Point_2>                    Base;
- typedef const Triangle_2*                                         Id;
- typedef Point_2                                                   result_type;
- typedef Random_points_in_triangles_2<Point_2>                     This;
+template <class Point_2,
+          class Triangle_2=typename Kernel_traits<Point_2>::Kernel::Triangle_2>
+struct Random_points_in_triangles_2
+  : public Generic_random_point_generator<const Triangle_2*,
+                                          internal::Deref<Triangle_2>,
+                                          Random_points_in_triangle_2<Point_2>,
+                                          Point_2>
+{
+  typedef Generic_random_point_generator<const Triangle_2*,
+                                         internal::Deref<Triangle_2>,
+                                         Random_points_in_triangle_2<Point_2>,
+                                         Point_2>                   Base;
+  typedef const Triangle_2*                                         Id;
+  typedef Point_2                                                   result_type;
+  typedef Random_points_in_triangles_2<Point_2>                     This;
 
- template<typename TriangleRange>
- Random_points_in_triangles_2( const TriangleRange& triangles, Random& rnd = default_random)
-  : Base(make_range( boost::make_transform_iterator(triangles.begin(), internal::Address_of<Triangle_2>()),
-                     boost::make_transform_iterator(triangles.end(), internal::Address_of<Triangle_2>()) ),
-         internal::Deref<const Triangle_2*>(),
-         typename Kernel_traits<Point_2>::Kernel::Compute_area_2()
-         ,rnd )
- {
- }
- This& operator++() {
-  Base::generate_point();
-  return *this;
- }
- This operator++(int) {
-  This tmp = *this;
-  ++(*this);
-  return tmp;
- }
+  template<typename TriangleRange>
+  Random_points_in_triangles_2( const TriangleRange& triangles, Random& rnd = default_random)
+    : Base(make_range( boost::make_transform_iterator(triangles.begin(), internal::Address_of<Triangle_2>()),
+                       boost::make_transform_iterator(triangles.end(), internal::Address_of<Triangle_2>()) ),
+           internal::Deref<Triangle_2>(),
+           typename Kernel_traits<Point_2>::Kernel::Compute_area_2(),
+           rnd )
+  {
+  }
+  This& operator++() {
+    Base::generate_point();
+    return *this;
+  }
+  This operator++(int) {
+    This tmp = *this;
+    ++(*this);
+    return tmp;
+  }
 };
 
 } //namespace CGAL
diff --git a/Generator/include/CGAL/point_generators_3.h b/Generator/include/CGAL/point_generators_3.h
index 2eb6e1e6887..bbc9f14575f 100644
--- a/Generator/include/CGAL/point_generators_3.h
+++ b/Generator/include/CGAL/point_generators_3.h
@@ -308,49 +308,50 @@ void Random_points_in_tetrahedron_3<P, Creator>::generate_point() {
 
 template <class TriangleMesh, class VertexPointMap = typename boost::property_map<TriangleMesh,
                                                                                   CGAL::vertex_point_t>::type>
-class Random_points_on_triangle_mesh_3 : public Generic_random_point_generator<
-   typename boost::graph_traits <TriangleMesh>::face_descriptor ,
-   CGAL::Property_map_to_unary_function<CGAL::Triangle_from_face_descriptor_map<
-                                        TriangleMesh, VertexPointMap > >,
-   Random_points_in_triangle_3<typename boost::property_traits<VertexPointMap>::value_type> ,
-  typename boost::property_traits<VertexPointMap>::value_type> {
-public:
- typedef typename boost::property_traits<VertexPointMap>::value_type  P;
- typedef Generic_random_point_generator<
- typename boost::graph_traits <TriangleMesh>::face_descriptor ,
- CGAL::Property_map_to_unary_function<typename CGAL::Triangle_from_face_descriptor_map<
-  TriangleMesh,typename boost::property_map<TriangleMesh,
-  CGAL::vertex_point_t>::type> >,
- Random_points_in_triangle_3<P> , P>                                  Base;
- typedef typename CGAL::Triangle_from_face_descriptor_map<
- TriangleMesh,VertexPointMap>                                         Pmap;
- typedef typename CGAL::Triangle_from_face_descriptor_map<
-     TriangleMesh,VertexPointMap>                                     Object_from_id_map;
- typedef Random_points_in_triangle_3<P>                               Generator_on_object;
- typedef typename boost::graph_traits<TriangleMesh>::face_descriptor  Id;
- typedef P result_type;
- typedef Random_points_on_triangle_mesh_3< TriangleMesh>              This;
+struct Random_points_on_triangle_mesh_3
+  : public Generic_random_point_generator<
+             typename boost::graph_traits <TriangleMesh>::face_descriptor ,
+             CGAL::Property_map_to_unary_function<CGAL::Triangle_from_face_descriptor_map<
+                                                    TriangleMesh, VertexPointMap > >,
+             Random_points_in_triangle_3<typename boost::property_traits<VertexPointMap>::value_type>,
+             typename boost::property_traits<VertexPointMap>::value_type>
+{
+  typedef typename boost::property_traits<VertexPointMap>::value_type  P;
+  typedef Generic_random_point_generator<
+            typename boost::graph_traits <TriangleMesh>::face_descriptor ,
+            CGAL::Property_map_to_unary_function<typename CGAL::Triangle_from_face_descriptor_map<
+            TriangleMesh,typename boost::property_map<TriangleMesh,
+            CGAL::vertex_point_t>::type> >,
+            Random_points_in_triangle_3<P> , P>                        Base;
+  typedef typename CGAL::Triangle_from_face_descriptor_map<
+                     TriangleMesh,VertexPointMap>                      Pmap;
+  typedef typename CGAL::Triangle_from_face_descriptor_map<
+                     TriangleMesh,VertexPointMap>                      Object_from_id_map;
+  typedef Random_points_in_triangle_3<P>                               Generator_on_object;
+  typedef typename boost::graph_traits<TriangleMesh>::face_descriptor  Id;
+  typedef P result_type;
+  typedef Random_points_on_triangle_mesh_3< TriangleMesh>              This;
 
 
- Random_points_on_triangle_mesh_3(  TriangleMesh& mesh,Random& rnd = default_random)
-  : Base( faces(mesh),
-          CGAL::Property_map_to_unary_function<Pmap>(&mesh),
-          typename Kernel_traits<P>::Kernel::Compute_area_3(),
-          rnd )
- {
- }
- This& operator++() {
-  Base::generate_point();
-  return *this;
- }
- This operator++(int) {
-  This tmp = *this;
-  ++(*this);
-  return tmp;
- }
+  Random_points_on_triangle_mesh_3(  TriangleMesh& mesh,Random& rnd = default_random)
+    : Base( faces(mesh),
+            CGAL::Property_map_to_unary_function<Pmap>(&mesh),
+            typename Kernel_traits<P>::Kernel::Compute_area_3(),
+            rnd )
+  {
+  }
+  This& operator++() {
+    Base::generate_point();
+    return *this;
+  }
+  This operator++(int) {
+    This tmp = *this;
+    ++(*this);
+    return tmp;
+  }
   double mesh_area() const
   {
-    this->sum_of_weights();
+    return this->sum_of_weights();
   }
 };
 
@@ -364,17 +365,17 @@ class Triangle_from_face_C3t3
   typedef typename T::Point                              Point;
   typedef std::pair<typename T::Cell_handle, int> Face;
 public:
- typedef Triangle result_type;
+  typedef Triangle result_type;
 
   Triangle_from_face_C3t3()
   {}
   Triangle operator()(Face face)const
   {
-   typename T::Cell_handle cell = face.first;
-   int index = face.second;
-   const Point& pa = cell->vertex((index+1)&3)->point();
-   const Point& pb = cell->vertex((index+2)&3)->point();
-   const Point& pc = cell->vertex((index+3)&3)->point();
+    typename T::Cell_handle cell = face.first;
+    int index = face.second;
+    const Point& pa = cell->vertex((index+1)&3)->point();
+    const Point& pb = cell->vertex((index+2)&3)->point();
+    const Point& pc = cell->vertex((index+3)&3)->point();
     return Triangle(pa, pb, pc);
   }
 };
@@ -386,123 +387,130 @@ class Tetrahedron_from_cell_C3t3
   typedef typename T::Point                                    Point;
   typedef typename Kernel_traits<Point>::Kernel::Tetrahedron_3 Tetrahedron;
 public:
- typedef Tetrahedron result_type;
+  typedef Tetrahedron result_type;
 
   Tetrahedron_from_cell_C3t3()
   {}
   Tetrahedron operator()(Cell cell)const
   {
-   Point p0 = cell->vertex(0)->point();
-   Point p1 = cell->vertex(1)->point();
-   Point p2 = cell->vertex(2)->point();
-   Point p3 = cell->vertex(3)->point();
+    Point p0 = cell->vertex(0)->point();
+    Point p1 = cell->vertex(1)->point();
+    Point p2 = cell->vertex(2)->point();
+    Point p3 = cell->vertex(3)->point();
     return Tetrahedron(p0,p1,p2,p3);
   }
 };
 }//end namespace internal
 
 template <class C3t3>
-class Random_points_on_tetrahedral_mesh_boundary : public Generic_random_point_generator<
-   std::pair<typename C3t3::Triangulation::Cell_handle, int>,
-   internal::Triangle_from_face_C3t3<typename C3t3::Triangulation>,
-   Random_points_in_triangle_3<typename C3t3::Point> , typename C3t3::Point> {
-public:
- typedef Generic_random_point_generator<
- std::pair<typename C3t3::Triangulation::Cell_handle, int>,
- internal::Triangle_from_face_C3t3<typename C3t3::Triangulation>,
- Random_points_in_triangle_3<typename C3t3::Point> , typename C3t3::Point> Base;
- typedef std::pair<typename C3t3::Triangulation::Cell_handle, int>  Id;
- typedef typename C3t3::Point                                       result_type;
- typedef Random_points_on_tetrahedral_mesh_boundary<C3t3>           This;
+struct Random_points_on_tetrahedral_mesh_boundary
+  : public Generic_random_point_generator<
+             std::pair<typename C3t3::Triangulation::Cell_handle, int>,
+             internal::Triangle_from_face_C3t3<typename C3t3::Triangulation>,
+             Random_points_in_triangle_3<typename C3t3::Point>,
+             typename C3t3::Point>
+{
+  typedef Generic_random_point_generator<
+            std::pair<typename C3t3::Triangulation::Cell_handle, int>,
+            internal::Triangle_from_face_C3t3<typename C3t3::Triangulation>,
+            Random_points_in_triangle_3<typename C3t3::Point>,
+            typename C3t3::Point>                                    Base;
+  typedef std::pair<typename C3t3::Triangulation::Cell_handle, int>  Id;
+  typedef typename C3t3::Point                                       result_type;
+  typedef Random_points_on_tetrahedral_mesh_boundary<C3t3>           This;
 
 
- Random_points_on_tetrahedral_mesh_boundary(  C3t3& c3t3,Random& rnd = default_random)
-  : Base( make_range( c3t3.facets_in_complex_begin(),
-                      c3t3.facets_in_complex_end()),
-          internal::Triangle_from_face_C3t3<typename C3t3::Triangulation>(),
-          typename Kernel_traits<typename C3t3::Point>::Kernel::Compute_area_3(),
-          rnd )
- {
- }
- This& operator++() {
-  Base::generate_point();
-  return *this;
- }
- This operator++(int) {
-  This tmp = *this;
-  ++(*this);
-  return tmp;
- }
+  Random_points_on_tetrahedral_mesh_boundary(  C3t3& c3t3,Random& rnd = default_random)
+    : Base( make_range( c3t3.facets_in_complex_begin(),
+                        c3t3.facets_in_complex_end()),
+            internal::Triangle_from_face_C3t3<typename C3t3::Triangulation>(),
+            typename Kernel_traits<typename C3t3::Point>::Kernel::Compute_area_3(),
+            rnd )
+  {
+  }
+  This& operator++() {
+    Base::generate_point();
+    return *this;
+  }
+  This operator++(int) {
+    This tmp = *this;
+    ++(*this);
+    return tmp;
+  }
 };
 
 template <class C3t3>
-class Random_points_in_tetrahedral_mesh_3 : public Generic_random_point_generator<
-   typename C3t3::Triangulation::Cell_handle,
-   internal::Tetrahedron_from_cell_C3t3<typename C3t3::Triangulation>,
-   Random_points_in_tetrahedron_3<typename C3t3::Point> , typename C3t3::Point> {
-public:
- typedef Generic_random_point_generator<
- typename C3t3::Triangulation::Cell_handle,
- internal::Tetrahedron_from_cell_C3t3<typename C3t3::Triangulation>,
- Random_points_in_tetrahedron_3<typename C3t3::Point> , typename C3t3::Point> Base;
- typedef typename C3t3::Triangulation::Cell_handle                            Id;
- typedef typename C3t3::Point                                                 result_type;
- typedef Random_points_in_tetrahedral_mesh_3<C3t3>                            This;
+struct Random_points_in_tetrahedral_mesh_3
+  : public Generic_random_point_generator<
+             typename C3t3::Triangulation::Cell_handle,
+             internal::Tetrahedron_from_cell_C3t3<typename C3t3::Triangulation>,
+             Random_points_in_tetrahedron_3<typename C3t3::Point>,
+             typename C3t3::Point>
+{
+  typedef Generic_random_point_generator<
+            typename C3t3::Triangulation::Cell_handle,
+            internal::Tetrahedron_from_cell_C3t3<typename C3t3::Triangulation>,
+            Random_points_in_tetrahedron_3<typename C3t3::Point>,
+            typename C3t3::Point>                                              Base;
+  typedef typename C3t3::Triangulation::Cell_handle                            Id;
+  typedef typename C3t3::Point                                                 result_type;
+  typedef Random_points_in_tetrahedral_mesh_3<C3t3>                            This;
 
 
- Random_points_in_tetrahedral_mesh_3(  C3t3& c3t3,Random& rnd = default_random)
-  : Base( CGAL::make_prevent_deref_range(c3t3.cells_in_complex_begin(),
-                      c3t3.cells_in_complex_end()),
-          internal::Tetrahedron_from_cell_C3t3<typename C3t3::Triangulation>(),
-          typename Kernel_traits<typename C3t3::Point>::Kernel::Compute_volume_3(),
-          rnd )
- {
- }
- This& operator++() {
-  Base::generate_point();
-  return *this;
- }
- This operator++(int) {
-  This tmp = *this;
-  ++(*this);
-  return tmp;
- }
+  Random_points_in_tetrahedral_mesh_3(  C3t3& c3t3,Random& rnd = default_random)
+    : Base( CGAL::make_prevent_deref_range(c3t3.cells_in_complex_begin(),
+                                           c3t3.cells_in_complex_end()),
+            internal::Tetrahedron_from_cell_C3t3<typename C3t3::Triangulation>(),
+            typename Kernel_traits<typename C3t3::Point>::Kernel::Compute_volume_3(),
+            rnd )
+  {
+  }
+  This& operator++() {
+    Base::generate_point();
+    return *this;
+  }
+  This operator++(int) {
+    This tmp = *this;
+    ++(*this);
+    return tmp;
+  }
 };
 
 
-template <class Point_3>
-class Random_points_in_triangles_3 : public Generic_random_point_generator<
-   const typename Kernel_traits<Point_3>::Kernel::Triangle_3*,
-   internal::Deref<const typename Kernel_traits<Point_3>::Kernel::Triangle_3*>,
-   Random_points_in_triangle_3<Point_3> ,Point_3> {
-public:
- typedef typename Kernel_traits<Point_3>::Kernel::Triangle_3       Triangle_3;
- typedef Generic_random_point_generator<
- const typename Kernel_traits<Point_3>::Kernel::Triangle_3*,
- internal::Deref<const Triangle_3*>,
- Random_points_in_triangle_3<Point_3> ,Point_3>                    Base;
- typedef const Triangle_3*                                         Id;
- typedef Point_3                                                   result_type;
- typedef Random_points_in_triangles_3<Point_3>                     This;
+template <class Point_3,
+         class Triangle_3=typename Kernel_traits<Point_3>::Kernel::Triangle_3>
+struct Random_points_in_triangles_3
+    : public Generic_random_point_generator<const Triangle_3*,
+                                            internal::Deref<Triangle_3>,
+                                            Random_points_in_triangle_3<Point_3>,
+                                            Point_3>
+{
+  typedef Generic_random_point_generator<const Triangle_3*,
+                                         internal::Deref<Triangle_3>,
+                                         Random_points_in_triangle_3<Point_3>,
+                                         Point_3>            Base;
+  typedef const Triangle_3*                                         Id;
+  typedef Point_3                                                   result_type;
+  typedef Random_points_in_triangles_3<Point_3>                     This;
 
- template<typename TriangleRange>
- Random_points_in_triangles_3( const TriangleRange& triangles, Random& rnd = default_random)
-  : Base(make_range( boost::make_transform_iterator(triangles.begin(), internal::Address_of<Triangle_3>()),
-                     boost::make_transform_iterator(triangles.end(), internal::Address_of<Triangle_3>()) ),
-         internal::Deref<const Triangle_3*>(),
-         typename Kernel_traits<Point_3>::Kernel::Compute_area_3()
-         ,rnd )
- {
- }
- This& operator++() {
-  Base::generate_point();
-  return *this;
- }
- This operator++(int) {
-  This tmp = *this;
-  ++(*this);
-  return tmp;
- }
+  template<typename TriangleRange>
+  Random_points_in_triangles_3( const TriangleRange& triangles, Random& rnd = default_random)
+    : Base(make_range( boost::make_transform_iterator(triangles.begin(), internal::Address_of<Triangle_3>()),
+                       boost::make_transform_iterator(triangles.end(), internal::Address_of<Triangle_3>()) ),
+           internal::Deref<Triangle_3>(),
+           typename Kernel_traits<Point_3>::Kernel::Compute_area_3()
+           ,rnd )
+  {
+  }
+  This& operator++() {
+    Base::generate_point();
+    return *this;
+  }
+  This operator++(int) {
+    This tmp = *this;
+    ++(*this);
+    return tmp;
+  }
 };
 
 } //namespace CGAL