Add OpenGR wrapper

BGL/include/CGAL/boost/graph/parameters_interface.h

@@ -142,3 +142,8 @@ CGAL_add_named_parameter(proxies_t, proxies, proxies)
 CGAL_add_named_parameter(anchors_t, anchors, anchors)
 CGAL_add_named_parameter(triangles_t, triangles, triangles)
 
+CGAL_add_named_parameter(number_of_samples_t, number_of_samples, number_of_samples)
+CGAL_add_named_parameter(accuracy_t, accuracy, accuracy)
+CGAL_add_named_parameter(maximum_running_time_t, maximum_running_time, maximum_running_time)
+CGAL_add_named_parameter(overlap_t, overlap, overlap)
+

BGL/test/BGL/test_cgal_bgl_named_params.cpp

@@ -187,6 +187,34 @@ void test(const NamedParameters& np)
   check_same_type<42>(get_param(np, CGAL::internal_np::projection_functor));
   check_same_type<46>(get_param(np, CGAL::internal_np::apply_per_connected_component));
   check_same_type<47>(get_param(np, CGAL::internal_np::output_iterator));
+
+  // Named parameters used in the package 'Point Set Processing'
+  check_same_type<9000>(get_param(np, CGAL::internal_np::point_map));
+  check_same_type<9001>(get_param(np, CGAL::internal_np::query_point_map));
+  check_same_type<9002>(get_param(np, CGAL::internal_np::normal_map));
+  check_same_type<9003>(get_param(np, CGAL::internal_np::diagonalize_traits));
+  check_same_type<9004>(get_param(np, CGAL::internal_np::svd_traits));
+  check_same_type<9005>(get_param(np, CGAL::internal_np::callback));
+  check_same_type<9006>(get_param(np, CGAL::internal_np::sharpness_angle));
+  check_same_type<9007>(get_param(np, CGAL::internal_np::edge_sensitivity));
+  check_same_type<9008>(get_param(np, CGAL::internal_np::neighbor_radius));
+  check_same_type<9009>(get_param(np, CGAL::internal_np::number_of_output_points));
+  check_same_type<9010>(get_param(np, CGAL::internal_np::size));
+  check_same_type<9011>(get_param(np, CGAL::internal_np::maximum_variation));
+  check_same_type<9012>(get_param(np, CGAL::internal_np::degree_fitting));
+  check_same_type<9013>(get_param(np, CGAL::internal_np::degree_monge));
+  check_same_type<9014>(get_param(np, CGAL::internal_np::threshold_percent));
+  check_same_type<9015>(get_param(np, CGAL::internal_np::threshold_distance));
+  check_same_type<9016>(get_param(np, CGAL::internal_np::attraction_factor));
+  check_same_type<9017>(get_param(np, CGAL::internal_np::plane_map));
+  check_same_type<9018>(get_param(np, CGAL::internal_np::plane_index_map));
+  check_same_type<9019>(get_param(np, CGAL::internal_np::select_percentage));
+  check_same_type<9020>(get_param(np, CGAL::internal_np::require_uniform_sampling));
+  check_same_type<9021>(get_param(np, CGAL::internal_np::point_is_constrained));
+  check_same_type<9022>(get_param(np, CGAL::internal_np::number_of_samples));
+  check_same_type<9023>(get_param(np, CGAL::internal_np::accuracy));
+  check_same_type<9024>(get_param(np, CGAL::internal_np::maximum_running_time));
+  check_same_type<9025>(get_param(np, CGAL::internal_np::overlap));
 }
 
 int main()
@@ -254,6 +282,32 @@ int main()
                          .erase_all_duplicates(A<48>(48))
                          .require_same_orientation(A<49>(49))
                          .face_size_map(A<52>(52))
+                         .point_map(A<9000>(9000))
+                         .query_point_map(A<9001>(9001))
+                         .normal_map(A<9002>(9002))
+                         .diagonalize_traits(A<9003>(9003))
+                         .svd_traits(A<9004>(9004))
+                         .callback(A<9005>(9005))
+                         .sharpness_angle(A<9006>(9006))
+                         .edge_sensitivity(A<9007>(9007))
+                         .neighbor_radius(A<9008>(9008))
+                         .number_of_output_points(A<9009>(9009))
+                         .size(A<9010>(9010))
+                         .maximum_variation(A<9011>(9011))
+                         .degree_fitting(A<9012>(9012))
+                         .degree_monge(A<9013>(9013))
+                         .threshold_percent(A<9014>(9014))
+                         .threshold_distance(A<9015>(9015))
+                         .attraction_factor(A<9016>(9016))
+                         .plane_map(A<9017>(9017))
+                         .plane_index_map(A<9018>(9018))
+                         .select_percentage(A<9019>(9019))
+                         .require_uniform_sampling(A<9020>(9020))
+                         .point_is_constrained_map(A<9021>(9021))
+                         .number_of_samples(A<9022>(9022))
+                         .accuracy(A<9023>(9023))
+                         .maximum_running_time(A<9024>(9024))
+                         .overlap(A<9025>(9025))
        );
 
   return EXIT_SUCCESS;

Documentation/doc/Documentation/Installation.txt

@@ -535,6 +535,14 @@ and the \ref PkgRidges3Ref packages.
 
 The \sc{Eigen} web site is <A HREF="http://eigen.tuxfamily.org/index.php?title=Main_Page">`http://eigen.tuxfamily.org`</A>.
 
+\subsection thirdpartyOpenGR OpenGR 
+
+\sc{OpenGR} is a is a set C++ libraries for 3D Global Registration released under the terms of the APACHE V2 licence.
+
+\cgal provides wrappers for the Super4PCS algorithm of \sc{OpenGR} in the \ref PkgPointSetProcessing3Ref packages. 
+
+The \sc{OpenGR} web site is <A HREF="https://github.com/STORM-IRIT/OpenGR">`https://github.com/STORM-IRIT/OpenGR`</A>.
+
 \subsection thirdpartyESBTL ESBTL
 
 The \sc{Esbtl} (Easy Structural Biology Template Library) is a library that allows

Documentation/doc/biblio/cgal_manual.bib

@@ -1543,6 +1543,13 @@ @book{ cgal:m-mec-96
   ,update       = "97.04 schoenherr"
 }
 
+@misc{ cgal:m-ogr-17,
+  author = {Nicolas Mellado and others},
+  title = {OpenGR: A C++ library for 3D Global Registration},
+  howpublished = {https://storm-irit.github.io/OpenGR/},
+  year = {2017}
+}
+
 @inproceedings{ cgal:m-pppd-96
   ,author       = "Kurt Mehlhorn"
   ,title        = "Position Paper for Panel Discussion"
@@ -1583,6 +1590,19 @@ @inproceedings{ cgal:mad-fpsep-05
 , booktitle = "Proceeding of IEEE Visualization"
 }
 
+@article {cgal:mam-sffgp-14,
+  author = {Mellado, Nicolas and Aiger, Dror and Mitra, Niloy J.},
+  title = {Super 4PCS Fast Global Pointcloud Registration via Smart Indexing},
+  journal = {Computer Graphics Forum},
+  volume = {33},
+  number = {5},
+  issn = {1467-8659},
+  url = {http://dx.doi.org/10.1111/cgf.12446},
+  doi = {10.1111/cgf.12446},
+  pages = {205--215},
+  year = {2014}
+}
+
 @inproceedings{ cgal:mdsb-ddgot-02,
  author="M. Meyer and M. Desbrun and P. Schr{\"o}der and A. H. Barr",
  title="Discrete Differential-Geometry Operators for Triangulated 2-Manifolds",

Point_set_processing_3/doc/Point_set_processing_3/NamedParameters.txt

@@ -191,6 +191,30 @@ Constrained points are left unaltered and are used as seeds in `mst_orient_norma
 <b>Default value</b>: a property map with only the highest point constrained.
 \cgalNPEnd
 
+\cgalNPBegin{number_of_samples} \anchor PSP_number_of_samples
+is the number of input points used for computation.\n
+\b Type: \c unsigned \c int \n
+<b>Default value</b>: `200`
+\cgalNPEnd
+
+\cgalNPBegin{accuracy} \anchor PSP_accuracy
+is the wanted output accuracy, expressed in scene units.\n
+\b Type: floating scalar value\n
+<b>Default value</b>: `5.00`
+\cgalNPEnd
+
+\cgalNPBegin{overlap} \anchor PSP_overlap
+is the expected overlap ratio (between 0 and 1) between two points sets to register.\n
+\b Type: floating scalar value\n
+<b>Default value</b>: `0.20`
+\cgalNPEnd
+
+\cgalNPBegin{maximum_running_time} \anchor PSP_maximum_running_time
+is the maximum time (in seconds) allowed to the function before ending and returning the best solution found so far.\n
+\b Type: floating scalar value\n
+<b>Default value</b>: `1000`
+\cgalNPEnd
+
 \cgalNPTableEnd
 
 */

Point_set_processing_3/doc/Point_set_processing_3/PackageDescription.txt

@@ -51,10 +51,12 @@ format.
 - `CGAL::estimate_global_range_scale()`
 - `CGAL::estimate_local_k_neighbor_scales()`
 - `CGAL::estimate_local_range_scales()`
+- `CGAL::OpenGR::compute_registration_transformation()`
+- `CGAL::OpenGR::register_point_sets()`
 - `CGAL::remove_outliers()`
 - `CGAL::grid_simplify_point_set()`
 - `CGAL::random_simplify_point_set()`
-- `CGAL::hierarchy_simplify_point_set()`	
+- `CGAL::hierarchy_simplify_point_set()`
 - `CGAL::wlop_simplify_and_regularize_point_set()`
 - `CGAL::jet_smooth_point_set()`
 - `CGAL::bilateral_smooth_point_set()`

Point_set_processing_3/doc/Point_set_processing_3/Point_set_processing_3.txt

@@ -314,7 +314,24 @@ points in the domain.
 
 \cgalExample{Point_set_processing_3/scale_estimation_2d_example.cpp}
 
+\section Point_set_processing_3Registration Registration
 
+\cgal provides two wrappers for the \ref thirdpartyOpenGR library
+\cgalCite{cgal:m-ogr-17} :
+
+- `CGAL::OpenGR::compute_registration_transformation()` computes the
+registration of one point set w.r.t. another in the form of a
+`CGAL::Aff_transformation_3` object, using the Super4PCS algorithm
+\cgalCite{cgal:mam-sffgp-14};
+
+- `CGAL::OpenGR::register_point_sets()` computes the registration of
+one point set w.r.t. another and directly aligns it to it.
+
+\subsection Point_set_processing_3Example_registration Example
+
+The following example reads two point sets and aligns them using the
+\ref thirdpartyOpenGR library:
+\cgalExample{Point_set_processing_3/registration_with_OpenGR.cpp}
 
 \section Point_set_processing_3OutlierRemoval Outlier Removal
 

Point_set_processing_3/doc/Point_set_processing_3/examples.txt

@@ -6,6 +6,7 @@
 \example Point_set_processing_3/average_spacing_example.cpp
 \example Point_set_processing_3/scale_estimation_example.cpp
 \example Point_set_processing_3/scale_estimation_2d_example.cpp
+\example Point_set_processing_3/registration_with_OpenGR.cpp
 \example Point_set_processing_3/remove_outliers_example.cpp
 \example Point_set_processing_3/grid_simplification_example.cpp
 \example Point_set_processing_3/grid_simplify_indices.cpp

Point_set_processing_3/examples/Point_set_processing_3/CMakeLists.txt

@@ -78,6 +78,16 @@ if ( CGAL_FOUND )
     create_single_source_cgal_program( "jet_smoothing_example.cpp" )
     create_single_source_cgal_program( "normal_estimation.cpp" )
     create_single_source_cgal_program( "edges_example.cpp" )
+
+    # Executables that require OpenGR
+    find_package(OpenGR)
+    if (OpenGR_FOUND)
+      include_directories(SYSTEM ${OpenGR_INCLUDE_DIR})
+      create_single_source_cgal_program( "registration_with_OpenGR.cpp" )
+    else()
+      message(STATUS "NOTICE: registration_with_OpenGR requires OpenGR, and will not be compiled.")
+    endif()
+
   else()
 
     message(STATUS "NOTICE: Some of the executables in this directory need Eigen 3.1 (or greater) and will not be compiled.")