Enhancements after review

Intersections_3/include/CGAL/Intersections_3/Bbox_3_Bbox_3.h

@@ -33,10 +33,10 @@ intersection(const CGAL::Bbox_3& a,
              const CGAL::Bbox_3& b)
 {
   typedef typename boost::variant<Bbox_3> variant_type;
-  typedef typename boost::optional<variant_type> Result_type;
+  typedef typename boost::optional<variant_type> result_type;
 
   if(!do_intersect(a,b))
-    return Result_type();
+    return result_type();
 
   double xmin = (std::max)(a.xmin(), b.xmin());
   double xmax = (std::min)(a.xmax(), b.xmax());
@@ -45,7 +45,7 @@ intersection(const CGAL::Bbox_3& a,
   double zmin = (std::max)(a.zmin(), b.zmin());
   double zmax = (std::min)(a.zmax(), b.zmax());
 
-  return Result_type(std::forward<Bbox_3>(Bbox_3(xmin, ymin, zmin, xmax, ymax, zmax)));
+  return result_type(std::forward<Bbox_3>(Bbox_3(xmin, ymin, zmin, xmax, ymax, zmax)));
 }
 
 } //namespace CGAL

Intersections_3/include/CGAL/Intersections_3/Line_3_Point_3.h

@@ -27,18 +27,18 @@ template <class K>
 inline bool
 do_intersect(const typename K::Point_3 &pt,
              const typename K::Line_3 &line,
-             const K&)
+             const K& k)
 {
-  return line.has_on(pt);
+  return k.has_on_3_object()(line,pt);
 }
 
 template <class K>
 inline bool
 do_intersect(const typename K::Line_3 &line,
              const typename K::Point_3 &pt,
-             const K&)
+             const K& k)
 {
-  return line.has_on(pt);
+  return k.has_on_3_object()(line, pt);
 }
 
 template <class K>

Intersections_3/include/CGAL/Intersections_3/Plane_3_Point_3.h

@@ -27,18 +27,18 @@ template <class K>
 inline bool
 do_intersect(const typename K::Point_3 &pt,
              const typename K::Plane_3 &plane,
-             const K&)
+             const K& k)
 {
-  return plane.has_on(pt);
+  return k.has_on_3_object()(plane,pt);
 }
 
 template <class K>
 inline bool
 do_intersect(const typename K::Plane_3 &plane,
              const typename K::Point_3 &pt,
-             const K&)
+             const K& k)
 {
-  return plane.has_on(pt);
+  return k.has_on_3_object()(plane,pt);
 }
 
 template <class K>

Intersections_3/include/CGAL/Intersections_3/Point_3_Ray_3.h

@@ -28,9 +28,9 @@ inline
 bool
 do_intersect(const typename K::Point_3 &pt,
              const typename K::Ray_3 &ray,
-             const K&)
+             const K& k)
 {
-  return ray.has_on(pt);
+  return k.has_on_3_object()(ray,pt);
 }
 
 
@@ -39,9 +39,9 @@ inline
 bool
 do_intersect(const typename K::Ray_3 &ray,
              const typename K::Point_3 &pt,
-             const K&)
+             const K& k)
 {
-  return ray.has_on(pt);
+  return k.has_on_3_object()(ray,pt);
 }
 
 

Intersections_3/include/CGAL/Intersections_3/Point_3_Segment_3.h

@@ -28,9 +28,9 @@ inline
 bool
 do_intersect(const typename K::Point_3 &pt,
              const typename K::Segment_3 &seg,
-             const K&)
+             const K& k)
 {
-    return seg.has_on(pt);
+    return k.has_on_3_object()(seg, pt);
 }
 
 template <class K>
@@ -38,9 +38,9 @@ inline
 bool
 do_intersect(const typename K::Segment_3 &seg,
              const typename K::Point_3 &pt,
-             const K&)
+             const K& k)
 {
-    return seg.has_on(pt);
+    return k.has_on_3_object()(seg, pt);
 }
 
 

Intersections_3/include/CGAL/Intersections_3/internal/Iso_cuboid_3_Plane_3_intersection.h

@@ -182,13 +182,62 @@ intersection(
   {
     Poly res;
     res.reserve(4);
-    std::list<Point_3> tmp;
+    typename K::Has_on_3 has_on;
-    std::list<Segment_3> seg_list;
+    if(has_on(pl, cub.vertex(0))
-    for(auto s : segments)
+       && has_on(pl, cub.vertex(5))
-      seg_list.push_back(s);
+       && has_on(pl, cub.vertex(4)))
-    fill_points_list(seg_list, tmp);
+    {
-    for(auto p : tmp)
+      res.push_back(cub.vertex(0));
-      res.push_back(p);
+      res.push_back(cub.vertex(5));
+      res.push_back(cub.vertex(4));
+      res.push_back(cub.vertex(3));
+    }
+    else if(has_on(pl, cub.vertex(0))
+            && has_on(pl, cub.vertex(1))
+            && has_on(pl, cub.vertex(6)))
+    {
+      res.push_back(cub.vertex(0));
+      res.push_back(cub.vertex(1));
+      res.push_back(cub.vertex(6));
+      res.push_back(cub.vertex(5));
+      
+    }
+    else if(has_on(pl, cub.vertex(1))
+            && has_on(pl, cub.vertex(2))
+            && has_on(pl, cub.vertex(7)))
+    {
+      res.push_back(cub.vertex(1));
+      res.push_back(cub.vertex(2));
+      res.push_back(cub.vertex(7));
+      res.push_back(cub.vertex(6));
+    }
+    else if(has_on(pl, cub.vertex(2))
+            && has_on(pl, cub.vertex(3))
+            && has_on(pl, cub.vertex(4)))
+    {
+      res.push_back(cub.vertex(2));
+      res.push_back(cub.vertex(3));
+      res.push_back(cub.vertex(4));
+      res.push_back(cub.vertex(7));
+    }
+    else if(has_on(pl, cub.vertex(6))
+            && has_on(pl, cub.vertex(7))
+            && has_on(pl, cub.vertex(4)))
+    {
+      res.push_back(cub.vertex(6));
+      res.push_back(cub.vertex(7));
+      res.push_back(cub.vertex(4));
+      res.push_back(cub.vertex(5));
+    }
+    else if(has_on(pl, cub.vertex(2))
+            && has_on(pl, cub.vertex(1))
+            && has_on(pl, cub.vertex(0)))
+    {
+      res.push_back(cub.vertex(2));
+      res.push_back(cub.vertex(1));
+      res.push_back(cub.vertex(0));
+      res.push_back(cub.vertex(3));
+    }
     return result_type(std::forward<Poly>(res));
   }
     break;
@@ -249,11 +298,11 @@ intersection(
   }
 
   std::list<Segment_3> tmp_segs;
-  for(auto line : plane_intersections)
+  for(const auto& line : plane_intersections)
   {
     bool first_found = false;
     Point_3 first_p;
-    for(auto p : filtered_points)
+    for(const auto  &p : filtered_points)
     {
       if(line.has_on(p))
       {
@@ -264,7 +313,7 @@ intersection(
         }
         else
         {
-          tmp_segs.push_back(Segment_3(first_p, p));
+          tmp_segs.emplace_back(first_p, p);
           break;
         }
       }
@@ -275,7 +324,7 @@ intersection(
   std::list<Point_3> tmp_pts;
   fill_points_list(tmp_segs,tmp_pts);
   Poly res;
-  for(auto p : tmp_pts)
+  for(const auto& p : tmp_pts)
     res.push_back(p);
   if(res.size() == 3){
     typename K::Triangle_3 tr(res[0], res[1], res[2]);

Intersections_3/include/CGAL/Intersections_3/internal/Tetrahedron_3_Plane_3_intersection.h

@@ -46,7 +46,7 @@ intersection(
 {
   typedef typename Intersection_traits<K,
       typename K::Tetrahedron_3,
-      typename K::Plane_3>::result_type Result_type;
+      typename K::Plane_3>::result_type result_type;
 
   typedef typename Intersection_traits<K,
       typename K::Triangle_3,
@@ -68,7 +68,7 @@ intersection(
       if(const typename K::Triangle_3* tr = boost::get<typename K::Triangle_3>(&*intersections[i]))
       {
         typename K::Triangle_3 res = *tr;
-        return Result_type(std::forward<typename K::Triangle_3>(res));
+        return result_type(std::forward<typename K::Triangle_3>(res));
       }
       else if( const Segment_3* s
                = boost::get<Segment_3>(&*intersections[i]))
@@ -91,25 +91,25 @@ intersection(
   case 0:
   {
     if(p_id == -1)
-      return Result_type();
+      return result_type();
     else
     {
       typename K::Point_3 p
           = *boost::get<typename K::Point_3>(&*intersections[p_id]);
 
-      return Result_type(std::forward<typename  K::Point_3>(p));
+      return result_type(std::forward<typename  K::Point_3>(p));
     }
   }
     break;
   case 2:
   {
-    return Result_type(std::forward<typename  K::Segment_3>(segments.back()));
+    return result_type(std::forward<typename  K::Segment_3>(segments.back()));
   }
     break;
   default:
   {
     std::set<typename K::Point_3> all_points;
-    for (auto s : segments)
+    for (const auto& s : segments)
     {
       all_points.insert(s.source());
       all_points.insert(s.target());
@@ -121,7 +121,7 @@ intersection(
       typename K::Point_3 mid_point = *p_it;
       ++p_it;
       typename K::Triangle_3 result(*all_points.begin(), mid_point, *p_it );
-      return Result_type(std::forward<typename K::Triangle_3>(result));
+      return result_type(std::forward<typename K::Triangle_3>(result));
     }
     else //size = 4
     {
@@ -129,14 +129,14 @@ intersection(
       std::list<typename K::Point_3> tmp;
       fill_points_list(segs, tmp);
       std::vector<typename K::Point_3> res;
-      for( auto p : tmp)
+      for( const auto& p : tmp)
         res.push_back(p);
-      return Result_type(std::forward<std::vector<typename K::Point_3> >(res));
+      return result_type(std::forward<std::vector<typename K::Point_3> >(res));
     }
   }
     break;
   }
-  return Result_type();
+  return result_type();
 }
 
 template <class K>

Intersections_3/include/CGAL/Intersections_3/internal/Tetrahedron_3_Triangle_3_intersection.h

@@ -41,11 +41,11 @@ typename Intersection_traits<K, typename K::Tetrahedron_3, typename K::Triangle_
 intersection(
     const typename K::Tetrahedron_3 &tet,
     const typename K::Triangle_3 &tr,
-    const K&)
+    const K& k)
 {
   typedef typename Intersection_traits<K,
       typename K::Tetrahedron_3,
-      typename K::Triangle_3>::result_type Result_type;
+      typename K::Triangle_3>::result_type result_type;
 
   typedef typename Intersection_traits<K,
       typename K::Triangle_3,
@@ -83,7 +83,7 @@ intersection(
         if(const Triangle_3* t = boost::get<typename K::Triangle_3>(&*intersections[i]))
         {
           Triangle_3 res = *t;
-          return Result_type(std::forward<Triangle_3>(res));
+          return result_type(std::forward<Triangle_3>(res));
         }
         //get segs and pts to construct poly
         else if( const Segment_3* s
@@ -102,7 +102,7 @@ intersection(
                  = boost::get<Poly>(&*intersections[i]))
         {
           Poly res = *p;
-          return Result_type(std::forward<Poly>(res));
+          return result_type(std::forward<Poly>(res));
         }
       }
     }
@@ -119,21 +119,21 @@ intersection(
       fill_segments_infos(segments,tmp, tr);
       Poly res;
       res.reserve(4);
-      for( auto p : tmp){
+      for( const auto& p : tmp){
         res.push_back(p);
       }
-      return Result_type(std::forward<Poly>(res));
+      return result_type(std::forward<Poly>(res));
     }
     //else it must be adjacent to an vertex, so we return the point
     else if(segments.size() == 1)
     {
       //adjacency to an edge, return resulting segment.
-      return Result_type(std::forward<Segment_3>(segments.front()));
+      return result_type(std::forward<Segment_3>(segments.front()));
     }
     else
     {
       //no segment = adjacency to an vertex or an edge : return result point
-      return Result_type(std::forward<Point_3>(points.front()));
+      return result_type(std::forward<Point_3>(points.front()));
 
     }
   }
@@ -155,7 +155,7 @@ intersection(
         if(const Triangle_3* t = boost::get<typename K::Triangle_3>(&*intersections[i]))
         {
           Triangle_3 res = *t;
-          return Result_type(std::forward<Triangle_3>(res));
+          return result_type(std::forward<Triangle_3>(res));
         }
         //get segs and pts to construct poly
         else if( const Segment_3* s
@@ -173,14 +173,14 @@ intersection(
                  = boost::get<Poly>(&*intersections[i]))
         {
           Poly res = *p;
-          return Result_type(std::forward<Poly>(res));
+          return result_type(std::forward<Poly>(res));
         }
       }
     }
     if(segments.empty())
     {
       //then there is only one point of contact. Return it:
-      return Result_type(std::forward<Point_3>(points.front()));
+      return result_type(std::forward<Point_3>(points.front()));
     }
 
     if(segments.size() > 1)
@@ -197,7 +197,7 @@ intersection(
       bool return_solo_seg = true;
       //only one intersection, a triangle edge is one of the tet edges, and
       //the 3rd point is outside. This is the only intersection.
-      for(auto p : inside_points)
+      for(const auto& p : inside_points)
       {
         if(!tet.has_on_boundary(p))
         {
@@ -207,14 +207,14 @@ intersection(
       }
       if(return_solo_seg)
       {
-        return Result_type(std::forward<Segment_3>(segments.front()));
+        return result_type(std::forward<Segment_3>(segments.front()));
       }
 
       if(inside_points.size() == 1)
       {
         Triangle_3 res(inside_points.front(), segments.front().source(),
                        segments.front().target());
-        return Result_type(std::forward<Triangle_3>(res));
+        return result_type(std::forward<Triangle_3>(res));
       }
       else //size 2
       {
@@ -232,15 +232,14 @@ intersection(
           res[3] = segments.front().target();
           res[2] = segments.front().source();
         }
-        return Result_type(std::forward<Poly>(res));
+        return result_type(std::forward<Poly>(res));
       }
       }
       break;
     case 2:
     case 3:
     {
-      std::list<Segment_3> segs;
+      std::list<Segment_3> segs(segments.begin(), segments.end());
-      for(auto s : segments){segs.push_back(s);}
       std::list<Point_3> tmp;
       fill_points_list(segs, tmp);
       if(inside_points.size() == 1)
@@ -248,21 +247,26 @@ intersection(
         Poly res;
         res.reserve(4);
         res.push_back(inside_points.front());
-        for( auto p : tmp){res.push_back(p);}
+        for( const auto& p : tmp){res.push_back(p);}
-        return Result_type(std::forward<Poly>(res));
+        return result_type(std::forward<Poly>(res));
       }
       else //size 2
       {
         Poly res;
         res.reserve(5);
-        if((inside_points.front() - inside_points.back()) *
+        typename K::Compute_scalar_product_3 scalar = 
-           (tmp.front() - tmp.back()) > 0)
+          k.compute_scalar_product_3_object();
+        typename K::Construct_vector_3 construct_vector = 
+          k.construct_vector_3_object();
+        
+        if(scalar(construct_vector(inside_points.front(), inside_points.back()),
+           construct_vector(tmp.front(), tmp.back())) > 0)
         {
           res.push_back(inside_points.front());
         }
         res.push_back(inside_points.back());
-        for( auto p : tmp){res.push_back(p);}
+        for( const auto& p : tmp){res.push_back(p);}
-        return Result_type(std::forward<Poly>(res));
+        return result_type(std::forward<Poly>(res));
       }
     }
       break;
@@ -276,8 +280,7 @@ intersection(
   case 3:
   {
     //triangle entirely inside tetra : return input triangle
-    typename K::Triangle_3 res = tr;
+    return result_type(tr);
-    return Result_type(std::forward<typename K::Triangle_3>(res));
   }
     break;
   default:

Intersections_3/include/CGAL/Intersections_3/internal/Triangle_3_Triangle_3_intersection.h

@@ -128,7 +128,7 @@ struct Triangle_Line_visitor {
 
   result_type
   operator()(const typename K::Point_3& p, const typename K::Segment_3& s) const {
-    if ( s.has_on(p) )
+    if ( typename K::Has_on_3()(s,p) )
       return intersection_return<typename K::Intersect_3, typename K::Triangle_3, typename K::Triangle_3>(p);
     else
       return result_type();

Intersections_3/include/CGAL/Intersections_3/internal/intersection_3_1_impl.h

@@ -1249,15 +1249,11 @@ inline
 typename Intersection_traits<K, Bbox_3, Bbox_3>::result_type
 intersection(const Bbox_3 &a,
 	     const Bbox_3 &b,
-	     const K& k)
+	     const K&)
 {
   return CGAL::intersection<K>(a, b);
 }
 
-
-
-
-
 template <class K>
 typename Intersection_traits<K, CGAL::Bbox_3, typename K::Iso_cuboid_3>::result_type
 intersection(const CGAL::Bbox_3 &box,

Intersections_3/include/CGAL/Intersections_3/internal/tetrahedron_intersection_helpers.h

@@ -75,7 +75,7 @@ void fill_segments_infos(std::vector<Segment>& segments,
 
   std::vector<Wrapped_segment> wrapped_segments;
 
-  for(auto s:segments)
+  for(const auto& s:segments)
     wrapped_segments.push_back(Wrapped_segment(s));
 
   std::vector<Segment> bis = segments;

Intersections_3/include/CGAL/Intersections_3/internal/tetrahedron_lines_intersections_3.h

@@ -138,8 +138,8 @@ struct Tetrahedron_lines_intersection_3_base
 
     for(std::size_t i = 0; i< res_points.size(); ++i)
     {
-      auto p1 = res_points[i];
+      const auto& p1 = res_points[i];
-      for(auto p2 : res_points)
+      for(const auto& p2 : res_points)
       {
         sq_distances[i].push_back(CGAL::squared_distance(p1, p2));
         if(sq_distances[i].back() > max_dist)

Intersections_3/test/Intersections_3/test_intersections_3.cpp

@@ -574,9 +574,16 @@ struct Test {
     if(is_exact)
     {
       check_no_intersection (tet, L(P(5,0,0), P(5,1,0)));
+      //on edge
       check_intersection (tet, L(P(0,2,0), P(0,3,0)), S(P(0,0,0), P(0,1,0)));
+      //through vertex and out from face
       check_intersection (tet, L(P(0,1,0), P(0.25,0,0.25)), S(P(0,1,0), P(0.25,0,0.25)));
+      //through a vertex only
       check_intersection (tet, L(P(1,1,0), P(-1,1,0)), P(0,1,0));
+      //through 2 faces
+      check_intersection (tet, L(P(0.25,0.25,0), P(0.25,0,0.25)), S(P(0.25,0,0.25), P(0.25,0.25,0)));
+      //through one edge
+      check_intersection (tet, L(P(0.5,-0.5,0.5), P(0.5,0.5,0.5)), P(0.5,0,0.5));
     }
 
   }
@@ -1251,7 +1258,7 @@ int main()
 {
   std::cout << " |||||||| Test Simple_cartesian<double> ||||||||" << std::endl;
   Test< CGAL::Simple_cartesian<double> >().run();
-/*
+  
   std::cout << " |||||||| Test CGAL::Homogeneous<CGAL::MP_Float> ||||||||" << std::endl;
   Test< CGAL::Homogeneous<CGAL::MP_Float> >().run();
 
@@ -1260,5 +1267,4 @@ int main()
 
   std::cout << " |||||||| Test CGAL::Homogeneous<CGAL::Epeck_ft> ||||||||" << std::endl;
   Test< CGAL::Homogeneous<CGAL::Epeck_ft> >().run(true);
-  */
 }