C语言实现一个四叉树quadtree

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