Fix functor usage in Distance_23

+ various code improvements along the way

Author: MaelRL

Distance_2/include/CGAL/Distance_2/Line_2_Line_2.h

@@ -20,7 +20,6 @@
 #define CGAL_DISTANCE_2_LINE_2_LINE_2_H
 
 #include <CGAL/Distance_2/internal/squared_distance_utils_2.h>
-#include <CGAL/Distance_2/Point_2_Line_2.h>
 
 #include <CGAL/Kernel/global_functions.h>
 #include <CGAL/Line_2.h>
@@ -35,8 +34,11 @@ squared_distance(const typename K::Line_2& line1,
                  const K& k)
 {
   typedef typename K::FT FT;
+
+  typename K::Compute_squared_distance_2 sq_dist = k.compute_squared_distance_2_object();
+
   if(internal::parallel(line1, line2, k))
-    return internal::squared_distance(line1.point(), line2, k);
+    return sq_dist(line1.point(), line2);
   else
     return FT(0);
 }
@@ -48,7 +50,7 @@ inline typename K::FT
 squared_distance(const Line_2<K>& line1,
                  const Line_2<K>& line2)
 {
-  return internal::squared_distance(line1, line2, K());
+  return K().compute_squared_distance_2_object()(line1, line2);
 }
 
 } // namespace CGAL

Distance_2/include/CGAL/Distance_2/Line_2_Triangle_2.h

@@ -20,7 +20,6 @@
 #define CGAL_DISTANCE_2_LINE_2_TRIANGLE_2_H
 
 #include <CGAL/Distance_2/internal/squared_distance_utils_2.h>
-#include <CGAL/Distance_2/Point_2_Line_2.h>
 
 #include <CGAL/enum.h>
 
@@ -38,17 +37,19 @@ squared_distance(const typename K::Line_2& line,
 {
   typedef typename K::FT FT;
 
-  Oriented_side side0 = line.oriented_side(triangle.vertex(0));
+  typename K::Compute_squared_distance_2 sq_dist = k.compute_squared_distance_2_object();
+
+  const Oriented_side side0 = line.oriented_side(triangle.vertex(0));
   if(line.oriented_side(triangle.vertex(1)) != side0)
     return FT(0);
 
   if(line.oriented_side(triangle.vertex(2)) != side0)
     return FT(0);
 
-  FT mindist = internal::squared_distance(triangle.vertex(0), line, k);
+  FT mindist = sq_dist(triangle.vertex(0), line);
   for(int i=1; i<3; ++i)
   {
-    FT dist = internal::squared_distance(triangle.vertex(i), line, k);
+    FT dist = sq_dist(triangle.vertex(i), line);
     if(dist < mindist)
       mindist = dist;
   }
@@ -72,15 +73,15 @@ inline typename K::FT
 squared_distance(const Line_2<K>& line,
                  const Triangle_2<K>& triangle)
 {
-  return internal::squared_distance(line, triangle, K());
+  return K().compute_squared_distance_2_object()(line, triangle);
 }
 
 template <class K>
 inline typename K::FT
 squared_distance(const Triangle_2<K>& triangle,
                  const Line_2<K>& line)
 {
-  return internal::squared_distance(line, triangle, K());
+  return K().compute_squared_distance_2_object()(triangle, line);
 }
 
 } // namespace CGAL

Distance_2/include/CGAL/Distance_2/Point_2_Line_2.h

@@ -92,15 +92,15 @@ inline typename K::FT
 squared_distance(const Point_2<K>& pt,
                  const Line_2<K>& line)
 {
-  return internal::squared_distance(pt, line, K());
+  return K().compute_squared_distance_2_object()(pt, line);
 }
 
 template <class K>
 inline typename K::FT
 squared_distance(const Line_2<K>& line,
                  const Point_2<K>& pt)
 {
-  return internal::squared_distance(pt, line, K());
+  return K().compute_squared_distance_2_object()(line, pt);
 }
 
 } // namespace CGAL

Distance_2/include/CGAL/Distance_2/Point_2_Point_2.h

@@ -41,7 +41,7 @@ inline typename K::FT
 squared_distance(const Point_2<K>& pt1,
                  const Point_2<K>& pt2)
 {
-  return internal::squared_distance(pt1, pt2, K());
+  return K().compute_squared_distance_2_object()(pt1, pt2);
 }
 
 } // namespace CGAL

Distance_2/include/CGAL/Distance_2/Point_2_Segment_2.h

@@ -20,8 +20,6 @@
 #define CGAL_DISTANCE_2_POINT_2_SEGMENT_2_H
 
 #include <CGAL/Distance_2/internal/squared_distance_utils_2.h>
-#include <CGAL/Distance_2/Point_2_Point_2.h>
-#include <CGAL/Distance_2/Point_2_Line_2.h>
 
 #include <CGAL/Point_2.h>
 #include <CGAL/Segment_2.h>
@@ -57,11 +55,15 @@ squared_distance_indexed(const typename K::Point_2 &pt,
                          int ind,
                          const K& k)
 {
+  typename K::Compute_squared_distance_2 sq_dist = k.compute_squared_distance_2_object();
+
   if(ind == 0)
-    return internal::squared_distance(pt, seg.source(), k);
+    return sq_dist(pt, seg.source());
+
   if(ind == 1)
-    return internal::squared_distance(pt, seg.target(), k);
-  return internal::squared_distance(pt, seg.supporting_line(), k);
+    return sq_dist(pt, seg.target());
+
+  return sq_dist(pt, seg.supporting_line());
 }
 
 template <class K>
@@ -73,21 +75,23 @@ squared_distance(const typename K::Point_2& pt,
   typedef typename K::Vector_2 Vector_2;
   typedef typename K::RT RT;
 
-  typename K::Construct_vector_2 construct_vector = k.construct_vector_2_object();
+  typename K::Construct_vector_2 vector = k.construct_vector_2_object();
+  typename K::Compute_squared_length_2 sq_length = k.compute_squared_length_2_object();
+  typename K::Compute_squared_distance_2 sq_dist = k.compute_squared_distance_2_object();
 
   // assert that the segment is valid (non zero length).
-  Vector_2 diff = construct_vector(seg.source(), pt);
-  Vector_2 segvec = construct_vector(seg.source(), seg.target());
+  const Vector_2 diff = vector(seg.source(), pt);
+  const Vector_2 segvec = vector(seg.source(), seg.target());
 
-  RT d = wdot(diff, segvec, k);
+  const RT d = wdot(diff, segvec, k);
   if(d <= RT(0))
-    return k.compute_squared_length_2_object()(diff);
+    return sq_length(diff);
 
-  RT e = wdot(segvec,segvec, k);
+  const RT e = wdot(segvec,segvec, k);
   if(wmult((K*)0 ,d, segvec.hw()) > wmult((K*)0, e, diff.hw()))
-    return internal::squared_distance(pt, seg.target(), k);
+    return sq_dist(pt, seg.target());
 
-  return internal::squared_distance(pt, seg.supporting_line(), k);
+  return sq_dist(pt, seg.supporting_line());
 }
 
 template <class K>
@@ -106,15 +110,15 @@ inline typename K::FT
 squared_distance(const Point_2<K>& pt,
                  const Segment_2<K>& seg)
 {
-  return internal::squared_distance(pt, seg, K());
+  return K().compute_squared_distance_2_object()(pt, seg);
 }
 
 template <class K>
 inline typename K::FT
 squared_distance(const Segment_2<K>& seg,
                  const Point_2<K>& pt)
 {
-  return internal::squared_distance(pt, seg, K());
+  return K().compute_squared_distance_2_object()(seg, pt);
 }
 
 } // namespace CGAL

Distance_2/include/CGAL/Distance_2/Point_2_Triangle_2.h

@@ -212,13 +212,15 @@ squared_distance_indexed(const typename K::Point_2& pt,
   typedef typename K::FT      FT;
   typedef typename K::Line_2  Line_2;
 
+  typename K::Compute_squared_distance_2 sq_dist = k.compute_squared_distance_2_object();
+
   if(ind1 == -1)
     return FT(0);
 
   if(ind2 == -1)
-    return internal::squared_distance(pt, triangle.vertex(ind1), k);
+    return sq_dist(pt, triangle.vertex(ind1));
 
-  return internal::squared_distance(pt, Line_2(triangle.vertex(ind1), triangle.vertex(ind2)), k);
+  return sq_dist(pt, Line_2{triangle.vertex(ind1), triangle.vertex(ind2)});
 }
 
 template <class K>
@@ -248,15 +250,15 @@ inline typename K::FT
 squared_distance(const Point_2<K>& pt,
                  const Triangle_2<K>& triangle)
 {
-  return internal::squared_distance(pt, triangle, K());
+  return K().compute_squared_distance_2_object()(pt, triangle);
 }
 
 template <class K>
 inline typename K::FT
 squared_distance(const Triangle_2<K>& triangle,
                  const Point_2<K>& pt)
 {
-  return internal::squared_distance(pt, triangle, K());
+  return K().compute_squared_distance_2_object()(triangle, pt);
 }
 
 } // namespace CGAL

Distance_2/include/CGAL/Distance_2/Ray_2_Line_2.h

@@ -72,15 +72,15 @@ inline typename K::FT
 squared_distance(const Line_2<K>& line,
                  const Ray_2<K>& ray)
 {
-  return internal::squared_distance(line, ray, K());
+  return K().compute_squared_distance_2_object()(line, ray);
 }
 
 template <class K>
 inline typename K::FT
 squared_distance(const Ray_2<K>& ray,
                  const Line_2<K>& line)
 {
-  return internal::squared_distance(line, ray, K());
+  return K().compute_squared_distance_2_object()(ray, line);
 }
 
 } // namespace CGAL

Distance_2/include/CGAL/Distance_2/Ray_2_Ray_2.h

@@ -46,7 +46,7 @@ ray_ray_squared_distance_parallel(const typename K::Vector_2& ray1dir,
   RT wcr = wcross(ray1dir, from1to2, k);
   RT w = from1to2.hw();
 
-  return (square(wcr) / FT(wmult((K*)0, RT(wdot(ray1dir, ray1dir, k)), w, w)));
+  return (square(wcr) / FT(wmult((K*)0, wdot(ray1dir, ray1dir, k), w, w)));
 }
 
 template <class K>
@@ -58,11 +58,12 @@ squared_distance(const typename K::Ray_2& ray1,
   typedef typename K::Vector_2 Vector_2;
   typedef typename K::FT FT;
 
-  typename K::Construct_vector_2 construct_vector = k.construct_vector_2_object();
+  typename K::Construct_vector_2 vector = k.construct_vector_2_object();
+  typename K::Compute_squared_distance_2 sq_dist = k.compute_squared_distance_2_object();
 
-  const Vector_2& ray1dir = ray1.direction().vector();
-  const Vector_2& ray2dir = ray2.direction().vector();
-  Vector_2 diffvec(construct_vector(ray1.source(),ray2.source()));
+  const Vector_2 ray1dir = ray1.direction().vector();
+  const Vector_2 ray2dir = ray2.direction().vector();
+  const Vector_2 diffvec = vector(ray1.source(),ray2.source());
 
   bool crossing1, crossing2;
   switch(orientation(ray1dir, ray2dir, k))
@@ -83,18 +84,18 @@ squared_distance(const typename K::Ray_2& ray1,
   {
     if(crossing2)
       return FT(0);
-    return internal::squared_distance(ray2.source(), ray1, k);
+    return sq_dist(ray2.source(), ray1);
   }
   else
   {
     if(crossing2)
     {
-      return internal::squared_distance(ray1.source(), ray2, k);
+      return sq_dist(ray1.source(), ray2);
     }
     else
     {
-      FT min1 = internal::squared_distance(ray1.source(), ray2, k);
-      FT min2 = internal::squared_distance(ray2.source(), ray1, k);
+      FT min1 = sq_dist(ray1.source(), ray2);
+      FT min2 = sq_dist(ray2.source(), ray1);
       return (min1 < min2) ? min1 : min2;
     }
   }
@@ -106,7 +107,7 @@ template <class K>
 inline typename K::FT
 squared_distance(const Ray_2<K> &ray1, const Ray_2<K> &ray2)
 {
-  return internal::squared_distance(ray1, ray2, K());
+  return K().compute_squared_distance_2_object()(ray1, ray2);
 }
 
 } // namespace CGAL

Distance_2/include/CGAL/Distance_2/Ray_2_Triangle_2.h

@@ -20,6 +20,7 @@
 #define CGAL_DISTANCE_2_RAY_2_TRIANGLE_2_H
 
 #include <CGAL/Distance_2/internal/squared_distance_utils_2.h>
+#include <CGAL/Distance_2/Point_2_Triangle_2.h>
 
 #include <CGAL/Ray_2.h>
 #include <CGAL/Triangle_2.h>
@@ -64,11 +65,10 @@ squared_distance(const typename K::Ray_2& ray,
   {
     // Check if all the segment vertices lie at the same side of
     // the triangle segment.
-    const Point_2 &vt1 = triangle.vertex(ind_tr1);
-    const Point_2 &vt2 = triangle.vertex(ind_tr2);
+    const Point_2& vt1 = triangle.vertex(ind_tr1);
+    const Point_2& vt2 = triangle.vertex(ind_tr2);
     if(clockwise(ray.direction().vector(), vt2-vt1, k))
       mindist = FT(0);
-
   }
   else
   {
@@ -105,15 +105,15 @@ inline typename K::FT
 squared_distance(const Ray_2<K>& ray,
                  const Triangle_2<K>& triangle)
 {
-  return internal::squared_distance(ray, triangle, K());
+  return K().compute_squared_distance_2_object()(ray, triangle);
 }
 
 template <class K>
 inline typename K::FT
 squared_distance(const Triangle_2<K>& triangle,
                  const Ray_2<K>& ray)
 {
-  return internal::squared_distance(ray, triangle, K());
+  return K().compute_squared_distance_2_object()(triangle, ray);
 }
 
 } // namespace CGAL