mirror of https://github.com/CGAL/cgal
simplifications, added consts
This commit is contained in:
Andreas Fabri
parent
880e9a5dd0
commit
464ecbe586
|
|
@ -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.
|
||||
|
|
|
|||
|
|
@ -109,7 +109,7 @@ protected:
|
|||
// typedef Range_tree_d< C_Data, C_Window, C_Interface> rT_d;
|
||||
Tree_base<C_Data, C_Window> *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<C_Data, C_Window> 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<class T>
|
||||
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;
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -68,7 +68,7 @@ public:
|
|||
typedef tree_point_traits<Key, Interval, Key_1,
|
||||
key_1, low_1, high_1, compare_1> I1;
|
||||
|
||||
typedef tree_anchor<Key, Interval> Tree_anchor_type;
|
||||
typedef Tree_anchor<Key, Interval> Tree_anchor_type;
|
||||
Tree_anchor_type *anchor;
|
||||
|
||||
typedef Range_tree_d<Key, Interval, I1> Range_tree_1_type;
|
||||
|
|
@ -82,16 +82,16 @@ public:
|
|||
}
|
||||
|
||||
template <class T>
|
||||
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 <class T>
|
||||
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<Key, Interval> Tree_anchor_type;
|
||||
typedef Tree_anchor<Key, Interval> Tree_anchor_type;
|
||||
Tree_anchor_type *anchor;
|
||||
|
||||
typedef Range_tree_d<Key, Interval, I2> Range_tree_1_type;
|
||||
|
|
@ -166,8 +166,8 @@ public:
|
|||
{}
|
||||
|
||||
template <class T>
|
||||
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 <class T>
|
||||
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<Key, Interval, Key_3,
|
||||
key_3, low_3, high_3, compare_3> I3;
|
||||
|
||||
typedef tree_anchor<Key, Interval> Tree_anchor_type;
|
||||
typedef Tree_anchor<Key, Interval> Tree_anchor_type;
|
||||
Tree_anchor_type *anchor;
|
||||
|
||||
typedef Range_tree_d<Key, Interval, I3> Range_tree_1_type;
|
||||
|
|
@ -261,8 +261,8 @@ public:
|
|||
{}
|
||||
|
||||
template <class T>
|
||||
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 <class T>
|
||||
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<Key, Interval, Key_4,
|
||||
key_4, low_4, high_4, compare_4> I4;
|
||||
|
||||
typedef tree_anchor<Key, Interval> Tree_anchor_type;
|
||||
typedef Tree_anchor<Key, Interval> Tree_anchor_type;
|
||||
Tree_anchor_type *anchor;
|
||||
|
||||
typedef Range_tree_d<Key, Interval, I4> Range_tree_1_type;
|
||||
|
|
@ -375,8 +375,8 @@ public:
|
|||
{}
|
||||
|
||||
template <class T>
|
||||
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 <class T>
|
||||
bool make_tree(T& first,
|
||||
T& last)
|
||||
bool make_tree(const T& first,
|
||||
const T& last)
|
||||
{
|
||||
delete range_tree_4;
|
||||
delete range_tree_3;
|
||||
|
|
|
|||
|
|
@ -50,34 +50,33 @@ template <class C_Data, class C_Window, class C_Interface>
|
|||
class Segment_tree_d;
|
||||
|
||||
template <class C_Data, class C_Window, class C_Interface>
|
||||
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<C_Data, C_Window> *sublayer;
|
||||
Tree_base<C_Data, C_Window> *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 C_Data, class C_Window, class C_Interface>
|
||||
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<C_Data, C_Window> tbt;
|
||||
typedef Tree_base<C_Data, C_Window> tbt;
|
||||
protected:
|
||||
typedef Segment_tree_d< C_Data, C_Window, C_Interface> sT_d;
|
||||
tree_base<C_Data, C_Window> *sublayer_tree;
|
||||
Tree_base<C_Data, C_Window> *sublayer_tree;
|
||||
|
||||
// type of a vertex
|
||||
// struct segment_tree_node;
|
||||
// struct Segment_tree_node;
|
||||
|
||||
friend class segment_tree_node<C_Data,C_Window,C_Interface>;
|
||||
typedef segment_tree_node<C_Data,C_Window,C_Interface> segment_tree_node_t;
|
||||
typedef segment_tree_node<C_Data,C_Window,C_Interface> *link_type;
|
||||
friend class Segment_tree_node<C_Data,C_Window,C_Interface>;
|
||||
typedef Segment_tree_node<C_Data,C_Window,C_Interface> Segment_tree_node_t;
|
||||
typedef Segment_tree_node<C_Data,C_Window,C_Interface> *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<link_type&>((*x).left_link);
|
||||
static link_type left(link_type x) {
|
||||
return static_cast<link_type>(x->left_link);
|
||||
}
|
||||
static link_type& right(link_type x) {
|
||||
return CGAL__static_cast(link_type&, (*x).right_link);
|
||||
//return static_cast<link_type&>((*x).right_link);
|
||||
static link_type right(link_type x) {
|
||||
return static_cast<link_type>(x->right_link);
|
||||
}
|
||||
static link_type& parent(link_type x) {
|
||||
return CGAL__static_cast(link_type&, (*x).parent_link);
|
||||
//return static_cast<link_type&>( (*x).parent_link);
|
||||
static link_type parent(link_type x) {
|
||||
return static_cast<link_type>( 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<link_type>(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<C_Data, C_Window> *g = sublayer_tree->clone();
|
||||
Tree_base<C_Data, C_Window> *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<C_Data, C_Window> *T = v->sublayer;
|
||||
Tree_base<C_Data, C_Window> *T = v->sublayer;
|
||||
|
||||
std::list< C_Data> tmp_result;
|
||||
std::back_insert_iterator<std::list< C_Data> > 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<C_Data, C_Window> *T = v->sublayer;
|
||||
Tree_base<C_Data, C_Window> *T = v->sublayer;
|
||||
|
||||
std::list< C_Data> tmp_result;
|
||||
std::back_insert_iterator<std::list< C_Data> > 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<C_Data, C_Window> *T=v->sublayer;
|
||||
if(! (*T).is_valid())
|
||||
Tree_base<C_Data, C_Window> *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<C_Data, C_Window> const &sub_tree):
|
||||
sublayer_tree(sub_tree.clone()), is_build(false), header(TREE_BASE_NULL)
|
||||
Segment_tree_d(Tree_base<C_Data, C_Window> 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<C_Data, C_Window> *clone() const {
|
||||
Tree_base<C_Data, C_Window> *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<class A>
|
||||
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<Key> keys(2*c1);
|
||||
std::vector<Key> 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;
|
||||
|
|
|
|||
|
|
@ -63,7 +63,7 @@ public:
|
|||
high_1, compare_1> I1;
|
||||
|
||||
|
||||
typedef tree_anchor<Interval, Interval> Tree_anchor_type;
|
||||
typedef Tree_anchor<Interval, Interval> Tree_anchor_type;
|
||||
Tree_anchor_type *anchor;
|
||||
|
||||
typedef Segment_tree_d<Interval, Interval, I1> Segment_tree_1_type;
|
||||
|
|
@ -75,16 +75,16 @@ public:
|
|||
{}
|
||||
|
||||
template <class T>
|
||||
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 <class T>
|
||||
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<Interval, Interval> Tree_anchor_type;
|
||||
typedef Tree_anchor<Interval, Interval> Tree_anchor_type;
|
||||
Tree_anchor_type *anchor;
|
||||
|
||||
typedef Segment_tree_d<Interval, Interval, I2> Segment_tree_1_type;
|
||||
|
|
@ -164,8 +164,8 @@ public:
|
|||
{}
|
||||
|
||||
template <class T>
|
||||
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 <class T>
|
||||
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<Interval, Interval> Tree_anchor_type;
|
||||
typedef Tree_anchor<Interval, Interval> Tree_anchor_type;
|
||||
Tree_anchor_type *anchor;
|
||||
|
||||
typedef Segment_tree_d<Interval, Interval, I3> Segment_tree_1_type;
|
||||
|
|
@ -270,8 +270,8 @@ public:
|
|||
{}
|
||||
|
||||
template <class T>
|
||||
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 <class T>
|
||||
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<Interval, Interval> Tree_anchor_type;
|
||||
typedef Tree_anchor<Interval, Interval> Tree_anchor_type;
|
||||
Tree_anchor_type *anchor;
|
||||
|
||||
typedef Segment_tree_d<Interval, Interval, I4> Segment_tree_1_type;
|
||||
|
|
@ -392,8 +392,8 @@ public:
|
|||
{}
|
||||
|
||||
template <class T>
|
||||
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 <class T>
|
||||
bool make_tree(T& first,
|
||||
T& last)
|
||||
bool make_tree(const T& first,
|
||||
const T& last)
|
||||
{
|
||||
delete segment_tree_4;
|
||||
delete segment_tree_3;
|
||||
|
|
|
|||
|
|
@ -65,30 +65,17 @@
|
|||
|
||||
CGAL_BEGIN_NAMESPACE
|
||||
|
||||
template <class InIt>
|
||||
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 C_Data, class C_Window>
|
||||
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<C_Data>::iterator lit;
|
||||
//typedef std::back_insert_iterator<lit> lbit;
|
||||
//typedef std::back_insert_iterator<vit> vbit;
|
||||
typedef tree_base<C_Data, C_Window> tree_base_type;
|
||||
tree_base() {}
|
||||
virtual ~tree_base() {}
|
||||
typedef Tree_base<C_Data, C_Window> Tree_base_type;
|
||||
Tree_base() {}
|
||||
virtual ~Tree_base() {}
|
||||
|
||||
// 'clone()' returns an object which can be used as argument to 'delete'
|
||||
virtual tree_base<C_Data, C_Window> *clone() const = 0;
|
||||
//virtual tree_base_type *clone() const = 0;
|
||||
virtual Tree_base<C_Data, C_Window> *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<C_Data>::iterator& beg,
|
||||
typename std::list<C_Data>::iterator& end,
|
||||
virtual bool make_tree(const typename std::list<C_Data>::iterator& beg,
|
||||
const typename std::list<C_Data>::iterator& end,
|
||||
lit *dummy=0) =0;
|
||||
#ifdef stlvector
|
||||
virtual bool make_tree(typename std::vector<C_Data>::iterator& beg,
|
||||
typename std::vector<C_Data>::iterator& end,
|
||||
virtual bool make_tree(const typename std::vector<C_Data>::iterator& beg,
|
||||
const typename std::vector<C_Data>::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<C_Data> >
|
||||
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 C_Data, class C_Window>
|
||||
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<C_Data, C_Window> *clone() const { return new tree_anchor(); }
|
||||
typedef tree_base<C_Data, C_Window> tbt;
|
||||
// tree_base_type *clone() const { return new tree_anchor(); }
|
||||
Tree_anchor() {}
|
||||
virtual ~Tree_anchor(){}
|
||||
Tree_base<C_Data, C_Window> *clone() const { return new Tree_anchor(); }
|
||||
typedef Tree_base<C_Data, C_Window> 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
|
||||
|
|
|
|||
|
|
@ -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
|
||||
|
|
|
|||
|
|
@ -2,12 +2,12 @@
|
|||
#include <CGAL/Simple_cartesian.h>
|
||||
#include <CGAL/Segment_tree_k.h>
|
||||
#include <CGAL/Range_segment_tree_traits.h>
|
||||
#include <CGAL/Timer.h>
|
||||
#include <iostream>
|
||||
#include <utility>
|
||||
#include <vector>
|
||||
#include <iterator>
|
||||
#include <list>
|
||||
|
||||
|
||||
typedef CGAL::Simple_cartesian<double> K;
|
||||
typedef CGAL::Range_segment_tree_set_traits_2<K> Traits;
|
||||
typedef CGAL::Segment_tree_2<Traits > Segment_tree_2_type;
|
||||
|
|
@ -15,9 +15,14 @@ typedef CGAL::Segment_tree_2<Traits > Segment_tree_2_type;
|
|||
typedef K::Point_2 Point_2;
|
||||
typedef K::Iso_rectangle_2 Iso_rectangle_2;
|
||||
typedef std::pair<Point_2, Point_2> Interval;
|
||||
typedef CGAL::Timer Timer;
|
||||
|
||||
int main()
|
||||
{
|
||||
|
||||
Timer t;
|
||||
|
||||
int ignore = 0;
|
||||
std::list<Iso_rectangle_2> rectangles;
|
||||
std::copy(std::istream_iterator<Iso_rectangle_2>(std::cin),
|
||||
std::istream_iterator<Iso_rectangle_2>(),
|
||||
|
|
@ -27,45 +32,67 @@ int main()
|
|||
for(std::list<Iso_rectangle_2>::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<Interval> output, N;
|
||||
|
||||
// creation of the segment tree
|
||||
std::list<Interval>::iterator first = intervals.begin();
|
||||
std::list<Interval>::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<Interval>::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<Interval>::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<Interval>::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;
|
||||
}
|
||||
|
||||
|
|
|
|||
Loading…
Reference in New Issue