songsenand
/
cgal
mirror of https://github.com/CGAL/cgal
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Consolidated free_functions.h 

Moved property maps outside of NamedParameters for point-based region growing
This commit is contained in:
Sven Oesau 2022-05-13 08:57:39 +02:00
parent 204c3ad289
commit e5ebd268ef
22 changed files with 158 additions and 222 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
Shape_detection/include/CGAL/Shape_detection/Region_growing/Region_growing_on_point_set/K_neighbor_query.h
View File

@ -134,10 +134,10 @@ namespace Point_set {
template<typename CGAL_NP_TEMPLATE_PARAMETERS>
K_neighbor_query(
const InputRange& input_range,
const Point_map point_map,
const CGAL_NP_CLASS& np = parameters::default_values()) :
m_input_range(input_range),
m_point_map(parameters::choose_parameter(parameters::get_parameter(
np, internal_np::point_map), PointMap())),
m_point_map(point_map),
m_index_to_point_map(m_input_range, m_point_map),
m_distance(m_index_to_point_map),
m_tree(

8
Shape_detection/include/CGAL/Shape_detection/Region_growing/Region_growing_on_point_set/Least_squares_circle_fit_region.h
View File

@ -162,12 +162,12 @@ namespace Point_set {
template<typename CGAL_NP_TEMPLATE_PARAMETERS>
Least_squares_circle_fit_region(
const InputRange& input_range,
const Point_map point_map,
const Normal_map normal_map,
const CGAL_NP_CLASS& np = parameters::default_values()) :
m_input_range(input_range),
m_point_map(parameters::choose_parameter(parameters::get_parameter(
np, internal_np::point_map), PointMap())),
m_normal_map(parameters::choose_parameter(parameters::get_parameter(
np, internal_np::normal_map), NormalMap())),
m_point_map(point_map),
m_normal_map(normal_map),
m_traits(parameters::choose_parameter(parameters::get_parameter(
np, internal_np::geom_traits), GeomTraits())),
m_sqrt(Get_sqrt::sqrt_object(m_traits)),

7
Shape_detection/include/CGAL/Shape_detection/Region_growing/Region_growing_on_point_set/Least_squares_circle_fit_sorting.h
View File

@ -112,15 +112,16 @@ namespace Point_set {
\pre `input_range.size() > 0`
*/
template<typename CGAL_NP_TEMPLATE_PARAMETERS>
template<typename Dummy, typename CGAL_NP_TEMPLATE_PARAMETERS>
Least_squares_circle_fit_sorting(
const InputRange& input_range,
NeighborQuery& neighbor_query,
const Point_map point_map,
const Dummy,
const CGAL_NP_CLASS& np = parameters::default_values()) :
m_input_range(input_range),
m_neighbor_query(neighbor_query),
m_point_map(parameters::choose_parameter(parameters::get_parameter(
np, internal_np::point_map), PointMap())),
m_point_map(point_map),
m_traits(parameters::choose_parameter(parameters::get_parameter(
np, internal_np::geom_traits), GeomTraits())) {

8
Shape_detection/include/CGAL/Shape_detection/Region_growing/Region_growing_on_point_set/Least_squares_cylinder_fit_region.h
View File

@ -162,12 +162,12 @@ namespace Point_set {
template<typename CGAL_NP_TEMPLATE_PARAMETERS>
Least_squares_cylinder_fit_region(
const InputRange& input_range,
const Point_map point_map,
const Normal_map normal_map,
const CGAL_NP_CLASS& np = parameters::default_values()) :
m_input_range(input_range),
m_point_map(parameters::choose_parameter(parameters::get_parameter(
np, internal_np::point_map), PointMap())),
m_normal_map(parameters::choose_parameter(parameters::get_parameter(
np, internal_np::normal_map), NormalMap())),
m_point_map(point_map),
m_normal_map(normal_map),
m_traits(parameters::choose_parameter(parameters::get_parameter(
np, internal_np::geom_traits), GeomTraits())),
m_sqrt(Get_sqrt::sqrt_object(m_traits)),

8
Shape_detection/include/CGAL/Shape_detection/Region_growing/Region_growing_on_point_set/Least_squares_cylinder_fit_sorting.h
View File

@ -127,13 +127,13 @@ namespace Point_set {
Least_squares_cylinder_fit_sorting(
const InputRange& input_range,
NeighborQuery& neighbor_query,
const Point_map point_map,
const Normal_map normal_map,
const CGAL_NP_CLASS& np = parameters::default_values()) :
m_input_range(input_range),
m_neighbor_query(neighbor_query),
m_point_map(parameters::choose_parameter(parameters::get_parameter(
np, internal_np::point_map), PointMap())),
m_normal_map(parameters::choose_parameter(parameters::get_parameter(
np, internal_np::normal_map), NormalMap())),
m_point_map(point_map),
m_normal_map(normal_map),
m_traits(parameters::choose_parameter(parameters::get_parameter(
np, internal_np::geom_traits), GeomTraits())) {

8
Shape_detection/include/CGAL/Shape_detection/Region_growing/Region_growing_on_point_set/Least_squares_line_fit_region.h
View File

@ -148,12 +148,12 @@ namespace Point_set {
template<typename CGAL_NP_TEMPLATE_PARAMETERS>
Least_squares_line_fit_region(
const InputRange& input_range,
const Point_map point_map,
const Normal_map normal_map,
const CGAL_NP_CLASS& np = parameters::default_values()) :
m_input_range(input_range),
m_point_map(parameters::choose_parameter(parameters::get_parameter(
np, internal_np::point_map), PointMap())),
m_normal_map(parameters::choose_parameter(parameters::get_parameter(
np, internal_np::normal_map), NormalMap())),
m_point_map(point_map),
m_normal_map(normal_map),
m_traits(parameters::choose_parameter(parameters::get_parameter(
np, internal_np::geom_traits), GeomTraits())),
m_squared_length_2(m_traits.compute_squared_length_2_object()),

7
Shape_detection/include/CGAL/Shape_detection/Region_growing/Region_growing_on_point_set/Least_squares_line_fit_sorting.h
View File

@ -112,15 +112,16 @@ namespace Point_set {
\pre `input_range.size() > 0`
*/
template<typename CGAL_NP_TEMPLATE_PARAMETERS>
template<typename Dummy, typename CGAL_NP_TEMPLATE_PARAMETERS>
Least_squares_line_fit_sorting(
const InputRange& input_range,
NeighborQuery& neighbor_query,
const Point_map point_map,
const Dummy,
const CGAL_NP_CLASS& np = parameters::default_values()) :
m_input_range(input_range),
m_neighbor_query(neighbor_query),
m_point_map(parameters::choose_parameter(parameters::get_parameter(
np, internal_np::point_map), PointMap())),
m_point_map(point_map),
m_traits(parameters::choose_parameter(parameters::get_parameter(
np, internal_np::geom_traits), GeomTraits())) {

8
Shape_detection/include/CGAL/Shape_detection/Region_growing/Region_growing_on_point_set/Least_squares_plane_fit_region.h
View File

@ -148,12 +148,12 @@ namespace Point_set {
template<typename CGAL_NP_TEMPLATE_PARAMETERS>
Least_squares_plane_fit_region(
const InputRange& input_range,
const Point_map point_map,
const Normal_map normal_map,
const CGAL_NP_CLASS& np = parameters::default_values()) :
m_input_range(input_range),
m_point_map(parameters::choose_parameter(parameters::get_parameter(
np, internal_np::point_map), PointMap())),
m_normal_map(parameters::choose_parameter(parameters::get_parameter(
np, internal_np::normal_map), NormalMap())),
m_point_map(point_map),
m_normal_map(normal_map),
m_traits(parameters::choose_parameter(parameters::get_parameter(
np, internal_np::geom_traits), GeomTraits())),
m_squared_length_3(m_traits.compute_squared_length_3_object()),

8
Shape_detection/include/CGAL/Shape_detection/Region_growing/Region_growing_on_point_set/Least_squares_plane_fit_sorting.h
View File

@ -112,15 +112,17 @@ namespace Point_set {
\pre `input_range.size() > 0`
*/
template<typename CGAL_NP_TEMPLATE_PARAMETERS>
template<typename Dummy,
typename CGAL_NP_TEMPLATE_PARAMETERS>
Least_squares_plane_fit_sorting(
const InputRange& input_range,
NeighborQuery& neighbor_query,
const Point_map point_map,
const Dummy,
const CGAL_NP_CLASS& np = parameters::default_values()) :
m_input_range(input_range),
m_neighbor_query(neighbor_query),
m_point_map(parameters::choose_parameter(parameters::get_parameter(
np, internal_np::point_map), PointMap())),
m_point_map(point_map),
m_traits(parameters::choose_parameter(parameters::get_parameter(
np, internal_np::geom_traits), GeomTraits())) {

8
Shape_detection/include/CGAL/Shape_detection/Region_growing/Region_growing_on_point_set/Least_squares_sphere_fit_region.h
View File

@ -161,12 +161,12 @@ namespace Point_set {
template<typename CGAL_NP_TEMPLATE_PARAMETERS>
Least_squares_sphere_fit_region(
const InputRange& input_range,
const Point_map point_map,
const Normal_map normal_map,
const CGAL_NP_CLASS& np = parameters::default_values()) :
m_input_range(input_range),
m_point_map(parameters::choose_parameter(parameters::get_parameter(
np, internal_np::point_map), PointMap())),
m_normal_map(parameters::choose_parameter(parameters::get_parameter(
np, internal_np::normal_map), NormalMap())),
m_point_map(point_map),
m_normal_map(normal_map),
m_traits(parameters::choose_parameter(parameters::get_parameter(
np, internal_np::geom_traits), GeomTraits())),
m_sqrt(Get_sqrt::sqrt_object(m_traits)),

8
Shape_detection/include/CGAL/Shape_detection/Region_growing/Region_growing_on_point_set/Least_squares_sphere_fit_sorting.h
View File

@ -112,15 +112,17 @@ namespace Point_set {
\pre `input_range.size() > 0`
*/
template<typename CGAL_NP_TEMPLATE_PARAMETERS>
template<typename Dummy,
typename CGAL_NP_TEMPLATE_PARAMETERS>
Least_squares_sphere_fit_sorting(
const InputRange& input_range,
NeighborQuery& neighbor_query,
const Point_map point_map,
const Dummy,
const CGAL_NP_CLASS& np= parameters::default_values()) :
m_input_range(input_range),
m_neighbor_query(neighbor_query),
m_point_map(parameters::choose_parameter(parameters::get_parameter(
np, internal_np::point_map), PointMap())),
m_point_map(point_map),
m_traits(parameters::choose_parameter(parameters::get_parameter(
np, internal_np::geom_traits), GeomTraits())) {

4
Shape_detection/include/CGAL/Shape_detection/Region_growing/Region_growing_on_point_set/Sphere_neighbor_query.h
View File

@ -131,10 +131,10 @@ namespace Point_set {
template<typename CGAL_NP_TEMPLATE_PARAMETERS>
Sphere_neighbor_query(
const InputRange& input_range,
const Point_map point_map,
const CGAL_NP_CLASS& np = parameters::default_values()) :
m_input_range(input_range),
m_point_map(parameters::choose_parameter(parameters::get_parameter(
np, internal_np::point_map), PointMap())),
m_point_map(point_map),
m_index_to_point_map(m_input_range, m_point_map),
m_tree(
boost::counting_iterator<std::size_t>(0),

178
Shape_detection/include/CGAL/Shape_detection/Region_growing/internal/free_functions.h
View File

@ -16,11 +16,6 @@
#include <CGAL/license/Shape_detection.h>
#include <CGAL/Point_set_3.h>
#include <CGAL/Surface_mesh.h>
#include <CGAL/Polyhedron_3.h>
#include <CGAL/HalfedgeDS_vector.h>
#include <CGAL/Shape_detection/Region_growing/Region_growing.h>
#include <CGAL/Shape_detection/Region_growing/Region_growing_on_point_set.h>
#include <CGAL/Shape_detection/Region_growing/Region_growing_on_polygon_mesh.h>
@ -28,7 +23,7 @@
#include <CGAL/Shape_detection/Region_growing/Region_growing_on_segment_set.h>
// TODO: this is not using generic programming for FaceGraph and PointSet
// as a consequence, artifical depencencies on Surface_mesh, Polyhedron,
// as a consequence, artificial dependencies on Surface_mesh, Polyhedron,
// HDS and Point_set_3 are done.
namespace CGAL {
@ -37,161 +32,79 @@ namespace internal {
template<
typename InputRange,
typename PointMap,
typename NormalMap,
typename OutputIterator,
typename CGAL_NP_TEMPLATE_PARAMETERS>
OutputIterator region_growing_lines(
const InputRange& points_with_normals, OutputIterator regions, const CGAL_NP_CLASS& np = parameters::default_values()) {
const InputRange& points, PointMap point_map, NormalMap normal_map, OutputIterator regions, const CGAL_NP_CLASS& np = parameters::default_values()) {
using Input_range = InputRange;
using Point_with_normal = typename Input_range::value_type;
using Point_type = typename Point_with_normal::first_type;
using Traits = typename Kernel_traits<Point_type>::Kernel;
using Point_map = CGAL::First_of_pair_property_map<Point_with_normal>;
using Normal_map = CGAL::Second_of_pair_property_map<Point_with_normal>;
using Kernel = typename Kernel_traits<boost::property_traits<PointMap>::value_type>::Kernel;
using Neighbor_query = Point_set::K_neighbor_query<Kernel, InputRange, PointMap>;
using Region_type = Point_set::Least_squares_line_fit_region<Kernel, InputRange, PointMap, NormalMap>;
using Sorting = Point_set::Least_squares_line_fit_sorting<Kernel, InputRange, Neighbor_query, PointMap>;
using Region_growing = Region_growing<InputRange, Neighbor_query, Region_type, typename Sorting::Seed_map>;
using Neighbor_query = Point_set::K_neighbor_query<Traits, Input_range, Point_map>;
using Region_type = Point_set::Least_squares_line_fit_region<Traits, Input_range, Point_map, Normal_map>;
using Sorting = Point_set::Least_squares_line_fit_sorting<Traits, Input_range, Neighbor_query, Point_map>;
using Region_growing = Region_growing<Input_range, Neighbor_query, Region_type, typename Sorting::Seed_map>;
Neighbor_query neighbor_query(points_with_normals, np);
Region_type region_type(points_with_normals, np);
Sorting sorting(points_with_normals, neighbor_query, np);
Neighbor_query neighbor_query(points, point_map, np);
Region_type region_type(points, point_map, normal_map, np);
Sorting sorting(points, neighbor_query, point_map, np);
sorting.sort();
Region_growing region_growing(
points_with_normals, neighbor_query, region_type, sorting.seed_map());
points, neighbor_query, region_type, sorting.seed_map());
region_growing.detect(regions);
return regions;
}
template<
typename InputRange,
typename PointMap,
typename NormalMap,
typename OutputIterator,
typename CGAL_NP_TEMPLATE_PARAMETERS>
OutputIterator region_growing_planes(
const InputRange& points_with_normals, OutputIterator regions, const CGAL_NP_CLASS& np = parameters::default_values()) {
InputRange& points, PointMap point_map, NormalMap normal_map, OutputIterator regions, const CGAL_NP_CLASS& np = parameters::default_values()) {
using Input_range = InputRange;
using Point_with_normal = typename Input_range::value_type;
using Point_type = typename Point_with_normal::first_type;
using Traits = typename Kernel_traits<Point_type>::Kernel;
using Point_map = CGAL::First_of_pair_property_map<Point_with_normal>;
using Normal_map = CGAL::Second_of_pair_property_map<Point_with_normal>;
using Kernel = typename Kernel_traits<boost::property_traits<PointMap>::value_type>::Kernel;
using Neighbor_query = Point_set::K_neighbor_query<Kernel, InputRange, PointMap>;
using Region_type = Point_set::Least_squares_plane_fit_region<Kernel, InputRange, PointMap, NormalMap>;
using Sorting = Point_set::Least_squares_plane_fit_sorting<Kernel, InputRange, Neighbor_query, PointMap>;
using Region_growing = Region_growing<InputRange, Neighbor_query, Region_type, typename Sorting::Seed_map>;
using Neighbor_query = Point_set::K_neighbor_query<Traits, Input_range, Point_map>;
using Region_type = Point_set::Least_squares_plane_fit_region<Traits, Input_range, Point_map, Normal_map>;
using Sorting = Point_set::Least_squares_plane_fit_sorting<Traits, Input_range, Neighbor_query, Point_map>;
using Region_growing = Region_growing<Input_range, Neighbor_query, Region_type, typename Sorting::Seed_map>;
Neighbor_query neighbor_query(points_with_normals, np);
Region_type region_type(points_with_normals, np);
Sorting sorting(points_with_normals, neighbor_query, np);
Neighbor_query neighbor_query(points, point_map, np);
Region_type region_type(points, point_map, normal_map, np);
Sorting sorting(points, neighbor_query, point_map, np);
sorting.sort();
Region_growing region_growing(
points_with_normals, neighbor_query, region_type, sorting.seed_map());
points, neighbor_query, region_type, sorting.seed_map());
region_growing.detect(regions);
return regions;
}
template<
typename PointType,
typename VectorType,
typename OutputIterator,
typename CGAL_NP_TEMPLATE_PARAMETERS_NO_DEFAULT>
OutputIterator region_growing_planes(
const CGAL::Point_set_3<PointType, VectorType>& point_set, OutputIterator regions, const CGAL_NP_CLASS& np) {
using Point_type = PointType;
using Vector_type = VectorType;
using Traits = typename Kernel_traits<Point_type>::Kernel;
using Point_set_3 = CGAL::Point_set_3<Point_type, Vector_type>;
using Point_map = typename Point_set_3::Point_map;
using Normal_map = typename Point_set_3::Vector_map;
using Neighbor_query = Point_set::K_neighbor_query<Traits, Point_set_3, Point_map>;
using Region_type = Point_set::Least_squares_plane_fit_region<Traits, Point_set_3, Point_map, Normal_map>;
using Sorting = Point_set::Least_squares_plane_fit_sorting<Traits, Point_set_3, Neighbor_query, Point_map>;
using Region_growing = Region_growing<Point_set_3, Neighbor_query, Region_type, typename Sorting::Seed_map>;
CGAL_precondition(point_set.has_normal_map());
Neighbor_query neighbor_query(point_set, np);
Region_type region_type(point_set, np);
Sorting sorting(point_set, neighbor_query, np);
sorting.sort();
Region_growing region_growing(
point_set, neighbor_query, region_type, sorting.seed_map());
region_growing.detect(regions);
return regions;
}
template<
typename PointType,
typename VectorType,
typename OutputIterator>
OutputIterator region_growing_planes(
const CGAL::Point_set_3<PointType, VectorType>& point_set, OutputIterator regions) {
return region_growing_planes(
point_set, regions, CGAL::parameters::
point_map(point_set.point_map()).
normal_map(point_set.normal_map()));
}
template<
typename GeomTraits,
typename PolygonMesh,
typename OutputIterator,
typename CGAL_NP_TEMPLATE_PARAMETERS>
OutputIterator region_growing_planes(
const CGAL::Polyhedron_3<GeomTraits, CGAL::Polyhedron_items_3, CGAL::HalfedgeDS_vector>& polyhedron,
OutputIterator regions, const CGAL_NP_CLASS& np = parameters::default_values()) {
OutputIterator region_growing_planes_polygon_mesh(
const PolygonMesh& polygon_mesh, OutputIterator regions, const CGAL_NP_CLASS& np = parameters::default_values()) {
using Traits = GeomTraits;
using Polyhedron = CGAL::Polyhedron_3<Traits, CGAL::Polyhedron_items_3, CGAL::HalfedgeDS_vector>;
using Face_range = typename CGAL::Iterator_range<typename boost::graph_traits<Polyhedron>::face_iterator>;
using Neighbor_query = Polygon_mesh::One_ring_neighbor_query<Polyhedron>;
using Region_type = Polygon_mesh::Least_squares_plane_fit_region<Traits, Polyhedron, Face_range>;
using Sorting = Polygon_mesh::Least_squares_plane_fit_sorting<Traits, Polyhedron, Neighbor_query, Face_range>;
using Kernel = typename Kernel_traits<typename PolygonMesh::Point>::Kernel;
using Face_iterator = typename boost::graph_traits<PolygonMesh>::face_iterator;
using Face_range = Iterator_range<typename Face_iterator>;
using Neighbor_query = Polygon_mesh::One_ring_neighbor_query<PolygonMesh>;
using Region_type = Polygon_mesh::Least_squares_plane_fit_region<Kernel, PolygonMesh, Face_range>;
using Sorting = Polygon_mesh::Least_squares_plane_fit_sorting<Kernel, PolygonMesh, Neighbor_query, Face_range>;
using Region_growing = Region_growing<Face_range, Neighbor_query, Region_type, typename Sorting::Seed_map>;
const Face_range face_range = faces(polyhedron);
Neighbor_query neighbor_query(polyhedron);
Region_type region_type(polyhedron, np);
Sorting sorting(polyhedron, neighbor_query, np);
Neighbor_query neighbor_query(polygon_mesh);
Region_type region_type(polygon_mesh, np);
Sorting sorting(polygon_mesh, neighbor_query, np);
sorting.sort();
Region_growing region_growing(
face_range, neighbor_query, region_type, sorting.seed_map());
region_growing.detect(regions);
return regions;
}
template<
typename PointType,
typename OutputIterator,
typename CGAL_NP_TEMPLATE_PARAMETERS>
OutputIterator region_growing_planes(
const CGAL::Surface_mesh<PointType>& surface_mesh, OutputIterator regions, const CGAL_NP_CLASS& np = parameters::default_values()) {
using Point_type = PointType;
using Traits = typename Kernel_traits<Point_type>::Kernel;
using Surface_mesh = CGAL::Surface_mesh<Point_type>;
using Face_range = typename Surface_mesh::Face_range;
using Neighbor_query = Polygon_mesh::One_ring_neighbor_query<Surface_mesh>;
using Region_type = Polygon_mesh::Least_squares_plane_fit_region<Traits, Surface_mesh>;
using Sorting = Polygon_mesh::Least_squares_plane_fit_sorting<Traits, Surface_mesh, Neighbor_query>;
using Region_growing = Region_growing<Face_range, Neighbor_query, Region_type, typename Sorting::Seed_map>;
const Face_range face_range = faces(surface_mesh);
Neighbor_query neighbor_query(surface_mesh);
Region_type region_type(surface_mesh, np);
Sorting sorting(surface_mesh, neighbor_query, np);
sorting.sort();
Region_growing region_growing(
face_range, neighbor_query, region_type, sorting.seed_map());
faces(polygon_mesh), neighbor_query, region_type, sorting.seed_map());
region_growing.detect(regions);
return regions;
}
@ -203,15 +116,14 @@ typename CGAL_NP_TEMPLATE_PARAMETERS>
OutputIterator region_growing_polylines(
const InputRange& polyline, OutputIterator regions, const CGAL_NP_CLASS& np = parameters::default_values()) {
using Input_range = InputRange;
using Point_type = typename Input_range::value_type;
using Traits = typename Kernel_traits<Point_type>::Kernel;
using Point_type = typename InputRange::value_type;
using Kernel = typename Kernel_traits<Point_type>::Kernel;
using Point_map = CGAL::Identity_property_map<Point_type>;
using Neighbor_query = Polyline::One_ring_neighbor_query<Traits, Input_range>;
using Region_type = Polyline::Least_squares_line_fit_region<Traits, Input_range, Point_map>;
using Sorting = Polyline::Least_squares_line_fit_sorting<Traits, Input_range, Neighbor_query, Point_map>;
using Region_growing = Region_growing<Input_range, Neighbor_query, Region_type, typename Sorting::Seed_map>;
using Neighbor_query = Polyline::One_ring_neighbor_query<Kernel, InputRange>;
using Region_type = Polyline::Least_squares_line_fit_region<Kernel, InputRange, Point_map>;
using Sorting = Polyline::Least_squares_line_fit_sorting<Kernel, InputRange, Neighbor_query, Point_map>;
using Region_growing = Region_growing<InputRange, Neighbor_query, Region_type, typename Sorting::Seed_map>;
Neighbor_query neighbor_query(polyline);
Region_type region_type(polyline, np);

4
Shape_detection/test/Shape_detection/test_region_growing_basic.cpp
View File

@ -45,8 +45,8 @@ int main(int argc, char *argv[]) {
assert(input_range.size() == 3634);
// Create parameter classes.
Neighbor_query neighbor_query(input_range);
Region_type region_type(input_range);
Neighbor_query neighbor_query(input_range, Point_map());
Region_type region_type(input_range, Point_map(), Normal_map());
// Run region growing.
Region_growing region_growing(

2
Shape_detection/test/Shape_detection/test_region_growing_on_cube.cpp
View File

@ -94,7 +94,7 @@ bool test_region_growing_on_cube(int argc, char *argv[]) {
// Test free functions and stability.
for (std::size_t k = 0; k < 3; ++k) {
regions.clear();
SD::internal::region_growing_planes(
SD::internal::region_growing_planes_polygon_mesh(
polyhedron, std::back_inserter(regions),
CGAL::parameters::
maximum_distance(distance_threshold).

5
Shape_detection/test/Shape_detection/test_region_growing_on_point_set_2.cpp
View File

@ -58,9 +58,12 @@ bool test_region_growing_on_point_set_2(int argc, char *argv[]) {
// Create parameter classes.
Neighbor_query neighbor_query(
input_range, CGAL::parameters::sphere_radius(sphere_radius));
input_range, Point_map(),
CGAL::parameters::sphere_radius(sphere_radius));
Region_type region_type(
input_range,
Point_map(),
Normal_map(),
CGAL::parameters::
maximum_distance(distance_threshold).
maximum_angle(angle_threshold).

9
Shape_detection/test/Shape_detection/test_region_growing_on_point_set_2_with_sorting.cpp
View File

@ -61,9 +61,9 @@ bool test(int argc, char** argv, const std::string name, const std::size_t minr,
// Create parameter classes.
Neighbor_query neighbor_query(
input_range, CGAL::parameters::k_neighbors(k));
input_range, Point_map(), CGAL::parameters::k_neighbors(k));
Region_type region_type(
input_range,
input_range, Point_map(), Normal_map(),
CGAL::parameters::
maximum_distance(max_distance).
maximum_angle(max_angle).
@ -71,7 +71,7 @@ bool test(int argc, char** argv, const std::string name, const std::size_t minr,
// Sort indices.
Sorting sorting(
input_range, neighbor_query);
input_range, neighbor_query, Point_map(), Normal_map());
sorting.sort();
// Run region growing.
@ -89,7 +89,8 @@ bool test(int argc, char** argv, const std::string name, const std::size_t minr,
for (std::size_t k = 0; k < 3; ++k) {
regions.clear();
SD::internal::region_growing_lines(
input_range, std::back_inserter(regions),
input_range, Point_map(), Normal_map(),
std::back_inserter(regions),
CGAL::parameters::
maximum_distance(max_distance).
maximum_angle(max_angle).

14
Shape_detection/test/Shape_detection/test_region_growing_on_point_set_3.cpp
View File

@ -55,18 +55,18 @@ bool test_region_growing_on_point_set_3(int argc, char *argv[]) {
// Create parameter classes.
Neighbor_query neighbor_query(
input_range, CGAL::parameters::
sphere_radius(sphere_radius).
point_map(input_range.point_map()));
input_range,
input_range.point_map(),
CGAL::parameters::
sphere_radius(sphere_radius));
Region_type region_type(
input_range,
input_range, input_range.point_map(),
input_range.normal_map(),
CGAL::parameters::
maximum_distance(distance_threshold).
maximum_angle(angle_threshold).
minimum_region_size(min_region_size).
point_map(input_range.point_map()).
normal_map(input_range.normal_map()));
minimum_region_size(min_region_size));
// Run region growing.
Region_growing region_growing(

49
Shape_detection/test/Shape_detection/test_region_growing_on_point_set_3_with_sorting.cpp
View File

@ -65,16 +65,14 @@ bool test(
// Create parameter classes.
Neighbor_query neighbor_query(
input_range, CGAL::parameters::
k_neighbors(k).
point_map(input_range.point_map()));
input_range, input_range.point_map(), CGAL::parameters::
k_neighbors(k));
// Sort indices.
Sorting sorting(
input_range, neighbor_query,
CGAL::parameters::
point_map(input_range.point_map()).
normal_map(input_range.normal_map()));
input_range.point_map(),
input_range.normal_map());
sorting.sort();
// Run region growing.
@ -97,13 +95,14 @@ bool test(
for (std::size_t k = 0; k < 3; ++k) {
regions.clear();
SD::internal::region_growing_planes(
input_range, std::back_inserter(regions),
input_range,
input_range.point_map(),
input_range.normal_map(),
std::back_inserter(regions),
CGAL::parameters::
maximum_distance(max_distance).
maximum_angle(max_angle).
minimum_region_size(min_region_size).
point_map(input_range.point_map()).
normal_map(input_range.normal_map()));
minimum_region_size(min_region_size));
assert(regions.size() == 7);
}
@ -122,12 +121,12 @@ int main(int argc, char *argv[]) {
const FT max_distance = FT(2);
const FT max_angle = FT(20);
const std::size_t min_region_size = 50;
return Plane_region(input_range, CGAL::parameters::
maximum_distance(max_distance).
return Plane_region(input_range,
input_range.point_map(),
input_range.normal_map(),
CGAL::parameters::maximum_distance(max_distance).
maximum_angle(max_angle).
minimum_region_size(min_region_size).
point_map(input_range.point_map()).
normal_map(input_range.normal_map()));
minimum_region_size(min_region_size));
},
[](const auto& region) -> bool {
std::cout << "- num regions planes: " << region.size() << std::endl;
@ -146,12 +145,12 @@ int main(int argc, char *argv[]) {
const FT max_distance = FT(1) / FT(100);
const FT max_angle = FT(10);
const std::size_t min_region_size = 50;
return Sphere_region(input_range, CGAL::parameters::
maximum_distance(max_distance).
return Sphere_region(input_range,
input_range.point_map(),
input_range.normal_map(),
CGAL::parameters::maximum_distance(max_distance).
maximum_angle(max_angle).
minimum_region_size(min_region_size).
point_map(input_range.point_map()).
normal_map(input_range.normal_map()));
minimum_region_size(min_region_size));
},
[](const auto& region) -> bool {
std::cout << "- num regions spheres: " << region.size() << std::endl;
@ -170,12 +169,12 @@ int main(int argc, char *argv[]) {
const FT max_distance = FT(1) / FT(20);
const FT max_angle = FT(5);
const std::size_t min_region_size = 200;
return Cylinder_region(input_range, CGAL::parameters::
maximum_distance(max_distance).
return Cylinder_region(input_range,
input_range.point_map(),
input_range.normal_map(),
CGAL::parameters::maximum_distance(max_distance).
maximum_angle(max_angle).
minimum_region_size(min_region_size).
point_map(input_range.point_map()).
normal_map(input_range.normal_map()));
minimum_region_size(min_region_size));
},
[](const auto& region) -> bool {
std::cout << "- num regions cylinders: " << region.size() << std::endl;

2
Shape_detection/test/Shape_detection/test_region_growing_on_polygon_mesh_with_sorting.cpp
View File

@ -81,7 +81,7 @@ int main(int argc, char *argv[]) {
// Test free functions and stability.
for (std::size_t k = 0; k < 3; ++k) {
regions.clear();
SD::internal::region_growing_planes(
SD::internal::region_growing_planes_polygon_mesh(
polygon_mesh, std::back_inserter(regions),
CGAL::parameters::
maximum_distance(distance_threshold).

26
Shape_detection/test/Shape_detection/test_region_growing_strict.cpp
View File

@ -11,6 +11,11 @@
#include <CGAL/assertions.h>
#include <CGAL/property_map.h>
#include <CGAL/Point_set_3.h>
#include <CGAL/Surface_mesh.h>
#include <CGAL/Polyhedron_3.h>
#include <CGAL/HalfedgeDS_vector.h>
#include <CGAL/Simple_cartesian.h>
#include <CGAL/Exact_predicates_inexact_constructions_kernel.h>
#include <CGAL/Exact_predicates_exact_constructions_kernel.h>
@ -45,7 +50,10 @@ bool test_lines_points_with_normals() {
assert(points_with_normals.size() == 9);
std::vector< std::vector<std::size_t> > regions;
CGAL::Shape_detection::internal::region_growing_lines(
points_with_normals, std::back_inserter(regions));
points_with_normals,
CGAL::First_of_pair_property_map<std::pair<Point_2, Vector_2> >(),
CGAL::Second_of_pair_property_map<std::pair<Point_2, Vector_2> >(),
std::back_inserter(regions));
assert(regions.size() == 3);
assert(regions[0].size() == 3);
assert(regions[1].size() == 3);
@ -201,7 +209,7 @@ bool test_lines_segment_set_3() {
assert(surface_mesh.number_of_faces() == 7320);
std::vector< std::vector<std::size_t> > regions;
CGAL::Shape_detection::internal::region_growing_planes(
CGAL::Shape_detection::internal::region_growing_planes_polygon_mesh(
surface_mesh, std::back_inserter(regions));
assert(regions.size() == 9);
@ -259,7 +267,10 @@ bool test_planes_points_with_normals() {
assert(points_with_normals.size() == 9);
std::vector< std::vector<std::size_t> > regions;
CGAL::Shape_detection::internal::region_growing_planes(
points_with_normals, std::back_inserter(regions));
points_with_normals,
CGAL::First_of_pair_property_map<std::pair<Point_3, Vector_3> >(),
CGAL::Second_of_pair_property_map<std::pair<Point_3, Vector_3> >(),
std::back_inserter(regions));
assert(regions.size() == 1);
assert(regions[0].size() == 9);
return true;
@ -295,7 +306,10 @@ bool test_planes_point_set() {
std::vector< std::vector<std::size_t> > regions;
CGAL::Shape_detection::internal::region_growing_planes(
point_set, std::back_inserter(regions));
point_set,
point_set.point_map(),
point_set.normal_map(),
std::back_inserter(regions));
assert(regions.size() == 1);
assert(regions[0].size() == 9);
return true;
@ -318,7 +332,7 @@ bool test_planes_polyhedron() {
assert(polyhedron.size_of_facets() == 4);
std::vector< std::vector<std::size_t> > regions;
CGAL::Shape_detection::internal::region_growing_planes(
CGAL::Shape_detection::internal::region_growing_planes_polygon_mesh(
polyhedron, std::back_inserter(regions));
assert(regions.size() == polyhedron.size_of_facets());
return true;
@ -340,7 +354,7 @@ bool test_planes_surface_mesh() {
assert(surface_mesh.number_of_faces() == 7320);
std::vector< std::vector<std::size_t> > regions;
CGAL::Shape_detection::internal::region_growing_planes(
CGAL::Shape_detection::internal::region_growing_planes_polygon_mesh(
surface_mesh, std::back_inserter(regions));
assert(regions.size() == 9);
return true;

5
Shape_detection/test/Shape_detection/test_validity_sampled_data.cpp
View File

@ -112,9 +112,10 @@ void test_copied_point_cloud (const Point_set& original_points, std::size_t nb)
CGAL::Real_timer t;
t.start();
RG_query rg_query (
points, CGAL::parameters::sphere_radius(parameters.cluster_epsilon));
points, Point_map(),
CGAL::parameters::sphere_radius(parameters.cluster_epsilon));
RG_region rg_region (
points,
points, Point_map(), Normal_map(),
CGAL::parameters::
maximum_distance(parameters.epsilon).
cosine_value(parameters.normal_threshold).