八叉树 C++ 基础 源码

最新推荐文章于 2024-02-20 03:00:00 发布
最新推荐文章于 2024-02-20 03:00:00 发布
阅读量1w 收藏 50
点赞数 9
分类专栏： C++ 文章标签： 数据结构

http://blog.csdn.net/pizi0475/article/details/6269060

四叉树或四元树也被称为Q树（Q-Tree）。四叉树广泛应用于图像处理、空间数据索引、2D中的快速碰撞检测、存储稀疏数据等，而八叉树（Octree）主要应用于3D图形处理。

实际的数据结构，就是一个树根不断地往下扩，每次分成八个枝，直到叶子为止。
叶子节点代表了分辨率最高的情况。例如分辨率设成0.01m，那么每个叶子就是一个1cm见方的小方块

这里写图片描述

这里写图片描述

#include <iostream>
using namespace std;

//定义八叉树节点类
template<class T>
struct OctreeNode
{
    T data; //节点数据
    T xMin, xMax; //节点坐标，即六面体个顶点的坐标
    T yMin, yMax;
    T zMin, zMax;
    OctreeNode <T> *top_left_front, *top_left_back; //该节点的个子结点
    OctreeNode <T> *top_right_front, *top_right_back;
    OctreeNode <T> *bottom_left_front, *bottom_left_back;
    OctreeNode <T> *bottom_right_front, *bottom_right_back;
    OctreeNode //节点类
    (T nodeValue = T(),
        T xminValue = T(), T xmaxValue = T(),
        T yminValue = T(), T ymaxValue = T(),
        T zminValue = T(), T zmaxValue = T(),
        OctreeNode<T>* top_left_front_Node = NULL,
        OctreeNode<T>* top_left_back_Node = NULL,
        OctreeNode<T>* top_right_front_Node = NULL,
        OctreeNode<T>* top_right_back_Node = NULL,
        OctreeNode<T>* bottom_left_front_Node = NULL,
        OctreeNode<T>* bottom_left_back_Node = NULL,
        OctreeNode<T>* bottom_right_front_Node = NULL,
        OctreeNode<T>* bottom_right_back_Node = NULL)
        : data(nodeValue),
        xMin(xminValue), xMax(xmaxValue),
        yMin(yminValue), yMax(ymaxValue),
        zMin(zminValue), zMax(zmaxValue),
        top_left_front(top_left_front_Node),
        top_left_back(top_left_back_Node),
        top_right_front(top_right_front_Node),
        top_right_back(top_right_back_Node),
        bottom_left_front(bottom_left_front_Node),
        bottom_left_back(bottom_left_back_Node),
        bottom_right_front(bottom_right_front_Node),
        bottom_right_back(bottom_right_back_Node) {}
};


//创建八叉树
template <class T>
void createOctree(OctreeNode<T> * &root, int maxdepth, double xMin, double xMax, double yMin, double yMax, double zMin, double zMax)
{
    cout << "处理中，请稍候……" << endl;
    maxdepth = maxdepth - 1; //每递归一次就将最大递归深度-1
    if (maxdepth >= 0)
    {
        root = new OctreeNode<T>();
        root->data = 9; //为节点赋值，可以存储节点信息，如物体可见性。由于是简单实现八叉树功能，简单赋值为。
        root->xMin = xMin; //为节点坐标赋值
        root->xMax = xMax;
        root->yMin = yMin;
        root->yMax = yMax;
        root->zMin = zMin;
        root->zMax = zMax;
        double xMind = (xMax - xMin) / 2;//计算节点个维度上的半边长
        double yMind = (yMax - yMin) / 2;
        double zMind = (zMax - zMin) / 2;
        //递归创建子树，根据每一个节点所处（是几号节点）的位置决定其子结点的坐标。
        createOctree(root->top_left_front, maxdepth, xMin, xMax - xMind, yMax - yMind, yMax, zMax - zMind, zMax);
        createOctree(root->top_left_back, maxdepth, xMin, xMax - xMind, yMin, yMax - yMind, zMax - zMind, zMax);
        createOctree(root->top_right_front, maxdepth, xMax - xMind, xMax, yMax - yMind, yMax, zMax - zMind, zMax);
        createOctree(root->top_right_back, maxdepth, xMax - xMind, xMax, yMin, yMax - yMind, zMax - zMind, zMax);
        createOctree(root->bottom_left_front, maxdepth, xMin, xMax - xMind, yMax - yMind, yMax, zMin, zMax - zMind);
        createOctree(root->bottom_left_back, maxdepth, xMin, xMax - xMind, yMin, yMax - yMind, zMin, zMax - zMind);
        createOctree(root->bottom_right_front, maxdepth, xMax - xMind, xMax, yMax - yMind, yMax, zMin, zMax - zMind);
        createOctree(root->bottom_right_back, maxdepth, xMax - xMind, xMax, yMin, yMax - yMind, zMin, zMax - zMind);
    }
}

int i = 1;
//先序遍历八叉树
template <class T>
void preOrder(OctreeNode<T> * & p)
{
    if (p)
    {
        cout << i << ".当前节点的值为：" << p->data << "\n坐标为：";
        cout << " xMin: " << p->xMin << " xMax: " << p->xMax;
        cout << " yMin: " << p->yMin << " yMax: " << p->yMax;
        cout << " zMin: " << p->zMin << " zMax: " << p->zMax;
        i += 1;
        cout << endl;
        preOrder(p->top_left_front);
        preOrder(p->top_left_back);
        preOrder(p->top_right_front);
        preOrder(p->top_right_back);
        preOrder(p->bottom_left_front);
        preOrder(p->bottom_left_back);
        preOrder(p->bottom_right_front);
        preOrder(p->bottom_right_back);
        cout << endl;
    }
}

//求八叉树的深度
template<class T>
int depth(OctreeNode<T> *& p)
{
    if (p == NULL)
        return -1;
    int h = depth(p->top_left_front);
    return h + 1;
}

//计算单位长度，为查找点做准备
int cal(int num)
{
    int result = 1;
    if (1 == num)
        result = 1;
    else
    {
        for (int i = 1; i < num; i++)
            result = 2 * result;
    }
    return result;
}

//查找点
int maxdepth = 0;
int times = 0;
static double xMin = 0, xMax = 0, yMin = 0, yMax = 0, zMin = 0, zMax = 0;
int tmaxdepth = 0;
double txm = 1, tym = 1, tzm = 1;

template<class T>
void find(OctreeNode<T> *& p, double x, double y, double z)
{
    double xMind = (p->xMax - p->xMin) / 2;
    double yMind = (p->yMax - p->yMin) / 2;
    double zMind = (p->yMax - p->yMin) / 2;
    times++;
    if (x > xMax || x<xMin || y>yMax || y<yMin || z>zMax || z < zMin)
    {
        cout << "该点不在场景中！" << endl;
        return;
    }
    if (x <= p->xMin + txm && x >= p->xMax - txm && y <= p->yMin + tym && 
        y >= p->yMax - tym && z <= p->zMin + tzm && z >= p->zMax - tzm)
    {
        cout << endl << "找到该点！" << "该点位于" << endl;
        cout << " xMin: " << p->xMin << " xMax: " << p->xMax;
        cout << " yMin: " << p->yMin << " yMax: " << p->yMax;
        cout << " zMin: " << p->zMin << " zMax: " << p->zMax;
        cout << "节点内！" << endl;
        cout << "共经过" << times << "次递归！" << endl;
    }
    else if (x < (p->xMax - xMind) && y < (p->yMax - yMind) && z < (p->zMax - zMind))
    {
        cout << "当前经过节点坐标：" << endl;
        cout << " xMin: " << p->xMin << " xMax: " << p->xMax;
        cout << " yMin: " << p->yMin << " yMax: " << p->yMax;
        cout << " zMin: " << p->zMin << " zMax: " << p->zMax;
        cout << endl;
        find(p->bottom_left_back, x, y, z);
    }
    else if (x < (p->xMax - xMind) && y<(p->yMax - yMind) && z>(p->zMax - zMind))
    {
        cout << "当前经过节点坐标：" << endl;
        cout << " xMin: " << p->xMin << " xMax: " << p->xMax;
        cout << " yMin: " << p->yMin << " yMax: " << p->yMax;
        cout << " zMin: " << p->zMin << " zMax: " << p->zMax;
        cout << endl;
        find(p->top_left_back, x, y, z);
    }
    else if (x > (p->xMax - xMind) && y < (p->yMax - yMind) && z < (p->zMax - zMind))
    {
        cout << "当前经过节点坐标：" << endl;
        cout << " xMin: " << p->xMin << " xMax: " << p->xMax;
        cout << " yMin: " << p->yMin << " yMax: " << p->yMax;
        cout << " zMin: " << p->zMin << " zMax: " << p->zMax;
        cout << endl;
        find(p->bottom_right_back, x, y, z);
    }
    else if (x > (p->xMax - xMind) && y<(p->yMax - yMind) && z>(p->zMax - zMind))
    {
        cout << "当前经过节点坐标：" << endl;
        cout << " xMin: " << p->xMin << " xMax: " << p->xMax;
        cout << " yMin: " << p->yMin << " yMax: " << p->yMax;
        cout << " zMin: " << p->zMin << " zMax: " << p->zMax;
        cout << endl;
        find(p->top_right_back, x, y, z);
    }
    else if (x<(p->xMax - xMind) && y>(p->yMax - yMind) && z < (p->zMax - zMind))
    {
        cout << "当前经过节点坐标：" << endl;
        cout << " xMin: " << p->xMin << " xMax: " << p->xMax;
        cout << " yMin: " << p->yMin << " yMax: " << p->yMax;
        cout << " zMin: " << p->zMin << " zMax: " << p->zMax;
        cout << endl;
        find(p->bottom_left_front, x, y, z);
    }
    else if (x<(p->xMax - xMind) && y>(p->yMax - yMind) && z > (p->zMax - zMind))
    {
        cout << "当前经过节点坐标：" << endl;
        cout << " xMin: " << p->xMin << " xMax: " << p->xMax;
        cout << " yMin: " << p->yMin << " yMax: " << p->yMax;
        cout << " zMin: " << p->zMin << " zMax: " << p->zMax;
        cout << endl;
        find(p->top_left_front, x, y, z);
    }
    else if (x > (p->xMax - xMind) && y > (p->yMax - yMind) && z < (p->zMax - zMind))
    {
        cout << "当前经过节点坐标：" << endl;
        cout << " xMin: " << p->xMin << " xMax: " << p->xMax;
        cout << " yMin: " << p->yMin << " yMax: " << p->yMax;
        cout << " zMin: " << p->zMin << " zMax: " << p->zMax;
        cout << endl;
        find(p->bottom_right_front, x, y, z);
    }
    else if (x > (p->xMax - xMind) && y > (p->yMax - yMind) && z > (p->zMax - zMind))
    {
        cout << "当前经过节点坐标：" << endl;
        cout << " xMin: " << p->xMin << " xMax: " << p->xMax;
        cout << " yMin: " << p->yMin << " yMax: " << p->yMax;
        cout << " zMin: " << p->zMin << " zMax: " << p->zMax;
        cout << endl;
        find(p->top_right_front, x, y, z);
    }
}


//main函数
int main()
{
    OctreeNode<double> * rootNode = NULL;
    int choiced = 0;
    while (true)
    {
        system("cls");
        cout << "请选择操作：\n";
        cout << "1.创建八叉树 2.先序遍历八叉树\n";
        cout << "3.查看树深度 4.查找节点   \n";
        cout << "0.退出\n\n";
        cin >> choiced;
        if (choiced == 0)
        {
            return 0;
        }
        else if (choiced == 1)
        {
            system("cls");
            cout << "请输入最大递归深度：" << endl;
            cin >> maxdepth;
            cout << "请输入外包盒坐标，顺序如下：xMin,xMax,yMin,yMax,zMin,zMax" << endl;
            cin >> xMin >> xMax >> yMin >> yMax >> zMin >> zMax;
            if (maxdepth >= 0 || xMax > xMin || yMax > yMin || zMax > zMin || xMin > 0 || yMin > 0 || zMin > 0)
            {
                tmaxdepth = cal(maxdepth);
                txm = (xMax - xMin) / tmaxdepth;
                tym = (yMax - yMin) / tmaxdepth;
                tzm = (zMax - zMin) / tmaxdepth;
                createOctree(rootNode, maxdepth, xMin, xMax, yMin, yMax, zMin, zMax);
            }
            else
            {
                cout << "输入错误！";
                return 0;
            }
        }
        else if (choiced == 2)
        {
            system("cls");
            cout << "先序遍历八叉树结果：\n";
            i = 1;
            preOrder(rootNode);
            cout << endl;
            system("pause");
        }
        else if (choiced == 3)
        {
            system("cls");
            int dep = depth(rootNode);
            cout << "此八叉树的深度为" << dep + 1 << endl;
            system("pause");
        }
        else if (choiced == 4)
        {
            system("cls");
            cout << "请输入您希望查找的点的坐标，顺序如下：x,y,z\n";
            double x, y, z;
            cin >> x >> y >> z;
            times = 0;
            cout << endl << "开始搜寻该点……" << endl;
            find(rootNode, x, y, z);
            system("pause");
        }
        else
        {
            system("cls");
            cout << "\n\n错误选择！\n";
            system("pause");
        }
    }
}
cmake.EXE
关注
  • 9
    点赞
  • 踩
  • 50
    收藏
    觉得还不错? 一键收藏
  • 7
    评论
专栏目录
c++八叉树实现
10-13
使用c++的八叉树实现，八叉树（Octree）的定义是：若不为空树的话，树中任一节点的子节点恰好只会有八个，或零个，也就是子节点不会有0与8以外的数目。
八叉树学习（Being_young部分博客参考加上书的内容）
weixin_43384504的博客
06-01 382
1.octree是一种用于管理稀疏3D数据的树形数据结构，每个内部节点都正好有八个子节点，介绍如何用octree在点云数据中进行空间划分及近邻搜索，实现“体素内近邻搜索（Neighbors within VOxel Search）”,"K近邻搜索（K Nearest Neighbor Search）","半径内近邻搜索"（Neighbors within Radius Search）K近邻搜索（K...
C++基础编程总结（代码实例）
最新发布
马上到我碗里来的博客
02-20 2097
数据类型 数组名[ 数组长度 ];数据类型 数组名[ 数组长度 ] = { 值1，值2 ...};数据类型 数组名[ ] = { 值1，值2 ...};//定义方式1//数据类型 数组名[元素个数];//利用下标赋值//利用下标输出//第二种定义方式//数据类型 数组名[元素个数] = {值1，值2 ，值3 ...};//如果{}内不足10个数据，剩余数据用0补全//逐个输出//一个一个输出太麻烦，因此可以利用循环进行输出i < 10;i++)
八叉树，内存无忧！
3D视觉工坊
08-20 368
3DCV有幸邀请到顶会作者Gernot Riegler与大家一起分享他的最新文章，如果您有相关工作需要分享，文末可以联系我们！在公众号「3D视觉工坊」后台，回复「原论文」即可获取pdf和代码。添加微信：dddvisiona，备注：三维点云，拉你入群。文末附行业细分群。1 前言大多数现有的3D网络架构通过稠密且规则的三维体素网格来代替2D像素阵列，并使用3D卷积和池化操作来处理该网格。然而，对于稠密...
四叉树与八叉树原理
weixin_34337265的博客
03-09 599
‘转’在前面 四叉树和八叉树就是2D和3D的“二分法”，搜索过程与二叉树搜索也类似，二叉树中是将数组sort后存入二叉树中，从而在查找中实现时间复杂度为log2N；四叉树/八叉树是按平面/空间范围划分有序node，将所有points（坐标已知，但是每个点的point在vector中的index可以认为是随机的，没有规律的，所以不能直接根据index取出point(x,y)）放入所属node中，实...
9、Neural Sparse Voxel Fields
小白的博客
08-10 1316
nerf
sparse-voxel-octrees, CPU稀疏素八叉树实现.zip
10-10
sparse-voxel-octrees, CPU稀疏素八叉树实现 稀疏体素八叉方案在 C++ 中实现了多线程。CPU稀疏的体素八叉树实现，能够实时跟踪大型数据集，将原始体素文件转换为八叉树，转化为。转换例程能够处理比工作内存大得多的数据集，从而允许创建和呈现非常大的八叉树( 分辨率 8192
八叉树静态Octree(点云) C++代码
qq_34512507的博客
04-12 1694
该代码为静态生成八叉树代码，一经创建，不可改变 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) { th
八叉树，用C++实现简单的八叉树类
JamesXue的博客
07-04 569
八叉树的C++实现代码。
八叉树Octree
热门推荐
Augusdi的专栏
06-30 3万+
维基释义：八叉树（Octree）是一种用于描述三维空间的树状数据结构。八叉树的每个节点表示一个正方体的体积元素，每个节点有八个子节点，这八个子节点所表示的体积元素加在一起就等于父节点的体积。一般中心点作为节点的分叉中心。百度百科释义：八叉树（Octree）的定义是：若不为空树的话，树中任一节点的子节点恰好只会有八个，或零个，也就是子节点不会有0与8以外的数目。那么，这要用来做什么？想象一个立方体，
C++实现八叉树
NINE_world的博客
10-24 1013
【代码】C++实现八叉树。
八叉树代码 最近点查找 八叉树代码
04-19
八叉树代码，实现最近点查找，内包含点云实例(Octree code to find the nearest point to achieve, and contains the point cloud instances)
VC实现的八叉树数据结构源代码
12-10
用VC实现的八叉树数据结构，十一个完整的工程，可以运行，通过该实例代码可以对八叉树的创建以及基本操作有比较清楚的认识。
稀疏八叉树：一种稀疏八叉树数据结构
02-01
稀疏八度 一种基于指针的稀疏八叉树数据结构。 有关线性实现，请参见 。 ·· 安装 该库需要对等依赖关系 。 npm install math-ds sparse-octree 用法 点数 import { Vector3 } from "math-ds" ; import { PointOctree } from "sparse-octree" ; const min = new Vector3 ( - 1 , - 1 , - 1 ) ; const max = new Vector3 ( 1 , 1 , 1 ) ; const octree = new PointOctree ( min , max ) ; const myData = { } ; const p1 = new Vector3 ( 0 , 0 , 0 ) ; const p2 = new Vector3 ( 0 , 0 , 0.5 ) ; octree . insert ( p1 , myData ) ; octree . move ( p1 , p2 ) ; octree . get ( p2 ) ; //
基于八叉树的三维网格模型体素化方法
06-13
利用八叉树进行三维网格模型体素化的一种方法
八叉树代码
06-30
这是一个关于八叉树的完整文件，所有注释和说明都有，可以给门外汉很好的帮助
八叉树颜色量化_八叉树_
09-30
该算法最早见于文章最早是在1988
matlab八叉树的建立.zip_MATLAB八叉树_matlab 八叉树_matlab 树_八叉树 matlab_八叉树mat
07-14
使用matlab的struct结构，建立一个八叉树
八叉树Demo - Unity下
06-24
八叉树Demo - Unity下 ， 基于四叉树的修改 https://blog.csdn.net/u010019717/article/details/80789271

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值