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

最新推荐文章于 2024-06-11 18:00:41 发布
最新推荐文章于 2024-06-11 18:00:41 发布
阅读量1k 收藏 10
点赞数 9
分类专栏： 数据结构和算法 文章标签： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/turbolove/article/details/135382059
版权
本文介绍了如何在QT图形视图框架中使用KD-Tree数据结构优化点集的最邻近点查找，相比于原始的排序方法，KD-Tree提高了约30倍的效率。作者展示了构建和查找过程，以及关键的代码实现细节。
摘要由CSDN通过智能技术生成

文章目录

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
关注
专栏目录
利用KDTree近邻搜索
Scarlett的博客
06-26 1734
利用KDTree近邻搜索
Kd树+BBF（最邻近、次邻近查询）Python实现
qq_35154529的博客
08-26 1925
 python2.7 import numpy as np  构建Kd树： KD树的构造  一维的二叉查找树很好构造，先对所有数据排序，然后每次取中值，把数据分成两半，左半为左子树，右半为右子树；然后递归下去就好了。这样可以保证构造出来的二叉树是平衡的。  KD树处理的数据是多维的，因此每次划分需要选定某一维作为参考来划分数据。选定后所有数据按这一维排序，然后划分成左子树，右子树。参考维度...
K-D Tree
Boyhou 的专栏
10-12 1277
简简介 k-d树[1]（k-dimensional树的简称），是一种分割k维数据空间的数据结构。主要应用于多维空间关键数据的搜索（如：范围搜索和最近邻搜索）。 2应用背景 SIFT算法中做特征点匹配的时候就会利用到k-d树。而特征点匹配实际上就是一个通过距离函数在高维矢量之间进行相似性检索的问题。针对如何快速而准确地找到查询点的近邻，现在提出了很多高维空间索引结构和近似查询的算法
基于kdtree的三种近邻点搜索方法（python版本）
最新发布
06-11 1916
基于python、kdtree的近邻点搜索
使用KD树进行最近邻查找的例子
六轱辘的专栏
05-04 7801
使用KD树进行最近邻查找的例子 例1： 查询点（2.1,3.1） 星号表示要查询的点（2.1,3.1）。通过二叉搜索，顺着搜索路径很快就能找到最邻近的近似点，也就是叶子节点（2,3）。而找到的叶子节点并不一定就是最邻近的，最邻近肯定距离查询点更近，应该位于以查询点为圆心且通过叶子节点的圆域内。为了找到真正的最近邻，还需要进行相关的‘回溯'操作。也就是说，算法首先沿搜索路径反向查找是否
kd树的最邻近搜索
随笔
10-26 1653
1. 在k-d树中进行数据的查找也是特征匹配的重要环节，其目的是检索在k-d树中与查询点距离最近的数据点。这里先以一个简单的实例来描述最邻近查找的基本思路。 星号表示要查询的点（2.1,3.1）。通过二叉搜索，顺着搜索路径很快就能找到最邻近的近似点，也就是叶子节点（2,3）。而找到的叶子节点并不一定就是最邻近的，最邻近肯定距离查询点更近，应该位于以查询点为圆心且通过叶子节点的圆域内。为了找到真正的...
二维点云配准+kd-tree相结合+三角剖分
06-30
在点云配对的指派问题中，kd-tree能快速找到最近邻点，显著减少了计算复杂度，提高了搜索效率，从而降低了匹配错误的可能性。 2. 结合“指派问题”：将匹配点的寻找与运筹学中的指派问题相结合，以优化匹配策略，...
KD-Tree C++程序
05-31
**KD-Tree（K-Dimensional Tree）是一种在高维空间中组织数据的树形数据结构，主要用于快速查找、分类和最近邻搜索等操作。在C++中实现KD-Tree可以帮助我们理解和应用这种数据结构，特别是在处理多维数据时，如在...
写给 Baby 的 Kd-tree 的实现原理 - demo程序
08-10
**Kd树的查询**主要包括最近邻搜索、范围搜索等。最近邻搜索寻找与查询点最接近的点，范围搜索则找出所有在给定范围内的点。在Kd树中，这些操作可以通过一系列的比较和递归调用来高效执行。查询过程中，沿着树的路径...
Spatial-Analytics-Using-KD-Trees:使用KD-Tree数据结构确定曼哈顿最繁忙的十字路口等。 包括视觉效果
07-08
此外，项目中可能还包括优化算法以提高查询效率，比如使用最近邻搜索（k-NN）或批量查询，并结合其他空间分析技术，如热力图或聚类分析，来进一步揭示交通模式。 最后，项目的视觉效果是关键，因为它能帮助用户直观...
查找最近点
12-07
java实现查找到一个点的最近点，并获取点的属性
kd-tree的基本教程PDF
07-12
- **定义**：KD-Tree（K-Dimensional Tree）是一种用于多维空间中的数据结构，特别适用于快速查找和组织点集合，如最近邻搜索等操作。 - **结构**：KD-Tree是一种二叉树结构，其中每个节点代表一个k维空间中的点，...
KDtree近邻点搜索
10-29 1484
PCL中kdtree搜索，可以实现K近邻搜索与半径r近邻搜索两种，使用案例如下： K个近邻点搜索： #include <pcl/point_cloud.h> #include <pcl/kdtree/kdtree_flann.h> #include <iostream> #include <pcl/io/pcd_io.h> #include <vector> #include <pcl/visualization/pcl_visuali
k邻近算法之 搜索kd树从 最邻近到 k邻近
qq_32478489的博客
10-08 2818
写在前面 在一番摸索之下，博主利用国庆的时间，系统地了解k邻近算法。从第一次接触，到完整地用c++代码实现利用kd树来进行 k邻近搜索。弄清了很多细节，但也可能有很多不足之处，小伙伴们尽情板砖。 算法的主体都有详细的程序，只是将样本放在矩阵库（armadillo）中。当然小伙伴们用opencv库更好，博主也打算转用opencv库。 k邻近分类算法简述 首先我们有m个样本，每个样...
PCL教程指南-如何使用KdTree寻找最邻近点
qq_41795143的博客
01-09 3842
PCL教程指南-如何使用KdTree寻找最邻近点 官方原文档 KdTree原理官方文档详解，简单概括 利用二叉树结构在高维度的应用，按维度中相近的数据组织，用于查找邻近点 对原文档代码解读，并扩展其他内容 #include <pcl/point_cloud.h> #include <pcl/kdtree/kdtree_flann.h> #include <iostream> #include <vector> #include <ctime>
Kd-Tree算法原理 最近邻查找
留下的，留不下的
08-22 4371
文章出处：http://blog.sina.com.cn/s/blog_6f611c300101bysf.html 本文介绍一种用于高维空间中的快速最近邻和近似最近邻查找技术——Kd-Tree（Kd树）。Kd-Tree，即K-dimensional tree，是一种高维索引树形数据结构，常用于在大规模的高维数据空间进行最近邻查找(Nearest Neighbor)和近似最近邻查找(Approxi...
KD树详解及KD树最近邻算法
weixin_43312083的博客
12-24 4484
1. 什么是KD树 Kd-树是K-dimension tree的缩写，是对数据点在k维空间（如二维(x，y)，三维(x，y，z)，k维(x，y，z..）中划分的一种数据结构，主要应用于多维空间关键数据的搜索（如：范围搜索和最近邻搜索）。 k-d树是一种空间划分树，就是把整个空间划分为特定的几个部分，然后在特定空间的部分内进行相关搜索操作。想像一个三维空间，kd树按照一定的划分规则把这个三维空间...
【k近邻】Kd树的构造与最近邻搜索算法
Frost_Descent的博客
02-22 902
Kd树是一种对K（与k近邻的k意义不同）维空间中的实例点进行存储以便对其进行快速检索的树形数据结构。Kd树是一种二叉树，表示对K维空间的一个划分(partition)。构造Kd树相当于不断地用垂直于坐标轴的超平面将K维空间切分，构成一 系列的K维超矩形区域。Kd树的每个结点对应于一个k维超矩形区域。
KD-Tree构建及邻近点搜索 C++实现
ts00001M的博客
05-03 964
KDTree C++实现
kd-tree算法详解：从入门到精通
kd-tree（kd树）是一种用于多维空间数据索引的数据结构，特别适合于进行最近邻搜索。它的设计灵感来源于二叉树，但扩展到了k维空间。kd-tree通过分割空间的方式，将数据组织成一个分层结构，每个内部节点对应一个超...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

turbolove

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

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

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

打赏作者

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

抵扣说明：

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

余额充值