zoukankan      html  css  js  c++  java
  • pcl之octree的使用

    pcl之octree的使用

    The Point Cloud Library provides point cloud compression functionality. It allows for encoding all kinds of point clouds including “unorganized” point clouds that are characterized by non-existing point references, varying point size, resolution, density and/or point ordering. Furthermore, the underlying octree data structure enables to efficiently merge point cloud data from several sources.

    • Point Cloud Compression
      First, create a file, let’s say, point_cloud_compression.cpp and place the following inside it:
    #include <pcl/point_cloud.h>
    #include <pcl/point_types.h>
    #include <pcl/io/openni_grabber.h>
    #include <pcl/visualization/cloud_viewer.h>
    
    #include <pcl/compression/octree_pointcloud_compression.h>
    
    #include <stdio.h>
    #include <sstream>
    #include <stdlib.h>
    
    #ifdef WIN32
    # define sleep(x) Sleep((x)*1000)
    #endif
    
    class SimpleOpenNIViewer
    {
    public:
      SimpleOpenNIViewer () :
        viewer (" Point Cloud Compression Example")
      {
      }
    
      void
      cloud_cb_ (const pcl::PointCloud<pcl::PointXYZRGBA>::ConstPtr &cloud)
      {
        if (!viewer.wasStopped ())
        {
          // stringstream to store compressed point cloud
          std::stringstream compressedData;
          // output pointcloud
          pcl::PointCloud<pcl::PointXYZRGBA>::Ptr cloudOut (new pcl::PointCloud<pcl::PointXYZRGBA> ());
    
          // compress point cloud
          PointCloudEncoder->encodePointCloud (cloud, compressedData);
    
          // decompress point cloud
          PointCloudDecoder->decodePointCloud (compressedData, cloudOut);
    
    
          // show decompressed point cloud
          viewer.showCloud (cloudOut);
        }
      }
    
      void
      run ()
      {
    
        bool showStatistics = true;
    
        // for a full list of profiles see: /io/include/pcl/compression/compression_profiles.h
        pcl::io::compression_Profiles_e compressionProfile = pcl::io::MED_RES_ONLINE_COMPRESSION_WITH_COLOR;
    
        // instantiate point cloud compression for encoding and decoding
        PointCloudEncoder = new pcl::io::OctreePointCloudCompression<pcl::PointXYZRGBA> (compressionProfile, showStatistics);
        PointCloudDecoder = new pcl::io::OctreePointCloudCompression<pcl::PointXYZRGBA> ();
    
        // create a new grabber for OpenNI devices
        pcl::Grabber* interface = new pcl::OpenNIGrabber ();
    
        // make callback function from member function
        boost::function<void
        (const pcl::PointCloud<pcl::PointXYZRGBA>::ConstPtr&)> f = boost::bind (&SimpleOpenNIViewer::cloud_cb_, this, _1);
    
        // connect callback function for desired signal. In this case its a point cloud with color values
        boost::signals2::connection c = interface->registerCallback (f);
    
        // start receiving point clouds
        interface->start ();
    
        while (!viewer.wasStopped ())
        {
          sleep (1);
        }
    
        interface->stop ();
    
        // delete point cloud compression instances
        delete (PointCloudEncoder);
        delete (PointCloudDecoder);
    
      }
    
      pcl::visualization::CloudViewer viewer;
    
      pcl::io::OctreePointCloudCompression<pcl::PointXYZRGBA>* PointCloudEncoder;
      pcl::io::OctreePointCloudCompression<pcl::PointXYZRGBA>* PointCloudDecoder;
    
    };
    
    int
    main (int argc, char **argv)
    {
      SimpleOpenNIViewer v;
      v.run ();
    
      return (0);
    }
    
    • Spatial Partitioning and Search Operations with Octrees
    #include <pcl/point_cloud.h>
    #include <pcl/octree/octree_search.h>
    
    #include <iostream>
    #include <vector>
    #include <ctime>
    
    int
    main (int argc, char** argv)
    {
      srand ((unsigned int) time (NULL));
    
      pcl::PointCloud<pcl::PointXYZ>::Ptr cloud (new pcl::PointCloud<pcl::PointXYZ>);
    
      // Generate pointcloud data
      cloud->width = 1000;
      cloud->height = 1;
      cloud->points.resize (cloud->width * cloud->height);
    
      for (size_t i = 0; i < cloud->points.size (); ++i)
      {
        cloud->points[i].x = 1024.0f * rand () / (RAND_MAX + 1.0f);
        cloud->points[i].y = 1024.0f * rand () / (RAND_MAX + 1.0f);
        cloud->points[i].z = 1024.0f * rand () / (RAND_MAX + 1.0f);
      }
    
      float resolution = 128.0f;
    
      pcl::octree::OctreePointCloudSearch<pcl::PointXYZ> octree (resolution);
    
      octree.setInputCloud (cloud);
      octree.addPointsFromInputCloud ();
    
      pcl::PointXYZ searchPoint;
    
      searchPoint.x = 1024.0f * rand () / (RAND_MAX + 1.0f);
      searchPoint.y = 1024.0f * rand () / (RAND_MAX + 1.0f);
      searchPoint.z = 1024.0f * rand () / (RAND_MAX + 1.0f);
    
      // Neighbors within voxel search
    
      std::vector<int> pointIdxVec;
    
      if (octree.voxelSearch (searchPoint, pointIdxVec))
      {
        std::cout << "Neighbors within voxel search at (" << searchPoint.x 
         << " " << searchPoint.y 
         << " " << searchPoint.z << ")" 
         << std::endl;
                  
        for (size_t i = 0; i < pointIdxVec.size (); ++i)
       std::cout << "    " << cloud->points[pointIdxVec[i]].x 
           << " " << cloud->points[pointIdxVec[i]].y 
           << " " << cloud->points[pointIdxVec[i]].z << std::endl;
      }
    
      // K nearest neighbor search
    
      int K = 10;
    
      std::vector<int> pointIdxNKNSearch;
      std::vector<float> pointNKNSquaredDistance;
    
      std::cout << "K nearest neighbor search at (" << searchPoint.x 
                << " " << searchPoint.y 
                << " " << searchPoint.z
                << ") with K=" << K << std::endl;
    
      if (octree.nearestKSearch (searchPoint, K, pointIdxNKNSearch, pointNKNSquaredDistance) > 0)
      {
        for (size_t i = 0; i < pointIdxNKNSearch.size (); ++i)
          std::cout << "    "  <<   cloud->points[ pointIdxNKNSearch[i] ].x 
                    << " " << cloud->points[ pointIdxNKNSearch[i] ].y 
                    << " " << cloud->points[ pointIdxNKNSearch[i] ].z 
                    << " (squared distance: " << pointNKNSquaredDistance[i] << ")" << std::endl;
      }
    
      // Neighbors within radius search
    
      std::vector<int> pointIdxRadiusSearch;
      std::vector<float> pointRadiusSquaredDistance;
    
      float radius = 256.0f * rand () / (RAND_MAX + 1.0f);
    
      std::cout << "Neighbors within radius search at (" << searchPoint.x 
          << " " << searchPoint.y 
          << " " << searchPoint.z
          << ") with radius=" << radius << std::endl;
    
    
      if (octree.radiusSearch (searchPoint, radius, pointIdxRadiusSearch, pointRadiusSquaredDistance) > 0)
      {
        for (size_t i = 0; i < pointIdxRadiusSearch.size (); ++i)
          std::cout << "    "  <<   cloud->points[ pointIdxRadiusSearch[i] ].x 
                    << " " << cloud->points[ pointIdxRadiusSearch[i] ].y 
                    << " " << cloud->points[ pointIdxRadiusSearch[i] ].z 
                    << " (squared distance: " << pointRadiusSquaredDistance[i] << ")" << std::endl;
      }
    }
    
    • Spatial change detection on unorganized point cloud data

    An octree is a tree-based data structure for organizing sparse 3-D data. In this tutorial we will learn how to use the octree implementation for detecting spatial changes between multiple unorganized point clouds which could vary in size, resolution, density and point ordering. By recursively comparing the tree structures of octrees, spatial changes represented by differences in voxel configuration can be identified. Additionally, we explain how to use the pcl octree “double buffering” technique allows us to efficiently process multiple point clouds over time.

    #include <pcl/point_cloud.h>
    #include <pcl/octree/octree_pointcloud_changedetector.h>
    
    #include <iostream>
    #include <vector>
    #include <ctime>
    
    int main (int argc, char** argv)
    {
      srand ((unsigned int) time (NULL));
    
      // Octree resolution - side length of octree voxels
      float resolution = 32.0f;
    
      // Instantiate octree-based point cloud change detection class
      pcl::octree::OctreePointCloudChangeDetector<pcl::PointXYZ> octree (resolution);
    
      pcl::PointCloud<pcl::PointXYZ>::Ptr cloudA (new pcl::PointCloud<pcl::PointXYZ> );
    
      // Generate pointcloud data for cloudA
      cloudA->width = 128;
      cloudA->height = 1;
      cloudA->points.resize (cloudA->width * cloudA->height);
    
      for (size_t i = 0; i < cloudA->points.size (); ++i)
      {
        cloudA->points[i].x = 64.0f * rand () / (RAND_MAX + 1.0f);
        cloudA->points[i].y = 64.0f * rand () / (RAND_MAX + 1.0f);
        cloudA->points[i].z = 64.0f * rand () / (RAND_MAX + 1.0f);
      }
    
      // Add points from cloudA to octree
      octree.setInputCloud (cloudA);
      octree.addPointsFromInputCloud ();
    
      // Switch octree buffers: This resets octree but keeps previous tree structure in memory.
      octree.switchBuffers ();
    
      pcl::PointCloud<pcl::PointXYZ>::Ptr cloudB (new pcl::PointCloud<pcl::PointXYZ> );
       
      // Generate pointcloud data for cloudB 
      cloudB->width = 128;
      cloudB->height = 1;
      cloudB->points.resize (cloudB->width * cloudB->height);
    
      for (size_t i = 0; i < cloudB->points.size (); ++i)
      {
        cloudB->points[i].x = 64.0f * rand () / (RAND_MAX + 1.0f);
        cloudB->points[i].y = 64.0f * rand () / (RAND_MAX + 1.0f);
        cloudB->points[i].z = 64.0f * rand () / (RAND_MAX + 1.0f);
      }
    
      // Add points from cloudB to octree
      octree.setInputCloud (cloudB);
      octree.addPointsFromInputCloud ();
    
      std::vector<int> newPointIdxVector;
    
      // Get vector of point indices from octree voxels which did not exist in previous buffer
      octree.getPointIndicesFromNewVoxels (newPointIdxVector);
    
      // Output points
      std::cout << "Output from getPointIndicesFromNewVoxels:" << std::endl;
      for (size_t i = 0; i < newPointIdxVector.size (); ++i)
        std::cout << i << "# Index:" << newPointIdxVector[i]
                  << "  Point:" << cloudB->points[newPointIdxVector[i]].x << " "
                  << cloudB->points[newPointIdxVector[i]].y << " "
                  << cloudB->points[newPointIdxVector[i]].z << std::endl;
    }
    

    参考

    Documentation - Point Cloud Library (PCL)

  • 相关阅读:
    Some day some time we will do
    qemu-img 的使用
    虚拟化qemu-img的简单用法。
    linux 后台执行命令
    C#向服务器上传文件问题
    Canvas保存为图片
    一个Sql备注
    fabric Clone
    Js 正则获取Html元素
    Graphic 完成文字缩放
  • 原文地址:https://www.cnblogs.com/ChrisCoder/p/9991537.html
Copyright © 2011-2022 走看看