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