New package: Frechet Distance

Frechet_distance/examples/Frechet_distance/Frechet_distance_2.cpp

@@ -1,14 +1,12 @@
-#include <CGAL/Frechet_distance.h>
-#include <CGAL/Frechet_distance_traits_2.h>
 #include <CGAL/Exact_predicates_inexact_constructions_kernel.h>
+#include <CGAL/Frechet_distance.h>
 #include <CGAL/IO/WKT.h>
 
 #include <ostream>
 #include <fstream>
 
 using Kernel = CGAL::Exact_predicates_inexact_constructions_kernel;
-using Traits = CGAL::Frechet_distance_traits_2<Kernel>;
-using Point = Traits::Point_d;
+using Point = Kernel::Point_2;
 
 int main(int argc, char* argv[])
 {
@@ -21,7 +19,7 @@ int main(int argc, char* argv[])
       std::ifstream in((argc > 1) ? argv[2] : CGAL::data_file_path("wkt/LetterAbis.wkt"));
       CGAL::IO::read_linestring_WKT(in, B);
     }
-    bool res = CGAL::is_Frechet_distance_larger<Traits>(A, B, 0.001);
+    bool res = CGAL::is_Frechet_distance_larger(A, B, 0.001);
     std::cout << std::boolalpha << res << std::endl;
     return 0;
 }

Frechet_distance/examples/Frechet_distance/Frechet_distance_3.cpp

@@ -1,14 +1,12 @@
 #include <CGAL/Frechet_distance.h>
-#include <CGAL/Frechet_distance_traits_3.h>
 #include <CGAL/Simple_cartesian.h>
 #include <CGAL/IO/WKT.h>
 
 #include <ostream>
 #include <fstream>
 
 using Kernel = CGAL::Simple_cartesian<double>;
-using Traits = CGAL::Frechet_distance_traits_3<Kernel>;
-using Point = Traits::Point_d;
+using Point = Kernel::Point_3;
 
 int main(int argc, char* argv[])
 {
@@ -22,7 +20,7 @@ int main(int argc, char* argv[])
       CGAL::IO::read_linestring_WKT(in, B);
     }
 
-    std::pair<double, double> res = CGAL::approximate_Frechet_distance<Traits>(A, B, 0.000001);
+    std::pair<double, double> res = CGAL::approximate_Frechet_distance(A, B, 0.000001);
     std::cout << "The Frechet distance between the polylines is between " <<  res.first << " and " << res.second << std::endl;
     return 0;
 }

Frechet_distance/examples/Frechet_distance/Frechet_distance_d.cpp

@@ -1,20 +1,18 @@
 #include <CGAL/Epick_d.h>
 #include <CGAL/Frechet_distance.h>
-#include <CGAL/Frechet_distance_traits_d.h>
 
 #include <iostream>
 #include <vector>
 
 using Kernel = CGAL::Epick_d<CGAL::Dimension_tag<4>>;
-using Traits = CGAL::Frechet_distance_traits_d<Kernel>;
-using Point = Traits::Point_d;
+using Point = Kernel::Point_d;
 
 int main()
 {
     std::array<Point,4> A = { Point(0,0,0,0), Point(1,0,0,0), Point(1,1,0,1),Point(1,1,1,0)};
     std::array<Point,4> B = { Point(0,0,0,0), Point(1,0,0,0), Point(1,1,0,0),Point(1,1,1,0)};
 
-    std::pair<double, double> res = CGAL::approximate_Frechet_distance<Traits>(A, B, 0.000001);
+    std::pair<double, double> res = CGAL::approximate_Frechet_distance(A, B, 0.000001);
     std::cout << "The Frechet distance between the polylines is between " <<  res.first << " and " << res.second << std::endl;
     return 0;
 }

Frechet_distance/include/CGAL/Frechet_distance.h

@@ -19,6 +19,7 @@
 #include <CGAL/license/Frechet_distance.h>
 #include <CGAL/basic.h>
 #include <CGAL/Frechet_distance/internal/Frechet_distance.h>
+#include <CGAL/Dimension.h>
 
 #include <CGAL/Named_function_parameters.h>
 
@@ -27,6 +28,61 @@
 namespace CGAL
 {
 
+#ifdef CGAL_EIGEN3_ENABLED
+template<class Dim> struct Epick_d;
+template<class Dim> struct Epeck_d;
+
+template < typename P, int D>
+struct Ambient_dimension<P, Epick_d<Dimension_tag<D>>>
+{
+  static constexpr int value = D;
+};
+
+template < typename P, int D>
+struct Ambient_dimension<P, Epeck_d<Dimension_tag<D>>>
+{
+  static constexpr int value = D;
+};
+#endif
+
+namespace internal
+{
+  template <typename P,
+            int Dimension = ::CGAL::Ambient_dimension<P>::value >
+  struct Get_default_traits_base
+  #ifdef CGAL_EIGEN3_ENABLED
+  {
+    using type = Frechet_distance_traits_d<typename Kernel_traits<P>::Kernel>;
+  };
+  #else
+  ;
+  #endif
+
+  template <typename P>
+  struct Get_default_traits_base<P, 2>
+  {
+    using type = Frechet_distance_traits_2<typename Kernel_traits<P>::Kernel>;
+  };
+
+  template <typename P>
+  struct Get_default_traits_base<P, 3>
+  {
+    using type = Frechet_distance_traits_3<typename Kernel_traits<P>::Kernel>;
+  };
+
+  template <class P, class K=typename Kernel_traits<P>::Kernel>
+  struct Get_default_traits
+  {
+    using type = typename Get_default_traits_base<P>::type;
+  };
+
+  template <class P>
+  struct Get_default_traits<P, ::CGAL::internal_kernel_traits::Dummy_kernel<P>>
+  {
+    using type = ::CGAL::internal_kernel_traits::Dummy_kernel<P>;
+  };
+} // end of internal namespace
+
 /**
  * \ingroup PkgFrechetDistanceFunctions
  * determines if the Frechet distance between two polylines is larger than a given distance bound.
@@ -43,14 +99,14 @@ namespace CGAL
  * \cgalNamedParamsBegin
  *   \cgalParamNBegin{geom_traits}
  *     \cgalParamDescription{an instance of a geometric traits class}
- *     \cgalParamType{Traits}
- *     \cgalParamDefault{`Traits()`}
+ *     \cgalParamType{a model of `FrechetDistanceTraits`}
+ *     \cgalParamDefault{`Frechet_distance_traits_2`, `Frechet_distance_traits_3`, or`Frechet_distance_traits_d`, depending on the dimension of the point type.}
  *   \cgalParamNEnd
  * \cgalNamedParamsEnd
  *
  * \pre the polylines must not be empty
  */
-template <class Traits, class PointRange, class NamedParameters =  parameters::Default_named_parameters>
+template <class PointRange, class NamedParameters =  parameters::Default_named_parameters>
 bool is_Frechet_distance_larger(const PointRange& polyline1,
                                 const PointRange& polyline2,
                                 const double distance_bound,
@@ -59,6 +115,11 @@ bool is_Frechet_distance_larger(const PointRange& polyline1,
     constexpr bool force_filtering =
       internal_np::Lookup_named_param_def<internal_np::force_filtering_t, NamedParameters, std::false_type>::type::value;
 
+    using Point_d = std::remove_cv_t<std::remove_reference_t<decltype(*polyline1.begin())>>;
+    using Default_traits = typename internal::Get_default_traits<Point_d>::type;
+    using Traits = typename internal_np::Lookup_named_param_def<internal_np::geom_traits_t,
+                                                                NamedParameters,
+                                                                Default_traits>::type;
     Traits traits =  parameters::choose_parameter<Traits>(
         parameters::get_parameter(np, internal_np::geom_traits));
 
@@ -92,8 +153,8 @@ bool is_Frechet_distance_larger(const PointRange& polyline1,
  * \cgalNamedParamsBegin
  *   \cgalParamNBegin{geom_traits}
  *     \cgalParamDescription{an instance of a geometric traits class}
- *     \cgalParamType{Traits}
- *     \cgalParamDefault{`Traits()`}
+ *     \cgalParamType{a model of `FrechetDistanceTraits`}
+ *     \cgalParamDefault{`Frechet_distance_traits_2`, `Frechet_distance_traits_3`, or`Frechet_distance_traits_d`, depending on the dimension of the point type.}
  *   \cgalParamNEnd
  * \cgalNamedParamsEnd
  *
@@ -102,7 +163,7 @@ bool is_Frechet_distance_larger(const PointRange& polyline1,
  * @return an interval enclosing the exact result, the difference between the upper and
  * the lower bound being less than `precision`.
  */
-template <class Traits, class PointRange, class NamedParameters =  parameters::Default_named_parameters>
+template <class PointRange, class NamedParameters =  parameters::Default_named_parameters>
 std::pair<double,double> approximate_Frechet_distance(const PointRange& polyline1,
                                                       const PointRange& polyline2,
                                                       const double precision,
@@ -111,9 +172,14 @@ std::pair<double,double> approximate_Frechet_distance(const PointRange& polyline
     constexpr bool force_filtering =
       internal_np::Lookup_named_param_def<internal_np::force_filtering_t, NamedParameters, std::false_type>::type::value;
 
-    Traits traits =  parameters::choose_parameter<Traits>(
-        parameters::get_parameter(np, internal_np::geom_traits));
+    using Point_d = std::remove_cv_t<std::remove_reference_t<decltype(*polyline1.begin())>>;
+    using Default_traits = typename internal::Get_default_traits<Point_d>::type;
+    using Traits = typename internal_np::Lookup_named_param_def<internal_np::geom_traits_t,
+                                                                NamedParameters,
+                                                                Default_traits>::type;
 
+    Traits traits =  parameters::choose_parameter<Traits>(
+      parameters::get_parameter(np, internal_np::geom_traits));
 
     constexpr bool filtered = force_filtering ||
       std::is_same_v<typename decltype(Frechet_distance_::internal::toCurve<force_filtering>(polyline1, traits))::IFT,

Frechet_distance/include/CGAL/Frechet_distance_near_neighbors_ds.h

@@ -76,8 +76,8 @@ auto FrechetDistanceNearNeighborsDS<PointRange, Traits>::get_close_curves(
 
     auto predicate = [&](PolylineID id) {
       CGAL_assertion(id < curves.size());
-        return  is_Frechet_distance_larger<Traits>(
-            curve, curves[id], distance);
+        return  is_Frechet_distance_larger(
+            curve, curves[id], distance, parameters::geom_traits(Traits()));
     };
     auto new_end = std::remove_if(result.begin(), result.end(), predicate);
     result.erase(new_end, result.end());

Frechet_distance/test/Frechet_distance/Frechet_distance_minimal_traits_2.cpp

@@ -58,16 +58,18 @@ int main()
   {
     using Traits = MinimalFrechetTraits<double>;
     std::vector<Traits::Point_d> curve;
-    /* bool decision = */ CGAL::is_Frechet_distance_larger<Traits>(curve, curve, 0.1, params::force_filtering(std::true_type()));
+    /* bool decision = */ CGAL::is_Frechet_distance_larger(
+        curve, curve, 0.1, params::force_filtering(std::true_type())
+                                  .geom_traits(Traits()));
   }
 
   {
     using Traits = MinimalFrechetTraits<CGAL::Exact_rational>;
     std::vector<Traits::Point_d> curve;
-    /* bool decision = */ CGAL::is_Frechet_distance_larger<Traits>(curve, curve, 0.1, params::force_filtering(std::true_type()));
+    /* bool decision = */ CGAL::is_Frechet_distance_larger(
+        curve, curve, 0.1, params::force_filtering(std::true_type())
+                                  .geom_traits(Traits()));
   }
 
-
-
   return 0;
 }

Frechet_distance/test/Frechet_distance/Frechet_distance_test.cpp

@@ -182,9 +182,10 @@ static double testFrechetDistance()
           */
             timer.start();
             auto decision =
-                ! CGAL::is_Frechet_distance_larger<TestTraits>(
+                ! CGAL::is_Frechet_distance_larger(
                     curves[query.id1], curves[query.id2], query.distance,
-                    params::force_filtering(std::bool_constant<force_filtering>()));
+                    params::force_filtering(std::bool_constant<force_filtering>())
+                           .geom_traits(TestTraits()));
             timer.stop();
 
             if (decision != query.decision) {