ikd-Tree 简单测试

最新推荐文章于 2024-05-05 19:12:31 发布
最新推荐文章于 2024-05-05 19:12:31 发布
阅读量202 收藏
点赞数 1
分类专栏： SLAM 文章标签： 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Solititude/article/details/132729754
版权

ikd-Tree 简单测试

因为在学习时手写的 KNN 搜索可以用多线程的方式搜索，搜索效率很高，就考虑 PCL 自带的函数是否能够多线程 KNN 搜索，貌似好像是不行的，不过没有深入研究

发现了 ikd-Tree 这个方法，但是阅读论文后发现其 KNN 搜索貌似依然是单线程的，只是在 re-build 部分采用了并行线程的方式

在这里插入图片描述

对其性能进行简单测试，主要是 Nearest_Search 函数的使用

void KD_TREE<PointType>::Nearest_Search(PointType point, int k_nearest, PointVector& Nearest_Points, vector<float> & Point_Distance, double max_dist)

在这里插入图片描述

注意 max_dist 参数可以控制在指定的范围内进行 KNN 搜索

inline bool compare_point(const sad::PointType& p1, const sad::PointType& p2){
    if(p1.x == p2.x && p1.y == p2.y && p1.z == p2.z){
        return true;
    }
    return false;
}

double max_distance = 3.0;

TEST(CH5_TEST, KDTREE_KNN) {
    sad::CloudPtr first(new sad::PointCloudType), second(new sad::PointCloudType);
    pcl::io::loadPCDFile(FLAGS_first_scan_path, *first);
    pcl::io::loadPCDFile(FLAGS_second_scan_path, *second);

    if (first->empty() || second->empty()) {
        LOG(ERROR) << "cannot load cloud";
        FAIL();
    }

    const int nearest_search_k = 5;

    // voxel grid 至 0.05
    sad::VoxelGrid(first);
    sad::VoxelGrid(second);

    sad::KdTree kdtree;
    sad::evaluate_and_call([&first, &kdtree]() { kdtree.BuildTree(first); }, "Kd Tree build", 1);

    kdtree.SetEnableANN(true, FLAGS_ANN_alpha);

    LOG(INFO) << "Kd tree leaves: " << kdtree.size() << ", points: " << first->size();

    // 比较 bfnn
    std::vector<std::pair<size_t, size_t>> true_matches;
    sad::bfnn_cloud_mt_k(first, second, true_matches);

    // 对第2个点云执行knn
    std::vector<std::pair<size_t, size_t>> matches;
    sad::evaluate_and_call([&first, &second, &kdtree, &matches]() { kdtree.GetClosestPointMT(second, matches, nearest_search_k); },
                           "Kd Tree 5NN multi-thread", 1);
    EvaluateMatches(true_matches, matches);

    LOG(INFO) << "building kdtree pcl";
    // 对比PCL
    pcl::search::KdTree<sad::PointType> kdtree_pcl;
    sad::evaluate_and_call([&first, &kdtree_pcl]() { kdtree_pcl.setInputCloud(first); }, "Kd Tree build", 1);

    LOG(INFO) << "searching pcl";
    matches.clear();
    std::vector<int> search_indices(second->size());
    for (int i = 0; i < second->points.size(); i++) {
        search_indices[i] = i;
    }

    std::vector<std::vector<int>> result_index;
    std::vector<std::vector<float>> result_distance;
    sad::evaluate_and_call(
        [&]() { kdtree_pcl.nearestKSearch(*second, search_indices, nearest_search_k, result_index, result_distance); },
        "Kd Tree 5NN in PCL", 1);
    for (int i = 0; i < second->points.size(); i++) {
        for (int j = 0; j < result_index[i].size(); ++j) {
            int m = result_index[i][j];
            double d = result_distance[i][j];
            matches.push_back({m, i});
        }
    }
    EvaluateMatches(true_matches, matches);

    LOG(INFO) << "ikd_Tree Test";
    KD_TREE<sad::PointType>::Ptr ikdtree_ptr = make_shared<KD_TREE<sad::PointType>>();
    KD_TREE<sad::PointType>& ikd_Tree = *ikdtree_ptr;
    sad::evaluate_and_call([&first, &ikd_Tree]() { ikd_Tree.Build(first->points); }, "iKd Tree build", 1);
    LOG(INFO) << "ikd-Tree valid points: " << ikd_Tree.validnum();

    LOG(INFO) << "searching ikd-Tree";
    LOG(INFO) << "ikdTree KNN search_distance:" << max_distance;
    vector<PointVector> nearest_points(second->points.size());
    vector<vector<float>> points_distance(second->points.size());
    sad::evaluate_and_call(
        [&]() { for(int i = 0; i < second->points.size(); ++i){
                ikd_Tree.Nearest_Search(second->points[i], nearest_search_k, nearest_points[i], points_distance[i], max_distance);}; },
        "ikd-Tree 5NN Search", 1);
    matches.clear();
    int m = 0;
    for(int i = 0; i < second->points.size(); ++i){
        for(int j = 0; j < nearest_points[i].size(); ++j){
            m = -1;
            for(int k = 0; k < first->points.size(); ++k){
                if(compare_point(first->points[k], nearest_points[i][j])){
                    m = k;
                    break;
                }
            }
            matches.push_back({m, i});
        }
    }
    EvaluateMatches(true_matches, matches);  
    
    LOG(INFO) << "done.";

    SUCCEED();
}

int main(int argc, char** argv) {
    google::InitGoogleLogging(argv[0]);
    FLAGS_stderrthreshold = google::INFO;
    FLAGS_colorlogtostderr = true;

    string envVarName = "ikdTree_search_distance";
    string max_distance_str = getenv(envVarName.data());
    max_distance = stod(max_distance_str);

    testing::InitGoogleTest(&argc, argv);
    google::ParseCommandLineFlags(&argc, &argv, true);
    return RUN_ALL_TESTS();
}

有几个需要注意的地方：

1、启动程序时从命令行参数中获取环境变量作为 max_dist 参数的值，这样可以避免每次变化max_dist 都要重新编译，编译还是很费时的

		string envVarName = "ikdTree_search_distance";
    string max_distance_str = getenv(envVarName.data());
    max_distance = stod(max_distance_str);

2、添加 ikd-Tree 的建树以及 KNN 搜索测试，对于 second 点云中的每个点找最近邻

		LOG(INFO) << "ikd_Tree Test";
    KD_TREE<sad::PointType>::Ptr ikdtree_ptr = make_shared<KD_TREE<sad::PointType>>();
    KD_TREE<sad::PointType>& ikd_Tree = *ikdtree_ptr;
    sad::evaluate_and_call([&first, &ikd_Tree]() { ikd_Tree.Build(first->points); }, "iKd Tree build", 1);
    LOG(INFO) << "ikd-Tree valid points: " << ikd_Tree.validnum();

    LOG(INFO) << "searching ikd-Tree";
    LOG(INFO) << "ikdTree KNN search_distance:" << max_distance;
    vector<PointVector> nearest_points(second->points.size());
    vector<vector<float>> points_distance(second->points.size());
    sad::evaluate_and_call(
        [&]() { for(int i = 0; i < second->points.size(); ++i){
                ikd_Tree.Nearest_Search(second->points[i], nearest_search_k, nearest_points[i], points_distance[i], max_distance);}; },
        "ikd-Tree 5NN Search", 1);

3、计算准确率和召回率，这里不太好实现的是 ikd-Tree 的 KNN 记录的是点信息而不是点在点云中的索引，而评价函数中用的是索引，因此还需要遍历找点对应的索引，这里的时间复杂度很高，应该进行优化

		matches.clear();
    int m = 0;
    for(int i = 0; i < second->points.size(); ++i){
        for(int j = 0; j < nearest_points[i].size(); ++j){
            m = -1;
            for(int k = 0; k < first->points.size(); ++k){
                if(compare_point(first->points[k], nearest_points[i][j])){
                    m = k;
                    break;
                }
            }
            matches.push_back({m, i});
        }
    }
    EvaluateMatches(true_matches, matches);

简单进行了几组实验

1、max_dist = 0.5

lei@lei:~/slam_in_autonomous_driving$ ikdTree_search_distance=0.5 ./bin/test_nn --gtest_filter=CH5_TEST.KDTREE_KNN
Note: Google Test filter = CH5_TEST.KDTREE_KNN
[==========] Running 1 test from 1 test suite.
[----------] Global test environment set-up.
[----------] 1 test from CH5_TEST
[ RUN      ] CH5_TEST.KDTREE_KNN
Failed to find match for field 'intensity'.
Failed to find match for field 'intensity'.
I0831 09:19:16.993024  3630 sys_utils.h:32] 方法 Kd Tree build 平均调用时间/次数: 6.07747/1 毫秒.
I0831 09:19:16.993263  3630 test_nn.cc:242] Kd tree leaves: 18869, points: 18869
I0831 09:19:19.454218  3630 sys_utils.h:32] 方法 Kd Tree 5NN multi-thread 平均调用时间/次数: 3.67089/1 毫秒.
I0831 09:19:19.454253  3630 test_nn.cc:69] truth: 93895, esti: 93895
I0831 09:19:22.478986  3630 test_nn.cc:95] precision: 1, recall: 1, fp: 0, fn: 0
I0831 09:19:22.479022  3630 test_nn.cc:254] building kdtree pcl
I0831 09:19:22.481360  3630 sys_utils.h:32] 方法 Kd Tree build 平均调用时间/次数: 2.31427/1 毫秒.
I0831 09:19:22.481376  3630 test_nn.cc:259] searching pcl
I0831 09:19:22.500319  3630 sys_utils.h:32] 方法 Kd Tree 5NN in PCL 平均调用时间/次数: 18.9071/1 毫秒.
I0831 09:19:22.500790  3630 test_nn.cc:69] truth: 93895, esti: 93895
I0831 09:19:25.495046  3630 test_nn.cc:95] precision: 1, recall: 1, fp: 0, fn: 0
I0831 09:19:25.495080  3630 test_nn.cc:280] ikd_Tree Test
Multi thread started 
I0831 09:19:25.516258  3630 sys_utils.h:32] 方法 iKd Tree build 平均调用时间/次数: 7.09316/1 毫秒.
I0831 09:19:25.516289  3630 test_nn.cc:284] ikd-Tree valid points: 18869
I0831 09:19:25.516294  3630 test_nn.cc:286] searching ikd-Tree
I0831 09:19:25.516294  3630 test_nn.cc:287] ikdTree KNN search_distance:0.5
I0831 09:19:25.550645  3630 sys_utils.h:32] 方法 ikd-Tree 5NN Search 平均调用时间/次数: 34.1594/1 毫秒.
I0831 09:19:26.320165  3630 test_nn.cc:69] truth: 93895, esti: 80229
I0831 09:19:29.010622  3630 test_nn.cc:95] precision: 1, recall: 0.854454, fp: 0, fn: 13666
I0831 09:19:29.010658  3630 test_nn.cc:310] done.
Rebuild thread terminated normally
[       OK ] CH5_TEST.KDTREE_KNN (12039 ms)
[----------] 1 test from CH5_TEST (12039 ms total)

[----------] Global test environment tear-down
[==========] 1 test from 1 test suite ran. (12040 ms total)
[  PASSED  ] 1 test.

2、max_dist = 1.0

lei@lei:~/slam_in_autonomous_driving$ ikdTree_search_distance=1.0 ./bin/test_nn --gtest_filter=CH5_TEST.KDTREE_KNN
Note: Google Test filter = CH5_TEST.KDTREE_KNN
[==========] Running 1 test from 1 test suite.
[----------] Global test environment set-up.
[----------] 1 test from CH5_TEST
[ RUN      ] CH5_TEST.KDTREE_KNN
Failed to find match for field 'intensity'.
Failed to find match for field 'intensity'.
I0831 09:19:44.656121  3637 sys_utils.h:32] 方法 Kd Tree build 平均调用时间/次数: 5.99205/1 毫秒.
I0831 09:19:44.656301  3637 test_nn.cc:242] Kd tree leaves: 18869, points: 18869
I0831 09:19:47.107566  3637 sys_utils.h:32] 方法 Kd Tree 5NN multi-thread 平均调用时间/次数: 4.01058/1 毫秒.
I0831 09:19:47.107602  3637 test_nn.cc:69] truth: 93895, esti: 93895
I0831 09:19:50.210033  3637 test_nn.cc:95] precision: 1, recall: 1, fp: 0, fn: 0
I0831 09:19:50.210068  3637 test_nn.cc:254] building kdtree pcl
I0831 09:19:50.212378  3637 sys_utils.h:32] 方法 Kd Tree build 平均调用时间/次数: 2.28724/1 毫秒.
I0831 09:19:50.212393  3637 test_nn.cc:259] searching pcl
I0831 09:19:50.231775  3637 sys_utils.h:32] 方法 Kd Tree 5NN in PCL 平均调用时间/次数: 19.3455/1 毫秒.
I0831 09:19:50.232239  3637 test_nn.cc:69] truth: 93895, esti: 93895
I0831 09:19:53.198168  3637 test_nn.cc:95] precision: 1, recall: 1, fp: 0, fn: 0
I0831 09:19:53.198204  3637 test_nn.cc:280] ikd_Tree Test
Multi thread started 
I0831 09:19:53.219951  3637 sys_utils.h:32] 方法 iKd Tree build 平均调用时间/次数: 6.79115/1 毫秒.
I0831 09:19:53.219980  3637 test_nn.cc:284] ikd-Tree valid points: 18869
I0831 09:19:53.219987  3637 test_nn.cc:286] searching ikd-Tree
I0831 09:19:53.219990  3637 test_nn.cc:287] ikdTree KNN search_distance:1
I0831 09:19:53.255913  3637 sys_utils.h:32] 方法 ikd-Tree 5NN Search 平均调用时间/次数: 35.78/1 毫秒.
I0831 09:19:54.156787  3637 test_nn.cc:69] truth: 93895, esti: 89684
I0831 09:19:56.939265  3637 test_nn.cc:95] precision: 1, recall: 0.955152, fp: 0, fn: 4211
I0831 09:19:56.939299  3637 test_nn.cc:310] done.
Rebuild thread terminated normally
[       OK ] CH5_TEST.KDTREE_KNN (12308 ms)
[----------] 1 test from CH5_TEST (12308 ms total)

[----------] Global test environment tear-down
[==========] 1 test from 1 test suite ran. (12308 ms total)
[  PASSED  ] 1 test.

3、max_dist = 1.5

lei@lei:~/slam_in_autonomous_driving$ ikdTree_search_distance=1.5 ./bin/test_nn --gtest_filter=CH5_TEST.KDTREE_KNN
Note: Google Test filter = CH5_TEST.KDTREE_KNN
[==========] Running 1 test from 1 test suite.
[----------] Global test environment set-up.
[----------] 1 test from CH5_TEST
[ RUN      ] CH5_TEST.KDTREE_KNN
Failed to find match for field 'intensity'.
Failed to find match for field 'intensity'.
I0831 09:43:12.231748  4167 sys_utils.h:32] 方法 Kd Tree build 平均调用时间/次数: 6.1671/1 毫秒.
I0831 09:43:12.251842  4167 test_nn.cc:242] Kd tree leaves: 18869, points: 18869
I0831 09:43:14.705106  4167 sys_utils.h:32] 方法 Kd Tree 5NN multi-thread 平均调用时间/次数: 4.15197/1 毫秒.
I0831 09:43:14.705140  4167 test_nn.cc:69] truth: 93895, esti: 93895
I0831 09:43:17.634130  4167 test_nn.cc:95] precision: 1, recall: 1, fp: 0, fn: 0
I0831 09:43:17.634166  4167 test_nn.cc:254] building kdtree pcl
I0831 09:43:17.636514  4167 sys_utils.h:32] 方法 Kd Tree build 平均调用时间/次数: 2.32538/1 毫秒.
I0831 09:43:17.636538  4167 test_nn.cc:259] searching pcl
I0831 09:43:17.655293  4167 sys_utils.h:32] 方法 Kd Tree 5NN in PCL 平均调用时间/次数: 18.7018/1 毫秒.
I0831 09:43:17.655751  4167 test_nn.cc:69] truth: 93895, esti: 93895
I0831 09:43:20.850251  4167 test_nn.cc:95] precision: 1, recall: 1, fp: 0, fn: 0
I0831 09:43:20.850288  4167 test_nn.cc:280] ikd_Tree Test
Multi thread started 
I0831 09:43:20.870407  4167 sys_utils.h:32] 方法 iKd Tree build 平均调用时间/次数: 5.79657/1 毫秒.
I0831 09:43:20.870435  4167 test_nn.cc:284] ikd-Tree valid points: 18869
I0831 09:43:20.870441  4167 test_nn.cc:286] searching ikd-Tree
I0831 09:43:20.870443  4167 test_nn.cc:287] ikdTree KNN search_distance:1.5
I0831 09:43:20.911399  4167 sys_utils.h:32] 方法 ikd-Tree 5NN Search 平均调用时间/次数: 40.8256/1 毫秒.
I0831 09:43:22.000274  4167 test_nn.cc:69] truth: 93895, esti: 91513
I0831 09:43:25.069787  4167 test_nn.cc:95] precision: 1, recall: 0.974631, fp: 0, fn: 2382
I0831 09:43:25.069824  4167 test_nn.cc:310] done.
Rebuild thread terminated normally
[       OK ] CH5_TEST.KDTREE_KNN (12858 ms)
[----------] 1 test from CH5_TEST (12858 ms total)

[----------] Global test environment tear-down
[==========] 1 test from 1 test suite ran. (12858 ms total)
[  PASSED  ] 1 test.

经观察可以发现随着 max_dist 的增大，KNN 搜索的时间在增大，但召回率(recall)也在增大，说明搜索效率和准确率确实是矛盾的

另外 ikd-Tree KNN 的时间确实要大于 PCL KNN 的时间，这和论文中是一致的，但总体时间短很多

Prejudices
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Fast-Lio2代码及论文解析2
努力努力努力
03-29 736
点云数据频率较低而IMU为高频数据。
ikd-Tree：此存储库为机器人应用程序提供了增量kd树的实现
03-04
ikd-Tree是为机器人应用程序设计的增量kd树。 ikd-Tree仅用新的到来点来增量更新kd树，从而导致计算时间比现有的静态kd树要少得多。 除了逐点操作外，ikd-Tree还支持盒式操作和下采样等多项功能，这些功能在机器人...
ikd-Tree是为机器人应用程序设计的增量kd树-C/C++开发
05-27
ikd-Tree是为机器人应用程序设计的增量kd树。 ikd-Tree仅用新的到来点来增量更新kd树，因此与现有的静态kd树相比，计算时间要短得多。 除了逐点操作外，ikd-Tree还支持盒式操作和下采样等多项功能，这些功能在机器人应用程序中非常有用。 ikd-tree ikd-Tree是为机器人应用程序设计的增量kd树。 ikd-Tree仅用新的到来点来增量更新kd树，因此与现有的静态kd树相比，计算时间要短得多。 除了逐点操作外，ikd-Tree还支持盒式操作和下采样等多项功能，这些功能在机器人应用程序中非常有用。 开发商Yixi Cai蔡逸熙：数据结构设计与实现Wei Xu徐威：纳入LiDAR-
ikd-tree
最新发布
m0_74036895的博客
05-05 1007
K-dimensional tree,一种高维索引树形数据结构，经常用于在大规模的高维数据空间进行最近邻查找类似于K维二叉树，树中存储一些K维数据。
ikdtree解析
qq_42700518的博客
08-31 1279
数据结构
ikd_tree代码和论文阅读
qq_42429516的博客
04-07 2004
fastlio2的主要创新点： 引入ikd_tree增加配准的效率，修改卡尔曼增益减少卡尔曼的增益求逆的时间。本文主要目的是记录一下增量kd树的理解。 增量kd树的数据结构： 和普通的kd树类似，都需要点，划分轴，左右子节点，不过增量kd树中为了支持盒操作，增加了range，以及是否删除该点以及该点下面的子树。 Struct TreeNode: PointType point; TreeNode* leftchild,rightchild; int axis; int treesize, inval
(1分钟)速通ikdtree
努力coding
01-03 1089
我们在理论和实际实验中都验证了ikd树的有效性。例如，在激光雷达测程法和映射中，基于k-d树的最近点搜索对于匹配新的激光雷达扫描中的一个点与其映射（或之前的扫描）[3]-[8]中的对应点是至关重要的。例如，在激光雷达测程法和映射中，基于k-d树的最近点搜索对于匹配新的激光雷达扫描中的一个点与其映射（或之前的扫描）[3]-[8]中的对应点是至关重要的。例如，在激光雷达测程法和映射中，基于k-d树的最近点搜索对于匹配新的激光雷达扫描中的一个点与其映射（或之前的扫描）[3]-[8]中的对应点是至关重要的。
ikd-Tree：增量KD树在机器人中的应用
点云PCL
08-14 2259
文章：ikd-Tree: An Incremental K-D Tree for Robotic Applications作者：Yixi Cai, Wei Xu and Fu Zhang编译：点云PCL代码：https://github.com/hku-mars/ikd-Tree本文仅做学术分享，如有侵权，请联系删除。欢迎各位加入免费知识星球，获取PDF论文，欢迎转发朋友圈。内容如有错误欢迎评论留言，未经作者允许请勿转载，欢迎各位同学积极分享和交流。公众号致力于分享点云处理，SLAM，三维视觉，高精地图相关
kd_tree数据结构C++实现源码
08-10
KD树（K-Dimensional Tree）是一种用于在高维空间中进行快速查找的数据结构，尤其适用于在欧几里得空间中进行邻近搜索。它是一种平衡的分层数据结构，可以看作是二叉搜索树在多维空间中的扩展。在C++中实现KD树，有...
dev-exam-ikd
04-16
该存储库是用于技术技能测试的存储库。要开发的应用程序概述请在租金信息属性信息屏幕上实施CRUD。该应用程序的源代码已经存在，它只是新的，因此请在其上实现它。 如果您习惯使用Ruby on Rails，我们估计该卷可以在...
对于fast-lio论文和代码的一些个人理解
07-07
在FAST-LIO 小节中，算法使用李群和李代数来描述LiDAR和IMU的变换关系，并使用ikd-tree来实现高效的邻域搜索。 2.2 LiDAR 数据预处理 LiDAR 数据预处理是FAST-LIO 框架的第一步，负责将LiDAR点云数据转换为适合...
动态增删kdtree(ikdtree)主要思路
xysjj的博客
10-26 585
上述做完之后，可以认为已经动态改变了，但是也可以看见，此时的删除和插入操作其实已经破坏了kdtree的特性，例如删除操作破坏了平衡特性，增加了很多无效的节点，增加了遍历，插入操作则破坏了树平衡性和有序性两个特性（这里注明一下，有序性的破坏并不会影响结果，这里让我迷糊了很久，因为寻找最近点即使有序的二叉树仅通过包围盒也是无法排除另一个孩子树的）。
iKd-Tree学习
m0_46905397的博客
08-31 823
ikdTree论文笔记
深入理解ikd-Tree从阅读代码开始(一)
lovely_yoshino的博客
01-15 7460
/ 定义EPSS为1e-6，表示误差范围// 定义最小不平衡树大小为10，即当某个子树的节点数小于10时，需要进行重平衡// 定义需要重建子树的点数达到1500时，使用额外线程处理// 定义DOWNSAMPLE_SWITCH为true，表示开启下采样功能// 定义强制重建百分比为0.2，即当某个子树中删除的节点数占总节点数的20%以上时，需要进行重建// 定义支持的最大队列长度为1000000// 构造函数，用来初始化点的坐标。
ikd-tree使用手册
lovely_yoshino的博客
08-15 2777
代码】ikd-tree使用手册。
深入理解ikd-Tree从阅读代码开始(二)
lovely_yoshino的博客
01-16 7235
增量KD树,我们知道这类算法可以更加高效并且有意义地完成数据结构的动态空间划分. ikd-Tree可以主动监视树结构并重新平衡树结构，从而在后期实现高效的最近点搜索，ikd-Tree经过了精心设计，支持多线程并行计算，以最大限度地提高整体效率.mars实验室已经将这个公开了,而且有很多人对代码进行了总结与阐述.这里我们主要来看一下ikd-Tree,并对作者的一些疑问进行解释.
深入理解ikd-Tree从阅读代码开始(三)
lovely_yoshino的博客
01-16 7469
增量KD树,我们知道这类算法可以更加高效并且有意义地完成数据结构的动态空间划分. ikd-Tree可以主动监视树结构并重新平衡树结构，从而在后期实现高效的最近点搜索，ikd-Tree经过了精心设计，支持多线程并行计算，以最大限度地提高整体效率.mars实验室已经将这个公开了,而且有很多人对代码进行了总结与阐述.这里我们主要来看一下ikd-Tree,并对作者的一些疑问进行解释.
kd-tree ikd-tree
10-06
相比于普通的k-d tree，IKD-Tree（Invariant K-Dimensional Tree）具有更好的查询性能，因为它利用了数据的不变性来减少对分割的次数和搜索的复杂度。通过使用IKD-Tree，我们可以更快地找到目标点的最近邻。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

Prejudices

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

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

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

打赏作者

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

抵扣说明：

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

余额充值