New package: Frechet Distance

Documentation/doc/Documentation/packages.txt

@@ -38,6 +38,7 @@
 \package_listing{Straight_skeleton_2}
 \package_listing{Minkowski_sum_2}
 \package_listing{Polyline_simplification_2}
+\package_listing{Polyline_distance}
 \package_listing{Visibility_2}
 \package_listing{Set_movable_separability_2}
 

Documentation/doc/scripts/generate_how_to_cite.py

@@ -157,7 +157,7 @@ def protect_upper_case(title):
   return title.replace("dD","{dD}").replace("2D","{2D}").replace("3D","{3D}").replace("CGAL","{CGAL}").replace("Qt","{Qt}").replace("Boost","{Boost}")
 
 def protect_accentuated_letters(authors):
-  res=authors.replace("é",r"{\'e}").replace("è",r"{\`e}").replace("É",r"{\'E}").replace("ä",r"{\"a}").replace("ö",r"{\"o}").replace("ñ",r"{\~n}").replace("ã",r"{\~a}").replace("ë",r"{\"e}").replace("ı",r"{\i}").replace("Ş",r"{\c{S}}").replace("ş",r"{\c{s}}").replace("%","").replace("đ",r"{\-d}")
+  res=authors.replace("é",r"{\'e}").replace("è",r"{\`e}").replace("É",r"{\'E}").replace("ä",r"{\"a}").replace("ö",r"{\"o}").replace("ñ",r"{\~n}").replace("ã",r"{\~a}").replace("ë",r"{\"e}").replace("ı",r"{\i}").replace("Ş",r"{\c{S}}").replace("ş",r"{\c{s}}").replace("%","").replace("đ",r"{\-d}").replace("ü",r"{\"u}")
   try:
     res.encode('ascii')
   except UnicodeEncodeError:

Installation/include/CGAL/license/Polyline_distance.h

@@ -0,0 +1,54 @@
+// Copyright (c) 2016  GeometryFactory SARL (France).
+// All rights reserved.
+//
+// This file is part of CGAL (www.cgal.org)
+//
+// $URL$
+// $Id$
+// SPDX-License-Identifier: LGPL-3.0-or-later OR LicenseRef-Commercial
+//
+// Author(s) : Andreas Fabri
+//
+// Warning: this file is generated, see include/CGAL/license/README.md
+
+#ifndef CGAL_LICENSE_POLYLINE_DISTANCE_H
+#define CGAL_LICENSE_POLYLINE_DISTANCE_H
+
+#include <CGAL/config.h>
+#include <CGAL/license.h>
+
+#ifdef CGAL_POLYLINE_DISTANCE_COMMERCIAL_LICENSE
+
+#  if CGAL_POLYLINE_DISTANCE_COMMERCIAL_LICENSE < CGAL_RELEASE_DATE
+
+#    if defined(CGAL_LICENSE_WARNING)
+
+       CGAL_pragma_warning("Your commercial license for CGAL does not cover "
+                           "this release of the Polyline Distances package.")
+#    endif
+
+#    ifdef CGAL_LICENSE_ERROR
+#      error "Your commercial license for CGAL does not cover this release \
+              of the dD Polyline Distances package. \
+              You get this error, as you defined CGAL_LICENSE_ERROR."
+#    endif // CGAL_LICENSE_ERROR
+
+#  endif // CGAL_POLYLINE_DISTANCE_COMMERCIAL_LICENSE < CGAL_RELEASE_DATE
+
+#else // no CGAL_POLYLINE_DISTANCE_COMMERCIAL_LICENSE
+
+#  if defined(CGAL_LICENSE_WARNING)
+     CGAL_pragma_warning("\nThe macro CGAL_POLYLINE_DISTANCE_COMMERCIAL_LICENSE is not defined."
+                          "\nYou use the CGAL Polyline Distances package under "
+                          "the terms of the GPLv3+.")
+#  endif // CGAL_LICENSE_WARNING
+
+#  ifdef CGAL_LICENSE_ERROR
+#    error "The macro CGAL_POLYLINE_DISTANCE_COMMERCIAL_LICENSE is not defined.\
+            You use the CGAL Polyline Distances package under the terms of \
+            the GPLv3+. You get this error, as you defined CGAL_LICENSE_ERROR."
+#  endif // CGAL_LICENSE_ERROR
+
+#endif // no CGAL_POLYLINE_DISTANCE_COMMERCIAL_LICENSE
+
+#endif // CGAL_LICENSE_POLYLINE_DISTANCE_H

NewKernel_d/include/CGAL/NewKernel_d/Cartesian_filter_K.h

@@ -63,6 +63,12 @@ struct Cartesian_filter_K : public Base_
     typedef typename Store_kernel<EK_>::reference_type EK_rt;
     EK_rt exact_kernel()const{return sek.kernel();}
 
+
+    // Added to be similar to CGAL::Filtered_kernel
+    typedef EK Exact_kernel;
+    enum { Has_filtered_predicates = true };
+    typedef Boolean_tag<Has_filtered_predicates> Has_filtered_predicates_tag;
+
     // MSVC is too dumb to perform the empty base optimization.
     typedef std::bool_constant<
       internal::Do_not_store_kernel<Kernel_base>::value &&

NewKernel_d/test/NewKernel_d/Epick_d.cpp

@@ -745,6 +745,11 @@ static_assert(std::is_same<CGAL::Dimension_tag<3>,Ker3::Dimension>::value);
 static_assert(std::is_same<CGAL::Dynamic_dimension_tag,Kerd::Dimension>::value);
 static_assert(std::is_same<CGAL::Dimension_tag<2>,CGAL::Ambient_dimension<Ker2::Point_d>::type>::value);
 static_assert(std::is_same<CGAL::Dimension_tag<3>,CGAL::Ambient_dimension<Ker3::Point_d,Ker3>::type>::value);
+
+static_assert(Ker2::Has_filtered_predicates_tag::value);
+static_assert(Ker3::Has_filtered_predicates_tag::value);
+static_assert(Kerd::Has_filtered_predicates_tag::value);
+
 int main(){
   //Broken with Linear_base_d (output iterator)
   //test2<CGAL::Kernel_d_interface<KK> >();

Polyline_distance/.clang-format

@@ -0,0 +1,6 @@
+BasedOnStyle: Google
+Language: Cpp
+IndentWidth: 4
+AccessModifierOffset: -4
+BreakBeforeBraces: Linux
+

Polyline_distance/doc/Polyline_distance/Doxyfile.in

@@ -0,0 +1,3 @@
+@INCLUDE = ${CGAL_DOC_PACKAGE_DEFAULTS}
+
+PROJECT_NAME = "CGAL ${CGAL_DOC_VERSION} - dD Polyline Distance"

Polyline_distance/doc/Polyline_distance/PackageDescription.txt

@@ -0,0 +1,45 @@
+/// \defgroup PkgPolylineDistanceRef dD Polyline Distance Reference
+/// \defgroup PkgPolylineDistanceConcepts Concepts
+/// \ingroup PkgPolylineDistanceRef
+/// \defgroup PkgPolylineDistanceFunctions Functions
+/// You can add some text here if you want a description at the group level
+/// \ingroup PkgPolylineDistanceRef
+
+
+/*!
+\addtogroup PkgPolylineDistanceRef
+
+\cgalPkgDescriptionBegin{dD Polyline Distance,PkgPolylineDistance}
+\cgalPkgPicture{pkg-small.png}
+
+\cgalPkgSummaryBegin
+\cgalPkgAuthors{André Nusser, Marvin Künnemann, and Karl Bringmann}
+\cgalPkgDesc{The package provides ... }
+\cgalPkgManuals{Chapter_dD_Polyline_distance,PkgPolylineDistanceRef}
+\cgalPkgSummaryEnd
+
+\cgalPkgShortInfoBegin
+\cgalPkgSince{6.1}
+\cgalPkgDependsOn{\ref PkgSpatialSearchingD}
+\cgalPkgBib{cgal:kn-pd}
+\cgalPkgLicense{\ref licensesGPL "GPL"}
+\cgalPkgShortInfoEnd
+
+\cgalPkgDescriptionEnd
+
+This package ....
+
+\cgalClassifedRefPages
+
+\cgalCRPSection{Concepts}
+- `PolylineDistanceTraits`
+
+\cgalCRPSection{Classes}
+- `CGAL::Polyline_distance_traits_2`
+- `CGAL::Polyline_distance_traits_3`
+- `CGAL::Polyline_distance_traits_d`
+
+\cgalCRPSection{Functions}
+- `CGAL::continuous_Frechet_distance()`
+- `CGAL::continuous_Frechet_distance_less_than()`
+*/

Polyline_distance/doc/Polyline_distance/Polyline_distance.txt

@@ -0,0 +1,29 @@
+namespace CGAL {
+/*!
+
+\mainpage User Manual
+\anchor Chapter_dD_Polyline_distance
+
+\cgalAutoToc
+\author André Nusser, Marvin Künnemann, and Karl Bringmann
+
+This chapter describes the ...
+
+\section secmydefinitions Definitions
+
+Section on definitions here ...
+
+\section secmyexamples Examples
+
+\subsection myFirstExample First Example
+
+The following example shows ...
+
+\cgalExample{Polyline_distance/Frechet_distance_2.cpp}
+
+\cgalFigureBegin{figRefId,pkg-small.png}
+Here you can put the caption
+\cgalFigureEnd
+
+*/
+} /* namespace CGAL */

Polyline_distance/doc/Polyline_distance/dependencies

@@ -0,0 +1,6 @@
+Manual
+Kernel_23
+STL_Extension
+Algebraic_foundations
+Circulator
+Stream_support

Polyline_distance/doc/Polyline_distance/examples.txt

@@ -0,0 +1,3 @@
+/*!
+\example Polyline_distance/Frechet_distance_2.cpp
+*/

Polyline_distance/examples/Polyline_distance/CMakeLists.txt

@@ -0,0 +1,18 @@
+# Created by the script cgal_create_cmake_script
+# This is the CMake script for compiling a CGAL application.
+
+cmake_minimum_required(VERSION 3.1...3.14)
+project( Polyline_distance_Examples )
+
+find_package(CGAL REQUIRED QUIET OPTIONAL_COMPONENTS Core )
+
+
+find_package(Eigen3 3.1.0 QUIET) #(requires 3.1.0 or greater)
+include(CGAL_Eigen3_support)
+
+create_single_source_cgal_program( "Frechet_distance_2.cpp" )
+
+if(TARGET CGAL::Eigen3_support)
+create_single_source_cgal_program( "Frechet_distance_d.cpp" )
+target_link_libraries(Frechet_distance_d PUBLIC CGAL::Eigen3_support)
+endif()

Polyline_distance/examples/Polyline_distance/Frechet_distance_2.cpp

@@ -0,0 +1,17 @@
+#include <CGAL/Frechet_distance.h>
+#include <CGAL/Polyline_distance_traits_2.h>
+#include <CGAL/Exact_predicates_inexact_constructions_kernel.h>
+
+#include <ostream>
+
+using Kernel = CGAL::Exact_predicates_inexact_constructions_kernel;
+using Traits = CGAL::Polyline_distance_traits_2<Kernel>;
+using Point = Traits::Point;
+
+int main(int argc, char* argv[])
+{
+    std::vector<Point> A, B;
+    bool res = CGAL::continuous_Frechet_distance_less_than<Traits>(A, B, 0.001);
+    std::cout << std::boolalpha << res << std::endl;
+    return 0;
+}

Polyline_distance/examples/Polyline_distance/Frechet_distance_d.cpp

@@ -0,0 +1,17 @@
+#include <CGAL/Frechet_distance.h>
+#include <CGAL/Polyline_distance_traits_d.h>
+#include <CGAL/Epick_d.h>
+
+#include <iostream>
+#include <vector>
+
+using Kernel = CGAL::Epick_d<CGAL::Dimension_tag<4>>;
+using Traits = CGAL::Polyline_distance_traits_d<Kernel>;
+using Point = Traits::Point;
+
+int main(int argc, char* argv[])
+{
+    std::vector<Point> A, B;
+    bool res = CGAL::continuous_Frechet_distance_less_than<Traits>(A, B, 0.001);
+    return 0;
+}

Polyline_distance/examples/Polyline_distance/Has_filtered_predicates.cpp

@@ -0,0 +1,92 @@
+
+
+#include <CGAL/Simple_cartesian.h>
+#include <CGAL/Exact_rational.h>
+#include <CGAL/Exact_predicates_inexact_constructions_kernel.h>
+#include <CGAL/Exact_predicates_exact_constructions_kernel.h>
+
+typedef CGAL::Simple_cartesian<double> SCd;
+typedef CGAL::Simple_cartesian<CGAL::Exact_rational> SCrat;
+
+typedef CGAL::Simple_cartesian<CGAL::Interval_nt<false>> SCinterval;
+
+template <typename K>
+struct Convert {
+
+    static auto get_type() {
+        if constexpr (K::Has_filtered_predicates_tag::value) {
+            return typename K::Exact_kernel{};
+        }
+        else {
+            return CGAL::Simple_cartesian<CGAL::Exact_rational>{};
+        }
+    }
+
+        using Has = decltype(get_type());
+
+
+   using Exact = std::conditional_t < std::is_floating_point_v<typename K::FT>, Has, CGAL::Simple_cartesian<CGAL::Exact_rational>>;
+
+   typename Exact::Point_2 exact(const typename K::Point_2& p)
+   {
+       if constexpr (typename K::Has_filtered_predicates_tag::value) {
+           std::cout << "Has_filtered_predicates_tag" << std::endl;
+           return typename K::C2E()(p);
+       }
+
+       if constexpr (std::is_floating_point<typename K::FT>::type::value) {
+           std::cout << "is_floating_point but not filtered" << std::endl;
+           return Exact::Point_2(p.x(), p.y());
+       }
+       // We could check if K::FT is an interval and then check that is tight.
+
+       // Otherwise we assume that K::FT converts to Rational
+       return typename Exact::Point_2();
+
+   }
+
+SCinterval::Point_2 approx(const typename K::Point_2& p)
+{
+    std::cout << "___________________\n" << typeid(K).name() << std::endl;
+
+    if constexpr (typename K::Has_filtered_predicates_tag::value) {
+        std::cout << "Has_filtered_predicates_tag" << std::endl;
+        return typename K::C2F()(p);
+    }
+
+    if constexpr (std::is_floating_point<typename K::FT>::type::value) {
+        std::cout << "is_floating_point but not filtered" << std::endl;
+        return SCinterval::Point_2(p.x(), p.y());
+    }
+    // Neither floating point, nor filtered
+    return SCinterval::Point_2(CGAL::to_interval(p.x()), CGAL::to_interval(p.y()));
+
+/*
+    if constexpr (typename K::Has_filtered_predicates_tag::value) {
+        std::cout << "Has_filtered_predicates_tag" << std::endl;
+        std::cout << typeid(typename K::Approximate_kernel).name() << std::endl;
+        std::cout << typeid(typename K::Exact_kernel::FT).name() << std::endl;
+        std::cout << typeid(typename K::C2F).name() << std::endl;
+        std::cout << typeid(typename K::C2E).name() << std::endl;
+    }
+    std::cout << std::endl;
+    */
+}
+
+
+
+};
+
+int main()
+{
+  SCinterval::Point_2 p;
+  p = Convert<SCd>().approx(SCd::Point_2(78,12));
+  p = Convert<SCrat>().approx(SCrat::Point_2(78, 12));
+  p = Convert<CGAL::Epick>().approx(CGAL::Epick::Point_2(78,12));
+  p = Convert<CGAL::Epeck>().approx(CGAL::Epeck::Point_2(78,12));
+
+
+  Convert<SCd>::Exact::Point_2 pd = Convert<SCd>().exact(SCd::Point_2(0.3, 12));
+  Convert<CGAL::Epick>::Exact::Point_2 pepick = Convert<CGAL::Epick>().exact(CGAL::Epick::Point_2(78, 12));
+  return 0;
+}