From 86634b3c17f1bd16e895c7820fa1ce002a8b24fc Mon Sep 17 00:00:00 2001 From: Simon Giraudot Date: Tue, 5 Dec 2017 10:05:16 +0100 Subject: [PATCH] Use new API of PSP with named parameters in include+example --- .../bilateral_smooth_point_set_example.cpp | 11 +- .../grid_simplification_example.cpp | 2 +- .../grid_simplify_indices.cpp | 9 +- .../hierarchy_simplification_example.cpp | 6 +- .../jet_smoothing_example.cpp | 2 +- .../normal_estimation.cpp | 26 +- .../random_simplification_example.cpp | 2 +- .../remove_outliers_example.cpp | 23 +- .../scale_estimation_2d_example.cpp | 4 +- .../scale_estimation_example.cpp | 4 +- .../structuring_example.cpp | 10 +- ...plify_and_regularize_point_set_example.cpp | 12 +- .../include/CGAL/bilateral_smooth_point_set.h | 136 ++-- .../include/CGAL/compute_average_spacing.h | 18 +- .../CGAL/edge_aware_upsample_point_set.h | 190 +++--- .../include/CGAL/estimate_scale.h | 583 ++++++++++++------ .../include/CGAL/grid_simplify_point_set.h | 156 +++-- .../CGAL/hierarchy_simplify_point_set.h | 168 +++-- .../include/CGAL/jet_estimate_normals.h | 188 ++++-- .../include/CGAL/jet_smooth_point_set.h | 172 ++++-- .../include/CGAL/mst_orient_normals.h | 286 +++++---- .../include/CGAL/pca_estimate_normals.h | 151 +++-- .../CGAL/point_set_processing_assertions.h | 2 +- .../include/CGAL/random_simplify_point_set.h | 86 ++- .../include/CGAL/remove_outliers.h | 140 +++-- .../include/CGAL/structure_point_set.h | 120 +++- .../include/CGAL/vcm_estimate_normals.h | 284 ++++++--- .../wlop_simplify_and_regularize_point_set.h | 203 +++--- 28 files changed, 1997 insertions(+), 997 deletions(-) diff --git a/Point_set_processing_3/examples/Point_set_processing_3/bilateral_smooth_point_set_example.cpp b/Point_set_processing_3/examples/Point_set_processing_3/bilateral_smooth_point_set_example.cpp index c37e22fe0a0..5a13326b7ba 100644 --- a/Point_set_processing_3/examples/Point_set_processing_3/bilateral_smooth_point_set_example.cpp +++ b/Point_set_processing_3/examples/Point_set_processing_3/bilateral_smooth_point_set_example.cpp @@ -53,12 +53,11 @@ int main(int argc, char*argv[]) { /* double error = */ CGAL::bilateral_smooth_point_set ( - points.begin(), - points.end(), - CGAL::First_of_pair_property_map(), - CGAL::Second_of_pair_property_map(), - k, - sharpness_angle); + points, + k, + sharpness_angle, + CGAL::parameters::point_map(CGAL::First_of_pair_property_map()). + normal_map(CGAL::Second_of_pair_property_map())); } //// Save point set. diff --git a/Point_set_processing_3/examples/Point_set_processing_3/grid_simplification_example.cpp b/Point_set_processing_3/examples/Point_set_processing_3/grid_simplification_example.cpp index 47b7584d34e..f2474710457 100644 --- a/Point_set_processing_3/examples/Point_set_processing_3/grid_simplification_example.cpp +++ b/Point_set_processing_3/examples/Point_set_processing_3/grid_simplification_example.cpp @@ -24,7 +24,7 @@ int main(int argc, char*argv[]) // simplification by clustering using erase-remove idiom double cell_size = 0.001; - points.erase(CGAL::grid_simplify_point_set(points.begin(), points.end(), cell_size), + points.erase(CGAL::grid_simplify_point_set(points, cell_size), points.end()); // Optional: after erase(), use Scott Meyer's "swap trick" to trim excess capacity diff --git a/Point_set_processing_3/examples/Point_set_processing_3/grid_simplify_indices.cpp b/Point_set_processing_3/examples/Point_set_processing_3/grid_simplify_indices.cpp index c376956d38c..3b3023edd3c 100644 --- a/Point_set_processing_3/examples/Point_set_processing_3/grid_simplify_indices.cpp +++ b/Point_set_processing_3/examples/Point_set_processing_3/grid_simplify_indices.cpp @@ -33,14 +33,13 @@ int main(int argc, char*argv[]) // simplification by clustering using erase-remove idiom double cell_size = 0.05; std::vector::iterator end; - end = CGAL::grid_simplify_point_set(indices.begin(), - indices.end(), - CGAL::make_property_map(points), - cell_size); + end = CGAL::grid_simplify_point_set(indices, + cell_size, + CGAL::parameters::point_map (CGAL::make_property_map(points))); std::size_t k = end - indices.begin(); - std::cerr << "Keep " << k << " of " << indices.size() << "indices" << std::endl; + std::cerr << "Keep " << k << " of " << indices.size() << " indices" << std::endl; { std::vector tmp_points(k); diff --git a/Point_set_processing_3/examples/Point_set_processing_3/hierarchy_simplification_example.cpp b/Point_set_processing_3/examples/Point_set_processing_3/hierarchy_simplification_example.cpp index beb2bb77fa4..41d011e4941 100644 --- a/Point_set_processing_3/examples/Point_set_processing_3/hierarchy_simplification_example.cpp +++ b/Point_set_processing_3/examples/Point_set_processing_3/hierarchy_simplification_example.cpp @@ -29,9 +29,9 @@ int main(int argc, char*argv[]) CGAL::Timer task_timer; task_timer.start(); // simplification by clustering using erase-remove idiom - points.erase (CGAL::hierarchy_simplify_point_set (points.begin (), points.end (), - 100, // Max cluster size - 0.01), // Max surface variation + points.erase (CGAL::hierarchy_simplify_point_set (points, + CGAL::parameters::size(100). // Max cluster size + maximum_variation(0.01)), // Max surface variation points.end ()); std::size_t memory = CGAL::Memory_sizer().virtual_size(); diff --git a/Point_set_processing_3/examples/Point_set_processing_3/jet_smoothing_example.cpp b/Point_set_processing_3/examples/Point_set_processing_3/jet_smoothing_example.cpp index eb50153d78c..f228c8d69f6 100644 --- a/Point_set_processing_3/examples/Point_set_processing_3/jet_smoothing_example.cpp +++ b/Point_set_processing_3/examples/Point_set_processing_3/jet_smoothing_example.cpp @@ -31,7 +31,7 @@ int main(void) // Smoothing. const unsigned int nb_neighbors = 8; // default is 24 for real-life point sets - CGAL::jet_smooth_point_set(points.begin(), points.end(), nb_neighbors); + CGAL::jet_smooth_point_set(points, nb_neighbors); return EXIT_SUCCESS; } diff --git a/Point_set_processing_3/examples/Point_set_processing_3/normal_estimation.cpp b/Point_set_processing_3/examples/Point_set_processing_3/normal_estimation.cpp index 886f10fe70c..94266adeb6c 100644 --- a/Point_set_processing_3/examples/Point_set_processing_3/normal_estimation.cpp +++ b/Point_set_processing_3/examples/Point_set_processing_3/normal_estimation.cpp @@ -92,10 +92,12 @@ void run_jet_estimate_normals(PointList& points, // input points + output normal // Estimates normals direction. // Note: jet_estimate_normals() requires an iterator over points // + property maps to access each point's position and normal. - CGAL::jet_estimate_normals(points.begin(), points.end(), - CGAL::First_of_pair_property_map(), - CGAL::Second_of_pair_property_map(), - nb_neighbors_jet_fitting_normals); + CGAL::jet_estimate_normals + (points, + nb_neighbors_jet_fitting_normals, + CGAL::parameters::point_map (CGAL::First_of_pair_property_map()). + normal_map (CGAL::Second_of_pair_property_map())); + std::size_t memory = CGAL::Memory_sizer().virtual_size(); std::cerr << "done: " << task_timer.time() << " seconds, " @@ -114,11 +116,9 @@ void run_vcm_estimate_normals(PointList &points, // input points + output normal // Estimates normals direction. // Note: vcm_estimate_normals() requires an iterator over points // + property maps to access each point's position and normal. - CGAL::vcm_estimate_normals(points.begin(), points.end(), - CGAL::First_of_pair_property_map(), - CGAL::Second_of_pair_property_map(), - R, - r); + CGAL::vcm_estimate_normals(points, R, r, + CGAL::parameters::point_map(CGAL::First_of_pair_property_map()). + normal_map(CGAL::Second_of_pair_property_map())); std::size_t memory = CGAL::Memory_sizer().virtual_size(); std::cerr << "done: " << task_timer.time() << " seconds, " @@ -138,10 +138,10 @@ void run_mst_orient_normals(PointList& points, // input points + input/output no // Note: mst_orient_normals() requires an iterator over points // as well as property maps to access each point's position and normal. PointList::iterator unoriented_points_begin = - CGAL::mst_orient_normals(points.begin(), points.end(), - CGAL::First_of_pair_property_map(), - CGAL::Second_of_pair_property_map(), - nb_neighbors_mst); + CGAL::mst_orient_normals(points, + nb_neighbors_mst, + CGAL::parameters::point_map(CGAL::First_of_pair_property_map()). + normal_map(CGAL::Second_of_pair_property_map())); // Optional: delete points with an unoriented normal // if you plan to call a reconstruction algorithm that expects oriented normals. diff --git a/Point_set_processing_3/examples/Point_set_processing_3/random_simplification_example.cpp b/Point_set_processing_3/examples/Point_set_processing_3/random_simplification_example.cpp index 7b2f3e2b494..d2822fc32f9 100644 --- a/Point_set_processing_3/examples/Point_set_processing_3/random_simplification_example.cpp +++ b/Point_set_processing_3/examples/Point_set_processing_3/random_simplification_example.cpp @@ -26,7 +26,7 @@ int main(int argc, char*argv[]) // Randomly simplifies using erase-remove idiom const double removed_percentage = 97.0; // percentage of points to remove - points.erase(CGAL::random_simplify_point_set(points.begin(), points.end(), removed_percentage), + points.erase(CGAL::random_simplify_point_set(points, removed_percentage), points.end()); // Optional: after erase(), use Scott Meyer's "swap trick" to trim excess capacity diff --git a/Point_set_processing_3/examples/Point_set_processing_3/remove_outliers_example.cpp b/Point_set_processing_3/examples/Point_set_processing_3/remove_outliers_example.cpp index e122debcc71..a3457acade5 100644 --- a/Point_set_processing_3/examples/Point_set_processing_3/remove_outliers_example.cpp +++ b/Point_set_processing_3/examples/Point_set_processing_3/remove_outliers_example.cpp @@ -33,18 +33,17 @@ int main(int argc, char*argv[]) // Estimate scale of the point set with average spacing const double average_spacing = CGAL::compute_average_spacing - (points.begin(), points.end(), nb_neighbors); + (points, nb_neighbors); ////////////////// // FIRST OPTION // // I don't know the ratio of outliers present in the point set std::vector::iterator first_to_remove - = CGAL::remove_outliers(points.begin(), points.end(), - CGAL::Identity_property_map(), - nb_neighbors, - 100., // No limit on the number of outliers to remove - 2. * average_spacing); // Point with distance above 2*average_spacing are considered outliers - + = CGAL::remove_outliers + (points, + nb_neighbors, + CGAL::parameters::threshold_percent (100.). // No limit on the number of outliers to remove + threshold_distance (2. * average_spacing)); // Point with distance above 2*average_spacing are considered outliers std::cerr << (100. * std::distance(first_to_remove, points.end()) / (double)(points.size())) << "% of the points are considered outliers when using a distance threshold of " @@ -56,11 +55,11 @@ int main(int argc, char*argv[]) // I know the ratio of outliers present in the point set const double removed_percentage = 5.0; // percentage of points to remove - points.erase(CGAL::remove_outliers(points.begin(), points.end(), - CGAL::Identity_property_map(), - nb_neighbors, - removed_percentage, // Minimum percentage to remove - 0.), // No distance threshold (can be omitted) + points.erase(CGAL::remove_outliers + (points, + nb_neighbors, + CGAL::parameters::threshold_percent(removed_percentage). // Minimum percentage to remove + threshold_distance(0.)), // No distance threshold (can be omitted) points.end()); // Optional: after erase(), use Scott Meyer's "swap trick" to trim excess capacity diff --git a/Point_set_processing_3/examples/Point_set_processing_3/scale_estimation_2d_example.cpp b/Point_set_processing_3/examples/Point_set_processing_3/scale_estimation_2d_example.cpp index 9f1599eb2a7..afc3bc5521b 100644 --- a/Point_set_processing_3/examples/Point_set_processing_3/scale_estimation_2d_example.cpp +++ b/Point_set_processing_3/examples/Point_set_processing_3/scale_estimation_2d_example.cpp @@ -37,8 +37,8 @@ int main (int, char**) queries.push_back (Point_2 (1., 0.)); std::vector k_scales; - CGAL::estimate_local_k_neighbor_scales (samples.begin(), samples.end(), - queries.begin(), queries.end(), + CGAL::estimate_local_k_neighbor_scales (samples, + queries, std::back_inserter (k_scales)); // Display results diff --git a/Point_set_processing_3/examples/Point_set_processing_3/scale_estimation_example.cpp b/Point_set_processing_3/examples/Point_set_processing_3/scale_estimation_example.cpp index bac9900fecf..426b72fe38b 100644 --- a/Point_set_processing_3/examples/Point_set_processing_3/scale_estimation_example.cpp +++ b/Point_set_processing_3/examples/Point_set_processing_3/scale_estimation_example.cpp @@ -44,7 +44,7 @@ int main (int argc, char** argv) // estimate k scale task_timer.start(); - std::size_t k_scale = CGAL::estimate_global_k_neighbor_scale (points.begin(), points.end()); + std::size_t k_scale = CGAL::estimate_global_k_neighbor_scale (points); task_timer.stop(); // Example: use estimated k as scale for jet smoothing @@ -54,7 +54,7 @@ int main (int argc, char** argv) // estimate range scale task_timer.start(); - FT range_scale = CGAL::estimate_global_range_scale (points.begin(), points.end()); + FT range_scale = CGAL::estimate_global_range_scale (points); task_timer.stop(); // Example: use estimated range for grid simplification diff --git a/Point_set_processing_3/examples/Point_set_processing_3/structuring_example.cpp b/Point_set_processing_3/examples/Point_set_processing_3/structuring_example.cpp index 3cb5347a866..02f9b7d43d2 100644 --- a/Point_set_processing_3/examples/Point_set_processing_3/structuring_example.cpp +++ b/Point_set_processing_3/examples/Point_set_processing_3/structuring_example.cpp @@ -55,12 +55,14 @@ int main (int argc, char** argv) Pwn_vector structured_pts; - CGAL::structure_point_set (points, Point_map(), Normal_map(), + CGAL::structure_point_set (points, planes, - CGAL::Shape_detection_3::Plane_map(), - CGAL::Shape_detection_3::Point_to_shape_index_map(points, planes), std::back_inserter (structured_pts), - 0.015); // epsilon for structuring points + 0.015, // epsilon for structuring points + CGAL::parameters::point_map (Point_map()). + normal_map (Normal_map()). + plane_map (CGAL::Shape_detection_3::Plane_map()). + plane_index_map (CGAL::Shape_detection_3::Point_to_shape_index_map(points, planes))); std::cerr << structured_pts.size () << " structured point(s) generated." << std::endl; diff --git a/Point_set_processing_3/examples/Point_set_processing_3/wlop_simplify_and_regularize_point_set_example.cpp b/Point_set_processing_3/examples/Point_set_processing_3/wlop_simplify_and_regularize_point_set_example.cpp index 2375ec6c3b1..20884f15f8d 100644 --- a/Point_set_processing_3/examples/Point_set_processing_3/wlop_simplify_and_regularize_point_set_example.cpp +++ b/Point_set_processing_3/examples/Point_set_processing_3/wlop_simplify_and_regularize_point_set_example.cpp @@ -40,14 +40,10 @@ int main(int argc, char** argv) const double retain_percentage = 2; // percentage of points to retain. const double neighbor_radius = 0.5; // neighbors size. - CGAL::wlop_simplify_and_regularize_point_set - - (points.begin(), - points.end(), - std::back_inserter(output), - retain_percentage, - neighbor_radius - ); + CGAL::wlop_simplify_and_regularize_point_set + (points, std::back_inserter(output), + CGAL::parameters::select_percentage(retain_percentage). + neighbor_radius (neighbor_radius)); std::ofstream out(output_filename); if (!out || !CGAL::write_xyz_points( diff --git a/Point_set_processing_3/include/CGAL/bilateral_smooth_point_set.h b/Point_set_processing_3/include/CGAL/bilateral_smooth_point_set.h index 580b3d10eea..72d10e5add9 100644 --- a/Point_set_processing_3/include/CGAL/bilateral_smooth_point_set.h +++ b/Point_set_processing_3/include/CGAL/bilateral_smooth_point_set.h @@ -31,6 +31,9 @@ #include #include +#include +#include + #include #include #include @@ -380,18 +383,18 @@ public: /// \pre Normals must be unit vectors /// \pre k >= 2 /// -/// @tparam Concurrency_tag enables sequential versus parallel algorithm. +/// @tparam ConcurrencyTag enables sequential versus parallel algorithm. /// Possible values are `Sequential_tag` /// and `Parallel_tag`. /// @tparam ForwardIterator iterator over input points. -/// @tparam PointPMap is a model of `ReadWritePropertyMap` +/// @tparam PointMap is a model of `ReadWritePropertyMap` /// with the value type of `ForwardIterator` as key and `Kernel::Point_3` as value type. /// It can be omitted if the value type of `ForwardIterator` is convertible to /// `Kernel::Point_3`. -/// @tparam NormalPMap is a model of `ReadWritePropertyMap` with the value type of `ForwardIterator` as key +/// @tparam NormalMap is a model of `ReadWritePropertyMap` with the value type of `ForwardIterator` as key /// and `Kernel::Vector_3` as value type. /// @tparam Kernel Geometric traits class. -/// It can be omitted and deduced automatically from the value type of `PointPMap` +/// It can be omitted and deduced automatically from the value type of `PointMap` /// using `Kernel_traits`. /// /// @return Average point movement error. It's a convergence criterium for the algorithm. @@ -399,30 +402,35 @@ public: /// sufficient. // This variant requires all parameters. -template +template double bilateral_smooth_point_set( - ForwardIterator first, ///< forward iterator on the first input point. - ForwardIterator beyond, ///< past-the-end iterator. - PointPMap point_pmap, ///< point property map. - NormalPMap normal_pmap, ///< normal property map. + PointRange& points, unsigned int k, ///< size of the neighborhood for the implicit surface patch fitting. ///< The larger the value is, the smoother the result will be. - typename Kernel::FT sharpness_angle, ///< controls the sharpness of the result. + double sharpness_angle, ///< controls the sharpness of the result. ///< The larger the value is, the smoother the result will be. ///< The range of possible value is [0, 90]. - const Kernel& /*kernel*/) ///< geometric traits. + const NamedParameters& np) { + using boost::choose_param; + // basic geometric types + typedef typename Point_set_processing_3::GetPointMap::type PointMap; + typedef typename Point_set_processing_3::GetNormalMap::type NormalMap; + typedef typename Point_set_processing_3::GetK::Kernel Kernel; + + CGAL_static_assertion_msg(!(boost::is_same::NoMap>::value), + "Error: no normal map"); + typedef typename CGAL::Point_with_normal_3 Pwn; typedef typename std::vector > Pwns; typedef typename Kernel::FT FT; - CGAL_point_set_processing_precondition(first != beyond); + CGAL_point_set_processing_precondition(points.begin() != points.end()); CGAL_point_set_processing_precondition(k > 1); // types for K nearest neighbors search structure @@ -432,12 +440,15 @@ bilateral_smooth_point_set( typedef CGAL::Orthogonal_k_neighbor_search Neighbor_search; typedef typename Neighbor_search::Tree Tree; + PointMap point_map = choose_param(get_param(np, internal_np::point_map), PointMap()); + NormalMap normal_map = choose_param(get_param(np, internal_np::normal_map), NormalMap()); + // copy points and normals Pwns pwns; - for(ForwardIterator it = first; it != beyond; ++it) + for(typename PointRange::iterator it = points.begin(); it != points.end(); ++it) { - typename boost::property_traits::reference p = get(point_pmap, *it); - typename boost::property_traits::reference n = get(normal_pmap, *it); + typename boost::property_traits::reference p = get(point_map, *it); + typename boost::property_traits::reference n = get(normal_map, *it); CGAL_point_set_processing_precondition(n.squared_length() > 1e-10); pwns.push_back(Pwn(p, n)); @@ -492,10 +503,10 @@ bilateral_smooth_point_set( pwns_neighbors.resize(nb_points); #ifndef CGAL_LINKED_WITH_TBB - CGAL_static_assertion_msg (!(boost::is_convertible::value), + CGAL_static_assertion_msg (!(boost::is_convertible::value), "Parallel_tag is enabled but TBB is unavailable."); #else - if (boost::is_convertible::value) + if (boost::is_convertible::value) { Compute_pwns_neighbors f(k, tree, pwns, pwns_neighbors); tbb::parallel_for(tbb::blocked_range(0, nb_points), f); @@ -527,7 +538,7 @@ bilateral_smooth_point_set( Pwns update_pwns(nb_points); #ifdef CGAL_LINKED_WITH_TBB - if(boost::is_convertible::value) + if(boost::is_convertible::value) { //tbb::task_scheduler_init init(4); tbb::blocked_range block(0, nb_points); @@ -564,67 +575,90 @@ bilateral_smooth_point_set( #endif // save results FT sum_move_error = 0; - ForwardIterator it = first; - for(unsigned int i = 0 ; it != beyond; ++it, ++i) + typename PointRange::iterator it = points.begin(); + for(unsigned int i = 0 ; it != points.end(); ++it, ++i) { - typename boost::property_traits::reference p = get(point_pmap, *it); + typename boost::property_traits::reference p = get(point_map, *it); sum_move_error += CGAL::squared_distance(p, update_pwns[i].position()); - put (point_pmap, *it, update_pwns[i].position()); - put (normal_pmap, *it, update_pwns[i].normal()); + put (point_map, *it, update_pwns[i].position()); + put (normal_map, *it, update_pwns[i].normal()); } return sum_move_error / nb_points; } +// This variant requires all parameters. +template +double +bilateral_smooth_point_set( + ForwardIterator first, ///< forward iterator on the first input point. + ForwardIterator beyond, ///< past-the-end iterator. + PointMap point_map, ///< point property map. + NormalMap normal_map, ///< normal property map. + unsigned int k, ///< size of the neighborhood for the implicit surface patch fitting. + ///< The larger the value is, the smoother the result will be. + typename Kernel::FT sharpness_angle, ///< controls the sharpness of the result. + ///< The larger the value is, the smoother the result will be. + ///< The range of possible value is [0, 90]. + const Kernel& /*kernel*/) ///< geometric traits. +{ + CGAL_POINT_SET_PROCESSING_DEPRECATED_V1_API("bilateral_smooth_point_set()"); + CGAL::Iterator_range points = CGAL::make_range (first, beyond); + return bilateral_smooth_point_set + (points, + k, sharpness_angle, + CGAL::parameters::point_map(point_map).normal_map(normal_map).geom_traits(Kernel())); +} + /// @cond SKIP_IN_MANUAL // This variant deduces the kernel from the point property map. -template + typename PointMap, + typename NormalMap> double bilateral_smooth_point_set( ForwardIterator first, ///< forward iterator to the first input point. ForwardIterator beyond, ///< past-the-end iterator. - PointPMap point_pmap, ///< property map OutputIterator -> Point_3. - NormalPMap normal_pmap, ///< property map ForwardIterator -> Vector_3. + PointMap point_map, ///< property map OutputIterator -> Point_3. + NormalMap normal_map, ///< property map ForwardIterator -> Vector_3. const unsigned int k, ///< number of neighbors. double sharpness_angle ///< control sharpness(0-90) ) ///< property map OutputIterator -> Vector_3. { - typedef typename boost::property_traits::value_type Point; - typedef typename Kernel_traits::Kernel Kernel; - return bilateral_smooth_point_set( - first, beyond, - point_pmap, - normal_pmap, - k, - sharpness_angle, - Kernel()); + CGAL_POINT_SET_PROCESSING_DEPRECATED_V1_API("bilateral_smooth_point_set()"); + CGAL::Iterator_range points = CGAL::make_range (first, beyond); + return bilateral_smooth_point_set + (points, + k, sharpness_angle, + CGAL::parameters::point_map(point_map).normal_map(normal_map)); } /// @endcond /// @cond SKIP_IN_MANUAL // This variant creates a default point property map = Dereference_property_map. -template + typename NormalMap> double bilateral_smooth_point_set( ForwardIterator first, ///< forward iterator to the first input point. ForwardIterator beyond, ///< past-the-end iterator. const unsigned int k, ///< number of neighbors. double sharpness_angle, ///< control sharpness(0-90) - NormalPMap normal_pmap) ///< property map OutputIterator -> Vector_3. + NormalMap normal_map) ///< property map OutputIterator -> Vector_3. { - return bilateral_smooth_point_set( - first, beyond, - make_identity_property_map( - typename std::iterator_traits::value_type()), - normal_pmap, - k, - sharpness_angle); + CGAL_POINT_SET_PROCESSING_DEPRECATED_V1_API("bilateral_smooth_point_set()"); + CGAL::Iterator_range points = CGAL::make_range (first, beyond); + return bilateral_smooth_point_set + (points, + k, sharpness_angle, + CGAL::parameters::normal_map(normal_map)); } /// @endcond diff --git a/Point_set_processing_3/include/CGAL/compute_average_spacing.h b/Point_set_processing_3/include/CGAL/compute_average_spacing.h index e2b0beac1c1..348dafab9ec 100644 --- a/Point_set_processing_3/include/CGAL/compute_average_spacing.h +++ b/Point_set_processing_3/include/CGAL/compute_average_spacing.h @@ -138,14 +138,14 @@ compute_average_spacing(const typename Kernel::Point_3& query, ///< 3D point who /// /// \pre `k >= 2.` /// -/// @tparam Concurrency_tag enables sequential versus parallel algorithm. +/// @tparam ConcurrencyTag enables sequential versus parallel algorithm. /// Possible values are `Sequential_tag` /// and `Parallel_tag`. /// @tparam InputIterator iterator over input points. -/// @tparam PointPMap is a model of `ReadablePropertyMap` with value type `Point_3`. +/// @tparam PointMap is a model of `ReadablePropertyMap` with value type `Point_3`. /// It can be omitted if the value type of `InputIterator` is convertible to `Point_3`. /// @tparam Kernel Geometric traits class. -/// It can be omitted and deduced automatically from the value type of `PointPMap`. +/// It can be omitted and deduced automatically from the value type of `PointMap`. /// /// @return average spacing (scalar). @@ -231,7 +231,7 @@ double compute_average_spacing( return compute_average_spacing (points, k, CGAL::parameters::all_default()); } -template ( + return compute_average_spacing( CGAL::make_range (first,beyond), k, CGAL::parameters::point_map (point_map).geom_traits (Kernel())); @@ -254,7 +254,7 @@ compute_average_spacing( /// @cond SKIP_IN_MANUAL // This variant deduces the kernel from the iterator type. -template @@ -266,7 +266,7 @@ compute_average_spacing( unsigned int k) ///< number of neighbors { CGAL_POINT_SET_PROCESSING_DEPRECATED_V1_API("compute_average_spacing()"); - return compute_average_spacing( + return compute_average_spacing( CGAL::make_range (first,beyond), k, CGAL::parameters::point_map (point_map)); @@ -275,7 +275,7 @@ compute_average_spacing( /// @cond SKIP_IN_MANUAL // This variant creates a default point property map = Identity_property_map. -template < typename Concurrency_tag, typename InputIterator > +template < typename ConcurrencyTag, typename InputIterator > typename Kernel_traits::value_type>::Kernel::FT compute_average_spacing( InputIterator first, ///< iterator over the first input point. @@ -283,7 +283,7 @@ compute_average_spacing( unsigned int k) ///< number of neighbors. { CGAL_POINT_SET_PROCESSING_DEPRECATED_V1_API("compute_average_spacing()"); - return compute_average_spacing( + return compute_average_spacing( CGAL::make_range (first,beyond), k); } /// @endcond diff --git a/Point_set_processing_3/include/CGAL/edge_aware_upsample_point_set.h b/Point_set_processing_3/include/CGAL/edge_aware_upsample_point_set.h index 2d36220ab64..45901d7d039 100644 --- a/Point_set_processing_3/include/CGAL/edge_aware_upsample_point_set.h +++ b/Point_set_processing_3/include/CGAL/edge_aware_upsample_point_set.h @@ -31,6 +31,9 @@ #include #include +#include +#include + #include #include #include @@ -283,7 +286,7 @@ update_new_point( /// in point-based rendering, hole filling, and sparse surface reconstruction. /// Normals of points are required as input. For more details, please refer to \cgalCite{ear-2013}. /// -/// @tparam Concurrency_tag enables sequential versus parallel +/// @tparam ConcurrencyTag enables sequential versus parallel /// versions of `compute_average_spacing()` (called internally). /// Possible values are `Sequential_tag` /// and `Parallel_tag`. @@ -294,63 +297,54 @@ update_new_point( /// function_output_iterator /// to match specific needs. /// @tparam ForwardIterator iterator over input points. -/// @tparam PointPMap is a model of `ReadablePropertyMap` +/// @tparam PointMap is a model of `ReadablePropertyMap` /// with the value type of `ForwardIterator` as key and `Kernel::Point_3` as value type. /// It can be omitted if the value type of `ForwardIterator` is convertible to /// `Kernel::Point_3`. -/// @tparam NormalPMap is a model of `ReadablePropertyMap` with the value type of `ForwardIterator` as key +/// @tparam NormalMap is a model of `ReadablePropertyMap` with the value type of `ForwardIterator` as key /// and `Kernel::Vector_3` as value type. /// @tparam Kernel Geometric traits class. -/// It can be omitted and deduced automatically from the value type of `PointPMap` +/// It can be omitted and deduced automatically from the value type of `PointMap` /// using `Kernel_traits`. /// // This variant requires all parameters. -template + typename NamedParameters> OutputIterator edge_aware_upsample_point_set( - ForwardIterator first, ///< forward iterator on the first input point. - ForwardIterator beyond, ///< past-the-end iterator. + const PointRange& points, OutputIterator output, ///< output iterator where output points and normals ///< are put. - PointPMap point_pmap, ///< point property map. - NormalPMap normal_pmap, ///< vector property map. - const typename Kernel::FT sharpness_angle, ///< - ///< controls the preservation of sharp features. - ///< The larger the value is, - ///< the smoother the result will be. - ///< The range of possible values is `[0, 90]`. - ///< See section \ref Point_set_processing_3Upsample_Parameter2 - ///< for an example. - typename Kernel::FT edge_sensitivity, ///< - ///< larger values of edge-sensitivity give higher priority - ///< to inserting points along sharp features. - ///< The range of possible values is `[0, 1]`. - ///< See section \ref Point_set_processing_3Upsample_Parameter1 - ///< for an example. - typename Kernel::FT neighbor_radius, ///< - ///< indicates the radius of the largest hole that should be filled. - ///< The default value is set to 3 times the average spacing of the point set. - ///< If the value given by user is smaller than the average spacing, - ///< the function will use the default value instead. - const std::size_t number_of_output_points,///< number of output - ///< points to generate. - const Kernel& /*kernel*/ ///< geometric traits. -) + const NamedParameters& np) { + using boost::choose_param; + // basic geometric types + typedef typename Point_set_processing_3::GetPointMap::type PointMap; + typedef typename Point_set_processing_3::GetNormalMap::type NormalMap; + typedef typename Point_set_processing_3::GetK::Kernel Kernel; + + CGAL_static_assertion_msg(!(boost::is_same::NoMap>::value), + "Error: no normal map"); + typedef typename Kernel::Point_3 Point; typedef typename Kernel::Vector_3 Vector; typedef typename Kernel::FT FT; typedef typename rich_grid_internal::Rich_point Rich_point; + PointMap point_map = choose_param(get_param(np, internal_np::point_map), PointMap()); + NormalMap normal_map = choose_param(get_param(np, internal_np::normal_map), NormalMap()); + double sharpness_angle = choose_param(get_param(np, internal_np::sharpness_angle), 30.); + double edge_sensitivity = choose_param(get_param(np, internal_np::sharpness_angle), 1); + double neighbor_radius = choose_param(get_param(np, internal_np::sharpness_angle), -1); + std::size_t number_of_output_points = choose_param(get_param(np, internal_np::number_of_output_points), 1000); + // preconditions - CGAL_point_set_processing_precondition(first != beyond); + CGAL_point_set_processing_precondition(points.begin() != points.end()); CGAL_point_set_processing_precondition(sharpness_angle >= 0 &&sharpness_angle <= 90); CGAL_point_set_processing_precondition(edge_sensitivity >= 0 @@ -359,15 +353,13 @@ edge_aware_upsample_point_set( edge_sensitivity *= 10; // just project [0, 1] to [0, 10]. - std::size_t number_of_input = std::distance(first, beyond); + std::size_t number_of_input = std::distance(points.begin(), points.end()); CGAL_point_set_processing_precondition(number_of_output_points > number_of_input); const unsigned int nb_neighbors = 6; // 1 ring - FT average_spacing = CGAL::compute_average_spacing( - first, beyond, - point_pmap, - nb_neighbors); + FT average_spacing = CGAL::compute_average_spacing( + points, nb_neighbors, np); if (neighbor_radius < average_spacing) { @@ -383,11 +375,11 @@ edge_aware_upsample_point_set( std::vector rich_point_set(number_of_input); CGAL::Bbox_3 bbox(0., 0., 0., 0., 0., 0.); - ForwardIterator it = first; // point iterator - for(unsigned int i = 0; it != beyond; ++it, ++i) + typename PointRange::const_iterator it = points.begin(); // point iterator + for(unsigned int i = 0; it != points.end(); ++it, ++i) { - rich_point_set[i].pt = get(point_pmap, *it); - rich_point_set[i].normal = get(normal_pmap, *it); + rich_point_set[i].pt = get(point_map, *it); + rich_point_set[i].normal = get(normal_map, *it); rich_point_set[i].index = i; bbox += rich_point_set[i].pt.bbox(); @@ -434,7 +426,7 @@ edge_aware_upsample_point_set( if (iter_time == 0) { - //estimate density threshold for the first time + //estimate density threshold for the points.begin() time for (unsigned int i = 0; i < rich_point_set.size() * 0.05; ++i) { const Rich_point& v = rich_point_set[i]; @@ -580,70 +572,114 @@ edge_aware_upsample_point_set( } +// This variant requires all parameters. +template +OutputIterator +edge_aware_upsample_point_set( + ForwardIterator first, ///< forward iterator on the first input point. + ForwardIterator beyond, ///< past-the-end iterator. + OutputIterator output, ///< output iterator where output points and normals + ///< are put. + PointMap point_map, ///< point property map. + NormalMap normal_map, ///< vector property map. + const typename Kernel::FT sharpness_angle, ///< + ///< controls the preservation of sharp features. + ///< The larger the value is, + ///< the smoother the result will be. + ///< The range of possible values is `[0, 90]`. + ///< See section \ref Point_set_processing_3Upsample_Parameter2 + ///< for an example. + typename Kernel::FT edge_sensitivity, ///< + ///< larger values of edge-sensitivity give higher priority + ///< to inserting points along sharp features. + ///< The range of possible values is `[0, 1]`. + ///< See section \ref Point_set_processing_3Upsample_Parameter1 + ///< for an example. + typename Kernel::FT neighbor_radius, ///< + ///< indicates the radius of the largest hole that should be filled. + ///< The default value is set to 3 times the average spacing of the point set. + ///< If the value given by user is smaller than the average spacing, + ///< the function will use the default value instead. + const std::size_t number_of_output_points,///< number of output + ///< points to generate. + const Kernel& /*kernel*/ ///< geometric traits. +) +{ + CGAL_POINT_SET_PROCESSING_DEPRECATED_V1_API("edge_aware_upsample_point_set()"); + return edge_aware_upsample_point_set + (CGAL::make_range (first, beyond), output, + CGAL::parameters::point_map (point_map). + normal_map (normal_map). + sharpness_angle (sharpness_angle). + edge_sensitivity (edge_sensitivity). + neighbor_radius (neighbor_radius). + number_of_output_points (number_of_output_points). + geom_traits (Kernel())); +} + /// @cond SKIP_IN_MANUAL // This variant deduces the kernel from the point property map. -template + typename PointMap, + typename NormalMap> OutputIterator edge_aware_upsample_point_set( ForwardIterator first, ///< forward iterator to the first input point. ForwardIterator beyond, ///< past-the-end iterator. OutputIterator output, ///< output iterator over points. - PointPMap point_pmap, ///< property map: `ForwardIterator` -> Point_3. - NormalPMap normal_pmap, ///< property map: `ForwardIterator` -> Vector_3. + PointMap point_map, ///< property map: `ForwardIterator` -> Point_3. + NormalMap normal_map, ///< property map: `ForwardIterator` -> Vector_3. double sharpness_angle, ///< control sharpness(0-90) double edge_sensitivity, ///< edge sensitivity(0-5) double neighbor_radius, ///< initial size of neighbors. const std::size_t number_of_output_points///< number of iterations. ) { - typedef typename boost::property_traits::value_type Point; - typedef typename Kernel_traits::Kernel Kernel; - typedef typename Kernel::FT FT; - return edge_aware_upsample_point_set( - first, beyond, - output, - point_pmap, - normal_pmap, - static_cast(sharpness_angle), - static_cast(edge_sensitivity), - static_cast(neighbor_radius), - number_of_output_points, - Kernel()); + CGAL_POINT_SET_PROCESSING_DEPRECATED_V1_API("edge_aware_upsample_point_set()"); + return edge_aware_upsample_point_set + (CGAL::make_range (first, beyond), output, + CGAL::parameters::point_map (point_map). + normal_map (normal_map). + sharpness_angle (sharpness_angle). + edge_sensitivity (edge_sensitivity). + neighbor_radius (neighbor_radius). + number_of_output_points (number_of_output_points)); } /// @endcond /// @cond SKIP_IN_MANUAL -template + typename NormalMap> OutputIterator edge_aware_upsample_point_set( ForwardIterator first, ///< iterator over the first input point ForwardIterator beyond, ///< past-the-end iterator OutputIterator output, ///< output iterator over points. - NormalPMap normal_pmap, ///< property map: OutputIterator -> Vector_3. + NormalMap normal_map, ///< property map: OutputIterator -> Vector_3. double sharpness_angle = 30, ///< control sharpness(0-90) double edge_sensitivity = 1, ///< edge sensitivity(0-5) double neighbor_radius = -1, ///< initial size of neighbors. const std::size_t number_of_output_points = 1000///< number of output points. ) { - // just deduce value_type of OutputIterator - return edge_aware_upsample_point_set - ::type>( - first, beyond, - output, - normal_pmap, - sharpness_angle, - edge_sensitivity, - neighbor_radius, - number_of_output_points); + CGAL_POINT_SET_PROCESSING_DEPRECATED_V1_API("edge_aware_upsample_point_set()"); + return edge_aware_upsample_point_set + (CGAL::make_range (first, beyond), output, + CGAL::parameters::normal_map (normal_map). + sharpness_angle (sharpness_angle). + edge_sensitivity (edge_sensitivity). + neighbor_radius (neighbor_radius). + number_of_output_points (number_of_output_points)); } /// @endcond diff --git a/Point_set_processing_3/include/CGAL/estimate_scale.h b/Point_set_processing_3/include/CGAL/estimate_scale.h index ecad70671ce..c1c591896d6 100644 --- a/Point_set_processing_3/include/CGAL/estimate_scale.h +++ b/Point_set_processing_3/include/CGAL/estimate_scale.h @@ -35,6 +35,9 @@ #include #include +#include +#include + #include #include @@ -66,13 +69,13 @@ class Quick_multiscale_approximate_knn_distance + template struct Pmap_unary_function : public CGAL::unary_function { - PointPMap point_pmap; - Pmap_unary_function (PointPMap point_pmap) : point_pmap (point_pmap) { } - typename boost::property_traits::reference - operator() (const ValueType& v) const { return get(point_pmap, v); } + PointMap point_map; + Pmap_unary_function (PointMap point_map) : point_map (point_map) { } + typename boost::property_traits::reference + operator() (const ValueType& v) const { return get(point_map, v); } }; std::size_t m_cluster_size; @@ -82,18 +85,24 @@ class Quick_multiscale_approximate_knn_distance + template Quick_multiscale_approximate_knn_distance (InputIterator first, InputIterator beyond, - PointPMap point_pmap, + PointMap point_map, std::size_t cluster_size = 25) : m_cluster_size (cluster_size) { typedef Pmap_unary_function::value_type, - PointPMap> Unary_f; + PointMap> Unary_f; + + // Avoid moving points of input as the range is const + std::vector kd_tree_points; + std::copy (boost::make_transform_iterator (first, Unary_f(point_map)), + boost::make_transform_iterator (beyond, Unary_f(point_map)), + std::back_inserter (kd_tree_points)); + - m_trees.push_back (new Tree (boost::make_transform_iterator (first, Unary_f(point_pmap)), - boost::make_transform_iterator (beyond, Unary_f(point_pmap)))); + m_trees.push_back (new Tree (kd_tree_points.begin(), kd_tree_points.end())); m_weights.push_back (1.); std::size_t nb_pts = m_trees[0]->size(); @@ -107,17 +116,16 @@ public: m_trees.reserve (nb_trees); m_weights.reserve (nb_trees); - InputIterator first_unused = beyond; + typename std::vector::iterator first_unused = kd_tree_points.end(); nb_pts = m_trees[0]->size(); for (std::size_t i = 1; i < nb_trees; ++ i) { first_unused - = CGAL::hierarchy_simplify_point_set (first, first_unused, point_pmap, + = CGAL::hierarchy_simplify_point_set (kd_tree_points.begin(), first_unused, static_cast(m_cluster_size), 1./3.); - m_trees.push_back (new Tree(boost::make_transform_iterator (first, Unary_f(point_pmap)), - boost::make_transform_iterator (first_unused, Unary_f(point_pmap)))); + m_trees.push_back (new Tree(kd_tree_points.begin(), first_unused)); m_weights.push_back (m_trees[0]->size() / (FT)(m_trees.back()->size())); } @@ -129,21 +137,21 @@ public: delete m_trees[i]; } - template - std::size_t compute_k_scale (InputIterator query, PointPMap point_pmap) + template + std::size_t compute_k_scale (InputIterator query, PointMap point_map) { std::size_t out; FT dummy; - compute_scale (query, point_pmap, out, dummy); + compute_scale (query, point_map, out, dummy); return out; } - template - FT compute_range_scale (InputIterator query, PointPMap point_pmap) + template + FT compute_range_scale (InputIterator query, PointMap point_map) { std::size_t dummy; FT out; - compute_scale (query, point_pmap, dummy, out); + compute_scale (query, point_map, dummy, out); return out; } @@ -166,8 +174,8 @@ public: } - template - void compute_scale (InputIterator query, PointPMap point_pmap, + template + void compute_scale (InputIterator query, PointMap point_map, std::size_t& k, FT& d) { if (m_precomputed_factor.empty()) @@ -182,7 +190,7 @@ public: std::size_t index = 0; for (std::size_t t = 0; t < m_trees.size(); ++ t) { - Neighbor_search search (*(m_trees[t]), get(point_pmap, *query), + Neighbor_search search (*(m_trees[t]), get(point_map, *query), static_cast((t == (m_trees.size() - 1) ? m_trees[t]->size() : m_weights[t+1] / m_weights[t]))); @@ -223,29 +231,25 @@ class Quick_multiscale_approximate_knn_distance Point_set; typedef typename Point_set::Vertex_handle Vertex_handle; - template + template struct Pmap_unary_function : public CGAL::unary_function { - PointPMap point_pmap; - Pmap_unary_function (PointPMap point_pmap) : point_pmap (point_pmap) { } - typename boost::property_traits::reference - operator() (const ValueType& v) const { return get(point_pmap, v); } + PointMap point_map; + Pmap_unary_function (PointMap point_map) : point_map (point_map) { } + typename boost::property_traits::reference + operator() (const ValueType& v) const { return get(point_map, v); } }; - template struct Pmap_to_3d { - PointPMap point_pmap; typedef typename Kernel::Point_3 value_type; typedef const value_type& reference; - typedef typename boost::property_traits::key_type key_type; + typedef typename Kernel::Point_2 key_type; typedef boost::lvalue_property_map_tag category; - Pmap_to_3d () { } - Pmap_to_3d (PointPMap point_pmap) - : point_pmap (point_pmap) { } - friend inline value_type get (const Pmap_to_3d& ppmap, key_type i) + + friend inline value_type get (const Pmap_to_3d&, key_type p) { - typename boost::property_traits::reference + typename boost::property_traits::reference p2 = get(ppmap.point_pmap, i); return value_type (p2.x(), p2.y(), 0.); } @@ -271,18 +275,24 @@ class Quick_multiscale_approximate_knn_distance + template Quick_multiscale_approximate_knn_distance (InputIterator first, InputIterator beyond, - PointPMap point_pmap, + PointMap point_map, std::size_t cluster_size = 25) : m_cluster_size (cluster_size) { typedef Pmap_unary_function::value_type, - PointPMap> Unary_f; + PointMap> Unary_f; - m_point_sets.push_back (new Point_set (boost::make_transform_iterator (first, Unary_f(point_pmap)), - boost::make_transform_iterator (beyond, Unary_f(point_pmap)))); + // Avoid moving points of input as the range is const + std::vector search_points; + std::copy (boost::make_transform_iterator (first, Unary_f(point_map)), + boost::make_transform_iterator (beyond, Unary_f(point_map)), + std::back_inserter (search_points)); + + + m_point_sets.push_back (new Point_set (search_points.begin(), search_points.end())); m_weights.push_back (1.); std::size_t nb_pts = m_point_sets[0]->number_of_vertices(); @@ -296,17 +306,16 @@ public: m_point_sets.reserve (nb_trees); m_weights.reserve (nb_trees); - InputIterator first_unused = beyond; + typename std::vector::iterator first_unused = search_points.end(); nb_pts = m_point_sets[0]->number_of_vertices(); for (std::size_t i = 1; i < nb_trees; ++ i) { first_unused - = CGAL::hierarchy_simplify_point_set (first, first_unused, Pmap_to_3d (point_pmap), + = CGAL::hierarchy_simplify_point_set (search_points.begin(), first_unused, Pmap_to_3d(), static_cast(m_cluster_size), 1./3.); - m_point_sets.push_back (new Point_set (boost::make_transform_iterator (first, Unary_f(point_pmap)), - boost::make_transform_iterator (first_unused, Unary_f(point_pmap)))); + m_point_sets.push_back (new Point_set (search_points.begin(), first_unused)); m_weights.push_back (nb_pts / (FT)(m_point_sets.back()->number_of_vertices())); } @@ -320,21 +329,21 @@ public: delete m_point_sets[i]; } - template - std::size_t compute_k_scale (InputIterator query, PointPMap point_pmap) + template + std::size_t compute_k_scale (InputIterator query, PointMap point_map) { std::size_t out; FT dummy; - compute_scale (query, point_pmap, out, dummy); + compute_scale (query, point_map, out, dummy); return out; } - template - FT compute_range_scale (InputIterator query, PointPMap point_pmap) + template + FT compute_range_scale (InputIterator query, PointMap point_map) { std::size_t dummy; FT out; - compute_scale (query, point_pmap, dummy, out); + compute_scale (query, point_map, dummy, out); return out; } @@ -356,8 +365,8 @@ public: } } - template - void compute_scale (InputIterator query, PointPMap point_pmap, + template + void compute_scale (InputIterator query, PointMap point_map, std::size_t& k, FT& d) { if (m_precomputed_factor.empty()) @@ -371,7 +380,7 @@ public: FT nb = 0.; std::size_t index = 0; - typename boost::property_traits::reference + typename boost::property_traits::reference pquery = get(point_pmap, *query); for (std::size_t t = 0; t < m_point_sets.size(); ++ t) { @@ -429,7 +438,7 @@ public: /// /// /// @tparam SamplesInputIterator iterator over input sample points. -/// @tparam SamplesPointPMap is a model of `ReadablePropertyMap` with +/// @tparam SamplesPointMap is a model of `ReadablePropertyMap` with /// value type `Point_3` or `Point_2`. It can /// be omitted if the value type of `SamplesInputIterator` is /// convertible to `Point_3` or to `Point_2`. @@ -442,42 +451,60 @@ public: /// @tparam OutputIterator is used to store the computed scales. It accepts /// values of type `std::size_t`. /// @tparam Kernel Geometric traits class. It can be omitted and -/// deduced automatically from the value type of `SamplesPointPMap`. +/// deduced automatically from the value type of `SamplesPointMap`. /// /// @note This function accepts both 2D and 3D points, but sample /// points and query must have the same dimension. // This variant requires all parameters. -template OutputIterator estimate_local_k_neighbor_scales( - SamplesInputIterator first, ///< iterator over the first input sample. - SamplesInputIterator beyond, ///< past-the-end iterator over the input samples. - SamplesPointPMap samples_pmap, ///< property map: value_type of InputIterator -> Point_3 or Point_2 - QueriesInputIterator first_query, ///< iterator over the first point where scale must be estimated - QueriesInputIterator beyond_query, ///< past-the-end iterator over the points where scale must be estimated - QueriesPointPMap queries_pmap, ///< property map: value_type of InputIterator -> Point_3 or Point_2 + const PointRange& points, + const QueryPointRange& queries, OutputIterator output, ///< output iterator to store the computed scales - const Kernel& /*kernel*/) ///< geometric traits. + const NamedParameters& np) { - typedef typename boost::property_traits::value_type Point_d; + using boost::choose_param; + typedef typename Point_set_processing_3::GetPointMap::const_type PointMap; + typedef typename Point_set_processing_3::GetQueryPointMap::const_type QueryPointMap; + typedef typename Point_set_processing_3::GetK::Kernel Kernel; + + typedef typename boost::property_traits::value_type Point_d; + + PointMap point_map = choose_param(get_param(np, internal_np::point_map), PointMap()); + QueryPointMap query_point_map = choose_param(get_param(np, internal_np::query_point_map), QueryPointMap()); // Build multi-scale KD-tree - internal::Quick_multiscale_approximate_knn_distance kdtree (first, beyond, samples_pmap); + internal::Quick_multiscale_approximate_knn_distance kdtree (points.begin(), + points.end(), + point_map); // Compute local scales everywhere - for (QueriesInputIterator it = first_query; it != beyond_query; ++ it) - *(output ++) = kdtree.compute_k_scale (it, queries_pmap); + for (typename QueryPointRange::const_iterator it = queries.begin(); + it != queries.end(); ++ it) + *(output ++) = kdtree.compute_k_scale (it, query_point_map); return output; } +template +OutputIterator +estimate_local_k_neighbor_scales( + const PointRange& points, + const QueryPointRange& queries, + OutputIterator output) ///< output iterator to store the computed scales +{ + return estimate_local_k_neighbor_scales + (points, queries, output, CGAL::parameters::all_default()); +} /// \ingroup PkgPointSetProcessingAlgorithms @@ -488,37 +515,37 @@ estimate_local_k_neighbor_scales( /// /// /// @tparam InputIterator iterator over input points. -/// @tparam PointPMap is a model of `ReadablePropertyMap` with +/// @tparam PointMap is a model of `ReadablePropertyMap` with /// value type `Point_3` or `Point_2`. It can /// be omitted if the value type of `InputIterator` is /// convertible to `Point_3` or to `Point_2`. /// @tparam Kernel Geometric traits class. It can be omitted and -/// deduced automatically from the value type of `PointPMap`. +/// deduced automatically from the value type of `PointMap`. /// /// @note This function accepts both 2D and 3D points. /// /// @return The estimated scale in the K nearest neighbors sense. // This variant requires all parameters. -template std::size_t estimate_global_k_neighbor_scale( - InputIterator first, ///< iterator over the first input point. - InputIterator beyond, ///< past-the-end iterator over the input points. - PointPMap point_pmap, ///< property map: value_type of InputIterator -> Point_3 or Point_2 - const Kernel& kernel) ///< geometric traits. + const PointRange& points, + const NamedParameters& np) { std::vector scales; - estimate_local_k_neighbor_scales (first, beyond, point_pmap, - first, beyond, point_pmap, - std::back_inserter (scales), - kernel); + estimate_local_k_neighbor_scales (points, points, std::back_inserter (scales), np); std::sort (scales.begin(), scales.end()); return scales[scales.size() / 2]; } +template +std::size_t +estimate_global_k_neighbor_scale(const PointRange& points) +{ + return estimate_global_k_neighbor_scale (points, CGAL::parameters::all_default()); +} /// \ingroup PkgPointSetProcessingAlgorithms @@ -530,7 +557,7 @@ estimate_global_k_neighbor_scale( /// /// /// @tparam SamplesInputIterator iterator over input sample points. -/// @tparam SamplesPointPMap is a model of `ReadablePropertyMap` with +/// @tparam SamplesPointMap is a model of `ReadablePropertyMap` with /// value type `Point_3` or `Point_2`. It can /// be omitted if the value type of `SamplesInputIterator` is /// convertible to `Point_3` or to `Point_2`. @@ -543,42 +570,59 @@ estimate_global_k_neighbor_scale( /// @tparam OutputIterator is used to store the computed scales. It accepts /// values of type `Kernel::FT`. /// @tparam Kernel Geometric traits class. It can be omitted and -/// deduced automatically from the value type of `SamplesPointPMap`. +/// deduced automatically from the value type of `SamplesPointMap`. /// /// @note This function accepts both 2D and 3D points, but sample /// points and query must have the same dimension. // This variant requires all parameters. -template OutputIterator estimate_local_range_scales( - SamplesInputIterator first, ///< iterator over the first input sample. - SamplesInputIterator beyond, ///< past-the-end iterator over the input samples. - SamplesPointPMap samples_pmap, ///< property map: value_type of InputIterator -> Point_3 or Point_2 - QueriesInputIterator first_query, ///< iterator over the first point where scale must be estimated - QueriesInputIterator beyond_query, ///< past-the-end iterator over the points where scale must be estimated - QueriesPointPMap queries_pmap, ///< property map: value_type of InputIterator -> Point_3 or Point_2 + const PointRange& points, + const QueryPointRange& queries, OutputIterator output, ///< output iterator to store the computed scales - const Kernel& /*kernel*/) ///< geometric traits. + const NamedParameters& np) { - typedef typename boost::property_traits::value_type Point_d; + using boost::choose_param; + typedef typename Point_set_processing_3::GetPointMap::const_type PointMap; + typedef typename Point_set_processing_3::GetQueryPointMap::const_type QueryPointMap; + typedef typename Point_set_processing_3::GetK::Kernel Kernel; + + typedef typename boost::property_traits::value_type Point_d; + + PointMap point_map = choose_param(get_param(np, internal_np::point_map), PointMap()); + QueryPointMap query_point_map = choose_param(get_param(np, internal_np::query_point_map), QueryPointMap()); // Build multi-scale KD-tree - internal::Quick_multiscale_approximate_knn_distance kdtree (first, beyond, samples_pmap); + internal::Quick_multiscale_approximate_knn_distance kdtree (points.begin(), + points.end(), + point_map); // Compute local scales everywhere - for (QueriesInputIterator it = first_query; it != beyond_query; ++ it) - *(output ++) = kdtree.compute_range_scale (it, queries_pmap); + for (typename QueryPointRange::const_iterator it = queries.begin(); it != queries.end(); ++ it) + *(output ++) = kdtree.compute_range_scale (it, query_point_map); return output; } +template +OutputIterator +estimate_local_range_scales( + const PointRange& points, + const QueryPointRange& queries, + OutputIterator output) ///< output iterator to store the computed scales +{ + return estimate_local_range_scales (points, queries, output, + CGAL::parameters::all_default()); +} /// \ingroup PkgPointSetProcessingAlgorithms @@ -589,63 +633,122 @@ estimate_local_range_scales( /// /// /// @tparam InputIterator iterator over input points. -/// @tparam PointPMap is a model of `ReadablePropertyMap` with +/// @tparam PointMap is a model of `ReadablePropertyMap` with /// value type `Point_3` or `Point_2`. It can /// be omitted if the value type of `InputIterator` is /// convertible to `Point_3` or to `Point_2`. /// @tparam Kernel Geometric traits class. It can be omitted and -/// deduced automatically from the value type of `PointPMap`. +/// deduced automatically from the value type of `PointMap`. /// /// @note This function accepts both 2D and 3D points. /// /// @return The estimated scale in the range sense. // This variant requires all parameters. -template -typename Kernel::FT +double estimate_global_range_scale( - InputIterator first, ///< iterator over the first input point. - InputIterator beyond, ///< past-the-end iterator over the input points. - PointPMap point_pmap, ///< property map: value_type of InputIterator -> Point_3 or Point_3 - const Kernel& kernel) ///< geometric traits. + const PointRange& points, + const NamedParameters& np) { - std::vector scales; - estimate_local_range_scales (first, beyond, point_pmap, - first, beyond, point_pmap, - std::back_inserter (scales), - kernel); + std::vector scales; + estimate_local_range_scales (points, points, std::back_inserter (scales), np); std::sort (scales.begin(), scales.end()); return std::sqrt (scales[scales.size() / 2]); } +template +double +estimate_global_range_scale(const PointRange& points) +{ + return estimate_global_range_scale(points, CGAL::parameters::all_default()); +} // ---------------------------------------------------------------------------- // Useful overloads // ---------------------------------------------------------------------------- /// \cond SKIP_IN_MANUAL +/// Estimates the local scale in a K nearest neighbors sense on a set +/// of user-defined query points. The computed scales correspond to +/// the smallest scales such that the K subsets of points have the +/// appearance of a surface in 3D or the appearance of a curve in 2D +/// (see \ref Point_set_processing_3Scale). +/// +/// +/// @tparam SamplesInputIterator iterator over input sample points. +/// @tparam SamplesPointMap is a model of `ReadablePropertyMap` with +/// value type `Point_3` or `Point_2`. It can +/// be omitted if the value type of `SamplesInputIterator` is +/// convertible to `Point_3` or to `Point_2`. +/// @tparam QueriesInputIterator iterator over points where scale +/// should be computed. +/// @tparam QueriesInputIterator is a model of `ReadablePropertyMap` +/// with value type `Point_3` or `Point_2`. It +/// can be omitted if the value type of `QueriesInputIterator` is +/// convertible to `Point_3` or to `Point_2`. +/// @tparam OutputIterator is used to store the computed scales. It accepts +/// values of type `std::size_t`. +/// @tparam Kernel Geometric traits class. It can be omitted and +/// deduced automatically from the value type of `SamplesPointMap`. +/// +/// @note This function accepts both 2D and 3D points, but sample +/// points and query must have the same dimension. + +// This variant requires all parameters. template +OutputIterator +estimate_local_k_neighbor_scales( + SamplesInputIterator first, ///< iterator over the first input sample. + SamplesInputIterator beyond, ///< past-the-end iterator over the input samples. + SamplesPointMap samples_map, ///< property map: value_type of InputIterator -> Point_3 or Point_2 + QueriesInputIterator first_query, ///< iterator over the first point where scale must be estimated + QueriesInputIterator beyond_query, ///< past-the-end iterator over the points where scale must be estimated + QueriesPointMap queries_map, ///< property map: value_type of InputIterator -> Point_3 or Point_2 + OutputIterator output, ///< output iterator to store the computed scales + const Kernel& /*kernel*/) ///< geometric traits. +{ + CGAL_POINT_SET_PROCESSING_DEPRECATED_V1_API("estimate_local_k_neighbor_scales()"); + return estimate_local_k_neighbor_scales + (CGAL::make_range (first, beyond), + CGAL::make_range (first_query, beyond_query), + output, + CGAL::parameters::point_map (samples_map). + query_point_map (queries_map). + geom_traits (Kernel())); +} + + +template OutputIterator estimate_local_k_neighbor_scales( SamplesInputIterator first, ///< iterator over the first input sample. SamplesInputIterator beyond, ///< past-the-end iterator over the input samples. - SamplesPointPMap samples_pmap, ///< property map: value_type of InputIterator -> Point_3 or Point_2 + SamplesPointMap samples_map, ///< property map: value_type of InputIterator -> Point_3 or Point_2 QueriesInputIterator first_query, ///< iterator over the first point where scale must be estimated QueriesInputIterator beyond_query, ///< past-the-end iterator over the points where scale must be estimated - QueriesPointPMap queries_pmap, ///< property map: value_type of InputIterator -> Point_3 or Point_2 + QueriesPointMap queries_map, ///< property map: value_type of InputIterator -> Point_3 or Point_2 OutputIterator output) ///< output iterator to store the computed scales { - typedef typename boost::property_traits::value_type Point; - typedef typename Kernel_traits::Kernel Kernel; - return estimate_local_k_neighbor_scales (first, beyond, samples_pmap, first_query, beyond_query, - queries_pmap, output, Kernel()); + CGAL_POINT_SET_PROCESSING_DEPRECATED_V1_API("estimate_local_k_neighbor_scales()"); + return estimate_local_k_neighbor_scales + (CGAL::make_range (first, beyond), + CGAL::make_range (first_query, beyond_query), + output, + CGAL::parameters::point_map (samples_map). + query_point_map (queries_map)); } template ::value_type()), - first_query, beyond_query, - make_identity_property_map (typename std::iterator_traits::value_type()), + (CGAL::make_range (first, beyond), + CGAL::make_range (first_query, beyond_query), output); } +/// Estimates the global scale in a K nearest neighbors sense. The +/// computed scale corresponds to the smallest scale such that the K +/// subsets of points have the appearance of a surface in 3D or the +/// appearance of a curve in 2D (see \ref Point_set_processing_3Scale). +/// +/// +/// @tparam InputIterator iterator over input points. +/// @tparam PointMap is a model of `ReadablePropertyMap` with +/// value type `Point_3` or `Point_2`. It can +/// be omitted if the value type of `InputIterator` is +/// convertible to `Point_3` or to `Point_2`. +/// @tparam Kernel Geometric traits class. It can be omitted and +/// deduced automatically from the value type of `PointMap`. +/// +/// @note This function accepts both 2D and 3D points. +/// +/// @return The estimated scale in the K nearest neighbors sense. +// This variant requires all parameters. template std::size_t estimate_global_k_neighbor_scale( InputIterator first, ///< iterator over the first input point. InputIterator beyond, ///< past-the-end iterator over the input points. - PointPMap point_pmap) ///< property map: value_type of InputIterator -> Point_3 or Point_2 + PointMap point_map, ///< property map: value_type of InputIterator -> Point_3 or Point_2 + const Kernel& kernel) ///< geometric traits. { - typedef typename boost::property_traits::value_type Point; - typedef typename Kernel_traits::Kernel Kernel; - return estimate_global_k_neighbor_scale (first, beyond, point_pmap, Kernel()); + CGAL_POINT_SET_PROCESSING_DEPRECATED_V1_API("estimate_global_k_neighbor_scale()"); + return estimate_global_k_neighbor_scale + (CGAL::make_range (first, beyond), + CGAL::parameters::point_map (point_map). + geom_traits (kernel)); +} + +template +std::size_t +estimate_global_k_neighbor_scale( + InputIterator first, ///< iterator over the first input point. + InputIterator beyond, ///< past-the-end iterator over the input points. + PointMap point_map) ///< property map: value_type of InputIterator -> Point_3 or Point_2 +{ + CGAL_POINT_SET_PROCESSING_DEPRECATED_V1_API("estimate_global_k_neighbor_scale()"); + return estimate_global_k_neighbor_scale + (CGAL::make_range (first, beyond), + CGAL::parameters::point_map (point_map)); } template ::value_type())); + (CGAL::make_range (first, beyond)); } +/// Estimates the local scale in a range sense on a set of +/// user-defined query points. The computed scales correspond to the +/// smallest scales such that the subsets of points included in the +/// sphere range have the appearance of a surface in 3D or the +/// appearance of a curve in 2D (see \ref Point_set_processing_3Scale). +/// +/// +/// @tparam SamplesInputIterator iterator over input sample points. +/// @tparam SamplesPointMap is a model of `ReadablePropertyMap` with +/// value type `Point_3` or `Point_2`. It can +/// be omitted if the value type of `SamplesInputIterator` is +/// convertible to `Point_3` or to `Point_2`. +/// @tparam QueriesInputIterator iterator over points where scale +/// should be computed. +/// @tparam QueriesInputIterator is a model of `ReadablePropertyMap` +/// with value type `Point_3` or `Point_2`. It +/// can be omitted if the value type of `QueriesInputIterator` is +/// convertible to `Point_3` or to `Point_2`. +/// @tparam OutputIterator is used to store the computed scales. It accepts +/// values of type `Kernel::FT`. +/// @tparam Kernel Geometric traits class. It can be omitted and +/// deduced automatically from the value type of `SamplesPointMap`. +/// +/// @note This function accepts both 2D and 3D points, but sample +/// points and query must have the same dimension. + +// This variant requires all parameters. template OutputIterator estimate_local_range_scales( SamplesInputIterator first, ///< iterator over the first input sample. SamplesInputIterator beyond, ///< past-the-end iterator over the input samples. - SamplesPointPMap samples_pmap, ///< property map: value_type of InputIterator -> Point_3 or Point_2 + SamplesPointMap samples_map, ///< property map: value_type of InputIterator -> Point_3 or Point_2 QueriesInputIterator first_query, ///< iterator over the first point where scale must be estimated QueriesInputIterator beyond_query, ///< past-the-end iterator over the points where scale must be estimated - QueriesPointPMap queries_pmap, ///< property map: value_type of InputIterator -> Point_3 or Point_2 - OutputIterator output) ///< output iterator to store the computed scales -{ - typedef typename boost::property_traits::value_type Point; - typedef typename Kernel_traits::Kernel Kernel; - return estimate_local_range_scales(first, beyond, samples_pmap, first_query, beyond_query, - queries_pmap, output, Kernel()); -} - - -template -OutputIterator -estimate_local_range_scales( - SamplesInputIterator first, ///< iterator over the first input sample. - SamplesInputIterator beyond, ///< past-the-end iterator over the input samples. - QueriesInputIterator first_query, ///< iterator over the first point where scale must be estimated - QueriesInputIterator beyond_query, ///< past-the-end iterator over the points where scale must be estimated - OutputIterator output) ///< output iterator to store the computed scales + QueriesPointMap queries_map, ///< property map: value_type of InputIterator -> Point_3 or Point_2 + OutputIterator output, ///< output iterator to store the computed scales + const Kernel& /*kernel*/) ///< geometric traits. { + CGAL_POINT_SET_PROCESSING_DEPRECATED_V1_API("estimate_local_range_scales()"); return estimate_local_range_scales - (first, beyond, - make_identity_property_map (typename std::iterator_traits::value_type()), - first_query, beyond_query, - make_identity_property_map (typename std::iterator_traits::value_type()), + (CGAL::make_range (first, beyond), + CGAL::make_range (first_query, beyond_query), + output, + CGAL::parameters::point_map (samples_map). + query_point_map (queries_map). + geom_traits (Kernel())); +} + +template +OutputIterator +estimate_local_range_scales( + SamplesInputIterator first, ///< iterator over the first input sample. + SamplesInputIterator beyond, ///< past-the-end iterator over the input samples. + SamplesPointMap samples_map, ///< property map: value_type of InputIterator -> Point_3 or Point_2 + QueriesInputIterator first_query, ///< iterator over the first point where scale must be estimated + QueriesInputIterator beyond_query, ///< past-the-end iterator over the points where scale must be estimated + QueriesPointMap queries_map, ///< property map: value_type of InputIterator -> Point_3 or Point_2 + OutputIterator output) ///< output iterator to store the computed scales +{ + CGAL_POINT_SET_PROCESSING_DEPRECATED_V1_API("estimate_local_range_scales()"); + return estimate_local_range_scales + (CGAL::make_range (first, beyond), + CGAL::make_range (first_query, beyond_query), + output, + CGAL::parameters::point_map (samples_map). + query_point_map (queries_map)); +} + + +template +OutputIterator +estimate_local_range_scales( + SamplesInputIterator first, ///< iterator over the first input sample. + SamplesInputIterator beyond, ///< past-the-end iterator over the input samples. + QueriesInputIterator first_query, ///< iterator over the first point where scale must be estimated + QueriesInputIterator beyond_query, ///< past-the-end iterator over the points where scale must be estimated + OutputIterator output) ///< output iterator to store the computed scales +{ + CGAL_POINT_SET_PROCESSING_DEPRECATED_V1_API("estimate_local_range_scales()"); + return estimate_local_range_scales + (CGAL::make_range (first, beyond), + CGAL::make_range (first_query, beyond_query), output); } - +/// Estimates the global scale in a range sense. The computed scale +/// corresponds to the smallest scale such that the subsets of points +/// inside the sphere range have the appearance of a surface in 3D or +/// the appearance of a curve in 2D (see \ref Point_set_processing_3Scale). +/// +/// +/// @tparam InputIterator iterator over input points. +/// @tparam PointMap is a model of `ReadablePropertyMap` with +/// value type `Point_3` or `Point_2`. It can +/// be omitted if the value type of `InputIterator` is +/// convertible to `Point_3` or to `Point_2`. +/// @tparam Kernel Geometric traits class. It can be omitted and +/// deduced automatically from the value type of `PointMap`. +/// +/// @note This function accepts both 2D and 3D points. +/// +/// @return The estimated scale in the range sense. +// This variant requires all parameters. template -typename Kernel_traits::value_type>::Kernel::FT +double estimate_global_range_scale( InputIterator first, ///< iterator over the first input point. InputIterator beyond, ///< past-the-end iterator over the input points. - PointPMap point_pmap) ///< property map: value_type of InputIterator -> Point_3 or Point_3 + PointMap point_map, ///< property map: value_type of InputIterator -> Point_3 or Point_3 + const Kernel& kernel) ///< geometric traits. { - typedef typename boost::property_traits::value_type Point; - typedef typename Kernel_traits::Kernel Kernel; - return estimate_global_range_scale (first, beyond, point_pmap, Kernel()); + CGAL_POINT_SET_PROCESSING_DEPRECATED_V1_API("estimate_global_range_scale()"); + return estimate_global_range_scale + (CGAL::make_range (first, beyond), + CGAL::parameters::point_map (point_map). + geom_traits (kernel)); +} + +template +double +estimate_global_range_scale( + InputIterator first, ///< iterator over the first input point. + InputIterator beyond, ///< past-the-end iterator over the input points. + PointMap point_map) ///< property map: value_type of InputIterator -> Point_3 or Point_3 +{ + CGAL_POINT_SET_PROCESSING_DEPRECATED_V1_API("estimate_global_range_scale()"); + return estimate_global_range_scale + (CGAL::make_range (first, beyond), + CGAL::parameters::point_map (point_map)); } template -typename Kernel_traits::value_type>::Kernel::FT +double estimate_global_range_scale( InputIterator first, ///< iterator over the first input point. InputIterator beyond) ///< past-the-end iterator over the input points. { + CGAL_POINT_SET_PROCESSING_DEPRECATED_V1_API("estimate_global_range_scale()"); return estimate_global_range_scale - (first, beyond, make_identity_property_map (typename std::iterator_traits::value_type())); - + (CGAL::make_range (first, beyond)); } /// \endcond diff --git a/Point_set_processing_3/include/CGAL/grid_simplify_point_set.h b/Point_set_processing_3/include/CGAL/grid_simplify_point_set.h index fc8b8f58af1..b8011b06706 100644 --- a/Point_set_processing_3/include/CGAL/grid_simplify_point_set.h +++ b/Point_set_processing_3/include/CGAL/grid_simplify_point_set.h @@ -28,8 +28,12 @@ #include #include #include +#include #include +#include +#include + #include #include #include @@ -55,25 +59,25 @@ inline double round_epsilon(double value, double epsilon) /// Utility class for grid_simplify_point_set(): Hash_epsilon_points_3 /// defines a 3D point hash / 2 points are equal iff they belong to /// the same cell of a grid of cell size = epsilon. -template +template struct Hash_epsilon_points_3 { private: double m_epsilon; - PointPMap point_pmap; - typedef typename boost::property_traits::value_type Point; + PointMap point_map; + typedef typename boost::property_traits::value_type Point; public: - Hash_epsilon_points_3 (double epsilon, PointPMap p_pmap) - : m_epsilon (epsilon), point_pmap(p_pmap) + Hash_epsilon_points_3 (double epsilon, PointMap p_map) + : m_epsilon (epsilon), point_map(p_map) { CGAL_point_set_processing_precondition(epsilon > 0); } std::size_t operator() (const Point_3& a) const { - const Point& pa = get(point_pmap,a); + const Point& pa = get(point_map,a); std::size_t result = boost::hash_value(round_epsilon(pa.x(), m_epsilon)); boost::hash_combine(result, boost::hash_value(round_epsilon(pa.y(), m_epsilon))); boost::hash_combine(result, boost::hash_value(round_epsilon(pa.z(), m_epsilon))); @@ -85,26 +89,26 @@ public: /// Utility class for grid_simplify_point_set(): Hash_epsilon_points_3 /// defines a 3D point equality / 2 points are equal iff they belong /// to the same cell of a grid of cell size = epsilon. -template +template struct Equal_epsilon_points_3 { private: const double m_epsilon; - PointPMap point_pmap; - typedef typename boost::property_traits::value_type Point; + PointMap point_map; + typedef typename boost::property_traits::value_type Point; public: - Equal_epsilon_points_3 (const double& epsilon, PointPMap p_pmap) - : m_epsilon (epsilon), point_pmap(p_pmap) + Equal_epsilon_points_3 (const double& epsilon, PointMap p_map) + : m_epsilon (epsilon), point_map(p_map) { CGAL_point_set_processing_precondition(epsilon > 0); } bool operator() (const Point_3& a, const Point_3& b) const { - const Point& pa = get(point_pmap,a); - const Point& pb = get(point_pmap,b); + const Point& pa = get(point_map,a); + const Point& pb = get(point_map,b); double ra = round_epsilon(pa.x(), m_epsilon); double rb = round_epsilon(pb.x(), m_epsilon); @@ -137,24 +141,24 @@ public: /// This class is a container sorted wrt points position /// => you should not modify directly the order or the position of points. -template +template class Epsilon_point_set_3 : public cpp11::unordered_set, - internal::Equal_epsilon_points_3 > + internal::Hash_epsilon_points_3, + internal::Equal_epsilon_points_3 > { private: // superclass typedef cpp11::unordered_set, - internal::Equal_epsilon_points_3 > Base; + internal::Hash_epsilon_points_3, + internal::Equal_epsilon_points_3 > Base; public: - Epsilon_point_set_3 (double epsilon, PointPMap point_pmap) - : Base(10, internal::Hash_epsilon_points_3(epsilon, point_pmap), - internal::Equal_epsilon_points_3(epsilon, point_pmap)) + Epsilon_point_set_3 (double epsilon, PointMap point_map) + : Base(10, internal::Hash_epsilon_points_3(epsilon, point_map), + internal::Equal_epsilon_points_3(epsilon, point_map)) { CGAL_point_set_processing_precondition(epsilon > 0); } @@ -174,68 +178,112 @@ public: /// \pre `epsilon > 0` /// /// @tparam ForwardIterator iterator over input points. -/// @tparam PointPMap is a model of `ReadablePropertyMap` with value type `Point_3`. +/// @tparam PointMap is a model of `ReadablePropertyMap` with value type `Point_3`. /// It can be omitted if the value type of `ForwardIterator` is convertible to `Point_3`. /// @tparam Kernel Geometric traits class. -/// It can be omitted and deduced automatically from the value type of `PointPMap`. +/// It can be omitted and deduced automatically from the value type of `PointMap`. /// /// @return iterator over the first point to remove. // This variant requires all parameters. -template -ForwardIterator grid_simplify_point_set( - ForwardIterator first, ///< iterator over the first input point. - ForwardIterator beyond, ///< past-the-end iterator over the input points. - PointPMap point_pmap, ///< property map: value_type of ForwardIterator -> Point_3 +template +typename PointRange::iterator +grid_simplify_point_set( + PointRange& points, double epsilon, ///< tolerance value when merging 3D points. - const Kernel& /*kernel*/) ///< geometric traits. + const NamedParameters& np) { + using boost::choose_param; + + typedef typename Point_set_processing_3::GetPointMap::const_type PointMap; + PointMap point_map = choose_param(get_param(np, internal_np::point_map), PointMap()); + // actual type of input points - typedef typename std::iterator_traits::value_type Enriched_point; + typedef typename std::iterator_traits::value_type Enriched_point; CGAL_point_set_processing_precondition(epsilon > 0); // Merges points which belong to the same cell of a grid of cell size = epsilon. // points_to_keep[] will contain 1 point per cell; the others will be in points_to_remove[]. - Epsilon_point_set_3 points_to_keep(epsilon, point_pmap); + Epsilon_point_set_3 points_to_keep(epsilon, point_map); std::deque points_to_remove; - for (ForwardIterator it=first ; it != beyond ; it++) + for (typename PointRange::iterator it = points.begin(); it != points.end(); it++) { - std::pair::iterator,bool> result; - result = points_to_keep.insert(*it); - if (!result.second) // if not inserted - points_to_remove.push_back(*it); + std::pair::iterator,bool> result; + result = points_to_keep.insert(*it); + if (!result.second) // if not inserted + points_to_remove.push_back(*it); } // Replaces `[first, beyond)` range by the content of points_to_keep, then points_to_remove. - ForwardIterator first_point_to_remove = - std::copy(points_to_keep.begin(), points_to_keep.end(), first); + typename PointRange::iterator first_point_to_remove = + std::copy(points_to_keep.begin(), points_to_keep.end(), points.begin()); std::copy(points_to_remove.begin(), points_to_remove.end(), first_point_to_remove); return first_point_to_remove; } +template +typename PointRange::iterator +grid_simplify_point_set(PointRange& points, double epsilon) +{ + return grid_simplify_point_set (points, epsilon, CGAL::parameters::all_default()); +} + +/// Merges points which belong to the same cell of a grid of cell size = `epsilon`. +/// +/// This method modifies the order of input points so as to pack all remaining points first, +/// and returns an iterator over the first point to remove (see erase-remove idiom). +/// For this reason it should not be called on sorted containers. +/// +/// \pre `epsilon > 0` +/// +/// @tparam ForwardIterator iterator over input points. +/// @tparam PointMap is a model of `ReadablePropertyMap` with value type `Point_3`. +/// It can be omitted if the value type of `ForwardIterator` is convertible to `Point_3`. +/// @tparam Kernel Geometric traits class. +/// It can be omitted and deduced automatically from the value type of `PointMap`. +/// +/// @return iterator over the first point to remove. + +// This variant requires all parameters. +template +ForwardIterator grid_simplify_point_set( + ForwardIterator first, ///< iterator over the first input point. + ForwardIterator beyond, ///< past-the-end iterator over the input points. + PointMap point_map, ///< property map: value_type of ForwardIterator -> Point_3 + double epsilon, ///< tolerance value when merging 3D points. + const Kernel& /*kernel*/) ///< geometric traits. +{ + CGAL_POINT_SET_PROCESSING_DEPRECATED_V1_API("grid_simplify_point_set()"); + CGAL::Iterator_range points = CGAL::make_range (first, beyond); + return grid_simplify_point_set + (points, + epsilon, + CGAL::parameters::point_map (point_map). + geom_traits (Kernel())); +} + /// @cond SKIP_IN_MANUAL // This variant deduces the kernel from the iterator type. template ForwardIterator grid_simplify_point_set( ForwardIterator first, ///< iterator over the first input point ForwardIterator beyond, ///< past-the-end iterator - PointPMap point_pmap, ///< property map: value_type of ForwardIterator -> Point_3 + PointMap point_map, ///< property map: value_type of ForwardIterator -> Point_3 double epsilon) ///< tolerance value when merging 3D points { - typedef typename boost::property_traits::value_type Point; - typedef typename Kernel_traits::Kernel Kernel; - return grid_simplify_point_set( - first,beyond, - point_pmap, - epsilon, - Kernel()); + CGAL_POINT_SET_PROCESSING_DEPRECATED_V1_API("grid_simplify_point_set()"); + CGAL::Iterator_range points = CGAL::make_range (first, beyond); + return grid_simplify_point_set + (points, + epsilon, + CGAL::parameters::point_map (point_map)); } /// @endcond @@ -249,11 +297,11 @@ grid_simplify_point_set( ForwardIterator beyond, ///< past-the-end iterator double epsilon) ///< tolerance value when merging 3D points { - return grid_simplify_point_set( - first,beyond, - make_identity_property_map( - typename std::iterator_traits::value_type()), - epsilon); + CGAL_POINT_SET_PROCESSING_DEPRECATED_V1_API("grid_simplify_point_set()"); + CGAL::Iterator_range points = CGAL::make_range (first, beyond); + return grid_simplify_point_set + (points, + epsilon); } /// @endcond diff --git a/Point_set_processing_3/include/CGAL/hierarchy_simplify_point_set.h b/Point_set_processing_3/include/CGAL/hierarchy_simplify_point_set.h index 41373aced99..71bbbb8d41c 100644 --- a/Point_set_processing_3/include/CGAL/hierarchy_simplify_point_set.h +++ b/Point_set_processing_3/include/CGAL/hierarchy_simplify_point_set.h @@ -37,6 +37,10 @@ #include #include #include +#include + +#include +#include namespace CGAL { @@ -44,12 +48,12 @@ namespace CGAL { namespace internal { template < typename InputIterator, - typename PointPMap, + typename PointMap, typename K > typename K::Point_3 hsps_centroid(InputIterator begin, InputIterator end, - PointPMap& point_pmap, + PointMap& point_map, const K&) { typedef typename K::Point_3 Point; @@ -61,8 +65,8 @@ namespace CGAL { unsigned int nb_pts = 0; while(begin != end) { - typename boost::property_traits::reference point = - get(point_pmap, *begin); + typename boost::property_traits::reference point = + get(point_map, *begin); x += point.x (); y += point.y (); z += point.z (); ++ nb_pts; ++ begin; @@ -71,13 +75,13 @@ namespace CGAL { } template < typename Input_type, - typename PointPMap, + typename PointMap, typename K > void hsc_terminate_cluster (std::list& cluster, std::list& points_to_keep, std::list& points_to_remove, - PointPMap& point_pmap, + PointMap& point_map, const typename K::Point_3& centroid, const K&) { @@ -89,7 +93,7 @@ namespace CGAL { typename std::list::iterator point_min; for (Iterator it = cluster.begin (); it != cluster.end (); ++ it) { - FT dist = CGAL::squared_distance (get(point_pmap, *it), centroid); + FT dist = CGAL::squared_distance (get(point_map, *it), centroid); if (dist < dist_min) { dist_min = dist; @@ -121,7 +125,7 @@ namespace CGAL { /// \pre `size > 0` /// /// @tparam ForwardIterator iterator over input points. - /// @tparam PointPMap is a model of `ReadablePropertyMap` with value type `Point_3`. + /// @tparam PointMap is a model of `ReadablePropertyMap` with value type `Point_3`. /// It can be omitted if the value type of `ForwardIterator` is convertible to `Point_3`. /// @tparam DiagonalizeTraits is a model of `DiagonalizeTraits`. It /// can be omitted: if Eigen 3 (or greater) is available and @@ -129,29 +133,35 @@ namespace CGAL { /// `Eigen_diagonalize_traits` is provided. Otherwise, the internal /// implementation `Internal_diagonalize_traits` is used. /// @tparam Kernel Geometric traits class. - /// It can be omitted and deduced automatically from the value type of `PointPMap`. + /// It can be omitted and deduced automatically from the value type of `PointMap`. /// /// @return iterator over the first point to remove. // This variant requires all parameters. - template - ForwardIterator hierarchy_simplify_point_set (ForwardIterator begin, - ForwardIterator end, - PointPMap point_pmap, - const unsigned int size, - const double var_max, - const DiagonalizeTraits&, - const Kernel&) + template + typename PointRange::iterator + hierarchy_simplify_point_set (PointRange& points, + const NamedParameters& np) { - typedef typename std::iterator_traits::value_type Input_type; - typedef typename Kernel::FT FT; - typedef typename Kernel::Point_3 Point; + using boost::choose_param; + + // basic geometric types + typedef typename Point_set_processing_3::GetPointMap::type PointMap; + typedef typename Point_set_processing_3::GetK::Kernel Kernel; + typedef typename GetDiagonalizeTraits::type DiagonalizeTraits; + + typedef typename Kernel::Point_3 Point; typedef typename Kernel::Vector_3 Vector; + typedef typename Kernel::FT FT; + + PointMap point_map = choose_param(get_param(np, internal_np::point_map), PointMap()); + unsigned int size = choose_param(get_param(np, internal_np::size), 10); + double var_max = choose_param(get_param(np, internal_np::maximum_variation), 1./3.); + + typedef typename std::iterator_traits::value_type Input_type; // We define a cluster as a point set + its centroid (useful for // faster computations of centroids - to be implemented) @@ -160,17 +170,17 @@ namespace CGAL { std::list clusters_stack; typedef typename std::list::iterator cluster_iterator; - CGAL_precondition (begin != end); + CGAL_precondition (points.begin() != points.end()); CGAL_point_set_processing_precondition (size > 0); CGAL_point_set_processing_precondition (var_max > 0.0); // The first cluster is the whole input point set clusters_stack.push_front (cluster (std::list(), Point (0., 0., 0.))); - std::copy (begin, end, std::back_inserter (clusters_stack.front ().first)); + std::copy (points.begin(), points.end(), std::back_inserter (clusters_stack.front ().first)); clusters_stack.front ().second = internal::hsps_centroid (clusters_stack.front ().first.begin (), - clusters_stack.front ().first.end (), - point_pmap, Kernel()); + clusters_stack.front ().first.end (), + point_map, Kernel()); std::list points_to_keep; std::list points_to_remove; @@ -195,7 +205,7 @@ namespace CGAL { for (typename std::list::iterator it = current_cluster->first.begin (); it != current_cluster->first.end (); ++ it) { - const Point& point = get(point_pmap, *it); + const Point& point = get(point_map, *it); Vector d = point - current_cluster->second; covariance[0] += d.x () * d.x (); covariance[1] += d.x () * d.y (); @@ -234,7 +244,7 @@ namespace CGAL { while (it != current_cluster->first.end ()) { typename std::list::iterator current = it ++; - const Point& point = get(point_pmap, *current); + const Point& point = get(point_map, *current); // Test if point is on negative side of plane and // transfer it to the negative_side cluster if it is @@ -254,12 +264,12 @@ namespace CGAL { // Compute the centroid nonempty->second = internal::hsps_centroid (nonempty->first.begin (), nonempty->first.end (), - point_pmap, Kernel()); + point_map, Kernel()); internal::hsc_terminate_cluster (nonempty->first, points_to_keep, points_to_remove, - point_pmap, + point_map, nonempty->second, Kernel ()); clusters_stack.pop_front (); @@ -273,7 +283,7 @@ namespace CGAL { // Compute the first centroid current_cluster->second = internal::hsps_centroid (current_cluster->first.begin (), current_cluster->first.end (), - point_pmap, Kernel()); + point_map, Kernel()); // The second centroid can be computed with the first and // the old ones : @@ -297,14 +307,14 @@ namespace CGAL { internal::hsc_terminate_cluster (current_cluster->first, points_to_keep, points_to_remove, - point_pmap, + point_map, current_cluster->second, Kernel ()); clusters_stack.pop_front (); } } - ForwardIterator first_point_to_remove = - std::copy (points_to_keep.begin(), points_to_keep.end(), begin); + typename PointRange::iterator first_point_to_remove = + std::copy (points_to_keep.begin(), points_to_keep.end(), points.begin()); std::copy (points_to_remove.begin(), points_to_remove.end(), first_point_to_remove); return first_point_to_remove; @@ -312,40 +322,96 @@ namespace CGAL { } /// @endcond + /// Recursively split the point set in smaller clusters until the + /// clusters have less than `size` elements or until their variation + /// factor is below `var_max`. + /// + /// This method modifies the order of input points so as to pack all remaining points first, + /// and returns an iterator over the first point to remove (see erase-remove idiom). + /// For this reason it should not be called on sorted containers. + /// + /// \pre `0 < var_max < 1/3` + /// \pre `size > 0` + /// + /// @tparam ForwardIterator iterator over input points. + /// @tparam PointMap is a model of `ReadablePropertyMap` with value type `Point_3`. + /// It can be omitted if the value type of `ForwardIterator` is convertible to `Point_3`. + /// @tparam DiagonalizeTraits is a model of `DiagonalizeTraits`. It + /// can be omitted: if Eigen 3 (or greater) is available and + /// `CGAL_EIGEN3_ENABLED` is defined then an overload using + /// `Eigen_diagonalize_traits` is provided. Otherwise, the internal + /// implementation `Internal_diagonalize_traits` is used. + /// @tparam Kernel Geometric traits class. + /// It can be omitted and deduced automatically from the value type of `PointMap`. + /// + /// @return iterator over the first point to remove. + + // This variant requires all parameters. + + template + ForwardIterator hierarchy_simplify_point_set (ForwardIterator begin, + ForwardIterator end, + PointMap point_map, + const unsigned int size, + const double var_max, + const DiagonalizeTraits&, + const Kernel&) + { + CGAL_POINT_SET_PROCESSING_DEPRECATED_V1_API("hierarchy_simplify_point_set()"); + CGAL::Iterator_range points (begin, end); + return hierarchy_simplify_point_set + (points, + CGAL::parameters::point_map (point_map). + size (size). + maximum_variation (var_max). + diagonalize_traits (DiagonalizeTraits()). + geom_traits(Kernel())); + } + /// @cond SKIP_IN_MANUAL // This variant deduces the kernel from the iterator type. template ForwardIterator hierarchy_simplify_point_set (ForwardIterator begin, ForwardIterator end, - PointPMap point_pmap, + PointMap point_map, const unsigned int size, const double var_max, const DiagonalizeTraits& diagonalize_traits) { - typedef typename boost::property_traits::value_type Point; - typedef typename Kernel_traits::Kernel Kernel; - return hierarchy_simplify_point_set (begin, end, point_pmap, size, var_max, - diagonalize_traits, Kernel()); + CGAL_POINT_SET_PROCESSING_DEPRECATED_V1_API("hierarchy_simplify_point_set()"); + CGAL::Iterator_range points (begin, end); + return hierarchy_simplify_point_set + (points, + CGAL::parameters::point_map (point_map). + size (size). + maximum_variation (var_max). + diagonalize_traits (diagonalize_traits)); } /// @endcond /// @cond SKIP_IN_MANUAL // This variant uses default diagonalize traits template + typename PointMap > ForwardIterator hierarchy_simplify_point_set (ForwardIterator begin, ForwardIterator end, - PointPMap point_pmap, + PointMap point_map, const unsigned int size, const double var_max) { - typedef typename boost::property_traits::value_type Point; - typedef typename Kernel_traits::Kernel Kernel; - return hierarchy_simplify_point_set (begin, end, point_pmap, size, var_max, - Default_diagonalize_traits (), Kernel()); + CGAL_POINT_SET_PROCESSING_DEPRECATED_V1_API("hierarchy_simplify_point_set()"); + CGAL::Iterator_range points (begin, end); + return hierarchy_simplify_point_set + (points, + CGAL::parameters::point_map (point_map). + size (size). + maximum_variation (var_max)); } /// @endcond @@ -357,10 +423,12 @@ namespace CGAL { const unsigned int size = 10, const double var_max = 0.333) { + CGAL_POINT_SET_PROCESSING_DEPRECATED_V1_API("hierarchy_simplify_point_set()"); + CGAL::Iterator_range points (begin, end); return hierarchy_simplify_point_set - (begin, end, - make_identity_property_map (typename std::iterator_traits::value_type()), - size, var_max); + (points, + CGAL::parameters::size (size). + maximum_variation (var_max)); } /// @endcond diff --git a/Point_set_processing_3/include/CGAL/jet_estimate_normals.h b/Point_set_processing_3/include/CGAL/jet_estimate_normals.h index 24fde6ff5db..4a7ab205537 100644 --- a/Point_set_processing_3/include/CGAL/jet_estimate_normals.h +++ b/Point_set_processing_3/include/CGAL/jet_estimate_normals.h @@ -32,6 +32,9 @@ #include #include +#include +#include + #include #include @@ -155,43 +158,54 @@ jet_estimate_normal(const typename Kernel::Point_3& query, ///< point to compute /// /// \pre `k >= 2` /// -/// @tparam Concurrency_tag enables sequential versus parallel algorithm. +/// @tparam ConcurrencyTag enables sequential versus parallel algorithm. /// Possible values are `Sequential_tag` /// and `Parallel_tag`. /// @tparam ForwardIterator iterator model of the concept of the same name over input points and able to store output normals. -/// @tparam PointPMap is a model of `ReadablePropertyMap` with value type `Point_3`. +/// @tparam PointMap is a model of `ReadablePropertyMap` with value type `Point_3`. /// It can be omitted if the value type of `ForwardIterator` is convertible to `Point_3`. -/// @tparam NormalPMap is a model of `WritablePropertyMap` with value type `Vector_3`. +/// @tparam NormalMap is a model of `WritablePropertyMap` with value type `Vector_3`. /// @tparam Kernel Geometric traits class. -/// It can be omitted and deduced automatically from the value type of `PointPMap`. +/// It can be omitted and deduced automatically from the value type of `PointMap`. /// @tparam SvdTraits template parameter for the class `Monge_via_jet_fitting` that /// can be ommited under conditions described in the documentation of `Monge_via_jet_fitting`. // This variant requires all parameters. -template void jet_estimate_normals( - ForwardIterator first, ///< iterator over the first input point. - ForwardIterator beyond, ///< past-the-end iterator over the input points. - PointPMap point_pmap, ///< property map: value_type of ForwardIterator -> Point_3. - NormalPMap normal_pmap, ///< property map: value_type of ForwardIterator -> Vector_3. + PointRange& points, unsigned int k, ///< number of neighbors. - const Kernel& /*kernel*/, ///< geometric traits. - unsigned int degree_fitting = 2) ///< fitting degree + const NamedParameters& np) { + using boost::choose_param; + CGAL_TRACE("Calls jet_estimate_normals()\n"); // basic geometric types + typedef typename Point_set_processing_3::GetPointMap::type PointMap; + typedef typename Point_set_processing_3::GetNormalMap::type NormalMap; + typedef typename Point_set_processing_3::GetK::Kernel Kernel; + typedef typename GetSvdTraits::type SvdTraits; + + CGAL_static_assertion_msg(!(boost::is_same::NoMap>::value), + "Error: no normal map"); + CGAL_static_assertion_msg(!(boost::is_same::NoMap>::value), + "Error: no SVD traits"); + + PointMap point_map = choose_param(get_param(np, internal_np::point_map), PointMap()); + NormalMap normal_map = choose_param(get_param(np, internal_np::normal_map), NormalMap()); + unsigned int degree_fitting = choose_param(get_param(np, internal_np::degree_fitting), 2); + typedef typename Kernel::Point_3 Point; // Input points types - typedef typename boost::property_traits::value_type Vector; + typedef typename boost::property_traits::value_type Vector; // types for K nearest neighbors search structure typedef typename CGAL::Search_traits_3 Tree_traits; @@ -201,7 +215,7 @@ jet_estimate_normals( // precondition: at least one element in the container. // to fix: should have at least three distinct points // but this is costly to check - CGAL_point_set_processing_precondition(first != beyond); + CGAL_point_set_processing_precondition(points.begin() != points.end()); // precondition: at least 2 nearest neighbors CGAL_point_set_processing_precondition(k >= 2); @@ -209,13 +223,13 @@ jet_estimate_normals( std::size_t memory = CGAL::Memory_sizer().virtual_size(); CGAL_TRACE(" %ld Mb allocated\n", memory>>20); CGAL_TRACE(" Creates KD-tree\n"); - ForwardIterator it; + typename PointRange::iterator it; // Instanciate a KD-tree search. // Note: We have to convert each input iterator to Point_3. std::vector kd_tree_points; - for(it = first; it != beyond; it++) - kd_tree_points.push_back(get(point_pmap, *it)); + for(it = points.begin(); it != points.end(); it++) + kd_tree_points.push_back(get(point_map, *it)); Tree tree(kd_tree_points.begin(), kd_tree_points.end()); memory = CGAL::Memory_sizer().virtual_size(); CGAL_TRACE(" %ld Mb allocated\n", memory>>20); @@ -224,31 +238,31 @@ jet_estimate_normals( // iterate over input points, compute and output normal // vectors (already normalized) #ifndef CGAL_LINKED_WITH_TBB - CGAL_static_assertion_msg (!(boost::is_convertible::value), + CGAL_static_assertion_msg (!(boost::is_convertible::value), "Parallel_tag is enabled but TBB is unavailable."); #else - if (boost::is_convertible::value) + if (boost::is_convertible::value) { std::vector normals (kd_tree_points.size ()); CGAL::internal::Jet_estimate_normals f (tree, k, kd_tree_points, degree_fitting, normals); tbb::parallel_for(tbb::blocked_range(0, kd_tree_points.size ()), f); unsigned int i = 0; - for(it = first; it != beyond; ++ it, ++ i) + for(it = points.begin(); it != points.end(); ++ it, ++ i) { - put (normal_pmap, *it, normals[i]); + put (normal_map, *it, normals[i]); } } else #endif { - for(it = first; it != beyond; it++) + for(it = points.begin(); it != points.end(); it++) { Vector normal = internal::jet_estimate_normal( - get(point_pmap,*it), + get(point_map,*it), tree, k, degree_fitting); - put(normal_pmap, *it, normal); // normal_pmap[it] = normal + put(normal_map, *it, normal); // normal_map[it] = normal } } @@ -258,20 +272,68 @@ jet_estimate_normals( CGAL_TRACE("End of jet_estimate_normals()\n"); } +/// \ingroup PkgPointSetProcessingAlgorithms +/// Estimates normal directions of the `[first, beyond)` range of points +/// using jet fitting on the k nearest neighbors. +/// The output normals are randomly oriented. +/// +/// \pre `k >= 2` +/// +/// @tparam ConcurrencyTag enables sequential versus parallel algorithm. +/// Possible values are `Sequential_tag` +/// and `Parallel_tag`. +/// @tparam ForwardIterator iterator model of the concept of the same name over input points and able to store output normals. +/// @tparam PointMap is a model of `ReadablePropertyMap` with value type `Point_3`. +/// It can be omitted if the value type of `ForwardIterator` is convertible to `Point_3`. +/// @tparam NormalMap is a model of `WritablePropertyMap` with value type `Vector_3`. +/// @tparam Kernel Geometric traits class. +/// It can be omitted and deduced automatically from the value type of `PointMap`. +/// @tparam SvdTraits template parameter for the class `Monge_via_jet_fitting` that +/// can be ommited under conditions described in the documentation of `Monge_via_jet_fitting`. + +// This variant requires all parameters. +template +void +jet_estimate_normals( + ForwardIterator first, ///< iterator over the first input point. + ForwardIterator beyond, ///< past-the-end iterator over the input points. + PointMap point_map, ///< property map: value_type of ForwardIterator -> Point_3. + NormalMap normal_map, ///< property map: value_type of ForwardIterator -> Vector_3. + unsigned int k, ///< number of neighbors. + const Kernel& /*kernel*/, ///< geometric traits. + unsigned int degree_fitting = 2) ///< fitting degree +{ + CGAL_POINT_SET_PROCESSING_DEPRECATED_V1_API("jet_estimate_normals()"); + CGAL::Iterator_range points (first, beyond); + return jet_estimate_normals + (points, + k, + CGAL::parameters::point_map (point_map). + normal_map (normal_map). + degree_fitting (degree_fitting). + geom_traits(Kernel())); +} + #if defined(CGAL_EIGEN3_ENABLED) || defined(CGAL_LAPACK_ENABLED) /// @cond SKIP_IN_MANUAL -template void jet_estimate_normals( ForwardIterator first, ForwardIterator beyond, - PointPMap point_pmap, - NormalPMap normal_pmap, + PointMap point_map, + NormalMap normal_map, unsigned int k, const Kernel& kernel, unsigned int degree_fitting = 2) @@ -281,59 +343,67 @@ jet_estimate_normals( #else typedef Lapack_svd SvdTraits; #endif - jet_estimate_normals( - first, beyond, point_pmap, normal_pmap, k, kernel, degree_fitting); + + CGAL_POINT_SET_PROCESSING_DEPRECATED_V1_API("jet_estimate_normals()"); + CGAL::Iterator_range points (first, beyond); + return jet_estimate_normals + (points, + k, + CGAL::parameters::point_map (point_map). + normal_map (normal_map). + degree_fitting (degree_fitting). + svd_traits (SvdTraits()). + geom_traits(kernel)); } /// @cond SKIP_IN_MANUAL // This variant deduces the kernel from the point property map. -template void jet_estimate_normals( ForwardIterator first, ///< iterator over the first input point. ForwardIterator beyond, ///< past-the-end iterator over the input points. - PointPMap point_pmap, ///< property map: value_type of ForwardIterator -> Point_3. - NormalPMap normal_pmap, ///< property map: value_type of ForwardIterator -> Vector_3. + PointMap point_map, ///< property map: value_type of ForwardIterator -> Point_3. + NormalMap normal_map, ///< property map: value_type of ForwardIterator -> Vector_3. unsigned int k, ///< number of neighbors. unsigned int degree_fitting = 2) { - typedef typename boost::property_traits::value_type Point; - typedef typename Kernel_traits::Kernel Kernel; - jet_estimate_normals( - first,beyond, - point_pmap, - normal_pmap, - k, - Kernel(), - degree_fitting); + CGAL_POINT_SET_PROCESSING_DEPRECATED_V1_API("jet_estimate_normals()"); + CGAL::Iterator_range points (first, beyond); + return jet_estimate_normals + (points, + k, + CGAL::parameters::point_map (point_map). + normal_map (normal_map). + degree_fitting (degree_fitting)); } /// @endcond /// @cond SKIP_IN_MANUAL // This variant creates a default point property map = Identity_property_map. -template void jet_estimate_normals( ForwardIterator first, ///< iterator over the first input point. ForwardIterator beyond, ///< past-the-end iterator over the input points. - NormalPMap normal_pmap, ///< property map: value_type of ForwardIterator -> Vector_3. + NormalMap normal_map, ///< property map: value_type of ForwardIterator -> Vector_3. unsigned int k, ///< number of neighbors. unsigned int degree_fitting = 2) { - jet_estimate_normals( - first,beyond, - make_identity_property_map( - typename std::iterator_traits::value_type()), - normal_pmap, - k, - degree_fitting); + CGAL_POINT_SET_PROCESSING_DEPRECATED_V1_API("jet_estimate_normals()"); + CGAL::Iterator_range points (first, beyond); + return jet_estimate_normals + (points, + k, + CGAL::parameters::normal_map (normal_map). + degree_fitting (degree_fitting)); } /// @endcond #endif diff --git a/Point_set_processing_3/include/CGAL/jet_smooth_point_set.h b/Point_set_processing_3/include/CGAL/jet_smooth_point_set.h index 8cd66aa1638..c998ca20751 100644 --- a/Point_set_processing_3/include/CGAL/jet_smooth_point_set.h +++ b/Point_set_processing_3/include/CGAL/jet_smooth_point_set.h @@ -31,6 +31,9 @@ #include #include +#include +#include + #include #include @@ -159,35 +162,43 @@ jet_smooth_point( /// /// \pre `k >= 2` /// -/// @tparam Concurrency_tag enables sequential versus parallel algorithm. +/// @tparam ConcurrencyTag enables sequential versus parallel algorithm. /// Possible values are `Sequential_tag` /// and `Parallel_tag`. /// @tparam InputIterator iterator over input points. -/// @tparam PointPMap is a model of `ReadWritePropertyMap` with value type `Point_3`. +/// @tparam PointMap is a model of `ReadWritePropertyMap` with value type `Point_3`. /// It can be omitted if the value type of `InputIterator` is convertible to `Point_3`. /// @tparam Kernel Geometric traits class. -/// It can be omitted and deduced automatically from the value type of `PointPMap`. +/// It can be omitted and deduced automatically from the value type of `PointMap`. /// @tparam SvdTraits template parameter for the class `Monge_via_jet_fitting` that /// can be ommited under conditions described in the documentation of `Monge_via_jet_fitting`. // This variant requires all parameters. -template void jet_smooth_point_set( - InputIterator first, ///< iterator over the first input point. - InputIterator beyond, ///< past-the-end iterator over the input points. - PointPMap point_pmap, ///< property map: value_type of InputIterator -> Point_3. + PointRange& points, unsigned int k, ///< number of neighbors. - const Kernel& /*kernel*/, ///< geometric traits. - unsigned int degree_fitting = 2, ///< fitting degree - unsigned int degree_monge = 2) ///< Monge degree + const NamedParameters& np) { + using boost::choose_param; + // basic geometric types + typedef typename Point_set_processing_3::GetPointMap::type PointMap; + typedef typename Point_set_processing_3::GetK::Kernel Kernel; + typedef typename GetSvdTraits::type SvdTraits; + + CGAL_static_assertion_msg(!(boost::is_same::NoMap>::value), + "Error: no SVD traits"); + + PointMap point_map = choose_param(get_param(np, internal_np::point_map), PointMap()); + unsigned int degree_fitting = choose_param(get_param(np, internal_np::degree_fitting), 2); + unsigned int degree_monge = choose_param(get_param(np, internal_np::degree_monge), 2); + typedef typename Kernel::Point_3 Point; // types for K nearest neighbors search structure @@ -198,28 +209,28 @@ jet_smooth_point_set( // precondition: at least one element in the container. // to fix: should have at least three distinct points // but this is costly to check - CGAL_point_set_processing_precondition(first != beyond); + CGAL_point_set_processing_precondition(points.begin() != points.end()); // precondition: at least 2 nearest neighbors CGAL_point_set_processing_precondition(k >= 2); - InputIterator it; + typename PointRange::iterator it; // Instanciate a KD-tree search. // Note: We have to convert each input iterator to Point_3. std::vector kd_tree_points; - for(it = first; it != beyond; it++) - kd_tree_points.push_back(get(point_pmap, *it)); + for(it = points.begin(); it != points.end(); it++) + kd_tree_points.push_back(get(point_map, *it)); Tree tree(kd_tree_points.begin(), kd_tree_points.end()); // Iterates over input points and mutates them. // Implementation note: the cast to Point& allows to modify only the point's position. #ifndef CGAL_LINKED_WITH_TBB - CGAL_static_assertion_msg (!(boost::is_convertible::value), + CGAL_static_assertion_msg (!(boost::is_convertible::value), "Parallel_tag is enabled but TBB is unavailable."); #else - if (boost::is_convertible::value) + if (boost::is_convertible::value) { std::vector mutated_points (kd_tree_points.size ()); CGAL::internal::Jet_smooth_pwns @@ -227,38 +238,94 @@ jet_smooth_point_set( mutated_points); tbb::parallel_for(tbb::blocked_range(0, kd_tree_points.size ()), f); unsigned int i = 0; - for(it = first; it != beyond; ++ it, ++ i) + for(it = points.begin(); it != points.end(); ++ it, ++ i) { - put(point_pmap, *it, mutated_points[i]); + put(point_map, *it, mutated_points[i]); } } else #endif { - for(it = first; it != beyond; it++) + for(it = points.begin(); it != points.end(); it++) { - const typename boost::property_traits::reference p = get(point_pmap, *it); - put(point_pmap, *it , + const typename boost::property_traits::reference p = get(point_map, *it); + put(point_map, *it , internal::jet_smooth_point( p,tree,k,degree_fitting,degree_monge) ); } } } +template +void +jet_smooth_point_set( + PointRange& points, + unsigned int k) ///< number of neighbors. +{ + jet_smooth_point_set (points, k, CGAL::parameters::all_default()); +} + +/// Smoothes the `[first, beyond)` range of points using jet fitting on the k +/// nearest neighbors and reprojection onto the jet. +/// As this method relocates the points, it +/// should not be called on containers sorted w.r.t. point locations. +/// +/// \pre `k >= 2` +/// +/// @tparam ConcurrencyTag enables sequential versus parallel algorithm. +/// Possible values are `Sequential_tag` +/// and `Parallel_tag`. +/// @tparam InputIterator iterator over input points. +/// @tparam PointMap is a model of `ReadWritePropertyMap` with value type `Point_3`. +/// It can be omitted if the value type of `InputIterator` is convertible to `Point_3`. +/// @tparam Kernel Geometric traits class. +/// It can be omitted and deduced automatically from the value type of `PointMap`. +/// @tparam SvdTraits template parameter for the class `Monge_via_jet_fitting` that +/// can be ommited under conditions described in the documentation of `Monge_via_jet_fitting`. + +// This variant requires all parameters. +template +void +jet_smooth_point_set( + InputIterator first, ///< iterator over the first input point. + InputIterator beyond, ///< past-the-end iterator over the input points. + PointMap point_map, ///< property map: value_type of InputIterator -> Point_3. + unsigned int k, ///< number of neighbors. + const Kernel& /*kernel*/, ///< geometric traits. + unsigned int degree_fitting = 2, ///< fitting degree + unsigned int degree_monge = 2) ///< Monge degree +{ + CGAL_POINT_SET_PROCESSING_DEPRECATED_V1_API("jet_smooth_point_set()"); + CGAL::Iterator_range points (first, beyond); + return jet_smooth_point_set + (points, + k, + CGAL::parameters::point_map (point_map). + degree_fitting (degree_fitting). + degree_monge (degree_monge). + geom_traits(Kernel())); +} + #if defined(CGAL_EIGEN3_ENABLED) || defined(CGAL_LAPACK_ENABLED) /// @cond SKIP_IN_MANUAL -template void jet_smooth_point_set( InputIterator first, ///< iterator over the first input point. InputIterator beyond, ///< past-the-end iterator over the input points. - PointPMap point_pmap, ///< property map: value_type of InputIterator -> Point_3. + PointMap point_map, ///< property map: value_type of InputIterator -> Point_3. unsigned int k, ///< number of neighbors. const Kernel& kernel, ///< geometric traits. unsigned int degree_fitting = 2, ///< fitting degree @@ -269,39 +336,47 @@ jet_smooth_point_set( #else typedef Lapack_svd SvdTraits; #endif - jet_smooth_point_set( - first, beyond, point_pmap, k, kernel, degree_fitting, degree_monge); + CGAL_POINT_SET_PROCESSING_DEPRECATED_V1_API("jet_smooth_point_set()"); + CGAL::Iterator_range points (first, beyond); + return jet_smooth_point_set + (points, + k, + CGAL::parameters::point_map (point_map). + degree_fitting (degree_fitting). + degree_monge (degree_monge). + svd_traits (SvdTraits()), + geom_traits(kernel)); } /// @cond SKIP_IN_MANUAL // This variant deduces the kernel from the point property map. -template void jet_smooth_point_set( InputIterator first, ///< iterator over the first input point InputIterator beyond, ///< past-the-end iterator - PointPMap point_pmap, ///< property map: value_type of InputIterator -> Point_3 + PointMap point_map, ///< property map: value_type of InputIterator -> Point_3 unsigned int k, ///< number of neighbors. const unsigned int degree_fitting = 2, const unsigned int degree_monge = 2) { - typedef typename boost::property_traits::value_type Point; - typedef typename Kernel_traits::Kernel Kernel; - jet_smooth_point_set( - first,beyond, - point_pmap, - k, - Kernel(), - degree_fitting,degree_monge); + CGAL_POINT_SET_PROCESSING_DEPRECATED_V1_API("jet_smooth_point_set()"); + CGAL::Iterator_range points (first, beyond); + return jet_smooth_point_set + (points, + k, + CGAL::parameters::point_map (point_map). + degree_fitting (degree_fitting). + degree_monge (degree_monge)); } /// @endcond /// @cond SKIP_IN_MANUAL // This variant creates a default point property map = Identity_property_map. -template void @@ -312,12 +387,13 @@ jet_smooth_point_set( const unsigned int degree_fitting = 2, const unsigned int degree_monge = 2) { - jet_smooth_point_set( - first,beyond, - make_identity_property_map( - typename std::iterator_traits::value_type()), - k, - degree_fitting,degree_monge); + CGAL_POINT_SET_PROCESSING_DEPRECATED_V1_API("jet_smooth_point_set()"); + CGAL::Iterator_range points (first, beyond); + return jet_smooth_point_set + (points, + k, + CGAL::parameters::degree_fitting (degree_fitting). + degree_monge (degree_monge)); } /// @endcond #endif diff --git a/Point_set_processing_3/include/CGAL/mst_orient_normals.h b/Point_set_processing_3/include/CGAL/mst_orient_normals.h index a9bd52e0211..c9b77e16358 100644 --- a/Point_set_processing_3/include/CGAL/mst_orient_normals.h +++ b/Point_set_processing_3/include/CGAL/mst_orient_normals.h @@ -34,6 +34,9 @@ #include #include +#include +#include + #include #include #include @@ -102,7 +105,7 @@ struct MST_graph_vertex_properties { bool is_oriented; ///< Is input point's normal oriented? }; template Normal + typename NormalMap, ///< property map: value_type of ForwardIterator -> Normal typename Kernel ///< Geometric traits class > class MST_graph @@ -111,10 +114,10 @@ class MST_graph MST_graph_vertex_properties > { public: - MST_graph(NormalPMap normal_pmap) : m_normal_pmap(normal_pmap) {} + MST_graph(NormalMap normal_map) : m_normal_map(normal_map) {} // Public data - const NormalPMap m_normal_pmap; + const NormalMap m_normal_map; }; @@ -130,17 +133,17 @@ public: /// \pre `0 < angle_max <= PI/2` /// /// @tparam ForwardIterator iterator over input points. -/// @tparam NormalPMap is a model of `ReadWritePropertyMap`. +/// @tparam NormalMap is a model of `ReadWritePropertyMap`. /// @tparam Kernel Geometric traits class. template Normal + typename NormalMap, ///< property map: value_type of ForwardIterator -> Normal typename Kernel > struct Propagate_normal_orientation - : public boost::base_visitor< Propagate_normal_orientation > + : public boost::base_visitor< Propagate_normal_orientation > { - typedef internal::MST_graph MST_graph; + typedef internal::MST_graph MST_graph; typedef boost::on_examine_edge event_filter; Propagate_normal_orientation(double angle_max = CGAL_PI/2.) ///< max angle to propagate the normal orientation (radians) @@ -153,16 +156,16 @@ struct Propagate_normal_orientation template void operator()(Edge& edge, const MST_graph& mst_graph) { - typedef typename boost::property_traits::reference Vector_ref; + typedef typename boost::property_traits::reference Vector_ref; typedef typename MST_graph::vertex_descriptor vertex_descriptor; // Gets source normal vertex_descriptor source_vertex = source(edge, mst_graph); - Vector_ref source_normal = get(mst_graph.m_normal_pmap, *(mst_graph[source_vertex].input_point) ); + Vector_ref source_normal = get(mst_graph.m_normal_map, *(mst_graph[source_vertex].input_point) ); const bool source_normal_is_oriented = mst_graph[source_vertex].is_oriented; // Gets target normal vertex_descriptor target_vertex = target(edge, mst_graph); - Vector_ref target_normal = get( mst_graph.m_normal_pmap, *(mst_graph[target_vertex].input_point) ); + Vector_ref target_normal = get( mst_graph.m_normal_map, *(mst_graph[target_vertex].input_point) ); bool& target_normal_is_oriented = ((MST_graph&)mst_graph)[target_vertex].is_oriented; if ( ! target_normal_is_oriented ) { @@ -171,7 +174,7 @@ struct Propagate_normal_orientation double normals_dot = source_normal * target_normal; if (normals_dot < 0) { - put( mst_graph.m_normal_pmap, *(mst_graph[target_vertex].input_point), -target_normal ); + put( mst_graph.m_normal_map, *(mst_graph[target_vertex].input_point), -target_normal ); } // Is orientation robust? @@ -190,29 +193,29 @@ private: /// Orients the normal of the point with maximum Z towards +Z axis. /// /// @tparam ForwardIterator iterator over input points. -/// @tparam PointPMap is a model of `ReadablePropertyMap` with a value_type = Point_3. -/// @tparam NormalPMap is a model of `ReadWritePropertyMap` with a value_type = Vector_3. +/// @tparam PointMap is a model of `ReadablePropertyMap` with a value_type = Point_3. +/// @tparam NormalMap is a model of `ReadWritePropertyMap` with a value_type = Vector_3. /// @tparam Kernel Geometric traits class. /// /// @return iterator over the top point. template ForwardIterator mst_find_source( ForwardIterator first, ///< iterator over the first input point. ForwardIterator beyond, ///< past-the-end iterator over the input points. - PointPMap point_pmap, ///< property map: value_type of ForwardIterator -> Point_3 - NormalPMap normal_pmap, ///< property map: value_type of ForwardIterator -> Vector_3 + PointMap point_map, ///< property map: value_type of ForwardIterator -> Point_3 + NormalMap normal_map, ///< property map: value_type of ForwardIterator -> Vector_3 const Kernel& /*kernel*/) ///< geometric traits. { CGAL_TRACE(" mst_find_source()\n"); // Input points types - typedef typename boost::property_traits::value_type Vector; - typedef typename boost::property_traits::reference Vector_ref; + typedef typename boost::property_traits::value_type Vector; + typedef typename boost::property_traits::reference Vector_ref; // Precondition: at least one element in the container CGAL_point_set_processing_precondition(first != beyond); @@ -222,19 +225,19 @@ mst_find_source( for (ForwardIterator v = ++first; v != beyond; v++) { - double top_z = get(point_pmap,*top_point).z(); // top_point's Z coordinate - double z = get(point_pmap,*v).z(); + double top_z = get(point_map,*top_point).z(); // top_point's Z coordinate + double z = get(point_map,*v).z(); if (top_z < z) top_point = v; } // Orients its normal towards +Z axis - Vector_ref normal = get(normal_pmap,*top_point); + Vector_ref normal = get(normal_map,*top_point); const Vector Z(0, 0, 1); if (Z * normal < 0) { CGAL_TRACE(" Flip top point normal\n"); - put(normal_pmap,*top_point, -normal); + put(normal_map,*top_point, -normal); } return top_point; @@ -250,31 +253,31 @@ mst_find_source( /// \pre `k >= 2` /// /// @tparam ForwardIterator iterator over input points. -/// @tparam IndexPMap is a model of `ReadablePropertyMap` with an integral value_type. -/// @tparam PointPMap is a model of `ReadablePropertyMap` with a value_type = Point_3. -/// @tparam NormalPMap is a model of `ReadWritePropertyMap` with a value_type = Vector_3. +/// @tparam IndexMap is a model of `ReadablePropertyMap` with an integral value_type. +/// @tparam PointMap is a model of `ReadablePropertyMap` with a value_type = Point_3. +/// @tparam NormalMap is a model of `ReadWritePropertyMap` with a value_type = Vector_3. /// @tparam Kernel Geometric traits class. /// /// @return the Riemannian graph template Riemannian_graph create_riemannian_graph( ForwardIterator first, ///< iterator over the first input point. ForwardIterator beyond, ///< past-the-end iterator over the input points. - PointPMap point_pmap, ///< property map: value_type of ForwardIterator -> Point_3 - NormalPMap normal_pmap, ///< property map: value_type of ForwardIterator -> Vector_3 - IndexPMap index_pmap, ///< property map ForwardIterator -> index + PointMap point_map, ///< property map: value_type of ForwardIterator -> Point_3 + NormalMap normal_map, ///< property map: value_type of ForwardIterator -> Vector_3 + IndexMap index_map, ///< property map ForwardIterator -> index unsigned int k, ///< number of neighbors const Kernel& /*kernel*/) ///< geometric traits. { // Input points types - typedef typename boost::property_traits::reference Point_ref; - typedef typename boost::property_traits::reference Vector_ref; + typedef typename boost::property_traits::reference Point_ref; + typedef typename boost::property_traits::reference Vector_ref; // Types for K nearest neighbors search structure typedef Point_vertex_handle_3 Point_vertex_handle_3; @@ -307,7 +310,7 @@ create_riemannian_graph( for (ForwardIterator it = first; it != beyond; it++) { - Point_ref point = get(point_pmap, *it); + Point_ref point = get(point_map, *it); Point_vertex_handle_3 point_wrapper(point.x(), point.y(), point.z(), it); kd_tree_points.push_back(point_wrapper); } @@ -330,7 +333,7 @@ create_riemannian_graph( for (ForwardIterator it = first; it != beyond; it++) { typename Riemannian_graph::vertex_descriptor v = add_vertex(riemannian_graph); - CGAL_point_set_processing_assertion(v == get(index_pmap,it)); + CGAL_point_set_processing_assertion(v == get(index_map,it)); riemannian_graph[v].input_point = it; } // @@ -338,15 +341,15 @@ create_riemannian_graph( Riemannian_graph_weight_map riemannian_graph_weight_map = get(boost::edge_weight, riemannian_graph); for (ForwardIterator it = first; it != beyond; it++) { - std::size_t it_index = get(index_pmap,it); - Vector_ref it_normal_vector = get(normal_pmap,*it); + std::size_t it_index = get(index_map,it); + Vector_ref it_normal_vector = get(normal_map,*it); // Gather set of (k+1) neighboring points. // Perform k+1 queries (as in point set, the query point is // output first). Search may be aborted if k is greater // than number of input points. - Point_ref point = get(point_pmap, *it); + Point_ref point = get(point_map, *it); Point_vertex_handle_3 point_wrapper(point.x(), point.y(), point.z(), it); Neighbor_search search(*tree, point_wrapper, k+1); Search_iterator search_iterator = search.begin(); @@ -356,7 +359,7 @@ create_riemannian_graph( break; // premature ending ForwardIterator neighbor = search_iterator->first; - std::size_t neighbor_index = get(index_pmap,neighbor); + std::size_t neighbor_index = get(index_map,neighbor); if (neighbor_index > it_index) // undirected graph { // Add edge @@ -371,7 +374,7 @@ create_riemannian_graph( // Computes edge weight = 1 - | normal1 * normal2 | // where normal1 and normal2 are the normal at the edge extremities. - Vector_ref neighbor_normal_vector = get(normal_pmap,*neighbor); + Vector_ref neighbor_normal_vector = get(normal_map,*neighbor); double weight = 1.0 - std::abs(it_normal_vector * neighbor_normal_vector); if (weight < 0) weight = 0; // safety check @@ -393,32 +396,32 @@ create_riemannian_graph( /// \pre Normals must be unit vectors. /// /// @tparam ForwardIterator iterator over input points. -/// @tparam IndexPMap is a model of `ReadablePropertyMap` with an integral value_type. -/// @tparam PointPMap is a model of `ReadablePropertyMap` with a value_type = Point_3. -/// @tparam NormalPMap is a model of `ReadWritePropertyMap` with a value_type = Vector_3. +/// @tparam IndexMap is a model of `ReadablePropertyMap` with an integral value_type. +/// @tparam PointMap is a model of `ReadablePropertyMap` with a value_type = Point_3. +/// @tparam NormalMap is a model of `ReadWritePropertyMap` with a value_type = Vector_3. /// @tparam Kernel Geometric traits class. /// /// @return the MST graph. template -MST_graph +MST_graph create_mst_graph( ForwardIterator first, ///< iterator over the first input point. ForwardIterator beyond, ///< past-the-end iterator over the input points. - PointPMap point_pmap, ///< property map: value_type of ForwardIterator -> Point_3 - NormalPMap normal_pmap, ///< property map: value_type of ForwardIterator -> Vector_3 - IndexPMap index_pmap, ///< property map ForwardIterator -> index + PointMap point_map, ///< property map: value_type of ForwardIterator -> Point_3 + NormalMap normal_map, ///< property map: value_type of ForwardIterator -> Vector_3 + IndexMap index_map, ///< property map ForwardIterator -> index unsigned int k, ///< number of neighbors const Kernel& kernel, ///< geometric traits. const Riemannian_graph& riemannian_graph, ///< graph connecting each vertex to its knn ForwardIterator source_point) ///< source point (with an oriented normal) { // prevents warnings - CGAL_USE(point_pmap); + CGAL_USE(point_map); CGAL_USE(k); CGAL_USE(kernel); @@ -430,7 +433,7 @@ create_mst_graph( typedef typename boost::property_map::const_type Riemannian_graph_weight_map; // MST_graph types - typedef internal::MST_graph MST_graph; + typedef internal::MST_graph MST_graph; // Precondition: at least one element in the container. CGAL_point_set_processing_precondition(first != beyond); @@ -442,7 +445,7 @@ create_mst_graph( CGAL_TRACE(" Calls boost::prim_minimum_spanning_tree()\n"); // Computes Minimum Spanning Tree. - std::size_t source_point_index = get(index_pmap, source_point); + std::size_t source_point_index = get(index_map, source_point); Riemannian_graph_weight_map riemannian_graph_weight_map = get(boost::edge_weight, riemannian_graph); typedef std::vector PredecessorMap; PredecessorMap predecessor(num_input_points); @@ -457,7 +460,7 @@ create_mst_graph( // - vertices are numbered like the input points index. // - vertices contain the corresponding input point iterator. // - we add the edge (predecessor[i], i) for each element of the predecessor map. - MST_graph mst_graph(normal_pmap); + MST_graph mst_graph(normal_map); // // Add vertices. source_point is the unique point marked "oriented". for (ForwardIterator it = first; it != beyond; it++) @@ -466,7 +469,7 @@ create_mst_graph( // 1.56 and 1.57: // https://svn.boost.org/trac/boost/ticket/10382 typename MST_graph::vertex_descriptor v = add_vertex(mst_graph); - CGAL_point_set_processing_assertion(v == get(index_pmap,it)); + CGAL_point_set_processing_assertion(v == get(index_map,it)); mst_graph[v].input_point = it; mst_graph[v].is_oriented = (it == source_point); } @@ -508,47 +511,55 @@ create_mst_graph( /// \pre `k >= 2` /// /// @tparam ForwardIterator iterator over input points. -/// @tparam PointPMap is a model of `ReadablePropertyMap` with value type `Point_3`. +/// @tparam PointMap is a model of `ReadablePropertyMap` with value type `Point_3`. /// It can be omitted if the value type of `ForwardIterator` is convertible to `Point_3`. -/// @tparam NormalPMap is a model of `ReadWritePropertyMap` with value type `Vector_3` . +/// @tparam NormalMap is a model of `ReadWritePropertyMap` with value type `Vector_3` . /// @tparam Kernel Geometric traits class. -/// It can be omitted and deduced automatically from the value type of `PointPMap`. +/// It can be omitted and deduced automatically from the value type of `PointMap`. /// /// @return iterator over the first point with an unoriented normal. // This variant requires all parameters. -template -ForwardIterator +typename PointRange::iterator mst_orient_normals( - ForwardIterator first, ///< iterator over the first input point. - ForwardIterator beyond, ///< past-the-end iterator over the input points. - PointPMap point_pmap, ///< property map: value_type of ForwardIterator -> Point_3. - NormalPMap normal_pmap, ///< property map: value_type of ForwardIterator -> Vector_3. - unsigned int k, ///< number of neighbors - const Kernel& kernel) ///< geometric traits. + PointRange& points, + unsigned int k, ///< number of neighbors + const NamedParameters& np) { + using boost::choose_param; CGAL_TRACE("Calls mst_orient_normals()\n"); - // Bring private stuff to scope + typedef typename Point_set_processing_3::GetPointMap::type PointMap; + typedef typename Point_set_processing_3::GetNormalMap::type NormalMap; + typedef typename Point_set_processing_3::GetK::Kernel Kernel; + + CGAL_static_assertion_msg(!(boost::is_same::NoMap>::value), + "Error: no normal map"); + + PointMap point_map = choose_param(get_param(np, internal_np::point_map), PointMap()); + NormalMap normal_map = choose_param(get_param(np, internal_np::normal_map), NormalMap()); + Kernel kernel; + + // Bring private stuff to scope using namespace internal; // Input points types - typedef typename std::iterator_traits::value_type Enriched_point; // actual type of input points - // Property map ForwardIterator -> index - typedef Index_property_map IndexPMap; + typedef typename std::iterator_traits::value_type Enriched_point; // actual type of input points + // Property map typename PointRange::iterator -> index + typedef Index_property_map IndexMap; // Riemannian_graph types - typedef Riemannian_graph Riemannian_graph; + typedef Riemannian_graph Riemannian_graph; // MST_graph types - typedef MST_graph MST_graph; + typedef MST_graph MST_graph; // Precondition: at least one element in the container. - CGAL_point_set_processing_precondition(first != beyond); + CGAL_point_set_processing_precondition(points.begin() != points.end()); // Precondition: at least 2 nearest neighbors CGAL_point_set_processing_precondition(k >= 2); @@ -557,16 +568,16 @@ mst_orient_normals( CGAL_TRACE(" Create Index_property_map\n"); // Create a property map Iterator -> index. - // - if ForwardIterator is a random access iterator (typically vector and deque), + // - if typename PointRange::iterator is a random access iterator (typically vector and deque), // get() just calls std::distance() and is very efficient; // - else, the property map allocates a std::map to store indices // and get() requires a lookup in the map. - IndexPMap index_pmap(first, beyond); + IndexMap index_map(points.begin(), points.end()); // Orients the normal of the point with maximum Z towards +Z axis. - ForwardIterator source_point - = mst_find_source(first, beyond, - point_pmap, normal_pmap, + typename PointRange::iterator source_point + = mst_find_source(points.begin(), points.end(), + point_map, normal_map, kernel); // Iterates over input points and creates Riemannian Graph: @@ -575,14 +586,14 @@ mst_orient_normals( // - we add the edge (i, j) if either vertex i is in the k-neighborhood of vertex j, // or vertex j is in the k-neighborhood of vertex i. Riemannian_graph riemannian_graph - = create_riemannian_graph(first, beyond, - point_pmap, normal_pmap, index_pmap, + = create_riemannian_graph(points.begin(), points.end(), + point_map, normal_map, index_map, k, kernel); // Creates a Minimum Spanning Tree starting at source_point - MST_graph mst_graph = create_mst_graph(first, beyond, - point_pmap, normal_pmap, index_pmap, + MST_graph mst_graph = create_mst_graph(points.begin(), points.end(), + point_map, normal_map, index_map, k, kernel, riemannian_graph, @@ -592,17 +603,17 @@ mst_orient_normals( CGAL_TRACE(" Calls boost::breadth_first_search()\n"); // Traverse the point set along the MST to propagate source_point's orientation - Propagate_normal_orientation orienter; - std::size_t source_point_index = get(index_pmap, source_point); + Propagate_normal_orientation orienter; + std::size_t source_point_index = get(index_map, source_point); boost::breadth_first_search(mst_graph, vertex(source_point_index, mst_graph), // source visitor(boost::make_bfs_visitor(orienter))); // Copy points with robust normal orientation to oriented_points[], the others to unoriented_points[]. std::deque oriented_points, unoriented_points; - for (ForwardIterator it = first; it != beyond; it++) + for (typename PointRange::iterator it = points.begin(); it != points.end(); it++) { - std::size_t it_index = get(index_pmap,it); + std::size_t it_index = get(index_map,it); typename MST_graph::vertex_descriptor v = vertex(it_index, mst_graph); if (mst_graph[v].is_oriented) oriented_points.push_back(*it); @@ -610,9 +621,9 @@ mst_orient_normals( unoriented_points.push_back(*it); } - // Replaces [first, beyond) range by the content of oriented_points[], then unoriented_points[]. - ForwardIterator first_unoriented_point = - std::copy(oriented_points.begin(), oriented_points.end(), first); + // Replaces [points.begin(), points.end()) range by the content of oriented_points[], then unoriented_points[]. + typename PointRange::iterator first_unoriented_point = + std::copy(oriented_points.begin(), oriented_points.end(), points.begin()); std::copy(unoriented_points.begin(), unoriented_points.end(), first_unoriented_point); // At this stage, we have typically 0 unoriented normals if k is large enough @@ -624,49 +635,94 @@ mst_orient_normals( return first_unoriented_point; } -/// @cond SKIP_IN_MANUAL -// This variant deduces the kernel from the point property map. +/// Orients the normals of the `[first, beyond)` range of points using the propagation +/// of a seed orientation through a minimum spanning tree of the Riemannian graph [Hoppe92]. +/// +/// This method modifies the order of input points so as to pack all sucessfully oriented points first, +/// and returns an iterator over the first point with an unoriented normal (see erase-remove idiom). +/// For this reason it should not be called on sorted containers. +/// \warning This function may fail when Boost version 1.54 is used, +/// because of the following bug: https://svn.boost.org/trac/boost/ticket/9012 +/// +/// \pre Normals must be unit vectors +/// \pre `k >= 2` +/// +/// @tparam ForwardIterator iterator over input points. +/// @tparam PointMap is a model of `ReadablePropertyMap` with value type `Point_3`. +/// It can be omitted if the value type of `ForwardIterator` is convertible to `Point_3`. +/// @tparam NormalMap is a model of `ReadWritePropertyMap` with value type `Vector_3` . +/// @tparam Kernel Geometric traits class. +/// It can be omitted and deduced automatically from the value type of `PointMap`. +/// +/// @return iterator over the first point with an unoriented normal. + +// This variant requires all parameters. template ForwardIterator mst_orient_normals( ForwardIterator first, ///< iterator over the first input point. ForwardIterator beyond, ///< past-the-end iterator over the input points. - PointPMap point_pmap, ///< property map: value_type of ForwardIterator -> Point_3. - NormalPMap normal_pmap, ///< property map: value_type of ForwardIterator -> Vector_3. + PointMap point_map, ///< property map: value_type of ForwardIterator -> Point_3. + NormalMap normal_map, ///< property map: value_type of ForwardIterator -> Vector_3. + unsigned int k, ///< number of neighbors + const Kernel& kernel) ///< geometric traits. +{ + CGAL_POINT_SET_PROCESSING_DEPRECATED_V1_API("mst_orient_normals()"); + CGAL::Iterator_range points (first, beyond); + return mst_orient_normals + (points, + k, + CGAL::parameters::point_map (point_map). + normal_map (normal_map). + geom_traits(kernel)); +} + +/// @cond SKIP_IN_MANUAL +// This variant deduces the kernel from the point property map. +template +ForwardIterator +mst_orient_normals( + ForwardIterator first, ///< iterator over the first input point. + ForwardIterator beyond, ///< past-the-end iterator over the input points. + PointMap point_map, ///< property map: value_type of ForwardIterator -> Point_3. + NormalMap normal_map, ///< property map: value_type of ForwardIterator -> Vector_3. unsigned int k) ///< number of neighbors { - typedef typename boost::property_traits::value_type Point; - typedef typename Kernel_traits::Kernel Kernel; - return mst_orient_normals( - first,beyond, - point_pmap, - normal_pmap, - k, - Kernel()); + CGAL_POINT_SET_PROCESSING_DEPRECATED_V1_API("mst_orient_normals()"); + CGAL::Iterator_range points (first, beyond); + return mst_orient_normals + (points, + k, + CGAL::parameters::point_map (point_map). + normal_map (normal_map)); } /// @endcond /// @cond SKIP_IN_MANUAL // This variant creates a default point property map = Identity_property_map. template ForwardIterator mst_orient_normals( ForwardIterator first, ///< iterator over the first input point. ForwardIterator beyond, ///< past-the-end iterator over the input points. - NormalPMap normal_pmap, ///< property map: value_type of ForwardIterator -> Vector_3. + NormalMap normal_map, ///< property map: value_type of ForwardIterator -> Vector_3. unsigned int k) ///< number of neighbors { - return mst_orient_normals( - first,beyond, - make_identity_property_map( - typename std::iterator_traits::value_type()), - normal_pmap, - k); + CGAL_POINT_SET_PROCESSING_DEPRECATED_V1_API("mst_orient_normals()"); + CGAL::Iterator_range points (first, beyond); + return mst_orient_normals + (points, + k, + CGAL::parameters::normal_map (normal_map)); } /// @endcond diff --git a/Point_set_processing_3/include/CGAL/pca_estimate_normals.h b/Point_set_processing_3/include/CGAL/pca_estimate_normals.h index edc126a785e..b9fd63d4dad 100644 --- a/Point_set_processing_3/include/CGAL/pca_estimate_normals.h +++ b/Point_set_processing_3/include/CGAL/pca_estimate_normals.h @@ -33,6 +33,9 @@ #include #include +#include +#include + #include #include @@ -146,39 +149,46 @@ pca_estimate_normal(const typename Kernel::Point_3& query, ///< point to compute /// /// \pre `k >= 2` /// -/// @tparam Concurrency_tag enables sequential versus parallel algorithm. +/// @tparam ConcurrencyTag enables sequential versus parallel algorithm. /// Possible values are `Sequential_tag` /// and `Parallel_tag`. /// @tparam ForwardIterator iterator over input points. -/// @tparam PointPMap is a model of `ReadablePropertyMap` with value type `Point_3`. +/// @tparam PointMap is a model of `ReadablePropertyMap` with value type `Point_3`. /// It can be omitted if the value type of `ForwardIterator` is convertible to `Point_3`. -/// @tparam NormalPMap is a model of `WritablePropertyMap` with value type `Vector_3`. +/// @tparam NormalMap is a model of `WritablePropertyMap` with value type `Vector_3`. /// @tparam Kernel Geometric traits class. -/// It can be omitted and deduced automatically from the value type of `PointPMap`. +/// It can be omitted and deduced automatically from the value type of `PointMap`. // This variant requires all parameters. -template void pca_estimate_normals( - ForwardIterator first, ///< iterator over the first input point. - ForwardIterator beyond, ///< past-the-end iterator over the input points. - PointPMap point_pmap, ///< property map: value_type of ForwardIterator -> Point_3. - NormalPMap normal_pmap, ///< property map: value_type of ForwardIterator -> Vector_3. + PointRange& points, unsigned int k, ///< number of neighbors. - const Kernel& /*kernel*/) ///< geometric traits. + const NamedParameters& np) { + using boost::choose_param; CGAL_TRACE("Calls pca_estimate_normals()\n"); // basic geometric types + typedef typename Point_set_processing_3::GetPointMap::type PointMap; + typedef typename Point_set_processing_3::GetNormalMap::type NormalMap; + typedef typename Point_set_processing_3::GetK::Kernel Kernel; + + CGAL_static_assertion_msg(!(boost::is_same::NoMap>::value), + "Error: no normal map"); + + PointMap point_map = choose_param(get_param(np, internal_np::point_map), PointMap()); + NormalMap normal_map = choose_param(get_param(np, internal_np::normal_map), NormalMap()); + typedef typename Kernel::Point_3 Point; // Input points types - typedef typename boost::property_traits::value_type Vector; + typedef typename boost::property_traits::value_type Vector; // types for K nearest neighbors search structure typedef typename CGAL::Search_traits_3 Tree_traits; @@ -188,7 +198,7 @@ pca_estimate_normals( // precondition: at least one element in the container. // to fix: should have at least three distinct points // but this is costly to check - CGAL_point_set_processing_precondition(first != beyond); + CGAL_point_set_processing_precondition(points.begin() != points.end()); // precondition: at least 2 nearest neighbors CGAL_point_set_processing_precondition(k >= 2); @@ -196,13 +206,13 @@ pca_estimate_normals( std::size_t memory = CGAL::Memory_sizer().virtual_size(); CGAL_TRACE(" %ld Mb allocated\n", memory>>20); CGAL_TRACE(" Creates KD-tree\n"); - ForwardIterator it; + typename PointRange::iterator it; // Instanciate a KD-tree search. // Note: We have to convert each input iterator to Point_3. std::vector kd_tree_points; - for(it = first; it != beyond; it++) - kd_tree_points.push_back(get(point_pmap, *it)); + for(it = points.begin(); it != points.end(); it++) + kd_tree_points.push_back(get(point_map, *it)); Tree tree(kd_tree_points.begin(), kd_tree_points.end()); memory = CGAL::Memory_sizer().virtual_size(); CGAL_TRACE(" %ld Mb allocated\n", memory>>20); @@ -211,32 +221,32 @@ pca_estimate_normals( // iterate over input points, compute and output normal // vectors (already normalized) #ifndef CGAL_LINKED_WITH_TBB - CGAL_static_assertion_msg (!(boost::is_convertible::value), + CGAL_static_assertion_msg (!(boost::is_convertible::value), "Parallel_tag is enabled but TBB is unavailable."); #else - if (boost::is_convertible::value) + if (boost::is_convertible::value) { std::vector normals (kd_tree_points.size ()); CGAL::internal::PCA_estimate_normals f (tree, k, kd_tree_points, normals); tbb::parallel_for(tbb::blocked_range(0, kd_tree_points.size ()), f); unsigned int i = 0; - for(it = first; it != beyond; ++ it, ++ i) + for(it = points.begin(); it != points.end(); ++ it, ++ i) { - put (normal_pmap, *it, normals[i]); + put (normal_map, *it, normals[i]); } } else #endif { - for(it = first; it != beyond; it++) + for(it = points.begin(); it != points.end(); it++) { Vector normal = internal::pca_estimate_normal( - get(point_pmap,*it), + get(point_map,*it), tree, k); - put(normal_pmap, *it, normal); // normal_pmap[it] = normal + put(normal_map, *it, normal); // normal_map[it] = normal } } @@ -244,51 +254,92 @@ pca_estimate_normals( CGAL_TRACE("End of pca_estimate_normals()\n"); } -/// @cond SKIP_IN_MANUAL -// This variant deduces the kernel from the point property map. -template = 2` +/// +/// @tparam ConcurrencyTag enables sequential versus parallel algorithm. +/// Possible values are `Sequential_tag` +/// and `Parallel_tag`. +/// @tparam ForwardIterator iterator over input points. +/// @tparam PointMap is a model of `ReadablePropertyMap` with value type `Point_3`. +/// It can be omitted if the value type of `ForwardIterator` is convertible to `Point_3`. +/// @tparam NormalMap is a model of `WritablePropertyMap` with value type `Vector_3`. +/// @tparam Kernel Geometric traits class. +/// It can be omitted and deduced automatically from the value type of `PointMap`. + +// This variant requires all parameters. +template void pca_estimate_normals( ForwardIterator first, ///< iterator over the first input point. ForwardIterator beyond, ///< past-the-end iterator over the input points. - PointPMap point_pmap, ///< property map: value_type of ForwardIterator -> Point_3. - NormalPMap normal_pmap, ///< property map: value_type of ForwardIterator -> Vector_3. + PointMap point_map, ///< property map: value_type of ForwardIterator -> Point_3. + NormalMap normal_map, ///< property map: value_type of ForwardIterator -> Vector_3. + unsigned int k, ///< number of neighbors. + const Kernel& /*kernel*/) ///< geometric traits. +{ + CGAL_POINT_SET_PROCESSING_DEPRECATED_V1_API("pca_estimate_normals()"); + CGAL::Iterator_range points (first, beyond); + return pca_estimate_normals + (points, + k, + CGAL::parameters::point_map (point_map). + normal_map (normal_map). + geom_traits(Kernel())); +} + +/// @cond SKIP_IN_MANUAL +// This variant deduces the kernel from the point property map. +template +void +pca_estimate_normals( + ForwardIterator first, ///< iterator over the first input point. + ForwardIterator beyond, ///< past-the-end iterator over the input points. + PointMap point_map, ///< property map: value_type of ForwardIterator -> Point_3. + NormalMap normal_map, ///< property map: value_type of ForwardIterator -> Vector_3. unsigned int k) ///< number of neighbors. { - typedef typename boost::property_traits::value_type Point; - typedef typename Kernel_traits::Kernel Kernel; - pca_estimate_normals( - first,beyond, - point_pmap, - normal_pmap, - k, - Kernel()); + CGAL_POINT_SET_PROCESSING_DEPRECATED_V1_API("pca_estimate_normals()"); + CGAL::Iterator_range points (first, beyond); + return pca_estimate_normals + (points, + k, + CGAL::parameters::point_map (point_map). + normal_map (normal_map)); } /// @endcond /// @cond SKIP_IN_MANUAL // This variant creates a default point property map = Identity_property_map. -template void pca_estimate_normals( ForwardIterator first, ///< iterator over the first input point. ForwardIterator beyond, ///< past-the-end iterator over the input points. - NormalPMap normal_pmap, ///< property map: value_type of ForwardIterator -> Vector_3. + NormalMap normal_map, ///< property map: value_type of ForwardIterator -> Vector_3. unsigned int k) ///< number of neighbors. { - pca_estimate_normals( - first,beyond, - make_identity_property_map( - typename std::iterator_traits::value_type()), - normal_pmap, - k); + CGAL_POINT_SET_PROCESSING_DEPRECATED_V1_API("pca_estimate_normals()"); + CGAL::Iterator_range points (first, beyond); + return pca_estimate_normals + (points, + k, + CGAL::parameters::normal_map (normal_map)); } /// @endcond diff --git a/Point_set_processing_3/include/CGAL/point_set_processing_assertions.h b/Point_set_processing_3/include/CGAL/point_set_processing_assertions.h index 37397a99071..19eb7fac237 100644 --- a/Point_set_processing_3/include/CGAL/point_set_processing_assertions.h +++ b/Point_set_processing_3/include/CGAL/point_set_processing_assertions.h @@ -373,7 +373,7 @@ #undef CGAL_POINT_SET_PROCESSING_DEPRECATED_V1_API #define CGAL_POINT_SET_PROCESSING_DEPRECATED_V1_API(FCT) \ - std::cerr << "Warning: you are using the deprecated V1 API of the Point Set Processing\n function " \ + std::cerr << "Warning: you are using the deprecated V1 API of the Point Set Processing\nfunction " \ << FCT << ", please update your code." << std::endl /// \endcond diff --git a/Point_set_processing_3/include/CGAL/random_simplify_point_set.h b/Point_set_processing_3/include/CGAL/random_simplify_point_set.h index b39be320c18..d39c6fdca0f 100644 --- a/Point_set_processing_3/include/CGAL/random_simplify_point_set.h +++ b/Point_set_processing_3/include/CGAL/random_simplify_point_set.h @@ -27,6 +27,10 @@ #include #include #include +#include + +#include +#include #include #include @@ -43,59 +47,83 @@ namespace CGAL { /// For this reason it should not be called on sorted containers. /// /// @tparam ForwardIterator iterator over input points. -/// @tparam PointPMap is a model of `ReadablePropertyMap` with value type `Point_3`. +/// @tparam PointMap is a model of `ReadablePropertyMap` with value type `Point_3`. /// It can be omitted if the value type of `ForwardIterator` is convertible to `Point_3`. /// @tparam Kernel Geometric traits class. -/// It can be omitted and deduced automatically from the value type of `PointPMap`. +/// It can be omitted and deduced automatically from the value type of `PointMap`. +/// +/// @return iterator over the first point to remove. + +// This variant requires all parameters. +template +typename PointRange::iterator +random_simplify_point_set( + PointRange& points, + double removed_percentage) ///< percentage of points to remove. +{ + CGAL_point_set_processing_precondition(removed_percentage >= 0 && removed_percentage <= 100); + + // Random shuffle + std::random_shuffle (points.begin(), points.end()); + + // Computes first iterator to remove + std::size_t nb_points = std::distance(points.begin(), points.end()); + std::size_t first_index_to_remove = (std::size_t)(double(nb_points) * ((100.0-removed_percentage)/100.0)); + typename PointRange::iterator first_point_to_remove = points.begin(); + std::advance(first_point_to_remove, first_index_to_remove); + + return first_point_to_remove; +} + + +/// Randomly deletes a user-specified fraction of the input points. +/// +/// This method modifies the order of input points so as to pack all remaining points first, +/// and returns an iterator over the first point to remove (see erase-remove idiom). +/// For this reason it should not be called on sorted containers. +/// +/// @tparam ForwardIterator iterator over input points. +/// @tparam PointMap is a model of `ReadablePropertyMap` with value type `Point_3`. +/// It can be omitted if the value type of `ForwardIterator` is convertible to `Point_3`. +/// @tparam Kernel Geometric traits class. +/// It can be omitted and deduced automatically from the value type of `PointMap`. /// /// @return iterator over the first point to remove. // This variant requires all parameters. template ForwardIterator random_simplify_point_set( ForwardIterator first, ///< iterator over the first input point. ForwardIterator beyond, ///< past-the-end iterator over the input points. - PointPMap /*point_pmap*/, ///< property map: value_type of ForwardIterator -> Point_3 + PointMap /*point_map*/, ///< property map: value_type of ForwardIterator -> Point_3 double removed_percentage, ///< percentage of points to remove. const Kernel& /*kernel*/) ///< geometric traits. { - CGAL_point_set_processing_precondition(removed_percentage >= 0 && removed_percentage <= 100); - - // Random shuffle - std::random_shuffle (first, beyond); - - // Computes first iterator to remove - std::size_t nb_points = std::distance(first, beyond); - std::size_t first_index_to_remove = (std::size_t)(double(nb_points) * ((100.0-removed_percentage)/100.0)); - ForwardIterator first_point_to_remove = first; - std::advance(first_point_to_remove, first_index_to_remove); - - return first_point_to_remove; + CGAL_POINT_SET_PROCESSING_DEPRECATED_V1_API("random_simplify_point_set()"); + CGAL::Iterator_range points (first, beyond); + return random_simplify_point_set (points, removed_percentage); } + /// @cond SKIP_IN_MANUAL // This variant deduces the kernel from the iterator type. template ForwardIterator random_simplify_point_set( ForwardIterator first, ///< iterator over the first input point ForwardIterator beyond, ///< past-the-end iterator - PointPMap point_pmap, ///< property map: value_type of ForwardIterator -> Point_3 + PointMap, ///< property map: value_type of ForwardIterator -> Point_3 double removed_percentage) ///< percentage of points to remove { - typedef typename boost::property_traits::value_type Point; - typedef typename Kernel_traits::Kernel Kernel; - return random_simplify_point_set( - first,beyond, - point_pmap, - removed_percentage, - Kernel()); + CGAL_POINT_SET_PROCESSING_DEPRECATED_V1_API("random_simplify_point_set()"); + CGAL::Iterator_range points (first, beyond); + return random_simplify_point_set (points, removed_percentage); } /// @endcond @@ -109,11 +137,9 @@ random_simplify_point_set( ForwardIterator beyond, ///< past-the-end iterator double removed_percentage) ///< percentage of points to remove { - return random_simplify_point_set( - first,beyond, - make_identity_property_map( - typename std::iterator_traits::value_type()), - removed_percentage); + CGAL_POINT_SET_PROCESSING_DEPRECATED_V1_API("random_simplify_point_set()"); + CGAL::Iterator_range points (first, beyond); + return random_simplify_point_set (points, removed_percentage); } /// @endcond diff --git a/Point_set_processing_3/include/CGAL/remove_outliers.h b/Point_set_processing_3/include/CGAL/remove_outliers.h index e600c69401f..8fc79d44e1e 100644 --- a/Point_set_processing_3/include/CGAL/remove_outliers.h +++ b/Point_set_processing_3/include/CGAL/remove_outliers.h @@ -29,6 +29,9 @@ #include #include +#include +#include + #include #include #include @@ -115,10 +118,10 @@ compute_avg_knn_sq_distance_3( /// \pre `k >= 2` /// /// @tparam InputIterator iterator over input points. -/// @tparam PointPMap is a model of `ReadablePropertyMap` with value type `Point_3`. +/// @tparam PointMap is a model of `ReadablePropertyMap` with value type `Point_3`. /// It can be omitted ifthe value type of `InputIterator` is convertible to `Point_3`. /// @tparam Kernel Geometric traits class. -/// It can be omitted and deduced automatically from the value type of `PointPMap`. +/// It can be omitted and deduced automatically from the value type of `PointMap`. /// /// @return iterator over the first point to remove. /// @@ -131,31 +134,32 @@ compute_avg_knn_sq_distance_3( /// taken into account. // This variant requires all parameters. -template -InputIterator +typename PointRange::iterator remove_outliers( - InputIterator first, ///< iterator over the first input point. - InputIterator beyond, ///< past-the-end iterator over the input points. - PointPMap point_pmap, ///< property map: value_type of InputIterator -> Point_3 + PointRange& points, unsigned int k, ///< number of neighbors. - double threshold_percent, ///< maximum percentage of points to remove. - double threshold_distance, ///< minimum distance for a point to be - ///< considered as outlier (distance here is the square root of the average - ///< squared distance to K nearest - ///< neighbors) - const Kernel& /*kernel*/) ///< geometric traits. + const NamedParameters& np) { + using boost::choose_param; + // geometric types + typedef typename Point_set_processing_3::GetPointMap::type PointMap; + typedef typename Point_set_processing_3::GetK::Kernel Kernel; + + PointMap point_map = choose_param(get_param(np, internal_np::point_map), PointMap()); + double threshold_percent = choose_param(get_param(np, internal_np::threshold_percent), 10.); + double threshold_distance = choose_param(get_param(np, internal_np::threshold_distance), 0.); + typedef typename Kernel::FT FT; // basic geometric types typedef typename Kernel::Point_3 Point; // actual type of input points - typedef typename std::iterator_traits::value_type Enriched_point; + typedef typename std::iterator_traits::value_type Enriched_point; // types for K nearest neighbors search structure typedef typename CGAL::Search_traits_3 Tree_traits; @@ -165,36 +169,36 @@ remove_outliers( // precondition: at least one element in the container. // to fix: should have at least three distinct points // but this is costly to check - CGAL_point_set_processing_precondition(first != beyond); + CGAL_point_set_processing_precondition(points.begin() != points.end()); // precondition: at least 2 nearest neighbors CGAL_point_set_processing_precondition(k >= 2); CGAL_point_set_processing_precondition(threshold_percent >= 0 && threshold_percent <= 100); - InputIterator it; + typename PointRange::iterator it; // Instanciate a KD-tree search. // Note: We have to convert each input iterator to Point_3. std::vector kd_tree_points; - for(it = first; it != beyond; it++) - kd_tree_points.push_back( get(point_pmap, *it) ); + for(it = points.begin(); it != points.end(); it++) + kd_tree_points.push_back( get(point_map, *it) ); Tree tree(kd_tree_points.begin(), kd_tree_points.end()); // iterate over input points and add them to multimap sorted by distance to k std::multimap sorted_points; - for(it = first; it != beyond; it++) + for(it = points.begin(); it != points.end(); it++) { FT sq_distance = internal::compute_avg_knn_sq_distance_3( - get(point_pmap,*it), + get(point_map,*it), tree, k); sorted_points.insert( std::make_pair(sq_distance, *it) ); } - // Replaces [first, beyond) range by the multimap content. + // Replaces [points.begin(), points.end()) range by the multimap content. // Returns the iterator after the (100-threshold_percent) % best points. - InputIterator first_point_to_remove = first; - InputIterator dst = first; + typename PointRange::iterator first_point_to_remove = points.begin(); + typename PointRange::iterator dst = points.begin(); int first_index_to_remove = int(double(sorted_points.size()) * ((100.0-threshold_percent)/100.0)); typename std::multimap::iterator src; int index; @@ -211,28 +215,84 @@ remove_outliers( return first_point_to_remove; } +/// Removes outliers: +/// - computes average squared distance to the K nearest neighbors, +/// - and sorts the points in increasing order of average distance. +/// +/// This method modifies the order of input points so as to pack all remaining points first, +/// and returns an iterator over the first point to remove (see erase-remove idiom). +/// For this reason it should not be called on sorted containers. +/// +/// \pre `k >= 2` +/// +/// @tparam InputIterator iterator over input points. +/// @tparam PointMap is a model of `ReadablePropertyMap` with value type `Point_3`. +/// It can be omitted ifthe value type of `InputIterator` is convertible to `Point_3`. +/// @tparam Kernel Geometric traits class. +/// It can be omitted and deduced automatically from the value type of `PointMap`. +/// +/// @return iterator over the first point to remove. +/// +/// @note There are two thresholds that can be used: +/// `threshold_percent` and `threshold_distance`. This function +/// returns the smallest number of outliers such that at least one of +/// these threshold is fullfilled. This means that if +/// `threshold_percent=100`, only `threshold_distance` is taken into +/// account; if `threshold_distance=0` only `threshold_percent` is +/// taken into account. + +// This variant requires all parameters. +template +InputIterator +remove_outliers( + InputIterator first, ///< iterator over the first input point. + InputIterator beyond, ///< past-the-end iterator over the input points. + PointMap point_map, ///< property map: value_type of InputIterator -> Point_3 + unsigned int k, ///< number of neighbors. + double threshold_percent, ///< maximum percentage of points to remove. + double threshold_distance, ///< minimum distance for a point to be + ///< considered as outlier (distance here is the square root of the average + ///< squared distance to K nearest + ///< neighbors) + const Kernel& /*kernel*/) ///< geometric traits. +{ + CGAL_POINT_SET_PROCESSING_DEPRECATED_V1_API("remove_outliers()"); + CGAL::Iterator_range points (first, beyond); + return remove_outliers + (points, + k, + CGAL::parameters::point_map (point_map). + threshold_percent (threshold_percent). + threshold_distance (threshold_distance). + geom_traits(Kernel())); +} + /// @cond SKIP_IN_MANUAL // This variant deduces the kernel from the iterator type. template InputIterator remove_outliers( InputIterator first, ///< iterator over the first input point InputIterator beyond, ///< past-the-end iterator - PointPMap point_pmap, ///< property map: value_type of InputIterator -> Point_3 + PointMap point_map, ///< property map: value_type of InputIterator -> Point_3 unsigned int k, ///< number of neighbors. double threshold_percent, ///< percentage of points to remove double threshold_distance = 0.0) ///< minimum average squared distance to K nearest neighbors ///< for a point to be removed. { - typedef typename boost::property_traits::value_type Point; - typedef typename Kernel_traits::Kernel Kernel; - return remove_outliers( - first,beyond, - point_pmap, - k, threshold_percent, threshold_distance, - Kernel()); + CGAL_POINT_SET_PROCESSING_DEPRECATED_V1_API("remove_outliers()"); + CGAL::Iterator_range points (first, beyond); + return remove_outliers + (points, + k, + CGAL::parameters::point_map (point_map). + threshold_percent (threshold_percent). + threshold_distance (threshold_distance)); } /// @endcond @@ -249,11 +309,13 @@ remove_outliers( double threshold_distance = 0.0) ///< minimum average squared distance to K nearest neighbors ///< for a point to be removed. { - return remove_outliers( - first,beyond, - make_identity_property_map( - typename std::iterator_traits::value_type()), - k, threshold_percent, threshold_distance); + CGAL_POINT_SET_PROCESSING_DEPRECATED_V1_API("remove_outliers()"); + CGAL::Iterator_range points (first, beyond); + return remove_outliers + (points, + k, + CGAL::parameters::threshold_percent (threshold_percent). + threshold_distance (threshold_distance)); } /// @endcond diff --git a/Point_set_processing_3/include/CGAL/structure_point_set.h b/Point_set_processing_3/include/CGAL/structure_point_set.h index 819ebea00eb..72009b7b54c 100644 --- a/Point_set_processing_3/include/CGAL/structure_point_set.h +++ b/Point_set_processing_3/include/CGAL/structure_point_set.h @@ -40,6 +40,9 @@ #include #include +#include +#include + #include #include #include @@ -1450,6 +1453,75 @@ private: /// @tparam Kernel Geometric traits class. /// It can be omitted and deduced automatically from the value type of `PointMap`. +// This variant requires all parameters +template +OutputIterator +structure_point_set (const PointRange& points, ///< range of points. + const PlaneRange& planes, ///< range of planes. + OutputIterator output, ///< output iterator where output points are written. + double epsilon, ///< size parameter. + const NamedParameters& np) +{ + using boost::choose_param; + + // basic geometric types + typedef typename Point_set_processing_3::GetPointMap::type PointMap; + typedef typename Point_set_processing_3::GetNormalMap::type NormalMap; + typedef typename Point_set_processing_3::GetK::Kernel Kernel; + typedef typename Point_set_processing_3::GetPlaneMap::type PlaneMap; + typedef typename Point_set_processing_3::GetPlaneIndexMap::type PlaneIndexMap; + + CGAL_static_assertion_msg(!(boost::is_same::NoMap>::value), + "Error: no normal map"); + CGAL_static_assertion_msg(!(boost::is_same::NoMap>::value), + "Error: no plane index map"); + + PointMap point_map = choose_param(get_param(np, internal_np::point_map), PointMap()); + NormalMap normal_map = choose_param(get_param(np, internal_np::normal_map), NormalMap()); + PlaneMap plane_map = choose_param(get_param(np, internal_np::plane_map), PlaneMap()); + PlaneIndexMap plane_index_map = choose_param(get_param(np, internal_np::plane_index_map), PlaneIndexMap()); + double attraction_factor = choose_param(get_param(np, internal_np::attraction_factor), 3.); + + Point_set_with_structure pss (points, point_map, normal_map, planes, plane_map, plane_index_map, + epsilon, attraction_factor); + + for (std::size_t i = 0; i < pss.size(); ++ i) + *(output ++) = pss[i]; + + return output; +} + +/// This is an implementation of the Point Set Structuring algorithm. This +/// algorithm takes advantage of a set of detected planes: it detects adjacency +/// relationships between planes and resamples the detected planes, edges and +/// corners to produce a structured point set. +/// +/// The size parameter `epsilon` is used both for detecting adjacencies and for +/// setting the sampling density of the structured point set. +/// +/// For more details, please refer to \cgalCite{cgal:la-srpss-13}. +/// +/// @tparam PointRange range of points, model of `ConstRange` +/// @tparam PointMap is a model of `ReadablePropertyMap` with value type `Kernel::Point_3`. +/// It can be omitted if the value type of the iterator of `PointRange` is convertible to `Point_3`. +/// @tparam NormalMap is a model of `ReadablePropertyMap` with value type `Kernel::Vector_3`. +/// @tparam PlaneRange range of planes, model of `ConstRange` +/// @tparam PlaneMap is a model of `ReadablePropertyMap` with value type `Kernel::Plane_3`. +/// It can be omitted if the value type of the iterator of `PlaneRange` is convertible to `Plane_3`. +/// @tparam IndexMap is a model of `ReadablePropertyMap` with value type `std::size_t`. +/// @tparam OutputIterator Type of the output iterator. The type of the objects +/// put in it is `std::pair`. Note that the +/// user may use a function_output_iterator +/// to match specific needs. +/// @tparam Kernel Geometric traits class. +/// It can be omitted and deduced automatically from the value type of `PointMap`. + // This variant requires all parameters template pss (points, point_map, normal_map, planes, plane_map, index_map, - epsilon, attraction_factor); - - for (std::size_t i = 0; i < pss.size(); ++ i) - *(output ++) = pss[i]; - - return output; + CGAL_POINT_SET_PROCESSING_DEPRECATED_V1_API("structure_point_set()"); + return structure_point_set + (points, planes, output, epsilon, + CGAL::parameters::point_map (point_map). + normal_map (normal_map). + plane_map (plane_map). + plane_index_map (index_map). + attraction_factor (attraction_factor). + geom_traits (Kernel())); } - + /// \cond SKIP_IN_MANUAL // This variant deduces the kernel from the point property map. @@ -1503,11 +1577,14 @@ structure_point_set (const PointRange& points, double epsilon, ///< size parameter double attraction_factor = 3.) ///< attraction factor { - typedef typename boost::property_traits::value_type Point; - typedef typename Kernel_traits::Kernel Kernel; - - return structure_point_set(points, point_map, normal_map, planes, plane_map, index_map, output, - Kernel(), epsilon, attraction_factor); + CGAL_POINT_SET_PROCESSING_DEPRECATED_V1_API("structure_point_set()"); + return structure_point_set + (points, planes, output, epsilon, + CGAL::parameters::point_map (point_map). + normal_map (normal_map). + plane_map (plane_map). + plane_index_map (index_map). + attraction_factor (attraction_factor)); } // This variant creates a default point property map = Identity_property_map. @@ -1526,17 +1603,12 @@ structure_point_set (const PointRange& points, double epsilon, ///< size parameter double attraction_factor = 3.) ///< attraction factor { - return structure_point_set(points, - make_identity_property_map( - typename std::iterator_traits::value_type()), - normal_map, - planes, - make_identity_property_map( - typename std::iterator_traits::value_type()), - index_map, - output, - epsilon, - attraction_factor); + CGAL_POINT_SET_PROCESSING_DEPRECATED_V1_API("structure_point_set()"); + return structure_point_set + (points, planes, output, epsilon, + CGAL::parameters::normal_map (normal_map). + plane_index_map (index_map). + attraction_factor (attraction_factor)); } diff --git a/Point_set_processing_3/include/CGAL/vcm_estimate_normals.h b/Point_set_processing_3/include/CGAL/vcm_estimate_normals.h index 9b79b966292..492d45108b6 100644 --- a/Point_set_processing_3/include/CGAL/vcm_estimate_normals.h +++ b/Point_set_processing_3/include/CGAL/vcm_estimate_normals.h @@ -36,6 +36,9 @@ #include #include +#include +#include + #include #include @@ -56,18 +59,18 @@ namespace internal { /// by `N` planes. /// /// @tparam ForwardIterator iterator over input points. -/// @tparam PointPMap is a model of `ReadablePropertyMap` with a value_type = `Kernel::Point_3`. +/// @tparam PointMap is a model of `ReadablePropertyMap` with a value_type = `Kernel::Point_3`. /// @tparam K Geometric traits class. /// @tparam Covariance Covariance matrix type. It is similar to an array with a length of 6. template < typename ForwardIterator, - typename PointPMap, + typename PointMap, class K, class Covariance > void vcm_offset (ForwardIterator first, ///< iterator over the first input point. ForwardIterator beyond, ///< past-the-end iterator over the input points. - PointPMap point_pmap, ///< property map: value_type of ForwardIterator -> Point_3. + PointMap point_map, ///< property map: value_type of ForwardIterator -> Point_3. std::vector &cov, ///< vector of covariance matrices. double offset_radius, ///< radius of the sphere. std::size_t N, ///< number of planes used to discretize the sphere. @@ -80,7 +83,7 @@ vcm_offset (ForwardIterator first, ///< iterator over the first input point. std::vector points; points.reserve(std::distance(first, beyond)); for (ForwardIterator it = first; it != beyond; ++it) - points.push_back(get(point_pmap, *it)); + points.push_back(get(point_map, *it)); typedef Delaunay_triangulation_3 DT; DT dt(points.begin(), points.end()); @@ -102,23 +105,23 @@ vcm_offset (ForwardIterator first, ///< iterator over the first input point. /// @cond SKIP_IN_MANUAL // Convolve using a radius. template < class ForwardIterator, - class PointPMap, + class PointMap, class K, class Covariance > void vcm_convolve (ForwardIterator first, ForwardIterator beyond, - PointPMap point_pmap, + PointMap point_map, const std::vector &cov, std::vector &ncov, double convolution_radius, const K &) { typedef std::pair Tree_point; - typedef First_of_pair_property_map< Tree_point > Tree_pmap; + typedef First_of_pair_property_map< Tree_point > Tree_map; typedef Search_traits_3 Traits_base; - typedef Search_traits_adapter Traits; + typedef Search_traits_adapter Traits; typedef Kd_tree Tree; typedef Fuzzy_sphere Fuzzy_sphere; @@ -127,7 +130,7 @@ vcm_convolve (ForwardIterator first, tree.reserve(cov.size()); std::size_t i=0; for (ForwardIterator it = first; it != beyond; ++it, ++i) - tree.insert( Tree_point(get(point_pmap, *it), i) ); + tree.insert( Tree_point(get(point_map, *it), i) ); // Convolving ncov.clear(); @@ -135,7 +138,7 @@ vcm_convolve (ForwardIterator first, for (ForwardIterator it = first; it != beyond; ++it) { std::vector nn; tree.search(std::back_inserter(nn), - Fuzzy_sphere (get(point_pmap, *it), convolution_radius)); + Fuzzy_sphere (get(point_map, *it), convolution_radius)); Covariance m; std::fill(m.begin(), m.end(), typename K::FT(0)); @@ -153,23 +156,23 @@ vcm_convolve (ForwardIterator first, /// @cond SKIP_IN_MANUAL // Convolve using neighbors. template < class ForwardIterator, - class PointPMap, + class PointMap, class K, class Covariance > void vcm_convolve (ForwardIterator first, ForwardIterator beyond, - PointPMap point_pmap, + PointMap point_map, const std::vector &cov, std::vector &ncov, unsigned int nb_neighbors_convolve, const K &) { typedef std::pair Tree_point; - typedef First_of_pair_property_map< Tree_point > Tree_pmap; + typedef First_of_pair_property_map< Tree_point > Tree_map; typedef Search_traits_3 Traits_base; - typedef Search_traits_adapter Traits; + typedef Search_traits_adapter Traits; typedef Orthogonal_k_neighbor_search Neighbor_search; typedef typename Neighbor_search::Tree Tree; @@ -178,13 +181,13 @@ vcm_convolve (ForwardIterator first, tree.reserve(cov.size()); std::size_t i=0; for (ForwardIterator it = first; it != beyond; ++it, ++i) - tree.insert( Tree_point(get(point_pmap, *it), i) ); + tree.insert( Tree_point(get(point_map, *it), i) ); // Convolving ncov.clear(); ncov.reserve(cov.size()); for (ForwardIterator it = first; it != beyond; ++it) { - Neighbor_search search(tree, get(point_pmap, *it), nb_neighbors_convolve); + Neighbor_search search(tree, get(point_map, *it), nb_neighbors_convolve); Covariance m; for (typename Neighbor_search::iterator nit = search.begin(); @@ -233,8 +236,8 @@ vcm_convolve (ForwardIterator first, */ /// /// @tparam ForwardIterator iterator over input points. -/// @tparam PointPMap is a model of `ReadablePropertyMap` with a value_type = `Kernel::Point_3`. -/// @tparam CovariancePMap is a model of `ReadWritePropertyMap` with a value_type = `cpp11::array`. +/// @tparam PointMap is a model of `ReadablePropertyMap` with a value_type = `Kernel::Point_3`. +/// @tparam CovarianceMap is a model of `ReadWritePropertyMap` with a value_type = `cpp11::array`. /// @tparam Kernel Geometric traits class. /// /// \sa `CGAL::vcm_is_on_feature_edge()` @@ -242,13 +245,13 @@ vcm_convolve (ForwardIterator first, /// /// \todo replace ccov by a property map. template < class ForwardIterator, - class PointPMap, + class PointMap, class Kernel > void compute_vcm (ForwardIterator first, ForwardIterator beyond, - PointPMap point_pmap, + PointMap point_map, std::vector< cpp11::array > &ccov, double offset_radius, double convolution_radius, @@ -258,7 +261,7 @@ compute_vcm (ForwardIterator first, std::vector< cpp11::array > cov; std::size_t N = 20; internal::vcm_offset (first, beyond, - point_pmap, + point_map, cov, offset_radius, N, @@ -269,7 +272,7 @@ compute_vcm (ForwardIterator first, std::copy(cov.begin(), cov.end(), std::back_inserter(ccov)); } else { internal::vcm_convolve(first, beyond, - point_pmap, + point_map, cov, ccov, convolution_radius, @@ -283,8 +286,8 @@ compute_vcm (ForwardIterator first, /// The output normals are randomly oriented. /// /// @tparam ForwardIterator iterator over input points. -/// @tparam PointPMap is a model of `ReadablePropertyMap` with a value_type = `Kernel::Point_3`. -/// @tparam NormalPMap is a model of `WritablePropertyMap` with a value_type = `Kernel::Vector_3`. +/// @tparam PointMap is a model of `ReadablePropertyMap` with a value_type = `Kernel::Point_3`. +/// @tparam NormalMap is a model of `WritablePropertyMap` with a value_type = `Kernel::Vector_3`. /// @tparam Kernel Geometric traits class. /// @tparam Covariance Covariance matrix type. It is similar to an array with a length of 6. /// @pre If `nb_neighbors_convolve` is equal to -1, then the convolution is made using a radius. @@ -294,15 +297,15 @@ compute_vcm (ForwardIterator first, // This variant requires all of the parameters. template < typename VCMTraits, typename ForwardIterator, - typename PointPMap, - typename NormalPMap, + typename PointMap, + typename NormalMap, typename Kernel > void vcm_estimate_normals (ForwardIterator first, ///< iterator over the first input point. ForwardIterator beyond, ///< past-the-end iterator over the input points. - PointPMap point_pmap, ///< property map: value_type of ForwardIterator -> Point_3. - NormalPMap normal_pmap, ///< property map: value_type of ForwardIterator -> Vector_3. + PointMap point_map, ///< property map: value_type of ForwardIterator -> Point_3. + NormalMap normal_map, ///< property map: value_type of ForwardIterator -> Vector_3. double offset_radius, ///< offset radius. double convolution_radius, ///< convolution radius. const Kernel & kernel, ///< geometric traits. @@ -314,14 +317,14 @@ vcm_estimate_normals (ForwardIterator first, ///< iterator over the first input std::vector cov; if (nb_neighbors_convolve == -1) { compute_vcm(first, beyond, - point_pmap, + point_map, cov, offset_radius, convolution_radius, kernel); } else { internal::vcm_offset(first, beyond, - point_pmap, + point_map, cov, offset_radius, 20, @@ -332,7 +335,7 @@ vcm_estimate_normals (ForwardIterator first, ///< iterator over the first input std::vector ccov; ccov.reserve(cov.size()); internal::vcm_convolve(first, beyond, - point_pmap, + point_map, cov, ccov, (unsigned int) nb_neighbors_convolve, @@ -353,7 +356,7 @@ vcm_estimate_normals (ForwardIterator first, ///< iterator over the first input typename Kernel::Vector_3 normal(enormal[0], enormal[1], enormal[2]); - put(normal_pmap, *it, normal); + put(normal_map, *it, normal); i++; } } @@ -368,8 +371,55 @@ vcm_estimate_normals (ForwardIterator first, ///< iterator over the first input /// and of the Voronoi Covariance Measure. /// /// @tparam ForwardIterator iterator over input points. -/// @tparam PointPMap is a model of `ReadablePropertyMap` with a value_type = `Kernel::Point_3`. -/// @tparam NormalPMap is a model of `WritablePropertyMap` with a value_type = `Kernel::Vector_3`. +/// @tparam PointMap is a model of `ReadablePropertyMap` with a value_type = `Kernel::Point_3`. +/// @tparam NormalMap is a model of `WritablePropertyMap` with a value_type = `Kernel::Vector_3`. +/// \tparam VCMTraits is a model of `DiagonalizeTraits`. It can be +/// omitted: if Eigen 3 (or greater) is available and +/// `CGAL_EIGEN3_ENABLED` is defined then an overload using +/// `Eigen_diagonalize_traits` is provided. Otherwise, the internal +/// implementation `Diagonalize_traits` is used. +// This variant deduces the kernel from the point property map +// and uses a radius for the convolution. +template +void +vcm_estimate_normals (PointRange& points, + double offset_radius, ///< offset radius. + double convolution_radius, ///< convolution radius. + const NamedParameters& np +) +{ + using boost::choose_param; + // basic geometric types + typedef typename Point_set_processing_3::GetPointMap::type PointMap; + typedef typename Point_set_processing_3::GetNormalMap::type NormalMap; + typedef typename Point_set_processing_3::GetK::Kernel Kernel; + typedef typename GetDiagonalizeTraits::type DiagonalizeTraits; + + CGAL_static_assertion_msg(!(boost::is_same::NoMap>::value), + "Error: no normal map"); + + PointMap point_map = choose_param(get_param(np, internal_np::point_map), PointMap()); + NormalMap normal_map = choose_param(get_param(np, internal_np::normal_map), NormalMap()); + + vcm_estimate_normals(points.begin(), points.end(), + point_map, normal_map, + offset_radius, convolution_radius, + Kernel()); +} + +/// Estimates normal directions of the points in the range `[first, beyond)` +/// using the Voronoi Covariance Measure with a radius for the convolution. +/// The output normals are randomly oriented. +/// +/// See `compute_vcm()` for a detailed description of the parameters `offset_radius` and `convolution_radius` +/// and of the Voronoi Covariance Measure. +/// +/// @tparam ForwardIterator iterator over input points. +/// @tparam PointMap is a model of `ReadablePropertyMap` with a value_type = `Kernel::Point_3`. +/// @tparam NormalMap is a model of `WritablePropertyMap` with a value_type = `Kernel::Vector_3`. /// \tparam VCMTraits is a model of `DiagonalizeTraits`. It can be /// omitted: if Eigen 3 (or greater) is available and /// `CGAL_EIGEN3_ENABLED` is defined then an overload using @@ -378,27 +428,28 @@ vcm_estimate_normals (ForwardIterator first, ///< iterator over the first input // This variant deduces the kernel from the point property map // and uses a radius for the convolution. template < typename ForwardIterator, - typename PointPMap, - typename NormalPMap, + typename PointMap, + typename NormalMap, typename VCMTraits > void vcm_estimate_normals (ForwardIterator first, ///< iterator over the first input point. ForwardIterator beyond, ///< past-the-end iterator over the input points. - PointPMap point_pmap, ///< property map: value_type of ForwardIterator -> Point_3. - NormalPMap normal_pmap, ///< property map: value_type of ForwardIterator -> Vector_3. + PointMap point_map, ///< property map: value_type of ForwardIterator -> Point_3. + NormalMap normal_map, ///< property map: value_type of ForwardIterator -> Vector_3. double offset_radius, ///< offset radius. double convolution_radius, ///< convolution radius. VCMTraits ) { - typedef typename boost::property_traits::value_type Point; - typedef typename Kernel_traits::Kernel Kernel; - - vcm_estimate_normals(first, beyond, - point_pmap, normal_pmap, - offset_radius, convolution_radius, - Kernel()); + CGAL_POINT_SET_PROCESSING_DEPRECATED_V1_API("vcm_estimate_normals()"); + CGAL::Iterator_range points (first, beyond); + vcm_estimate_normals + (points, + offset_radius, convolution_radius, + CGAL::parameters::point_map (point_map). + normal_map (normal_map). + diagonalize_traits (VCMTraits())); } @@ -411,8 +462,57 @@ vcm_estimate_normals (ForwardIterator first, ///< iterator over the first input /// and of the Voronoi Covariance Measure. /// /// @tparam ForwardIterator iterator over input points. -/// @tparam PointPMap is a model of `ReadablePropertyMap` with a value_type = `Kernel::Point_3`. -/// @tparam NormalPMap is a model of `WritablePropertyMap` with a value_type = `Kernel::Vector_3`. +/// @tparam PointMap is a model of `ReadablePropertyMap` with a value_type = `Kernel::Point_3`. +/// @tparam NormalMap is a model of `WritablePropertyMap` with a value_type = `Kernel::Vector_3`. +/// \tparam VCMTraits is a model of `DiagonalizeTraits`. It can be +/// omitted: if Eigen 3 (or greater) is available and +/// `CGAL_EIGEN3_ENABLED` is defined then an overload using +/// `Eigen_diagonalize_traits` is provided. Otherwise, the internal +/// implementation `Diagonalize_traits` is used. + +// This variant deduces the kernel from the point property map +// and uses a number of neighbors for the convolution. +template < typename PointRange, + typename NamedParameters +> +void +vcm_estimate_normals (PointRange& points, + double offset_radius, ///< offset radius. + unsigned int k, ///< number of neighbor points used for the convolution. + const NamedParameters& np +) +{ + using boost::choose_param; + // basic geometric types + typedef typename Point_set_processing_3::GetPointMap::type PointMap; + typedef typename Point_set_processing_3::GetNormalMap::type NormalMap; + typedef typename Point_set_processing_3::GetK::Kernel Kernel; + typedef typename GetDiagonalizeTraits::type DiagonalizeTraits; + + CGAL_static_assertion_msg(!(boost::is_same::NoMap>::value), + "Error: no normal map"); + + PointMap point_map = choose_param(get_param(np, internal_np::point_map), PointMap()); + NormalMap normal_map = choose_param(get_param(np, internal_np::normal_map), NormalMap()); + + vcm_estimate_normals(points.begin(), points.end(), + point_map, normal_map, + offset_radius, 0, + Kernel(), + k); +} + +/// Estimates normal directions of the points in the range `[first, beyond)` +/// using the Voronoi Covariance Measure with a number of neighbors for the convolution. +/// The output normals are randomly oriented. +/// +/// See `compute_vcm()` for a detailed description of the parameter `offset_radius` +/// and of the Voronoi Covariance Measure. +/// +/// @tparam ForwardIterator iterator over input points. +/// @tparam PointMap is a model of `ReadablePropertyMap` with a value_type = `Kernel::Point_3`. +/// @tparam NormalMap is a model of `WritablePropertyMap` with a value_type = `Kernel::Vector_3`. /// \tparam VCMTraits is a model of `DiagonalizeTraits`. It can be /// omitted: if Eigen 3 (or greater) is available and /// `CGAL_EIGEN3_ENABLED` is defined then an overload using @@ -422,62 +522,70 @@ vcm_estimate_normals (ForwardIterator first, ///< iterator over the first input // This variant deduces the kernel from the point property map // and uses a number of neighbors for the convolution. template < typename ForwardIterator, - typename PointPMap, - typename NormalPMap, + typename PointMap, + typename NormalMap, typename VCMTraits > void vcm_estimate_normals (ForwardIterator first, ///< iterator over the first input point. ForwardIterator beyond, ///< past-the-end iterator over the input points. - PointPMap point_pmap, ///< property map: value_type of ForwardIterator -> Point_3. - NormalPMap normal_pmap, ///< property map: value_type of ForwardIterator -> Vector_3. + PointMap point_map, ///< property map: value_type of ForwardIterator -> Point_3. + NormalMap normal_map, ///< property map: value_type of ForwardIterator -> Vector_3. double offset_radius, ///< offset radius. unsigned int k, ///< number of neighbor points used for the convolution. VCMTraits ) { - typedef typename boost::property_traits::value_type Point; - typedef typename Kernel_traits::Kernel Kernel; - - vcm_estimate_normals(first, beyond, - point_pmap, normal_pmap, - offset_radius, 0, - Kernel(), - k); + CGAL_POINT_SET_PROCESSING_DEPRECATED_V1_API("vcm_estimate_normals()"); + CGAL::Iterator_range points (first, beyond); + vcm_estimate_normals + (points, + offset_radius, k, + CGAL::parameters::point_map (point_map). + normal_map (normal_map). + diagonalize_traits (VCMTraits())); } - - + template < typename ForwardIterator, - typename PointPMap, - typename NormalPMap + typename PointMap, + typename NormalMap > void vcm_estimate_normals (ForwardIterator first, ForwardIterator beyond, - PointPMap point_pmap, - NormalPMap normal_pmap, + PointMap point_map, + NormalMap normal_map, double offset_radius, double convolution_radius) { - vcm_estimate_normals(first, beyond, point_pmap, normal_pmap, offset_radius, convolution_radius, - CGAL::Default_diagonalize_traits()); + CGAL_POINT_SET_PROCESSING_DEPRECATED_V1_API("vcm_estimate_normals()"); + CGAL::Iterator_range points (first, beyond); + vcm_estimate_normals + (points, + offset_radius, convolution_radius, + CGAL::parameters::point_map (point_map). + normal_map (normal_map)); } template < typename ForwardIterator, - typename PointPMap, - typename NormalPMap + typename PointMap, + typename NormalMap > void vcm_estimate_normals (ForwardIterator first, ForwardIterator beyond, - PointPMap point_pmap, - NormalPMap normal_pmap, + PointMap point_map, + NormalMap normal_map, double offset_radius, unsigned int nb_neighbors_convolve) { - vcm_estimate_normals(first, beyond, point_pmap, normal_pmap, offset_radius, nb_neighbors_convolve, - CGAL::Default_diagonalize_traits()); - + CGAL_POINT_SET_PROCESSING_DEPRECATED_V1_API("vcm_estimate_normals()"); + CGAL::Iterator_range points (first, beyond); + vcm_estimate_normals + (points, + offset_radius, nb_neighbors_convolve, + CGAL::parameters::point_map (point_map). + normal_map (normal_map)); } @@ -485,18 +593,20 @@ vcm_estimate_normals (ForwardIterator first, // This variant creates a default point property map = Identity_property_map // and use a radius for the convolution. template < typename ForwardIterator, - typename NormalPMap + typename NormalMap > void vcm_estimate_normals (ForwardIterator first, ForwardIterator beyond, - NormalPMap normal_pmap, + NormalMap normal_map, double offset_radius, double convolution_radius) { - vcm_estimate_normals(first, beyond, - make_identity_property_map(typename std::iterator_traits::value_type()), - normal_pmap, - offset_radius, convolution_radius); + CGAL_POINT_SET_PROCESSING_DEPRECATED_V1_API("vcm_estimate_normals()"); + CGAL::Iterator_range points (first, beyond); + vcm_estimate_normals + (points, + offset_radius, convolution_radius, + CGAL::parameters::normal_map (normal_map)); } /// @endcond @@ -504,18 +614,20 @@ vcm_estimate_normals (ForwardIterator first, // This variant creates a default point property map = Identity_property_map // and use a number of neighbors for the convolution. template < typename ForwardIterator, - typename NormalPMap + typename NormalMap > void vcm_estimate_normals (ForwardIterator first, ForwardIterator beyond, - NormalPMap normal_pmap, + NormalMap normal_map, double offset_radius, unsigned int nb_neighbors_convolve) { - vcm_estimate_normals(first, beyond, - make_identity_property_map(typename std::iterator_traits::value_type()), - normal_pmap, - offset_radius, nb_neighbors_convolve); + CGAL_POINT_SET_PROCESSING_DEPRECATED_V1_API("vcm_estimate_normals()"); + CGAL::Iterator_range points (first, beyond); + vcm_estimate_normals + (points, + offset_radius, nb_neighbors_convolve, + CGAL::parameters::normal_map (normal_map)); } /// @endcond diff --git a/Point_set_processing_3/include/CGAL/wlop_simplify_and_regularize_point_set.h b/Point_set_processing_3/include/CGAL/wlop_simplify_and_regularize_point_set.h index ed4ac20e778..4e4ee4bc984 100644 --- a/Point_set_processing_3/include/CGAL/wlop_simplify_and_regularize_point_set.h +++ b/Point_set_processing_3/include/CGAL/wlop_simplify_and_regularize_point_set.h @@ -31,6 +31,9 @@ #include #include +#include +#include + #include #include #include @@ -408,51 +411,44 @@ public: /// See the TBB documentation /// for more details. /// -/// @tparam Concurrency_tag enables sequential versus parallel algorithm. +/// @tparam ConcurrencyTag enables sequential versus parallel algorithm. /// Possible values are `Sequential_tag` /// and `Parallel_tag`. /// @tparam OutputIterator Type of the output iterator. /// It must accept objects of type `Kernel::Point_3`. /// @tparam RandomAccessIterator Iterator over input points. -/// @tparam PointPMap is a model of `ReadablePropertyMap` +/// @tparam PointMap is a model of `ReadablePropertyMap` /// with the value type of `ForwardIterator` as key type and `Kernel::Point_3` as value type. /// It can be omitted if the value type of ` RandomAccessIterator` is convertible /// to `Kernel::Point_3`. /// @tparam Kernel Geometric traits class. -/// It can be omitted and deduced automatically from the value type of `PointPMap` +/// It can be omitted and deduced automatically from the value type of `PointMap` /// using `Kernel_traits`. // This variant requires all parameters. -template + typename NamedParameters> OutputIterator wlop_simplify_and_regularize_point_set( - RandomAccessIterator first, ///< random-access iterator to the first input point. - RandomAccessIterator beyond, ///< past-the-end iterator. + PointRange& points, OutputIterator output, ///< output iterator where output points are put. - PointPMap point_pmap, ///< point property map. - double select_percentage, ///< percentage of points to retain. - ///< The default value is set to 5 (\%). - double radius, ///< spherical neighborhood radius. - ///< This is a key parameter that needs to be finely tuned. - ///< The result will be irregular if too small, but a larger - ///< value will impact the runtime. - ///< In practice, choosing a radius such that the neighborhood of each sample point - ///< includes at least two rings of neighboring sample points - ///< gives satisfactory result. - ///< The default value is set to 8 times the average spacing of the point set. - unsigned int iter_number, ///< number of iterations to solve the optimsation problem. The default value is 35. - ///< More iterations give a more regular result but increase the runtime. - bool require_uniform_sampling,///< an optional preprocessing, which will give better result - ///< if the distribution of the input points is highly non-uniform. - ///< The default value is `false`. - const Kernel& ///< geometric traits. + const NamedParameters& np ) { + using boost::choose_param; + // basic geometric types + typedef typename Point_set_processing_3::GetPointMap::type PointMap; + typedef typename Point_set_processing_3::GetK::Kernel Kernel; + + PointMap point_map = choose_param(get_param(np, internal_np::point_map), PointMap()); + double select_percentage = choose_param(get_param(np, internal_np::select_percentage), 5.); + double radius = choose_param(get_param(np, internal_np::neighbor_radius), -1); + unsigned int iter_number = choose_param(get_param(np, internal_np::number_of_iterations), 35); + bool require_uniform_sampling = choose_param(get_param(np, internal_np::require_uniform_sampling), false); + typedef typename Kernel::Point_3 Point; typedef typename Kernel::FT FT; @@ -465,23 +461,23 @@ wlop_simplify_and_regularize_point_set( // precondition: at least one element in the container. // to fix: should have at least three distinct points // but this is costly to check - CGAL_point_set_processing_precondition(first != beyond); + CGAL_point_set_processing_precondition(points.begin() != points.end()); CGAL_point_set_processing_precondition(select_percentage >= 0 && select_percentage <= 100); // Random shuffle - std::random_shuffle (first, beyond); + std::random_shuffle (points.begin(), points.end()); // Computes original(input) and sample points size - std::size_t number_of_original = std::distance(first, beyond); + std::size_t number_of_original = std::distance(points.begin(), points.end()); std::size_t number_of_sample = (std::size_t)(FT(number_of_original) * (select_percentage / FT(100.0))); std::size_t first_index_to_sample = number_of_original - number_of_sample; // The first point iter of original and sample points - RandomAccessIterator it; // point iterator - RandomAccessIterator first_original_iter = first; - RandomAccessIterator first_sample_iter = first; + typename PointRange::iterator it; // point iterator + typename PointRange::iterator first_original_iter = points.begin(); + typename PointRange::iterator first_sample_iter = points.begin(); std::advance(first_sample_iter, first_index_to_sample); //Copy sample points @@ -489,18 +485,18 @@ wlop_simplify_and_regularize_point_set( sample_points.reserve(number_of_sample); unsigned int i; - for(it = first_sample_iter; it != beyond; ++it) + for(it = first_sample_iter; it != points.end(); ++it) { - sample_points.push_back(get(point_pmap, *it)); + sample_points.push_back(get(point_map, *it)); } //compute default neighbor_radius, if no radius in if (radius < 0) { const unsigned int nb_neighbors = 6; // 1 ring - FT average_spacing = CGAL::compute_average_spacing( - first, beyond, - point_pmap, + FT average_spacing = CGAL::compute_average_spacing( + points.begin(), points.end(), + point_map, nb_neighbors); radius = average_spacing * 8.0; @@ -515,8 +511,8 @@ wlop_simplify_and_regularize_point_set( // Initiate a KD-tree search for original points std::vector original_treeElements; - for (it = first_original_iter, i=0 ; it != beyond ; ++it, ++i) - original_treeElements.push_back( Kd_tree_element(get(point_pmap, *it), i) ); + for (it = first_original_iter, i=0 ; it != points.end() ; ++it, ++i) + original_treeElements.push_back( Kd_tree_element(get(point_map, *it), i) ); Kd_Tree original_kd_tree(original_treeElements.begin(), original_treeElements.end()); @@ -530,12 +526,12 @@ wlop_simplify_and_regularize_point_set( if (require_uniform_sampling)//default value is false { //todo: this part could also be parallelized if needed - for (it = first_original_iter, i = 0; it != beyond ; ++it, ++i) + for (it = first_original_iter, i = 0; it != points.end() ; ++it, ++i) { FT density = simplify_and_regularize_internal:: compute_density_weight_for_original_point ( - get(point_pmap, *it), + get(point_map, *it), original_kd_tree, radius); @@ -572,14 +568,14 @@ wlop_simplify_and_regularize_point_set( typename std::vector::iterator update_iter = update_sample_points.begin(); #ifndef CGAL_LINKED_WITH_TBB - CGAL_static_assertion_msg (!(boost::is_convertible::value), + CGAL_static_assertion_msg (!(boost::is_convertible::value), "Parallel_tag is enabled but TBB is unavailable."); #else //parallel - if (boost::is_convertible::value) + if (boost::is_convertible::value) { tbb::blocked_range block(0, number_of_sample); - Sample_point_updater sample_updater( + Sample_point_updater sample_updater( update_sample_points, sample_points, original_kd_tree, @@ -599,7 +595,7 @@ wlop_simplify_and_regularize_point_set( *update_iter = simplify_and_regularize_internal:: compute_update_sample_point + typename PointRange::iterator> (*sample_iter, original_kd_tree, sample_kd_tree, @@ -628,18 +624,88 @@ wlop_simplify_and_regularize_point_set( return output; } +/// This is an implementation of the Weighted Locally Optimal Projection (WLOP) simplification algorithm. +/// The WLOP simplification algorithm can produce a set of +/// denoised, outlier-free and evenly distributed particles over the original +/// dense point cloud. +/// The core of the algorithm is a Weighted Locally Optimal Projection operator +/// with a density uniformization term. +/// For more details, please refer to \cgalCite{wlop-2009}. +/// +/// A parallel version of WLOP is provided and requires the executable to be +/// linked against the Intel TBB library. +/// To control the number of threads used, the user may use the tbb::task_scheduler_init class. +/// See the TBB documentation +/// for more details. +/// +/// @tparam ConcurrencyTag enables sequential versus parallel algorithm. +/// Possible values are `Sequential_tag` +/// and `Parallel_tag`. +/// @tparam OutputIterator Type of the output iterator. +/// It must accept objects of type `Kernel::Point_3`. +/// @tparam RandomAccessIterator Iterator over input points. +/// @tparam PointMap is a model of `ReadablePropertyMap` +/// with the value type of `ForwardIterator` as key type and `Kernel::Point_3` as value type. +/// It can be omitted if the value type of ` RandomAccessIterator` is convertible +/// to `Kernel::Point_3`. +/// @tparam Kernel Geometric traits class. +/// It can be omitted and deduced automatically from the value type of `PointMap` +/// using `Kernel_traits`. + +// This variant requires all parameters. +template +OutputIterator +wlop_simplify_and_regularize_point_set( + RandomAccessIterator first, ///< random-access iterator to the first input point. + RandomAccessIterator beyond, ///< past-the-end iterator. + OutputIterator output, ///< output iterator where output points are put. + PointMap point_map, ///< point property map. + double select_percentage, ///< percentage of points to retain. + ///< The default value is set to 5 (\%). + double radius, ///< spherical neighborhood radius. + ///< This is a key parameter that needs to be finely tuned. + ///< The result will be irregular if too small, but a larger + ///< value will impact the runtime. + ///< In practice, choosing a radius such that the neighborhood of each sample point + ///< includes at least two rings of neighboring sample points + ///< gives satisfactory result. + ///< The default value is set to 8 times the average spacing of the point set. + unsigned int iter_number, ///< number of iterations to solve the optimsation problem. The default value is 35. + ///< More iterations give a more regular result but increase the runtime. + bool require_uniform_sampling,///< an optional preprocessing, which will give better result + ///< if the distribution of the input points is highly non-uniform. + ///< The default value is `false`. + const Kernel& ///< geometric traits. +) +{ + CGAL_POINT_SET_PROCESSING_DEPRECATED_V1_API("wlop_simplify_and_regularize_point_set()"); + CGAL::Iterator_range points (first, beyond); + return wlop_simplify_and_regularize_point_set + (points, output, + CGAL::parameters::point_map (point_map). + select_percentage (select_percentage). + neighbor_radius (radius). + number_of_iterations(iter_number). + require_uniform_sampling (require_uniform_sampling). + geom_traits (Kernel())); +} + /// @cond SKIP_IN_MANUAL // This variant deduces the kernel from the iterator type. -template + typename PointMap> OutputIterator wlop_simplify_and_regularize_point_set( RandomAccessIterator first, ///< iterator over the first input point RandomAccessIterator beyond, ///< past-the-end iterator OutputIterator output, ///< add back-inserter - PointPMap point_pmap, ///< property map RandomAccessIterator -> Point_3 + PointMap point_map, ///< property map RandomAccessIterator -> Point_3 const double select_percentage, ///< percentage of points to retain double neighbor_radius, ///< size of neighbors. const unsigned int max_iter_number, ///< number of iterations. @@ -647,18 +713,15 @@ wlop_simplify_and_regularize_point_set( /// to generate more rugularized result. ) { - typedef typename boost::property_traits::value_type Point; - typedef typename Kernel_traits::Kernel Kernel; - - return wlop_simplify_and_regularize_point_set( - first, beyond, - output, - point_pmap, - select_percentage, - neighbor_radius, - max_iter_number, - require_uniform_sampling, - Kernel()); + CGAL_POINT_SET_PROCESSING_DEPRECATED_V1_API("wlop_simplify_and_regularize_point_set()"); + CGAL::Iterator_range points (first, beyond); + return wlop_simplify_and_regularize_point_set + (points, output, + CGAL::parameters::point_map (point_map). + select_percentage (select_percentage). + neighbor_radius (neighbor_radius). + number_of_iterations(max_iter_number). + require_uniform_sampling (require_uniform_sampling)); } /// @endcond @@ -666,7 +729,7 @@ wlop_simplify_and_regularize_point_set( /// @cond SKIP_IN_MANUAL /// This variant creates a default point property map=Dereference_property_map. -template OutputIterator @@ -681,16 +744,14 @@ wlop_simplify_and_regularize_point_set( ///to generate a more uniform result. ) { - return wlop_simplify_and_regularize_point_set( - first, beyond, - output, - make_identity_property_map(typename std::iterator_traits - :: - value_type()), - select_percentage, - neighbor_radius, - max_iter_number, - require_uniform_sampling); + CGAL_POINT_SET_PROCESSING_DEPRECATED_V1_API("wlop_simplify_and_regularize_point_set()"); + CGAL::Iterator_range points (first, beyond); + return wlop_simplify_and_regularize_point_set + (points, output, + CGAL::parameters::select_percentage (select_percentage). + neighbor_radius (neighbor_radius). + number_of_iterations(max_iter_number). + require_uniform_sampling (require_uniform_sampling)); } /// @endcond