Segment_2/Segment_3 midpoint()

Cartesian_kernel/include/CGAL/Cartesian/function_objects.h

@@ -2741,6 +2741,7 @@ namespace CartesianKernelFunctors {
   {
     typedef typename K::FT        FT;
     typedef typename K::Point_2   Point_2;
+    typedef typename K::Segment_2 Segment_2;
   public:
     typedef Point_2          result_type;
 
@@ -2752,13 +2753,25 @@ namespace CartesianKernelFunctors {
       midpointC2(p.x(), p.y(), q.x(), q.y(), x, y);
       return construct_point_2(x, y);
     }
+
+    Point_2
+    operator()(const Segment_2& s) const
+    {
+      typename K::Construct_point_2 construct_point_2;
+      FT x, y;
+      const Point_2& p = s.source();
+      const Point_2& q = s.target();
+      midpointC2(p.x(), p.y(), q.x(), q.y(), x, y);
+      return construct_point_2(x, y);
+    }
   };
 
   template <typename K>
   class Construct_midpoint_3
   {
     typedef typename K::FT        FT;
     typedef typename K::Point_3   Point_3;
+    typedef typename K::Segment_3 Segment_3;
   public:
     typedef Point_3               result_type;
 
@@ -2770,6 +2783,17 @@ namespace CartesianKernelFunctors {
       midpointC3(p.x(), p.y(), p.z(), q.x(), q.y(), q.z(), x, y, z);
       return construct_point_3(x, y, z);
     }
+
+    Point_3
+    operator()(const Segment_3& s) const
+    {
+      const Point_3& p = s.source();
+      const Point_3& q = s.target();
+      typename K::Construct_point_3 construct_point_3;
+      FT x, y, z;
+      midpointC3(p.x(), p.y(), p.z(), q.x(), q.y(), q.z(), x, y, z);
+      return construct_point_3(x, y, z);
+    }
   };
 
   template <typename K>

Homogeneous_kernel/include/CGAL/Homogeneous/function_objects.h

@@ -2950,6 +2950,7 @@ namespace HomogeneousKernelFunctors {
   {
     typedef typename K::FT        FT;
     typedef typename K::Point_2   Point_2;
+    typedef typename K::Segment_2 Segment_2;
   public:
     typedef Point_2          result_type;
 
@@ -2963,13 +2964,27 @@ namespace HomogeneousKernelFunctors {
                       p.hy()*qhw + q.hy()*phw,
                       phw * qhw * RT( 2));
     }
+
+    Point_2
+    operator()(const Segment_2& s) const
+    {
+      typedef typename K::RT RT;
+      const Point_2& p = s.source();
+      const Point_2& q = s.target();
+      const RT& phw = p.hw();
+      const RT& qhw = q.hw();
+      return Point_2( p.hx()*qhw + q.hx()*phw,
+                      p.hy()*qhw + q.hy()*phw,
+                      phw * qhw * RT( 2));
+    }
   };
 
   template <typename K>
   class Construct_midpoint_3
   {
     typedef typename K::FT        FT;
     typedef typename K::Point_3   Point_3;
+    typedef typename K::Segment_3 Segment_3;
   public:
     typedef Point_3          result_type;
 
@@ -2984,6 +2999,20 @@ namespace HomogeneousKernelFunctors {
                       p.hz()*qhw + q.hz()*phw,
                       RT(2) * phw * qhw );
     }
+
+    Point_3
+    operator()(const Segment_3& s) const
+    {
+      typedef typename K::RT RT;
+      const Point_3& p = s.source();
+      const Point_3& q = s.target();
+      RT phw = p.hw();
+      RT qhw = q.hw();
+      return Point_3( p.hx()*qhw + q.hx()*phw,
+                      p.hy()*qhw + q.hy()*phw,
+                      p.hz()*qhw + q.hz()*phw,
+                      RT(2) * phw * qhw );
+    }
   };
 
   // TODO ...

Kernel_23/doc/Kernel_23/CGAL/Kernel/global_functions.h

@@ -2242,12 +2242,25 @@ template <typename Kernel>
 CGAL::Point_2<Kernel> midpoint( const CGAL::Point_2<Kernel>& p,
 const CGAL::Point_2<Kernel>& q );
 
+
+  /*!
+computes the midpoint of the segment `s`.
+*/
+template <typename Kernel>
+CGAL::Point_2<Kernel> midpoint( const CGAL::Segment_2<Kernel>& s);
+
 /*!
 computes the midpoint of the segment `pq`.
 */
 template <typename Kernel>
 CGAL::Point_3<Kernel> midpoint( const CGAL::Point_3<Kernel>& p, const CGAL::Point_3<Kernel>& q );
 
+/*!
+computes the midpoint of the segment `s`.
+*/
+template <typename Kernel>
+CGAL::Point_3<Kernel> midpoint( const CGAL::Segment_3<Kernel>& s );
+
 /// @}
 
 /// \defgroup min_vertex_grp CGAL::min_vertex()

Kernel_23/doc/Kernel_23/Concepts/FunctionObjectConcepts.h

@@ -4996,6 +4996,10 @@ class ConstructMidpoint_2 {
   */
   Kernel::Point_2 operator()(const Kernel::Point_2& p,
                              const Kernel::Point_2& q );
+  /*!
+    computes the midpoint of the segment `s`.
+  */
+  Kernel::Point_2 operator()(const Kernel::Segment_2& s);
 
   /// @}
 
@@ -5023,6 +5027,11 @@ class ConstructMidpoint_3 {
   Kernel::Point_3 operator()(const Kernel::Point_3& p,
                              const Kernel::Point_3& q );
 
+  /*!
+    computes the midpoint of the segment `s`.
+  */
+  Kernel::Point_3 operator()(const Kernel::Segment_3& s);
+
 
   /// @}
 

Kernel_23/include/CGAL/Kernel/global_functions_2.h

@@ -754,6 +754,12 @@ midpoint(const Point_2<K> &p, const Point_2<K> &q)
   return internal::midpoint(p, q, K());
 }
 
+template < class K >
+inline typename K::Point_2 midpoint(const Segment_2<K> &s)
+{
+  return internal::midpoint(s, K());
+}
+
 template < class K >
 inline
 typename K::Point_2

Kernel_23/include/CGAL/Kernel/global_functions_3.h

@@ -738,6 +738,12 @@ midpoint(const Point_3<K> &p, const Point_3<K> &q)
   return internal::midpoint(p, q, K());
 }
 
+template < class K >
+inline typename K::Point_3 midpoint(const Segment_3<K> &s)
+{
+  return internal::midpoint(s, K());
+}
+
 template < class K >
 inline
 typename K::Point_3

Kernel_23/include/CGAL/Kernel/global_functions_internal_2.h

@@ -788,6 +788,14 @@ midpoint(const typename K::Point_2 &p,
   return k.construct_midpoint_2_object()(p, q);
 }
 
+template < class K >
+inline
+typename K::Point_2
+midpoint(const typename K::Segment_2 &s, const K &k)
+{
+  return k.construct_midpoint_2_object()(s);
+}
+
 template < class K >
 inline
 typename K::Point_2

Kernel_23/include/CGAL/Kernel/global_functions_internal_3.h

@@ -829,6 +829,14 @@ midpoint(const typename K::Point_3 &p,
   return k.construct_midpoint_3_object()(p, q);
 }
 
+template < class K >
+inline
+typename K::Point_3
+midpoint(const typename K::Segment_3 &s, const K &k)
+{
+  return k.construct_midpoint_3_object()(s);
+}
+
 template < class K >
 inline
 typename K::Point_3

Kernel_23/test/Kernel_23/include/CGAL/_test_fct_constructions_2.h

@@ -24,6 +24,7 @@ _test_fct_constructions_2(const R&)
 {
   typedef typename R::RT              RT;
   typedef CGAL::Point_2<R>            Point;
+  typedef CGAL::Segment_2<R>          Segment;
   typedef CGAL::Weighted_point_2<R>   Weighted_Point;
   typedef CGAL::Triangle_2<R>         Triangle;
   typedef CGAL::Vector_2<R>           Vector;
@@ -52,6 +53,7 @@ _test_fct_constructions_2(const R&)
   // midpoint
   assert( CGAL::midpoint( pne, psw) == p);
   assert( CGAL::midpoint( pnw, pse) == p);
+  assert( CGAL::midpoint( Segment{pnw, pse}) == p);
 
   // circumcenter
   assert( CGAL::circumcenter( pne, pne ) == pne);

Kernel_23/test/Kernel_23/include/CGAL/_test_fct_constructions_3.h

@@ -69,6 +69,7 @@ _test_fct_constructions_3(const R& r)
   assert( CGAL::midpoint( p110, p001) == p);
   assert( CGAL::midpoint( p010, p101) == p);
   assert( CGAL::midpoint( p100, p011) == p);
+  assert( CGAL::midpoint( Segment{p100, p011}) == p);
 
   // circumcenter
   assert( CGAL::circumcenter( p111, p001, p010, p000) == p);