Generic 2D/3D Periodic Triangulations

Cartesian_kernel/include/CGAL/Cartesian/function_objects.h

@@ -559,6 +559,36 @@ namespace CartesianKernelFunctors {
     }
   };
 
+  template <typename K>
+  class Compare_squared_radius_2
+  {
+    typedef typename K::Point_2            Point_2;
+    typedef typename K::FT                 FT;
+
+  public:
+    typedef typename K::Comparison_result  result_type;
+
+    result_type operator()(const Point_2& p, const Point_2& q, const Point_2& r, const FT& ft) const
+    {
+      return CGAL::compare(squared_radiusC2(p.x(), p.y(),
+                                            q.x(), q.y(),
+                                            r.x(), r.y()),
+                           ft);
+    }
+
+    result_type operator()(const Point_2& p, const Point_2& q, const FT& ft) const
+    {
+      return CGAL::compare(squared_radiusC2(p.x(), p.y(),
+                                            q.x(), q.y()),
+                           ft);
+    }
+
+    result_type operator()(const Point_2&, const FT& ft) const
+    {
+      return - CGAL_NTS sign(ft);
+    }
+  };
+
   template <typename K>
   class Compare_squared_radius_3
   {

Filtered_kernel/include/CGAL/Filtered_kernel.h

@@ -112,14 +112,16 @@ template < typename CK, bool UseStaticFilters = true >
 struct Filtered_kernel_adaptor
   : public Filtered_kernel_base<CK>
 {
-        enum { Has_static_filters = false };
+  enum { Has_static_filters = false };
+  typedef Boolean_tag<Has_static_filters> Has_static_filters_tag;
 };
 
 template < typename CK >
 struct Filtered_kernel_adaptor<CK, true>
   : public Static_filters_base<CK>
 {
-        enum { Has_static_filters = true };
+  enum { Has_static_filters = true };
+  typedef Boolean_tag<Has_static_filters> Has_static_filters_tag;
 };
 
 // UseStaticFilters has a default value, depending on

Filtered_kernel/include/CGAL/Lazy_kernel.h

@@ -129,8 +129,9 @@ class Lazy_kernel_generic_base : protected internal::Enum_holder
   typedef typename Exact_kernel::Rep_tag                          Rep_tag;
 
   enum { Has_filtered_predicates = true };
+  typedef Boolean_tag<Has_filtered_predicates>                    Has_filtered_predicates_tag;
   enum { Has_static_filters = false };
-  typedef Boolean_tag<Has_filtered_predicates> Has_filtered_predicates_tag;
+  typedef Boolean_tag<Has_static_filters>                         Has_static_filters_tag;
 
   // Types
   typedef CGAL::Lazy_exact_nt<typename Exact_kernel::FT>  FT;

Filtered_kernel/include/CGAL/internal/Static_filters/Static_filters.h

@@ -195,9 +195,8 @@ class Static_filters : public K_base
   compare_weighted_squared_radius_3_object() const
   { return Compare_weighted_squared_radius_3(); }
 
-
   enum { Has_static_filters = true };
-
+  typedef Boolean_tag<Has_static_filters>           Has_static_filters_tag;
 
   typedef Static_filters_predicates::Compare_y_at_x_2<K_base,Self>          Compare_y_at_x_2;
 

Generator/include/CGAL/point_generators_2.h

@@ -110,8 +110,8 @@ class Random_points_in_square_2 : public Random_generator_base<P> {
     Random_points_in_square_2( double a = 1, Random& rnd = CGAL::get_default_random())
         // g is an input iterator creating points of type `P' uniformly
         // distributed in the half-open square with side length a,
-        // centered around the origin, i.e. \forall p = `*g': -\frac{a}{2}
-        // <= p.x() < \frac{a}{2} and -\frac{a}{2} <= p.y() < \frac{a}{2}
+        // centered around the origin, i.e.
+        // \forall p = `*g': -a <= p.x() < a and a <= p.y() < a
         // . Two random numbers are needed from `rnd' for each point.
     : Random_generator_base<P>( a, rnd) { generate_point(); }
     This& operator++()    {

Homogeneous_kernel/include/CGAL/Homogeneous/function_objects.h

@@ -34,6 +34,7 @@ namespace HomogeneousKernelFunctors {
   using CartesianKernelFunctors::Are_parallel_2;
   using CartesianKernelFunctors::Are_parallel_3;
   using CartesianKernelFunctors::Compute_squared_area_3;
+  using CartesianKernelFunctors::Compare_squared_radius_2;
   using CartesianKernelFunctors::Compare_squared_radius_3;
   using CartesianKernelFunctors::Collinear_3;
   using CartesianKernelFunctors::Construct_line_3;

Kernel_23/doc/Kernel_23/Concepts/FunctionObjectConcepts.h

@@ -1209,6 +1209,38 @@ class CompareSquaredRadius_3 {
 
 }; /* end Kernel::CompareSquaredRadius_3 */
 
+/*!
+\ingroup PkgKernel23ConceptsFunctionObjects
+\cgalConcept
+\cgalRefines `AdaptableFunctor`
+\sa `ComputePowerProduct_2` for the definition of of orthogonality for power distances.
+*/
+class CompareWeightedSquaredRadius_2
+{
+public:
+  /// \name Operations
+  /// A model of this concept must provide:
+  /// @{
+
+  /*!
+    compares the weight of the smallest circle orthogonal to the
+    input weighted point(s) with the input weight.
+    */
+    Comparison_result operator()(const Kernel::Weighted_point_2& pw,
+                                 const Kernel::Weighted_point_2& qw,
+                                 const Kernel::Weighted_point_2& rw,
+                                 const Kernel::FT& w);
+
+    Comparison_result operator()(const Kernel::Weighted_point_2& pw,
+                                 const Kernel::Weighted_point_2& qw,
+                                 const Kernel::FT& w);
+
+    Comparison_result operator()(const Kernel::Weighted_point_2& pw,
+                                 const Kernel::FT& w);
+
+    /// @}
+}; /* end Kernel::CompareWeightedSquaredRadius_2 */
+
 /*!
 \ingroup PkgKernel23ConceptsFunctionObjects
 \cgalConcept

Kernel_23/doc/Kernel_23/Concepts/Kernel.h

@@ -642,6 +642,16 @@ class Kernel {
   */
   typedef unspecified_type Compare_square_distance_2;
 
+  /*!
+    a model of `Kernel::CompareSquaredRadius_2`
+  */
+  typedef unspecified_type Compare_squared_radius_2;
+
+  /*!
+    a model of `Kernel::CompareWeightedSquaredRadius_2`
+  */
+  typedef unspecified_type Compare_weighted_squared_radius_2;
+
   /*!
     a model of `Kernel::CompareAngleWithXAxis_2`
   */
@@ -1418,11 +1428,6 @@ class Kernel {
   */
   typedef unspecified_type Less_xyz_3;
 
-  /*!
-    a model of `Kernel::CompareWeightedSquaredRadius_3`
-  */
-  typedef unspecified_type Compare_weighted_squared_radius_3;
-
   /*!
     a model of `Kernel::CompareX_3`
   */
@@ -1458,6 +1463,16 @@ class Kernel {
   */
   typedef unspecified_type Compare_squared_distance_3;
 
+  /*!
+    a model of `Kernel::CompareSquaredRadius_3`
+  */
+  typedef unspecified_type Compare_squared_radius_3;
+
+  /*!
+    a model of `Kernel::CompareWeightedSquaredRadius_3`
+  */
+  typedef unspecified_type Compare_weighted_squared_radius_3;
+
   /*!
     a model of `Kernel::LessSignedDistanceToPlane_3`
   */

Kernel_23/doc/Kernel_23/PackageDescription.txt

@@ -284,7 +284,9 @@
 - `Kernel::CompareSignedDistanceToLine_2`
 - `Kernel::CompareSquaredDistance_2`
 - `Kernel::CompareSquaredDistance_3`
+- `Kernel::CompareSquaredRadius_2`
 - `Kernel::CompareSquaredRadius_3`
+- `Kernel::CompareWeightedSquaredRadius_2`
 - `Kernel::CompareWeightedSquaredRadius_3`
 - `Kernel::CompareXAtY_2`
 - `Kernel::CompareXYZ_3`

Kernel_23/include/CGAL/Kernel/function_objects.h

@@ -693,6 +693,45 @@ namespace CommonKernelFunctors {
     }
   };
 
+  template <typename K>
+  class Compare_weighted_squared_radius_2
+  {
+  public:
+    typedef typename K::Weighted_point_2                  Weighted_point_2;
+    typedef typename K::Comparison_result                 Comparison_result;
+    typedef typename K::FT                                FT;
+
+    typedef Comparison_result                             result_type;
+
+    result_type operator()(const Weighted_point_2 & p,
+                           const Weighted_point_2 & q,
+                           const Weighted_point_2 & r,
+                           const FT& w) const
+    {
+      return CGAL::compare(squared_radius_orthogonal_circleC2(
+                             p.x(),p.y(),p.weight(),
+                             q.x(),q.y(),q.weight(),
+                             r.x(),r.y(),r.weight()),
+                           w);
+    }
+
+    result_type operator()(const Weighted_point_2 & p,
+                           const Weighted_point_2 & q,
+                           const FT& w) const
+    {
+      return CGAL::compare(squared_radius_smallest_orthogonal_circleC2(
+                             p.x(),p.y(),p.weight(),
+                             q.x(),q.y(),q.weight()),
+                           w);
+    }
+
+    result_type operator()(const Weighted_point_2 & p,
+                           const FT& w) const
+    {
+      return CGAL::compare(-p.weight(), w);
+    }
+  };
+
   template <typename K>
   class Compare_weighted_squared_radius_3
   {

Kernel_23/include/CGAL/Kernel/global_functions_internal_2.h

@@ -332,6 +332,69 @@ compare_squared_distance(const typename K::Point_2 &p,
   return k.compare_squared_distance_2_object()(p, q, d2);
 }
 
+template < class K >
+inline
+typename K::Comparison_result
+compare_squared_radius(const typename K::Point_2 &p,
+                       const typename K::FT &sr,
+                       const K& k)
+{
+  return k.compare_squared_radius_2_object()(p, sr);
+}
+
+template < class K >
+inline
+typename K::Comparison_result
+compare_squared_radius(const typename K::Point_2 &p,
+                       const typename K::Point_2 &q,
+                       const typename K::FT &sr,
+                       const K& k)
+{
+  return k.compare_squared_radius_2_object()(p, q, sr);
+}
+
+template < class K >
+inline
+typename K::Comparison_result
+compare_squared_radius(const typename K::Point_2 &p,
+                       const typename K::Point_2 &q,
+                       const typename K::Point_2 &r,
+                       const typename K::FT &sr,
+                       const K& k)
+{
+  return k.compare_squared_radius_2_object()(p, q, r, sr);
+}
+
+template < class K >
+inline
+typename K::Comparison_result
+compare_weighted_squared_radius(const typename K::Weighted_point_2 &p,
+                                const typename K::FT &w, const K &k)
+{
+  return k.compare_weighted_squared_radius_2_object()(p, w);
+}
+
+template < class K >
+inline
+typename K::Comparison_result
+compare_weighted_squared_radius(const typename K::Weighted_point_2 &p,
+                                const typename K::Weighted_point_2 &q,
+                                const typename K::FT &w, const K &k)
+{
+  return k.compare_weighted_squared_radius_2_object()(p, q, w);
+}
+
+template < class K >
+inline
+typename K::Comparison_result
+compare_weighted_squared_radius(const typename K::Weighted_point_2 &p,
+                                const typename K::Weighted_point_2 &q,
+                                const typename K::Weighted_point_2 &r,
+                                const typename K::FT &w, const K &k)
+{
+  return k.compare_weighted_squared_radius_2_object()(p, q, r, w);
+}
+
 template <class K>
 inline
 typename K::Comparison_result

Kernel_23/include/CGAL/Kernel/interface_macros.h

@@ -126,8 +126,12 @@ CGAL_Kernel_pred(Compare_squared_distance_2,
                  compare_squared_distance_2_object)
 CGAL_Kernel_pred(Compare_squared_distance_3,
                  compare_squared_distance_3_object)
+CGAL_Kernel_pred(Compare_squared_radius_2,
+                 compare_squared_radius_2_object)
 CGAL_Kernel_pred(Compare_squared_radius_3,
                  compare_squared_radius_3_object)
+CGAL_Kernel_pred(Compare_weighted_squared_radius_2,
+                 compare_weighted_squared_radius_2_object)
 CGAL_Kernel_pred(Compare_weighted_squared_radius_3,
                  compare_weighted_squared_radius_3_object)
 CGAL_Kernel_pred(Compare_x_at_y_2,

Kernel_23/include/CGAL/internal/Has_boolean_tags.h

@@ -14,12 +14,10 @@
 #ifndef CGAL_INTERNAL_HAS_BOOLEAN_TAGS_H
 #define CGAL_INTERNAL_HAS_BOOLEAN_TAGS_H
 
-#include <boost/mpl/has_xxx.hpp>
 #include <CGAL/tags.h>
 
-namespace CGAL{
-
-namespace internal{
+namespace CGAL {
+namespace internal {
 
 #define CGAL_HAS_XXX_MEMBER_NAMED_DEF(CLASS,MEMBER) \
 template<typename T> struct CLASS { \
@@ -43,32 +41,29 @@ template<class Traits, bool has_tag = Has_nested_type_Has_filtered_predicates<Tr
 struct Has_filtered_predicates;
 
 template<class Traits>
-struct Has_filtered_predicates<Traits,false>
-{
-  static const bool value = false;
-};
+struct Has_filtered_predicates<Traits, false>
+  : public CGAL::Tag_false
+{ };
 
 template<class Traits>
-struct Has_filtered_predicates<Traits,true>
-{
-  static const bool value = Traits::Has_filtered_predicates;
-};
+struct Has_filtered_predicates<Traits, true>
+  : public Traits::Has_filtered_predicates_tag
+{ };
 
 template<class Traits, bool has_tag = Has_nested_type_Has_static_filters<Traits>::value >
 struct Has_static_filters;
 
 template<class Traits>
-struct Has_static_filters<Traits,false>
-{
-  static const bool value = false;
-};
+struct Has_static_filters<Traits, false>
+  : public CGAL::Tag_false
+{ };
 
 template<class Traits>
-struct Has_static_filters<Traits,true>
-{
-  static const bool value = Traits::Has_static_filters;
-};
+struct Has_static_filters<Traits, true>
+  : public Traits::Has_static_filters_tag
+{ };
 
-} } //namespace CGAL::internal
+} // namespace internal
+} // namespace CGAL
 
 #endif //CGAL_INTERNAL_HAS_BOOLEAN_TAGS_H