diff --git a/GraphicsView/include/CGAL/Buffer_for_vao.h b/GraphicsView/include/CGAL/Buffer_for_vao.h
index beeb5907486..3fc91ec4f10 100644
--- a/GraphicsView/include/CGAL/Buffer_for_vao.h
+++ b/GraphicsView/include/CGAL/Buffer_for_vao.h
@@ -39,9 +39,6 @@
 
 namespace CGAL
 {
-  typedef CGAL::Exact_predicates_inexact_constructions_kernel Local_kernel;
-  typedef Local_kernel::Point_3  Local_point;
-  typedef Local_kernel::Vector_3 Local_vector;
 
 //------------------------------------------------------------------------------
 namespace internal
@@ -58,90 +55,77 @@ namespace internal
                n.z()+((p.x()-q.x())*(p.y()+q.y())));
     }
 
-  inline
-  Local_vector compute_normal_of_face(const std::vector<Local_point>& points)
+  template <class Point, class Vector>
+  Vector compute_normal_of_face(const std::vector<Point>& points)
   {
-    Local_vector normal(CGAL::NULL_VECTOR);
+    Vector normal(CGAL::NULL_VECTOR);
     unsigned int nb = 0;
     for (std::size_t i=0; i<points.size(); ++i)
     {
-      newell_single_step_3(points[i], points[(i+1)%points.size()], normal);
+      internal::newell_single_step_3(points[i], points[(i+1)%points.size()],
+                                     normal);
       ++nb;
     }
     
     assert(nb>0);
-    return (Local_kernel::Construct_scaled_vector_3()(normal, 1.0/nb));
+    return (typename Kernel_traits<Vector>::Kernel::Construct_scaled_vector_3()
+            (normal, 1.0/nb));
   }
 
   ////////////////////////////////////////////////////////////////
   // Structs to transform any CGAL point/vector into a Local_point/Local_vector
-  template<typename K>
+  template<typename K, typename Local_kernel>
   struct Geom_utils
   {
-    static Local_point get_local_point(const typename K::Point_2& p)
+    static typename Local_kernel::Point_3 get_local_point(const typename K::Point_2& p)
     {
       CGAL::Cartesian_converter<K, Local_kernel> converter;
       return Local_point(converter(p.x()), 0, converter(p.y()));
     }
-    static Local_point get_local_point(const typename K::Weighted_point_2& p)
+    static typename Local_kernel::Point_3 get_local_point(const typename K::Weighted_point_2& p)
     {
       typename K::Point_2 lp(p);
-      return Geom_utils<K>::get_local_point(lp);
+      return Geom_utils<K, Local_kernel>::get_local_point(lp);
     }
-    static Local_point get_local_point(const typename K::Point_3& p)
+    static typename Local_kernel::Point_3 get_local_point(const typename K::Point_3& p)
     {
       CGAL::Cartesian_converter<K, Local_kernel> converter;
       return converter(p);
     }
-    static Local_point get_local_point(const typename K::Weighted_point_3& p)
+    static typename Local_kernel::Point_3 get_local_point(const typename K::Weighted_point_3& p)
     {
       typename K::Point_3 lp(p);
-      return Geom_utils<K>::get_local_point(lp);
+      return Geom_utils<K, Local_kernel>::get_local_point(lp);
     }
-    static Local_vector get_local_vector(const typename K::Vector_2& v)
+    static typename Local_kernel::Vector_3 get_local_vector(const typename K::Vector_2& v)
     {
       CGAL::Cartesian_converter<K, Local_kernel> converter;
       return Local_vector(converter(v.x()), 0, converter(v.y()));
     }
-    static Local_vector get_local_vector(const typename K::Vector_3& v)
+    static typename Local_kernel::Vector_3 get_local_vector(const typename K::Vector_3& v)
     {
       CGAL::Cartesian_converter<K, Local_kernel> converter;
       return converter(v);
     }
   };
 
-  // Specialization for Local_kernel, because there is no need of convertion here.
-  template<>
-  struct Geom_utils<Local_kernel>
+  // Specialization when K==Local_kernel, because there is no need of convertion here.
+  template<typename Local_kernel>
+  struct Geom_utils<Local_kernel, Local_kernel>
   {
-    static Local_point get_local_point(const Local_kernel::Point_2& p)
-    { return Local_point(p.x(), 0, p.y()); }
-    static Local_point get_local_point(const Local_kernel::Weighted_point_2& p)
-    { return Local_point(p.point().x(), 0, p.point().y());}
-    static const Local_point & get_local_point(const Local_kernel::Point_3& p)
+    static typename Local_kernel::Point_3 get_local_point(const typename Local_kernel::Point_2& p)
+    { return typename Local_kernel::Point_3(p.x(), 0, p.y()); }
+    static typename Local_kernel::Point_3 get_local_point(const typename Local_kernel::Weighted_point_2& p)
+    { return typename Local_kernel::Point_3(p.point().x(), 0, p.point().y());}
+    static const typename Local_kernel::Point_3 & get_local_point(const typename Local_kernel::Point_3& p)
     { return p; }
-    static Local_point get_local_point(const Local_kernel::Weighted_point_3& p)
-    { return Local_point(p);}
-    static Local_vector get_local_vector(const Local_kernel::Vector_2& v)
-    { return Local_vector(v.x(), 0, v.y()); }
-    static const Local_vector& get_local_vector(const Local_kernel::Vector_3& v)
+    static typename Local_kernel::Point_3 get_local_point(const typename Local_kernel::Weighted_point_3& p)
+    { return typename Local_kernel::Point_3(p);}
+    static typename Local_kernel::Vector_3 get_local_vector(const typename Local_kernel::Vector_2& v)
+    { return typename Local_kernel::Vector_3(v.x(), 0, v.y()); }
+    static const typename Local_kernel::Vector_3& get_local_vector(const typename Local_kernel::Vector_3& v)
     { return v; }
-  };    
-
-  ////////////////////////////////////////////////////////////////
-  // Global function to simplify function calls.
-  template<typename KPoint>
-  Local_point get_local_point(const KPoint& p)
-  {
-    return Geom_utils<typename CGAL::Kernel_traits<KPoint>::Kernel>::
-      get_local_point(p);
-  }
-  template<typename KVector>
-  Local_vector get_local_vector(const KVector& v)
-  {
-    return Geom_utils<typename CGAL::Kernel_traits<KVector>::Kernel>::
-      get_local_vector(v);
-  }
+  };
 } // End namespace internal
 
 //------------------------------------------------------------------------------
@@ -149,6 +133,10 @@ template<typename BufferType=float, typename IndexType=std::size_t>
 class Buffer_for_vao
 {
 public:
+  typedef CGAL::Exact_predicates_inexact_constructions_kernel Local_kernel;
+  typedef Local_kernel::Point_3  Local_point;
+  typedef Local_kernel::Vector_3 Local_vector;
+
   Buffer_for_vao(std::vector<BufferType>* pos=nullptr,
                  std::vector<IndexType>* indices=nullptr,
                  CGAL::Bbox_3* bbox=nullptr,
@@ -220,7 +208,7 @@ public:
   {
     if (!has_position()) return (std::size_t)-1;
     
-    Local_point p=internal::get_local_point(kp);
+    Local_point p=get_local_point(kp);
     add_point_in_buffer(p, *m_pos_buffer);
 
     if (m_bb!=nullptr)
@@ -293,7 +281,7 @@ public:
   template<typename KNormal>
   void face_begin(const KNormal& kv)
   {
-    m_normal_of_face=internal::get_local_vector(kv);
+    m_normal_of_face=get_local_vector(kv);
     face_begin_internal(false, true);
   }
 
@@ -302,7 +290,7 @@ public:
   void face_begin(const CGAL::Color& c, const KNormal& kv)
   {
     m_color_of_face=c;
-    m_normal_of_face=internal::get_local_vector(kv);
+    m_normal_of_face=get_local_vector(kv);
     face_begin_internal(true, true);
   }
 
@@ -314,7 +302,7 @@ public:
   {
     if (!is_a_face_started()) return false;
 
-    Local_point p=internal::get_local_point(kp);
+    Local_point p=get_local_point(kp);
     if (m_points_of_face.empty() || m_points_of_face.back()!=p) // TODO test if the distance between prev point and kp is smaller than an epsilon (?? not sure ??)
     {
       m_points_of_face.push_back(p);
@@ -331,7 +319,7 @@ public:
   {
     if (add_point_in_face(kp))
     {
-      m_vertex_normals_for_face.push_back(internal::get_local_vector(p_normal));
+      m_vertex_normals_for_face.push_back(get_local_vector(p_normal));
       return true;
     }
     return false;
@@ -388,7 +376,8 @@ public:
     }
     
     Local_vector normal=(m_started_face_has_normal?m_normal_of_face:
-                         internal::compute_normal_of_face(m_points_of_face));
+                         internal::compute_normal_of_face
+                         <Local_point, Local_vector>(m_points_of_face));
 
     if (m_points_of_face.size()==3)
     { triangular_face_end_internal(normal); } // Triangle: no need to triangulate
@@ -411,7 +400,7 @@ public:
   template<typename KPoint>
   static void add_point_in_buffer(const KPoint& kp, std::vector<float>& buffer)
   {
-    Local_point p=internal::get_local_point(kp);
+    Local_point p=get_local_point(kp);
     buffer.push_back(p.x());
     buffer.push_back(p.y());
     buffer.push_back(p.z());
@@ -421,7 +410,7 @@ public:
   template<typename KVector>
   static void add_normal_in_buffer(const KVector& kv, std::vector<float>& buffer)
   {
-    Local_vector n=internal::get_local_vector(kv);
+    Local_vector n=get_local_vector(kv);
     buffer.push_back(n.x());
     buffer.push_back(n.y());
     buffer.push_back(n.z());
@@ -796,6 +785,21 @@ protected:
     { add_normal_in_buffer(kv, *m_gouraud_normal_buffer); }
   }
 
+protected:
+  // Shortcuts to simplify function calls.
+  template<typename KPoint>
+  static Local_point get_local_point(const KPoint& p)
+  {
+    return internal::Geom_utils<typename CGAL::Kernel_traits<KPoint>::Kernel, Local_kernel>::
+      get_local_point(p);
+  }
+  template<typename KVector>
+  static Local_vector get_local_vector(const KVector& v)
+  {
+    return internal::Geom_utils<typename CGAL::Kernel_traits<KVector>::Kernel, Local_kernel>::
+      get_local_vector(v);
+  }
+
 protected:
   // Types usefull for triangulation
   struct Vertex_info
diff --git a/GraphicsView/include/CGAL/Qt/Basic_viewer_qt.h b/GraphicsView/include/CGAL/Qt/Basic_viewer_qt.h
index 8b23594cd7c..29e615e26c1 100644
--- a/GraphicsView/include/CGAL/Qt/Basic_viewer_qt.h
+++ b/GraphicsView/include/CGAL/Qt/Basic_viewer_qt.h
@@ -446,6 +446,20 @@ public:
   }
 
 protected:
+  // Shortcuts to simplify function calls.
+  template<typename KPoint>
+  static Local_point get_local_point(const KPoint& p)
+  {
+    return internal::Geom_utils<typename CGAL::Kernel_traits<KPoint>::Kernel, Local_kernel>::
+      get_local_point(p);
+  }
+  template<typename KVector>
+  static Local_vector get_local_vector(const KVector& v)
+  {
+    return internal::Geom_utils<typename CGAL::Kernel_traits<KVector>::Kernel, Local_kernel>::
+      get_local_vector(v);
+  }
+
   void compile_shaders()
   {
     rendering_program_face.removeAllShaders();
diff --git a/Linear_cell_complex/include/CGAL/draw_linear_cell_complex.h b/Linear_cell_complex/include/CGAL/draw_linear_cell_complex.h
index 1b750f2dc0b..39dc2dce637 100644
--- a/Linear_cell_complex/include/CGAL/draw_linear_cell_complex.h
+++ b/Linear_cell_complex/include/CGAL/draw_linear_cell_complex.h
@@ -127,29 +127,30 @@ struct DefaultDrawingFunctorLCC
   }
 };
 
-template<class LCC, class Kernel, int dim=LCC::ambient_dimension>
+template<class LCC, class Local_kernel, int dim=LCC::ambient_dimension>
 struct LCC_geom_utils;
 
-template<class LCC, class Kernel>
-struct LCC_geom_utils<LCC, Kernel, 3>
+template<class LCC, class Local_kernel>
+struct LCC_geom_utils<LCC, Local_kernel, 3>
 {
-  static typename Kernel::Vector_3
+  static typename Local_kernel::Vector_3
   get_vertex_normal(const LCC& lcc, typename LCC::Dart_const_handle dh)
   {
-    typename Kernel::Vector_3 n = internal::Geom_utils<typename LCC::Traits>::
+    typename Local_kernel::Vector_3 n = internal::Geom_utils
+      <typename LCC::Traits, Local_kernel>::
       get_local_vector(CGAL::compute_normal_of_cell_0<LCC>(lcc,dh));
     n = n/(CGAL::sqrt(n*n));
     return n;
   }
 };
 
-template<class LCC, class Kernel>
-struct LCC_geom_utils<LCC, Kernel, 2>
+template<class LCC, class Local_kernel>
+struct LCC_geom_utils<LCC, Local_kernel, 2>
 {
-  static typename Kernel::Vector_3
+  static typename Local_kernel::Vector_3
   get_vertex_normal(const LCC&, typename LCC::Dart_const_handle)
   {
-    typename Kernel::Vector_3 n=CGAL::NULL_VECTOR;
+    typename Local_kernel::Vector_3 n=CGAL::NULL_VECTOR;
     return n;
   }
 };
diff --git a/Polyhedron/include/CGAL/draw_polyhedron.h b/Polyhedron/include/CGAL/draw_polyhedron.h
index 66cf3a7f3bd..1e005623df8 100644
--- a/Polyhedron/include/CGAL/draw_polyhedron.h
+++ b/Polyhedron/include/CGAL/draw_polyhedron.h
@@ -157,8 +157,8 @@ protected:
     do
     {
       internal::newell_single_step_3
-        (internal::Geom_utils<Kernel>::get_local_point(he->vertex()->point()),
-         internal::Geom_utils<Kernel>::get_local_point(he->next()->vertex()->point()),
+        (this->get_local_point(he->vertex()->point()),
+         this->get_local_point(he->next()->vertex()->point()),
          normal);
       ++nb;
       he=he->next();
diff --git a/Surface_mesh/include/CGAL/draw_surface_mesh.h b/Surface_mesh/include/CGAL/draw_surface_mesh.h
index bfd76350505..029aec8b769 100644
--- a/Surface_mesh/include/CGAL/draw_surface_mesh.h
+++ b/Surface_mesh/include/CGAL/draw_surface_mesh.h
@@ -165,8 +165,8 @@ protected:
     do
     {
       internal::newell_single_step_3
-        (internal::Geom_utils<Kernel>::get_local_point(sm.point(sm.source(he))),
-         internal::Geom_utils<Kernel>::get_local_point(sm.point(sm.target(he))), normal);
+        (this->get_local_point(sm.point(sm.source(he))),
+         this->get_local_point(sm.point(sm.target(he))), normal);
       ++nb;
       he=sm.next(he);
     }