From 464ecbe5860af4bf577b5a14a6edafd42daf4b01 Mon Sep 17 00:00:00 2001 From: Andreas Fabri Date: Thu, 10 Apr 2003 13:30:40 +0000 Subject: [PATCH] simplifications, added consts --- Packages/SearchStructures/changes.txt | 4 + .../include/CGAL/Range_tree_d.h | 28 +-- .../include/CGAL/Range_tree_k.h | 40 ++--- .../include/CGAL/Segment_tree_d.h | 160 ++++++++---------- .../include/CGAL/Segment_tree_k.h | 40 ++--- .../SearchStructures/include/CGAL/Tree_base.h | 73 ++++---- .../test/RangeSegmentTrees/makefile | 9 +- .../RangeSegmentTrees/segment_tree_set_2.C | 83 ++++++--- 8 files changed, 225 insertions(+), 212 deletions(-) diff --git a/Packages/SearchStructures/changes.txt b/Packages/SearchStructures/changes.txt index 85848470819..039f6d82bc7 100644 --- a/Packages/SearchStructures/changes.txt +++ b/Packages/SearchStructures/changes.txt @@ -1,3 +1,7 @@ +- cleanup: initialization, naming conventions for classes +- replaced count_elements__C by std::distance +- added plenty of const + Version 2.69 (8 April 2003) [af] - Fixed a bug reported by Serge Pashkov on 08/01/2003 - A vector was too long. diff --git a/Packages/SearchStructures/include/CGAL/Range_tree_d.h b/Packages/SearchStructures/include/CGAL/Range_tree_d.h index 012e2d59062..e58e83192ac 100644 --- a/Packages/SearchStructures/include/CGAL/Range_tree_d.h +++ b/Packages/SearchStructures/include/CGAL/Range_tree_d.h @@ -109,7 +109,7 @@ protected: // typedef Range_tree_d< C_Data, C_Window, C_Interface> rT_d; Tree_base *sublayer_tree; C_Interface interface; - int is_build; + int is_built; // A vertex is of this type: @@ -391,12 +391,12 @@ public: // construction of a tree Range_tree_d(Range_tree_d const &fact, bool): - sublayer_tree(fact.sublayer_tree->clone()), is_build(false), header(0) + sublayer_tree(fact.sublayer_tree->clone()), is_built(false), header(0) {} // construction of a tree Range_tree_d(Tree_base const &fact): - sublayer_tree(fact.clone()), is_build(false), header(0) + sublayer_tree(fact.clone()), is_built(false), header(0) {} // destruction @@ -419,22 +419,22 @@ public: return new Range_tree_d(*this, true); } - bool make_tree(typename std::list< C_Data>::iterator& beg, - typename std::list< C_Data>::iterator& end, + bool make_tree(const typename std::list< C_Data>::iterator& beg, + const typename std::list< C_Data>::iterator& end, typename tbt::lit * =0){ return make_tree_impl(beg,end); } #ifdef stlvector - bool make_tree(typename std::vector< C_Data>::iterator& beg, - typename std::vector< C_Data>::iterator& end, + bool make_tree(const typename std::vector< C_Data>::iterator& beg, + const typename std::vector< C_Data>::iterator& end, typename tbt::vbit * =0){ return make_tree_impl(beg,end); } #endif #ifdef carray - bool make_tree(C_Data *beg, - C_Data *end){ + bool make_tree(const C_Data *beg, + const C_Data *end){ return make_tree_impl(beg,end); } #endif @@ -442,20 +442,20 @@ public: // the tree is build according to the input elements in [first,last) template inline - bool make_tree_impl(T& first, - T& last) + bool make_tree_impl(T first, + T last) // af: was & todo: can we turn it in const& ?? { link_type leftchild, rightchild, prevchild, leftmostlink; - if(!is_build) - is_build = true; + if(!is_built) + is_built = true; else return false; int n = std::distance(first, last); if(n==0) { - is_build = false; + is_built = false; return true; } diff --git a/Packages/SearchStructures/include/CGAL/Range_tree_k.h b/Packages/SearchStructures/include/CGAL/Range_tree_k.h index c2c624b24bf..86bd2390692 100644 --- a/Packages/SearchStructures/include/CGAL/Range_tree_k.h +++ b/Packages/SearchStructures/include/CGAL/Range_tree_k.h @@ -68,7 +68,7 @@ public: typedef tree_point_traits I1; - typedef tree_anchor Tree_anchor_type; + typedef Tree_anchor Tree_anchor_type; Tree_anchor_type *anchor; typedef Range_tree_d Range_tree_1_type; @@ -82,16 +82,16 @@ public: } template - Range_tree_1(T& first, - T& last) + Range_tree_1(const T& first, + const T& last) : anchor(new Tree_anchor_type), range_tree_1(new Range_tree_1_type(*anchor)) { range_tree_1->make_tree(first,last); } template - bool make_tree(T& first, - T& last) + bool make_tree(const T& first, + const T& last) { delete range_tree_1; delete anchor; @@ -149,7 +149,7 @@ public: Key_2, key_2, low_2, high_2, compare_2> I2; - typedef tree_anchor Tree_anchor_type; + typedef Tree_anchor Tree_anchor_type; Tree_anchor_type *anchor; typedef Range_tree_d Range_tree_1_type; @@ -166,8 +166,8 @@ public: {} template - Range_tree_2(T& first, - T& last) + Range_tree_2(const T& first, + const T& last) : anchor(new Tree_anchor_type), range_tree_1(new Range_tree_1_type(*anchor)), range_tree_2(new Range_tree_2_type(*range_tree_1)) @@ -176,8 +176,8 @@ public: } template - bool make_tree(T& first, - T& last) + bool make_tree(const T& first, + const T& last) { delete range_tree_2; delete range_tree_1; @@ -241,7 +241,7 @@ public: typedef tree_point_traits I3; - typedef tree_anchor Tree_anchor_type; + typedef Tree_anchor Tree_anchor_type; Tree_anchor_type *anchor; typedef Range_tree_d Range_tree_1_type; @@ -261,8 +261,8 @@ public: {} template - Range_tree_3(T& first, - T& last) + Range_tree_3(const T& first, + const T& last) : anchor(new Tree_anchor_type), range_tree_1(new Range_tree_1_type(*anchor)), range_tree_2(new Range_tree_2_type(*range_tree_1)), @@ -272,8 +272,8 @@ public: } template - bool make_tree(T& first, - T& last) + bool make_tree(const T& first, + const T& last) { delete range_tree_3; delete range_tree_2; @@ -351,7 +351,7 @@ public: typedef tree_point_traits I4; - typedef tree_anchor Tree_anchor_type; + typedef Tree_anchor Tree_anchor_type; Tree_anchor_type *anchor; typedef Range_tree_d Range_tree_1_type; @@ -375,8 +375,8 @@ public: {} template - Range_tree_4(T& first, - T& last) + Range_tree_4(const T& first, + const T& last) : anchor(new Tree_anchor_type), range_tree_1(new Range_tree_1_type(*anchor)), range_tree_2(new Range_tree_2_type(*range_tree_1)), @@ -387,8 +387,8 @@ public: } template - bool make_tree(T& first, - T& last) + bool make_tree(const T& first, + const T& last) { delete range_tree_4; delete range_tree_3; diff --git a/Packages/SearchStructures/include/CGAL/Segment_tree_d.h b/Packages/SearchStructures/include/CGAL/Segment_tree_d.h index 62522916ff7..4305f44a6d9 100644 --- a/Packages/SearchStructures/include/CGAL/Segment_tree_d.h +++ b/Packages/SearchStructures/include/CGAL/Segment_tree_d.h @@ -50,34 +50,33 @@ template class Segment_tree_d; template -struct segment_tree_node: public tree_node_base +struct Segment_tree_node: public Tree_node_base { typedef C_Data Data; typedef C_Window Window; typedef typename C_Interface::Key Key; typedef C_Interface Interface; - typedef tree_base< C_Data, C_Window> tree_base_type; - typedef Segment_tree_d< C_Data, C_Window, C_Interface> sT_d; + typedef Tree_base< C_Data, C_Window> Tree_base_type; std::list< C_Data> objects; Key left_key; Key right_key; - tree_base *sublayer; + Tree_base *sublayer; public: friend class Segment_tree_d< C_Data, C_Window, C_Interface>; - segment_tree_node() - : tree_node_base(TREE_BASE_NULL, TREE_BASE_NULL), sublayer(0) + Segment_tree_node() + : Tree_node_base(TREE_BASE_NULL, TREE_BASE_NULL), sublayer(0) {} - segment_tree_node(segment_tree_node * p_left, - segment_tree_node * p_right, + Segment_tree_node(Segment_tree_node * p_left, + Segment_tree_node * p_right, const Key p_left_key, const Key p_right_key) - : tree_node_base(p_left,p_right), left_key(p_left_key), right_key(p_right_key), sublayer(0) + : Tree_node_base(p_left,p_right), left_key(p_left_key), right_key(p_right_key), sublayer(0) {} - ~segment_tree_node(){ + ~Segment_tree_node(){ objects.clear(); if (sublayer != 0)//(tree_base_type *) delete sublayer; @@ -86,7 +85,7 @@ public: template -class Segment_tree_d: public tree_base< C_Data, C_Window> +class Segment_tree_d: public Tree_base< C_Data, C_Window> { private: typedef C_Data Data; @@ -94,20 +93,19 @@ private: typedef typename C_Interface::Key Key; typedef C_Interface Interface; public: - typedef tree_base tbt; + typedef Tree_base tbt; protected: - typedef Segment_tree_d< C_Data, C_Window, C_Interface> sT_d; - tree_base *sublayer_tree; + Tree_base *sublayer_tree; // type of a vertex - // struct segment_tree_node; + // struct Segment_tree_node; - friend class segment_tree_node; - typedef segment_tree_node segment_tree_node_t; - typedef segment_tree_node *link_type; + friend class Segment_tree_node; + typedef Segment_tree_node Segment_tree_node_t; + typedef Segment_tree_node *link_type; C_Interface interface; - bool is_build; + bool is_built; bool is_less_equal(const Key& x, const Key& y) const @@ -115,17 +113,14 @@ protected: return (!interface.comp(y,x)); } - static link_type& left(link_type x) { - return CGAL__static_cast(link_type&, (*x).left_link); - // return static_cast((*x).left_link); + static link_type left(link_type x) { + return static_cast(x->left_link); } - static link_type& right(link_type x) { - return CGAL__static_cast(link_type&, (*x).right_link); - //return static_cast((*x).right_link); + static link_type right(link_type x) { + return static_cast(x->right_link); } - static link_type& parent(link_type x) { - return CGAL__static_cast(link_type&, (*x).parent_link); - //return static_cast( (*x).parent_link); + static link_type parent(link_type x) { + return static_cast( x->parent_link); } link_type header; @@ -134,9 +129,8 @@ protected: link_type leftmost(){return left(header);} link_type root() const{ if(header!=0) - return CGAL__static_cast(link_type&,header->parent_link); - // return parent(header); - else return 0; + return static_cast(header->parent_link); + return 0; } // returns true, if the object lies inside of win @@ -148,8 +142,7 @@ protected: { return sublayer_tree->is_inside(win,object); } - else - return false; + return false; } // this tree is not a recursion anchor @@ -158,10 +151,10 @@ protected: void insert_segment(link_type v, C_Data& element) { - if ((is_less_equal(interface.get_left(element), (*v).left_key) && - is_less_equal((*v).right_key, interface.get_right(element))) + if ((is_less_equal(interface.get_left(element), v->left_key) && + is_less_equal(v->right_key, interface.get_right(element))) || left(v)==TREE_BASE_NULL) - (*v).objects.insert((*v).objects.end(), element); + v->objects.insert(v->objects.end(), element); else { if (!is_less_equal((*left(v)).right_key, interface.get_left(element))) @@ -185,7 +178,7 @@ protected: typename std::list< C_Data>::iterator sub_first = v->objects.begin(); typename std::list< C_Data>::iterator sub_last = v->objects.end(); - tree_base *g = sublayer_tree->clone(); + Tree_base *g = sublayer_tree->clone(); g->make_tree(sub_first, sub_last); v->sublayer = g; if (!v->sublayer->is_anchor()) @@ -206,21 +199,21 @@ protected: if (n==2) { link_type vright; - link_type vleft = new segment_tree_node_t + link_type vleft = new Segment_tree_node_t (TREE_BASE_NULL, TREE_BASE_NULL, keys[index], keys[index+1]); index++; if(index+1>last) { - vright = new segment_tree_node_t + vright = new Segment_tree_node_t (TREE_BASE_NULL, TREE_BASE_NULL, keys[index], keys[index]); } else { - vright = new segment_tree_node_t + vright = new Segment_tree_node_t (TREE_BASE_NULL, TREE_BASE_NULL, keys[index], keys[index+1]); } index++; - link_type vparent = new segment_tree_node_t + link_type vparent = new Segment_tree_node_t (vleft, vright, vleft->left_key, vright->right_key); vleft->parent_link = vparent; @@ -237,11 +230,11 @@ protected: { link_type vright; if(index+1 > last){ - vright = new segment_tree_node_t + vright = new Segment_tree_node_t (TREE_BASE_NULL, TREE_BASE_NULL, keys[index], keys[index]); } else{ - vright = new segment_tree_node_t + vright = new Segment_tree_node_t (TREE_BASE_NULL, TREE_BASE_NULL, keys[index], keys[index+1]); } index++; @@ -254,7 +247,7 @@ protected: // recursiv call for the construction. the interval is devided. build_segment_tree(n - (int)n/2, leftchild, rightchild, prevchild, leftmostlink, index, last, keys); - link_type vparent = new segment_tree_node_t + link_type vparent = new Segment_tree_node_t (prevchild, TREE_BASE_NULL, prevchild->left_key, prevchild->left_key); prevchild->parent_link = vparent; build_segment_tree((int)n/2, leftchild, rightchild, @@ -284,17 +277,17 @@ protected: A result, link_type v) { - if(is_less_equal(interface.get_right_win(win), (*v).left_key) - || is_less_equal((*v).right_key,interface.get_left_win(win))) + if(is_less_equal(interface.get_right_win(win), v->left_key) + || is_less_equal(v->right_key,interface.get_left_win(win))) return result; if (v->sublayer!=0 && (!v->sublayer->is_anchor())) //(tree_base_type *) { - tree_base *T = v->sublayer; + Tree_base *T = v->sublayer; std::list< C_Data> tmp_result; std::back_insert_iterator > tmp_back_inserter = std::back_inserter(tmp_result); - (*T).enclosing_query(win, tmp_back_inserter); + T->enclosing_query(win, tmp_back_inserter); typename std::list< C_Data>::iterator tmp = tmp_result.begin(); while(tmp!=tmp_result.end()) { @@ -303,7 +296,7 @@ protected: { if(is_less_equal(interface.get_right_win(win), interface.get_right(*tmp))) - if(is_less_equal((*v).left_key, interface.get_left_win(win))) + if(is_less_equal(v->left_key, interface.get_left_win(win))) *result++=(*tmp); } tmp++; @@ -321,7 +314,7 @@ protected: { if(is_less_equal(interface.get_right_win(win), interface.get_right(*j))) - if(is_less_equal((*v).left_key, interface.get_left_win(win))) + if(is_less_equal(v->left_key, interface.get_left_win(win))) *result++=(*j); } j++; @@ -342,32 +335,32 @@ protected: inline A window_query( C_Window const &win, A result, - link_type& v) + const link_type& v) // af: was not const { - if(is_less_equal(interface.get_right_win(win), (*v).left_key) || - is_less_equal((*v).right_key,interface.get_left_win(win))) + if(is_less_equal(interface.get_right_win(win), v->left_key) || + is_less_equal(v->right_key,interface.get_left_win(win))) return result; if (v->sublayer!=0 && (!v->sublayer->is_anchor())) //(tree_base_type *) { - tree_base *T = v->sublayer; + Tree_base *T = v->sublayer; std::list< C_Data> tmp_result; std::back_insert_iterator > tmp_back_inserter = std::back_inserter(tmp_result); - (*T).window_query(win, tmp_back_inserter); + T->window_query(win, tmp_back_inserter); typename std::list< C_Data>::iterator tmp = tmp_result.begin(); while(tmp!=tmp_result.end()) { if(interface.comp(interface.get_left(*tmp), interface.get_left_win(win))) { - if(is_less_equal((*v).left_key, interface.get_left_win(win))){ + if(is_less_equal(v->left_key, interface.get_left_win(win))){ *result++=(*tmp); } } else { - if(is_less_equal((*v).left_key,interface.get_left(*tmp))){ + if(is_less_equal(v->left_key,interface.get_left(*tmp))){ *result++=(*tmp); } } @@ -383,13 +376,13 @@ protected: { if(interface.comp(interface.get_left(*j), interface.get_left_win(win))) { - if(is_less_equal((*v).left_key, interface.get_left_win(win))) + if(is_less_equal(v->left_key, interface.get_left_win(win))) { *result++=(*j); } } else - if(is_less_equal((*v).left_key,interface.get_left(*j))) + if(is_less_equal(v->left_key,interface.get_left(*j))) { *result++=(*j); } @@ -405,12 +398,12 @@ protected: return result; } - bool is_valid(link_type& v) const + bool is_valid(const link_type& v) const // af:was not const reference { if (v->sublayer != 0)//(tree_base_type *) { - tree_base *T=v->sublayer; - if(! (*T).is_valid()) + Tree_base *T=v->sublayer; + if(! T->is_valid()) return false; } if(left(v)!=TREE_BASE_NULL) @@ -428,13 +421,13 @@ protected: link_type parent_of_v = parent(v); while (j!= v->objects.end()) { - if(!is_less_equal(interface.get_left(*j), (*v).left_key)) + if(!is_less_equal(interface.get_left(*j), v->left_key)) return false; - if(!is_less_equal( (*v).right_key, interface.get_right(*j))) + if(!is_less_equal( v->right_key, interface.get_right(*j))) return false; if (parent_of_v != root()) - if((is_less_equal(interface.get_left(*j),(*parent_of_v).left_key))&& - (is_less_equal( (*parent_of_v).right_key, + if((is_less_equal(interface.get_left(*j), parent_of_v->left_key))&& + (is_less_equal( parent_of_v->right_key, interface.get_right(*j)))) return false; j++; @@ -449,12 +442,12 @@ public: // construction of a tree Segment_tree_d(Segment_tree_d const &sub_tree, bool): - sublayer_tree(sub_tree.sublayer_tree->clone()), is_build(false), header(TREE_BASE_NULL) + sublayer_tree(sub_tree.sublayer_tree->clone()), is_built(false), header(TREE_BASE_NULL) {} // construction of a tree, definition of the prototype of sublayer tree - Segment_tree_d(tree_base const &sub_tree): - sublayer_tree(sub_tree.clone()), is_build(false), header(TREE_BASE_NULL) + Segment_tree_d(Tree_base const &sub_tree): + sublayer_tree(sub_tree.clone()), is_built(false), header(TREE_BASE_NULL) {} // destruction @@ -470,25 +463,25 @@ public: } // clone creates a prototype - tree_base *clone() const { + Tree_base *clone() const { return new Segment_tree_d(*this, true); } - bool make_tree(typename std::list< C_Data>::iterator& beg, - typename std::list< C_Data>::iterator& end, + bool make_tree(const typename std::list< C_Data>::iterator& beg, + const typename std::list< C_Data>::iterator& end, typename tbt::lit * =0){ return make_tree_impl(beg,end); } #ifdef stlvector - bool make_tree(typename std::vector< C_Data>::iterator& beg, - typename std::vector< C_Data>::iterator& end, + bool make_tree(const typename std::vector< C_Data>::iterator& beg, + const typename std::vector< C_Data>::iterator& end, typename tbt::vbit * =0){ return make_tree_impl(beg,end); } #endif #ifdef carray - bool make_tree(C_Data *beg, - C_Data *end){ + bool make_tree(const C_Data *beg, + const C_Data *end){ return make_tree_impl(beg,end); } #endif @@ -496,19 +489,16 @@ public: // the tree is build according to Data [first,last) template inline - bool make_tree_impl(A& first,A& last) + bool make_tree_impl(const A& first, const A& last) { - if(!is_build) - is_build = true; + if(!is_built) + is_built = true; else return false; A count = first; int n=0; - int c1 = count_elements__C(first, last); - int c2 = std::distance(first, last); - assert(c1 == c2); - std::vector keys(2*c1); + std::vector keys(2* std::distance(first, last)); while(count!=last) { if (interface.comp(interface.get_left(*count), @@ -528,7 +518,7 @@ public: if(n==0) { - is_build = false; + is_built = false; return true; } std::sort(keys.begin(), keys.end(), interface.comp); @@ -554,7 +544,7 @@ public: build_segment_tree(num-1, leftchild, rightchild, prevchild, leftmostlink, start, num-1, keys2); - header = new segment_tree_node_t(); + header = new Segment_tree_node_t(); header->right_link = rightchild; header->parent_link = prevchild; prevchild->parent_link = prevchild; diff --git a/Packages/SearchStructures/include/CGAL/Segment_tree_k.h b/Packages/SearchStructures/include/CGAL/Segment_tree_k.h index 52c98f05f35..f4231d6407a 100644 --- a/Packages/SearchStructures/include/CGAL/Segment_tree_k.h +++ b/Packages/SearchStructures/include/CGAL/Segment_tree_k.h @@ -63,7 +63,7 @@ public: high_1, compare_1> I1; - typedef tree_anchor Tree_anchor_type; + typedef Tree_anchor Tree_anchor_type; Tree_anchor_type *anchor; typedef Segment_tree_d Segment_tree_1_type; @@ -75,16 +75,16 @@ public: {} template - Segment_tree_1(T& first, - T& last) + Segment_tree_1(const T& first, + const T& last) : anchor(new Tree_anchor_type), segment_tree_1(new Segment_tree_1_type(*anchor)) { segment_tree_1->make_tree(first,last); } template - bool make_tree(T& first, - T& last) + bool make_tree(const T& first, + const T& last) { delete segment_tree_1; delete anchor; @@ -148,7 +148,7 @@ public: low_2, high_2, low_2, high_2, compare_2> I2; - typedef tree_anchor Tree_anchor_type; + typedef Tree_anchor Tree_anchor_type; Tree_anchor_type *anchor; typedef Segment_tree_d Segment_tree_1_type; @@ -164,8 +164,8 @@ public: {} template - Segment_tree_2(T& first, - T& last) + Segment_tree_2(const T& first, + const T& last) : anchor( new Tree_anchor_type), segment_tree_1(new Segment_tree_1_type(*anchor)), segment_tree_2(new Segment_tree_2_type(*segment_tree_1)) @@ -174,8 +174,8 @@ public: } template - bool make_tree(T& first, - T& last) + bool make_tree(const T& first, + const T& last) { delete segment_tree_2; delete segment_tree_1; @@ -250,7 +250,7 @@ public: low_3, high_3, low_3, high_3, compare_3> I3; - typedef tree_anchor Tree_anchor_type; + typedef Tree_anchor Tree_anchor_type; Tree_anchor_type *anchor; typedef Segment_tree_d Segment_tree_1_type; @@ -270,8 +270,8 @@ public: {} template - Segment_tree_3(T& first, - T& last) + Segment_tree_3(const T& first, + const T& last) : anchor(new Tree_anchor_type), segment_tree_1(new Segment_tree_1_type(*anchor)), segment_tree_2(new Segment_tree_2_type(*segment_tree_1)), @@ -281,8 +281,8 @@ public: } template - bool make_tree(T& first, - T& last) + bool make_tree(const T& first, + const T& last) { delete segment_tree_3; delete segment_tree_2; @@ -368,7 +368,7 @@ public: low_4, high_4, low_4, high_4, compare_4> I4; - typedef tree_anchor Tree_anchor_type; + typedef Tree_anchor Tree_anchor_type; Tree_anchor_type *anchor; typedef Segment_tree_d Segment_tree_1_type; @@ -392,8 +392,8 @@ public: {} template - Segment_tree_4(T& first, - T& last) + Segment_tree_4(const T& first, + const T& last) : anchor(new Tree_anchor_type), segment_tree_1(new Segment_tree_1_type(*anchor)), segment_tree_2(new Segment_tree_2_type(*segment_tree_1)), @@ -404,8 +404,8 @@ public: } template - bool make_tree(T& first, - T& last) + bool make_tree(const T& first, + const T& last) { delete segment_tree_4; delete segment_tree_3; diff --git a/Packages/SearchStructures/include/CGAL/Tree_base.h b/Packages/SearchStructures/include/CGAL/Tree_base.h index 1a9a2fd55a9..86a1938f75e 100644 --- a/Packages/SearchStructures/include/CGAL/Tree_base.h +++ b/Packages/SearchStructures/include/CGAL/Tree_base.h @@ -65,30 +65,17 @@ CGAL_BEGIN_NAMESPACE -template -int count_elements__C( const InIt first, const InIt last ) -{ - InIt z=first; - int i=0; - - while ( z++ != last ) { - i++; - } - - return i; -} - //link type definition of an ordinary vertex of the tree -struct tree_node_base { +struct Tree_node_base { void *parent_link; void *left_link; void *right_link; - tree_node_base() + Tree_node_base() :parent_link(0), left_link(0), right_link(0) {} - tree_node_base(void* ll, void* rl) + Tree_node_base(void* ll, void* rl) :parent_link(0), left_link(ll), right_link(rl) {} }; @@ -100,12 +87,12 @@ struct tree_node_base { // A tree class has to be derived from this class. template -class tree_base +class Tree_base { protected: - tree_base(tree_base const &); // prevent access - void operator= (tree_base const &); // prevent access + Tree_base(Tree_base const &); // prevent access + void operator= (Tree_base const &); // prevent access public: typedef double vit; @@ -117,26 +104,26 @@ public: //typedef std::list::iterator lit; //typedef std::back_insert_iterator lbit; //typedef std::back_insert_iterator vbit; - typedef tree_base tree_base_type; - tree_base() {} - virtual ~tree_base() {} + typedef Tree_base Tree_base_type; + Tree_base() {} + virtual ~Tree_base() {} // 'clone()' returns an object which can be used as argument to 'delete' - virtual tree_base *clone() const = 0; - //virtual tree_base_type *clone() const = 0; + virtual Tree_base *clone() const = 0; + //virtual Tree_base_type *clone() const = 0; // 'make_tree()' returns an object which can be used as argument to 'delete' - virtual bool make_tree(typename std::list::iterator& beg, - typename std::list::iterator& end, + virtual bool make_tree(const typename std::list::iterator& beg, + const typename std::list::iterator& end, lit *dummy=0) =0; #ifdef stlvector - virtual bool make_tree(typename std::vector::iterator& beg, - typename std::vector::iterator& end, + virtual bool make_tree(const typename std::vector::iterator& beg, + const typename std::vector::iterator& end, vit *dummy=0) =0; #endif #ifdef carray - virtual bool make_tree(C_Data *beg, - C_Data *end) =0; + virtual bool make_tree(const C_Data *beg, + const C_Data *end) =0; #endif virtual std::back_insert_iterator< std::list > window_query(C_Window const &win, std::back_insert_iterator< @@ -182,18 +169,18 @@ public: // most inner class. This class is doing nothin exept stopping the recursion template -class tree_anchor: public tree_base< C_Data, C_Window> +class Tree_anchor: public Tree_base< C_Data, C_Window> { public: // Construct a factory with the given factory as sublayer - tree_anchor() {} - virtual ~tree_anchor(){} - tree_base *clone() const { return new tree_anchor(); } - typedef tree_base tbt; -// tree_base_type *clone() const { return new tree_anchor(); } + Tree_anchor() {} + virtual ~Tree_anchor(){} + Tree_base *clone() const { return new Tree_anchor(); } + typedef Tree_base tbt; +// Tree_base_type *clone() const { return new Tree_anchor(); } - bool make_tree(typename std::list< C_Data>::iterator& beg, - typename std::list< C_Data>::iterator& end, + bool make_tree(const typename std::list< C_Data>::iterator& beg, + const typename std::list< C_Data>::iterator& end, typename tbt::lit * =0) { USE_ARGUMENT(beg); @@ -201,8 +188,8 @@ public: return true; } #ifdef stlvector - bool make_tree(typename std::vector< C_Data>::iterator& beg, - typename std::vector< C_Data>::iterator& end, + bool make_tree(const typename std::vector< C_Data>::iterator& beg, + const typename std::vector< C_Data>::iterator& end, typename tbt::vit * =0) { USE_ARGUMENT(beg); @@ -211,8 +198,8 @@ public: } #endif #ifdef carray - bool make_tree( C_Data *beg, - C_Data *end) + bool make_tree(const C_Data *beg, + const C_Data *end) { USE_ARGUMENT(beg); USE_ARGUMENT(end); @@ -300,5 +287,5 @@ protected: }; CGAL_END_NAMESPACE -// ------------------------------------------------------------------- + #endif diff --git a/Packages/SearchStructures/test/RangeSegmentTrees/makefile b/Packages/SearchStructures/test/RangeSegmentTrees/makefile index a34c9dfbd8b..0e45fbdb324 100644 --- a/Packages/SearchStructures/test/RangeSegmentTrees/makefile +++ b/Packages/SearchStructures/test/RangeSegmentTrees/makefile @@ -18,7 +18,7 @@ include $(CGAL_MAKEFILE) # compiler flags #---------------------------------------------------------------------# -CXXFLAGS = -I../../include \ +CXXFLAGS = -O3 -I../../include \ $(TESTSUITE_CXXFLAGS) \ $(EXTRA_FLAGS) \ $(CGAL_CXXFLAGS) \ @@ -48,8 +48,13 @@ all: \ segment_tree_set_2$(EXE_EXT): segment_tree_set_2$(OBJ_EXT) $(CGAL_CXX) $(LIBPATH) $(EXE_OPT)segment_tree_set_2 segment_tree_set_2$(OBJ_EXT) $(LDFLAGS) +generate$(EXE_EXT): generate$(OBJ_EXT) + $(CGAL_CXX) $(LIBPATH) $(EXE_OPT)generate generate$(OBJ_EXT) $(LDFLAGS) + +run: segment_tree_set_2$(EXE_EXT) + segment_tree_set_2$(EXE_EXT) < thousand.rect > thousand.tmp; diff thousand.out thousand.tmp clean: \ - segment_tree_set_2.clean + segment_tree_set_2.clean generate.clean #---------------------------------------------------------------------# # suffix rules diff --git a/Packages/SearchStructures/test/RangeSegmentTrees/segment_tree_set_2.C b/Packages/SearchStructures/test/RangeSegmentTrees/segment_tree_set_2.C index 43827311803..5fe43eff332 100644 --- a/Packages/SearchStructures/test/RangeSegmentTrees/segment_tree_set_2.C +++ b/Packages/SearchStructures/test/RangeSegmentTrees/segment_tree_set_2.C @@ -2,12 +2,12 @@ #include #include #include +#include #include -#include #include -#include #include + typedef CGAL::Simple_cartesian K; typedef CGAL::Range_segment_tree_set_traits_2 Traits; typedef CGAL::Segment_tree_2 Segment_tree_2_type; @@ -15,9 +15,14 @@ typedef CGAL::Segment_tree_2 Segment_tree_2_type; typedef K::Point_2 Point_2; typedef K::Iso_rectangle_2 Iso_rectangle_2; typedef std::pair Interval; +typedef CGAL::Timer Timer; + int main() { + Timer t; + + int ignore = 0; std::list rectangles; std::copy(std::istream_iterator(std::cin), std::istream_iterator(), @@ -27,45 +32,67 @@ int main() for(std::list::iterator it = rectangles.begin(); it != rectangles.end(); ++it){ - intervals.push_back(Interval(it->vertex(0),it->vertex(2))); + if( CGAL::x_equal(it->vertex(0),it->vertex(2)) || + CGAL::y_equal(it->vertex(0),it->vertex(2))){ + ignore++; + } else { + intervals.push_back(Interval(it->vertex(0),it->vertex(2))); + } + } + + if(ignore > 0){ + std::cerr << "ignored " << ignore << " 1D rectangle" << std::endl; } std::list output, N; - // creation of the segment tree - std::list::iterator first = intervals.begin(); - std::list::iterator last = intervals.end(); - - Segment_tree_2_type Segment_tree_2(first, last); + t.start(); + Segment_tree_2_type segment_tree_2(intervals.begin(), intervals.end()); + t.stop(); + std::cerr << "Construction time t = " << t.time() << std::endl; + t.reset(); + t.start(); // perform a window query - Interval a=Interval(Point_2(3,6), Point_2(7,12)); - Segment_tree_2.window_query(a,std::back_inserter(output)); + Interval a(Point_2(1.5, 1.5), Point_2(3.5, 4.5)); + segment_tree_2.window_query(a, std::back_inserter(output)); + + t.stop(); + std::cerr << "Window query time t = " << t.time() << std::endl; + // output of the querey elements on stdout - std::list::iterator j = output.begin(); - std::cerr << "\n window_query (3,6), (7,12)\n"; - while(j!=output.end()) + + std::cout << "\n window_query " << Iso_rectangle_2(a.first, a.second) << std::endl; + for(std::list::iterator j = output.begin(); + j != output.end(); + ++j) { - std::cerr << (*j).first.x() << "-" << (*j).second.x() << " " - << (*j).first.y() << "-" << (*j).second.y() << std::endl; - j++; + std::cout << Iso_rectangle_2(j->first, j->second) << std::endl; } - std::cerr << "\n enclosing_query (6,10),(7,11) \n"; - Interval b=Interval(Point_2(6,10),Point_2(7,11)); - Segment_tree_2.enclosing_query(b,std::back_inserter(N)); - j = N.begin(); - std::cerr << "\n enclosing_query (6,10),(7,11) \n"; - while(j!=N.end()) + + std::cout << "\n enclosing_query " << Iso_rectangle_2(a.first, a.second) << std::endl; + + t.reset(); + t.start(); + segment_tree_2.enclosing_query(a,std::back_inserter(N)); + t.stop(); + std::cerr << "Enclosing query time t = " << t.time() << std::endl; + + for(std::list::iterator eit = N.begin(); + eit != N.end(); + ++eit) { - std::cerr << (*j).first.x() << "-" << (*j).second.x() << " " - << (*j).first.y() << "-" << (*j).second.y() << std::endl; - j++; + std::cout << Iso_rectangle_2(eit->first, eit->second) << std::endl; } - if(Segment_tree_2.segment_tree_2->is_valid()) - std::cerr << "Tree is valid\n"; + + + if(segment_tree_2.segment_tree_2->is_valid()) + std::cout << "Tree is valid\n"; else - std::cerr << "Tree is not valid\n"; + std::cout << "Tree is not valid\n"; + + return 0; }