关闭

场景管理:八叉树算法C++实现

标签: 游戏
2944人阅读 评论(1) 收藏 举报
分类:

简单实现了场景管理八叉树算法

代码结构:

  • object.h,object.cpp 被管理的对象类
  • octree_node.h,octree_node.cpp 八叉树类
  • main.cpp程序入口

object.h
#pragma once
/*
//被管理的对象类
*/
class Object
{
public:
	Object(float _x,float _y,float _z,float _xSize,float _ySize,float _zSize);
	~Object();
public:
	//对象的属性,例如坐标和长宽高,以左上角为锚点
	float x;
	float y;
	float z;
	float xSize;
	float ySize;
	float zSize;
};

object.cpp
#include "object.h"


Object::Object(float _x,float _y,float _z,float _xSize,float _ySize,float _zSize):
	x(_x),
	y(_y),
	z(_z),
	xSize(_xSize),
	ySize(_ySize),
	zSize(_zSize)
{
}


Object::~Object()
{
}

octree_node.h
/*
//八叉树节点类,用头节点代表八叉树
//采用opengl右手坐标系,靠近原点的那个角为锚点,方便计算
//本八叉树的策略是:1,一次划分所有节点,是满树;2,当立方体空间完全包含某物体才剔除,当立方体空间与某物体相交或者完全包含时才查询;3,对象放在完全包含它的区域叶子节点内,非根节点不存储对象,默认为物体不可能跨多个叶子节点,都在一个叶子节点的空间范围内部,未考虑交叉的情况
*/
#pragma once
#include <list>

//八叉树节点类型
enum OctreeType        
{
	ROOT,                   //根
	BOTTOM_LEFT_FRONT,		// 1 
	BOTTOM_RIGHT_FRONT,		// 2 
	BOTTOM_LEFT_BACK,		// 3 
	BOTTOM_RIGHT_BACK,      // 4 
	TOP_LEFT_FRONT,         // 5 
	TOP_RIGHT_FRONT,        // 6 
	TOP_LEFT_BACK,          // 7 
	TOP_RIGHT_BACK          // 8   
};

template <class T>
class OctreeNode
{
public:
	OctreeNode(float _x,float _y,float _z,float _xSize,float _ySize,float _zSize,OctreeType _octreeNodeType,int _level,int _maxLevel);
	~OctreeNode();
public:
	void BuildTree(int level); //建立八叉树,划分到所有子节点
	void InsertObject(T *object); //插入对象
	std::list<T *> GetObjectsAt(float px,float py,float pz,float x_size,float y_size,float z_size); //查询对象,获得一片区域里的对象链表,考虑包含或相交,由于
	void RemoveObjectsAt(float px,float py,float pz,float x_size,float y_size,float z_size); //删除对象,删除一片区域里的对象,此处只考虑完全包含的
private:
	bool IsContain(float px,float py,float pz,float x_size,float y_size,float z_size,T *object) const; //判断某个区域是否包含某对象
	bool IsContain(float px,float py,float pz,float x_size,float y_size,float z_size,OctreeNode<T> *octreeNode) const; //重载,判断某个区域是否包含某个节点
	bool IsInterSect(float px,float py,float pz,float x_size,float y_size,float z_size,OctreeNode<T> *octreeNode) const; //判断某个区域是否与节点相交,如果相交,则查询时要递归到其子节点
public:
	std::list<T *> objectList; //节点存储的对象列表
private:
	//节点属性
	OctreeType octreeNodeType;
	float x;
	float y;
	float z;
	float xSize;
	float ySize;
	float zSize;
	int level;
	int maxLevel;
	//子节点,根据opengl坐标系,依次坐标增大
	OctreeNode *bottom_left_front_node;
	OctreeNode *bottom_right_front_node;
	OctreeNode *bottom_left_back_node;
	OctreeNode *bottom_right_back_node;
	OctreeNode *top_left_front_node;
	OctreeNode *top_right_front_node;
	OctreeNode *top_left_back_node;
	OctreeNode *top_right_back_node;
};

octree_node.cpp 
#include "octree_node.h"

template <class T>
OctreeNode<T>::OctreeNode(float _x,float _y,float _z,float _xSize,float _ySize,float _zSize,OctreeType _octreeNodeType,int _level,int _maxLevel):
	x(_x),
	y(_y),
	z(_z),
	xSize(_xSize),
	ySize(_ySize),
	zSize(_zSize),
	octreeNodeType(_octreeNodeType),
	level(_level),
	maxLevel(_maxLevel)
{
	//初始子节点都赋空值
	bottom_left_front_node=nullptr;
	bottom_right_front_node=nullptr;
	bottom_left_back_node=nullptr;
	bottom_right_back_node=nullptr;
	top_left_front_node=nullptr;
	top_right_front_node=nullptr;
	top_left_back_node=nullptr;
	top_right_back_node=nullptr;
}

template <class T>
OctreeNode<T>::~OctreeNode()
{
	
}

template <class T>
bool OctreeNode<T>::IsContain(float px,float py,float pz,float x_size,float y_size,float z_size,T *object) const
{
	if(object->x>=px
		&&object->x+object->xSize<=px+x_size
		&&object->y>=py
		&&object->y+object->ySize<=py+y_size
		&&object->z>=pz
		&&object->z+object->zSize<=pz+z_size)
		return true;
	return false;
}

template <class T>
bool OctreeNode<T>::IsContain(float px,float py,float pz,float x_size,float y_size,float z_size,OctreeNode<T> *octreeNode) const
{
	if(octreeNode->x>=px
		&&octreeNode->x+octreeNode->xSize<=px+x_size
		&&octreeNode->y>=py
		&&octreeNode->y+octreeNode->ySize<=py+y_size
		&&octreeNode->z>=pz
		&&octreeNode->z+octreeNode->zSize<=pz+z_size)
		return true;
	return false;
}

template <class T>
bool OctreeNode<T>::IsInterSect(float px,float py,float pz,float x_size,float y_size,float z_size,OctreeNode<T> *octreeNode) const
{
	if(octreeNode->x>px+x_size
		||octreeNode->x+xSize<px
		||octreeNode->y>py+y_size
		||octreeNode->y+ySize<py
		||octreeNode->z+zSize<pz
		||octreeNode->z>pz+z_size)
		return false;
	return true;
}

template <class T>
void OctreeNode<T>::BuildTree(int level)
{
	//递归地进行八叉树空间划分,直到最大深度
	if(level==maxLevel)
		return;
	//创建子节点
	bottom_left_front_node=new OctreeNode(x,y,z,xSize/2,ySize/2,zSize/2,BOTTOM_LEFT_FRONT,level+1,maxLevel);
	bottom_right_front_node=new OctreeNode(x+xSize/2,y,z,xSize/2,ySize/2,zSize/2,BOTTOM_RIGHT_FRONT,level+1,maxLevel);
	bottom_left_back_node=new OctreeNode(x,y+ySize/2,z,xSize/2,ySize/2,zSize/2,BOTTOM_LEFT_BACK,level+1,maxLevel);
	bottom_right_back_node=new OctreeNode(x+xSize/2,y+ySize/2,z,xSize/2,ySize/2,zSize/2,BOTTOM_RIGHT_BACK,level+1,maxLevel);
	top_left_front_node=new OctreeNode(x,y,z+zSize/2,xSize/2,ySize/2,zSize/2,TOP_LEFT_FRONT,level+1,maxLevel);
	top_right_front_node=new OctreeNode(x+xSize/2,y,z+zSize/2,xSize/2,ySize/2,zSize/2,TOP_RIGHT_FRONT,level+1,maxLevel);
	top_left_back_node=new OctreeNode(x,y+ySize/2,z+zSize/2,xSize/2,ySize/2,zSize/2,TOP_LEFT_BACK,level+1,maxLevel);
	top_right_back_node=new OctreeNode(x+xSize/2,y+ySize/2,z+zSize/2,xSize/2,ySize/2,zSize/2,TOP_RIGHT_BACK,level+1,maxLevel);
	//递归构造
	bottom_left_front_node->BuildTree(level+1);
	bottom_right_front_node->BuildTree(level+1);
	bottom_left_back_node->BuildTree(level+1);
	bottom_right_back_node->BuildTree(level+1);
	top_left_front_node->BuildTree(level+1);
	top_right_front_node->BuildTree(level+1);
	top_left_back_node->BuildTree(level+1);
	top_right_back_node->BuildTree(level+1);
}

template <class T>
void OctreeNode<T>::InsertObject(T *object)
{
	if(level==maxLevel)
	{
		objectList.push_back(object);
		return;
	}
	//递归地插入,直到叶子节点
	//1
	if(bottom_left_front_node&&IsContain(x,y,z,xSize/2,ySize/2,zSize/2,object))
	{
		bottom_left_front_node->InsertObject(object);
		return;
	}
	//2
	if(bottom_right_front_node&&IsContain(x+xSize/2,y,z,xSize/2,ySize/2,zSize/2,object))
	{
		bottom_right_front_node->InsertObject(object);
		return;
	}
	//3
	if(bottom_left_back_node&&IsContain(x,y+ySize/2,z,xSize/2,ySize/2,zSize/2,object))
	{
		bottom_left_back_node->InsertObject(object);
		return;
	}
	//4
	if(bottom_right_back_node&&IsContain(x+xSize/2,y+ySize/2,z,xSize/2,ySize/2,zSize/2,object))
	{
		bottom_right_back_node->InsertObject(object);
		return;
	}
	//5
	if(top_left_front_node&&IsContain(x,y,z+zSize/2,xSize/2,ySize/2,zSize/2,object))
	{
		top_left_front_node->InsertObject(object);
		return;
	}
	//6
	if(top_right_front_node&&IsContain(x+xSize/2,y,z+zSize/2,xSize/2,ySize/2,zSize/2,object))
	{
		top_right_front_node->InsertObject(object);
		return;
	}
	//7
	if(top_left_back_node&&IsContain(x,y+ySize/2,z+zSize/2,xSize/2,ySize/2,zSize/2,object))
	{
		top_left_back_node->InsertObject(object);
		return;
	}
	//8
	if(top_right_back_node&&IsContain(x+xSize/2,y+ySize/2,z+zSize/2,xSize/2,ySize/2,zSize/2,object))
	{
		top_right_back_node->InsertObject(object);
		return;
	}
}

template <class T>
std::list<T *> OctreeNode<T>::GetObjectsAt(float px,float py,float pz,float x_size,float y_size,float z_size)
{
	if(level==maxLevel)
		return objectList;
	std::list<T *> resObjects;
	//递归地判断选定区域是否与某个节点相交(包含或被包含都算)
	//1
	if(bottom_left_front_node&&IsInterSect(px,py,pz,x_size,y_size,z_size,bottom_left_front_node))
	{
		std::list<T *> childObjects1=bottom_left_front_node->GetObjectsAt(px,py,pz,x_size,y_size,z_size);
		resObjects.insert(resObjects.end(),childObjects1.begin(),childObjects1.end());
	}
	//2
	if(bottom_right_front_node&&IsInterSect(px,py,pz,x_size,y_size,z_size,bottom_right_front_node))
	{
		std::list<T *> childObjects2=bottom_right_front_node->GetObjectsAt(px,py,pz,x_size,y_size,z_size);
		resObjects.insert(resObjects.end(),childObjects2.begin(),childObjects2.end());
	}
	//3
	if(bottom_left_back_node&&IsInterSect(px,py,pz,x_size,y_size,z_size,bottom_left_back_node))
	{
		std::list<T *> childObjects3=bottom_left_back_node->GetObjectsAt(px,py,pz,x_size,y_size,z_size);
		resObjects.insert(resObjects.end(),childObjects3.begin(),childObjects3.end());
	}
	//4
	if(bottom_right_back_node&&IsInterSect(px,py,pz,x_size,y_size,z_size,bottom_right_back_node))
	{
		std::list<T *> childObjects4=bottom_right_back_node->GetObjectsAt(px,py,pz,x_size,y_size,z_size);
		resObjects.insert(resObjects.end(),childObjects4.begin(),childObjects4.end());
	}
	//5
	if(top_left_front_node&&IsInterSect(px,py,pz,x_size,y_size,z_size,top_left_front_node))
	{
		std::list<T *> childObjects5=top_left_front_node->GetObjectsAt(px,py,pz,x_size,y_size,z_size);
		resObjects.insert(resObjects.end(),childObjects5.begin(),childObjects5.end());
	}
	//6
	if(top_right_front_node&&IsInterSect(px,py,pz,x_size,y_size,z_size,top_right_front_node))
	{
		std::list<T *> childObjects6=top_right_front_node->GetObjectsAt(px,py,pz,x_size,y_size,z_size);
		resObjects.insert(resObjects.end(),childObjects6.begin(),childObjects6.end());
	}
	//7
	if(top_left_back_node&&IsInterSect(px,py,pz,x_size,y_size,z_size,top_left_back_node))
	{
		std::list<T *> childObjects7=top_left_back_node->GetObjectsAt(px,py,pz,x_size,y_size,z_size);
		resObjects.insert(resObjects.end(),childObjects7.begin(),childObjects7.end());
	}
	//8
	if(top_right_back_node&&IsInterSect(px,py,pz,x_size,y_size,z_size,top_right_back_node))
	{
		std::list<T *> childObjects8=top_right_back_node->GetObjectsAt(px,py,pz,x_size,y_size,z_size);
		resObjects.insert(resObjects.end(),childObjects8.begin(),childObjects8.end());
	}

	return resObjects;
}

template <class T>
void OctreeNode<T>::RemoveObjectsAt(float px,float py,float pz,float x_size,float y_size,float z_size)
{
	if(level==maxLevel)
	{
		if(IsContain(px,py,pz,x_size,y_size,z_size,this))
			objectList.clear(); //到了叶子节点且完全被包含就把该节点存储的对象清空
		return;
	}
	//递归地判断选定区域是否与某个节点相交(包含或被包含都算),没有相交就不用再递归了
	//1
	if(bottom_left_front_node&&IsInterSect(px,py,pz,x_size,y_size,z_size,bottom_left_front_node))
		bottom_left_front_node->RemoveObjectsAt(px,py,pz,x_size,y_size,z_size);
	//2
	if(bottom_right_front_node&&IsInterSect(px,py,pz,x_size,y_size,z_size,bottom_right_front_node))
		bottom_right_front_node->RemoveObjectsAt(px,py,pz,x_size,y_size,z_size);
	//3
	if(bottom_left_back_node&&IsInterSect(px,py,pz,x_size,y_size,z_size,bottom_left_back_node))
		bottom_left_back_node->RemoveObjectsAt(px,py,pz,x_size,y_size,z_size);
	//4
	if(bottom_right_back_node&&IsInterSect(px,py,pz,x_size,y_size,z_size,bottom_right_back_node))
		bottom_right_back_node->RemoveObjectsAt(px,py,pz,x_size,y_size,z_size);
	//5
	if(top_left_front_node&&IsInterSect(px,py,pz,x_size,y_size,z_size,top_left_front_node))
		top_left_front_node->RemoveObjectsAt(px,py,pz,x_size,y_size,z_size);
	//6
	if(top_right_front_node&&IsInterSect(px,py,pz,x_size,y_size,z_size,top_right_front_node))
		top_right_front_node->RemoveObjectsAt(px,py,pz,x_size,y_size,z_size);
	//7
	if(top_left_back_node&&IsInterSect(px,py,pz,x_size,y_size,z_size,top_left_back_node))
		top_left_back_node->RemoveObjectsAt(px,py,pz,x_size,y_size,z_size);
	//8
	if(top_right_back_node&&IsInterSect(px,py,pz,x_size,y_size,z_size,top_right_back_node))
		top_right_back_node->RemoveObjectsAt(px,py,pz,x_size,y_size,z_size);
}

main.cpp
#include <iostream>
#include "object.h"
#include "octree_node.h"
#include "octree_node.cpp" //模板分开写要包含h和cpp
using namespace std;
int main()
{
	OctreeNode<Object> *octree=new OctreeNode<Object>(0,0,0,200,200,200,ROOT,1,3);
	octree->BuildTree(1);

	octree->InsertObject(new Object(10,10,10,30,30,30));
	octree->InsertObject(new Object(11,11,11,32,32,32));
	octree->InsertObject(new Object(110,60,60,30,30,30));
	octree->InsertObject(new Object(110,110,110,30,30,30));

	octree->RemoveObjectsAt(0,0,0,110,70,70);
	list<Object *> resObjects=octree->GetObjectsAt(0,0,0,130,130,130);
	cout<<resObjects.size()<<endl;
	for(auto &t:resObjects)
		cout<<t->x<<' '<<t->y<<' '<<t->z<<' '<<t->xSize<<' '<<t->ySize<<' '<<t->zSize<<endl;

	delete octree;
	system("pause");
	return 0;
}


2
0
查看评论

八叉树 C++ 基础 源码

http://blog.csdn.net/pizi0475/article/details/6269060四叉树或四元树也被称为Q树(Q-Tree)。四叉树广泛应用于图像处理、空间数据索引、2D中的快速碰撞检测、存储稀疏数据等,而八叉树(Octree)主要应用于3D图形处理。实际的数据结构,就是一个...
  • yulinxx
  • yulinxx
  • 2017-06-20 23:28
  • 1208

八叉树Octree

维基释义:八叉树(Octree)是一种用于描述三维空间的树状数据结构。八叉树的每个节点表示一个正方体的体积元素,每个节点有八个子节点,这八个子节点所表示的体积元素加在一起就等于父节点的体积。一般中心点作为节点的分叉中心。百度百科释义:八叉树(Octree)的定义是:若不为空树的话,树中任一节点的子节...
  • Augusdi
  • Augusdi
  • 2014-06-30 16:41
  • 12780

八叉树Octree

八叉树 维基释义:八叉树(Octree)是一种用于描述三维空间的树状数据结构。八叉树的每个节点表示一个正方体的体积元素,每个节点有八个子节点,这八个子节点所表示的体积元素加在一起就等于父节点的体积。一般中心点作为节点的分叉中心。 百度百科释义:八叉树(Octree)的定义...
  • huapenguag
  • huapenguag
  • 2016-03-09 19:28
  • 1432

八叉树三维数据结构

(一)基本原理     用八叉树来表示三维形体,并研究在这种表示下的各种操作及应用是在进入80年代后才比较全面地开展起来的。这种方法,既可以看成是四叉树方法在三维空间的推广,也可以认为是用三维体素阵列表示形体方法的一种改进。    ...
  • Chinamming
  • Chinamming
  • 2013-11-24 13:15
  • 3309

空间八叉树剖分

空间八叉树剖分转载自:http://hi.baidu.com/j_factory/blog/item/8bc1ca182d7f45f6af5133c3.html  空间八叉树算法是一个空间非均匀网格剖分算法,该算法将含有整个场景的空间立方体按三个方向分割成八个子立方体网格,组织成一棵八叉树...
  • Augusdi
  • Augusdi
  • 2014-06-30 16:49
  • 4652

四叉树与八叉树

转自:http://blog.csdn.net/zhanxinhang/article/details/6706217 前序 四叉树或四元树也被称为Q树(Q-Tree)。四叉树广泛应用于图像处理、空间数据索引、2D中的快速碰撞检测、存储稀疏数据等,而八叉树(Octree)主要应用于3D图形处理...
  • hjwang1
  • hjwang1
  • 2016-09-03 01:36
  • 1196

八叉树及K-D树的应用和实现

1. 八叉树、k-d树的原理2. 八叉树、k-d树的应用、优缺点3. 八叉树、k-d树的实现八叉树和k-d树都经常用来处理三维空间数据,k-d树的使用范围更宽泛些,适用于k维空间的数据,在Sift算法中,k-d树被用于在k维的空间内搜索邻近特征点。1. 八叉树、k-d树的原理wiki或百科上面都有详...
  • Augusdi
  • Augusdi
  • 2014-06-30 20:46
  • 2264

基于八叉树的网格生成算法剖析

基于八叉树的网格生成算法剖析前言  对于网格生成这个主题,之前的网格生成系列的三篇博客文章分别介绍了MC算法,SMC算法以及Cuberille算法三种方法。同时还有一篇介绍网格生成与种子点生长算法高效结合的算法。本篇文章继续这一主题,介绍采用八叉树结构来进行网格生成的算法,这个算法并不是独立于之前介...
  • Kaitiren
  • Kaitiren
  • 2016-03-11 11:40
  • 2392

四叉树与八叉树

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

八叉树的实现

八叉树的实现 2008-11-29 17:30 1455人阅读 评论(1) 收藏 举报 systemnull存储 //Date : 2008/05/01 //Filename : octr...
  • pi9nc
  • pi9nc
  • 2013-07-11 10:05
  • 743
    个人资料
    • 访问:460626次
    • 积分:5839
    • 等级:
    • 排名:第5245名
    • 原创:110篇
    • 转载:58篇
    • 译文:3篇
    • 评论:190条
    博主描述
    艺术?技术?finance?
    邮箱:tashaxing123@163.com
    [新浪微博]:踏莎行hyx
    [github]: tashaxing
    文章分类
    最新评论