使用KD-Tree树查找最近邻点 - 二维

最新推荐文章于 2024-02-22 16:47:31 发布
最新推荐文章于 2024-02-22 16:47:31 发布
阅读量735 收藏 8
点赞数 9
分类专栏： 数据结构和算法 文章标签： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/turbolove/article/details/135382059
版权

文章目录

KD-Tree

介绍

kd-tree，是一种对k维空间中的实例点进行存储以便对其进行快速检索的树形数据结构。 主要应用于多维空间关键数据的搜索（如：范围搜索和最近邻搜索）。K-D树是二进制空间分割树的特殊的情况。

用法

QT图形视图框架绘制曲线图和Smith图_qtcreator画smith图-CSDN博客 在这篇博客中绘图的mark点支持，最初我是使用set的自排序功能来查找最近的点，虽然效率能跟得上使用，但是这种方式弊端非常明显。每次移动的时候就需要重写计算距离，然后重新生成这个set。这个方式浪费不仅浪费空间也浪费时间。

所以在后续更新的时候使用了KD-Tree做了最邻近点的计算，比上述暴力的的排序方式快了不止30倍(这里是只测试了4W个点，使用排序打印的ms为0，使用上面的方式打印的在30左右)。

接下来展示我的代码：

kdtree.h

#ifndef TURBOPLOT_KDTREE_H
#define TURBOPLOT_KDTREE_H

/******************************************************************
 * @brief     求最邻近点算法
 * @author    turbo
 * @class     KDTree
 * @date      2023年11月2日10:59:27
 * @version   0.0.1
 * @property  root_            kdtree跟节点
 ******************************************************************/

#include <QPointF>
#include <QVector>

namespace turbo
{
    class KDTree
    {
    public:
        struct KDTreeNode
        {
            QPointF      point;
            KDTreeNode*  left;
            KDTreeNode*  right;
        };
        KDTree();
        ~KDTree();
        /**
         * @brief 设置点,根据点生成对应的KDTree
         * @param points
         */
        void setPoints(QVector<QPointF> &points);
        /**
         * @brief 获取离入参点最近的点
         * @param point
         * @return
         */
        QPointF getNearestPoint(const QPointF &point);

    protected:
        /**
         * @brief 计算两个点之间的欧氏距离
         * @param point1
         * @param point2
         * @return
         */
        static double euclideanDistance(const QPointF& point1, const QPointF& point2);
        /**
         * @brief 根据两个点的x比较大小
         * @param point1
         * @param point2
         * @return
         */
        static bool compareX(const QPointF& point1, const QPointF& point2);
        /**
         * @brief 根据两个点的y比较大小
         * @param point1
         * @param point2
         * @return
         */
        static bool compareY(const QPointF& point1, const QPointF& point2);
        /**
         * @brief 构建KD树
         * @param points
         * @param compareX
         * @return
         */
        KDTreeNode* buildKdTree(QVector<QPointF>& points, int depth);
        /**
         * @brief 计算最邻近点
         * @param root
         * @param target
         * @param nearest
         * @param minDist
         * @param depth
         */
        void findNearestNeighbor(KDTreeNode* root, QPointF target, QPointF& nearest, double& minDist, int depth);
        /**
         * @brief 清理kdtree 释放空间
         * @param root
         */
        void clearKdTree(KDTreeNode* root);

    private:
        KDTreeNode *root_;
    };
}

#endif //TURBOPLOT_KDTREE_H

kdtree.cpp

#include "kdtree.h"
#include <algorithm>
#include <cmath>

namespace turbo
{
    KDTree::KDTree() : root_(nullptr)
    {

    }

    KDTree::~KDTree()
    {
        clearKdTree(root_);
    }

    // 清理KD树
    void KDTree::clearKdTree(KDTreeNode* root)
    {
        if (root == nullptr)
        {
            return;
        }
        clearKdTree(root->left);
        clearKdTree(root->right);
        delete root;
        root = nullptr;
    }

    double KDTree::euclideanDistance(const QPointF &point1, const QPointF &point2)
    {
        double dx = point1.x() - point2.x();
        double dy = point1.y() - point2.y();
        return std::sqrt(dx*dx + dy*dy);
    }

    bool KDTree::compareX(const QPointF &point1, const QPointF &point2)
    {
        return point1.x() < point2.x();
    }

    bool KDTree::compareY(const QPointF &point1, const QPointF &point2)
    {
        return point1.y() < point2.y();
    }

    KDTree::KDTreeNode *KDTree::buildKdTree(QVector<QPointF> &points, int depth)
    {
        if (points.isEmpty())
        {
            return nullptr;
        }
        // 根据分割轴对点进行排序
        if (depth % 2 == 0)
        {
            std::sort(points.begin(), points.end(), compareX);
        }
        else
        {
            std::sort(points.begin(), points.end(), compareY);
        }

        // 选择中间点作为根节点
        int mid = points.size() / 2;
        auto* root = new KDTreeNode();
        root->point = points[mid];
        QVector<QPointF> points1 = QVector<QPointF>(points.begin(), points.begin() + mid);
        QVector<QPointF> points2 = QVector<QPointF>(points.begin() + mid + 1, points.end());
        root->left = buildKdTree(points1, depth + 1);
        root->right = buildKdTree(points2, depth + 1);
        return root;
    }

    // 在KD树中查找最近邻点
    void KDTree::findNearestNeighbor(KDTree::KDTreeNode* root, QPointF target, QPointF& nearest, double& minDist, int depth)
    {
        if (root == nullptr)
        {
            return;
        }
        // 计算当前节点到目标点的欧氏距离
        double dist = euclideanDistance(root->point, target);
        // 如果当前节点更近，则更新最近邻点和最小距离
        if (dist < minDist)
        {
            nearest = root->point;
            minDist = dist;
        }
        // 根据深度选择分割轴
        int axis = depth % 2;
        // 根据分割轴比较目标点和当前节点，并决定遍历顺序
        if ((axis == 0 && target.x() < root->point.x()) || (axis == 1 && target.y() < root->point.y()))
        {
            findNearestNeighbor(root->left, target, nearest, minDist, depth + 1);
            if ((axis == 0 && target.x() + minDist >= root->point.x()) || (axis == 1 && target.y() + minDist >= root->point.y()))
            {
                findNearestNeighbor(root->right, target, nearest, minDist, depth + 1);
            }
        }
        else
        {
            findNearestNeighbor(root->right, target, nearest, minDist, depth + 1);
            if ((axis == 0 && target.x() - minDist <= root->point.x()) || axis == 1 && target.y() - minDist <= root->point.y())
            {
                findNearestNeighbor(root->left, target, nearest, minDist, depth + 1);
            }
        }
    }

    void KDTree::setPoints(QVector<QPointF> &points)
    {
        clearKdTree(root_);
        root_ = buildKdTree(points, 0);
    }

    QPointF KDTree::getNearestPoint(const QPointF &point)
    {
        QPointF nearest;
        double minDist = std::numeric_limits<double>::max();
        // 在KD树中查找最近邻点
        findNearestNeighbor(root_, point, nearest, minDist, 0);
        return nearest;
    }
}

这里面就说一下构建时候的思路和查找时候的思路

KD-Tree的构建

KDTree::KDTreeNode *KDTree::buildKdTree(QVector<QPointF> &points, int depth)
{
    if (points.isEmpty())
    {
        return nullptr;
    }
    // 根据分割轴对点进行排序
    if (depth % 2 == 0)
    {
        std::sort(points.begin(), points.end(), compareX);
    }
    else
    {
        std::sort(points.begin(), points.end(), compareY);
    }

    // 选择中间点作为根节点
    int mid = points.size() / 2;
    auto* root = new KDTreeNode();
    root->point = points[mid];
    QVector<QPointF> points1 = QVector<QPointF>(points.begin(), points.begin() + mid);
    QVector<QPointF> points2 = QVector<QPointF>(points.begin() + mid + 1, points.end());
    root->left = buildKdTree(points1, depth + 1);
    root->right = buildKdTree(points2, depth + 1);
    return root;
}
  1. 检查点集是否为空，如果是则返回空指针。
  2. 根据当前深度选择分割轴，偶数深度使用compareX函数排序，奇数深度使用compareY函数排序。
  3. 选择中间点作为根节点，并创建一个新的KDTreeNode对象来存储该点。
  4. 将点集分为两部分，分别是从起始位置到中间位置的点集points1和从中间位置+1到结束位置的点集points2。
  5. 递归地调用buildKdTree函数来构建左子树，并将其赋值给根节点的left指针。
  6. 递归地调用buildKdTree函数来构建右子树，并将其赋值给根节点的right指针。

这么做的主要目的就是将一整个区域分成不同的区域

最邻近点的查找

// 在KD树中查找最近邻点
void KDTree::findNearestNeighbor(KDTree::KDTreeNode* root, QPointF target, QPointF& nearest, double& minDist, int depth)
{
    if (root == nullptr)
    {
        return;
    }
    // 计算当前节点到目标点的欧氏距离
    double dist = euclideanDistance(root->point, target);
    // 如果当前节点更近，则更新最近邻点和最小距离
    if (dist < minDist)
    {
        nearest = root->point;
        minDist = dist;
    }
    // 根据深度选择分割轴
    int axis = depth % 2;
    // 根据分割轴比较目标点和当前节点，并决定遍历顺序
    if ((axis == 0 && target.x() < root->point.x()) || (axis == 1 && target.y() < root->point.y()))
    {
        findNearestNeighbor(root->left, target, nearest, minDist, depth + 1);
        if ((axis == 0 && target.x() + minDist >= root->point.x()) || (axis == 1 && target.y() + minDist >= root->point.y()))
        {
            findNearestNeighbor(root->right, target, nearest, minDist, depth + 1);
        }
    }
    else
    {
        findNearestNeighbor(root->right, target, nearest, minDist, depth + 1);
        if ((axis == 0 && target.x() - minDist <= root->point.x()) || axis == 1 && target.y() - minDist <= root->point.y())
        {
            findNearestNeighbor(root->left, target, nearest, minDist, depth + 1);
        }
    }
}

这里注释都写的很清楚了，本质上就是递归查找。这边要说明白得绘图了，单纯用文字描述的话，确实有点不太清楚。但是我绘图技术太菜，直接看代码理解吧。

判断的地方，因为之前划分的时候就是按照深度划分的，这里根据深度来决定是使用x还是y来找最近点。

turbolove
关注
  • 9
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
二维点云配准+kd-tree相结合+三角剖分
06-30
利用ICP算法测试点云配准情况，并基于ICP算法，应用kd-tree与icp算法相结合的方式。对点云配对的指派问题进行更好的处理，从而得到更好的点云配准结果。本文采用的编程环境为MATLAB2022，文章末尾含ICP和icp与kd-tree相结合的核心代码即：放置的是函数文件，没有方式.m文件。 来源于大二期末大作业，做的一般，希望能够帮助到你。（通过latex生成的论文）
KD-Tree 开源实现以及 OpenCV KD-Tree 使用
06-23
KD-Tree 开源实现以及 OpenCV KD-Tree 使用
go-kdtree:KD树数据结构的Golang实现
05-30
KD树 KD树（ ）数据结构的Golang实现 入门 使用 go 工具在你的包树中安装包： go get github.com/hongshibao/go-kdtree 然后你可以在你的 Go 程序的导入部分使用它： import "github.com/hongshibao/go-kdtree" 包名是kdtree 。 基本示例 首先，您需要实现Point接口： type Point interface { // Return the total number of dimensions Dim () int // Return the value X_{dim}, dim is started from 0 GetValue ( dim int ) float64 // Return the distance between two points Dist
自编K-D树K最近邻搜索matlab程序
10-19
K-D树K最近邻搜索自编程序，含K折交叉验证，并与matlab自带KD树程序比较，结果完全一致
查找最近点
12-07
java实现查找到一个点的最近点，并获取点的属性
K-D Tree
Boyhou 的专栏
10-12 1213
简简介 k-d树[1]（k-dimensional树的简称），是一种分割k维数据空间的数据结构。主要应用于多维空间关键数据的搜索（如：范围搜索和最近邻搜索）。 2应用背景 SIFT算法中做特征点匹配的时候就会利用到k-d树。而特征点匹配实际上就是一个通过距离函数在高维矢量之间进行相似性检索的问题。针对如何快速而准确地找到查询点的近邻，现在提出了很多高维空间索引结构和近似查询的算法
找到距离最近的点，性能最好的方法
hhh314159的博客
06-14 1582
要找到距离最近的点并且性能最好，一种常用的方法是使用空间数据结构来加速搜索过程。这些空间数据结构可以根据实际需求选择和实现。构建数据结构的时间复杂度可能较高，但在之后的最近邻搜索过程中可以快速找到最近的点，从而提高性能。请注意，对于非常大的数据集，您可能还需要考虑使用更高级的数据结构或算法来进一步优化搜索效率。另外，如果点的数量不是非常大，你也可以使用简单的遍历方法，在遍历过程中计算并更新最近的点。这种方法的时间复杂度为O(n)，其中n是点的数量。虽然这种方法的性能较差，但对于小规模的数据集可能是足够的。
【k近邻】Kd树的构造与最近邻搜索算法
最新发布
Frost_Descent的博客
02-22 508
Kd树是一种对K（与k近邻的k意义不同）维空间中的实例点进行存储以便对其进行快速检索的树形数据结构。Kd树是一种二叉树，表示对K维空间的一个划分(partition)。构造Kd树相当于不断地用垂直于坐标轴的超平面将K维空间切分，构成一 系列的K维超矩形区域。Kd树的每个结点对应于一个k维超矩形区域。
KD树
qq_41745284的博客
03-07 9684
问题导入： k近邻法最简单的实现是线性扫描（穷举搜索），即要计算输入实例与每一个训练实例的距离。计算并存储好以后，再查找K近邻。当训练集很大时，计算非常耗时。 为了提高kNN搜索的效率，可以考虑使用特殊的结构存储训练数据，以减小计算距离的次数。这里介绍的就是KD树 简介： 为了避免每次都重新计算一遍距离，算法会把距离信息保存在一棵树里，这样在计算之前从树里查询距离信息，尽量避免重新计算。其基本原理是，如果A和B距离很远，B和C距离很近，那么A和C的距离也很远。有了这个信息，就可以在合适的时候跳过距离远的点。
kd tree最近邻搜索算法深度解析
昔风不起，唯有努力生存！
06-29 4116
李航统计学习方法（第二版）（六）：k近邻算法实现（kd tree方法）中，对kd树进行了介绍，包括，kd树的简介、kd树的建立以及kd树的搜索。在看到李航老师书中对kd树搜索算法的描述后，其中对于递归回退的操作描述不是很理解，觉得太抽象了（很可能是我自己的理解能力的问题）。对比多个源码（各个源码都还有我觉得有问题的地方，有时间我会在各博主博客下面留言，主要有：1.[c++实现kdTree创建以及最近邻点查找](https://blog.csdn.net/zfjbit/article/details/9547
dbscan:基于Kd-tree最近邻居搜索的快速dbscan算法
05-12
基于密度的带噪声应用程序空间聚类（DBSCAN） 基于Kd-tree最近邻居搜索的快速dbscan算法调用方式： double eps = 0.02 ; // radius of searchingint minPts = 1 ; // minimus points numberDbscan< Clusterable> ...
kd.rar_kd-tree
09-20
是一款循环试拨号程序，就只是对绵阳职业技术学院的拨号有用，它可以去试那些号码拨的上去。很好用的。
基于c的kd-tree实现方法.zip
04-08
kd-tree的简约实现。该实现既可以通过MEX调用在MATLAB内部使用，也可以直接从C / C ++程序中作为独立工具使用。网站上的图像已使用“ fulltest.m”创建。 此实现提供以下功能： -kdtree_build：kd树构造O -kdtree_...
写给 Baby 的 Kd-tree 的实现原理 - demo程序
08-10
Blog “写给 Baby 的 Kd-tree 的实现原理” 的 demo 程序
KD tree算法（2）－最近邻搜索KD tree
约瑟夫的杂货店
07-07 1629
书接上文，我们这一张来讨论KD Tree的最近邻搜索。首先来看一下《统计学习方法》书中给出的算法描述： 我们用网上很常见的例子进行分析： （7，2），（5，4），（9，6），（2，3），（4，7），（8，1） 待测节点：（2，4.5） 我们先不管在坐标上是怎么划分的，先看看在KD Tree上是如何遍历的。 我们先来进行分析： （1）在kd树中找出包含目标点x的叶节点。 这一步比较简
机器学习算法（二十五）：KD树详解及KD树最近邻算法
热门推荐
weixin_39910711的博客
03-06 1万+
目录 1 KD树 1.1什么是KD树 1.2KD树的构建 1.3 KD树的插入 1.4KD树的删除 1.5KD树的最近邻搜索算法 1.5.1举例：查询点（2.1,3.1） 1.5.2 举例：查询点（2，4.5） 2 kd树近邻搜索算法的改进：BBF算法 3 球树、M树、VP树、MVP树 3.1球树 3.2VP树与MVP树简介 特征点匹配和数据库查、图像检索本质上是同一个问题，都可以归结为一个通过距离函数在高维矢量之间进行相似性检索的问题，如何快速而准确...
二叉树节点的最近邻公共祖先节点
YtiniFni的博客
07-21 832
二叉树节点的最近邻公共祖先节点介绍求一个二叉树中两个节点的最近邻公共祖先节点（LCA According to the definition of LCA on Wikipedia: “The lowest common ancestor is defined between two nodes v and w as the lowest node in T that has bot
KDtree最近点查找C++用例
weixin_43891708的博客
11-05 1258
KDtree相关库nanoflann的应用 在ICP求解运动估计问题中，首先要解决的就是特征关联问题，一般都是利用KD树进行最近邻（NN）搜索，即在点云集A中找出其中每个点在点云集B中的距离最近的点，以实现数据关联。 与PCL中的KD树最近邻搜索相比，更推荐nanoflann方法，后者运行速度更快，且只需要包含少量头文件即可（nanoflann.hpp和nanoflann_utils.h）。 nanoflann实例应用 在source点云中，找出每一个特征点pisrcp^{src}_ipisrc​在targ
kd-tree分类并画出平面分割图
04-02
抱歉，作为一个AI语言模型，我无法进行可视化操作。但是我可以解释一下kd-tree分类和平面分割图的概念。 kd-tree是一种二叉树结构，用于存储k维空间中的点数据。它将空间划分为一个个小的超立方体，每个超立方体中包含一个点或多个点。这种数据结构可以用于快速查找点的最近邻，也可以用于分类和回归等机器学习任务。 在kd-tree中，通过不断地将数据点沿着坐标轴分割成两部分，构建一个二叉树结构。每个节点代表一个超立方体，节点左子树中的点在该超立方体的左半部分，右子树中的点在该超立方体的右半部分。这样就可以快速地定位到目标点所在的超立方体，然后通过遍历树结构，找到最近邻点或进行分类或回归等任务。 平面分割图是指在二维平面上，将数据点按照某种规则划分成多个区域的图像。在kd-tree中，每个节点代表一个超矩形区域，将数据点沿着坐标轴分割成两部分，就相当于在平面上画出了一个垂直于该坐标轴的直线，将数据点分割成两个区域。这个直线就是平面分割图中的分割线。不断地沿着坐标轴进行分割，就可以构建出一个平面分割图。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

turbolove

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

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

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

打赏作者

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

抵扣说明：

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

余额充值