Octree based Point Cloud Downsample

最新推荐文章于 2021-11-29 17:50:23 发布
最新推荐文章于 2021-11-29 17:50:23 发布
阅读量867 收藏 3
点赞数
分类专栏： C++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_25826371/article/details/49947631
版权

本算法基于哈希八叉树，并可进行按比例抽稀。

基本思路是迭代执行如下步骤直到目标数量ReserveNum等于0：

1）抽取不大于目标数量ReserveNum的前N层点云，并实时调整八叉树，类似从二叉树中pop元素；

2）更新目标数量ReserveNum为原值减去已去除的点云数量；


Notice: this code is a demo. No optimization tech has been used.


#include "tgHashedOctree.h"

int main(int argc, char* argv[])
{
	//
	std::vector<double> l_lstX;
	std::vector<double> l_lstY;
	std::vector<double> l_lstZ;
	//
	// put point cloud into l_lstX, l_lstY, l_lstZ
	// 
	tg::mesh::HashedOctree l_oHashedOctree;
	for (int i = 0; i < l_lstX.size(); ++i)
		l_oHashedOctree.AddPoint(l_lstX[i], l_lstY[i], l_lstY[i], i);

	std::vector<size_t> l_lstIndex;
	l_oHashedOctree.DownSample(l_dRadio, l_lstIndex);

	return 0;
}

Header File 

/*
Hashed Octree

Copyright (C) by Tony Gauss (gaoxing.mes@gmail.com) in 2015

License : MIT
http://opensource.org/licenses/MIT

Permission is hereby granted, free of charge, to any person obtaining a copy of this software
and associated documentation files (the "Software"), to deal in the Software without restriction,
including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense,
and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so,
subject to the following conditions:

The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT
LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

*/

#ifndef ___tgHashedOctree___
#define ___tgHashedOctree___

#include <unordered_map>

namespace tg
{

/*

HashedOctree
this class defines a hashed octree, only the indices of the input points will be stored in 
the octree, a downsample method is developed based on this octree
Notic: downsample will clear the octree

*/
class HashedOctree
{
public:
	///
	// constructors and destructor

	HashedOctree(const int&	i_nMaxDepth = 20);

	~HashedOctree();

	///
	// public member functions

	// Add a normalized point into the Octree, 
	void AddPoint(	const double	i_dX	,	// Range [-0.5, 0.5]
					const double	i_dY	,	// Range [-0.5, 0.5]
					const double	i_dZ	,	// Range [-0.5, 0.5]
					const size_t	i_sIndex);	// index of the point in the original point cloud

	// Downsample the point cloud based on Octree
	void DownSample(	const double				i_dRatio	,	// reserve ratio
								std::vector<size_t>&		i_lstIndex	);	// indices of points that are reserverd

	// show how many depth of the Octree have been filled
	int GetFilledDepth() const;

	// show how many points the Octree contains
	size_t Size() const;

private:
	///
	// private member functions

	// Get the key of the child no deeper than a threshold
	size_t GetChildNoDeeperThan(size_t			i_sKey		,	// input key
								const int&		i_nDepthThre);	// threshold depth

	// Remove all points above a threshold depth
	void RemoveNodesAboveDepth(	size_t			i_sKey		,	// initial key, should be 1
								int				i_nDepthCur	,	// initial Depth, should be 1
								const int&		i_nDepthThre);	// threshold depth

	// Get all points below a threshold depth
	void GetPointsBelowDepth(	std::vector<size_t>&		i_lstIndex	,	// indices list to contain the result
								size_t						i_sKey		,	// initial key, should be 1
								int							i_nDepthCur	,	// initial Depth, should be 1
								const int&					i_nDepthThre);	// threshold depth

	///
	// private variables

	int m_nMaxDepth		;		// max depth of the octree
	int m_nFilledDepth	;		// filled depth of the octree
	size_t m_sReserveNum;		// number of points that shall be reserved

	std::vector<size_t> m_lstDepthPointNum;		// number of points in each depth

	std::unordered_map<size_t, std::vector<size_t> > m_oHashedOctree;	// hash map to store the octree
	
};

};

#endif

Source File 


/*
Hashed Octree

Copyright (C) by Tony Gauss (gaoxing.mes@gmail.com) in 2015

License : MIT
http://opensource.org/licenses/MIT

Permission is hereby granted, free of charge, to any person obtaining a copy of this software
and associated documentation files (the "Software"), to deal in the Software without restriction,
including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense,
and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so,
subject to the following conditions:

The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT
LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

*/

#include "tgHashedOctree.h"

namespace tg
{

HashedOctree::HashedOctree(const int&	i_nMaxDepth)
{
	this->m_nMaxDepth = i_nMaxDepth;
	this->m_lstDepthPointNum.resize(this->m_nMaxDepth + 1, 0);
	this->m_nFilledDepth = 0;
}

HashedOctree::~HashedOctree()
{

}

size_t HashedOctree::Size() const
{
	size_t l_sCurNum = 0;
	for (int i = 0; i <= this->m_nMaxDepth; ++i)
	{
		l_sCurNum += this->m_lstDepthPointNum[i];
	}
	return l_sCurNum;
}

int HashedOctree::GetFilledDepth() const
{
	return this->m_nFilledDepth;
}

void HashedOctree::AddPoint(const double	i_dX		,
							const double	i_dY		,
							const double	i_dZ		,
							const size_t	i_sIndex	)
{
	//assert(i_dX >= -0.5 && i_dX <= 0.5);
	//assert(i_dY >= -0.5 && i_dY <= 0.5);
	//assert(i_dZ >= -0.5 && i_dZ <= 0.5);

	double l_dCentroid[3] = { 0 };
	size_t l_sLabelAll = 1;
	if (this->m_oHashedOctree.find(l_sLabelAll) == this->m_oHashedOctree.end())
	{
		this->m_oHashedOctree[l_sLabelAll].push_back(i_sIndex);
		this->m_nFilledDepth = 1;
		this->m_lstDepthPointNum[0]++;
		return;
	}

	int i;
	const size_t l_s1 = 1;
	for (i = 1; i < this->m_nMaxDepth; ++i)
	{
		size_t l_sLabel = 0;
		double l_dStep = 0.5 / (l_s1 << i);
		if (i_dX > l_dCentroid[0])
		{
			l_sLabel += 1;
			l_dCentroid[0] += l_dStep;
		}
		else
		{
			l_dCentroid[0] -= l_dStep;
		}
		if (i_dY > l_dCentroid[1])
		{
			l_sLabel += 2;
			l_dCentroid[1] += l_dStep;
		}
		else
		{
			l_dCentroid[1] -= l_dStep;
		}
		if (i_dZ > l_dCentroid[2])
		{
			l_sLabel += 4;
			l_dCentroid[2] += l_dStep;
		}
		else
		{
			l_dCentroid[2] -= l_dStep;
		}
		l_sLabelAll = (l_sLabelAll << 3) + l_sLabel;

		if (this->m_oHashedOctree.find(l_sLabelAll) == this->m_oHashedOctree.end())
		{
			++i;
			break;
		}
	}
	this->m_nFilledDepth = this->m_nFilledDepth > i ? this->m_nFilledDepth: i;
	this->m_lstDepthPointNum[i-1]++;

	this->m_oHashedOctree[l_sLabelAll].push_back(i_sIndex);
}

void HashedOctree::DownSample(	const double			i_dRatio	,
								std::vector<size_t>&	i_lstIndex	)
{
	assert(i_dRatio > 0);
	assert(i_dRatio <= 1.0);

	this->m_sReserveNum = this->Size() * i_dRatio;
	if(this->m_sReserveNum == 0)
		return;

	i_lstIndex.reserve(this->m_sReserveNum);
	while (i_lstIndex.size() < this->m_sReserveNum)
	{
		/
		// Find depth threshold
		size_t l_sCurNum = i_lstIndex.size();
		int l_nDepthThre;
		for (l_nDepthThre = 0; l_nDepthThre <= this->m_nMaxDepth; ++l_nDepthThre)
		{
			l_sCurNum += this->m_lstDepthPointNum[l_nDepthThre];
			if (l_sCurNum > this->m_sReserveNum)
				break;
		}

		/
		// Get points in depth below l_nDepthThre
		this->GetPointsBelowDepth(i_lstIndex, 1, 0, l_nDepthThre);

		printf("[%I64u/%I64u], Threshold: %d\n", i_lstIndex.size(), this->m_sReserveNum, l_nDepthThre);
	}
	this->m_oHashedOctree.clear();
}

void HashedOctree::GetPointsBelowDepth(	std::vector<size_t>&	i_lstIndex	,
										size_t					i_sKey		,
										int						i_nDepthCur	,
										const int&				i_nDepthThre)
{
	// return if threshold is reached
	if (i_nDepthCur >= i_nDepthThre)
		return;

	// return if this node does Not exits, which implies it has No child
	auto iter = this->m_oHashedOctree.find(i_sKey);
	if (iter == this->m_oHashedOctree.end())
		return;

	// Get a point from this node
	i_lstIndex.push_back(iter->second[0]);
	// Find the deepest (no deeper than the threshold) child of this node
	size_t l_sKeyTmp = GetChildNoDeeperThan(i_sKey, i_nDepthThre);
	// if the child's depth is equal to the threshold, move one point from child to this node 
	if ((l_sKeyTmp >> (3 * i_nDepthThre)) > 0)
	{
		auto iterTmp = this->m_oHashedOctree.find(l_sKeyTmp);
		iter->second[0] = iterTmp->second.back();
		iterTmp->second.pop_back();
		if (!iterTmp->second.size())
			this->m_oHashedOctree.erase(iterTmp);

		--this->m_lstDepthPointNum[i_nDepthThre];
	}
	// otherwise remove this node
	else
	{
		this->m_oHashedOctree.erase(iter);
		--this->m_lstDepthPointNum[i_nDepthCur];
	}
	// recursively ... until the threshold depth is reached
	i_sKey = (i_sKey << 3);
	for (size_t i = 0; i < 8; ++i)
	{
		this->GetPointsBelowDepth(i_lstIndex, i_sKey + i, i_nDepthCur + 1, i_nDepthThre);
	}
}

size_t HashedOctree::GetChildNoDeeperThan(	size_t		i_sKey		,
											const int&	i_nDepthThre)
{
	size_t l_sKeyMax = i_sKey;
	i_sKey = (i_sKey << 3);
	for (size_t i = 0; i < 8; ++i)
	{
		auto iter = this->m_oHashedOctree.find(i_sKey + i);
		if (iter != this->m_oHashedOctree.end())
		{
			if (((i_sKey + i) >> (3 * i_nDepthThre)) > 0)
				return i_sKey + i;

			size_t l_sKeyTmp = GetChildNoDeeperThan(i_sKey + i, i_nDepthThre);
			l_sKeyMax = l_sKeyMax > l_sKeyTmp ? l_sKeyMax : l_sKeyTmp;
		}
	}
	return l_sKeyMax;
}

void HashedOctree::RemoveNodesAboveDepth(	size_t		i_sKey		,	// initial key, should be 1
											int			i_nDepthCur	,	// initial Depth, should be 1
											const int&	i_nDepthThre)	// threshold depth
{
	// return if reached max depth
	if (i_nDepthCur > this->m_nMaxDepth)
		return;

	// return if this node does Not exits, which implies it has No child
	auto iter = this->m_oHashedOctree.find(i_sKey);
	if (iter == this->m_oHashedOctree.end())
		return;

	// remove this node if its depth is larger than threshold
	if (i_nDepthCur > i_nDepthThre)
	{
		this->m_oHashedOctree.erase(iter);
		--this->m_lstDepthPointNum[i_nDepthCur];
	}

	// recursively ... 
	i_sKey = (i_sKey << 3);
	for (size_t i = 0; i < 8; ++i)
	{
		this->RemoveNodesAboveDepth(i_sKey + i, i_nDepthCur + 1, i_nDepthThre);
	}
}

}




TG-Gaoxing
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
点云下采样方法总结（downsampling in pointcloud）
weixin_43955917的博客
05-11 8090
前言：相比于投影或体素分割的方法处理点云，直接对点云进行特征提取能较好地保留三维结构信息，但由于点云的无序性，直接处理的方式在对邻域进行搜索时需要较高的计算成本。一个常用的解决方式就是对点云进行下采样，将对全部点云的操作转换到下采样所得到的关键点上，降低计算量。FPS(farthest point sampling)是一种较为常用的非学习式的下采样方法，其具有简单快速的特点，因此成为众多点云处理网络的采样方案，但是FPS仅仅是基于点的位置和欧式距离作为采样依据，对点云的稀疏性以及语义信息无感，所以在进行高层
点云降采样（DownSampling）
热门推荐
MSTIFIY的博客
07-26 1万+
点云降采样学习笔记
vtk-PolyData/DownsamplePointCloud
小可爱的博客
01-03 371
官方例子：https://lorensen.github.io/VTKExamples/site/Cxx/PolyData/DownsamplePointCloud/ #include <vtkSmartPointer.h> #include <vtkPointSource.h> #include <vtkPolyData.h> #include <vtk...
Octree-based convolutional neural network summary
windyafx的博客
09-11 605
在3D shape的分类、检索、分割等应用中，使用神经网络面临的一大挑战是3D shape的不规则性。 已有的应有： 使用3D object在多个特定角度下的投影，作为输入，使用神经网络进行处理 使用voxel-based 的方法，每一个三维cube都使用binary 表示是否为3D object的一部分，这样就解决了 irregularity的问题。 使用geometry image的方法，将3
基于ROS的激光点云处理（点云降采样、欧式聚类分割的目标检测、地面拟合分割）
01-08
完整的ROS工程，针对激光点云数据，可以实现点云降采样处理、基于欧氏距离聚类分割的目标检测和地面拟合分割算法。可以直接使用。
PointCloud_Segmentation
04-29
使用Octree进行点云分割1.先决条件我已经在Ubuntu 16.04中测试了该库，但是在其他平台上应该很容易编译。C ++ 11或C ++ 0x编译器穿山甲我使用进行可视化和用户界面。 下载和安装说明可以在以下找到： : 。本征3 下载...
SimpleOctree:一个简单且快速的Octree实现，支持最近的Neigbour搜索
05-26
简单八度警告：当前存在一个错误，需要... 一个简单且快速的Octree实现，支持Nearest Neigbour Search。 该代码使用池分配器，但是很容易将其换成malloc / free。 该代码已在CC0下获得许可/已发布到Public Domain中。
kdree_octree
10-10
《kdree_octree：Python实现的kd树与八叉树数据结构及其应用》 在计算机图形学、机器学习以及地理信息系统等领域，数据的高效存储和检索是至关重要的。kd树（K-dimensional Tree）和八叉树（Octree）是两种常用的...
Deep Learning and Multimodal Fusion of 3D Point Cloud
最新发布
09-05
本文将深入探讨"Deep Learning and Multimodal Fusion of 3D Point Cloud"这一主题，旨在为读者提供全面且深入的理解。 一、3D深度学习基础 3D深度学习是针对3D数据进行的机器学习，主要利用神经网络模型处理点云...
point_cloud_viewer:在浏览器中查看数十亿个点
04-29
点查看器 这是一个独立的项目，可让您轻松便捷地查看大量点云。 它是为满足项目的需要而构建的，但它本身很有用。... 然后使用target/release/build_octree从PLY文件中生成一个八叉树。 SDL客户端 这是使
点云分割入门（2）——基于区域生长的分割算法
MyLying97的博客
08-05 7505
二 基于区域的分割算法 其中,kd树用来获得点云的拓扑结构，可以得到邻域信息。对于kd树，这就简单说一下，网上资料很全。 （点云空间拓扑关系的建立方式主要有Octree 法和 KD-tree 法）。 根据PCL官网例程得到的结果如下图所示： PCL官网：http://pointclouds.org/documentation/tutorials/#segmentation-tutorial ...
ROS PCL 点云处理学习之二 Downsampling a PointCloud using a VoxelGrid filter
02-21 2259
mkdir test2 cd test2 touch voxel_grid.cpp gedit voxel_grid.cpp #include #include #include #include int main (int argc, char** argv) { pcl::PCLPointCloud2::Ptr cloud (new pcl::PCLPointCloud2
（十二）OcTree教程四--OcTree在PCL中的应用-点云压缩
jiaojialulu的专栏
04-05 7076
点云压缩点云带有大量的数据，不仅包括三维信息，还有额外的距离，颜色，法向量等等。此外，点云可以快速生成，这会占有大量的内存资源。一旦点云必须被存储或者用于通信传输，对于点云的压缩技术就显得十分重要了。PCL提供了点云压缩功能，它支持对各种类型点云的压缩，其中包括无序点云，此外，在八叉树结构下的数据支持高效地合并多个来自不同数据源的点云。 下面我们将一个点云进行压缩，压缩的结果是一个String
octree与kd-tree对比
GspeedChen的博客
07-06 3173
octree与kd-tree对比 问题1：哪个速度更快 问题2;octree可以在建立完成之后再增长规模吗 1. Comparison of nearest-neighbor-search strategies and implementations for efficient shape registration 最近邻搜索nn问题有很多中方法，nns问题最差的时间复杂是O（nm）;平均复杂度是O(nlogm)；在点云领域常用的是kd-tree octree;其他的方法有R-tree、range-tr
下采样downsample代码
微电子学与固体电子学-俞驰
09-14 2656
针对二分类表格数据任务 [1]代码如下： def df_train(df_train): number_records_fraud = len(df_train[df_train.isFraud == 1])#多少数据 fraud_indices = np.array(df_train[df_train.isFraud == 1].index)#isFraud＝１数...
【点云空间索引】python-pcl：KdTree与八叉树
qq_40985985的博客
09-04 6231
点云数据主要是表征目标表面的海量点集合，并不具备传统实体网格数据的几何拓扑信息。点云处理中最核心的问题就是建立离散点间的拓扑结构。实现基于邻域关系的快速查找，划分空间的索引结构主要有：k-d tree，八叉树。...
PCL中Octree模块中类的说明
CFH1021的博客
11-29 2331
文章目录1. class Octree2BufBase2. class OctreeBase3. class OctreeContainerBase4. class OctreeIteratorBase5. class OctreeKey6. class OctreeNodePool7. class OctreeNode8. class OctreePointCloud9. class OctreePointCloudAdjacency10. class OctreePointCloudAdjacencyC
PCL的downsample(体素滤波)
ethan_guo的博客
05-02 8062
转载于：https://www.cnblogs.com/li-yao7758258/p/6445831.html　　　使用体素化网格方法实现下采样，即减少点的数量 减少点云数据，并同时保存点云的形状特征，在提高配准，曲面重建，形状识别等算法速度中非常实用，PCL是实现的VoxelGrid类通过输入的点云数据创建一个三维体素栅格，容纳后每个体素内用体素中所有点的重心来近似显示体素中其他点，这样该体素...
叉树Octree原理及简单实现（C++版）
06-08
叉树Octree是一种用于空间分割的数据结构，常用于计算机图形学、物理模拟等领域。其原理是将空间递归地分割成八个子空间，每个子空间又可以继续递归地分割成八个子空间，直到最小空间达到一定的大小。 C++中可以通过定义节点类和递归函数来实现叉树Octree。以下是一个简单的实现： ```c++ #include <iostream> #include <vector> #include <cmath> using namespace std; class Node { public: double x, y, z; // 三维坐标 double size; // 此节点所代表的空间大小 vector<Node*> children; // 子节点指针数组 Node(double x_, double y_, double z_, double size_) { x = x_; y = y_; z = z_; size = size_; children.resize(8, nullptr); } }; void insert(Node* node, double x, double y, double z, double size) { if (size <= node->size) { // 如果此节点的大小大于等于当前空间大小，则将此空间添加到此节点的子节点中 if (node->children[0] == nullptr) { // 如果当前节点还没有子节点，则创建 node->children[0] = new Node(node->x - node->size / 4, node->y - node->size / 4, node->z - node->size / 4, node->size / 2); node->children[1] = new Node(node->x + node->size / 4, node->y - node->size / 4, node->z - node->size / 4, node->size / 2); node->children[2] = new Node(node->x - node->size / 4, node->y + node->size / 4, node->z - node->size / 4, node->size / 2); node->children[3] = new Node(node->x + node->size / 4, node->y + node->size / 4, node->z - node->size / 4, node->size / 2); node->children[4] = new Node(node->x - node->size / 4, node->y - node->size / 4, node->z + node->size / 4, node->size / 2); node->children[5] = new Node(node->x + node->size / 4, node->y - node->size / 4, node->z + node->size / 4, node->size / 2); node->children[6] = new Node(node->x - node->size / 4, node->y + node->size / 4, node->z + node->size / 4, node->size / 2); node->children[7] = new Node(node->x + node->size / 4, node->y + node->size / 4, node->z + node->size / 4, node->size / 2); } for (int i = 0; i < 8; i++) { // 递归插入 insert(node->children[i], x, y, z, size / 2); } } } int main() { Node* root = new Node(0, 0, 0, 1); // 创建根节点 insert(root, 0.5, 0.5, 0.5, 0.1); // 插入一个大小为0.1的空间，其坐标为(0.5,0.5,0.5) return 0; } ``` 在这个简单的实现中，我们定义了一个节点类Node，包含了三维坐标和空间大小等属性，同时还有一个指向子节点的数组。我们通过递归函数insert来递归地插入新的空间，如果当前节点的大小大于等于要插入的空间大小，则将此空间插入到当前节点的子节点中，否则递归进入子节点。在main函数中，我们创建了一个根节点，并插入了一个大小为0.1的空间。 需要注意的是，此实现仅是一个简单的示例，实际应用中可能需要更复杂的节点类和插入函数。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值