Make pyramid filters inherit from PCLBase.

Author: larshg

filters/include/pcl/filters/pyramid.h

@@ -42,8 +42,10 @@
 #include <pcl/memory.h>
 #include <pcl/pcl_macros.h>
 #include <pcl/point_cloud.h>
+#include <pcl/pcl_base.h>
 #include <pcl/pcl_config.h>
 
+
 namespace pcl
 {
   namespace filters
@@ -59,9 +61,9 @@ namespace pcl
       * \author Nizar Sallem
       */
     template <typename PointT>
-    class Pyramid
+  class Pyramid : public PCLBase<PointT>
     {
-      public:
+    public:
         using PointCloudPtr = typename PointCloud<PointT>::Ptr;
         using PointCloudConstPtr = typename PointCloud<PointT>::ConstPtr;
         using Ptr = shared_ptr< Pyramid<PointT> >;

filters/src/pyramid.cpp

@@ -60,15 +60,15 @@ Pyramid<pcl::PointXYZRGB>::compute(
   int kernel_center_y = kernel_rows / 2;
 
   output.resize(levels_ + 1);
-  output[0].reset(new pcl::PointCloud<pcl::PointXYZRGB>);
+  output[0].reset(new PointCloud);
   *(output[0]) = *input_;
 
   if (input_->is_dense) {
     for (int l = 1; l <= levels_; ++l) {
-      output[l].reset(new pcl::PointCloud<pcl::PointXYZRGB>(output[l - 1]->width / 2,
-                                                            output[l - 1]->height / 2));
-      const PointCloud<pcl::PointXYZRGB>& previous = *output[l - 1];
-      PointCloud<pcl::PointXYZRGB>& next = *output[l];
+      output[l].reset(new PointCloud(output[l - 1]->width / 2,
+                                     output[l - 1]->height / 2));
+      const PointCloud& previous = *output[l - 1];
+      PointCloud& next = *output[l];
 #pragma omp parallel for default(none)                                                 \
     shared(next, previous, kernel_rows, kernel_cols, kernel_center_x, kernel_center_y) \
     num_threads(num_threads_)
@@ -111,10 +111,10 @@ Pyramid<pcl::PointXYZRGB>::compute(
   }
   else {
     for (int l = 1; l <= levels_; ++l) {
-      output[l].reset(new pcl::PointCloud<pcl::PointXYZRGB>(output[l - 1]->width / 2,
-                                                            output[l - 1]->height / 2));
-      const PointCloud<pcl::PointXYZRGB>& previous = *output[l - 1];
-      PointCloud<pcl::PointXYZRGB>& next = *output[l];
+      output[l].reset(new PointCloud(output[l - 1]->width / 2,
+                                     output[l - 1]->height / 2));
+      const PointCloud& previous = *output[l - 1];
+      PointCloud& next = *output[l];
 #pragma omp parallel for default(none)                                                 \
     shared(next, previous, kernel_rows, kernel_cols, kernel_center_x, kernel_center_y) \
     num_threads(num_threads_)
@@ -187,15 +187,15 @@ Pyramid<pcl::PointXYZRGBA>::compute(
   int kernel_center_y = kernel_rows / 2;
 
   output.resize(levels_ + 1);
-  output[0].reset(new pcl::PointCloud<pcl::PointXYZRGBA>);
+  output[0].reset(new PointCloud);
   *(output[0]) = *input_;
 
   if (input_->is_dense) {
     for (int l = 1; l <= levels_; ++l) {
-      output[l].reset(new pcl::PointCloud<pcl::PointXYZRGBA>(
+      output[l].reset(new PointCloud(
           output[l - 1]->width / 2, output[l - 1]->height / 2));
-      const PointCloud<pcl::PointXYZRGBA>& previous = *output[l - 1];
-      PointCloud<pcl::PointXYZRGBA>& next = *output[l];
+      const PointCloud& previous = *output[l - 1];
+      PointCloud& next = *output[l];
 #pragma omp parallel for default(none)                                                 \
     shared(next, previous, kernel_rows, kernel_cols, kernel_center_x, kernel_center_y) \
     num_threads(num_threads_)
@@ -240,10 +240,10 @@ Pyramid<pcl::PointXYZRGBA>::compute(
   }
   else {
     for (int l = 1; l <= levels_; ++l) {
-      output[l].reset(new pcl::PointCloud<pcl::PointXYZRGBA>(
+      output[l].reset(new PointCloud(
           output[l - 1]->width / 2, output[l - 1]->height / 2));
-      const PointCloud<pcl::PointXYZRGBA>& previous = *output[l - 1];
-      PointCloud<pcl::PointXYZRGBA>& next = *output[l];
+      const PointCloud& previous = *output[l - 1];
+      PointCloud& next = *output[l];
 #pragma omp parallel for default(none)                                                 \
     shared(next, previous, kernel_rows, kernel_cols, kernel_center_x, kernel_center_y) \
     num_threads(num_threads_)
@@ -325,15 +325,15 @@ Pyramid<pcl::RGB>::compute(std::vector<Pyramid<pcl::RGB>::PointCloudPtr>& output
   int kernel_center_y = kernel_rows / 2;
 
   output.resize(levels_ + 1);
-  output[0].reset(new pcl::PointCloud<pcl::RGB>);
+  output[0].reset(new PointCloud);
   *(output[0]) = *input_;
 
   if (input_->is_dense) {
     for (int l = 1; l <= levels_; ++l) {
-      output[l].reset(new pcl::PointCloud<pcl::RGB>(output[l - 1]->width / 2,
+      output[l].reset(new PointCloud(output[l - 1]->width / 2,
                                                     output[l - 1]->height / 2));
-      const PointCloud<pcl::RGB>& previous = *output[l - 1];
-      PointCloud<pcl::RGB>& next = *output[l];
+      const PointCloud& previous = *output[l - 1];
+      PointCloud& next = *output[l];
 #pragma omp parallel for default(none)                                                 \
     shared(next, previous, kernel_rows, kernel_cols, kernel_center_x, kernel_center_y) \
     num_threads(num_threads_)
@@ -368,10 +368,10 @@ Pyramid<pcl::RGB>::compute(std::vector<Pyramid<pcl::RGB>::PointCloudPtr>& output
   }
   else {
     for (int l = 1; l <= levels_; ++l) {
-      output[l].reset(new pcl::PointCloud<pcl::RGB>(output[l - 1]->width / 2,
+      output[l].reset(new PointCloud(output[l - 1]->width / 2,
                                                     output[l - 1]->height / 2));
-      const PointCloud<pcl::RGB>& previous = *output[l - 1];
-      PointCloud<pcl::RGB>& next = *output[l];
+      const PointCloud& previous = *output[l - 1];
+      PointCloud& next = *output[l];
 #pragma omp parallel for default(none)                                                 \
     shared(next, previous, kernel_rows, kernel_cols, kernel_center_x, kernel_center_y) \
     num_threads(num_threads_)