久久久久久久艹,这里是精品在线观看,久久深夜福利

作者：姜小明 @github

日期：2020-06-28

關鍵字：Kdtreee, DBSCAN, PCL, 點云

DBSCAN算法適用于點云聚類，但是3d點云數(shù)據(jù)一般較大，樸素的DBSCAN算法處理起來效率很低。對此，可以通過使用Kdtree檢索臨近點，從而加速DBSCAN算法。

1. DBSCAN

在點云數(shù)據(jù)分析中，我們經常需要對點云數(shù)據(jù)進行分割，提取感興趣的部分。聚類是點云分割中的一類方法（其他方法有模型擬合、區(qū)域增長、基于圖的方法、深度學習方法等）。DBSCAN 是一種基于密度的聚類算法，具有抗噪聲、無需指定類別種數(shù)、可以在空間數(shù)據(jù)中發(fā)現(xiàn)任意形狀的聚類等優(yōu)點，適用于點云聚類。

1.1 概念

DBSCAN中為了增加抗噪聲的能力，引入了核心對象等概念。

ε：參數(shù)，鄰域距離。

minPts： 參數(shù)，核心點領域內最少點數(shù)。

核心點： 在 $\epsilon$ 鄰域內有至少 $minPts$ 個鄰域點的點為核心點。

直接密度可達： 對于樣本集合 $D$ ，如果樣本點 $q$ 在 $p$ 的 $\epsilon$ 鄰域內，并且 $p$ 為核心對象，那么對象 $q$ 從對象 $p$ 直接密度可達。

密度可達： 對于樣本集合 $D$ ，給定一串樣本點 $p_1$ , $p_2$ , ..., $p_n$ ， $p = p_1$ , $q = p_n$ , 假如對象 $p_i$ 從 $p_{i-1}$ 直接密度可達，那么對象 $q$ 從對象 $p$ 密度可達。

密度相連： 存在樣本集合 $D$ 中的一點 $o$ ，如果對象 $o$ 到對象 $p$ 和對象 $q$ 都是密度可達的，那么 $p$ 和 $q$ 密度相聯(lián)。

DBSCAN 算法核心是找到密度相連對象的最大集合。參考百度百科-DBSCAN

[圖片上傳失敗...(image-2a5ab9-1593586772755)]

如圖， $minPts=4$ ，紅點為高密度核心點，黃點為邊界點，藍點為低密度噪聲點。紅黃點組成了一個簇（聚類）。

核心點、邊界點、噪聲點對應于不同密度，這就是 DBSCAN 屬于基于密度聚類方法的原因，也是其具有抗噪聲能力的原因。

1.2 算法

如前所述，DBSCAN 算法核心是找到密度相連對象的最大集合。為了實現(xiàn)該算法，有兩種方法：

先遍歷所有的點根據(jù)鄰域點數(shù)找出所有核心點，然后采用區(qū)域增長方法對其聚類，再遍歷聚類中的點，將其直接密度可達的點加入聚類，從而形成最終的聚類。
逐點遍歷，如果該點非核心點，則認為是噪聲點并忽視（噪聲點可能在后續(xù)被核心點歸入聚類中），若為核心點則新建聚類，并將所有鄰域點加入聚類。對于鄰域點中的核心點，還要遞歸地把其鄰域點加入聚類。依此類推直到無點可加入該聚類，并開始考慮新的點，建立新的聚類。

這里我們采用第二種方法，優(yōu)點是只用遍歷一趟。
偽代碼如下（參考維基百科-DBSCAN）：

DBSCAN(DB, distFunc, eps, minPts) {
    C = 0                                                  /* Cluster counter */
    for each point P in database DB {
        if label(P) ≠ undefined then continue              /* Previously processed in inner loop */
        Neighbors N = RangeQuery(DB, distFunc, P, eps)     /* Find neighbors */
        if |N| < minPts then {                             /* Density check */
            label(P) = Noise                               /* Label as Noise */
            continue
        }
        C = C + 1                                          /* next cluster label */
        label(P) = C                                       /* Label initial point */
        Seed set S = N \ {P}                               /* Neighbors to expand */
        for each point Q in S {                            /* Process every seed point */
            if label(Q) = Noise then label(Q) = C          /* Change Noise to border point */
            if label(Q) ≠ undefined then continue          /* Previously processed */
            label(Q) = C                                   /* Label neighbor */
            Neighbors N = RangeQuery(DB, distFunc, Q, eps) /* Find neighbors */
            if |N| ≥ minPts then {                         /* Density check */
                S = S ∪ N                                  /* Add new neighbors to seed set */
            }
        }
    }
}

2. DBSCAN 算法改進

這里算法的復雜度取決于鄰域點查找（即RangeQuery）的復雜度。最直觀的方法是使用線性掃描查找，但是這樣算法整體時間復雜度為 $O(n^2)$ 。這里給出兩種改進方法：

一種改進的方法是通過預先計算距離矩陣后進行鄰域查找。其復雜度為 $O(n^2/2)+O(n*k)$ ，其中 $k$ 為平均鄰域點數(shù)。但是這種改進的缺點是需要額外 $O(n^2)$ 或 $O(n*k)$ 的空間。
另一種更大的改進是使用索引方法查詢鄰域點，如使用Kdtree。其復雜度為 $O(n*log(n)+k*log(n)*n)$ ，其中加號前一項為建樹時間復雜度，后一項為鄰域查找復雜度(未考證)。

2.1 算法實現(xiàn)

我們實現(xiàn)了上述三種方法，這里我們重點介紹第三種實現(xiàn)，即使用 Kdtree 進行鄰域查找的 DBSCAN 算法。算法框架參考 wikipedia 給出的偽代碼(如上已列出，對照偽代碼看下面的代碼更輕松~)，接口等參考 pcl::EuclideanClusterExtraction，并參考加入了參數(shù) MinClusterSize, MaxClusterSize 來控制聚類大小。算法的核心是radiusSearch() 實現(xiàn)使用了 pcl::search::KdTree 進行鄰域搜索，而其內部實際使用了 pcl::KdTreeFLANN 結構來索引點云數(shù)據(jù)。

#ifndef DBSCAN_H
#define DBSCAN_H

#include <pcl/point_types.h>

#define UN_PROCESSED 0
#define PROCESSING 1
#define PROCESSED 2

inline bool comparePointClusters (const pcl::PointIndices &a, const pcl::PointIndices &b) {
    return (a.indices.size () < b.indices.size ());
}

template <typename PointT>
class DBSCANSimpleCluster {
public:
    typedef typename pcl::PointCloud<PointT>::Ptr PointCloudPtr;
    typedef typename pcl::search::KdTree<PointT>::Ptr KdTreePtr;
    
    virtual void setInputCloud(PointCloudPtr cloud) {
        input_cloud_ = cloud;
    }

    void setSearchMethod(KdTreePtr tree) {
        search_method_ = tree;
    }

    void extract(std::vector<pcl::PointIndices>& cluster_indices) {
        std::vector<int> nn_indices;
        std::vector<float> nn_distances;
        std::vector<bool> is_noise(input_cloud_->points.size(), false);
        std::vector<int> types(input_cloud_->points.size(), UN_PROCESSED);
        for (int i = 0; i < input_cloud_->points.size(); i++) {
            if (types[i] == PROCESSED) {
                continue;
            }
            int nn_size = radiusSearch(i, eps_, nn_indices, nn_distances);
            if (nn_size < minPts_) {
                is_noise[i] = true;
                continue;
            }
            std::vector<int> seed_queue;
            seed_queue.push_back(i);
            types[i] = PROCESSED;
            for (int j = 0; j < nn_size; j++) {
                if (nn_indices[j] != i) {
                    seed_queue.push_back(nn_indices[j]);
                    types[nn_indices[j]] = PROCESSING;
                }
            } // for every point near the chosen core point.
            int sq_idx = 1;
            while (sq_idx < seed_queue.size()) {
                int cloud_index = seed_queue[sq_idx];
                if (is_noise[cloud_index] || types[cloud_index] == PROCESSED) {
                    // seed_queue.push_back(cloud_index);
                    types[cloud_index] = PROCESSED;
                    sq_idx++;
                    continue; // no need to check neighbors.
                }
                nn_size = radiusSearch(cloud_index, eps_, nn_indices, nn_distances);
                if (nn_size >= minPts_) {
                    for (int j = 0; j < nn_size; j++) {
                        if (types[nn_indices[j]] == UN_PROCESSED) {
                            
                            seed_queue.push_back(nn_indices[j]);
                            types[nn_indices[j]] = PROCESSING;
                        }
                    }
                }
                types[cloud_index] = PROCESSED;
                sq_idx++;
            }
            if (seed_queue.size() >= min_pts_per_cluster_ && seed_queue.size () <= max_pts_per_cluster_) {
                pcl::PointIndices r;
                r.indices.resize(seed_queue.size());
                for (int j = 0; j < seed_queue.size(); ++j) {
                    r.indices[j] = seed_queue[j];
                }
                // These two lines should not be needed: (can anyone confirm?) -FF
                std::sort (r.indices.begin (), r.indices.end ());
                r.indices.erase (std::unique (r.indices.begin (), r.indices.end ()), r.indices.end ());

                r.header = input_cloud_->header;
                cluster_indices.push_back (r);   // We could avoid a copy by working directly in the vector
            }
        } // for every point in input cloud
        std::sort (cluster_indices.rbegin (), cluster_indices.rend (), comparePointClusters);
    }

    void setClusterTolerance(double tolerance) {
        eps_ = tolerance; 
    }

    void setMinClusterSize (int min_cluster_size) { 
        min_pts_per_cluster_ = min_cluster_size; 
    }

    void setMaxClusterSize (int max_cluster_size) { 
        max_pts_per_cluster_ = max_cluster_size; 
    }
    
    void setCorePointMinPts(int core_point_min_pts) {
        minPts_ = core_point_min_pts;
    }

protected:
    PointCloudPtr input_cloud_;
    double eps_ {0.0};
    int minPts_ {1}; // not including the point itself.
    int min_pts_per_cluster_ {1};
    int max_pts_per_cluster_ {std::numeric_limits<int>::max()};
    KdTreePtr search_method_;

    virtual int radiusSearch(
        int index, double radius, std::vector<int> &k_indices,
        std::vector<float> &k_sqr_distances) const
    {
        return this->search_method_->radiusSearch(index, radius, k_indices, k_sqr_distances);
    }
}; // class DBSCANCluster

#endif // DBSCAN_H

使用示例如下：

    pcl::search::KdTree<pcl::PointXYZ>::Ptr tree(new pcl::search::KdTree<pcl::PointXYZ>);
    tree->setInputCloud(point_cloud_input);
    std::vector<pcl::PointIndices> cluster_indices;
    DBSCANKdtreeCluster<pcl::PointXYZ> ec;
    ec.setCorePointMinPts(20);

    ec.setClusterTolerance(0.05);
    ec.setMinClusterSize(100);
    ec.setMaxClusterSize(25000);
    ec.setSearchMethod(tree);
    ec.setInputCloud(point_cloud_input);
    ec.extract(cluster_indices);

2.2 項目描述

全部工程代碼：github-dbscan_kdtree

項目中包括了一些常見場景的點云處理流程，如點云數(shù)據(jù)的讀取、寫入、降采樣預處理、平面檢測與過濾、點云聚類等，同時包含了一個測試點云數(shù)據(jù)，對于想快速入門 PCL 點云處理的同學會有所幫助。

項目中測試的點云聚類算法除了前面提到的三種 DBSCAN 聚類方法外，還包含 pcl 自帶的 pcl::EuclideanClusterExtraction 聚類，算法接口相同可替換后重新編譯測試。有人說 pcl::EuclideanClusterExtraction 算法是簡化版 DBSCAN，看過源碼后我覺得更應該算作區(qū)域增長方法。該算法和 DBSCAN 算法共同的優(yōu)點是支持任意數(shù)量、任意形狀的聚類，缺點是少了抗噪聲能力。

3. 算法評估

3.1 算法效果

原始點云總點數(shù)為460400，如下圖：

original point cloud

降采樣并去掉地面平面后總點數(shù)為20513，如下圖：

preprocessed point cloud

三種 DBSCAN 算法的效果一樣，除去點數(shù)太少的聚類后，總共有4個聚類，如下圖：

DBSCAN result

而 pcl::EuclideanClusterExtraction 算法只聚類出兩類，主要原因是右側稀疏噪聲點云將3團點云連成了一團。如下圖：

EuclideanClusterExtraction result

對比可見，DBSCAN 具有一定的抗噪聲能力。

3.1 算法效率

測試機器處理器：Intel? Core? i7-5820K CPU @ 3.30GHz × 12

聚類過程耗時如下表所示單位s：

DBSCAN simple	DBSCAN pre-compute	DBSCAN Kdtree	pcl::EuclideanClusterExtraction
12.402	6.043	0.150	0.139

可見，預先計算距離矩陣的優(yōu)化可以加速一倍，而使用Kdtree的方法在當前數(shù)據(jù)上可以加速約80倍，其效率和 pcl::EuclideanClusterExtraction 相當。

色偷偷精品伊人,欧洲久久精品,欧美综合婷婷骚逼,国产AV主播,国产最新探花在线,九色在线视频一区,伊人大交九欧美,1769亚洲,黄色成人av

使用Kdtree加速的DBSCAN進行點云聚類

使用Kdtree加速的DBSCAN進行點云聚類

作者：姜小明 @github

日期：2020-06-28

關鍵字：Kdtreee, DBSCAN, PCL, 點云

1. DBSCAN

1.1 概念

1.2 算法

2. DBSCAN 算法改進

2.1 算法實現(xiàn)

2.2 項目描述

3. 算法評估

3.1 算法效果

3.1 算法效率

友情鏈接更多精彩內容

色偷偷精品伊人,欧洲久久精品,欧美综合婷婷骚逼,国产AV主播,国产最新探花在线,九色在线视频一区,伊人大交九 欧美,1769亚洲,黄色成人av

使用Kdtree加速的DBSCAN進行點云聚類

作者：姜小明 @github

日期：2020-06-28

關鍵字：Kdtreee, DBSCAN, PCL, 點云

1. DBSCAN

1.1 概念

1.2 算法

2. DBSCAN 算法改進

2.1 算法實現(xiàn)

2.2 項目描述

3. 算法評估

3.1 算法效果

3.1 算法效率

友情鏈接更多精彩內容

色偷偷精品伊人,欧洲久久精品,欧美综合婷婷骚逼,国产AV主播,国产最新探花在线,九色在线视频一区,伊人大交九欧美,1769亚洲,黄色成人av