四叉树空间索引原理及其实现

最新推荐文章于 2023-12-09 13:00:45 发布
最新推荐文章于 2023-12-09 13:00:45 发布
阅读量1k 收藏 1
点赞数
分类专栏： GIS 文章标签： GIS 四叉树

四叉树索引的基本思想是将地理空间递归划分为不同层次的树结构。它将已知范围的空间等分成四个相等的子空间，如此递归下去，直至树的层次达到一定深度或者满足某种要求后停止分割。四叉树的结构比较简单，并且当空间数据对象分布比较均匀时，具有比较高的空间数据插入和查询效率，因此四叉树是GIS中常用的空间索引之一。常规四叉树的结构如图所示，地理空间对象都存储在叶子节点上，中间节点以及根节点不存储地理空间对象。

 

四叉树示意图

 

四叉树对于区域查询，效率比较高。但如果空间对象分布不均匀，随着地理空间对象的不断插入，四叉树的层次会不断地加深，将形成一棵严重不平衡的四叉树，那么每次查询的深度将大大的增多，从而导致查询效率的急剧下降。

 

本节将介绍一种改进的四叉树索引结构。四叉树结构是自顶向下逐步划分的一种树状的层次结构。传统的四叉树索引存在着以下几个缺点：

(1)空间实体只能存储在叶子节点中，中间节点以及根节点不能存储空间实体信息，随着空间对象的不断插入，最终会导致四叉树树的层次比较深，在进行空间数据窗口查询的时候效率会比较低下。

(2)同一个地理实体在四叉树的分裂过程中极有可能存储在多个节点中，这样就导致了索引存储空间的浪费。

(3)由于地理空间对象可能分布不均衡，这样会导致常规四叉树生成一棵极为不平衡的树，这样也会造成树结构的不平衡以及存储空间的浪费。

相应的改进方法，将地理实体信息存储在完全包含它的最小矩形节点中，不存储在它的父节点中，每个地理实体只在树中存储一次，避免存储空间的浪费。首先生成满四叉树，避免在地理实体插入时需要重新分配内存，加快插入的速度，最后将空的节点所占内存空间释放掉。改进后的四叉树结构如下图所示。四叉树的深度一般取经验值4-7之间为最佳。

 

图改进的四叉树结构

 

为了维护空间索引与对存储在文件或数据库中的空间数据的一致性，作者设计了如下的数据结构支持四叉树的操作。

(1)四分区域标识

分别定义了一个平面区域的四个子区域索引号，右上为第一象限0，左上为第二象限1，左下为第三象限2，右下为第四象限3。

typedef enum

{

      UR = 0,// UR第一象限

      UL = 1, // UL为第二象限

      LL = 2, // LL为第三象限

      LR = 3  // LR为第四象限

}QuadrantEnum;

(2)空间对象数据结构

空间对象数据结构是对地理空间对象的近似，在空间索引中，相当一部分都是采用MBR作为近似。

/*空间对象MBR信息*/

typedef struct SHPMBRInfo

{

      int nID;       //空间对象ID号

      MapRect Box;    //空间对象MBR范围坐标

}SHPMBRInfo;

nID是空间对象的标识号，Box是空间对象的最小外包矩形（MBR）。

(3)四叉树节点数据结构

四叉树节点是四叉树结构的主要组成部分，主要用于存储空间对象的标识号和MBR，也是四叉树算法操作的主要部分。

/*四叉树节点类型结构*/

typedef struct QuadNode

{

      MapRect            Box;                   //节点所代表的矩形区域

      int                nShpCount;        //节点所包含的所有空间对象个数

      SHPMBRInfo* pShapeObj;          //空间对象指针数组

      int         nChildCount;            //子节点个数

      QuadNode *children[4];             //指向节点的四个孩子

}QuadNode;

Box是代表四叉树对应区域的最小外包矩形，上一层的节点的最小外包矩形包含下一层最小外包矩形区域；nShpCount代表本节点包含的空间对象的个数；pShapeObj代表指向空间对象存储地址的首地址，同一个节点的空间对象在内存中连续存储；nChildCount代表节点拥有的子节点的数目；children是指向孩子节点指针的数组。

上述理论部分都都讲的差不多了，下面就贴上我的C语言实现版本代码。

头文件如下：

#pragma once
#include <vector>
#include "ogrsf_frmts.h"
#include "ogr_core.h"
using namespace std;


#ifndef _POINTD
#define _POINTD
typedef struct tagPOINTD
{
	double x;
	double y;
}POINTD;
#endif // _POINTD

/* 一个矩形区域的象限划分：:

UL(1)   |    UR(0)
----------|-----------
LL(2)   |    LR(3)
以下对该象限类型的枚举
*/
typedef enum
{
	UR = 0,
	UL = 1,
	LL = 2,
	LR = 3
}QuadrantEnum;

/*空间对象MBR信息*/
typedef struct SHPMBRInfo
{
	long nID;		//空间对象ID号
	OGREnvelope envelope;	//空间对象MBR范围坐标
}SHPMBRInfo;

/* 四叉树节点类型结构 */
typedef struct QuadNode
{
	OGREnvelope	envelope;		//节点所代表的矩形区域
	int			nShpCount;		//节点所包含的所有空间对象个数
	SHPMBRInfo* pShapeObj;		//空间对象指针数组
	int			nChildCount;	//子节点个数
	QuadNode  *children[4];		//指向节点的四个孩子 
}QuadNode;

/* 四叉树类型结构 */
typedef struct quadtree_t
{
	QuadNode  *root;
	int         depth;           // 四叉树的深度                    
}QuadTree;


//初始化四叉树节点
QuadNode *InitQuadNode();

//层次创建四叉树方法（满四叉树）
void CreateQuadTree(int depth,OGRLayer *poLayer,QuadTree* pQuadTree);

//创建各个分支
void CreateQuadBranch(int depth,OGREnvelope &rect,QuadNode** node);

//构建四叉树空间索引
void BuildQuadTree(OGRLayer*poLayer,QuadTree* pQuadTree);

//四叉树索引查询(矩形查询)
void SearchQuadTree(QuadNode* node,OGREnvelope &queryRect,vector<long>& ItemSearched);

//四叉树索引查询(矩形查询)并行查询
void SearchQuadTreePara(vector<QuadNode*> resNodes,OGREnvelope &queryRect,vector<long>& ItemSearched);

//四叉树的查询（点查询）
void PtSearchQTree(QuadNode* node,double cx,double cy,vector<long>& ItemSearched);

//将指定的空间对象插入到四叉树中
void Insert(long key,OGREnvelope &itemRect,QuadNode* pNode);

//将指定的空间对象插入到四叉树中
void InsertQuad(long key,OGREnvelope &itemRect,QuadNode* pNode);

//将指定的空间对象插入到四叉树中
void InsertQuad2(long key,OGREnvelope &itemRect,QuadNode* pNode);

//判断一个节点是否是叶子节点
bool IsQuadLeaf(QuadNode* node);

//删除多余的节点
bool DelFalseNode(QuadNode* node);

//四叉树遍历(所有要素)
void TraversalQuadTree(QuadNode* quadTree,vector<long>& resVec);

//四叉树遍历（所有节点）
void TraversalQuadTree(QuadNode* quadTree,vector<QuadNode*>& arrNode);

//释放树的内存空间
void ReleaseQuadTree(QuadNode** quadTree);

//计算四叉树所占的字节的大小
long CalByteQuadTree(QuadNode* quadTree,long& nSize);

void split(OGREnvelope origin,OGREnvelope target[]);

bool IsPointInRect(OGREnvelope envelope,POINTD point);

bool IsPointInRect(OGREnvelope envelope,double cx,double cy);



源文件如下： 
<pre name="code" class="cpp">#include "StdAfx.h"
#include <assert.h>
#include <algorithm>
#include <deque>
#include "QuadTree.h"

QuadNode *InitQuadNode()
{
	QuadNode *node = new QuadNode;
	node->envelope.MaxX = 0;
	node->envelope.MaxY = 0;
	node->envelope.MinX = 0;
	node->envelope.MinY = 0;

	for (int i = 0; i < 4; i ++)
	{
		node->children[i] = NULL;
	}
	node->nChildCount = 0;
	node->nShpCount = 0;
	node->pShapeObj = NULL;

	return node;
}

void CreateQuadTree(int depth,OGRLayer *poLayer,QuadTree* pQuadTree)
{
	pQuadTree->depth = depth;

	OGREnvelope env;	//整个图层的MBR
	poLayer->GetExtent(&env);
	
	OGREnvelope rect;
	rect.MinX = env.MinX;
	rect.MinY = env.MinY;
	rect.MaxX = env.MaxX;
	rect.MaxY = env.MaxY;
	
	//创建各个分支
	CreateQuadBranch(depth,rect,&(pQuadTree->root));

	int nCount = poLayer->GetFeatureCount();
	OGRFeature **pFeatureClass = new OGRFeature*[nCount];
	for (int i = 0; i < poLayer->GetFeatureCount(); ++i)
	{
		pFeatureClass[i] = poLayer->GetFeature(i);
	}

	//插入各个要素
	OGREnvelope envObj;	//空间对象的MBR
	//#pragma omp parallel for
	for (int i = 0; i < nCount; ++i)
	{
		pFeatureClass[i]->GetGeometryRef()->getEnvelope(&envObj);
		rect.MinX = envObj.MinX;
		rect.MinY = envObj.MinY;
		rect.MaxX = envObj.MaxX;
		rect.MaxY = envObj.MaxY;
		InsertQuad(i,rect,pQuadTree->root);
	}

	//DelFalseNode(pQuadTree->root);
}

void CreateQuadBranch(int depth,OGREnvelope &rect,QuadNode** node)
{
	if (depth != 0)
	{
		*node = InitQuadNode();	//创建树根
		QuadNode *pNode = *node;
		pNode->envelope = rect;
		pNode->nChildCount = 4;

		OGREnvelope boxs[4];
		split(pNode->envelope,boxs);
		for (int i = 0; i < 4; ++i)
		{
			//创建四个节点并插入相应的MBR
			pNode->children[i] = InitQuadNode();
			pNode->children[i]->envelope = boxs[i];

			CreateQuadBranch(depth-1,boxs[i],&(pNode->children[i]));
		}
	}
}

void BuildQuadTree(OGRLayer *poLayer,QuadTree* pQuadTree)
{
	assert(poLayer);
	OGREnvelope env;	//整个图层的MBR
	poLayer->GetExtent(&env);
	pQuadTree->root = InitQuadNode();

	QuadNode* rootNode = pQuadTree->root;

	rootNode->envelope.MinX = env.MinX;
	rootNode->envelope.MinY = env.MinY;
	rootNode->envelope.MaxX = env.MaxX;
	rootNode->envelope.MaxY = env.MaxY;

	//设置树的深度(	根据等比数列的求和公式)
	//pQuadTree->depth = log(poLayer->GetFeatureCount()*3/8.0+1)/log(4.0);
	int nCount = poLayer->GetFeatureCount();

	OGREnvelope envObj;	//空间对象的MBR
	for (int i = 0; i < nCount; ++i)
	{
		poLayer->GetFeature(i)->GetGeometryRef()->getEnvelope(&envObj);
		InsertQuad2(i,envObj,rootNode);
		printf("Shape:%d\n",i);
	}

	DelFalseNode(pQuadTree->root);
}

void SearchQuadTree(QuadNode* node,OGREnvelope &queryRect,vector<long>& ItemSearched)
{
	assert(node);

	//int coreNum = omp_get_num_procs();
	//vector<int> * pResArr = new vector<int>[coreNum];

	if (NULL != node)
	{
		for (int i = 0; i < node->nShpCount; ++i)
		{
			if (queryRect.Contains(node->pShapeObj[i].envelope)
				|| queryRect.Intersects(node->pShapeObj[i].envelope))
			{
				ItemSearched.push_back(node->pShapeObj[i].nID);
			}
		}

		//并行搜索四个孩子节点
		/*#pragma omp parallel sections
		{
			#pragma omp section
			if ((node->children[0] != NULL) && 
				(node->children[0]->Box.Contains(queryRect)
				|| node->children[0]->Box.Intersects(queryRect)))
			{
				int tid = omp_get_thread_num();
				SearchQuadTree(node->children[0],queryRect,pResArr[tid]);
			}

			#pragma omp section
			if ((node->children[1] != NULL) && 
				(node->children[1]->Box.Contains(queryRect)
				|| node->children[1]->Box.Intersects(queryRect)))
			{
				int tid = omp_get_thread_num();
				SearchQuadTree(node->children[1],queryRect,pResArr[tid]);
			}

			#pragma omp section
			if ((node->children[2] != NULL) && 
				(node->children[2]->Box.Contains(queryRect)
				|| node->children[2]->Box.Intersects(queryRect)))
			{
				int tid = omp_get_thread_num();
				SearchQuadTree(node->children[2],queryRect,pResArr[tid]);
			}

			#pragma omp section
			if ((node->children[3] != NULL) && 
				(node->children[3]->Box.Contains(queryRect)
				|| node->children[3]->Box.Intersects(queryRect)))
			{
				int tid = omp_get_thread_num();
				SearchQuadTree(node->children[3],queryRect,pResArr[tid]);
			}
		}*/
		for (int i = 0; i < 4; ++i)
		{
			if ((node->children[i] != NULL) && 
				(node->children[i]->envelope.Contains(queryRect)
				|| node->children[i]->envelope.Intersects(queryRect)))
			{
				SearchQuadTree(node->children[i],queryRect,ItemSearched);
				//node = node->children[i];	//非递归
			}
		}
	}

	/*for (int i = 0 ; i < coreNum; i ++)
	{
		ItemSearched.insert(ItemSearched.end(),pResArr[i].begin(),pResArr[i].end());
	}*/

}

void SearchQuadTreePara(vector<QuadNode*> resNodes,OGREnvelope &queryRect,vector<long>& ItemSearched)
{
// 	int coreNum = omp_get_num_procs();
// 	omp_set_num_threads(coreNum);
// 	vector<int>* searchArrs = new vector<int>[coreNum];
// 	for (int i = 0; i < coreNum; i ++)
// 	{
// 		searchArrs[i].clear();
// 	}
// 
// 	#pragma omp parallel for
// 	for (int i = 0; i < (int)resNodes.size(); i ++)
// 	{
// 		int tid = omp_get_thread_num();
// 		for (int j = 0; j < resNodes[i]->nShpCount; j ++)
// 		{
// 			if (queryRect.Contains(resNodes[i]->pShapeObj[j].envelope)
// 				|| queryRect.Intersects(resNodes[i]->pShapeObj[j].envelope))
// 			{
// 				searchArrs[tid].push_back(resNodes[i]->pShapeObj[j].nID);
// 			}
// 		}
// 	}
// 
// 	for (int i = 0; i < coreNum; i ++)
// 	{
// 		ItemSearched.insert(ItemSearched.end(),
// 			searchArrs[i].begin(),searchArrs[i].end());
// 	}
// 
// 	delete [] searchArrs;
// 	searchArrs = NULL;
	vector<long> searchArrs;

	for (int i = 0; i < (int)resNodes.size(); ++i)
	{
		for (int j = 0; j < resNodes[i]->nShpCount; ++j)
		{
			if (queryRect.Contains(resNodes[i]->pShapeObj[j].envelope)
				|| queryRect.Intersects(resNodes[i]->pShapeObj[j].envelope))
			{
				searchArrs.push_back(resNodes[i]->pShapeObj[j].nID);
			}
		}
	}

	ItemSearched.insert(ItemSearched.end(),	searchArrs.begin(),searchArrs.end());
}

void PtSearchQTree(QuadNode* node,double cx,double cy,vector<long>& ItemSearched)
{
	assert(node);
	if (node->nShpCount >0)		//节点
	{
		for (int i = 0; i < node->nShpCount; ++i)
		{
			if (IsPointInRect(node->pShapeObj[i].envelope,cx,cy))
			{
				ItemSearched.push_back(node->pShapeObj[i].nID);
			}
		}
	}
	else if (node->nChildCount >0)				//子节点
	{
		for (int i = 0; i < 4; ++i)
		{
			if (IsPointInRect(node->children[i]->envelope,cx,cy))
			{
				PtSearchQTree(node->children[i],cx,cy,ItemSearched);
			}
		}
	}

	//找出重复元素的位置
	sort(ItemSearched.begin(),ItemSearched.end());	//先排序,默认升序
	vector<long>::iterator unique_iter = 
		unique(ItemSearched.begin(),ItemSearched.end());
	ItemSearched.erase(unique_iter,ItemSearched.end());
}

void Insert(long key, OGREnvelope &itemRect,QuadNode* pNode)
{
	QuadNode *node = pNode;		//保留根节点副本
	SHPMBRInfo pShpInfo;
	
	//节点有孩子
	if (0 < node->nChildCount)
	{
		for (int i = 0; i < 4; ++i)
		{  
			//如果包含或相交，则将节点插入到此节点
			if (node->children[i]->envelope.Contains(itemRect)
				|| node->children[i]->envelope.Intersects(itemRect))
			{
				//node = node->children[i];
				Insert(key,itemRect,node->children[i]);
			}
		}
	}
	else if (1 == node->nShpCount)//如果当前节点存在一个子节点时
	{
		OGREnvelope boxs[4];
		split(node->envelope,boxs);

		//创建四个节点并插入相应的MBR
		node->children[UR] = InitQuadNode();
		node->children[UL] = InitQuadNode();
		node->children[LL] = InitQuadNode();
		node->children[LR] = InitQuadNode();

		node->children[UR]->envelope = boxs[0];
		node->children[UL]->envelope = boxs[1];
		node->children[LL]->envelope = boxs[2];
		node->children[LR]->envelope = boxs[3];
		node->nChildCount = 4;

		for (int i = 0; i < 4; ++i)
		{  
			//将当前节点中的要素移动到相应的子节点中
			for (int j = 0; j < node->nShpCount; j ++)
			{
				if (node->children[i]->envelope.Contains(node->pShapeObj[j].envelope)
					|| node->children[i]->envelope.Intersects(node->pShapeObj[j].envelope))
				{
					++node->children[i]->nShpCount;
					node->children[i]->pShapeObj = 
						(SHPMBRInfo*)malloc(node->children[i]->nShpCount*sizeof(SHPMBRInfo));
					
					memcpy(node->children[i]->pShapeObj,&(node->pShapeObj[j]),sizeof(SHPMBRInfo));

					free(node->pShapeObj);
					node->pShapeObj = NULL;
					node->nShpCount = 0;
				}
			}
		}

		for (int i = 0; i < 4; i ++)
		{  
			//如果包含或相交，则将节点插入到此节点
			if (node->children[i]->envelope.Contains(itemRect)
				|| node->children[i]->envelope.Intersects(itemRect))
			{
				pShpInfo.envelope = itemRect;
				pShpInfo.nID = key;
				if (node->children[i]->nShpCount == 0)	 //如果之前没有节点
				{
					++node->children[i]->nShpCount;
					node->children[i]->pShapeObj = 
						(SHPMBRInfo*)malloc(sizeof(SHPMBRInfo)*node->children[i]->nShpCount);
				}
				else if	(node->children[i]->nShpCount > 0)
				{
					++node->children[i]->nShpCount;
					node->children[i]->pShapeObj = 
						(SHPMBRInfo *)realloc(node->children[i]->pShapeObj,
						sizeof(SHPMBRInfo)*node->children[i]->nShpCount);
				}
				memcpy(node->children[i]->pShapeObj,&pShpInfo,sizeof(SHPMBRInfo));
			}
		}
	}	
	else if (0 == node->nShpCount)//当前节点没有空间对象
	{
		++node->nShpCount;
		node->pShapeObj = 
			(SHPMBRInfo*)malloc(sizeof(SHPMBRInfo)*node->nShpCount);

		pShpInfo.envelope = itemRect;
		pShpInfo.nID = key;
		memcpy(node->pShapeObj,&pShpInfo,sizeof(SHPMBRInfo));
	}
}

void InsertQuad(long key,OGREnvelope &itemRect,QuadNode* pNode)
{
	assert(pNode != NULL);

	if (!IsQuadLeaf(pNode))	   //非叶子节点
	{
		int nCorver = 0;		//跨越的子节点个数
		int iIndex = -1;		//被哪个子节点完全包含的索引号
		for (int i = 0; i < 4; ++i)
		{
			if (pNode->children[i]->envelope.Contains(itemRect)
				&& pNode->envelope.Contains(itemRect))
			{
				++nCorver;
				iIndex = i;
			}
		}

		//如果被某一个子节点包含，则进入该子节点
		if (/*pNode->Box.Contains(itemRect) || 
			pNode->Box.Intersects(itemRect)*/1 <= nCorver)
		{ 
			InsertQuad(key,itemRect,pNode->children[iIndex]);
		}

		//如果跨越了多个子节点，直接放在这个节点中
		else if (nCorver == 0)
		{
			if (pNode->nShpCount == 0)	 //如果之前没有节点
			{
				++pNode->nShpCount;
				pNode->pShapeObj = 
					(SHPMBRInfo*)malloc(sizeof(SHPMBRInfo)*pNode->nShpCount);
			}
			else
			{
				++pNode->nShpCount;
				pNode->pShapeObj = 
					(SHPMBRInfo *)realloc(pNode->pShapeObj,sizeof(SHPMBRInfo)*pNode->nShpCount);
			}

			SHPMBRInfo pShpInfo;
			pShpInfo.envelope = itemRect;
			pShpInfo.nID = key;
			memcpy(pNode->pShapeObj+pNode->nShpCount-1,&pShpInfo,sizeof(SHPMBRInfo));
		}
	}	
	else if (IsQuadLeaf(pNode))//如果是叶子节点，直接放进去
	{
		if (pNode->nShpCount == 0)	 //如果之前没有节点
		{
			++pNode->nShpCount;
			pNode->pShapeObj = 
				(SHPMBRInfo*)malloc(sizeof(SHPMBRInfo)*pNode->nShpCount);
		}
		else
		{
			++pNode->nShpCount;
			pNode->pShapeObj = 
				(SHPMBRInfo *)realloc(pNode->pShapeObj,sizeof(SHPMBRInfo)*pNode->nShpCount);
		}

		SHPMBRInfo pShpInfo;
		pShpInfo.envelope = itemRect;
		pShpInfo.nID = key;
		memcpy(pNode->pShapeObj+pNode->nShpCount-1,&pShpInfo,sizeof(SHPMBRInfo));
	}
}

void InsertQuad2(long key,OGREnvelope &itemRect,QuadNode* pNode)
{
	QuadNode *node = pNode;		//保留根节点副本
	SHPMBRInfo pShpInfo;

	//节点有孩子
	if (0 < node->nChildCount)
	{
		for (int i = 0; i < 4; ++i)
		{  
			//如果包含或相交，则将节点插入到此节点
			if (node->children[i]->envelope.Contains(itemRect)
				|| node->children[i]->envelope.Intersects(itemRect))
			{
				//node = node->children[i];
				Insert(key,itemRect,node->children[i]);
			}
		}
	}	
	else if (0 == node->nChildCount)//如果当前节点存在一个子节点时
	{
		OGREnvelope boxs[4];
		split(node->envelope,boxs);

		int cnt = -1;
		for (int i = 0; i < 4; ++i)
		{  
			//如果包含或相交，则将节点插入到此节点
			if (boxs[i].Contains(itemRect))
			{
				cnt = i;
				break;
			}
		}

		//如果有一个矩形包含此对象，则创建四个孩子节点
		if (cnt > -1)
		{
			for (int i = 0; i < 4; ++i)
			{
				//创建四个节点并插入相应的MBR
				node->children[i] = InitQuadNode();
				node->children[i]->envelope = boxs[i];
			}
			node->nChildCount = 4;
			InsertQuad2(key,itemRect,node->children[cnt]);	//递归
		}
		else if (cnt == -1)//如果都不包含，则直接将对象插入此节点
		{
			if (node->nShpCount == 0)	 //如果之前没有节点
			{
				++node->nShpCount;
				node->pShapeObj = (SHPMBRInfo*)malloc(sizeof(SHPMBRInfo)*node->nShpCount);
			}
			else if	(node->nShpCount > 0)
			{
				++node->nShpCount;
				node->pShapeObj = 
					(SHPMBRInfo *)realloc(node->pShapeObj,sizeof(SHPMBRInfo)*node->nShpCount);
			}

			pShpInfo.envelope = itemRect;
			pShpInfo.nID = key;
			memcpy(node->pShapeObj,&pShpInfo,sizeof(SHPMBRInfo));
		}
	}

	//当前节点没有空间对象
	/*else if (0 == node->nShpCount)
	{
		node->nShpCount += 1;
		node->pShapeObj = 
			(SHPMBRInfo*)malloc(sizeof(SHPMBRInfo)*node->nShpCount);

		pShpInfo.Box = itemRect;
		pShpInfo.nID = key;
		memcpy(node->pShapeObj,&pShpInfo,sizeof(SHPMBRInfo));
	}*/
}

bool IsQuadLeaf(QuadNode* node)
{
	if (NULL == node)
	{
		return 1;
	}
	for (int i = 0; i < 4; ++i)
	{
		if (node->children[i] != NULL)
		{
			return 0;
		}
	}

	return true;
}

bool DelFalseNode(QuadNode* node)
{
	//如果没有子节点且没有要素
	if (node->nChildCount ==0 && node->nShpCount == 0)
	{
		ReleaseQuadTree(&node);
	}
	else if (node->nChildCount > 0)//如果有子节点
	{
		for (int i = 0; i < 4; ++i)
		{
			DelFalseNode(node->children[i]);
		}
	}

	return true;
}

void TraversalQuadTree(QuadNode* quadTree,vector<long>& resVec)
{
	QuadNode *node = quadTree;
	int i = 0; 
	if (NULL != node)
	{
		//将本节点中的空间对象存储数组中
		for (i = 0; i < node->nShpCount; ++i)
		{
			resVec.push_back((node->pShapeObj+i)->nID);
		}

		//遍历孩子节点
		for (i = 0; i < node->nChildCount; ++i)
		{
			if (node->children[i] != NULL)
			{
				TraversalQuadTree(node->children[i],resVec);
			}
		}
	}
}

void TraversalQuadTree(QuadNode* quadTree,vector<QuadNode*>& arrNode)
{
	deque<QuadNode*> nodeQueue;
	if (quadTree != NULL)
	{
		nodeQueue.push_back(quadTree);
		while (!nodeQueue.empty())
		{
			QuadNode* queueHead = nodeQueue.at(0);	//取队列头结点
			arrNode.push_back(queueHead);
			nodeQueue.pop_front();
			for (int i = 0; i < 4; ++i)
			{
				if (queueHead->children[i] != NULL)
				{
					nodeQueue.push_back(queueHead->children[i]);
				}
			}
		}
	}
}

void ReleaseQuadTree(QuadNode** quadTree)
{
	int i = 0;
	QuadNode* node = *quadTree;
	if (NULL == node)
	{
		return;
	}
	else
	{
		for (i = 0; i < 4; ++i)
		{ 
			ReleaseQuadTree(&node->children[i]);
		}
		free(node);
		node = NULL;
	}

	node = NULL;
}

long CalByteQuadTree(QuadNode* quadTree,long& nSize)
{
	if (quadTree != NULL)
	{
		nSize += sizeof(QuadNode)+quadTree->nChildCount*sizeof(SHPMBRInfo);
		for (int i = 0; i < 4; ++i)
		{
			if (quadTree->children[i] != NULL)
			{
				nSize += CalByteQuadTree(quadTree->children[i],nSize);
			}
		}
	}

	return 1;
}

void split( OGREnvelope origin,OGREnvelope target[] )
{
	double width = origin.MaxX-origin.MinX;
	double height = origin.MaxY-origin.MinY;

	target[0].MinX = target[1].MaxX = target[2].MaxX = target[3].MinX = origin.MinX+width/2;
	target[0].MaxX = target[3].MaxX = origin.MaxX;
	target[1].MinX = target[2].MinX = origin.MinX;

	target[0].MaxY = target[1].MaxY = target[2].MinY = target[3].MinY = origin.MinY+height/2;
	target[0].MinY = target[1].MinY = origin.MinY;
	target[2].MaxY = target[3].MaxY = origin.MaxY;
}

bool IsPointInRect( OGREnvelope envelope,POINTD point )
{
	if (envelope.MinX > point.x || envelope.MaxX < point.x || envelope.MinY > point.y || envelope.MaxY < point.y)
	{
		return false;
	}
	return true;
}

bool IsPointInRect( OGREnvelope envelope,double cx,double cy )
{
	if (envelope.MinX > cx || envelope.MaxX < cx || envelope.MinY > cy || envelope.MaxY < cy)
	{
		return false;
	}
	return true;
}
 

 
代码有点长，有需要的朋友可以借鉴并自己优化。 


                

        

        

    




    

      

        

            

              
                
                  lggrief
                
              
            

            

                关注
              
            

        

        

          
    
            
  • 
              
                
                
                
                
                      0
                
              
              
    点赞
    
            
    • 
            
  • 
              
                
                
                
              
              
    踩
    
            
    • 
            
  • 
              
                
                
                
                
                    1
                
              
              
    
                
    
                  
                    收藏
                  
                
    
              
    
              
    
                
    
                  觉得还不错?
                  
                    一键收藏
                  
                 
                
    
              
    
            
    • 
          
  • 
            
    
              
              
            
    
              
              
              
                    0
              
            
            
    评论
    
          
    • 
          
  • 
          
    • 
          
  • 
            
              
            
              
    
            
              
                
            
    
          
    • 
        

      

      

            

                专栏目录
          










                



	

		

			

				
					
四叉树与八叉树

				
			

			

				

					花心龟 cabin
				

				

					08-21
					
					5万+
					
				

			

		

		

			
				
前序
四叉树或四元树也被称为Q树（Q-Tree）。四叉树广泛应用于图像处理、空间数据索引、2D中的快速碰撞检测、存储稀疏数据等，而八叉树（Octree）主要应用于3D图形处理。对游戏编程，这会很有用。本文着重于对四叉树与八叉树的原理与结构的介绍，帮助您在脑海中建立四叉树与八叉树

			
		

	



                

              
                



	

		

			

				
					
C#几何算法：空间索引——Quadtree四叉树及应用（一）

				
			

			

				

					petergoing的博客
				

				

					05-12
					
					3821
					
				

			

		

		

			
				
最近在CAD中开发拓扑检查和空间分析功能时发现，传统的双层递归法会极大的降低程序运行速度，就比如：图上有1000个图形，我们要求图形之间的交点，传统的作法就是遍历两次图形，在两次循环中分别对图形求交处理，对于图形较少的情况，传统的双层递归法也不会太多的影响程序的效率，但是如果图上有10000个图形，或者更多图形呢？按照传统的双层递归法来运算显然是不太可能的，可能会直接导致CAD无响应，大幅度影响计算效率。为了解决这个问题，针对大量图形进行空间运算的时候就必须用到空间索引了。等，我们今天要讲的就是。

			
		

	



                


  
              

                


	

		

			

				
					
莫顿曲线映射 二维到一维的变换 MD（莫顿）码 正向变换 线性四叉树

				
			

			

				

					qq_69574549的博客
				

				

					06-12
					
					3800
					
				

			

		

		

			
				
线性四叉树是基于莫顿码的一种四叉树实现方式，它将二维空间划分为一系列正方形区域，并将每个区域标记为叶子节点。每个叶子节点对应着一个莫顿码，通过莫顿码的前缀匹配可以快速定位到对应的叶子节点。线性四叉树的节点可以压缩为一个连续的数组，因此可以实现高效的存储和访问。莫顿码是一种将二维坐标映射为一维编码的方法，它将一个二维点的坐标表示为一个整数，使得相邻的二维点在一维空间中的编码也相邻。（Linear Quadtree）是一种基于莫顿码（Morton Code）的数据结构，用于存储和处理二维空间中的信息。

			
		

	





	

		

			

				
					
建立四叉树

					
最新发布

				
			

			

				

					weixin_36670529的博客
				

				

					12-09
					
					1001
					
				

			

		

		

			
				
如果是，那么这一部分对应的是一个叶节点，我们构造出对应的叶节点并结束递归；如果不是，那么这一部分对应的是一个非叶节点，我们需要将其分成四个部分：行的分界线为。，根据这两条分界线递归地调用 dfs\text{dfs}dfs 函数得到四个部分对应的树，再将它们对应地挂在非叶节点的四个子节点上。，那么说明这一部分包含的元素大部分都是相同的，也就是说，有很大概率在深入递归时遇到元素完全相同的一部分，从而提前结束递归。的数组需要的时间复杂度，那么「判定这一部分是否均为。，即为递归需要使用的栈空间。

			
		

	



		

			
		



	

		

			

				
					
四叉树分类

				
			

			

				

					jtabibito's blog
				

				

					06-06
					
					2136
					
				

			

		

		

			
				
四叉树是一种空间划分树，每个节点最多有四个子树的数据结构。
主要应用于:


场景管理:
特别适合大规模的广阔室外场景管理。
一般来说如果游戏场景是基于地形的（甚至没有高度）（如城市、平原、2D场景），那么适合用四叉树来管理。
而如果游戏场景在高度轴上也有大量物体需要管理（如太空、高山），那么适合用八叉树来管理。


感知检测
如图所示，假如保证一个（图中为绿色⚪）智能体最远不会感知到所在区域外的地方。
那么通过四叉树，可以快速过滤掉K区域外的红色目标，只需考虑K区域内的红色目标。


碰撞检测
类似上面感

			
		

	





	

		

			

				
					
四叉树实现碰撞检测、坐标点查找与比对，如果是坐标组，那么需要另外定义插入的规则，该Demo代码示例针对的是单个坐标点。

				
			

			

				

					04-09
				

			

		

		

			
				
四叉树（Quadtree）是一种数据结构，特别适用于在二维空间中组织和管理对象，尤其在处理图形和图像处理领域，如碰撞检测、坐标查找和比对等方面具有显著优势。四叉树是二叉树的扩展，每个节点都有四个子节点，分别...

			
		

	





	

		

			

				
					
基于Oracle Spatial的空间数据索引.pdf

				
			

			

				

					10-10
				

			

		

		

			
				
主要的两种空间索引是R树索引和四叉树索引。  1. R树索引：R树是一种多维索引结构，适合处理多边形和复杂的几何对象。它允许索引的数据项在多个维度上重叠，从而有效处理空间查询中的覆盖、邻近等操作。R树通过将...

			
		

	





	

		

			

				
					
QuadTree:C# https 中 QuadTree 实现的 Github 镜像

				
			

			

				

					07-05
				

			

		

		

			
				
四叉树（QuadTree）是一种数据结构，特别适用于在二维空间中组织和查询对象，它将平面分成四个相等的子区域，每个子区域可以进一步分割，直到满足特定条件为止。这种分治策略使得四叉树成为处理地理信息系统、图像...

			
		

	





	

		

			

				
					
空间数据库讲义

				
			

			

				

					11-01
				

			

		

		

			
				
第四章可能涉及“空间数据模型”，其中会介绍点、线、面等基本空间元素的表示方法，以及更复杂的拓扑关系模型，如R树、四叉树等索引结构，用于高效的空间查询和分析。  第五章可能探讨“空间数据的存储与索引”，...

			
		

	





	

		

			

				
					
空间数据库

				
			

			

				

					02-26
				

			

		

		

			
				
这部分可能讨论了如何高效地存储空间对象，以及利用空间索引来加速空间查询，如R树和四叉树等空间索引结构。  5. **空间查询语言**（4-空间查询语言.ppt）：空间数据库支持扩展的SQL，允许用户进行复杂的地理空间...

			
		

	





	

		

			

				
					
四叉树索引

				
			

			

				

					sjzwl的专栏
				

				

					10-06
					
					5374
					
				

			

		

		

			
				
 四叉树索引（Quadtree），类似于前面介绍的网格索引,也是对地理空间进行网格划分，对地理空间递归进行四分来构建四叉树，本文将在普通四叉树的基础上，介绍一种改进的四叉树索引结构。       首先，先介绍一个GIS（Geographic Information System）或者计算机图形学上非常重要的概念——最小外包矩形(MBR-Minimum Bounding Rectangle)

			
		

	





	

		

			

				
					
四叉树是干什么的？

				
			

			

				

					Itmylove8的博客
				

				

					06-19
					
					1669
					
				

			

		

		

			
				
四元树又称四叉树是一种树状数据结构，在每一个节点上会有四个子区块。四元树常应用于二维空间数据的分析与分类。 它将数据区分成为四个象限。数据范围可以是方形或矩形或其他任意形状。
从定义我们可以看出重点信息：
树状结构
四个区块
分类
矩形
图示讲解
讲解之前需要先说明一下四叉树是用来做什么的，明白了原理才好理解它的行为。
使用四叉树就是使用分类的方法，减少碰撞节点的个数，只取出与给定碰撞体相同区域或者压在碰撞体所在区域边上的对象。
将游戏屏幕分为四个区域。
插入对象
插入的对象超过了我们设置的阈值时，划分
插

			
		

	





	

		

			

				
					
HEVC中四叉树划分详解

				
			

			

				

					小小柴的博客
				

				

					01-16
					
					6216
					
				

			

		

		

			
				
偶然看到一篇论文，关于四叉树划分，感觉写的挺清楚的，随手记录下。      HEVC中，一帧图像被分割为多个互补重叠的LCU,LCU大小一般设为64*64。每个LCU又可按照四叉树的方式递归划分为多个子CU。编码器编码时，需要判断当前CU是否已经进行划分。当前CU的划分情况由语法元素split_flag的值给出，其值为1表示CU已经划分，否则表示为进行子CU划分。                 

			
		

	





	

		

			

				
					
四叉树的前序，后序，层次遍历

				
			

			

				

					dumanyi007的专栏
				

				

					12-29
					
					2887
					
				

			

		

		

			
				
//四叉树的前序，后序，层次遍历
#include 
#include 
#include 
using namespace std;
typedef char datatype;
typedef struct node        //二叉树
{
 datatype data;
 struct node *lt,*rt,*lb,*rb;
} fourtnode, *four

			
		

	





	

		

			

				
					
四叉树C#实现

				
			

			

				

					草莽的专栏
				

				

					12-10
					
					9154
					
				

			

		

		

			
				
四叉树是用于二维空间对象查找的一个数据结构，本实现包括了三个类：QuadTree,QuadTreeNode, QuadNodeItem。见名思意用于对外提供构建和查找功能的接口都定义在泛型的QuadTree中，QuadTreeNode类和QuadNodeItem类都做为QuadTree类的内部类型实现，对外不可见。

			
		

	





	

		

			

				
					
GIS空间索引(有了思路代码还不是手到擒来)

				
			

			

				

					dengweidan3299的博客
				

				

					03-06
					
					1012
					
				

			

		

		

			
				
在介绍空间索引之前，先谈谈什么叫“索引“。对一个数据集做”索引“，是为了提高对这个数据集检索的效率。书的”目录“就是这本书内容的”索引“，当我们拿到一本新书，想查看感兴趣内容的时候，我们会先查看目录，确定感兴趣的内容会在哪些页里，直接翻到那些页，就OK了，而不是从第一章节开始翻，一个字一个字地找我们感兴趣的内容，直到找到为止，这种检索内容的效率也太低了，如果一本书没有目录，可以想象有多么...

			
		

	





	

		

			

				
					
四叉树

				
			

			

				

					CCCStudyer的专栏
				

				

					10-26
					
					1972
					
				

			

		

		

			
				
转载：http://hi.baidu.com/begingame/item/461aff15b41376731009b53d


 


        今天终于有空来说说4叉树的相邻节点。上次在2D场景导航中提起，但一直没有详细讨论.经过我仔细研究，最终得到了较快的一个解决方案。方案的核心在于对节点的编码上。
编码
        由于是四叉树，即每个节点有四个子节点，很自然会想

			
		

	





	

		

			

				
					
线性四叉树十进制Morton码计算示例

				
			

			

				

					weixin_34279184的博客
				

				

					01-18
					
					8719
					
				

			

		

		

			
				
线性四叉树十进制Morton码计算，具体算法描述龚健雅《地理信息系统基础》P108


			
		

	





	

		

			

				
					
用Java实现四叉树空间索引

				
			

			

				

					03-31
				

			

		

		

			
				
在Java中，可以使用以下代码实现四叉树空间索引：  1. 定义QuadTree类  public class QuadTree {  private final int MAX_CAPACITY = 4; // 每个节点最大容量  private final int MAX_LEVEL = 5; // 最大深度  ...

			
		

	



              



  
“相关推荐”对你有帮助么？

  

      
    
          
  • 
              
    
                  
                  
              
    
              
    非常没帮助
    
          
    • 
          
  • 
              
    
                  
                  
              
    
              
    没帮助
    
          
    • 
          
  • 
              
    
                  
                  
              
    
              
    一般
    
          
    • 
          
  • 
              
    
                  
                  
              
    
              
    有帮助
    
          
    • 
          
  • 
              
    
                  
                  
              
    
              
    非常有帮助
    
          
    • 
      

      

      

          
          提交
      

      

  




          




        



    





    



      

      

        
      

      





	

		评论	
	

	
	




  

    

      添加红包
      
    

    

      

        
        

          
          
        

        
请填写红包祝福语或标题

      

      

        
        

          
          个
        

        
红包个数最小为10个

      

      

        
        

          
          元
        

        
红包金额最低5元

      

      

        
        

          当前余额3.43元
          前往充值 >
        

      

      

        

          需支付：10.00元
        

        
        
      

    

  





  

    
    
  

  

    
    
  








  

    

      

        

          

            
            
成就一亿技术人!

          

          

        

        

          

          

            领取后你会自动成为博主和红包主的粉丝
            规则
          

        

      

      

        

          

            
              
            
            

              
hope_wisdom
 发出的红包
            

          

        

        

          

          

          

        

      

    

    

  



      
      

      
实付元

      
使用余额支付

      

        

          

            
            点击重新获取
          

        

        
扫码支付

      

      

        
          
            
          
          
        
      

      

        
        钱包余额
          0
          

            
            

              

                
抵扣说明：

                
 1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
 2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

              

            

          

      

      余额充值