2. 程式人生 > >pcl 基於對應分組的三維目標識別

pcl 基於對應分組的三維目標識別

阿新 • • 發佈：2019-01-16

本教程旨在說明如何基於pcl_recognition模組的三維物體識別，本教程解釋瞭如何使用對應分組演算法，獲得的模型和實際場景的3D描述子匹配後，以叢集的點至點的對應關係找到場景中好模型相似的例項。每個叢集，代表一個可能的場景中的模型例項，此演算法也輸出的場景中的模型例項的的六自由度位姿估計。
官方教程：
http://pointclouds.org/documentation/tutorials/correspondence_grouping.php#correspondence-grouping
我對官方教程中的部分程式碼做了簡單的修改。讓程式直接顯示原圖和keypoint等。
程式碼如下

#include <pcl/io/pcd_io.h>
#include <pcl/point_cloud.h>     //點雲型別標頭檔案
#include <pcl/correspondence.h>   //對應表示兩個實體之間的匹配（例如，點，描述符等）。
#include <pcl/features/normal_3d_omp.h>   //法線
#include <pcl/features/shot_omp.h>    //描述子
#include <pcl/features/board.h>       
#include <pcl/filters/uniform_sampling.h>   //均勻取樣
 

#include <pcl/recognition/cg/hough_3d.h>    //hough運算元
#include <pcl/recognition/cg/geometric_consistency.h>  //幾何一致性
#include <pcl/visualization/pcl_visualizer.h>   //視覺化
#include <pcl/kdtree/kdtree_flann.h>             //配準方法
#include <pcl/kdtree/impl/kdtree_flann.hpp>      //
#include <pcl/common/transforms.h>             //轉換矩陣
 

#include <pcl/console/parse.h>

typedef pcl::PointXYZRGBA PointType;  //PointXYZRGBA資料結構
typedef pcl::Normal NormalType;       //法線結構
typedef pcl::ReferenceFrame RFType;    //參考幀
typedef pcl::SHOT352 DescriptorType;   //SHOT特徵的資料結構http://www.cnblogs.com/li-yao7758258/p/6612856.html

std::string model_filename_;   //模型的檔名
std::string scene_filename_;

//Algorithm params
bool show_keypoints_(true);
bool show_correspondences_(true);
bool use_cloud_resolution_(false);
bool use_hough_(true);
float model_ss_(0.01f);
float scene_ss_(0.03f);
float rf_rad_(0.015f);
float descr_rad_(0.02f);
float cg_size_(0.01f);
float cg_thresh_(5.0f);

void
showHelp(char *filename)
{
    std::cout << std::endl;
    std::cout << "***************************************************************************" << std::endl;
    std::cout << "*                                                                         *" << std::endl;
    std::cout << "*             Correspondence Grouping Tutorial - Usage Guide              *" << std::endl;
    std::cout << "*                                                                         *" << std::endl;
    std::cout << "***************************************************************************" << std::endl << std::endl;
    std::cout << "Usage: " << filename << " model_filename.pcd scene_filename.pcd [Options]" << std::endl << std::endl;
    std::cout << "Options:" << std::endl;
    std::cout << "     -h:                     Show this help." << std::endl;
    std::cout << "     -k:                     Show used keypoints." << std::endl;
    std::cout << "     -c:                     Show used correspondences." << std::endl;
    std::cout << "     -r:                     Compute the model cloud resolution and multiply" << std::endl;
    std::cout << "                             each radius given by that value." << std::endl;
    std::cout << "     --algorithm (Hough|GC): Clustering algorithm used (default Hough)." << std::endl;
    std::cout << "     --model_ss val:         Model uniform sampling radius (default 0.01)" << std::endl;
    std::cout << "     --scene_ss val:         Scene uniform sampling radius (default 0.03)" << std::endl;
    std::cout << "     --rf_rad val:           Reference frame radius (default 0.015)" << std::endl;
    std::cout << "     --descr_rad val:        Descriptor radius (default 0.02)" << std::endl;
    std::cout << "     --cg_size val:          Cluster size (default 0.01)" << std::endl;
    std::cout << "     --cg_thresh val:        Clustering threshold (default 5)" << std::endl << std::endl;
}

void
parseCommandLine(int argc, char *argv[])
{
    //Show help
    if (pcl::console::find_switch(argc, argv, "-h"))
    {
        showHelp(argv[0]);
        exit(0);
    }

    //Model & scene filenames
    std::vector<int> filenames;
    filenames = pcl::console::parse_file_extension_argument(argc, argv, ".pcd");
    if (filenames.size() != 2)
    {
        for (int i = 0; i < filenames.size(); i++)
            std::cout << filenames.at(i) << endl;
        std::cout << "Filenames missing.\n";
        showHelp(argv[0]);
        exit(-1);
    }

    model_filename_ = argv[filenames[0]];
    scene_filename_ = argv[filenames[1]];

    //Program behavior
    if (pcl::console::find_switch(argc, argv, "-k"))
    {
        show_keypoints_ = true;
    }
    if (pcl::console::find_switch(argc, argv, "-c"))
    {
        show_correspondences_ = true;
    }
    if (pcl::console::find_switch(argc, argv, "-r")) //計算點雲的解析度和多樣性
    {
        use_cloud_resolution_ = true;
    }

    std::string used_algorithm;
    if (pcl::console::parse_argument(argc, argv, "--algorithm", used_algorithm) != -1)
    {
        if (used_algorithm.compare("Hough") == 0)
        {
            use_hough_ = true;
        }
        else if (used_algorithm.compare("GC") == 0)
        {
            use_hough_ = false;
        }
        else
        {
            std::cout << "Wrong algorithm name.\n";
            showHelp(argv[0]);
            exit(-1);
        }
    }

    //General parameters
    pcl::console::parse_argument(argc, argv, "--model_ss", model_ss_);
    pcl::console::parse_argument(argc, argv, "--scene_ss", scene_ss_);
    pcl::console::parse_argument(argc, argv, "--rf_rad", rf_rad_);
    pcl::console::parse_argument(argc, argv, "--descr_rad", descr_rad_);
    pcl::console::parse_argument(argc, argv, "--cg_size", cg_size_);
    pcl::console::parse_argument(argc, argv, "--cg_thresh", cg_thresh_);
}

double
computeCloudResolution(const pcl::PointCloud<PointType>::ConstPtr &cloud)//計算點雲解析度
{
    double res = 0.0;
    int n_points = 0;
    int nres;
    std::vector<int> indices(2);
    std::vector<float> sqr_distances(2);
    pcl::search::KdTree<PointType> tree;
    tree.setInputCloud(cloud);   //設定輸入點雲

    for (size_t i = 0; i < cloud->size(); ++i)
    {
        if (!pcl_isfinite((*cloud)[i].x))
        {
            continue;
        }
        //Considering the second neighbor since the first is the point itself.
        //運算第二個臨近點，因為第一個點是它本身
        nres = tree.nearestKSearch(i, 2, indices, sqr_distances);//return :number of neighbors found 
        if (nres == 2)
        {
            res += sqrt(sqr_distances[1]);
            ++n_points;
        }
    }
    if (n_points != 0)
    {
        res /= n_points;
    }
    return res;
}

int
main(int argc, char *argv[])
{
    parseCommandLine(argc, argv);

    pcl::PointCloud<PointType>::Ptr model(new pcl::PointCloud<PointType>()); //模型點雲
    pcl::PointCloud<PointType>::Ptr model_keypoints(new pcl::PointCloud<PointType>());//模型角點
    pcl::PointCloud<PointType>::Ptr scene(new pcl::PointCloud<PointType>());  //目標點雲
    pcl::PointCloud<PointType>::Ptr scene_keypoints(new pcl::PointCloud<PointType>());//目標角點
    pcl::PointCloud<NormalType>::Ptr model_normals(new pcl::PointCloud<NormalType>()); //法線
    pcl::PointCloud<NormalType>::Ptr scene_normals(new pcl::PointCloud<NormalType>());
    pcl::PointCloud<DescriptorType>::Ptr model_descriptors(new pcl::PointCloud<DescriptorType>()); //描述子
    pcl::PointCloud<DescriptorType>::Ptr scene_descriptors(new pcl::PointCloud<DescriptorType>());

    //載入檔案  載入模型（模板）
    if (pcl::io::loadPCDFile(model_filename_, *model) < 0)
    {
        std::cout << "Error loading model cloud." << std::endl;
        showHelp(argv[0]);
        return (-1);
    }
    if (pcl::io::loadPCDFile(scene_filename_, *scene) < 0)  //載入場景
    {
        std::cout << "Error loading scene cloud." << std::endl;
        showHelp(argv[0]);
        return (-1);
    }


    // 設定解析度
    if (use_cloud_resolution_)
    {
        float resolution = static_cast<float> (computeCloudResolution(model));
        if (resolution != 0.0f)
        {
            model_ss_ *= resolution;
            scene_ss_ *= resolution;
            rf_rad_ *= resolution;
            descr_rad_ *= resolution;
            cg_size_ *= resolution;
        }

        std::cout << "Model resolution:       " << resolution << std::endl;
        std::cout << "Model sampling size:    " << model_ss_ << std::endl;
        std::cout << "Scene sampling size:    " << scene_ss_ << std::endl;
        std::cout << "LRF support radius:     " << rf_rad_ << std::endl;
        std::cout << "SHOT descriptor radius: " << descr_rad_ << std::endl;
        std::cout << "Clustering bin size:    " << cg_size_ << std::endl << std::endl;
    }

    //計演算法線 normalestimationomp估計區域性表面特性在每個三個特點，分別表面的法向量和曲率，平行，使用OpenMP標準。//初始化排程程式並設定要使用的執行緒數（預設為0）。
    pcl::NormalEstimationOMP<PointType, NormalType> norm_est;
    norm_est.setKSearch(10);       //設定K鄰域搜尋閥值為10個點
    norm_est.setInputCloud(model);  //設定輸入點雲
    norm_est.compute(*model_normals);   //計算點雲法線 

    norm_est.setInputCloud(scene);
    norm_est.compute(*scene_normals);
    //計演算法線


    //均勻取樣點雲並提取關鍵點      體素下采樣，重心代替
    pcl::UniformSampling<PointType> uniform_sampling;
    uniform_sampling.setInputCloud(model);  //輸入點雲
    uniform_sampling.setRadiusSearch(model_ss_);   //設定半徑 model_ss_初值是0.01可以通過agv修改
    uniform_sampling.filter(*model_keypoints);   //濾波
    std::cout << "Model total points: " << model->size() << "; Selected Keypoints: " << model_keypoints->size() << std::endl;

    uniform_sampling.setInputCloud(scene);
    uniform_sampling.setRadiusSearch(scene_ss_);
    uniform_sampling.filter(*scene_keypoints);
    std::cout << "Scene total points: " << scene->size() << "; Selected Keypoints: " << scene_keypoints->size() << std::endl;
    //均勻取樣點雲並提取關鍵點      體素下采樣，重心代替



    //為關鍵點計算描述子
    pcl::SHOTEstimationOMP<PointType, NormalType, DescriptorType> descr_est;
    descr_est.setRadiusSearch(descr_rad_);  //設定搜尋半徑

    descr_est.setInputCloud(model_keypoints);  //輸入模型的關鍵點
    descr_est.setInputNormals(model_normals);  //輸入模型的法線
    descr_est.setSearchSurface(model);         //輸入的點雲
    descr_est.compute(*model_descriptors);     //計算描述子

    descr_est.setInputCloud(scene_keypoints);  //同理
    descr_est.setInputNormals(scene_normals);
    descr_est.setSearchSurface(scene);
    descr_est.compute(*scene_descriptors);

    //  使用Kdtree找出 Model-Scene 匹配點
    pcl::CorrespondencesPtr model_scene_corrs(new pcl::Correspondences());

    pcl::KdTreeFLANN<DescriptorType> match_search;   //設定配準的方法
    match_search.setInputCloud(model_descriptors);  //輸入模板點雲的描述子

    //每一個場景的關鍵點描述子都要找到模板中匹配的關鍵點描述子並將其新增到對應的匹配向量中。
    for (size_t i = 0; i < scene_descriptors->size(); ++i)
    {
        std::vector<int> neigh_indices(1);   //設定最近鄰點的索引
        std::vector<float> neigh_sqr_dists(1); //申明最近鄰平方距離值
        if (!pcl_isfinite(scene_descriptors->at(i).descriptor[0])) //忽略 NaNs點
        {
            continue;
        }
        int found_neighs = match_search.nearestKSearch(scene_descriptors->at(i), 1, neigh_indices, neigh_sqr_dists);
        //scene_descriptors->at (i)是給定點雲 1是臨近點個數 ，neigh_indices臨近點的索引  neigh_sqr_dists是與臨近點的索引

        if (found_neighs == 1 && neigh_sqr_dists[0] < 0.25f) // 僅當描述子與臨近點的平方距離小於0.25（描述子與臨近的距離在一般在0到1之間）才新增匹配
        {
            //neigh_indices[0]給定點，  i  是配準數  neigh_sqr_dists[0]與臨近點的平方距離
            pcl::Correspondence corr(neigh_indices[0], static_cast<int> (i), neigh_sqr_dists[0]);
            model_scene_corrs->push_back(corr);   //把配準的點儲存在容器中
        }
    }
    std::cout << "Correspondences found: " << model_scene_corrs->size() << std::endl;


    //  實際的配準方法的實現
    std::vector<Eigen::Matrix4f, Eigen::aligned_allocator<Eigen::Matrix4f> > rototranslations;
    std::vector<pcl::Correspondences> clustered_corrs;

    //  使用 Hough3D演算法尋找匹配點
    if (use_hough_)
    {
        //
        //  Compute (Keypoints) Reference Frames only for Hough
        //計算參考幀的Hough（也就是關鍵點）
        cout << "使用3d hough 匹配方法" << endl;
        pcl::PointCloud<RFType>::Ptr model_rf(new pcl::PointCloud<RFType>());
        pcl::PointCloud<RFType>::Ptr scene_rf(new pcl::PointCloud<RFType>());
        //特徵估計的方法（點雲，法線，參考幀）
        pcl::BOARDLocalReferenceFrameEstimation<PointType, NormalType, RFType> rf_est;
        rf_est.setFindHoles(true);
        rf_est.setRadiusSearch(rf_rad_);   //設定搜尋半徑

        rf_est.setInputCloud(model_keypoints);  //模型關鍵點
        rf_est.setInputNormals(model_normals); //模型法線
        rf_est.setSearchSurface(model);    //模型
        rf_est.compute(*model_rf);      //模型的參考幀   

        rf_est.setInputCloud(scene_keypoints);  //同理
        rf_est.setInputNormals(scene_normals);
        rf_est.setSearchSurface(scene);
        rf_est.compute(*scene_rf);

        //  Clustering聚類的方法

        //對輸入點與的聚類，以區分不同的例項的場景中的模型 
        pcl::Hough3DGrouping<PointType, PointType, RFType, RFType> clusterer;
        clusterer.setHoughBinSize(cg_size_);//霍夫空間設定每個bin的大小
        clusterer.setHoughThreshold(cg_thresh_);//閥值
        clusterer.setUseInterpolation(true);
        clusterer.setUseDistanceWeight(false);

        clusterer.setInputCloud(model_keypoints);
        clusterer.setInputRf(model_rf);   //設定輸入的參考幀
        clusterer.setSceneCloud(scene_keypoints);
        clusterer.setSceneRf(scene_rf);
        clusterer.setModelSceneCorrespondences(model_scene_corrs);//model_scene_corrs儲存配準的點

        //clusterer.cluster (clustered_corrs);辨認出聚類的物件
        clusterer.recognize(rototranslations, clustered_corrs);
    }
    else // Using GeometricConsistency  或者使用幾何一致性性質
    {
        cout << "使用幾何一致性方法" << endl;
        pcl::GeometricConsistencyGrouping<PointType, PointType> gc_clusterer;
        gc_clusterer.setGCSize(cg_size_);   //設定幾何一致性的大小
        gc_clusterer.setGCThreshold(cg_thresh_); //閥值

        gc_clusterer.setInputCloud(model_keypoints);
        gc_clusterer.setSceneCloud(scene_keypoints);
        gc_clusterer.setModelSceneCorrespondences(model_scene_corrs);

        //gc_clusterer.cluster (clustered_corrs);
        gc_clusterer.recognize(rototranslations, clustered_corrs);
    }

    //輸出的結果  找出輸入模型是否在場景中出現
    std::cout << "Model instances found: " << rototranslations.size() << std::endl;
    for (size_t i = 0; i < rototranslations.size(); ++i)
    {
        std::cout << "\n    Instance " << i + 1 << ":" << std::endl;
        std::cout << "        Correspondences belonging to this instance: " << clustered_corrs[i].size() << std::endl;

        // 列印處相對於輸入模型的旋轉矩陣與平移矩陣
        Eigen::Matrix3f rotation = rototranslations[i].block<3, 3>(0, 0);
        Eigen::Vector3f translation = rototranslations[i].block<3, 1>(0, 3);

        printf("\n");
        printf("            | %6.3f %6.3f %6.3f | \n", rotation(0, 0), rotation(0, 1), rotation(0, 2));
        printf("        R = | %6.3f %6.3f %6.3f | \n", rotation(1, 0), rotation(1, 1), rotation(1, 2));
        printf("            | %6.3f %6.3f %6.3f | \n", rotation(2, 0), rotation(2, 1), rotation(2, 2));
        printf("\n");
        printf("        t = < %0.3f, %0.3f, %0.3f >\n", translation(0), translation(1), translation(2));
    }

    //視覺化
    pcl::visualization::PCLVisualizer viewer("Correspondence Grouping");
    viewer.addPointCloud(scene, "scene_cloud");//視覺化場景點雲

    pcl::PointCloud<PointType>::Ptr off_scene_model(new pcl::PointCloud<PointType>());
    pcl::PointCloud<PointType>::Ptr off_scene_model_keypoints(new pcl::PointCloud<PointType>());

    if (show_correspondences_ || show_keypoints_)  //視覺化配準點
    {
        //  We are translating the model so that it doesn't end in the middle of the scene representation
        //就是要對輸入的模型進行旋轉與平移，使其在視覺化介面的中間位置
        pcl::transformPointCloud(*model, *off_scene_model, Eigen::Vector3f(-1, 0, 0), Eigen::Quaternionf(1, 0, 0, 0));
        pcl::transformPointCloud(*model_keypoints, *off_scene_model_keypoints, Eigen::Vector3f(-1, 0, 0), Eigen::Quaternionf(1, 0, 0, 0));  //因為模型的位置變化了，所以要對特徵點進行變化

        pcl::visualization::PointCloudColorHandlerCustom<PointType> off_scene_model_color_handler(off_scene_model, 255, 255, 128);  //對模型點雲上顏色
        viewer.addPointCloud(off_scene_model, off_scene_model_color_handler, "off_scene_model");
    }

    if (show_keypoints_)   //視覺化關鍵點
    {
        pcl::visualization::PointCloudColorHandlerCustom<PointType> scene_keypoints_color_handler(scene_keypoints, 0, 0, 255);  //對場景中的點雲上為綠色
        viewer.addPointCloud(scene_keypoints, scene_keypoints_color_handler, "scene_keypoints");
        viewer.setPointCloudRenderingProperties(pcl::visualization::PCL_VISUALIZER_POINT_SIZE, 5, "scene_keypoints");

        pcl::visualization::PointCloudColorHandlerCustom<PointType> off_scene_model_keypoints_color_handler(off_scene_model_keypoints, 0, 0, 255);
        viewer.addPointCloud(off_scene_model_keypoints, off_scene_model_keypoints_color_handler, "off_scene_model_keypoints");
        viewer.setPointCloudRenderingProperties(pcl::visualization::PCL_VISUALIZER_POINT_SIZE, 5, "off_scene_model_keypoints");
    }
    pcl::visualization::PointCloudColorHandlerRGBField<PointType> rgb(scene);
    viewer.addPointCloud(scene,rgb,"The Scene");

    for (size_t i = 0; i < rototranslations.size(); ++i)
    {
        pcl::PointCloud<PointType>::Ptr rotated_model(new pcl::PointCloud<PointType>());
        pcl::transformPointCloud(*model, *rotated_model, rototranslations[i]);//把model轉化為rotated_model
        //    <Eigen::Matrix4f, Eigen::aligned_allocator<Eigen::Matrix4f> >   rototranslations是射影變換矩陣
        std::stringstream ss_cloud;
        ss_cloud << "instance" << i;

        pcl::visualization::PointCloudColorHandlerCustom<PointType> rotated_model_color_handler(rotated_model, 255, 0, 0);
        viewer.addPointCloud(rotated_model, rotated_model_color_handler, ss_cloud.str());

        if (show_correspondences_)   //顯示配準連線
        {
            for (size_t j = 0; j < clustered_corrs[i].size(); ++j)
            {
                std::stringstream ss_line;
                ss_line << "correspondence_line" << i << "_" << j;
                PointType& model_point = off_scene_model_keypoints->at(clustered_corrs[i][j].index_query);
                PointType& scene_point = scene_keypoints->at(clustered_corrs[i][j].index_match);

                //  We are drawing a line for each pair of clustered correspondences found between the model and the scene
                viewer.addLine<PointType, PointType>(model_point, scene_point, 0, 255, 0, ss_line.str());
            }
        }
    }

    while (!viewer.wasStopped())
    {
        viewer.spinOnce();
    }

    return (0);
}

在官方教程上下載milk.pcb和milk_cartoon_all_small_clorox.pcd 執行程式碼時候在命令引數裡輸入 milk.pcb milk_cartoon_all_small_clorox.pcd。
結果
這裡寫圖片描述

程式碼的註釋比較多。自己看吧

相關推薦

pcl 基於對應分組的三維目標識別

本教程旨在說明如何基於pcl_recognition模組的三維物體識別，本教程解釋瞭如何使用對應分組演算法，獲得的模型和實際場景的3D描述子匹配後，以叢集的點至點的對應關係找到場景中好模型相似的例項。每個叢集，代表一個可能的場景中的模型例項，此演算法也輸出的場景

基於PCL實現拾取螢幕三維點座標（暫未解決，待更新）

該功能暫未實現，誠邀大神指點，感激不盡！ 目錄： 問題介紹 本人基於PCL1.8.0+Qt5.7.0+VS2013開發三維點雲資料處理軟體，其中一項功能是拾取螢幕三維點座標，並將其三維座標顯示在一個子視窗對話方塊中。 功能流程描述 主視

三維人臉識別技術使我們更好地認識彼此

直觀 關聯 post 識別 模型 最小 部門 蘋果 tle 人臉識別，一種基於人的臉部特征信息進行身份認證的生物特征識別技術。近年來，隨著歐美發達國家人臉識別技術開始進入實用階段後，人臉識別迅速成為近年來全球的一個市場熱點，它具有如下顯著優點： ·非接觸，智能交互，用戶接

基於supermap webgl三維樓層顯隱控制思路

find 基於 layers cpn fin 多個 var super blog supermap 9D 產品中，可以先獲取到模型的simd值，再調用setOnlyObjsVisible方法控制模型中單個物體的顯示和隱藏。 var smid = "94"; //樓層的s

柔性電子：基於複合材料的三維互聯壓電陶瓷薄膜用於機械和熱量能量收集

零維，一維，二維，三維材料的定義：https://www.zhihu.com/question/46430290 期刊：Energy & Environmental Science 摘要： 柔性壓電材料是可穿戴電子裝置，醫療感知裝置的關鍵。目前嵌入地位陶瓷填料的精細陶瓷

基於OpenCASCADE的三維工廠瀏覽程式的開發

基於OpenCASCADE的三維工廠瀏覽程式的開發 摘要：本文簡要介紹了藉助於開源的幾何造型核心OpenCASCADE把從AVEVA Plant(PDMS)中匯出的資料重新以三維展示，類似AVEVA Review的功能；以及利用OCC的資料交換功能模組，將匯出的資料轉換成常見三維資料標準儲存格式，便於其它CA

基於樹莓派的實時目標識別與移動目標監測系統

        本文主要分為兩部分，分別是基於樹莓派的實時目標識別與移動監測系統。兩部分主要根據兩個具體的教程進行講解。本篇重點講解配置過程，其中第一個主要是由mxnet官方的文件而來，起初進行這次測試的目的是因為看到了機器之心公眾號推的文章《亞馬遜詳解如何使用MXNet在

一種基於OpenCV的三維重建實現方案

摘 要 本文以計算機視覺三維重建技術為研究物件，分析了開放計算機視覺函式庫OpenCV中的三維重建模型，通過六個步驟,特別是攝像機標定和立體匹配中極線約束方法的使用，給出了基於OpenCV的三維重建演算法。該演算法充分發揮了OpenCV的函式庫功能，提高了計算的精度效率，具有良好的跨平臺移植性，可以滿足各

基於輪廓的三維骨架重建方法和核心程式碼

 背景（為什麼要這麼做？）：         目前獲取三維資料的方法很多，比如：雙目視覺技術，深度相機等等。         但是存在一個問題：資料量巨大！如果要做線上檢測，那速度很可能達不到要求。 總思路：         用二維的資料來表示三維資料（資料量從n3降到n2

OpenGL 基於OpenGL的三維機器人仿真

std ble scale mage num ima pre ali lena 分享一下我老師大神的人工智能教程吧。零基礎！通俗易懂！風趣幽默！還帶黃段子！希望你也加入到我們人工智能的隊伍中來！http://www.captainbed.net 基於OpenGL的三維

基於OpenCV做“三維重建”（3）--相機參數矩陣

過程 ora 希望 .cn href 標準 www. solid http 通過前面的相機標定，我們能夠獲得一些參數模型。但是這些相機的參數矩陣到底是什麽意思？怎樣才能夠判斷是否正確？誤差都會來自哪裏？這裏就必須要通過具體實驗來加深認識。采集帶相機參數的圖片

基於檢視聚合的聯合三維生成與目標檢測

摘要 我們提出AVOD，一個用於自主駕駛場景的聚合檢視物件檢測網路。提出的神經網路結構使用LIDAR點雲和RGB影象生成由兩個子網路共享的特徵：區域建議網路（RPN）和第二級檢測器網路。提出的RPN使用能夠在高解析度特徵地圖上執行多模態特徵融合的新體系結構來為道路場景中的多個物件類生成可靠的3D物件

3D目標識別---三維區域性座標系(LRF)效能分析

1 加權區域性參考座標系的定義 以任意一個特徵點p及其鄰域S(p)為例來說明基於加權協方差矩陣的區域性參考座標系LRF的建立過程。 C=1∑ni=1wi∑i=1nwi(q−p)(q−p)T,,q∈S(p) CV=EV 區域性參考座標系的3根軸由協方差矩

基於PCL的三維重建——點雲的濾波處理

在獲取點雲資料時 ，由於裝置精度，操作者經驗環境因素帶來的影響，以及電磁波的衍射特性，被測物體表面性質變化和資料拼接配準操作過程的影響，點雲資料中講不可避免的出現一些噪聲。在點雲處理流程中濾波處理作為預處理的第一步，對後續的影響比較大，只有在濾波預處理中將噪聲點 ，離群點，

基於Matlab的立體相機標定StereoCalibration與目標三維座標定位

1.Matlab關於立體相機標定與目標三維座標定位的流程 環境：Matlab r2015b 找到 APPS-->Stereo Camera Calibrator-->Add Image， 此時會提示左右攝像頭拍攝的棋盤格標定圖片輸入路徑(Folder for i

PCL—綜述—三維圖像處理

組合 好的 相機 二維 檢測 不同的 ext eat 分享圖片 點雲模型與三維信息　 三維圖像是一種特殊的信息表達形式，其特征是表達的空間中三個維度的數據。和二維圖像相比，三維圖像借助第三個維度的信息，可以實現天然的物體-背景解耦。除此之外，對於視覺測量來說，物體的二維信息

基於matplotlib的數據可視化 - 三維曲面圖gca

iat then 一個 rst plt 示例 surf plot 情況 1 語法 ax = plt.gca(projection=‘3d‘)ax.plot_surface(x,y,z,rstride=行步距，cstride=列步距，cmap=顏色映射) gca(*

《基於影象點特徵的多檢視三維重建》——相關概念彙總筆記

1.    基於影象的影象3D重建 傳統上首先使用 Structure-from-Motion 恢復場景的稀疏表示和輸入影象的相機姿勢。 然後，此輸出用作Multi-View Stereo（多檢視立體）的輸入，以恢復場景衝密集表示。     

基於數字光柵投影的結構光三維測量技術（總結）

概述 三維重建 光學三維測量 被動三維測量 主動三維測量 基於PMP的結構光三維測量技術 結

第十九節、基於傳統影象處理的目標檢測與識別(詞袋模型BOW+SVM附程式碼)

在上一節、我們已經介紹了使用HOG和SVM實現目標檢測和識別，這一節我們將介紹使用詞袋模型BOW和SVM實現目標檢測和識別。 一 詞袋介紹 詞袋模型(Bag-Of-Word)的概念最初不是針對計算機視覺的，但計算機視覺會使用該概念的升級。詞袋最早出現在神經語言程式學(NLP)和資訊檢索(IR)領域，該模型