八叉树静态Octree(点云) C++代码

最新推荐文章于 2023-07-04 20:50:15 发布
最新推荐文章于 2023-07-04 20:50:15 发布
阅读量1.7k 收藏 27
点赞数 5
文章标签： c++ 数据结构 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_34512507/article/details/115631606
版权

该代码为静态生成八叉树代码，一经创建，不可改变

step1:节点数据结构

//结构体
struct Point {
    double x;
	double y;
	double z;
	void setPoint(double x, double y, double z) {
		this->x = x;
		this->y = y;
		this->z = z;
	}
	Point() {}
	Point(double x, double y, double z) {
		this->x = x;
		this->y = y;
		this->z = z;
	}
};
typedef struct Octree_Node {
	int count;                    //该节点往下所包含点的个数
	std::vector<Point> points;    //用来在叶子节点保存点云
	Octree_Node *nodes[8];        //8个孩子节点
	Octree_Node *parent;          //父节点

	int level;                    //该节点在八叉树中的深度
	Point centel;                 //八叉树格子中心位置
	double length;                //八叉树小格子宽度

	//初始化八叉树节点（父节点，格子宽度，深度）
	void init(Octree_Node *parent, double length, int level) {
		this->parent = parent;
		for (int i = 0; i < 8; i++) {
			nodes[i] = NULL;
		}
		centel.setPoint(0, 0, 0);
		this->level = level;
		this->length = length;
	}

	//释放该节点
	void destory() {
		this->parent = NULL;
		for (int i = 0; i < 8; i++) {
			nodes[i] = NULL;
		}
	}

}Octree_Node, *Octree_Struct;

//类成员
Octree_Struct octree;                    //八叉树root节点
std::vector<Point> pointCloud;
double max_x;                            //八叉树包围盒大小
double max_z;
double max_y;
double octLength;

step2:初始化点云数据

for (int i = 0; i < 1000; i++) {
	Point point;
	point.setPoint(rand() % 1000, rand() % 1000, rand() % 1000);
	pointCloud.push_back(point);
}

step3: 根据点云规模创建相应大小的八叉树

//初始化八叉树（包围盒大小pointCloud）
void CreatOctreeByPointCloud() {

	this->max_x = pointCloud.at(0).x;
	this->max_y = pointCloud.at(0).y;
	this->max_z = pointCloud.at(0).z;

	std::vector<Point>::iterator it = pointCloud.begin();
	for (; it != pointCloud.end(); it++) {
		this->max_x = this->max_x < (*it).x ? (*it).x : this->max_x;
		this->max_y = this->max_y < (*it).y ? (*it).y : this->max_y;
		this->max_z = this->max_z < (*it).z ? (*it).z : this->max_z;
	}

	octree = new Octree_Node();
    //octLength为手动设置叶子节点格子大小，根据点云规模设置，越小八叉树分的越细
	double length = octLength;            
	double maxLength;
	int level = 1;
	maxLength = max_x > max_y ? max_x : max_y;
	maxLength = maxLength > max_z ? maxLength : max_z;
	while (length < maxLength) {    //maxLength为最小能包含所有点的边长
		length *= 2;                //但在八叉树中，每层都是子节点的两倍，
                                    //所以根节点的length要大于maxLength
		level++;
	}

    //根节点octree
    //length：根节点每个格子的宽度，格子为正方体
    //level：将要创建的八叉树的深度的最大值，
    //       比如深度为5的八叉树，根节点的level就是5，叶子节点为1
	octree->init(NULL, length, level);    //初始化根节点（该函数在Step1）

    //生成一个空的八叉树，不包含任何数据
	creat(octree);

    //把数据放到八叉树中，并把不包含数据的地方释放掉
	addPointCloud(pointCloud);
}
//递归生产八叉树空节点
void creat(Octree_Struct octree) {
	if (octree->level == 1) {
		return;
	}
	for (int i = 0; i < 8; i++) {
		octree->nodes[i] = new Octree_Node();
		octree->nodes[i]->init(octree, octree->length / 2, octree->level - 1);


		if (i == 0 || i == 1 || i == 4 || i == 5)
			octree->nodes[i]->centel.y = octree->centel.y + octree->length / 2;
		if (i == 2 || i == 3 || i == 6 || i == 7)
			octree->nodes[i]->centel.y = octree->centel.y - octree->length / 2;
		if (i == 0 || i == 2 || i == 4 || i == 6)
			octree->nodes[i]->centel.x = octree->centel.x + octree->length / 2;
		if (i == 1 || i == 3 || i == 5 || i == 7)
			octree->nodes[i]->centel.x = octree->centel.x - octree->length / 2;
		if (i == 0 || i == 1 || i == 2 || i == 3)
			octree->nodes[i]->centel.z = octree->centel.z + octree->length / 2;
		if (i == 4 || i == 5 || i == 6 || i == 7)
			octree->nodes[i]->centel.z = octree->centel.z - octree->length / 2;

		creat(octree->nodes[i]);
	}
}

把每个点放到它该在的位置（对应叶子节点中）

//添加点云到八叉树中
void addPointCloud(std::vector<Point> pointCloud) {
	std::vector<Point>::iterator it = pointCloud.begin();
	for (; it != pointCloud.end(); it++) {
		octree->count++;
		addNode(octree, *it);
	}
	addNodeEnd(octree);
}
void addNode(Octree_Struct octree, Point point) {
		if (octree->level == 1) {
			octree->points.push_back(point);
			return;
		}
		if (point.x >= octree->centel.x && point.y >= octree->centel.y && point.z >= octree->centel.z) {
			octree->nodes[0]->count++;
			addNode(octree->nodes[0], point);
		}
		else if (point.x < octree->centel.x && point.y >= octree->centel.y && point.z >= octree->centel.z) {
			octree->nodes[1]->count++;
			addNode(octree->nodes[1], point);
		}
		else if (point.x >= octree->centel.x && point.y < octree->centel.y && point.z >= octree->centel.z) {
			octree->nodes[2]->count++;
			addNode(octree->nodes[2], point);
		}
		else if (point.x < octree->centel.x && point.y < octree->centel.y && point.z >= octree->centel.z) {
			octree->nodes[3]->count++;
			addNode(octree->nodes[3], point);
		}
		else if (point.x >= octree->centel.x && point.y >= octree->centel.y && point.z < octree->centel.z) {
			octree->nodes[4]->count++;
			addNode(octree->nodes[4], point);
		}
		else if (point.x < octree->centel.x && point.y >= octree->centel.y && point.z < octree->centel.z) {
			octree->nodes[5]->count++;
			addNode(octree->nodes[5], point);
		}
		else if (point.x >= octree->centel.x && point.y < octree->centel.y && point.z < octree->centel.z) {
			octree->nodes[6]->count++;
			addNode(octree->nodes[6], point);
		}
		else if (point.x < octree->centel.x && point.y < octree->centel.y && point.z < octree->centel.z) {
			octree->nodes[7]->count++;
			addNode(octree->nodes[7], point);
		}
	}

当所有点都添加到八叉树中后，把空节点释放掉

void addNodeEnd(Octree_Struct octree) {
	for (int i = 0; i < 8; i++) {
		if (octree->nodes[i] != NULL) {
			addNodeEnd(octree->nodes[i]);
			if (octree->nodes[i]->count == 0) {
				octree->nodes[i]->parent = NULL;
				delete octree->nodes[i];
				octree->nodes[i] = NULL;
			}
		}
	}
}

至此，八叉树已经创建好了

Step4:销毁八叉树

void destory(Octree_Struct octree) {
	for (int i = 0; i < 8; i++) {
		if (octree->nodes[i] != NULL) {
			destory(octree->nodes[i]);
			octree->nodes[i]->parent = NULL;
			octree->nodes[i]->points.clear();
			delete octree->nodes[i];
		}
	}
	if (octree->parent == NULL) {
		pointCloud.clear();
		delete octree;
	}
}

完整代码：

#pragma once
#include <iostream>
#include <vector>
#include <math.h>

class Octree{
public:

	Octree() {}
	~Octree() { destory(octree); }

	struct Point {
		double x;
		double y;
		double z;
		void setPoint(double x, double y, double z) {
			this->x = x;
			this->y = y;
			this->z = z;
		}
		Point() {}
		Point(double x, double y, double z) {
			this->x = x;
			this->y = y;
			this->z = z;
		}
	};
	typedef struct Octree_Node {
		int count;
		std::vector<Point> points;
		Octree_Node *nodes[8];
		Octree_Node *parent;

		int level;
		Point centel;
		double length;

		void init(Octree_Node *parent, double length, int level) {
			this->parent = parent;
			for (int i = 0; i < 8; i++) {
				nodes[i] = NULL;
			}
			centel.setPoint(0, 0, 0);
			this->level = level;
			this->length = length;
		}

		void destory() {
			this->parent = NULL;
			for (int i = 0; i < 8; i++) {
				nodes[i] = NULL;
			}
		}
	}Octree_Node, *Octree_Struct;

	Octree_Struct octree;
	double octLength;
	std::vector<Point> pointCloud;
	double max_x;
	double max_z;
	double max_y;

	void setPoint(std::vector<Point> points) {
		int size = points.size();
		for (int i = 0; i < size; i++) {
			pointCloud.push_back(points[i]);
		}
	}

	void CreatOctreeByPointCloud() {
		this->max_x = pointCloud.at(0).x;
		this->max_y = pointCloud.at(0).y;
		this->max_z = pointCloud.at(0).z;

		//计算八叉树深度和宽度
		std::vector<Point>::iterator it = pointCloud.begin();
		for (; it != pointCloud.end(); it++) {
			this->max_x = this->max_x < (*it).x ? (*it).x : this->max_x;
			this->max_y = this->max_y < (*it).y ? (*it).y : this->max_y;
			this->max_z = this->max_z < (*it).z ? (*it).z : this->max_z;
		}
		
		double length = octLength;
		double maxLength;
		int level = 1;
		maxLength = max_x > max_y ? max_x : max_y;
		maxLength = maxLength > max_z ? maxLength : max_z;
		while (length < maxLength) {
			length *= 2;
			level++;
		}
		
		//初始化八叉树
		octree = new Octree_Node();
		octree->init(NULL, length, level);
				
		creat(octree);

		addPointCloud(pointCloud);
	}

	void creat(Octree_Struct octree) {
		if (octree->level == 1) {
			return;
		}
		for (int i = 0; i < 8; i++) {
			octree->nodes[i] = new Octree_Node();
			octree->nodes[i]->init(octree, octree->length / 2, octree->level - 1);

			if (i == 0 || i == 1 || i == 4 || i == 5)
				octree->nodes[i]->centel.y = octree->centel.y + octree->length / 2;
			if (i == 2 || i == 3 || i == 6 || i == 7)
				octree->nodes[i]->centel.y = octree->centel.y - octree->length / 2;
			if (i == 0 || i == 2 || i == 4 || i == 6)
				octree->nodes[i]->centel.x = octree->centel.x + octree->length / 2;
			if (i == 1 || i == 3 || i == 5 || i == 7)
				octree->nodes[i]->centel.x = octree->centel.x - octree->length / 2;
			if (i == 0 || i == 1 || i == 2 || i == 3)
				octree->nodes[i]->centel.z = octree->centel.z + octree->length / 2;
			if (i == 4 || i == 5 || i == 6 || i == 7)
				octree->nodes[i]->centel.z = octree->centel.z - octree->length / 2;

			creat(octree->nodes[i]);
		}
	}

	void addPointCloud(std::vector<Point> pointCloud) {
		std::vector<Point>::iterator it = pointCloud.begin();
		for (; it != pointCloud.end(); it++) {
			octree->count++;
			addNode(octree, *it);
		}
		addNodeEnd(octree);
	}

	void addNode(Octree_Struct octree, Point point) {
		if (octree->level == 1) {
			octree->points.push_back(point);
			return;
		}
		if (point.x >= octree->centel.x && point.y >= octree->centel.y && point.z >= octree->centel.z) {
			octree->nodes[0]->count++;
			addNode(octree->nodes[0], point);
		}
		else if (point.x < octree->centel.x && point.y >= octree->centel.y && point.z >= octree->centel.z) {
			octree->nodes[1]->count++;
			addNode(octree->nodes[1], point);
		}
		else if (point.x >= octree->centel.x && point.y < octree->centel.y && point.z >= octree->centel.z) {
			octree->nodes[2]->count++;
			addNode(octree->nodes[2], point);
		}
		else if (point.x < octree->centel.x && point.y < octree->centel.y && point.z >= octree->centel.z) {
			octree->nodes[3]->count++;
			addNode(octree->nodes[3], point);
		}
		else if (point.x >= octree->centel.x && point.y >= octree->centel.y && point.z < octree->centel.z) {
			octree->nodes[4]->count++;
			addNode(octree->nodes[4], point);
		}
		else if (point.x < octree->centel.x && point.y >= octree->centel.y && point.z < octree->centel.z) {
			octree->nodes[5]->count++;
			addNode(octree->nodes[5], point);
		}
		else if (point.x >= octree->centel.x && point.y < octree->centel.y && point.z < octree->centel.z) {
			octree->nodes[6]->count++;
			addNode(octree->nodes[6], point);
		}
		else if (point.x < octree->centel.x && point.y < octree->centel.y && point.z < octree->centel.z) {
			octree->nodes[7]->count++;
			addNode(octree->nodes[7], point);
		}
	}

	void addNodeEnd(Octree_Struct octree) {
		for (int i = 0; i < 8; i++) {
			if (octree->nodes[i] != NULL) {
				addNodeEnd(octree->nodes[i]);
				if (octree->nodes[i]->count == 0) {
					octree->nodes[i]->parent = NULL;
					delete octree->nodes[i];
					octree->nodes[i] = NULL;
				}
			}
		}
	}

	void destory(Octree_Struct octree) {
		for (int i = 0; i < 8; i++) {
			if (octree->nodes[i] != NULL) {
				destory(octree->nodes[i]);
				octree->nodes[i]->parent = NULL;
				octree->nodes[i]->points.clear();
				delete octree->nodes[i];
			}
		}
		if (octree->parent == NULL) {
			pointCloud.clear();
			delete octree;
		}
	}

};

main.cpp

#include "Octree3.h"

int main(int argc, char *argv[])
{
	int size = 10;
	std::vector<Octree::Point> pointCloud;
	for (int i = 0; i < size; i++) {
		pointCloud.push_back(Octree::Point(rand() % 1000 - 500, rand() % 1000 - 500, rand() % 1000 - 500));
	}

	Octree oct;
	oct.octLength = 10;
	oct.setPoint(pointCloud);
	oct.CreatOctreeByPointCloud();
}

八叉树可视化

 

点睡
关注
  • 5
    点赞
  • 踩
  • 27
    收藏
    觉得还不错? 一键收藏
  • 4
    评论
octree-helper:用于three.js的八叉树可视化工具
05-08
八重奏助手 :warning: 弃用声明：octree帮助器现在包含在。 :warning: 用于的八叉树可视化工具。 · 安装 该库需要对等依赖项 。 npm install three octree-helper 要求 该帮助程序可以可视化符合以下协议的任何八叉树： 用法 以下示例使用模块。 import { Scene } from "three" ; import { Octree } from "sparse-octree" ; import { OctreeHelper } from "octree-helper" ; const scene = new Scene ( ) ; const octree = new Octree ( ) ; const octreeHelper = new OctreeHelper ( octree ) ; // Render the helper. scen
VC实现的八叉树数据结构源代码
12-10
用VC实现的八叉树数据结构，十一个完整的工程，可以运行，通过该实例代码可以对八叉树的创建以及基本操作有比较清楚的认识。
场景管理：八叉树算法C++实现
踏莎行的博客
07-30 6575
简单实现了场景管理八叉树算法 代码结构： 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
八叉树动态Octree(点云) C++代码
qq_34512507的博客
04-13 6182
动态生成八叉树，就是该八叉树可以根据新加入点的位置自动调整树的结构，将新加入点放到正确的位置。 #pragma once #include <vector> class Octree { public: Octree() {} ~Octree() { std::cout << "delete"; destory(root); } struct Point { float x, y, z; void setPoint(float x, float y, float
八叉树图及点云构建
依然吧的博客
10-15 5852
常见的八叉树的构建是根据递归思想构建，在递归划分时，一般按照格网大小，或者是格网内点数进行约束，对格网均匀划分成8个格网，直至满足条件为止。如下为一个立方体被划分成8个子节点示意图。 根据需要，对点云进行八叉树构造，将点云划分成多个小的块。 #include "arrayoperation.h" #include "DataStruct.h" #include "IO.h" #include "CalculateFeatures.h" #include<iostream> #inc
Octree_点云构建八叉树_pcl库_点云库_
10-02
在VS2010平台上搭建PCL库使用C++语言对散乱点云进行八叉树构建
八叉树代码 最近点查找 八叉树代码
04-19
八叉树代码，实现最近点查找，内包含点云实例(Octree code to find the nearest point to achieve, and contains the point cloud instances)
八叉树，用C++实现简单的八叉树类
JamesXue的博客
07-04 590
八叉树的C++实现代码。
八叉树 C++ 基础 源码
热门推荐
...
06-20 1万+
http://blog.csdn.net/pizi0475/article/details/6269060四叉树或四元树也被称为Q树（Q-Tree）。四叉树广泛应用于图像处理、空间数据索引、2D中的快速碰撞检测、存储稀疏数据等，而八叉树（Octree）主要应用于3D图形处理。实际的数据结构，就是一个树根不断地往下扩，每次分成八个枝，直到叶子为止。 叶子节点代表了分辨率最高的情况。例如分辨率设成0.
C++实现八叉树
NINE_world的博客
10-24 1020
【代码】C++实现八叉树。
【C++】pcl库中的k-d tree和八叉树算法
Zhang_Chen_的博客
09-21 2881
1.计算机图形学中的Mesh(网格)数据结构；2.k-d tree的概念以及在pcl中的应用(快速邻域搜索)；3.八叉树的概念以及在pcl中的应用(空间划分及搜索)
CloudCompare——基于八叉树的点云下采样
点云侠的博客
09-01 2293
使用CloudCompare基于八叉树实现的点云下采样
java简单实现八叉树图像处理代码示例
08-28
主要介绍了java简单实现八叉树图像处理代码示例，具有一定借鉴价值，需要的朋友可以参考下。
八叉树算法
10-08
文件包含八叉树构建算法； 用100万个点测试，构建效率高； 代码里面还有关于八叉树的相关操作函数； 欢迎广大爱好者使用交流。
三维点云模型
11-05
三维典型Bunny,dragon点云数据文件，正确打开即可使用
基于类八叉树索引的点云管理策略研究
02-06
以点云数据为研究对象,提出了一种结合K维(KD)树空间切分思想的类八叉树混合点云索引结构,实现了对海量点云的高效管理。对于点云所在空间,首先利用KD树思想进行初步分割,再对所得的子空间利用八叉树做进一步切分,建立...
c++八叉树实现
10-13
使用c++的八叉树实现，八叉树（Octree）的定义是：若不为空树的话，树中任一节点的子节点恰好只会有八个，或零个，也就是子节点不会有0与8以外的数目。
点云库PCL学习4——点云的常用操作
init_bin的博客
11-28 993
1.如何知道点云的是XYZ格式还是xyzrgb格式？ #define _CRT_SECURE_NO_WARNINGS #pragma warning(disable:4996) #include "iostream" using namespace std; #include "time.h" #include <pcl/io/pcd_io.h> #include <...
点云八叉树构建（机载、车载与地基）
依然吧的博客
05-28 1570
1、八叉树构建原理 点云八叉树是在点云体素化或者二维格网化基础上（点云二维组织与体素化构建参考博客三维点云的格网（体素）组织_仰望星空_2022的博客-CSDN博客），再做进一步处理，将满足相同性质的点划入到同一块中，如同一体素内点能够拟合成面，或者来自同一地物等。 不管是二维格网还是三维体素构建八叉树，其原理步骤是相同的，都是以初始体素（或者格网）为处理基元，根据八叉树构建原理对其进行划分，实现构建。下面以体素块为例，讲解八叉树构建的思路。 一个正方体均匀划分成8个小立方体的形式如下（左图），包括两
八叉树 python
最新发布
08-21
八叉树（Octree）是一种树状数据结构，常用于处理三维空间中的点云或体素数据。它可以将空间划分为八个子空间，每个子空间继续递归地划分，直到满足某个终止条件。 在Python中，我们可以使用类来实现八叉树。首先，我们需要定义一个节点类，其中包含节点的位置、范围以及可能的子节点。例如，我们可以使用一个包含最小和最大坐标的边界框表示节点的范围。 然后，我们可以定义一个八叉树类，其中包含根节点以及相关的方法。其中包括插入节点、查找节点、遍历节点等操作。插入节点操作会根据节点位置递归地将节点插入到合适的子节点中。查找节点操作会在八叉树中按照一定规则递归地查找指定位置的节点。遍历节点操作可以按照某种规则遍历八叉树中的所有节点。 在使用八叉树处理空间数据时，我们可以先构建一棵八叉树，然后可以快速地查询附近的点或体素，并进行一些空间分析或处理操作。例如，我们可以在八叉树中查找与某个指定节点相邻的节点，或者查找位于某个指定范围内的节点。 总之，八叉树是一种在处理三维空间数据时非常有用的数据结构，它可以快速地进行查询和分析操作。在Python中，我们可以利用类的方式实现八叉树，并通过递归的方式构建和操作八叉树。

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

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 4
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值