Add Float 2d snap rounding

Arrangement_on_surface_2/include/CGAL/Arr_segment_traits_2.h

@@ -728,6 +728,11 @@ class Arr_segment_traits_2 : public Kernel_ {
       // Check if we have a single intersection point.
       const Point_2* ip = std::get_if<Point_2>(&*res);
       if (ip != nullptr) {
+        if(!(cv1.is_vertical() ?
+                       m_traits.is_in_y_range_2_object()(cv1, *ip) :
+                       m_traits.is_in_x_range_2_object()(cv1, *ip))){
+                        std::cout << cv1 << std::endl;
+                       }
         CGAL_assertion(cv1.is_vertical() ?
                        m_traits.is_in_y_range_2_object()(cv1, *ip) :
                        m_traits.is_in_x_range_2_object()(cv1, *ip));

STL_Extension/include/CGAL/STL_Extension/internal/parameters_interface.h

@@ -406,6 +406,9 @@ CGAL_add_named_parameter(do_not_modify_geometry_t, do_not_modify_geometry, do_no
 CGAL_add_named_parameter_with_compatibility_ref_only(angles_param_t, angles_param, angles)
 CGAL_add_named_parameter(maximum_height_t, maximum_height, maximum_height)
 
+//List of named parameters used in Snap_rounding_2
+CGAL_add_named_parameter(compute_intersection_t, compute_intersection, compute_intersection)
+
 // List of named parameters used in the package 'Constrained_triangulation_3'
 CGAL_add_named_parameter(plc_face_id_t, plc_face_id, plc_face_id)
 CGAL_add_named_parameter(with_plc_face_id_t, with_plc_face_id, with_plc_face_id)

Snap_rounding_2/doc/Snap_rounding_2/Concepts/FloatSnapRoundingTraits_2.h

@@ -0,0 +1,228 @@
+
+/*!
+\ingroup PkgSnapRounding2Concepts
+\cgalConcept
+
+The concept `FloatSnapRoundingTraits_2` lists the set of requirements that must be fulfilled by
+an instance of the `Traits` template-parameter of
+the free functions of TODO.
+The list includes the nested types of the geometric primitives used in this class and
+some function object types for the required predicates on those primitives.
+
+\cgalRefines{AosTraits_2}
+
+\cgalHasModelsBegin
+\cgalHasModels{CGAL::Float_snap_rounding_traits_2<Kernel>}
+\cgalHasModelsEnd
+*/
+
+class FloatSnapRoundingTraits_2 {
+public:
+
+/// \name Types
+/// @{
+
+/*!
+The number type. This type must fulfill the requirements on
+`FieldNumberType`
+*/
+typedef unspecified_type FT;
+
+/*!
+Models the concept `ArrTraits::Point_2`.
+*/
+typedef unspecified_type Point_2;
+
+/*!
+Models the concept `ArrTraits::XMonotoneCurve_2`.
+*/
+typedef unspecified_type Segment_2;
+
+/// @}
+
+/// \name Functor Types
+/// @{
+
+/*!
+Models the concept `Kernel::ConstructSource_2`.
+*/
+typedef unspecified_type Construct_source_2;
+
+/*!
+Models the concept `Kernel::ConstructTarget_2`.
+*/
+typedef unspecified_type Construct_target_2;
+
+/*!
+Models the concept `Kernel::ConstructSegment_2`.
+*/
+typedef unspecified_type Construct_segment_2;
+
+/*!
+Models the concept `Kernel::LessXY_2`.
+*/
+typedef unspecified_type Less_xy_2;
+
+/*!
+Models the concept `Kernel::LessY_2`.
+*/
+typedef unspecified_type Less_y_2;
+
+/*!
+Models the concept `Kernel::Equal_2`.
+*/
+typedef unspecified_type Equal_2;
+
+/*!
+Models the concept `FSRTraits_2::ConstructRoundPoint_2`.
+*/
+typedef unspecified_type Construct_round_point_2;
+
+/*!
+Models the concept `FSRTraits_2::SquaredRoundBound_2`.
+*/
+typedef unspecified_type Squared_round_bound_2;
+
+/*!
+Models the concept `FSRTraits_2::ConverterToExact`.
+*/
+typedef unspecified_type Converter_to_exact;
+
+/*!
+Models the concept `FSRTraits_2::ConverterFromExact`.
+*/
+typedef unspecified_type Converter_from_exact;
+
+/// @}
+
+/// \name Accessing Functor Objects
+/// @{
+
+/*!
+
+*/
+Construct_source_2 construct_source_2_object();
+
+/*!
+
+*/
+Construct_target_2 construct_target_2_object();
+
+/*!
+
+*/
+Construct_segment_2 construct_segment_2_object();
+
+/*!
+
+*/
+Less_xy_2 less_xy_2_object();
+
+/*!
+
+*/
+Less_y_2 less_y_2_object();
+
+/*!
+
+*/
+Construct_round_point_2 construct_round_point_2_object();
+
+/*!
+
+*/
+Squared_round_bound_2 squared_round_bound_2_object();
+
+/*!
+
+*/
+Converter_to_exact converter_to_exact_object();
+
+/*!
+
+*/
+Converter_from_exact converter_from_exact_object();
+
+
+/// @}
+
+}; /* end FloatSnapRoundingTraits_2 */
+
+
+namespace FSRTraits_2{
+
+/*!
+  \ingroup PkgSnapRounding2Concepts
+  \cgalConcept
+  \cgalHasModelsBegin
+  \cgalHasModelsBare{\link FloatSnapRoundingTraits_2::Construct_round_point_2 `Float_snap_rounding_traits_2::Construct_round_point_2` \endlink}
+  \cgalHasModelsEnd
+*/
+class ConstructRoundPoint_2
+{
+  public:
+
+  /*!
+  Given a point, construct its rounded version
+  */
+  Point_2 operator()(Point_2 p);
+};
+
+/*!
+  \ingroup PkgSnapRounding2Concepts
+  \cgalConcept
+  \cgalHasModelsBegin
+  \cgalHasModelsBare{\link FloatSnapRoundingTraits_2::Squared_round_bound_2 `Float_snap_rounding_traits_2::Squared_round_bound_2` \endlink}
+  \cgalHasModelsEnd
+*/
+class SquaredRoundBound_2
+{
+  public:
+
+  /*!
+  Given a point, compute an upper bound of the squared distance between its exact coordinates and its rounded coordinates
+  */
+  double operator()(Point_2 p);
+};
+
+/*!
+  \ingroup PkgSnapRounding2Concepts
+  \cgalConcept
+  \cgalHasModelsBegin
+  \cgalHasModelsBare{\link FloatSnapRoundingTraits_2::Converter_to_exact `Float_snap_rounding_traits_2::Convertex_to_exact` \endlink}
+  \cgalHasModelsEnd
+*/
+class ConverterToExact
+{
+  public:
+  typedef unspecified_type InputPoint_2;
+  typedef unspecified_type InputSegment_2;
+  /*!
+  Convert input points (i.e. segments) into points (i.e. segments) of the type of the traits
+  */
+  Point_2 operator()(InputPoint_2 p);
+  Segment_2 operator()(InputSegment_2 p);
+};
+
+/*!
+  \ingroup PkgSnapRounding2Concepts
+  \cgalConcept
+  \cgalHasModelsBegin
+  \cgalHasModelsBare{\link FloatSnapRoundingTraits_2::Converter_from_exact `Float_snap_rounding_traits_2::Convertex_to_exact` \endlink}
+  \cgalHasModelsEnd
+*/
+class ConverterFromExact
+{
+  public:
+  typedef unspecified_type OutputPoint_2;
+  typedef unspecified_type OutputSegment_2;
+  /*!
+  Convert points (i.e. segments) of the type of the traits into points (i.e. segments) of the output
+  */
+  OutputPoint_2 operator()(Point_2 p);
+  OutputSegment_2 operator()(Segment_2 p);
+};
+
+
+
+} /* end of namespace SRTraits_2 */

Snap_rounding_2/doc/Snap_rounding_2/Doxyfile.in

@@ -1,3 +1,11 @@
 @INCLUDE = ${CGAL_DOC_PACKAGE_DEFAULTS}
 
 PROJECT_NAME = "CGAL ${CGAL_DOC_VERSION} - 2D Snap Rounding"
+
+# custom options for this package
+HIDE_UNDOC_CLASSES         =  true
+WARN_IF_UNDOCUMENTED       =  false
+
+
+INPUT += ${CGAL_PACKAGE_INCLUDE_DIR}/CGAL/Float_snap_rounding_2.h \
+         ${CGAL_PACKAGE_INCLUDE_DIR}/CGAL/Float_snap_rounding_traits_2.h

Snap_rounding_2/examples/Snap_rounding_2/CMakeLists.txt

@@ -14,3 +14,11 @@ file(
 foreach(cppfile ${cppfiles})
   create_single_source_cgal_program("${cppfile}")
 endforeach()
+
+find_package(TBB QUIET)
+include(CGAL_TBB_support)
+if(TARGET CGAL::TBB_support)
+  target_link_libraries(float_snap_rounding PRIVATE CGAL::TBB_support)
+else()
+  message(STATUS "NOTICE: Intel TBB was not found. Sequential code will be used.")
+endif()

Snap_rounding_2/examples/Snap_rounding_2/float_snap_rounding.cpp

@@ -0,0 +1,68 @@
+#include <CGAL/Exact_predicates_exact_constructions_kernel.h>
+#include <CGAL/Exact_predicates_inexact_constructions_kernel.h>
+#include <CGAL/Float_snap_rounding_2.h>
+#include <CGAL/Arr_segment_traits_2.h>
+#include <CGAL/Random.h>
+
+typedef CGAL::Exact_predicates_exact_constructions_kernel       Kernel;
+typedef CGAL::Exact_predicates_inexact_constructions_kernel     Epick;
+typedef Kernel::Segment_2                                       Segment_2;
+typedef Kernel::Point_2                                         Point_2;
+typedef Kernel::FT                                              FT;
+typedef std::vector<Point_2 >                                   Polyline_2;
+
+int main(int argc, char *argv[])
+{
+  std::vector< Segment_2 > segs;
+
+  if(argc>1){
+    std::cout << "Read segments in " << argv[1] << std::endl;
+    std::ifstream in(argv[1]);
+
+    int n;
+    in >> n;
+    segs.reserve(n);
+    for (int i=0; i<n; ++i)
+    {
+      double x1,x2,y1,y2;
+      in >> x1 >> y1 >> x2 >> y2;
+      if(Point_2(x1,y1)!=Point_2(x2,y2))
+        segs.emplace_back(Point_2(x1, y1), Point_2(x2, y2));
+    }
+  } else {
+    //Example with a non-trivial rounding
+    FT e(std::pow(2, -60));
+
+    segs.emplace_back(Point_2(1-e, 1), Point_2(-1-e, -1+2*e));
+    segs.emplace_back(Point_2(e/2, e/2), Point_2(1, -1));
+    segs.emplace_back(Point_2(0, 2-e/2), Point_2(2, 0));
+    segs.emplace_back(Point_2(0, 2-e/2), Point_2(-2+e, -4));
+    segs.emplace_back(Point_2(-2, 2), Point_2(2, 2));
+    segs.emplace_back(Point_2(7, 7), Point_2(7+e, 7+e));
+    segs.emplace_back(Point_2(5, 7-e), Point_2(9, 7-e));
+  }
+
+  std::cout << "Computes the intersections and snaps the segments" << std::endl;
+  std::vector< Segment_2> out;
+  CGAL::compute_snapped_subcurves_2(segs.begin(), segs.end(), std::back_inserter(out));
+  std::cout << "Does the output intersect: " << CGAL::do_curves_intersect(out.begin(), out.end()) << std::endl;
+  std::cout << "Size of the output: " << out.size() << std::endl;
+
+  std::string out_path=(argc>2)?argv[2]:"out.segs";
+  std::cout << "Write the outputs in " << out_path << std::endl;
+  std::ofstream outf(out_path);
+  CGAL::Random r;
+
+  outf << std::setprecision(17);
+  outf << out.size() << std::endl;
+  for (auto &seg: out)
+  {
+    double x1 = CGAL::to_double(seg.source().x());
+    double y1 = CGAL::to_double(seg.source().y());
+    double x2 = CGAL::to_double(seg.target().x());
+    double y2 = CGAL::to_double(seg.target().y());
+    outf << x1 << " " << y1 << " " << x2 << " " << y2 << std::endl;
+  }
+
+  return 0;
+}