c++实现kdTree创建以及最近邻点查找

最新推荐文章于 2022-01-04 19:17:17 发布
最新推荐文章于 2022-01-04 19:17:17 发布
阅读量3.2k 收藏 21
点赞数 2
分类专栏： C/C++编程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zfjBIT/article/details/95476288
版权

参考：

https://blog.csdn.net/zfjBIT/article/details/95370168

https://www.cnblogs.com/theodoric008/p/9475189.html

Kd-Tree的创建：

（1）在K维数据集合中选择具有最大方差的维度k，然后在该维度上选择中值m为起始节点对该数据集合进行划分，得到两个子集合；同时创建一个树结点node，用于存储；

（2）对两个子集合重复（1）步骤的过程，直至所有子集合都不能再划分为止；

Kd-Tree的最近邻查找：

（1）将查询数据Q从根结点开始，按照Q与各个结点的比较结果向下访问Kd-Tree，直至达到叶子结点。

        其中Q与结点的比较指的是将Q对应于结点中的k维度上的值与中值m进行比较，若Q(k) < m，则访问左子树，否则访问右子树。达到叶子结点时，计算Q与叶子结点上保存的数据之间的距离，记录下最小距离对应的数据点，记为当前最近邻点nearest和最小距离dis。
（2）进行回溯操作，该操作是为了找到离Q更近的“最近邻点”。即判断未被访问过的分支里是否还有离Q更近的点，它们之间的距离小于dis。
        如果Q与其父结点下的未被访问过的分支之间的距离小于dis，则认为该分支中存在离P更近的数据，进入该结点，进行（1）步骤一样的查找过程，如果找到更近的数据点，则更新为当前的最近邻点nearest，并更新dis。
        如果Q与其父结点下的未被访问过的分支之间的距离大于dis，则说明该分支内不存在与Q更近的点。
        回溯的判断过程是从下往上进行的，直到回溯到根结点时已经不存在与P更近的分支为止。

注：判断未被访问过的树分支中是否还有离Q更近的点，就是判断"Q与未被访问的树分支的距离|Q(k) - m|“是否小于"Q到当前的最近邻点nearest的距离dis”。从几何空间上来看，就是判断以Q为中心，以dis为半径超球面是否与未被访问的树分支代表的超矩形相交。

测试示例：

假设有6个二维数据点{（2,3），（5,4），（9,6），（4,7），（8,1），（7,2）}，数据点位于二维空间内（如下图中黑点所示）：

                  图1

递归创建Kd-Tree：

  1. 分别计算x，y方向上数据的方差，得知x方向上的方差最大；
  2. 根据x轴方向的值2,5,9,4,8,7排序选出中值为7，所以该node中的data = （7,2）。这样，该节点的分割超平面就是通过（7,2）并垂直于x轴的直线x = 7；
  3. 确定左子空间和右子空间。分割超平面x = 7将整个空间分为两部分，如下图所示。x < =  7的部分为左子空间，包含3个节点{（2,3），（5,4），（4,7）}；另一部分为右子空间，包含2个节点{（9,6），（8,1）}。

k-d树的构建是一个递归的过程。然后对左子空间和右子空间内的数据重复根节点的过程就可以得到下一级子节点（5,4）和（9,6）（也就是左右子空间的’根’节点），同时将空间和数据集进一步细分。如此反复直到空间中只包含一个数据点，如下图所示：

                                     图2

查找点Q(2.1,3.1)：

如下图所示，红色的点即为要查找的点。通过图2二叉搜索，顺着搜索路径很快就能找到当前的最邻近点（2,3）。

                                                              

                                                                               图3

       在上述搜索过程中，产生的搜索路径节点有<（7,2），（5,4），（2,3）>。为了找到真正的最近邻，还需要进行’回溯’操作，首先以（2,3）作为当前最近邻点nearest，计算其到查询点Q（2.1,3.1）的距离dis为0.1414，然后回溯到其父节点（5,4），并判断在该父节点的其他子节点空间中是否有距离查询点Q更近的数据点。以（2.1,3.1）为圆心，以0.1414为半径画圆，如图6所示。发现该圆并不和超平面y = 4交割，即这里：|Q(k) - m|=|3.1 - 4|=0.9 > 0.1414，因此不用进入（5,4）节点右子空间中去搜索。

                                                                 

                                                                                 图. 4

        再回溯到（7,2），以（2.1,3.1）为圆心，以0.1414为半径的圆更不会与x = 7超平面交割，因此不用进入（7,2）右子空间进行查找。至此，搜索路径中的节点已经全部回溯完，结束整个搜索，返回最近邻点（2,3），最近距离为0.1414。

#include <stdio.h>
#include <iostream>
#include <algorithm>
#include <iostream>
#include <vector>
#include <stack>
#include <cmath>

#define KDtreeSize 1000

#define UL unsigned long

using namespace std;

struct coordinate
{
	double x = 0;
	double y = 0;
	UL index = 0;
};

struct TreeNode
{
	struct coordinate dom_elt;
	UL split = 0;
	struct TreeNode* left = nullptr;
	struct TreeNode* right = nullptr;
};

bool cmp1(const coordinate& a, const coordinate& b) {
	return a.x < b.x;
}

bool cmp2(const coordinate& a, const coordinate& b) {
	return a.y < b.y;
}

bool equal(const coordinate& a, const coordinate& b) {
	return (a.x == b.x && a.y == b.y);
}

void ChooseSplit(coordinate exm_set[], UL size, UL &split, coordinate &SplitChoice) {
	/*
	1. 计算每个维度(x,y)的方差,从具有最大方差的维度开始切分，如x方向；
	2. 计算x方向的参数得中值，作为起始节点；
	*/

	double tmp1, tmp2;
	tmp1 = tmp2 = 0;
	for (int i = 0; i < size; ++i)
	{
		tmp1 += 1.0 / (double)size * exm_set[i].x * exm_set[i].x;
		tmp2 += 1.0 / (double)size * exm_set[i].x;
	}
	double v1 = tmp1 - tmp2 * tmp2;  //compute variance on the x dimension

	tmp1 = tmp2 = 0;
	for (int i = 0; i < size; ++i)
	{
		tmp1 += 1.0 / (double)size * exm_set[i].y * exm_set[i].y;
		tmp2 += 1.0 / (double)size * exm_set[i].y;
	}
	double v2 = tmp1 - tmp2 * tmp2;  //compute variance on the y dimension

	split = v1 > v2 ? 0 : 1; //set the split dimension

	//排序
	if (split == 0)
	{
		sort(exm_set, exm_set + size, cmp1);
	}
	else {
		sort(exm_set, exm_set + size, cmp2);
	}

	//set the split point value:中值
	SplitChoice.x = exm_set[size / 2].x;
	SplitChoice.y = exm_set[size / 2].y;
}

//递归创建kdtree
TreeNode* build_kdtree(coordinate exm_set[], UL size, TreeNode* T) {
	//call function ChooseSplit to choose the split dimension and split point
	if (size == 0) {
		return nullptr;
	}
	else {
		UL split;
		coordinate dom_elt;
		ChooseSplit(exm_set, size, split, dom_elt);//返回起始切分方向和起始节点
		coordinate exm_set_right[KDtreeSize];//存储位于左子空间的点
		coordinate exm_set_left[KDtreeSize]; //存储位于左子空间的点
		UL size_left, size_right;
		size_left = size_right = 0;

		if (split == 0)
		{
			//起始切分方向为x方向
			for (UL i = 0; i < size; ++i)
			{
				//小于等于节点dom_elt.x的属于左空间
				if (!equal(exm_set[i], dom_elt) && exm_set[i].x <= dom_elt.x)
				{
					exm_set_left[size_left].x = exm_set[i].x;
					exm_set_left[size_left].y = exm_set[i].y;
					size_left++;
				}//大于节点dom_elt.x的属于右空间
				else if (!equal(exm_set[i], dom_elt) && exm_set[i].x > dom_elt.x)
				{
					exm_set_right[size_right].x = exm_set[i].x;
					exm_set_right[size_right].y = exm_set[i].y;
					size_right++;
				}
			}
		}
		else {
			//起始切分方向为y方向
			for (UL i = 0; i < size; ++i)
			{
				//小于等于节点dom_elt.y的属于左空间
				if (!equal(exm_set[i], dom_elt) && exm_set[i].y <= dom_elt.y)
				{
					exm_set_left[size_left].x = exm_set[i].x;
					exm_set_left[size_left].y = exm_set[i].y;
					size_left++;
				}//大于节点dom_elt.y的属于左空间
				else if (!equal(exm_set[i], dom_elt) && exm_set[i].y > dom_elt.y)
				{
					exm_set_right[size_right].x = exm_set[i].x;
					exm_set_right[size_right].y = exm_set[i].y;
					size_right++;
				}
			}
		}
		T = new TreeNode;
		T->dom_elt.x = dom_elt.x;
		T->dom_elt.y = dom_elt.y;
		T->split = split;
		T->left = build_kdtree(exm_set_left, size_left, T->left);    //递归
		T->right = build_kdtree(exm_set_right, size_right, T->right);//递归
		return T;
	}
}

//计算两点间距离
double Distance(coordinate a, coordinate b) {
	double tmp = (a.x - b.x) * (a.x - b.x) + (a.y - b.y) * (a.y - b.y);
	return sqrt(tmp);
}

//搜索最邻近点
void searchNearest(TreeNode * Kd, coordinate target, coordinate &nearestpoint, double & distance) {

	//1. 如果Kd是空的，则设dist为无穷大返回
	//2. 向下搜索直到叶子结点
	stack<TreeNode*> search_path;
	TreeNode* pSearch = Kd;
	coordinate nearest;
	double dist;

	while (pSearch != nullptr)
	{
		//pSearch加入到search_path中;
		search_path.push(pSearch);

		if (pSearch->split == 0)
		{
			if (target.x <= pSearch->dom_elt.x) /* 如果小于就进入左子树 */
			{
				pSearch = pSearch->left;
			}
			else
			{
				pSearch = pSearch->right;
			}
		}
		else {
			if (target.y <= pSearch->dom_elt.y) /* 如果小于就进入左子树 */
			{
				pSearch = pSearch->left;
			}
			else
			{
				pSearch = pSearch->right;
			}
		}
	}
	//取出search_path最后一个赋给nearest
	nearest.x = search_path.top()->dom_elt.x;
	nearest.y = search_path.top()->dom_elt.y;
	search_path.pop();

	dist = Distance(nearest, target);
	//3. 回溯搜索路径
	TreeNode* pBack;

	while (search_path.empty())
	{
		//取出search_path最后一个结点赋给pBack
		pBack = search_path.top();
		search_path.pop();

		if (pBack->left == nullptr && pBack->right == nullptr) /* 如果pBack为叶子结点 */
		{
			if (Distance(nearest, target) > Distance(pBack->dom_elt, target))
			{
				nearest = pBack->dom_elt;
				dist = Distance(pBack->dom_elt, target);
			}
		}
		else
		{
			UL s = pBack->split;
			if (s == 0)
			{
				if (fabs(pBack->dom_elt.x - target.x) < dist) /* 如果以target为中心的圆（球或超球），半径为dist的圆与分割超平面相交， 那么就要跳到另一边的子空间去搜索 */
				{
					if (Distance(nearest, target) > Distance(pBack->dom_elt, target))
					{
						nearest = pBack->dom_elt;
						dist = Distance(pBack->dom_elt, target);
					}
					if (target.x <= pBack->dom_elt.x) /* 如果target位于pBack的左子空间，那么就要跳到右子空间去搜索 */
						pSearch = pBack->right;
					else
						pSearch = pBack->left; /* 如果target位于pBack的右子空间，那么就要跳到左子空间去搜索 */
					if (pSearch != nullptr)
						//pSearch加入到search_path中
						search_path.push(pSearch);
				}
			}
			else {
				if (fabs(pBack->dom_elt.y - target.y) < dist) /* 如果以target为中心的圆（球或超球），半径为dist的圆与分割超平面相交， 那么就要跳到另一边的子空间去搜索 */
				{
					if (Distance(nearest, target) > Distance(pBack->dom_elt, target))
					{
						nearest = pBack->dom_elt;
						dist = Distance(pBack->dom_elt, target);
					}
					if (target.y <= pBack->dom_elt.y) /* 如果target位于pBack的左子空间，那么就要跳到右子空间去搜索 */
						pSearch = pBack->right;
					else
						pSearch = pBack->left; /* 如果target位于pBack的右子空间，那么就要跳到左子空间去搜索 */
					if (pSearch != nullptr)
						// pSearch加入到search_path中
						search_path.push(pSearch);
				}
			}

		}
	}

	nearestpoint.x = nearest.x;
	nearestpoint.y = nearest.y;
	distance = dist;
}

void test_kdtree() {
	coordinate exm_set[6];
	exm_set[0].x = 2;    exm_set[0].y = 3;
	exm_set[1].x = 5;    exm_set[1].y = 4;
	exm_set[2].x = 9;    exm_set[2].y = 6;
	exm_set[3].x = 4;    exm_set[3].y = 7;
	exm_set[4].x = 8;    exm_set[4].y = 1;
	exm_set[5].x = 7;    exm_set[5].y = 2;

	struct TreeNode * root = nullptr;
	root = build_kdtree(exm_set, 6, root);

	coordinate nearestpoint;
	double distance;
	coordinate target;
	target.x = 2.1;
	target.y = 3.1;

	searchNearest(root, target, nearestpoint, distance);
	cout << "The nearest distance is " << distance << ",and the nearest point is " << nearestpoint.x << "," << nearestpoint.y << endl;
}

int main() {
	test_kdtree();
	return 0;
}

 

JoannaJuanCV
关注
  • 2
    点赞
  • 踩
  • 21
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 6
    评论
专栏目录
Open3D (C++) 计算最近邻点的距离
点云侠的博客
01-16 466
计算最近邻点的距离的C++版本Open3D代码实现
c++实现kd树和临近查找
11-05
c++实现kd树和临近查找
K-最近邻法(KNN) C++实现
网络资源是无限的
11-15 3065
K-最近邻法(KNN) C++实现
使用kd树进行k邻近搜索，c++实现
10-08
程序可以直接运行，有代码注释，vs2012 x64环境，使用armadillo矩阵库，已将矩阵库的dll，lib，头文件放在工程中，无需配置。 具体可以看以下博客https://blog.csdn.net/qq_32478489/article/details/82972391
分治策略（算法设计）寻找最邻近点对c++源代码
12-25
使用分治算法实现寻找n个点中最邻近点的距离的平方。时间复杂度O（nlogn）.
最近邻点提取
hai_fellow_Z的博客
01-04 427
#include <iostream> #include <pcl/features/normal_3d.h> #include <pcl/io/pcd_io.h> #include <pcl/point_types.h> #include <boost/thread/thread.hpp> #include <pcl/kdtree/kdtree_flann.h> //kdtree近邻搜索 using namespace std;
最近邻查找算法kd-tree
热门推荐
皮皮blog
08-12 6万+
http://blog.csdn.net/pipisorry/article/details/52186307 海量数据最近邻查找的kd-tree简介         利用Octree，為封閉的3D空間建立一個資料結構來管理空間中的每個元素。如此我們可以在 O(log N) 的時間內對這3D空間進行搜尋。         3D空間可以用Octree，2D空間可以用Quadtree(四元樹，概...
kdTree算法实现（C++代码实现）
weixin_45645810的博客
06-20 1712
kdTree算法实现（C++代码实现） VS中需要安装Eigen包，可自行百度下载，添加至属性——包含项目即可。 kdTree.h文件 #ifndef KD_TREE_H #define KD_TREE_H #define lson (rt << 1)//左节点 #define rson (rt << 1 | 1)//右节点 #include #include #include <Eigen/Dense> #include using std::vector; us
KD-Tree（C++实现）
Nick
11-27 6935
参考资料： https://blog.csdn.net/dymodi/article/details/46830071 https://github.com/WiseDoge/libkdtree 作为存取高维数据的一种数据结构，k-d tree 在静态查询和插入方面的效率还是很高的。本文在这里对 k-d tree 的内容作一些介绍，可能也会结合自己使用 k-d tree 的一些体验作一些点评...
分治法实现最近点对问题（C++）
weixin_47389461的博客
06-01 2242
最近点对问题 要求 随机生成30个浮点数（1-10）之间 求出最近距离的两点 C语言实现 #include <iostream> #include <math.h> using namespace std; struct dot{ //点结构 float x; float y; }; void sortByX(dot dots[6],int num){ //将点按照X坐标从小到大排列好(冒泡) for (int i = num-1; i >=
kdtree实现源码(C++) 范围查询
05-27
数据结构课程设计 k-d树ADT、范围查询、可视化。kd-tree（k-dimensional树的简称），是一种分割k维数据空间的数据结构。主要应用于多维空间关键数据的搜索（如：范围搜索和最近邻搜索）。K-D树是二进制空间分割树的特殊的情况。 在计算机科学里，k-d树（ k-维树的缩写）是在k维欧几里德空间组织点的数据结构。k-d树可以使用在多种应用场合，如多维键值搜索（例：范围搜寻及最邻近搜索）。k-d树是空间二分树（Binary space partitioning ）的一种特殊情况。
KDTree（C++）.zip
07-13
使用C++实现的基于KDTree的邻近搜索，代码添加了注释。
VTK 查找KDTree最接近查询点的点 此示例创建一组三个点，从它们生成 KDTree，然后演示如何查找最接近查询点的点
02-26
VTK 查找KDTree最接近查询点的点 此示例创建一组三个点，从它们生成 KDTree，然后演示如何查找最接近查询点的点。 完整可编译运行的实例
KD-Tree 开源实现以及 OpenCV KD-Tree 使用
06-23
KD-Tree 开源实现以及 OpenCV KD-Tree 使用
《算法导论》实验五：最近点对算法（C++）
allin_allin的恋爱小屋
12-15 1万+
最近点对问题： 在n>=2个点的集合Q中寻找最近点对。 “最近”是指通常意义下的欧几里得距离：即点p1（x1，y1）和p2（x2，y2）之间的距离为：sqrt（（x1-x2）2 +（y1-y2）2）。
Games101 笔记 14 光线跟踪2
richard9006的专栏
03-28 179
使用AABB来加速光线跟踪 使用 找到包围盒 找到包围盒, 创建各自和物体表面相交的地方保存起来. 现在就可以做光线跟踪. 只需要 遍历所有格子 测试是否相关 然后保存相关的格子. 加速效果怎么样. 和不加格子的效率怎么样. 格子太密 一般情况下格子不用疏也不能太密 这种就工作的比较好, 因为场景中有大量的物体. 这种就不是, 物体的分布不均匀. 运动场中有个茶壶. 使用均匀的格子的算法不是很好. 空间划分(Spatial Parti...
统计学习方法c++实现之二 k近邻算法
bobxx的博客
12-21 352
k近邻算法 前言 k近邻算法可以说概念上很简单，即：“给定一个训练数据集，对新的输入实例，在训练数据集中找到与这个实例最邻近的k个实例，这k个实例的多数属于某个类，就把该输入分为这个类。”其中我认为距离度量最关键，但是距离度量的方法也很简单，最长用的就是欧氏距离，其他的距离度量准则实际上就是不同的向量范数，这部分我就不赘述了，毕竟这系列博客的重点是实现。代码地址：https://github.co...
k近邻法的C++实现
Just for fun的专栏
08-14 1424
k近邻法的C++实现：kd树 1.k近邻算法的思想 给定一个训练集，对于新的输入实例，在训练集中找到与该实例最近的k个实例，这k个实例中的多数属于某个类，就把该输入实例分为这个类。 因为要找到最近的k个实例，所以计算输入实例与训练集中实例之间的距离是关键！ k近邻算法最简单的方法是线性扫描，这时要计算输入实例与每一个训练实例的距离，当训练集很大时，非常耗时，这种方法不可行，为了提高k近邻的
C/C++数组的大小最大能有多大？
zfjBIT的专栏
03-18 5万+
直接定义一个数组，如a[SIZE];这个是分配的静态空间，在栈上（局部变量）或全局静态区（全局变量）上分配的，一般栈的内存是1M到2M，所以静态分配的空间不能太大，比如如果定义a[1024*1024];运行时就会报”段错误“，遇到要申请大的空间时，就需要动态申请。 函数内申请的变量，数组，是在栈（stack）中申请的一段连续的空间。栈的默认大小为2M或1M，开的比较小； 全局变量，全局数组，静...
kd-tree k邻域 c++
最新发布
01-03
kd-tree是一种用于在高维空间中存储和快速检索数据的数据结构。它能够通过将数据点按照某种规则分割为多个子空间，并将子空间以树的形式连接起来来实现。kd-tree中的每个节点代表一个子空间，并包含一个划分超平面和划分超平面上的数据点。 k邻域是指对于给定的一个数据点，kd-tree可以迅速找到离该点最近的k个邻居点。这一过程通常被称为k近邻搜索，通过在kd-tree中进行递归遍历，根据当前节点所代表的划分超平面和数据点的特征值比较，可以确定需要继续向子节点进行搜索还是回溯到父节点的另一个子节点。通过不断更新当前最近邻点的集合和最短距离，kd-tree可以非常高效地找到最近的k个邻居点。 c指的是kd-tree中的一个参数，即一个节点所代表的子空间内最多可以包含的数据点的数量。当一个子空间内的数据点数量超过c时，kd-tree需要对其进行划分，以保证每个节点的负载尽量平衡。c的取值通常是根据实际问题的特点和数据集的大小来确定的，可以通过实验和交叉验证来选择最优的取值。 总结来说，kd-tree是一种高效的数据结构，可以在高维空间中进行快速的k近邻搜索。通过合适地选择和调整c的取值，可以进一步优化kd-tree的性能和搜索效果。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

JoannaJuanCV

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值