C语言实现一个四叉树quadtree
cheungmine
用C语言实现一个2维四叉树quadtree，具有一定的实际意义。你可以把几何图形的索引（用long型的id标识）放到这个树中（根据最小边界矩形）。quadtree可以用来快速区域查找图形，虽然不是那么精确，但是毕竟没有漏掉的。虽然quadtree的效率不如RTree？但是RTree的实现毕竟复杂了些，我会尽快收集整理出RTree的代码。RTree确实比QuadTree好的多？（起码RTree很时髦啊！）
头文件如下：
/*
* quadtree.h
* Quad tree structure -- for spatial quick searching
* cheungmine
* Oct. 5, 2007. All rights reserved.
*/
#ifndef QUADTREE_H_INCLUDED
#define
QUADTREE_H_INCLUDED
#include
"
unistd.h
"
#include
"
list.h
"
#define
QUAD_SUBNODES 4
#define
QBOX_OVERLAP_MAX 0.4
#define
QBOX_OVERLAP_MIN 0.02
#define
QTREE_DEPTH_MAX 8
#define
QTREE_DEPTH_MIN 4
#define
QUADRANT_BITS 3
/*
a quadrant defined below:
NW(1) | NE(0)
-----------|-----------
SW(2) | SE(3)
*/
typedef
enum
{
NE
=
0
,
NW
=
1
,
SW
=
2
,
SE
=
3
}QuadrantEnum;
/*
a box defined below:
_____max
|__|__|
|__|__|
min
*/
typedef
struct
_quadbox_t
{
double
_xmin,
_ymin,
_xmax,
_ymax;
}quadbox_t;
/*
quad node
*/
typedef
struct
_quadnode_t
{
quadbox_t _box;
/*
node bound box
*/
list_t
*
_lst;
/*
node data list
*/
struct
_quadnode_t
*
_sub[QUAD_SUBNODES];
/*
pointer to subnodes of this node
*/
}quadnode_t;
/*
quad tree
*/
typedef
struct
_quadtree_t
{
quadnode_t
*
_root;
int
_depth;
/*
max depth of tree: 0-based
*/
float
_overlap;
/*
overlapped ratio of quanbox
*/
}quadtree_t;
/*
=============================================================================
Public Functions
=============================================================================
*/
/*
creates a quadtree and returns a pointer to it
*/
extern
quadtree_t
*
quadtree_create (quadbox_t box,
int
depth,
/*
4~8
*/
float
overlap
/*
0.02 ~ 0.4
*/
);
/*
destroys a quad tree and free all memory
*/
extern
void
quadtree_destroy (IN quadtree_t
*
qtree
);
/*
inserts a node identified by node_key into a quadtree, returns the node quadtree encoding
*/
extern
quadnode_t
*
quadtree_insert (IN quadtree_t
*
qtree,
IN
long
node_key,
IN quadbox_t
*
node_box
);
/*
searches nodes inside search_box
*/
extern
void
quadtree_search (IN
const
quadtree_t
*
qtree,
IN quadbox_t
*
search_box,
OUT list_t
*
results_list
);
#endif
//
QUADTREE_H_INCLUDED
实现文件如下：
/*
* quadtree.c
* Quad tree implementation -- for spatial quick searching
* cheungmine
* Oct. 5, 2007. All rights reserved.
*/
#include
"
quadtree.h
"
#include
<
assert.h
>
/*
=============================================================================
Private Functions
=============================================================================
*/
static
BOOL quadbox_is_valid (quadbox_t
*
qb)
{
return
(qb
->
_xmin
<
qb
->
_xmax
&&
qb
->
_ymin
<
qb
->
_ymax)
?
TRUE : FALSE;
}
static
double
quadbox_width (
const
quadbox_t
*
qb)
{
return
(qb
->
_xmax
-
qb
->
_xmin);
}
static
double
quadbox_height (
const
quadbox_t
*
qb)
{
return
(qb
->
_ymax
-
qb
->
_ymin);
}
static
void
quadbox_init (quadbox_t
*
qb,
double
xmin,
double
ymin,
double
xmax,
double
ymax)
{
qb
->
_xmin
=
xmin; qb
->
_ymin
=
ymin; qb
->
_xmax
=
xmax; qb
->
_ymax
=
ymax;
assert (quadbox_is_valid (qb) );
}
static
void
quadbox_inflate(quadbox_t
*
qb,
double
dx,
double
dy)
{
assert (dx
>
0
&&
dy
>
0
);
qb
->
_xmin
-=
(dx
/
2
);
qb
->
_xmax
+=
(dx
/
2
);
qb
->
_ymin
-=
(dy
/
2
);
qb
->
_ymax
+=
(dy
/
2
);
}
/*
splits the quadrant such as below:
nw(0010) | ne(0001)
----------|----------
sw(0100) | se(1000)
*/
static
void
quadbox_split(
const
quadbox_t
*
qb,
quadbox_t
*
ne, quadbox_t
*
nw, quadbox_t
*
se, quadbox_t
*
sw,
float
overlap)
{
double
dx
=
quadbox_width(qb)
*
(
1.0
+
overlap)
/
2
;
double
dy
=
quadbox_height(qb)
*
(
1.0
+
overlap)
/
2
;
assert (overlap
>=
QBOX_OVERLAP_MIN
-
0.0001
);
assert (overlap
<=
QBOX_OVERLAP_MAX
+
0.0001
);
quadbox_init (ne, qb
->
_xmax
-
dx, qb
->
_ymax
-
dy, qb
->
_xmax, qb
->
_ymax);
quadbox_init (nw, qb
->
_xmin, qb
->
_ymax
-
dy, qb
->
_xmin
+
dx, qb
->
_ymax);
quadbox_init (sw, qb
->
_xmin, qb
->
_ymin, qb
->
_xmin
+
dx, qb
->
_ymin
+
dy);
quadbox_init (se, qb
->
_xmax
-
dx, qb
->
_ymin, qb
->
_xmax, qb
->
_ymin
+
dy);
}
/*
returns TRUE if the first is inside the senond
*/
static
BOOL quadbox_is_inside(
const
quadbox_t
*
_first,
const
quadbox_t
*
_second)
{
return
(_second
->
_xmin
<
_first
->
_xmin
&&
_second
->
_xmax
>
_first
->
_xmax
&&
_second
->
_ymin
<
_first
->
_ymin
&&
_second
->
_ymax
>
_first
->
_ymax)
?
TRUE : FALSE;
}
/*
returns TRUE if two quad_box is overlapped
*/
static
BOOL quadbox_is_overlapped(
const
quadbox_t
*
_first,
const
quadbox_t
*
_second)
{
return
(_first
->
_xmin
>
_second
->
_xmax
||
_first
->
_xmax
<
_second
->
_xmin
||
_first
->
_ymin
>
_second
->
_ymax
||
_first
->
_ymax
<
_second
->
_ymin)
?
FALSE : TRUE;
}
static
quadnode_t
*
quadnode_create (
const
quadbox_t
*
box)
{
quadnode_t
*
node
=
(quadnode_t
*
) calloc (
1
,
sizeof
(quadnode_t));
if
(node)
memcpy (
&
(node
->
_box), box,
sizeof
(quadbox_t));
return
node;
}
static
void
quadnode_destroy(quadnode_t
*
node)
{
if
(node
->
_sub[NE]
!=
0
){
quadnode_destroy (node
->
_sub[NE]);
quadnode_destroy (node
->
_sub[NW]);
quadnode_destroy (node
->
_sub[SE]);
quadnode_destroy (node
->
_sub[SW]);
}
if
(node
->
_lst)
list_destroy(node
->
_lst, NULL);
free (node);
}
static
void
quadnode_create_child(quadnode_t
*
node,
float
overlap,
int
depth)
{
quadbox_t ne, nw, se, sw;
assert (node);
quadbox_split (
&
(node
->
_box),
&
ne,
&
nw,
&
se,
&
sw, overlap );
node
->
_sub[NE]
=
quadnode_create (
&
ne);
node
->
_sub[NW]
=
quadnode_create (
&
nw);
node
->
_sub[SW]
=
quadnode_create (
&
sw);
node
->
_sub[SE]
=
quadnode_create (
&
se);
}
static
BOOL quadnode_has_child(
const
quadnode_t
*
node)
{
return
(node
->
_sub[NE]
!=
0
);
}
static
BOOL quadnode_has_data (
const
quadnode_t
*
node)
{
return
(node
->
_lst
&&
node
->
_lst
->
size
>
0
)
?
TRUE: FALSE;
}
static
void
quadnode_add_data ( quadnode_t
*
node,
long
node_key )
{
assert (node);
if
(
!
node
->
_lst) node
->
_lst
=
list_create();
assert (node
->
_lst);
list_append_node (node
->
_lst, list_key_create (node_key));
}
/*
inserts a node to parent node of tree. returns pointer to node
*/
static
quadnode_t
*
quadtree_insert_node ( quadtree_t
*
tree,
quadnode_t
*
parent,
long
node_key,
quadbox_t
*
node_box,
int
*
depth
)
{
if
( quadbox_is_inside (node_box,
&
(parent
->
_box)) )
{
if
(
++
(
*
depth)
<
tree
->
_depth )
{
if
(
!
quadnode_has_child ( parent ) )
quadnode_create_child (parent, tree
->
_overlap, (
*
depth));
if
( quadbox_is_inside (node_box,
&
(parent
->
_sub[NE]
->
_box) ) )
return
quadtree_insert_node (tree, parent
->
_sub[NE], node_key, node_box, depth);
if
( quadbox_is_inside (node_box,
&
(parent
->
_sub[NW]
->
_box) ) )
return
quadtree_insert_node (tree, parent
->
_sub[NW], node_key, node_box, depth);
if
( quadbox_is_inside (node_box,
&
(parent
->
_sub[SW]
->
_box) ) )
return
quadtree_insert_node (tree, parent
->
_sub[SW], node_key, node_box, depth);
if
( quadbox_is_inside (node_box,
&
(parent
->
_sub[SE]
->
_box) ) )
return
quadtree_insert_node (tree, parent
->
_sub[SE], node_key, node_box, depth);
}
/*
inserts into this node since it can NOT be included in any subnodes
*/
quadnode_add_data (parent, node_key);
return
parent;
}
return
NULL;
}
/*
searched tree nodes
*/
static
void
quadtree_search_nodes (quadnode_t
*
current_node,
quadbox_t
*
search_box,
list_t
*
results_list
)
{
if
( quadbox_is_overlapped (
&
(current_node
->
_box), search_box ) )
{
if
( quadnode_has_data (current_node) )
list_append_node (results_list, list_node_create(current_node));
if
( quadnode_has_child (current_node) )
{
quadtree_search_nodes (current_node
->
_sub[NE], search_box, results_list);
quadtree_search_nodes (current_node
->
_sub[NW], search_box, results_list);
quadtree_search_nodes (current_node
->
_sub[SW], search_box, results_list);
quadtree_search_nodes (current_node
->
_sub[SE], search_box, results_list);
}
}
}
/*
=============================================================================
Public Functions
=============================================================================
*/
quadtree_t
*
quadtree_create (quadbox_t box,
int
depth,
/*
4~8
*/
float
overlap
/*
0.02 ~ 0.4
*/
)
{
quadtree_t
*
qt
=
NULL;
assert (depth
>=
QTREE_DEPTH_MIN
-
0.0001
&&
depth
<=
QTREE_DEPTH_MAX
+
0.0001
);
assert (overlap
>=
QBOX_OVERLAP_MIN
-
0.0001
&&
overlap
<=
QBOX_OVERLAP_MAX
+
0.0001
);
qt
=
(quadtree_t
*
) calloc (
1
,
sizeof
(quadtree_t));
if
(qt)
{
qt
->
_depth
=
depth;
qt
->
_overlap
=
overlap;
quadbox_inflate (
&
box, quadbox_width(
&
box)
*
overlap, quadbox_height(
&
box)
*
overlap);
qt
->
_root
=
quadnode_create (
&
box);
assert (qt
->
_root);
if
(
!
qt
->
_root)
{
free (qt);
qt
=
NULL;
}
}
assert (qt);
return
qt;
}
/*
destroys a quad tree
*/
void
quadtree_destroy (IN quadtree_t
*
qtree)
{
assert (qtree
&&
qtree
->
_root);
quadnode_destroy (qtree
->
_root);
free (qtree);
}
/*
inserts a node into quadtree and return pointer to new node
*/
quadnode_t
*
quadtree_insert (IN quadtree_t
*
qtree,
IN
long
node_key,
IN quadbox_t
*
node_box
)
{
int
depth
=
-
1
;
return
quadtree_insert_node (qtree, qtree
->
_root, node_key, node_box,
&
depth);
}
/*
searches nodes inside search_box
*/
void
quadtree_search (IN
const
quadtree_t
*
qtree,
IN quadbox_t
*
search_box,
OUT list_t
*
results_list
)
{
quadtree_search_nodes (qtree
->
_root, search_box, results_list);
}
其中用到的文件（list.h，list.c，unistd.h）参考我的另一篇文章：
C语言实现一个简单的单向链表list
