Merge remote-tracking branch 'origin/master' into pcl-1.7.0

Author: jspricke

.travis.yml

@@ -9,4 +9,4 @@ before_install:
   - sudo apt-get install cmake libvtk5-qt4-dev libflann-dev libeigen3-dev libopenni-dev libqhull-dev libboost-filesystem1.53-dev libboost-iostreams1.53-dev libboost-thread1.53-dev
 script: 
   - mkdir build && cd build
-  - cmake -DCMAKE_C_FLAGS="-Wall -Wextra -Wabi -O2" -DCMAKE_CXX_FLAGS="-Wall -Wextra -Wabi -O2" -DPCL_ONLY_CORE_POINT_TYPES=ON .. && make -j2 && make test
+  - cmake -DBUILD_global_tests=ON -DCMAKE_C_FLAGS="-Wall -Wextra -Wabi -O2" -DCMAKE_CXX_FLAGS="-Wall -Wextra -Wabi -O2" -DPCL_ONLY_CORE_POINT_TYPES=ON .. && make -j2 && make test

CMakeLists.txt

@@ -109,7 +109,7 @@ endif()
 
 if(MSVC)
   SET(CMAKE_COMPILER_IS_MSVC 1)
-  add_definitions ("-DBOOST_ALL_NO_LIB -D_SCL_SECURE_NO_WARNINGS -D_CRT_SECURE_NO_WARNINGS -DNOMINMAX")
+  add_definitions ("-DBOOST_ALL_NO_LIB -D_SCL_SECURE_NO_WARNINGS -D_CRT_SECURE_NO_WARNINGS -DNOMINMAX /bigobj")
   if("${CMAKE_CXX_FLAGS}" STREQUAL "")
     SET(CMAKE_CXX_FLAGS "/bigobj /EHsc /fp:precise /wd4800 /wd4521 /wd4251 /wd4275 /wd4305 /wd4355 ${SSE_FLAGS}")
 

apps/cloud_composer/CMakeLists.txt

@@ -185,11 +185,11 @@ if(build)
     set (SAN_HEADERS include/pcl/apps/${SUBSYS_NAME}/tools/sanitize_cloud.h)
     define_composer_tool (sanitize_cloud "${SAN_SOURCES}" "${SAN_HEADERS}" "${SAN_DEPS}")
 
-     #Voxel SuperPixels
+     #Supervoxels
     set (VSP_DEPS pcl_octree pcl_segmentation)
-    set (VSP_SOURCES tools/voxel_superpixels.cpp include/pcl/apps/${SUBSYS_NAME}/tools/impl/voxel_superpixels.hpp)
-    set (VSP_HEADERS include/pcl/apps/${SUBSYS_NAME}/tools/voxel_superpixels.h)
-    define_composer_tool (voxel_superpixels "${VSP_SOURCES}" "${VSP_HEADERS}" "${VSP_DEPS}")
+    set (VSP_SOURCES tools/supervoxels.cpp include/pcl/apps/${SUBSYS_NAME}/tools/impl/supervoxels.hpp)
+    set (VSP_HEADERS include/pcl/apps/${SUBSYS_NAME}/tools/supervoxels.h)
+    define_composer_tool (supervoxels "${VSP_SOURCES}" "${VSP_HEADERS}" "${VSP_DEPS}")
 
   endif ()  #VTK_FOUND AND QT4_FOUND AND VTK_USE_QVTK
 

apps/cloud_composer/include/pcl/apps/cloud_composer/tools/impl/voxel_superpixels.hpp renamed to apps/cloud_composer/include/pcl/apps/cloud_composer/tools/impl/supervoxels.hpp

@@ -35,26 +35,26 @@
 *
 */
 
-#ifndef IMPL_VOXEL_SUPERPIXELS_HPP_
-#define IMPL_VOXEL_SUPERPIXELS_HPP_
+#ifndef IMPL_SUPERVOXELS_HPP_
+#define IMPL_SUPERVOXELS_HPP_
 
-#include <pcl/apps/cloud_composer/tools/voxel_superpixels.h>
+#include <pcl/apps/cloud_composer/tools/supervoxels.h>
 #include <pcl/apps/cloud_composer/impl/cloud_item.hpp>
 #include <pcl/apps/cloud_composer/items/normals_item.h>
 #include <pcl/point_cloud.h>
-#include <pcl/segmentation/supervoxels.h>
+#include <pcl/segmentation/supervoxel_clustering.h>
 
 
 template <typename PointT> QList <pcl::cloud_composer::CloudComposerItem*>
-pcl::cloud_composer::VoxelSuperpixelsTool::performTemplatedAction (QList <const CloudComposerItem*> input_data)
+pcl::cloud_composer::SupervoxelsTool::performTemplatedAction (QList <const CloudComposerItem*> input_data)
 {
   QList <CloudComposerItem*> output;  
 
   foreach (const CloudComposerItem* input_item, input_data)
   {
    // if ( !input_item->isSanitized () )
   //  {
-  //    qCritical () << "VoxelSuperpixelsTool requires sanitized input!";
+  //    qCritical () << "SupervoxelsTool requires sanitized input!";
   //    return output;
   //  }
     QVariant variant = input_item->data (ItemDataRole::CLOUD_TEMPLATED);
@@ -83,63 +83,23 @@ pcl::cloud_composer::VoxelSuperpixelsTool::performTemplatedAction (QList <const
     float normal_weight = parameter_model_->getProperty("Normals Weight").toFloat ();
     float spatial_weight = parameter_model_->getProperty("Spatial Weight").toFloat ();
 
-    pcl::SuperVoxels<PointT> super (resolution, seed_resolution);
+  
+    pcl::SupervoxelClustering<PointT> super (resolution, seed_resolution);
     super.setInputCloud (input_cloud);
     super.setColorImportance (rgb_weight);
     super.setSpatialImportance (spatial_weight);
     super.setNormalImportance (normal_weight);
-    pcl::PointCloud<pcl::PointSuperVoxel>::Ptr supervoxel_cloud;
-    super.extract (supervoxel_cloud);
-    
-    
-    
-    typename pcl::PointCloud<PointXYZRGB>::Ptr color_segments;
-    color_segments = super.getColoredVoxelCloud ();
-    
-    typename pcl::PointCloud<pcl::PointXYZL>::Ptr label_cloud;
-    label_cloud = super.getLabeledVoxelCloud ();
+    std::map <uint32_t, typename pcl::Supervoxel<PointT>::Ptr > supervoxel_clusters;
+    super.extract (supervoxel_clusters);
 
-    std::map<uint32_t, PointSuperVoxel> label_centers;
-    super.getSuperVoxelCenters (label_centers);
-    pcl::PointCloud<pcl::Normal>::Ptr cloud_normals (new pcl::PointCloud<pcl::Normal>);
-    std::map<uint32_t, PointSuperVoxel>::iterator itr_centers = label_centers.begin ();
-    
-    typedef boost::adjacency_list<boost::setS, boost::setS, boost::undirectedS, pcl::PointSuperVoxel, pcl::octree::EdgeProperties> VoxelAdjacencyList;
-    typedef boost::graph_traits<VoxelAdjacencyList>::vertex_iterator VertexIterator;
-    VoxelAdjacencyList supervoxel_adjacency_list;  
-    super.getSuperVoxelAdjacencyList (supervoxel_adjacency_list);
-    //The vertices in the supervoxel adjacency list are the supervoxel centroids    
-    std::pair<VertexIterator, VertexIterator> vertex_iterator_range;
-    vertex_iterator_range = boost::vertices(supervoxel_adjacency_list);
-    for (VertexIterator itr=vertex_iterator_range.first ; itr != vertex_iterator_range.second; ++itr)
-    {
-      PointSuperVoxel label_centroid = supervoxel_adjacency_list[*itr];
-      std::cout << label_centroid<<std::endl;
-    }
-    
-    for (; itr_centers != label_centers.end () ; ++itr_centers)
-      std::cout << itr_centers->second<<std::endl;
-    for (int i = 0; i < label_cloud->points.size (); ++i)
-    {
-      pcl::PointXYZL point = label_cloud->points[i];
-      pcl::PointSuperVoxel super_center = label_centers[point.label];
-      
-      pcl::Normal normal_point;
-      //point.normal = itr_centers->second.normal;
-      normal_point.normal_x = super_center.normal_x;
-      normal_point.normal_y = super_center.normal_y;
-      normal_point.normal_z = super_center.normal_z;
-      normal_point.curvature = super_center.curvature;
-     // std::cout << point.x <<" "<< point.y <<" "<< point.z <<" "<< point.label<<"\n";
-    //  std::cout << super_center<< std::endl;
-     // std::cout << normal_point<<std::endl<<std::endl;
-      cloud_normals->points.push_back (normal_point);
-    }    
-    CloudItem*  cloud_item_out = CloudItem::createCloudItemFromTemplate<PointXYZRGB>(input_item->text(),color_segments);
+    std::map <uint32_t, typename pcl::Supervoxel<PointT>::Ptr > refined_supervoxel_clusters;
+    super.refineSupervoxels (3, refined_supervoxel_clusters);
+  
+    typename pcl::PointCloud<PointXYZRGBA>::Ptr color_segments;
+    color_segments= super.getColoredVoxelCloud ();
 
-    NormalsItem* normals_item = new NormalsItem (tr("Normals r=%1").arg(0.03),cloud_normals,0.03);
-
-    cloud_item_out->addChild (normals_item);
+    CloudItem*  cloud_item_out = CloudItem::createCloudItemFromTemplate<PointXYZRGBA>(input_item->text(),color_segments);
+ 
 
     output.append (cloud_item_out);
 
@@ -155,8 +115,8 @@ pcl::cloud_composer::VoxelSuperpixelsTool::performTemplatedAction (QList <const
 
 
 
-#define PCL_INSTANTIATE_performTemplatedAction(T) template PCL_EXPORTS void pcl::cloud_composer::VoxelSuperpixelsTool::performTemplatedAction<T> (QList <const CloudComposerItem*>);
+#define PCL_INSTANTIATE_performTemplatedAction(T) template PCL_EXPORTS void pcl::cloud_composer::SupervoxelsTool::performTemplatedAction<T> (QList <const CloudComposerItem*>);
 
 
 
-#endif //IMPL_VOXEL_SUPERPIXELS_HPP_
+#endif //IMPL_SUPERVOXELS_HPP_

apps/cloud_composer/include/pcl/apps/cloud_composer/tools/voxel_superpixels.h renamed to apps/cloud_composer/include/pcl/apps/cloud_composer/tools/supervoxels.h

@@ -35,8 +35,8 @@
   *
   */
 
- #ifndef VOXEL_SUPERPIXELS_H_
- #define VOXEL_SUPERPIXELS_H_
+ #ifndef SUPERVOXELS_H_
+ #define SUPERVOXELS_H_
 
  #include <pcl/apps/cloud_composer/tool_interface/abstract_tool.h>
  #include <pcl/apps/cloud_composer/tool_interface/tool_factory.h>
@@ -46,12 +46,12 @@
  {
    namespace cloud_composer
    {
-     class VoxelSuperpixelsTool : public SplitItemTool
+     class SupervoxelsTool : public SplitItemTool
      {
        Q_OBJECT
      public:
-       VoxelSuperpixelsTool (PropertiesModel* parameter_model, QObject* parent);
-       virtual ~VoxelSuperpixelsTool ();
+       SupervoxelsTool (PropertiesModel* parameter_model, QObject* parent);
+       virtual ~SupervoxelsTool ();
 
        virtual QList <CloudComposerItem*>
        performAction (QList <const CloudComposerItem*> input_data, PointTypeFlags::PointType type = PointTypeFlags::NONE);
@@ -66,28 +66,28 @@
     };
 
 
-     class VoxelSuperpixelsToolFactory : public QObject, public ToolFactory
+     class SupervoxelsToolFactory : public QObject, public ToolFactory
      {
        Q_OBJECT
        Q_INTERFACES (pcl::cloud_composer::ToolFactory)
      public:
        SplitItemTool*
        createTool (PropertiesModel* parameter_model, QObject* parent = 0) 
        {
-         return new VoxelSuperpixelsTool(parameter_model, parent);
+         return new SupervoxelsTool(parameter_model, parent);
        }
 
        PropertiesModel*
        createToolParameterModel (QObject* parent);
 
        inline virtual QString 
-       getPluginName () const { return "Voxel Superpixels";}
+       getPluginName () const { return "Supervoxels";}
 
        inline virtual QString 
        getToolGroupName () const { return "Segmentation";}
 
        inline virtual QString
-       getIconName () const { return ":/voxel_superpixels.png"; }
+       getIconName () const { return ":/supervoxels.png"; }
 
        inline virtual CloudComposerItem::ItemType
        getInputItemType () const
@@ -113,4 +113,4 @@
 
 
 
- #endif //VOXEL_SUPERPIXELS_H_
+ #endif //SUPERVOXELS_H_

apps/cloud_composer/tools/voxel_superpixels.cpp renamed to apps/cloud_composer/tools/supervoxels.cpp

@@ -1,29 +1,27 @@
-#include <pcl/apps/cloud_composer/tools/voxel_superpixels.h>
+#include <pcl/apps/cloud_composer/tools/supervoxels.h>
 #include <pcl/apps/cloud_composer/items/cloud_item.h>
-
-#include <pcl/point_types.h>
 #include <pcl/filters/extract_indices.h>
 #include <pcl/kdtree/kdtree.h>
+#include <pcl/point_types.h>
 #include <pcl/segmentation/extract_clusters.h>
 
+#include <pcl/apps/cloud_composer/tools/impl/supervoxels.hpp>
 
-#include <pcl/apps/cloud_composer/tools/impl/voxel_superpixels.hpp>
+Q_EXPORT_PLUGIN2(cloud_composer_voxel_superpixels_tool, pcl::cloud_composer::SupervoxelsToolFactory)
 
-Q_EXPORT_PLUGIN2(cloud_composer_voxel_superpixels_tool, pcl::cloud_composer::VoxelSuperpixelsToolFactory)
-
-pcl::cloud_composer::VoxelSuperpixelsTool::VoxelSuperpixelsTool (PropertiesModel* parameter_model, QObject* parent)
+pcl::cloud_composer::SupervoxelsTool::SupervoxelsTool (PropertiesModel* parameter_model, QObject* parent)
 : SplitItemTool (parameter_model, parent)
 {
 
 }
 
-pcl::cloud_composer::VoxelSuperpixelsTool::~VoxelSuperpixelsTool ()
+pcl::cloud_composer::SupervoxelsTool::~SupervoxelsTool ()
 {
 
 }
 
 QList <pcl::cloud_composer::CloudComposerItem*>
-pcl::cloud_composer::VoxelSuperpixelsTool::performAction (ConstItemList input_data, PointTypeFlags::PointType type)
+pcl::cloud_composer::SupervoxelsTool::performAction (ConstItemList input_data, PointTypeFlags::PointType type)
 {
   if (type != PointTypeFlags::NONE)
   {
@@ -38,18 +36,18 @@ pcl::cloud_composer::VoxelSuperpixelsTool::performAction (ConstItemList input_da
 
   QList <CloudComposerItem*> output;
 
-  qCritical () << "voxel_superpixels requires templated types!";
+  qCritical () << "supervoxels requires templated types!";
 
   return output;
 } 
 
-template QList <pcl::cloud_composer::CloudComposerItem*> pcl::cloud_composer::VoxelSuperpixelsTool::performTemplatedAction <pcl::PointXYZRGB> (QList <const CloudComposerItem*>);
-//template QList <pcl::cloud_composer::CloudComposerItem*> pcl::cloud_composer::VoxelSuperpixelsTool::performTemplatedAction <pcl::PointXYZRGBA> (QList <const CloudComposerItem*>);
+template QList <pcl::cloud_composer::CloudComposerItem*> pcl::cloud_composer::SupervoxelsTool::performTemplatedAction <pcl::PointXYZRGB> (QList <const CloudComposerItem*>);
+//template QList <pcl::cloud_composer::CloudComposerItem*> pcl::cloud_composer::SupervoxelsTool::performTemplatedAction <pcl::PointXYZRGBA> (QList <const CloudComposerItem*>);
 
 
 /////////////////// PARAMETER MODEL /////////////////////////////////
 pcl::cloud_composer::PropertiesModel*
-pcl::cloud_composer::VoxelSuperpixelsToolFactory::createToolParameterModel (QObject* parent)
+pcl::cloud_composer::SupervoxelsToolFactory::createToolParameterModel (QObject* parent)
 {
   PropertiesModel* parameter_model = new PropertiesModel(parent);
 
@@ -58,12 +56,6 @@ pcl::cloud_composer::VoxelSuperpixelsToolFactory::createToolParameterModel (QObj
   parameter_model->addProperty ("RGB Weight", 0.2,  Qt::ItemIsEditable | Qt::ItemIsEnabled);
   parameter_model->addProperty ("Normals Weight", 0.8,  Qt::ItemIsEditable | Qt::ItemIsEnabled);
   parameter_model->addProperty ("Spatial Weight", 0.4,  Qt::ItemIsEditable | Qt::ItemIsEnabled);
-  //parameter_model->addProperty ("Min Plane Size", 10000,  Qt::ItemIsEditable | Qt::ItemIsEnabled);
-  //parameter_model->addProperty ("Angular Threshold", 2.0,  Qt::ItemIsEditable | Qt::ItemIsEnabled);
-  //parameter_model->addProperty ("Distance Threshold", 0.02,  Qt::ItemIsEditable | Qt::ItemIsEnabled);
-  //parameter_model->addProperty ("Cluster Dist. Thresh.", 0.01,  Qt::ItemIsEditable | Qt::ItemIsEnabled);
-  //parameter_model->addProperty ("Min Cluster Size", 1000,  Qt::ItemIsEditable | Qt::ItemIsEnabled);
-  
 
   return parameter_model;
 }

common/CMakeLists.txt

@@ -68,6 +68,16 @@ if(build)
         include/pcl/Vertices.h
         include/pcl/PointIndices.h
         include/pcl/sse.h
+        include/pcl/PCLPointField.h
+        include/pcl/PCLPointCloud2.h
+        include/pcl/PCLImage.h
+        include/pcl/PCLHeader.h
+        include/pcl/ModelCoefficients.h
+        include/pcl/PolygonMesh.h
+        include/pcl/Vertices.h
+        include/pcl/PointIndices.h
+        include/pcl/register_point_struct.h
+        include/pcl/conversions.h
         )
 
     set(common_incs 

common/include/pcl/common/common.h

@@ -160,6 +160,14 @@ namespace pcl
   template <typename PointT> inline void 
   getMinMax (const PointT &histogram, int len, float &min_p, float &max_p);
 
+  /** \brief Calculate the area of a polygon given a point cloud that defines the polygon 
+	  * \param polygon point cloud that contains those vertices that comprises the polygon. Vertices are stored in counterclockwise.
+	  * \return the polygon area 
+	  * \ingroup common
+	  */
+  template<typename PointT> inline float
+  calculatePolygonArea (const pcl::PointCloud<PointT> &polygon);
+
   /** \brief Get the minimum and maximum values on a point histogram
     * \param cloud the cloud containing multi-dimensional histograms
     * \param idx point index representing the histogram that we need to compute min/max for

common/include/pcl/common/impl/common.hpp

@@ -386,5 +386,26 @@ pcl::getMinMax (const PointT &histogram, int len, float &min_p, float &max_p)
   }
 }
 
+//////////////////////////////////////////////////////////////////////////////////////////////
+template <typename PointT> inline float
+pcl::calculatePolygonArea (const pcl::PointCloud<PointT> &polygon) 
+{
+  float area = 0.0f;
+  int num_points = polygon.size ();
+  int j = 0;
+  Eigen::Vector3f va,vb,res;
+
+  res(0) = res(1) = res(2) = 0.0f;
+  for (int i = 0; i < num_points; ++i) 
+  {
+    j = (i + 1) % num_points;
+    va = polygon[i].getVector3fMap ();
+    vb = polygon[j].getVector3fMap ();
+    res += va.cross (vb);
+  }
+  area = res.norm ();
+  return (area*0.5);
+}
+
 #endif  //#ifndef PCL_COMMON_IMPL_H_
 

doc/tutorials/content/building_pcl.rst

@@ -40,7 +40,7 @@ You should see something like the following on screen::
  BUILD_common                     ON
  BUILD_features                   ON
  BUILD_filters                    ON
- BUILD_global_tests               ON
+ BUILD_global_tests               OFF
  BUILD_io                         ON
  BUILD_kdtree                     ON
  BUILD_keypoints                  ON

doc/tutorials/content/conditional_removal.rst

@@ -3,7 +3,7 @@
 Removing outliers using a ConditionalRemoval filter
 ---------------------------------------------------
 
-This document demonstrates how to use the ConditionalRemoval filter to remove points from a PointCloud that do no statisfy a specific or multiple conditions.
+This document demonstrates how to use the ConditionalRemoval filter to remove points from a PointCloud that do no satisfy a specific or multiple conditions.
 
 The code
 --------
@@ -25,7 +25,7 @@ In the following Lines, we define the PointCloud structures, fill in the input c
    :language: cpp
    :lines: 8-27
 
-Then, we create the condition which a given point must satisfy so that it remains in our PointCloud.  To do this we must add two comparisons to the conditon, greater than 0.0, and less than 0.8.  This condition is then used to build the filter. 
+Then, we create the condition which a given point must satisfy so that it remains in our PointCloud.  To do this we must add two comparisons to the condition, greater than 0.0, and less than 0.8.  This condition is then used to build the filter. 
 
 .. literalinclude:: sources/conditional_removal/conditional_removal.cpp
    :language: cpp

doc/tutorials/content/images/supervoxel_clustering_adjacency.jpg

@@ -928,6 +928,21 @@ Segmentation
 
      .. |se_8| image:: images/don_segmentation.png
                :height: 100px
+
+  * :ref:`supervoxel_clustering`
+
+     ======  ======
+     |se_9|  Title: **Supervoxel Clustering**
+
+             Author: *Jeremie Papon*
+
+             Compatibility: > PCL 1.7
+
+             In this tutorial, we show to break a pointcloud into the mid-level supervoxel representation.
+     ======  ======
+
+     .. |se_9| image:: images/supervoxel_clustering_small.png
+               :height: 100px
 
 .. _surface_tutorial: