From e9094e1eeffb032d5f6c426344688439c21750b3 Mon Sep 17 00:00:00 2001 From: Andreas Fabri Date: Tue, 18 Nov 2003 22:05:55 +0000 Subject: [PATCH] *** empty log message *** --- .../include/CGAL/Euclidean_distance.h | 46 +++---- .../CGAL/Euclidean_distance_sphere_point.h | 52 ++++---- .../include/CGAL/Fuzzy_iso_box.h | 24 ++-- .../include/CGAL/Fuzzy_sphere.h | 34 ++--- .../CGAL/Incremental_neighbor_search.h | 48 +++---- .../include/CGAL/Iso_rectangle_d.h | 20 +-- .../include/CGAL/K_neighbor_search.h | 64 ++++++---- .../Spatial_searching/include/CGAL/Kd_tree.h | 36 +++--- .../include/CGAL/Kd_tree_d_new.h | 12 +- .../include/CGAL/Kd_tree_node.h | 28 ++-- .../include/CGAL/Kd_tree_rectangle.h | 72 +++++------ .../CGAL/Manhattan_distance_iso_box_point.h | 42 +++--- .../Orthogonal_incremental_neighbor_search.h | 66 +++++----- .../CGAL/Orthogonal_k_neighbor_search.h | 72 ++++++----- .../include/CGAL/Plane_separator.h | 18 +-- .../include/CGAL/Point_container.h | 120 +++++++++--------- ...Kd_tree_traits_point.h => Search_traits.h} | 16 +-- ...ree_traits_point_2.h => Search_traits_2.h} | 18 +-- ...ree_traits_point_3.h => Search_traits_3.h} | 18 +-- ...ree_traits_point_d.h => Search_traits_d.h} | 16 +-- .../include/CGAL/Splitters.h | 102 +++++++-------- .../CGAL/Weighted_Minkowski_distance.h | 84 ++++++------ 22 files changed, 516 insertions(+), 492 deletions(-) rename Packages/Spatial_searching/include/CGAL/{Kd_tree_traits_point.h => Search_traits.h} (76%) mode change 100755 => 100644 rename Packages/Spatial_searching/include/CGAL/{Kd_tree_traits_point_2.h => Search_traits_2.h} (74%) mode change 100755 => 100644 rename Packages/Spatial_searching/include/CGAL/{Kd_tree_traits_point_3.h => Search_traits_3.h} (74%) mode change 100755 => 100644 rename Packages/Spatial_searching/include/CGAL/{Kd_tree_traits_point_d.h => Search_traits_d.h} (79%) mode change 100755 => 100644 diff --git a/Packages/Spatial_searching/include/CGAL/Euclidean_distance.h b/Packages/Spatial_searching/include/CGAL/Euclidean_distance.h index 895629846ad..ef31d38505a 100644 --- a/Packages/Spatial_searching/include/CGAL/Euclidean_distance.h +++ b/Packages/Spatial_searching/include/CGAL/Euclidean_distance.h @@ -29,14 +29,14 @@ namespace CGAL { - template + template class Euclidean_distance { public: - typedef typename GeomTraits::Point Point; - typedef typename GeomTraits::NT NT; - typedef Point Query_item; + typedef typename SearchTraits::Point_d Point_d; + typedef typename SearchTraits::FT FT; + typedef Point_d Query_item; public: @@ -44,10 +44,10 @@ namespace CGAL { Euclidean_distance() {} - inline NT distance(const Point& q, const Point& p) const { - NT distance = NT(0); - typename GeomTraits::Construct_cartesian_const_iterator construct_it; - typename GeomTraits::Cartesian_const_iterator qit = construct_it(q), + inline FT transformed_distance(const Point_d& q, const Point_d& p) const { + FT distance = FT(0); + typename SearchTraits::Construct_cartesian_const_iterator_d construct_it; + typename SearchTraits::Cartesian_const_iterator_d qit = construct_it(q), qe = construct_it(q,1), pit = construct_it(p); for(; qit != qe; qit++, pit++){ distance += ((*qit)-(*pit))*((*qit)-(*pit)); @@ -56,11 +56,11 @@ namespace CGAL { } - inline NT min_distance_to_rectangle(const Point& q, - const Kd_tree_rectangle& r) const { - NT distance = NT(0); - typename GeomTraits::Construct_cartesian_const_iterator construct_it; - typename GeomTraits::Cartesian_const_iterator qit = construct_it(q), + inline FT min_distance_to_rectangle(const Point_d& q, + const Kd_tree_rectangle& r) const { + FT distance = FT(0); + typename SearchTraits::Construct_cartesian_const_iterator_d construct_it; + typename SearchTraits::Cartesian_const_iterator_d qit = construct_it(q), qe = construct_it(q,1); for(unsigned int i = 0;qit != qe; i++, qit++){ if((*qit) < r.min_coord(i)) @@ -74,14 +74,14 @@ namespace CGAL { return distance; } - inline NT max_distance_to_rectangle(const Point& q, - const Kd_tree_rectangle& r) const { - NT distance=NT(0); - typename GeomTraits::Construct_cartesian_const_iterator construct_it; - typename GeomTraits::Cartesian_const_iterator qit = construct_it(q), + inline FT max_distance_to_rectangle(const Point_d& q, + const Kd_tree_rectangle& r) const { + FT distance=FT(0); + typename SearchTraits::Construct_cartesian_const_iterator_d construct_it; + typename SearchTraits::Cartesian_const_iterator_d qit = construct_it(q), qe = construct_it(q,1); for(unsigned int i = 0;qit != qe; i++, qit++){ - if ((*qit) <= (r.min_coord(i)+r.max_coord(i))/NT(2.0)) + if ((*qit) <= (r.min_coord(i)+r.max_coord(i))/FT(2.0)) distance += (r.max_coord(i)-(*qit))*(r.max_coord(i)-(*qit)); else distance += ((*qit)-r.min_coord(i))*((*qit)-r.min_coord(i)); @@ -89,18 +89,18 @@ namespace CGAL { return distance; } - inline NT new_distance(NT dist, NT old_off, NT new_off, + inline FT new_distance(FT dist, FT old_off, FT new_off, int cutting_dimension) const { - NT new_dist = dist + new_off*new_off - old_off*old_off; + FT new_dist = dist + new_off*new_off - old_off*old_off; return new_dist; } - inline NT transformed_distance(NT d) const { + inline FT transformed_distance(FT d) const { return d*d; } - inline NT inverse_of_transformed_distance(NT d) const { + inline FT inverse_of_transformed_distance(FT d) const { return CGAL::sqrt(d); } diff --git a/Packages/Spatial_searching/include/CGAL/Euclidean_distance_sphere_point.h b/Packages/Spatial_searching/include/CGAL/Euclidean_distance_sphere_point.h index 46bf5066e31..fcfcd7e76a6 100644 --- a/Packages/Spatial_searching/include/CGAL/Euclidean_distance_sphere_point.h +++ b/Packages/Spatial_searching/include/CGAL/Euclidean_distance_sphere_point.h @@ -29,13 +29,13 @@ namespace CGAL { - template + template class Euclidean_distance_sphere_point { public: - typedef typename GeomTraits::Point Point; - typedef typename GeomTraits::NT NT; + typedef typename SearchTraits::Point_d Point_d; + typedef typename SearchTraits::FT FT; typedef Sphere Query_item; public: @@ -43,27 +43,27 @@ namespace CGAL { Euclidean_distance_sphere_point() {} - inline NT distance(const Sphere& q, const Point& p) const { - Point c=q.center(); - NT distance = NT(0); - typename GeomTraits::Construct_cartesian_const_iterator construct_it; - typename GeomTraits::Cartesian_const_iterator cit = construct_it(c), + inline FT transformed_distance(const Sphere& q, const Point_d& p) const { + Point_d c=q.center(); + FT distance = FT(0); + typename SearchTraits::Construct_cartesian_const_iterator_d construct_it; + typename SearchTraits::Cartesian_const_iterator_d cit = construct_it(c), ce = construct_it(c,1), pit = construct_it(p); for(; cit != ce; cit++, pit++){ distance += ((*cit)-(*pit))*((*cit)-(*pit)); } distance += -q.squared_radius(); - if (distance<0) distance=NT(0); + if (distance<0) distance=FT(0); return distance; } - inline NT min_distance_to_rectangle(const Sphere& q, - const Kd_tree_rectangle& r) const { - Point c=q.center(); - NT distance = NT(0); - typename GeomTraits::Construct_cartesian_const_iterator construct_it; - typename GeomTraits::Cartesian_const_iterator cit = construct_it(c), + inline FT min_distance_to_rectangle(const Sphere& q, + const Kd_tree_rectangle& r) const { + Point_d c=q.center(); + FT distance = FT(0); + typename SearchTraits::Construct_cartesian_const_iterator_d construct_it; + typename SearchTraits::Cartesian_const_iterator_d cit = construct_it(c), ce = construct_it(c,1); for (unsigned int i = 0; cit != ce; ++i, ++cit) { if ((*cit) < r.min_coord(i)) @@ -75,35 +75,35 @@ namespace CGAL { }; distance += -q.squared_radius(); - if (distance<0) distance=NT(0); + if (distance<0) distance=FT(0); return distance; } - inline NT max_distance_to_rectangle(const Sphere& q, - const Kd_tree_rectangle& r) const { - Point c=q.center(); - NT distance=NT(0); - typename GeomTraits::Construct_cartesian_const_iterator construct_it; - typename GeomTraits::Cartesian_const_iterator cit = construct_it(c), + inline FT max_distance_to_rectangle(const Sphere& q, + const Kd_tree_rectangle& r) const { + Point_d c=q.center(); + FT distance=FT(0); + typename SearchTraits::Construct_cartesian_const_iterator_d construct_it; + typename SearchTraits::Cartesian_const_iterator_d cit = construct_it(c), ce = construct_it(c,1); for (unsigned int i = 0; cit != ce; ++i, ++cit) { - if ((*cit) <= (r.min_coord(i)+r.max_coord(i))/NT(2.0)) + if ((*cit) <= (r.min_coord(i)+r.max_coord(i))/FT(2.0)) distance += (r.max_coord(i)-(*cit))*(r.max_coord(i)-(*cit)); else distance += ((*cit)-r.min_coord(i))*((*cit)-r.min_coord(i)); }; distance += -q.squared_radius(); - if (distance<0) distance=NT(0); + if (distance<0) distance=FT(0); return distance; } - inline NT transformed_distance(NT d) const { + inline FT transformed_distance(FT d) const { return d*d; } - inline NT inverse_of_transformed_distance(NT d) const { + inline FT inverse_of_transformed_distance(FT d) const { return CGAL::sqrt(d); } diff --git a/Packages/Spatial_searching/include/CGAL/Fuzzy_iso_box.h b/Packages/Spatial_searching/include/CGAL/Fuzzy_iso_box.h index ad52c62ad72..3aa113c6842 100644 --- a/Packages/Spatial_searching/include/CGAL/Fuzzy_iso_box.h +++ b/Packages/Spatial_searching/include/CGAL/Fuzzy_iso_box.h @@ -29,18 +29,18 @@ namespace CGAL { - template + template class Fuzzy_iso_box{ public: - typedef typename GeomTraits::Point Point; - typedef typename GeomTraits::NT NT; + typedef typename SearchTraits::Point_d Point_d; + typedef typename SearchTraits::FT FT; private: Iso_box box; - NT eps; + FT eps; unsigned int dim; public: @@ -49,27 +49,27 @@ namespace CGAL { Fuzzy_iso_box() {} // constructor - Fuzzy_iso_box(const Point& p, const Point& q, NT epsilon=NT(0)) + Fuzzy_iso_box(const Point_d& p, const Point_d& q, FT epsilon=FT(0)) : eps(epsilon) { - typename GeomTraits::Construct_cartesian_const_iterator construct_it; - typename GeomTraits::Cartesian_const_iterator begin = construct_it(p), + typename SearchTraits::Construct_cartesian_const_iterator_d construct_it; + typename SearchTraits::Cartesian_const_iterator_d begin = construct_it(p), end = construct_it(p,1); dim = end - begin; box = Iso_box(p,q); } - bool contains(const Point& p) const { - typename GeomTraits::Construct_cartesian_const_iterator construct_it; - typename GeomTraits::Cartesian_const_iterator pit = construct_it(p); + bool contains(const Point_d& p) const { + typename SearchTraits::Construct_cartesian_const_iterator_d construct_it; + typename SearchTraits::Cartesian_const_iterator_d pit = construct_it(p); for (unsigned int i = 0; i < dim; ++i, ++pit) { if ( ((*pit) < box.min()[i]) || ((*pit) >= box.max()[i]) ) return false; } return true; } - bool inner_range_intersects(const Kd_tree_rectangle& rectangle) const { + bool inner_range_intersects(const Kd_tree_rectangle& rectangle) const { for (unsigned int i = 0; i < dim; ++i) { if ( (box.max()[i]-eps < rectangle.min_coord(i)) || (box.min()[i]+eps >= rectangle.max_coord(i)) ) return false; @@ -78,7 +78,7 @@ namespace CGAL { } - bool outer_range_is_contained_by(const Kd_tree_rectangle& rectangle) const { + bool outer_range_is_contained_by(const Kd_tree_rectangle& rectangle) const { for (unsigned int i = 0; i < dim; ++i) { if ( (box.max()[i]+eps < rectangle.max_coord(i) ) || (box.min()[i]-eps >= rectangle.min_coord(i)) ) return false; diff --git a/Packages/Spatial_searching/include/CGAL/Fuzzy_sphere.h b/Packages/Spatial_searching/include/CGAL/Fuzzy_sphere.h index 445356a567c..75c5a316d98 100644 --- a/Packages/Spatial_searching/include/CGAL/Fuzzy_sphere.h +++ b/Packages/Spatial_searching/include/CGAL/Fuzzy_sphere.h @@ -29,19 +29,19 @@ namespace CGAL { - template + template class Fuzzy_sphere{ public: - typedef typename PointTraits::NT NT; + typedef typename SearchTraits::FT FT; - typedef typename PointTraits::Point Point; + typedef typename SearchTraits::Point_d Point_d; private: - Point c; - NT r; - NT eps; + Point_d c; + FT r; + FT eps; unsigned int dim; public: @@ -51,18 +51,18 @@ namespace CGAL { // constructor - Fuzzy_sphere(const Point& center, NT radius, NT epsilon=NT(0)) : + Fuzzy_sphere(const Point_d& center, FT radius, FT epsilon=FT(0)) : c(center), r(radius), eps(epsilon), dim(c.dimension()) { // avoid problems if eps > r if (eps>r) eps=r; } - bool contains(const Point& p) const { + bool contains(const Point_d& p) const { // test whether the squared distance // between P and c // is at most the squared_radius - NT squared_radius = r*r; - NT distance=NT(0); + FT squared_radius = r*r; + FT distance=FT(0); for (unsigned int i = 0; (i < dim) && (distance <= squared_radius); ++i) { distance += @@ -72,12 +72,12 @@ namespace CGAL { } - bool inner_range_intersects(const Kd_tree_rectangle& rectangle) const { + bool inner_range_intersects(const Kd_tree_rectangle& rectangle) const { // test whether the interior of a sphere // with radius (r-eps) intersects r, i.e. // if the minimal distance of r to c is less than r-eps - NT distance = NT(0); - NT squared_radius = (r-eps)*(r-eps); + FT distance = FT(0); + FT squared_radius = (r-eps)*(r-eps); for (unsigned int i = 0; (i < dim) && (distance < squared_radius); ++i) { if (c[i] < rectangle.min_coord(i)) distance += @@ -90,15 +90,15 @@ namespace CGAL { } - bool outer_range_is_contained_by(const Kd_tree_rectangle& rectangle) const { + bool outer_range_is_contained_by(const Kd_tree_rectangle& rectangle) const { // test whether the interior of a sphere // with radius (r+eps) is contained by r, i.e. // if the minimal distance of the boundary of r // to c is less than r+eps - NT distance=NT(0); - NT squared_radius = (r+eps)*(r+eps); + FT distance=FT(0); + FT squared_radius = (r+eps)*(r+eps); for (unsigned int i = 0; (i < dim) && (distance < squared_radius) ; ++i) { - if (c[i] <= (rectangle.min_coord(i)+rectangle.max_coord(i))/NT(2)) + if (c[i] <= (rectangle.min_coord(i)+rectangle.max_coord(i))/FT(2)) distance += (rectangle.max_coord(i)-c[i])*(rectangle.max_coord(i)-c[i]); else diff --git a/Packages/Spatial_searching/include/CGAL/Incremental_neighbor_search.h b/Packages/Spatial_searching/include/CGAL/Incremental_neighbor_search.h index 53e32554a76..124a9597483 100644 --- a/Packages/Spatial_searching/include/CGAL/Incremental_neighbor_search.h +++ b/Packages/Spatial_searching/include/CGAL/Incremental_neighbor_search.h @@ -34,22 +34,22 @@ namespace CGAL { -template , - class Splitter_ = Sliding_midpoint, - class Tree_=Kd_tree > +template , + class Splitter_ = Sliding_midpoint, + class Tree_=Kd_tree > class Incremental_neighbor_search { public: typedef Distance_ Distance; typedef Tree_ Tree; - typedef typename GeomTraits::Point Point; - typedef typename GeomTraits::NT NT; - typedef typename Tree::Point_iterator Point_iterator; + typedef typename SearchTraits::Point_d Point_d; + typedef typename SearchTraits::FT FT; + typedef typename Tree::Point_d_iterator Point_d_iterator; typedef typename Tree::Node_handle Node_handle; typedef typename Tree::Splitter Splitter; - typedef Kd_tree_rectangle Node_box; + typedef Kd_tree_rectangle Node_box; typedef typename Distance::Query_item Query_item; class Cell @@ -78,8 +78,8 @@ class Cell -typedef std::pair Point_with_distance; -typedef std::pair Cell_with_distance; +typedef std::pair Point_with_distance; +typedef std::pair Cell_with_distance; // this forward declaration may problems for g++ class iterator; @@ -89,7 +89,7 @@ class iterator; typedef std::vector Point_with_distance_vector; - typedef std::vector Distance_vector; + typedef std::vector Distance_vector; iterator *start; iterator *past_the_end; @@ -98,7 +98,7 @@ class iterator; // constructor Incremental_neighbor_search(Tree& tree, const Query_item& q, - NT Eps=NT(0.0), bool search_nearest=true, + FT Eps=FT(0.0), bool search_nearest=true, const Distance& tr=Distance()) { start = new iterator(tree,q,tr,Eps,search_nearest); @@ -145,7 +145,7 @@ class iterator; } // constructor - iterator(const Tree& tree, const Query_item& q, const Distance& tr, NT eps, + iterator(const Tree& tree, const Query_item& q, const Distance& tr, FT eps, bool search_nearest) { Ptr_implementation = new Iterator_implementation(tree, q, tr, eps, search_nearest); @@ -210,17 +210,17 @@ class iterator; private: - NT multiplication_factor; + FT multiplication_factor; Query_item query_point; int total_item_number; - NT distance_to_root; + FT distance_to_root; bool search_nearest_neighbour; - NT rd; + FT rd; class Priority_higher { @@ -280,7 +280,7 @@ class Distance_smaller // constructor Iterator_implementation(const Tree& tree, const Query_item& q,const Distance& tr, - NT Eps, bool search_nearest) + FT Eps, bool search_nearest) { @@ -296,7 +296,7 @@ class Distance_smaller reference_count=1; Distance_instance=new Distance(tr); multiplication_factor= - Distance_instance->transformed_distance(NT(1)+Eps); + Distance_instance->transformed_distance(FT(1)+Eps); Node_box *bounding_box = new Node_box(*(tree.bounding_box())); @@ -422,16 +422,16 @@ class Distance_smaller while (!(N->is_leaf())) { // compute new distances number_of_internal_nodes_visited++; int new_cut_dim=N->cutting_dimension(); - NT new_cut_val=N->cutting_value(); + FT new_cut_val=N->cutting_value(); Node_box* lower_box = new Node_box(*B); Node_box* upper_box = lower_box->split(new_cut_dim, new_cut_val); delete B; if (search_nearest_neighbour) { -NT distance_to_box_lower = +FT distance_to_box_lower = Distance_instance->min_distance_to_rectangle(query_point, *lower_box); -NT distance_to_box_upper = +FT distance_to_box_upper = Distance_instance->min_distance_to_rectangle(query_point, *upper_box); if (distance_to_box_lower <= distance_to_box_upper) { Cell* C_upper = new Cell(upper_box, N->upper()); @@ -451,9 +451,9 @@ else { } } else { // search furthest -NT distance_to_box_lower = +FT distance_to_box_lower = Distance_instance->max_distance_to_rectangle(query_point, *lower_box); -NT distance_to_box_upper = +FT distance_to_box_upper = Distance_instance->max_distance_to_rectangle(query_point, *upper_box); if (distance_to_box_lower >= distance_to_box_upper) { Cell* C_upper = new Cell(upper_box, N->upper()); @@ -479,7 +479,7 @@ else { if (N->size() > 0) { for (Point_iterator it=N->begin(); it != N->end(); it++) { number_of_items_visited++; - NT distance_to_query_point= + FT distance_to_query_point= Distance_instance-> distance(query_point,**it); Point_with_distance *NN_Candidate= diff --git a/Packages/Spatial_searching/include/CGAL/Iso_rectangle_d.h b/Packages/Spatial_searching/include/CGAL/Iso_rectangle_d.h index d4c9b302092..16abfd7c8bb 100644 --- a/Packages/Spatial_searching/include/CGAL/Iso_rectangle_d.h +++ b/Packages/Spatial_searching/include/CGAL/Iso_rectangle_d.h @@ -28,22 +28,22 @@ namespace CGAL { template class Iso_rectangle_d { public: - typedef typename R::FT NT; + typedef typename R::FT FT; typedef typename R::Point_d Point_d; private: int dim; - NT *lower; - NT *upper; + FT *lower; + FT *upper; public: Iso_rectangle_d(const Point_d& p, const Point_d& q) { assert(p.dimension() == q.dimension()); dim = p.dimension(); - lower = new NT[dim]; - upper = new NT[dim]; + lower = new FT[dim]; + upper = new FT[dim]; for (int i = 0; i < dim; ++i) { if (p[i] <= q[i]) { lower[i]=p[i]; @@ -58,8 +58,8 @@ namespace CGAL { // copy constructor Iso_rectangle_d(const Iso_rectangle_d& b) : dim(b.dim) { - lower = new NT[dim]; - upper = new NT[dim]; + lower = new FT[dim]; + upper = new FT[dim]; for (int i = 0; i < dim; ++i) { lower[i]=b.lower[i]; upper[i]=b.upper[i]; @@ -69,7 +69,7 @@ namespace CGAL { bool has_on_bounded_side(const Point_d& p) const { - NT h; + FT h; for (int i = 0; i < dimension(); ++i) { h=p[i]; if ( (h < lower[i]) || (h > upper[i]) ) return 0; @@ -79,11 +79,11 @@ namespace CGAL { inline int dimension() const { return dim;} - inline NT min_coord(int i) const { + inline FT min_coord(int i) const { return lower[i]; } - inline NT max_coord(int i) const { + inline FT max_coord(int i) const { return upper[i]; } diff --git a/Packages/Spatial_searching/include/CGAL/K_neighbor_search.h b/Packages/Spatial_searching/include/CGAL/K_neighbor_search.h index 6816d7e7fa4..fad9ff7768d 100644 --- a/Packages/Spatial_searching/include/CGAL/K_neighbor_search.h +++ b/Packages/Spatial_searching/include/CGAL/K_neighbor_search.h @@ -34,10 +34,10 @@ namespace CGAL { -template , - class Splitter_=Sliding_midpoint , - class Tree_=Kd_tree > +template , + class Splitter_=Sliding_midpoint , + class Tree_=Kd_tree > class K_neighbor_search { @@ -45,14 +45,14 @@ public: typedef Splitter_ Splitter; typedef Distance_ Distance; typedef Tree_ Tree; - typedef typename GeomTraits::Point Point; - typedef typename GeomTraits::NT NT; - typedef std::pair Point_with_distance; + typedef typename SearchTraits::Point_d Point_d; + typedef typename SearchTraits::FT FT; + typedef std::pair Point_with_distance; typedef typename Tree::Node_handle Node_handle; - typedef typename Tree::Point_iterator Point_iterator; - typedef Kd_tree_rectangle Rectangle; + typedef typename Tree::Point_d_iterator Point_d_iterator; + typedef Kd_tree_rectangle Rectangle; typedef typename Distance::Query_item Query_item; private: @@ -62,20 +62,24 @@ private: bool search_nearest; - NT multiplication_factor; + FT multiplication_factor; Query_item query_object; int total_item_number; - NT distance_to_root; + FT distance_to_root; typedef std::list NN_list; +public: + typedef typename NN_list::const_iterator iterator; +private: + NN_list l; int max_k; int actual_k; Distance* distance_instance; - inline bool branch(NT distance) { + inline bool branch(FT distance) { if (actual_k OutputIterator the_k_neighbors(OutputIterator res) { @@ -118,18 +122,28 @@ public: for (; it != l.end(); it++) { *res= *it; res++; } return res; } + */ + iterator begin() const + { + return l.begin(); + } + + iterator end() const + { + return l.end(); + } // constructor K_neighbor_search(Tree& tree, const Query_item& q, - int k=1, NT Eps=NT(0.0), + int k=1, FT Eps=FT(0.0), bool Search_nearest=true, const Distance& d=Distance()) { distance_instance=new Distance(d); multiplication_factor= - distance_instance->transformed_distance(NT(1.0)+Eps); + distance_instance->transformed_distance(FT(1.0)+Eps); max_k=k; actual_k=0; @@ -170,21 +184,21 @@ public: private: - void compute_neighbors_general(Node_handle N, const Kd_tree_rectangle& r) { + void compute_neighbors_general(Node_handle N, const Kd_tree_rectangle& r) { if (!(N->is_leaf())) { number_of_internal_nodes_visited++; int new_cut_dim=N->cutting_dimension(); - NT new_cut_val=N->cutting_value(); + FT new_cut_val=N->cutting_value(); - Kd_tree_rectangle r_lower(r); + Kd_tree_rectangle r_lower(r); // modifies also r_lower to lower half - Kd_tree_rectangle r_upper(r_lower); + Kd_tree_rectangle r_upper(r_lower); r_lower.split(r_upper, new_cut_dim, new_cut_val); - NT distance_to_lower_half; - NT distance_to_upper_half; + FT distance_to_lower_half; + FT distance_to_upper_half; if (search_nearest) { @@ -240,11 +254,11 @@ public: // n is a leaf number_of_leaf_nodes_visited++; if (N->size() > 0) - for (Point_iterator it=N->begin(); it != N->end(); it++) { + for (Point_d_iterator it=N->begin(); it != N->end(); it++) { number_of_items_visited++; - NT distance_to_query_object= + FT distance_to_query_object= distance_instance-> - distance(query_object,**it); + transformed_distance(query_object,**it); insert(*it,distance_to_query_object); } } diff --git a/Packages/Spatial_searching/include/CGAL/Kd_tree.h b/Packages/Spatial_searching/include/CGAL/Kd_tree.h index b7ec42f2d00..d80e0eb0637 100644 --- a/Packages/Spatial_searching/include/CGAL/Kd_tree.h +++ b/Packages/Spatial_searching/include/CGAL/Kd_tree.h @@ -36,21 +36,21 @@ namespace CGAL { - template , class UseExtendedNode = Tag_true > + template , class UseExtendedNode = Tag_true > class Kd_tree { public: typedef Splitter_ Splitter; - typedef typename GeomTraits::Point Point; + typedef typename SearchTraits::Point_d Point_d; typedef typename Splitter::Container Point_container; - typedef typename GeomTraits::NT NT; - typedef Kd_tree_node Node; - typedef Kd_tree Tree; + typedef typename SearchTraits::FT FT; + typedef Kd_tree_node Node; + typedef Kd_tree Tree; typedef typename Compact_container::iterator Node_handle; - typedef typename std::vector::iterator Point_iterator; + typedef typename std::vector::iterator Point_d_iterator; typedef typename Splitter::Separator Separator; private: @@ -60,16 +60,16 @@ private: Node_handle tree_root; - Kd_tree_rectangle* bbox; - std::list pts; + Kd_tree_rectangle* bbox; + std::list pts; // Instead of storing the points in arrays in the Kd_tree_node // we put all the data in a vector in the Kd_tree. // and we only store an iterator range in the Kd_tree_node. // - std::vector data; - Point_iterator data_iterator; - GeomTraits tr; + std::vector data; + Point_d_iterator data_iterator; + SearchTraits tr; int the_item_number; // protected copy constructor @@ -200,16 +200,16 @@ template Splitter s = Splitter()) : split(s) { assert(first != beyond); std::copy(first, beyond, std::back_inserter(pts)); - const Point& p = *pts.begin(); - typename GeomTraits::Construct_cartesian_const_iterator ccci; + const Point_d& p = *pts.begin(); + typename SearchTraits::Construct_cartesian_const_iterator_d ccci; int dim = std::distance(ccci(p), ccci(p,0)); - data = std::vector(pts.size()); // guarantees that iterators we store in Kd_tree_nodes stay valid + data = std::vector(pts.size()); // guarantees that iterators we store in Kd_tree_nodes stay valid data_iterator = data.begin(); Point_container c(dim, pts.begin(), pts.end()); - bbox = new Kd_tree_rectangle(c.bounding_box()); + bbox = new Kd_tree_rectangle(c.bounding_box()); the_item_number=c.size(); if (c.size() <= split.bucket_size()) @@ -223,7 +223,7 @@ template template OutputIterator search(OutputIterator it, const FuzzyQueryItem& q) { - Kd_tree_rectangle b(*bbox); + Kd_tree_rectangle b(*bbox); tree_root->search(it,q,b); return it; } @@ -238,11 +238,11 @@ template }; - GeomTraits traits() const {return tr;} // Returns the traits class; + SearchTraits traits() const {return tr;} // Returns the traits class; Node_handle root()const { return tree_root; } - const Kd_tree_rectangle& bounding_box() const {return *bbox; } + const Kd_tree_rectangle& bounding_box() const {return *bbox; } int size() const {return the_item_number;} diff --git a/Packages/Spatial_searching/include/CGAL/Kd_tree_d_new.h b/Packages/Spatial_searching/include/CGAL/Kd_tree_d_new.h index 3442ce867d9..cc6701ca3c4 100644 --- a/Packages/Spatial_searching/include/CGAL/Kd_tree_d_new.h +++ b/Packages/Spatial_searching/include/CGAL/Kd_tree_d_new.h @@ -80,7 +80,7 @@ namespace CGAL { template > class Kdtree_interface_2d : - public Kd_tree_traits_point { + public Search_traits { public: @@ -122,7 +122,7 @@ namespace CGAL { Kdtree_interface_2d(unsigned int bucket_size=100, NT aspect_ratio=NT(3), bool use_extended_nodes=true) { - Kd_tree_traits_point(bucket_size,aspect_ratio,use_extended_nodes); + Search_traits(bucket_size,aspect_ratio,use_extended_nodes); } @@ -136,7 +136,7 @@ namespace CGAL { template > class Kdtree_interface_3d : - public Kd_tree_traits_point { + public Search_traits { public: @@ -178,7 +178,7 @@ template (bucket_size,aspect_ratio,use_extended_nodes); + Search_traits(bucket_size,aspect_ratio,use_extended_nodes); } @@ -190,7 +190,7 @@ template > class Kdtree_interface : - public Kd_tree_traits_point { + public Search_traits { public: @@ -232,7 +232,7 @@ template (bucket_size,aspect_ratio,use_extended_nodes); + Search_traits(bucket_size,aspect_ratio,use_extended_nodes); } diff --git a/Packages/Spatial_searching/include/CGAL/Kd_tree_node.h b/Packages/Spatial_searching/include/CGAL/Kd_tree_node.h index 1578da7d883..42eb9f93552 100644 --- a/Packages/Spatial_searching/include/CGAL/Kd_tree_node.h +++ b/Packages/Spatial_searching/include/CGAL/Kd_tree_node.h @@ -25,7 +25,7 @@ #include namespace CGAL { - template , class UseExtendedNode = Tag_true > + template , class UseExtendedNode = Tag_true > class Kd_tree; template < class TreeTraits, class Splitter, class UseExtendedNode > @@ -35,11 +35,11 @@ namespace CGAL { typedef typename Kd_tree::Node_handle Node_handle; enum Node_type {LEAF, INTERNAL, EXTENDED_INTERNAL}; - typedef typename TreeTraits::Point Point; + typedef typename TreeTraits::Point_d Point_d; - typedef typename TreeTraits::NT NT; + typedef typename TreeTraits::FT FT; typedef typename Kd_tree::Separator Separator; - typedef typename Kd_tree::Point_iterator Point_iterator; + typedef typename Kd_tree::Point_d_iterator Point_d_iterator; private: @@ -48,7 +48,7 @@ namespace CGAL { // private variables for leaf nodes unsigned int n; // denotes number of items in a leaf node - Point_iterator data; // iterator to data in leaf node + Point_d_iterator data; // iterator to data in leaf node // private variables for internal nodes @@ -57,8 +57,8 @@ namespace CGAL { Separator sep; // private variables for extended internal nodes - NT low_val; - NT high_val; + FT low_val; + FT high_val; public: @@ -74,8 +74,8 @@ namespace CGAL { // members for leaf nodes only inline unsigned int size() const { return n;} - inline Point_iterator begin() const {return data;} - inline Point_iterator end() const {return data + n;} + inline Point_d_iterator begin() const {return data;} + inline Point_d_iterator end() const {return data + n;} // members for internal node and extended internal node @@ -85,15 +85,15 @@ namespace CGAL { // inline Separator& separator() {return sep; } // use instead - inline NT cutting_value() const + inline FT cutting_value() const {return sep.cutting_value();} inline int cutting_dimension() const {return sep.cutting_dimension();} // members for extended internal node only - inline NT low_value() const { return low_val; } - inline NT high_value() const { return high_val; } + inline FT low_value() const { return low_val; } + inline FT high_value() const { return high_val; } Separator& separator() { @@ -121,7 +121,7 @@ namespace CGAL { if (is_leaf()) { if (n>0) - for (Point_iterator i=begin(); i != end(); i++) + for (Point_d_iterator i=begin(); i != end(); i++) {*it=**i; ++it;} } else { @@ -136,7 +136,7 @@ namespace CGAL { Kd_tree_rectangle& b) { if (is_leaf()) { if (n>0) - for (Point_iterator i=begin(); i != end(); i++) + for (Point_d_iterator i=begin(); i != end(); i++) if (q.contains(**i)) {*it=**i; ++it;} } diff --git a/Packages/Spatial_searching/include/CGAL/Kd_tree_rectangle.h b/Packages/Spatial_searching/include/CGAL/Kd_tree_rectangle.h index 1478143f0f7..c8b2f77d46b 100644 --- a/Packages/Spatial_searching/include/CGAL/Kd_tree_rectangle.h +++ b/Packages/Spatial_searching/include/CGAL/Kd_tree_rectangle.h @@ -30,16 +30,16 @@ namespace CGAL { - template - struct set_bounds : public std::unary_function { + template + struct set_bounds : public std::unary_function { int dim; T *lower; T *upper; set_bounds(int d, T *l, T *u) : dim(d), lower(l), upper(u) {} - void operator() (Point& p) { + void operator() (Point_d& p) { T h; - typename GeomTraits::Construct_cartesian_const_iterator construct_it; - typename GeomTraits::Cartesian_const_iterator pit = construct_it(p); + typename SearchTraits::Construct_cartesian_const_iterator_d construct_it; + typename SearchTraits::Cartesian_const_iterator_d pit = construct_it(p); for (int i = 0; i < dim; ++i, ++pit) { h=(*pit); if (h < lower[i]) lower[i] = h; @@ -48,7 +48,7 @@ namespace CGAL { } }; - template + template struct set_bounds_from_pointer : public std::unary_function { int dim; T *lower; @@ -57,8 +57,8 @@ namespace CGAL { dim(d), lower(l), upper(u) {} void operator() (P p) { T h; - typename GeomTraits::Construct_cartesian_const_iterator construct_it; - typename GeomTraits::Cartesian_const_iterator pit = construct_it(*p); + typename SearchTraits::Construct_cartesian_const_iterator_d construct_it; + typename SearchTraits::Cartesian_const_iterator_d pit = construct_it(*p); for (int i = 0; i < dim; ++i, ++pit) { h=(*pit); if (h < lower[i]) lower[i] = h; @@ -68,10 +68,10 @@ namespace CGAL { }; - template class Kd_tree_rectangle { + template class Kd_tree_rectangle { public: - typedef typename GeomTraits::NT NT; - typedef NT T; + typedef typename SearchTraits::FT FT; + typedef FT T; private: @@ -82,14 +82,14 @@ namespace CGAL { public: - inline void set_upper_bound(int i, const NT& x) { + inline void set_upper_bound(int i, const FT& x) { assert(i >= 0 && i < dim); assert(x >= lower_[i]); upper_[i] = x; set_max_span(); } - inline void set_lower_bound(int i, const NT& x) { + inline void set_lower_bound(int i, const FT& x) { assert(i >= 0 && i < dim); assert(x <= upper_[i]); lower_[i] = x; @@ -97,10 +97,10 @@ namespace CGAL { } inline void set_max_span() { - NT span = upper_[0]-lower_[0]; + FT span = upper_[0]-lower_[0]; max_span_coord_ = 0; for (int i = 1; i < dim; ++i) { - NT tmp = upper_[i] - lower_[i]; + FT tmp = upper_[i] - lower_[i]; if (span < tmp) { span = tmp; max_span_coord_ = i; @@ -109,7 +109,7 @@ namespace CGAL { } Kd_tree_rectangle(int d) : - dim(d), lower_(new NT[d]), upper_(new NT[d]) + dim(d), lower_(new FT[d]), upper_(new FT[d]) { std::fill(lower_, lower_ + dim, 0); std::fill(upper_, upper_ + dim, 0); @@ -119,8 +119,8 @@ namespace CGAL { Kd_tree_rectangle() : dim(0), lower_(0), upper_(0) {} - explicit Kd_tree_rectangle(const Kd_tree_rectangle& r) : dim(r.dim), - lower_(new NT[dim]), upper_(new NT[dim]) { + explicit Kd_tree_rectangle(const Kd_tree_rectangle& r) : dim(r.dim), + lower_(new FT[dim]), upper_(new FT[dim]) { std::copy(r.lower_, r.lower_+dim, lower_); std::copy(r.upper_, r.upper_+dim, upper_); set_max_span(); @@ -128,12 +128,12 @@ namespace CGAL { template Kd_tree_rectangle(int d, PointIter begin, PointIter end) - : dim(d), lower_(new NT[d]), upper_(new NT[d]) + : dim(d), lower_(new FT[d]), upper_(new FT[d]) { // initialize with values of first point - typename GeomTraits::Construct_cartesian_const_iterator construct_it; - typename GeomTraits::Cartesian_const_iterator bit = construct_it(*begin); - // typename GeomTraits::Cartesian_const_iterator be = construct_it(*begin,1); + typename SearchTraits::Construct_cartesian_const_iterator_d construct_it; + typename SearchTraits::Cartesian_const_iterator_d bit = construct_it(*begin); + // typename SearchTraits::Cartesian_const_iterator_d be = construct_it(*begin,1); for (int i=0; i < dim; ++bit, ++i) { @@ -141,7 +141,7 @@ namespace CGAL { } begin++; typedef typename std::iterator_traits::value_type P; - std::for_each(begin, end, set_bounds(dim, lower_, upper_)); + std::for_each(begin, end, set_bounds(dim, lower_, upper_)); set_max_span(); } @@ -151,12 +151,12 @@ namespace CGAL { if (empty) { // no points for (int i=0; i < dim; ++i) { - lower_[i]= NT(1); upper_[i]= NT(-1); + lower_[i]= FT(1); upper_[i]= FT(-1); } } else { // initialize with values of first point - typename GeomTraits::Construct_cartesian_const_iterator construct_it; - typename GeomTraits::Cartesian_const_iterator bit = construct_it(**begin); + typename SearchTraits::Construct_cartesian_const_iterator_d construct_it; + typename SearchTraits::Cartesian_const_iterator_d bit = construct_it(**begin); for (int i=0; i < dim; ++i, ++bit) { lower_[i]= *bit; upper_[i]=lower_[i]; @@ -165,22 +165,22 @@ namespace CGAL { typedef typename std::iterator_traits::value_type P; std::for_each(begin, end, - set_bounds_from_pointer(dim, lower_, upper_)); + set_bounds_from_pointer(dim, lower_, upper_)); } set_max_span(); } inline int max_span_coord() const { return max_span_coord_; } - inline NT max_span() const { + inline FT max_span() const { return upper_[max_span_coord_] - lower_[max_span_coord_]; } - inline NT min_coord(int i) const { + inline FT min_coord(int i) const { return lower_[i]; } - inline NT max_coord(int i) const { + inline FT max_coord(int i) const { return upper_[i]; } @@ -190,12 +190,12 @@ namespace CGAL { for (int i=0; i < dim; ++i) s << lower_[i] << " "; // std::copy(lower_, lower_ + dim, - // std::ostream_iterator(s," ")); + // std::ostream_iterator(s," ")); s << "\n upper: "; for (int j=0; j < dim; ++j) s << upper_[j] << " "; // std::copy(upper_, upper_ + dim, - // std::ostream_iterator(s," ")); + // std::ostream_iterator(s," ")); s << "\n maximum span " << max_span() << " at coordinate " << max_span_coord() << std::endl; return s; @@ -205,7 +205,7 @@ namespace CGAL { // and returns upper half // Kd_tree_rectangle* void -split(Kd_tree_rectangle& r, int d, NT value) { +split(Kd_tree_rectangle& r, int d, FT value) { // assert(d >= 0 && d < dim); // assert(lower_[d] <= value && value <= upper_[d]); @@ -226,7 +226,7 @@ split(Kd_tree_rectangle& r, int d, NT value) { int dimension() const {return dim;} - Kd_tree_rectangle& operator= (const Kd_tree_rectangle& r) { + Kd_tree_rectangle& operator= (const Kd_tree_rectangle& r) { if (this != &r) { std::copy(r.lower_, r.lower_+dim, lower_); @@ -240,8 +240,8 @@ split(Kd_tree_rectangle& r, int d, NT value) { }; // of class Kd_tree_rectangle - template - std::ostream& operator<< (std::ostream& s, Kd_tree_rectangle& r) { + template + std::ostream& operator<< (std::ostream& s, Kd_tree_rectangle& r) { return r.print(s); } diff --git a/Packages/Spatial_searching/include/CGAL/Manhattan_distance_iso_box_point.h b/Packages/Spatial_searching/include/CGAL/Manhattan_distance_iso_box_point.h index 738e21e66b2..b2a403c3092 100644 --- a/Packages/Spatial_searching/include/CGAL/Manhattan_distance_iso_box_point.h +++ b/Packages/Spatial_searching/include/CGAL/Manhattan_distance_iso_box_point.h @@ -29,13 +29,13 @@ namespace CGAL { - template + template class Manhattan_distance_iso_box_point { public: - typedef typename GeomTraits::Point Point; - typedef typename GeomTraits::NT NT; + typedef typename SearchTraits::Point_d Point_d; + typedef typename SearchTraits::FT FT; typedef QueryItem Query_item; @@ -49,10 +49,10 @@ namespace CGAL { ~Manhattan_distance_iso_box_point() {} - inline NT distance(const QueryItem& q, const Point& p) { - NT distance = NT(0); - typename GeomTraits::Construct_cartesian_const_iterator construct_it; - typename GeomTraits::Cartesian_const_iterator qmaxit = construct_it(q.max()), + inline FT transformed_distance(const QueryItem& q, const Point_d& p) { + FT distance = FT(0); + typename SearchTraits::Construct_cartesian_const_iterator_d construct_it; + typename SearchTraits::Cartesian_const_iterator_d qmaxit = construct_it(q.max()), qe = construct_it(q.max(),1), qminit = construct_it(q.min()), pit = construct_it(p); for (; qmaxit != qe; ++qmaxit) { @@ -65,11 +65,11 @@ namespace CGAL { } - inline NT min_distance_to_rectangle(const QueryItem& q, - const Kd_tree_rectangle& r) { - NT distance = NT(0); - typename GeomTraits::Construct_cartesian_const_iterator construct_it; - typename GeomTraits::Cartesian_const_iterator qmaxit = construct_it(q.max()), + inline FT min_distance_to_rectangle(const QueryItem& q, + const Kd_tree_rectangle& r) { + FT distance = FT(0); + typename SearchTraits::Construct_cartesian_const_iterator_d construct_it; + typename SearchTraits::Cartesian_const_iterator_d qmaxit = construct_it(q.max()), qe = construct_it(q.max(),1), qminit = construct_it(q.min()); for (unsigned int i = 0; qmaxit != qe; ++ qmaxit, ++i) { if (r.min_coord(i)>(*qmaxit)) @@ -81,12 +81,12 @@ namespace CGAL { } inline - NT + FT max_distance_to_rectangle(const QueryItem& q, - const Kd_tree_rectangle& r) { - NT distance=NT(0); - typename GeomTraits::Construct_cartesian_const_iterator construct_it; - typename GeomTraits::Cartesian_const_iterator qmaxit = construct_it(q.max()), + const Kd_tree_rectangle& r) { + FT distance=FT(0); + typename SearchTraits::Construct_cartesian_const_iterator_d construct_it; + typename SearchTraits::Cartesian_const_iterator_d qmaxit = construct_it(q.max()), qe = construct_it(q.max(),1), qminit = construct_it(q.min()); for (unsigned int i = 0; qmaxit != qe; ++ qmaxit, ++i) { if ( r.max_coord(i)-(*qminit) >(*qmaxit)-r.min_coord(i) ) @@ -98,15 +98,15 @@ namespace CGAL { } inline - NT - transformed_distance(NT d) + FT + transformed_distance(FT d) { return d; } inline - NT - inverse_of_transformed_distance(NT d) + FT + inverse_of_transformed_distance(FT d) { return d; } diff --git a/Packages/Spatial_searching/include/CGAL/Orthogonal_incremental_neighbor_search.h b/Packages/Spatial_searching/include/CGAL/Orthogonal_incremental_neighbor_search.h index 323bd19b11c..07574aeb63e 100644 --- a/Packages/Spatial_searching/include/CGAL/Orthogonal_incremental_neighbor_search.h +++ b/Packages/Spatial_searching/include/CGAL/Orthogonal_incremental_neighbor_search.h @@ -27,34 +27,30 @@ #include #include #include -#include +#include #include namespace CGAL { - - - - -template , - class Splitter_ = Sliding_midpoint, - class Tree_=Kd_tree > +template , + class Splitter_ = Sliding_midpoint, + class Tree_=Kd_tree > class Orthogonal_incremental_neighbor_search { public: typedef Splitter_ Splitter; typedef Tree_ Tree; typedef Distance_ Distance; - typedef typename GeomTraits::Point Point; - typedef Point Query_item; - typedef typename GeomTraits::NT NT; - typedef typename Tree::Point_iterator Point_iterator; + typedef typename SearchTraits::Point_d Point_d; + typedef Point_d Query_item; + typedef typename SearchTraits::FT FT; + typedef typename Tree::Point_d_iterator Point_d_iterator; typedef typename Tree::Node_handle Node_handle; - typedef std::pair Point_with_distance; - typedef std::pair Node_with_distance; + typedef std::pair Point_with_distance; + typedef std::pair Node_with_distance; typedef std::vector Node_with_distance_vector; typedef std::vector Point_with_distance_vector; @@ -72,17 +68,17 @@ class Iterator_implementation { private: - NT multiplication_factor; + FT multiplication_factor; - Point* query_point; + Point_d* query_point; int total_item_number; - NT distance_to_root; + FT distance_to_root; bool search_nearest_neighbour; - NT rd; + FT rd; class Priority_higher { @@ -140,7 +136,7 @@ class Iterator_implementation { // constructor Iterator_implementation(Tree& tree, Query_item& q, const Distance& tr, - NT Eps=NT(0.0), bool search_nearest=true) + FT Eps=FT(0.0), bool search_nearest=true) { PriorityQueue= new std::priority_queuetransformed_distance(NT(1.0)+Eps); + Orthogonal_distance_instance->transformed_distance(FT(1.0)+Eps); // if (search_nearest) distance_to_root= @@ -263,26 +259,26 @@ class Iterator_implementation { next_neighbour_found= (rd < multiplication_factor*Item_PriorityQueue->top()->second); } - typename GeomTraits::Construct_cartesian_const_iterator construct_it; - typename GeomTraits::Cartesian_const_iterator query_point_it = construct_it(*query_point); + typename SearchTraits::Construct_cartesian_const_iterator_d construct_it; + typename SearchTraits::Cartesian_const_iterator_d query_point_it = construct_it(*query_point); // otherwise browse the tree further while ((!next_neighbour_found) && (!PriorityQueue->empty())) { Node_with_distance* The_node_top=PriorityQueue->top(); Node_handle N= The_node_top->first; PriorityQueue->pop(); delete The_node_top; - NT copy_rd=rd; + FT copy_rd=rd; while (!(N->is_leaf())) { // compute new distance number_of_internal_nodes_visited++; int new_cut_dim=N->cutting_dimension(); - NT old_off, new_rd; - NT new_off = + FT old_off, new_rd; + FT new_off = *(query_point_it + new_cut_dim) - N->cutting_value(); - if (new_off < NT(0.0)) { + if (new_off < FT(0.0)) { old_off= *(query_point_it + new_cut_dim)-N->low_value(); - if (old_off>NT(0.0)) old_off=NT(0.0); + if (old_off>FT(0.0)) old_off=FT(0.0); new_rd= Orthogonal_distance_instance-> new_distance(copy_rd,old_off,new_off,new_cut_dim); @@ -305,7 +301,7 @@ class Iterator_implementation { else { // compute new distance old_off= N->high_value() - *(query_point_it+new_cut_dim); - if (old_off>NT(0.0)) old_off=NT(0.0); + if (old_off>FT(0.0)) old_off=FT(0.0); new_rd=Orthogonal_distance_instance-> new_distance(copy_rd,old_off,new_off,new_cut_dim); assert(new_rd >= copy_rd); @@ -327,11 +323,11 @@ class Iterator_implementation { // n is a leaf number_of_leaf_nodes_visited++; if (N->size() > 0) { - for (Point_iterator it=N->begin(); it != N->end(); it++) { + for (Point_d_iterator it=N->begin(); it != N->end(); it++) { number_of_items_visited++; - NT distance_to_query_point= + FT distance_to_query_point= Orthogonal_distance_instance-> - distance(*query_point,**it); + transformed_distance(*query_point,**it); Point_with_distance *NN_Candidate= new Point_with_distance(**it,distance_to_query_point); Item_PriorityQueue->push(NN_Candidate); @@ -373,13 +369,13 @@ class iterator; typedef std::vector Point_with_distance_vector; - typedef std::vector Distance_vector; + typedef std::vector Distance_vector; public: // constructor Orthogonal_incremental_neighbor_search(Tree& tree, - Query_item& q, NT Eps = NT(0.0), + Query_item& q, FT Eps = FT(0.0), bool search_nearest=true, const Distance& tr=Distance()) : start(tree,q,tr,Eps,search_nearest), past_the_end() @@ -428,7 +424,7 @@ class iterator; } // constructor - iterator(Tree& tree, Query_item& q, const Distance& tr=Distance(), NT eps=NT(0.0), + iterator(Tree& tree, Query_item& q, const Distance& tr=Distance(), FT eps=FT(0.0), bool search_nearest=true){ Ptr_implementation = new Iterator_implementation(tree, q, tr, eps, search_nearest); diff --git a/Packages/Spatial_searching/include/CGAL/Orthogonal_k_neighbor_search.h b/Packages/Spatial_searching/include/CGAL/Orthogonal_k_neighbor_search.h index 6605ab835ef..02792655405 100644 --- a/Packages/Spatial_searching/include/CGAL/Orthogonal_k_neighbor_search.h +++ b/Packages/Spatial_searching/include/CGAL/Orthogonal_k_neighbor_search.h @@ -34,10 +34,10 @@ namespace CGAL { -template , - class Splitter_=Sliding_midpoint , - class Tree_=Kd_tree > +template , + class Splitter_=Sliding_midpoint , + class Tree_=Kd_tree > class Orthogonal_k_neighbor_search { public: @@ -45,14 +45,14 @@ public: typedef Splitter_ Splitter; typedef Tree_ Tree; typedef Distance_ Distance; - typedef typename GeomTraits::Point Point; - typedef typename GeomTraits::Point Query_item; - typedef typename GeomTraits::NT NT; - typedef std::pair Point_with_distance; + typedef typename SearchTraits::Point_d Point_d; + typedef typename SearchTraits::Point_d Query_item; + typedef typename SearchTraits::FT FT; + typedef std::pair Point_with_distance; typedef typename Tree::Node_handle Node_handle; - typedef typename Tree::Point_iterator Point_iterator; + typedef typename Tree::Point_d_iterator Point_d_iterator; private: @@ -62,13 +62,17 @@ int number_of_items_visited; bool search_nearest; -NT multiplication_factor; +FT multiplication_factor; Query_item query_object; int total_item_number; -NT distance_to_root; +FT distance_to_root; typedef std::list NN_list; +public: + typedef typename NN_list::const_iterator iterator; +private: + NN_list l; int max_k; int actual_k; @@ -76,7 +80,7 @@ int actual_k; Distance* distance_instance; - inline bool branch(NT distance) { + inline bool branch(FT distance) { if (actual_ksecond * multiplication_factor); }; - inline void insert(Point* I, NT dist) { + inline void insert(Point_d* I, FT dist) { bool insert; if (actual_k OutputIterator the_k_neighbors(OutputIterator res) { @@ -119,11 +123,21 @@ Distance* distance_instance; for (; it != l.end(); it++) { *res= *it; res++; } return res; } + */ + iterator begin() const + { + return l.begin(); + } + + iterator end() const + { + return l.end(); + } // constructor Orthogonal_k_neighbor_search(Tree& tree, const Query_item& q, - int k=1, NT Eps=NT(0.0), bool Search_nearest=true, const Distance& d=Distance()) { + int k=1, FT Eps=FT(0.0), bool Search_nearest=true, const Distance& d=Distance()) { distance_instance=new Distance(d); @@ -175,30 +189,30 @@ Distance* distance_instance; private: - void compute_neighbors_orthogonally(Node_handle N, NT rd) { + void compute_neighbors_orthogonally(Node_handle N, FT rd) { - typename GeomTraits::Construct_cartesian_const_iterator construct_it; - typename GeomTraits::Cartesian_const_iterator query_object_it = construct_it(query_object); + typename SearchTraits::Construct_cartesian_const_iterator_d construct_it; + typename SearchTraits::Cartesian_const_iterator_d query_object_it = construct_it(query_object); if (!(N->is_leaf())) { number_of_internal_nodes_visited++; int new_cut_dim=N->cutting_dimension(); - NT old_off, new_rd; - NT new_off = + FT old_off, new_rd; + FT new_off = *(query_object_it + new_cut_dim) - N->cutting_value(); - if ( ((new_off < NT(0.0)) && (search_nearest)) || - (( new_off >= NT(0.0)) && (!search_nearest)) ) { + if ( ((new_off < FT(0.0)) && (search_nearest)) || + (( new_off >= FT(0.0)) && (!search_nearest)) ) { compute_neighbors_orthogonally(N->lower(),rd); if (search_nearest) { old_off= *(query_object_it + new_cut_dim)- N->low_value(); - if (old_off>NT(0.0)) old_off=NT(0.0); + if (old_off>FT(0.0)) old_off=FT(0.0); } else { old_off= *(query_object_it + new_cut_dim) - N->high_value(); - if (old_off @@ -212,13 +226,13 @@ Distance* distance_instance; if (search_nearest) { old_off= N->high_value() - *(query_object_it + new_cut_dim); - if (old_off>NT(0.0)) old_off=NT(0.0); + if (old_off>FT(0.0)) old_off=FT(0.0); } else { old_off= N->low_value() - *(query_object_it + new_cut_dim); - if (old_off @@ -233,11 +247,11 @@ Distance* distance_instance; // n is a leaf number_of_leaf_nodes_visited++; if (N->size() > 0) - for (Point_iterator it=N->begin(); it != N->end(); it++) { + for (Point_d_iterator it=N->begin(); it != N->end(); it++) { number_of_items_visited++; - NT distance_to_query_object= + FT distance_to_query_object= distance_instance-> - distance(query_object,**it); + transformed_distance(query_object,**it); insert(*it,distance_to_query_object); } } diff --git a/Packages/Spatial_searching/include/CGAL/Plane_separator.h b/Packages/Spatial_searching/include/CGAL/Plane_separator.h index a353a0bb81f..59fdfddb9bf 100644 --- a/Packages/Spatial_searching/include/CGAL/Plane_separator.h +++ b/Packages/Spatial_searching/include/CGAL/Plane_separator.h @@ -23,21 +23,21 @@ #ifndef CGAL_PLANE_SEPARATOR_H #define CGAL_PLANE_SEPARATOR_H namespace CGAL { -template < class NT> class Plane_separator { +template < class FT> class Plane_separator { public: int cutting_dim; - NT cutting_val; + FT cutting_val; inline int cutting_dimension() const { return cutting_dim;} - inline NT cutting_value() const { return cutting_val;} + inline FT cutting_value() const { return cutting_val;} void set_cutting_dimension(int d) { cutting_dim=d; } - void set_cutting_value(NT val) { + void set_cutting_value(FT val) { cutting_val=val; } @@ -46,13 +46,13 @@ template < class NT> class Plane_separator { return i[cutting_dimension()] < cutting_value(); } - Plane_separator(const int d, const NT& v) : + Plane_separator(const int d, const FT& v) : cutting_dim(d), cutting_val(v) {} - Plane_separator(const Plane_separator& s) : + Plane_separator(const Plane_separator& s) : cutting_dim(s.cutting_dimension()), cutting_val(s.cutting_value()) {} explicit Plane_separator() : cutting_dim(0), cutting_val(0) {} - Plane_separator& operator= (const Plane_separator& s) { + Plane_separator& operator= (const Plane_separator& s) { cutting_dim = s.cutting_dimension(); cutting_val = s.cutting_value(); return *this; @@ -62,8 +62,8 @@ template < class NT> class Plane_separator { }; - template < class NT> - std::ostream& operator<< (std::ostream& s, Plane_separator& x) { + template < class FT> + std::ostream& operator<< (std::ostream& s, Plane_separator& x) { s << "\n Separator coordinate: " << x.cutting_dimension() << " value: " << x.cutting_value() << "\n"; return s; diff --git a/Packages/Spatial_searching/include/CGAL/Point_container.h b/Packages/Spatial_searching/include/CGAL/Point_container.h index 8bbf31bcc55..b7284cdab23 100644 --- a/Packages/Spatial_searching/include/CGAL/Point_container.h +++ b/Packages/Spatial_searching/include/CGAL/Point_container.h @@ -32,32 +32,32 @@ #include namespace CGAL { - template class Point_container { + template class Point_container { private: - typedef typename GeomTraits::Point Point; - typedef std::vector Point_vector; - typedef Point_container Self; + typedef typename SearchTraits::Point_d Point_d; + typedef std::vector Point_vector; + typedef Point_container Self; public: - typedef typename GeomTraits::NT NT; - typedef std::list Point_list; + typedef typename SearchTraits::FT FT; + typedef std::list Point_list; typedef Point_list::iterator iterator; private: Point_list p_list; // list of pointers to points int built_coord; // a coordinate for which the pointer list is built unsigned int the_size; - Kd_tree_rectangle bbox; // bounding box, i.e. rectangle of node - Kd_tree_rectangle tbox; // tight bounding box, + Kd_tree_rectangle bbox; // bounding box, i.e. rectangle of node + Kd_tree_rectangle tbox; // tight bounding box, // i.e. minimal enclosing bounding // box of points public: - inline const Kd_tree_rectangle& bounding_box() const { return bbox; } + inline const Kd_tree_rectangle& bounding_box() const { return bbox; } - inline const Kd_tree_rectangle& tight_bounding_box() const + inline const Kd_tree_rectangle& tight_bounding_box() const { return tbox; } inline int dimension() const { return bbox.dimension(); } @@ -70,35 +70,35 @@ namespace CGAL { // coordinate of the maximal tight span inline int max_tight_span_coord() const { return tbox.max_span_coord(); } - inline NT max_span_lower() const + inline FT max_span_lower() const { return bbox.min_coord(max_span_coord());} - inline NT max_tight_span_lower() const { + inline FT max_tight_span_lower() const { return tbox.min_coord(max_tight_span_coord());} - inline NT max_span_upper() const + inline FT max_span_upper() const { return bbox.max_coord(max_span_coord());} - inline NT max_tight_span_upper() const { + inline FT max_tight_span_upper() const { return tbox.max_coord(max_tight_span_coord());} - inline NT max_spread() const + inline FT max_spread() const { return max_span_upper() - max_span_lower(); } - inline NT max_tight_spread() const { + inline FT max_tight_spread() const { return max_tight_span_upper() - max_tight_span_lower(); } - int max_tight_span_coord_balanced(NT Aspect_ratio) const { + int max_tight_span_coord_balanced(FT Aspect_ratio) const { int cut_dim(-1); - NT max_spread_points(NT(-1)); - NT max_length=max_spread(); // length of longest side of box + FT max_spread_points(FT(-1)); + FT max_length=max_spread(); // length of longest side of box int dim=dimension(); for (int d=0; d max_spread_points) { max_spread_points = spread; @@ -110,41 +110,41 @@ namespace CGAL { return cut_dim; } - NT max_span_upper_without_dim(int d) const { - NT max_span(NT(0)); + FT max_span_upper_without_dim(int d) const { + FT max_span(FT(0)); int dim=dimension(); for (int i=0; i max_span) max_span=span; } return max_span; } - NT balanced_fair(int d, NT Aspect_ratio) { - NT small_piece = + FT balanced_fair(int d, FT Aspect_ratio) { + FT small_piece = max_span_upper_without_dim(d) / Aspect_ratio; - NT low_cut = + FT low_cut = bbox.min_coord(d) + small_piece; // lowest legal cut; - NT high_cut = + FT high_cut = bbox.max_coord(d) - small_piece; //highest legal cut; // assert (high_cut >= low_cut); - NT split_value = median(d); + FT split_value = median(d); if (split_value < low_cut) split_value=low_cut; if (split_value > high_cut) split_value=high_cut; return split_value; } - NT balanced_sliding_fair(int d, NT Aspect_ratio) { - NT small_piece = + FT balanced_sliding_fair(int d, FT Aspect_ratio) { + FT small_piece = max_span_upper_without_dim(d) / Aspect_ratio; - NT low_cut = + FT low_cut = bbox.min_coord(d) + small_piece; // lowest legal cut; - NT high_cut = + FT high_cut = bbox.max_coord(d) - small_piece; //highest legal cut; // assert (high_cut >= low_cut); - NT split_value = median(d); - NT max_span_lower = tbox.min_coord(d); - NT max_span_upper = tbox.max_coord(d); + FT split_value = median(d); + FT max_span_lower = tbox.min_coord(d); + FT max_span_upper = tbox.max_coord(d); if (split_value < low_cut) split_value= max_span_lower; if (split_value > high_cut) split_value = max_span_upper; return split_value; @@ -172,7 +172,7 @@ namespace CGAL { - bbox = Kd_tree_rectangle(d, begin, end); + bbox = Kd_tree_rectangle(d, begin, end); tbox = bbox; // build list @@ -187,7 +187,7 @@ namespace CGAL { Point_container(const int d) : the_size(0), bbox(d), tbox(d) {} - void swap(Point_container& c) { + void swap(Point_container& c) { swap(p_list,c.p_list); @@ -203,12 +203,12 @@ namespace CGAL { c.built_coord = h; // work-around - Kd_tree_rectangle h_bbox(bbox); + Kd_tree_rectangle h_bbox(bbox); bbox = c.bbox; c.bbox = h_bbox; // work-around - Kd_tree_rectangle h_tbox(tbox); + Kd_tree_rectangle h_tbox(tbox); tbox = c.tbox; c.tbox = h_tbox; @@ -229,7 +229,7 @@ namespace CGAL { // note that splitting is restricted to the built coordinate template - void split(Point_container& c, Separator& sep, + void split(Point_container& c, Separator& sep, bool sliding=false) { assert(dimension()==c.dimension()); @@ -240,7 +240,7 @@ namespace CGAL { // bool test_validity=false; const int split_coord = sep.cutting_dimension(); - const NT cutting_value = sep.cutting_value(); + const FT cutting_value = sep.cutting_value(); built_coord=split_coord; c.built_coord=split_coord; @@ -248,8 +248,8 @@ namespace CGAL { iterator pt=p_list.begin(); - typename GeomTraits::Construct_cartesian_const_iterator construct_it; - typename GeomTraits::Cartesian_const_iterator ptit; + typename SearchTraits::Construct_cartesian_const_iterator_d construct_it; + typename SearchTraits::Cartesian_const_iterator_d ptit; for (; (pt != p_list.end()); ++pt) { @@ -263,7 +263,7 @@ namespace CGAL { if (sliding) { // avoid empty lists if (l_lower.empty()) { iterator pt_min=l_upper.begin(); - NT min_value=bbox.max_coord(built_coord); + FT min_value=bbox.max_coord(built_coord); for (pt=l_upper.begin(); (pt != l_upper.end()); ++pt) { ptit = construct_it((*(*pt))); if ( *(ptit+split_coord) < min_value) { @@ -275,7 +275,7 @@ namespace CGAL { } if (l_upper.empty()) { iterator pt_max=l_lower.begin(); - NT max_value=bbox.min_coord(built_coord); + FT max_value=bbox.min_coord(built_coord); for (pt=l_lower.begin(); (pt != l_lower.end()); ++pt) { ptit = construct_it((*(*pt))); if ( *(ptit+split_coord) > max_value) { @@ -311,51 +311,51 @@ namespace CGAL { - template + template struct comp_coord_val { private: Value coord; - typedef typename GeomTraits2::Point Point; + typedef typename SearchTraits2::Point_d Point_d; public: comp_coord_val (const Value& coordinate) : coord(coordinate) {} - bool operator() (const Point *a, const Point *b) { - typename GeomTraits2::Construct_cartesian_const_iterator construct_it; - typename GeomTraits2::Cartesian_const_iterator ait = construct_it(*a), + bool operator() (const Point_d *a, const Point_d *b) { + typename SearchTraits2::Construct_cartesian_const_iterator_d construct_it; + typename SearchTraits2::Cartesian_const_iterator_d ait = construct_it(*a), bit = construct_it(*b); return *(ait+coord) < *(bit+coord); } }; - NT median(const int split_coord) { + FT median(const int split_coord) { #ifdef CGAL_CFG_RWSTD_NO_MEMBER_TEMPLATES Point_vector p_vector; std::copy(p_list.begin(), p_list.end(), std::back_inserter(p_vector)); - std::sort(p_vector.begin(),p_vector.end(),comp_coord_val(split_coord)); + std::sort(p_vector.begin(),p_vector.end(),comp_coord_val(split_coord)); p_list.clear(); std::copy(p_vector.begin(), p_vector.end(), std::back_inserter(p_list)); #else - p_list.sort(comp_coord_val(split_coord)); + p_list.sort(comp_coord_val(split_coord)); #endif iterator median_point_ptr = p_list.begin(); for (unsigned int i = 0; i < the_size/2-1; i++, median_point_ptr++) {} - typename GeomTraits::Construct_cartesian_const_iterator construct_it; - typename GeomTraits::Cartesian_const_iterator mpit = construct_it((*(*median_point_ptr))); - NT val1= *(mpit+split_coord); + typename SearchTraits::Construct_cartesian_const_iterator_d construct_it; + typename SearchTraits::Cartesian_const_iterator_d mpit = construct_it((*(*median_point_ptr))); + FT val1= *(mpit+split_coord); median_point_ptr++; mpit = construct_it((*(*median_point_ptr))); - NT val2= *(mpit+split_coord); + FT val2= *(mpit+split_coord); - return (val1+val2)/NT(2); + return (val1+val2)/FT(2); }; diff --git a/Packages/Spatial_searching/include/CGAL/Kd_tree_traits_point.h b/Packages/Spatial_searching/include/CGAL/Search_traits.h old mode 100755 new mode 100644 similarity index 76% rename from Packages/Spatial_searching/include/CGAL/Kd_tree_traits_point.h rename to Packages/Spatial_searching/include/CGAL/Search_traits.h index a2a7a739f57..7bc011bc377 --- a/Packages/Spatial_searching/include/CGAL/Kd_tree_traits_point.h +++ b/Packages/Spatial_searching/include/CGAL/Search_traits.h @@ -11,7 +11,7 @@ // release : // release_date : // -// file : include/CGAL/Kd_tree_traits_point.h +// file : include/CGAL/Search_traits.h // package : ASPAS // revision : 3.0 // revision_date : 2003/07/10 @@ -28,17 +28,17 @@ namespace CGAL { - template - class Kd_tree_traits_point { + template + class Search_traits { public: - typedef CartesianCoordinateIterator Cartesian_const_iterator; - typedef ConstructCartesianCoordinateIterator Construct_cartesian_const_iterator; - typedef Point_ Point; - typedef NT_ NT; + typedef CartesianCoordinateIterator Cartesian_const_iterator_d; + typedef ConstructCartesianCoordinateIterator Construct_cartesian_const_iterator_d; + typedef Point Point_d; + typedef FT_ FT; }; } // namespace CGAL -#endif // KD_TREE_TRAITS_POINT_H +#endif // KD_TREE_TRAITS_POINT_H diff --git a/Packages/Spatial_searching/include/CGAL/Kd_tree_traits_point_2.h b/Packages/Spatial_searching/include/CGAL/Search_traits_2.h old mode 100755 new mode 100644 similarity index 74% rename from Packages/Spatial_searching/include/CGAL/Kd_tree_traits_point_2.h rename to Packages/Spatial_searching/include/CGAL/Search_traits_2.h index 7df8f42e8c0..188da71ce52 --- a/Packages/Spatial_searching/include/CGAL/Kd_tree_traits_point_2.h +++ b/Packages/Spatial_searching/include/CGAL/Search_traits_2.h @@ -11,7 +11,7 @@ // release : // release_date : // -// file : include/CGAL/Kd_tree_traits_point_2.h +// file : include/CGAL/Search_traits_2.h // package : ASPAS // revision : 3.0 // revision_date : 2003/07/10 @@ -22,23 +22,23 @@ // ====================================================================== -#ifndef CGAL_KD_TREE_TRAITS_POINT_2_H -#define CGAL_KD_TREE_TRAITS_POINT_2_H +#ifndef CGAL_SEARCH_TRAITS_2_H +#define CGAL_SEARCH_TRAITS_2_H namespace CGAL { template - class Kd_tree_traits_point_2 { + class Search_traits_2 { public: - typedef typename K::Point_2 Point; - typedef typename K::Cartesian_const_iterator_2 Cartesian_const_iterator; - typedef typename K::Construct_cartesian_const_iterator_2 Construct_cartesian_const_iterator; - typedef typename K::FT NT; + typedef typename K::Point_2 Point_d; + typedef typename K::Cartesian_const_iterator_2 Cartesian_const_iterator_d; + typedef typename K::Construct_cartesian_const_iterator_2 Construct_cartesian_const_iterator_d; + typedef typename K::FT FT; }; } // namespace CGAL -#endif // KD_TREE_TRAITS_POINT_2_H +#endif // CGAL_SEARCH_TRAITS_2_H diff --git a/Packages/Spatial_searching/include/CGAL/Kd_tree_traits_point_3.h b/Packages/Spatial_searching/include/CGAL/Search_traits_3.h old mode 100755 new mode 100644 similarity index 74% rename from Packages/Spatial_searching/include/CGAL/Kd_tree_traits_point_3.h rename to Packages/Spatial_searching/include/CGAL/Search_traits_3.h index 3b253a5979e..e0c989a35c0 --- a/Packages/Spatial_searching/include/CGAL/Kd_tree_traits_point_3.h +++ b/Packages/Spatial_searching/include/CGAL/Search_traits_3.h @@ -11,7 +11,7 @@ // release : // release_date : // -// file : include/CGAL/Kd_tree_traits_point_3.h +// file : include/CGAL/Search_traits_3.h // package : ASPAS // revision : 3.0 // revision_date : 2003/07/10 @@ -22,25 +22,25 @@ // ====================================================================== -#ifndef CGAL_KD_TREE_TRAITS_POINT_3_H -#define CGAL_KD_TREE_TRAITS_POINT_3_H +#ifndef CGAL_SEARCH_TRAITS_3_H +#define CGAL_SEARCH_TRAITS_3_H namespace CGAL { template - class Kd_tree_traits_point_3 { + class Search_traits_3 { public: - typedef typename K::Cartesian_const_iterator_3 Cartesian_const_iterator; - typedef typename K::Construct_cartesian_const_iterator_3 Construct_cartesian_const_iterator; - typedef typename K::Point_3 Point; - typedef typename K::FT NT; + typedef typename K::Cartesian_const_iterator_3 Cartesian_const_iterator_d; + typedef typename K::Construct_cartesian_const_iterator_3 Construct_cartesian_const_iterator_d; + typedef typename K::Point_3 Point_d; + typedef typename K::FT FT; }; } // namespace CGAL -#endif // KD_TREE_TRAITS_POINT_3_H +#endif // SEARCH_TRAITS_3_H diff --git a/Packages/Spatial_searching/include/CGAL/Kd_tree_traits_point_d.h b/Packages/Spatial_searching/include/CGAL/Search_traits_d.h old mode 100755 new mode 100644 similarity index 79% rename from Packages/Spatial_searching/include/CGAL/Kd_tree_traits_point_d.h rename to Packages/Spatial_searching/include/CGAL/Search_traits_d.h index 66f5c3d61e6..6b153048370 --- a/Packages/Spatial_searching/include/CGAL/Kd_tree_traits_point_d.h +++ b/Packages/Spatial_searching/include/CGAL/Search_traits_d.h @@ -22,22 +22,22 @@ // ====================================================================== -#ifndef CGAL_KD_TREE_TRAITS_POINT_D_H -#define CGAL_KD_TREE_TRAITS_POINT_D_H +#ifndef CGAL_SEARCH_TRAITS_D_H +#define CGAL_SEARCH_TRAITS_D_H namespace CGAL { template - class Kd_tree_traits_point_d { + class Search_traits_d { public: - typedef typename K::Cartesian_const_iterator_d Cartesian_const_iterator; - typedef typename K::Construct_Cartesian_const_iterator_d Construct_cartesian_const_iterator; - typedef typename K::Point_d Point; - typedef typename K::FT NT; + typedef typename K::Cartesian_const_iterator_d Cartesian_const_iterator_d; + typedef typename K::Construct_Cartesian_const_iterator_d Construct_cartesian_const_iterator_d; + typedef typename K::Point_d Point_d; + typedef typename K::FT FT; }; } // namespace CGAL -#endif // KD_TREE_TRAITS_POINT_D_H +#endif // CGAL_SEARCH_TRAITS_D_H diff --git a/Packages/Spatial_searching/include/CGAL/Splitters.h b/Packages/Spatial_searching/include/CGAL/Splitters.h index 0121b6fe3df..d1757c36cae 100644 --- a/Packages/Spatial_searching/include/CGAL/Splitters.h +++ b/Packages/Spatial_searching/include/CGAL/Splitters.h @@ -23,7 +23,7 @@ // Defines rules used for constructing a split node. That is, it implements, // in several ways, the concept -// Boxtree_splitter. +// Boxtree_splitter. #ifndef CGAL_SPLITTERS_H #define CGAL_SPLITTERS_H @@ -31,20 +31,20 @@ #include namespace CGAL { - template + template class Splitter_base { private: unsigned int the_bucket_size; - NT the_aspect_ratio; + FT the_aspect_ratio; public: Splitter_base(unsigned int bucket_size = 3, - NT aspect_ratio = NT(3)) + FT aspect_ratio = FT(3)) : the_bucket_size(bucket_size), the_aspect_ratio(aspect_ratio) {} - NT + FT aspect_ratio() const { return the_aspect_ratio; } @@ -57,15 +57,15 @@ public: }; -template , - class Separator_=Plane_separator > +template , + class Separator_=Plane_separator > class Median_of_max_spread - : public Splitter_base + : public Splitter_base { - typedef Splitter_base Base; + typedef Splitter_base Base; public: - typedef typename GeomTraits::NT NT; + typedef typename SearchTraits::FT FT; typedef Container_ Container; typedef Separator_ Separator; @@ -80,20 +80,20 @@ public: void operator() (Separator& sep, Container& c0, Container& c1) { - sep=Separator(c0.max_tight_span_coord(),NT(0)); + sep=Separator(c0.max_tight_span_coord(),FT(0)); sep.set_cutting_value(c0.median(sep.cutting_dimension())); c0.split(c1,sep,true); } }; -template , - class Separator_=Plane_separator > +template , + class Separator_=Plane_separator > class Fair - : public Splitter_base { + : public Splitter_base { - typedef Splitter_base Base; + typedef Splitter_base Base; public: - typedef typename GeomTraits::NT NT; + typedef typename SearchTraits::FT FT; typedef Container_ Container; typedef Separator_ Separator; @@ -102,7 +102,7 @@ public: {} Fair(unsigned int bucket_size, - NT aspect_ratio=NT(3)) + FT aspect_ratio=FT(3)) : Base(bucket_size, aspect_ratio) {} @@ -110,22 +110,22 @@ public: Container& c1) { // find legal cut with max spread sep=Separator(c0.max_tight_span_coord_balanced(aspect_ratio()), - NT(0)); + FT(0)); sep.set_cutting_value(c0.balanced_fair(sep.cutting_dimension(), aspect_ratio())); c0.split(c1,sep); } }; -template , - class Separator_=Plane_separator > +template , + class Separator_=Plane_separator > class Sliding_fair - : public Splitter_base { + : public Splitter_base { - typedef Splitter_base Base; + typedef Splitter_base Base; public: - typedef typename GeomTraits::NT NT; + typedef typename SearchTraits::FT FT; typedef Container_ Container; typedef Separator_ Separator; @@ -134,7 +134,7 @@ public: {} Sliding_fair(unsigned int bucket_size, - NT aspect_ratio=NT(3)) + FT aspect_ratio=FT(3)) : Base(bucket_size, aspect_ratio) {} @@ -143,7 +143,7 @@ public: // find legal cut with max spread sep=Separator(c0.max_tight_span_coord_balanced(aspect_ratio()), - NT(0)); + FT(0)); sep.set_cutting_value(c0.balanced_sliding_fair(sep.cutting_dimension(), aspect_ratio())); @@ -152,15 +152,15 @@ public: }; -template , - class Separator_=Plane_separator > +template , + class Separator_=Plane_separator > class Sliding_midpoint - : public Splitter_base { + : public Splitter_base { - typedef Splitter_base Base; + typedef Splitter_base Base; public: - typedef typename GeomTraits::NT NT; + typedef typename SearchTraits::FT FT; typedef Container_ Container; typedef Separator_ Separator; @@ -176,10 +176,10 @@ public: Container& c1) { sep=Separator(c0.max_span_coord(), - (c0.max_span_upper() + c0.max_span_lower())/NT(2)); - NT max_span_lower = + (c0.max_span_upper() + c0.max_span_lower())/FT(2)); + FT max_span_lower = c0.tight_bounding_box().min_coord(c0.max_span_coord()); - NT max_span_upper = + FT max_span_upper = c0.tight_bounding_box().max_coord(c0.max_span_coord()); if (max_span_upper <= sep.cutting_value()) { sep.set_cutting_value(max_span_upper); @@ -191,15 +191,15 @@ public: } }; -template , - class Separator_=Plane_separator > +template , + class Separator_=Plane_separator > class Median_of_rectangle - : public Splitter_base { + : public Splitter_base { - typedef Splitter_base Base; + typedef Splitter_base Base; public: - typedef typename GeomTraits::NT NT; + typedef typename SearchTraits::FT FT; typedef Container_ Container; typedef Separator_ Separator; @@ -215,21 +215,21 @@ public: void operator() (Separator& sep, Container& c0, Container& c1) { - sep=Separator(c0.max_span_coord(),NT(0)); + sep=Separator(c0.max_span_coord(),FT(0)); sep.set_cutting_value(c0.median(sep.cutting_dimension())); c0.split(c1,sep,true); } }; -template , - class Separator_=Plane_separator > +template , + class Separator_=Plane_separator > class Midpoint_of_max_spread - : public Splitter_base { + : public Splitter_base { - typedef Splitter_base Base; + typedef Splitter_base Base; public: - typedef typename GeomTraits::NT NT; + typedef typename SearchTraits::FT FT; typedef Container_ Container; typedef Separator_ Separator; @@ -246,19 +246,19 @@ public: Container& c1) { sep= Separator(c0.max_tight_span_coord(), - (c0.max_tight_span_upper() + c0.max_tight_span_lower())/NT(2)); + (c0.max_tight_span_upper() + c0.max_tight_span_lower())/FT(2)); c0.split(c1,sep); } }; -template , - class Separator_=Plane_separator > +template , + class Separator_=Plane_separator > class Midpoint_of_rectangle - : public Splitter_base { + : public Splitter_base { - typedef Splitter_base Base; + typedef Splitter_base Base; public: - typedef typename GeomTraits::NT NT; + typedef typename SearchTraits::FT FT; typedef Container_ Container; typedef Separator_ Separator; @@ -275,7 +275,7 @@ public: Container& c1) { sep = Separator(c0.max_span_coord(), - (c0.max_span_upper() + c0.max_span_lower())/NT(2)); + (c0.max_span_upper() + c0.max_span_lower())/FT(2)); c0.split(c1,sep); } diff --git a/Packages/Spatial_searching/include/CGAL/Weighted_Minkowski_distance.h b/Packages/Spatial_searching/include/CGAL/Weighted_Minkowski_distance.h index 3a0aa22ad07..9e3eda6fc58 100644 --- a/Packages/Spatial_searching/include/CGAL/Weighted_Minkowski_distance.h +++ b/Packages/Spatial_searching/include/CGAL/Weighted_Minkowski_distance.h @@ -31,19 +31,19 @@ namespace CGAL { - template + template class Weighted_Minkowski_distance { public: - typedef typename GeomTraits::Point Point; - typedef typename GeomTraits::NT NT; - typedef std::vector Weight_vector; + typedef typename SearchTraits::Point_d Point_d; + typedef typename SearchTraits::FT FT; + typedef std::vector Weight_vector; private: - typedef typename GeomTraits::Cartesian_const_iterator Coord_iterator; - NT power; + typedef typename SearchTraits::Cartesian_const_iterator_d Coord_iterator; + FT power; Weight_vector the_weights; @@ -59,51 +59,51 @@ namespace CGAL { : power(2) { the_weights.reserve(d); - for (unsigned int i = 0; i < d; ++i) the_weights[i]=NT(1); + for (unsigned int i = 0; i < d; ++i) the_weights[i]=FT(1); } //default copy constructor and destructor - Weighted_Minkowski_distance (NT pow, int dim, + Weighted_Minkowski_distance (FT pow, int dim, const Weight_vector& weights) : power(pow) { - assert(power >= NT(0)); + assert(power >= FT(0)); assert(dim==weights.size()); for (unsigned int i = 0; i < weights.size(); ++i) - assert(weights[i]>=NT(0)); + assert(weights[i]>=FT(0)); the_weights.resize(weights.size()); the_weights = weights; } template - Weighted_Minkowski_distance (NT pow, int dim, + Weighted_Minkowski_distance (FT pow, int dim, InputIterator begin, InputIterator end) : power(pow) { - assert(power >= NT(0)); + assert(power >= FT(0)); the_weights.resize(dim); std::copy(begin, end, the_weights.begin()); for (unsigned int i = 0; i < dim; ++i){ the_weights[i] = *begin; ++begin; - assert(the_weights[i]>=NT(0)); + assert(the_weights[i]>=FT(0)); } assert(begin == end); } inline - NT - distance(const Point& q, const Point& p) + FT + transformed_distance(const Point_d& q, const Point_d& p) { - NT distance = NT(0); - typename GeomTraits::Construct_cartesian_const_iterator construct_it; + FT distance = FT(0); + typename SearchTraits::Construct_cartesian_const_iterator_d construct_it; Coord_iterator qit = construct_it(q), qe = construct_it(q,1), pit = construct_it(p); - if (power == NT(0)) { + if (power == FT(0)) { for (unsigned int i = 0; qit != qe; ++qit, ++i) if (the_weights[i] * fabs((*qit) - (*pit)) > distance) distance = the_weights[i] * fabs((*qit)-(*pit)); @@ -117,14 +117,14 @@ namespace CGAL { inline - NT - min_distance_to_rectangle(const Point& q, - const Kd_tree_rectangle& r) const + FT + min_distance_to_rectangle(const Point_d& q, + const Kd_tree_rectangle& r) const { - NT distance = NT(0); - typename GeomTraits::Construct_cartesian_const_iterator construct_it; + FT distance = FT(0); + typename SearchTraits::Construct_cartesian_const_iterator_d construct_it; Coord_iterator qit = construct_it(q), qe = construct_it(q,1); - if (power == NT(0)) + if (power == FT(0)) { for (unsigned int i = 0; qit != qe; ++qit, ++i) { if (the_weights[i]*(r.min_coord(i) - @@ -152,17 +152,17 @@ namespace CGAL { } inline - NT - max_distance_to_rectangle(const Point& q, - const Kd_tree_rectangle& r) const { - NT distance=NT(0); - typename GeomTraits::Construct_cartesian_const_iterator construct_it; + FT + max_distance_to_rectangle(const Point_d& q, + const Kd_tree_rectangle& r) const { + FT distance=FT(0); + typename SearchTraits::Construct_cartesian_const_iterator_d construct_it; Coord_iterator qit = construct_it(q), qe = construct_it(q,1); - if (power == NT(0)) + if (power == FT(0)) { for (unsigned int i = 0; qit != qe; ++qit, ++i) { if ((*qit) >= (r.min_coord(i) + - r.max_coord(i))/NT(2.0)) + r.max_coord(i))/FT(2.0)) if (the_weights[i] * ((*qit) - r.min_coord(i)) > distance) distance = the_weights[i] * @@ -177,7 +177,7 @@ namespace CGAL { else { for (unsigned int i = 0; qit != qe; ++qit, ++i) { - if ((*qit) <= (r.min_coord(i)+r.max_coord(i))/NT(2.0)) + if ((*qit) <= (r.min_coord(i)+r.max_coord(i))/FT(2.0)) distance += the_weights[i] * pow(r.max_coord(i)-(*qit),power); else distance += the_weights[i] * pow((*qit)-r.min_coord(i),power); @@ -187,12 +187,12 @@ namespace CGAL { } inline - NT - new_distance(NT dist, NT old_off, NT new_off, + FT + new_distance(FT dist, FT old_off, FT new_off, int cutting_dimension) const { - NT new_dist; - if (power == NT(0)) + FT new_dist; + if (power == FT(0)) { if (the_weights[cutting_dimension]*fabs(new_off) > dist) @@ -209,19 +209,19 @@ namespace CGAL { } inline - NT - transformed_distance(NT d) const + FT + transformed_distance(FT d) const { - if (power <= NT(0)) return d; + if (power <= FT(0)) return d; else return pow(d,power); } inline - NT - inverse_of_transformed_distance(NT d) const + FT + inverse_of_transformed_distance(FT d) const { - if (power <= NT(0)) return d; + if (power <= FT(0)) return d; else return pow(d,1/power); }