From e939b43ad745abd40a84c1cd09d0788d1be11510 Mon Sep 17 00:00:00 2001
From: SunBlack <SunBlack@users.noreply.github.com>
Date: Fri, 25 Nov 2022 13:12:18 +0100
Subject: [PATCH] Drop most CUDA apps, as they are never built.

---
 cuda/apps/src/kinect_cloud.cpp                | 129 -----
 cuda/apps/src/kinect_debayering.cpp           | 106 -----
 cuda/apps/src/kinect_dediscretize.cpp         | 110 -----
 cuda/apps/src/kinect_mapping.cpp              | 291 ------------
 cuda/apps/src/kinect_normals_cuda.cpp         | 263 -----------
 cuda/apps/src/kinect_planes_cuda.cpp          | 320 -------------
 cuda/apps/src/kinect_ransac.cpp               | 232 ---------
 cuda/apps/src/kinect_segmentation_cuda.cpp    | 442 ------------------
 .../src/kinect_segmentation_planes_cuda.cpp   | 311 ------------
 cuda/apps/src/kinect_tool_standalone.cpp      | 117 -----
 10 files changed, 2321 deletions(-)
 delete mode 100644 cuda/apps/src/kinect_cloud.cpp
 delete mode 100644 cuda/apps/src/kinect_debayering.cpp
 delete mode 100644 cuda/apps/src/kinect_dediscretize.cpp
 delete mode 100644 cuda/apps/src/kinect_mapping.cpp
 delete mode 100644 cuda/apps/src/kinect_normals_cuda.cpp
 delete mode 100644 cuda/apps/src/kinect_planes_cuda.cpp
 delete mode 100644 cuda/apps/src/kinect_ransac.cpp
 delete mode 100644 cuda/apps/src/kinect_segmentation_cuda.cpp
 delete mode 100644 cuda/apps/src/kinect_segmentation_planes_cuda.cpp
 delete mode 100644 cuda/apps/src/kinect_tool_standalone.cpp

diff --git a/cuda/apps/src/kinect_cloud.cpp b/cuda/apps/src/kinect_cloud.cpp
deleted file mode 100644
index 4390c46828b..00000000000
--- a/cuda/apps/src/kinect_cloud.cpp
+++ /dev/null
@@ -1,129 +0,0 @@
-/*
- * Software License Agreement (BSD License)
- *
- *  Copyright (c) 2010, Willow Garage, Inc.
- *  All rights reserved.
- *
- *  Redistribution and use in source and binary forms, with or without
- *  modification, are permitted provided that the following conditions
- *  are met:
- *
- *   * Redistributions of source code must retain the above copyright
- *     notice, this list of conditions and the following disclaimer.
- *   * Redistributions in binary form must reproduce the above
- *     copyright notice, this list of conditions and the following
- *     disclaimer in the documentation and/or other materials provided
- *     with the distribution.
- *   * Neither the name of Willow Garage, Inc. nor the names of its
- *     contributors may be used to endorse or promote products derived
- *     from this software without specific prior written permission.
- *
- *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- *  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- *  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
- *  FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
- *  COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
- *  INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
- *  BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
- *  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
- *  CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- *  LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
- *  ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
- *  POSSIBILITY OF SUCH DAMAGE.
- *
- * $Id$
- *
- */
-
-#include <ros/ros.h>
-#include <pcl/PCLPointCloud2.h>
-#include <message_filters/subscriber.h>
-#include <message_filters/synchronizer.h>
-#include <message_filters/sync_policies/approximate_time.h>
-#include <pcl_cuda/io/disparity_to_cloud.h>
-#include <pcl_cuda/sample_consensus/sac_model_plane.h>
-#include <pcl_cuda/sample_consensus/ransac.h>
-
-#include <pcl/point_cloud.h>
-#include <pcl_ros/point_cloud.h>
-#include <pcl/point_types.h>
-
-#include <functional>
-
-using namespace message_filters;
-using namespace pcl;
-using namespace pcl_cuda;
-
-DisparityToCloud d2c;
-ros::Publisher pub;
-
-struct EventHelper
-{
-  void
-  callback (const pcl::PCLImage::ConstPtr &depth,
-            const pcl::PCLImage::ConstPtr &rgb,
-            const pcl::CameraInfo::ConstPtr &info)
-  {
-    //using Indices = pcl_cuda::SampleConsensusModel<pcl_cuda::Host>::Indices;
-
-    //pcl_cuda::PointCloudAOS<pcl_cuda::Host>::Ptr data (new pcl_cuda::PointCloudAOS<pcl_cuda::Host>);
-    PointCloudAOS<Device>::Ptr data;
-    d2c.callback (depth, rgb, info, data);
-
-    SampleConsensusModelPlane<Device>::Ptr sac_model (new SampleConsensusModelPlane<Device> (data));
-//    SampleConsensusModelPlane<Host>::Ptr sac_model (new pcl_cuda::SampleConsensusModelPlane<pcl_cuda::Host> (data));
-    RandomSampleConsensus<Device> sac (sac_model);
-    sac.setDistanceThreshold (0.05);
-
-    if (!sac.computeModel (2))
-      std::cerr << "Failed to compute model" << std::endl;
-
-    // Convert data from Thrust/HOST to PCL
-    pcl::PointCloud<pcl::PointXYZRGB> output;
-//    pcl_cuda::toPCL (*data, output);
-
-    output.header.stamp = ros::Time::now ();
-    pub.publish (output);
-  }
-};
-
-int
-main (int argc, char **argv)
-{
-  ros::init (argc, argv, "disparity_to_cloud");
-  ros::NodeHandle nh;
-
-  // Prepare output
-  pub = nh.advertise<PCLPointCloud2>("output", 1);
-
-  // Subscribe to topics
-  Synchronizer<sync_policies::ApproximateTime<PCLImage, PCLImage, CameraInfo> > sync_rgb (30);
-  Synchronizer<sync_policies::ApproximateTime<PCLImage, CameraInfo> > sync (30);
-  Subscriber<PCLImage> sub_depth, sub_rgb;
-  Subscriber<CameraInfo> sub_info;
-  sub_depth.subscribe (nh, "/camera/depth/image", 30);
-  sub_rgb.subscribe (nh, "/camera/rgb/image_color", 30);
-  sub_info.subscribe (nh, "/camera/rgb/camera_info", 120);
-  //sub_info.subscribe (nh, "/camera/depth/camera_info", 120);
-
-  EventHelper h;
-
-  if (argc > 1 && atoi (argv[1]) == 1)
-  {
-    ROS_INFO ("[disparity_to_cloud] Using RGB to color the points.");
-    sync_rgb.connectInput (sub_depth, sub_rgb, sub_info);
-    //sync_rgb.registerCallback (bind (&pcl_cuda::DisparityToCloud::callback, k, _1, _2, _3));
-    sync_rgb.registerCallback (std::bind (&EventHelper::callback, &h, _1, _2, _3));
-  }
-  else
-  {
-    sync.connectInput (sub_depth, sub_info);
-    //sync.registerCallback (bind (&pcl_cuda::DisparityToCloud::callback, k, _1, PCLImageConstPtr (), _2));
-    sync.registerCallback (std::bind (&EventHelper::callback, &h, _1, PCLImageConstPtr (), _2));
-  }
-
-  // Do this indefinitely
-  ros::spin ();
-
-  return (0);
-}
diff --git a/cuda/apps/src/kinect_debayering.cpp b/cuda/apps/src/kinect_debayering.cpp
deleted file mode 100644
index 1b9f075ad5a..00000000000
--- a/cuda/apps/src/kinect_debayering.cpp
+++ /dev/null
@@ -1,106 +0,0 @@
-/*
- * Software License Agreement (BSD License)
- *
- *  Copyright (c) 2010, Willow Garage, Inc.
- *  All rights reserved.
- *
- *  Redistribution and use in source and binary forms, with or without
- *  modification, are permitted provided that the following conditions
- *  are met:
- *
- *   * Redistributions of source code must retain the above copyright
- *     notice, this list of conditions and the following disclaimer.
- *   * Redistributions in binary form must reproduce the above
- *     copyright notice, this list of conditions and the following
- *     disclaimer in the documentation and/or other materials provided
- *     with the distribution.
- *   * Neither the name of Willow Garage, Inc. nor the names of its
- *     contributors may be used to endorse or promote products derived
- *     from this software without specific prior written permission.
- *
- *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- *  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- *  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
- *  FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
- *  COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
- *  INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
- *  BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
- *  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
- *  CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- *  LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
- *  ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
- *  POSSIBILITY OF SUCH DAMAGE.
- *
- * $Id$
- *
- */
-
-#include <pcl/memory.h>
-#include <pcl/cuda/io/cloud_to_pcl.h>
-#include <pcl/cuda/io/debayering.h>
-#include <pcl/cuda/time_cpu.h>
-#include <pcl/io/kinect_grabber.h>
-
-#include <opencv2/opencv.hpp>
-
-#include <functional>
-#include <iostream>
-#include <mutex>
-
-
-class SimpleKinectTool
-{
-  public:
-     //SimpleKinectTool () : viewer ("KinectGrabber"), init_(false) {}
-
-    void cloud_cb_ (const openni_wrapper::Image::Ptr& image)
-    {
-    	thrust::host_vector<pcl_cuda::OpenNIRGB> rgb_image(image->getWidth () * image->getHeight ());
-    	cv::Mat cv_image( image->getHeight (), image->getWidth (), CV_8UC3 );
-    	{
-    	pcl::ScopeTime t ("computeBilinear+memcpy");
-    	debayering.computeBilinear (image, rgb_image);
-    	//debayering.computeEdgeAware (image, rgb_image);
-    	// now fill image and show!
-    	pcl::ScopeTime t2 ("memcpy");
-    	memcpy (cv_image.data, &rgb_image[0], image->getWidth () * image->getHeight () * 3);
-    	}
-    	imshow ("test", cv_image);
-    }
-    
-    void run (const std::string& device_id)
-    {
-	    cv::namedWindow("test", CV_WINDOW_AUTOSIZE);
-      pcl::Grabber* interface = new pcl::OpenNIGrabber(device_id);
-
-      std::function<void (const openni_wrapper::Image::Ptr& image)> f = std::bind (&SimpleKinectTool::cloud_cb_, this, _1);
-
-      interface->registerCallback (f);
-
-      interface->start ();
-      
-      while (true)
-      {
-        //sleep (1);
-        cv::waitKey(10);
-      }
-
-      interface->stop ();
-    }
-
-    pcl_cuda::Debayering<pcl_cuda::Host> debayering;
-    std::mutex mutex_;
-    bool init_;
-};
-
-int main (int argc, char** argv)
-{
-	std::string device_id = "#1";
-	if (argc == 2)
-	{
-		device_id = argv[1];
-	}
-  SimpleKinectTool v;
-  v.run (device_id);
-  return 0;
-}
diff --git a/cuda/apps/src/kinect_dediscretize.cpp b/cuda/apps/src/kinect_dediscretize.cpp
deleted file mode 100644
index 18840374bbf..00000000000
--- a/cuda/apps/src/kinect_dediscretize.cpp
+++ /dev/null
@@ -1,110 +0,0 @@
-/*
- * Software License Agreement (BSD License)
- *
- *  Copyright (c) 2010, Willow Garage, Inc.
- *  All rights reserved.
- *
- *  Redistribution and use in source and binary forms, with or without
- *  modification, are permitted provided that the following conditions
- *  are met:
- *
- *   * Redistributions of source code must retain the above copyright
- *     notice, this list of conditions and the following disclaimer.
- *   * Redistributions in binary form must reproduce the above
- *     copyright notice, this list of conditions and the following
- *     disclaimer in the documentation and/or other materials provided
- *     with the distribution.
- *   * Neither the name of Willow Garage, Inc. nor the names of its
- *     contributors may be used to endorse or promote products derived
- *     from this software without specific prior written permission.
- *
- *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- *  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- *  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
- *  FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
- *  COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
- *  INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
- *  BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
- *  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
- *  CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- *  LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
- *  ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
- *  POSSIBILITY OF SUCH DAMAGE.
- *
- * $Id$
- *
- */
-
-#include <pcl/memory.h>
-#include <pcl/point_cloud.h>
-#include <pcl/point_types.h>
-#include <pcl/cuda/io/cloud_to_pcl.h>
-#include <pcl/cuda/io/disparity_to_cloud.h>
-#include <pcl/cuda/sample_consensus/ransac.h>
-#include <pcl/cuda/sample_consensus/sac_model_plane.h>
-#include <pcl/cuda/time_cpu.h>
-#include <pcl/io/openni_grabber.h>
-#include <pcl/visualization/cloud_viewer.h>
-
-#include <functional>
-#include <iostream>
-#include <mutex>
-
-
-class SimpleKinectTool
-{
-  public:
-     SimpleKinectTool () : viewer ("KinectGrabber"), init_(false) {}
-
-    void cloud_cb_ (const openni_wrapper::Image::Ptr& image, const openni_wrapper::DepthImage::Ptr& depth_image, float constant)
-    {
-	    pcl_cuda::PointCloudAOS<pcl_cuda::Device>::Ptr data;
-    	{
-    	pcl::ScopeTime t ("time:");    
-      d2c.compute<pcl_cuda::Device> (depth_image, image, constant, data);
-      }
-      //d2c.callback (depth_image, constant, *data);
-
-      pcl::PointCloud<pcl::PointXYZRGB>::Ptr output (new pcl::PointCloud<pcl::PointXYZRGB>);
-      pcl_cuda::toPCL (*data, *output);
-
-      viewer.showCloud (output);
-
-    }
-    
-    void run (const std::string& device_id)
-    {
-      pcl::Grabber* interface = new pcl::OpenNIGrabber(device_id);
-
-      std::function<void (const openni_wrapper::Image::Ptr& image, const openni_wrapper::DepthImage::Ptr& depth_image, float)> f = std::bind (&SimpleKinectTool::cloud_cb_, this, _1, _2, _3);
-
-      interface->registerCallback (f);
-
-      //viewer.runOnVisualizationThread (fn, "viz_cb");
-      interface->start ();
-      
-      while (true)
-      {
-        sleep (1);
-      }
-
-      interface->stop ();
-    }
-
-    pcl_cuda::DisparityToCloud d2c;
-    pcl::visualization::CloudViewer viewer;
-    std::mutex mutex_;
-    bool init_;
-};
-
-int main (int argc, char** argv)
-{
-	std::string device_id = "#1";
-	if (argc == 2)
-	{
-		device_id = argv[1];
-	}
-  SimpleKinectTool v;
-  v.run (device_id);
-  return 0;
-}
diff --git a/cuda/apps/src/kinect_mapping.cpp b/cuda/apps/src/kinect_mapping.cpp
deleted file mode 100644
index 834fdf1be87..00000000000
--- a/cuda/apps/src/kinect_mapping.cpp
+++ /dev/null
@@ -1,291 +0,0 @@
-/*
- * Software License Agreement (BSD License)
- *
- *  Copyright (c) 2010, Willow Garage, Inc.
- *  All rights reserved.
- *
- *  Redistribution and use in source and binary forms, with or without
- *  modification, are permitted provided that the following conditions
- *  are met:
- *
- *   * Redistributions of source code must retain the above copyright
- *     notice, this list of conditions and the following disclaimer.
- *   * Redistributions in binary form must reproduce the above
- *     copyright notice, this list of conditions and the following
- *     disclaimer in the documentation and/or other materials provided
- *     with the distribution.
- *   * Neither the name of Willow Garage, Inc. nor the names of its
- *     contributors may be used to endorse or promote products derived
- *     from this software without specific prior written permission.
- *
- *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- *  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- *  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
- *  FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
- *  COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
- *  INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
- *  BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
- *  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
- *  CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- *  LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
- *  ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
- *  POSSIBILITY OF SUCH DAMAGE.
- *
- * $Id$
- *
- */
-
-#include <pcl/memory.h>
-#include <pcl/point_cloud.h>
-#include <pcl/point_types.h>
-#include <pcl/common/transform.h>
-#include <pcl/cuda/io/cloud_to_pcl.h>
-#include <pcl/cuda/io/disparity_to_cloud.h>
-#include <pcl/cuda/io/extract_indices.h>
-#include <pcl/cuda/sample_consensus/multi_ransac.h>
-#include <pcl/cuda/sample_consensus/sac_model_1point_plane.h>
-#include <pcl/cuda/segmentation/connected_components.h>
-#include <pcl/cuda/time_cpu.h>
-#include <pcl/cuda/time_gpu.h>
-#include <pcl/io/openni_grabber.h>
-#include <pcl/io/pcd_grabber.h>
-#include <pcl/visualization/cloud_viewer.h>
-#include <pcl/visualization/pcl_visualizer.h>
-#include <pcl/visualization/point_cloud_handlers.h>
-
-#include <boost/filesystem.hpp>
-
-#include <Eigen/Core>
-#include <Eigen/Geometry>
-
-#include <opencv2/opencv.hpp>
-#include <opencv2/gpu/gpu.hpp>
-
-#include <functional>
-#include <iostream>
-#include <mutex>
-
-
-using namespace pcl_cuda;
-
-template <template <typename> class Storage>
-struct ImageType
-{
-  using type = void;
-};
-
-template <>
-struct ImageType<pcl_cuda::Device>
-{
-  using type = cv::gpu::GpuMat;
-};
-
-template <>
-struct ImageType<pcl_cuda::Host>
-{
-  using type = cv::Mat;
-};
-
-class MultiRansac
-{
-  public:
-    MultiRansac () : viewer ("PCL CUDA - MultiSac"), new_cloud(false), use_viewer(true) {}
-
-    void logo_cb (const pcl::PointCloud<pcl::PointXYZRGB>::ConstPtr & cloud)
-    {
-      //logo_cloud_ = cloud;
-      //viewer.showCloud (logo_cloud_, "logo");
-      std::cerr << "got logo" << std::endl;
-    }
-
-    void viz_cb (pcl::visualization::PCLVisualizer& viz)
-    {
-      std::lock_guard<std::mutex> l(m_mutex);
-      if (new_cloud)
-      {
-        using ColorHandler = pcl::visualization::PointCloudColorHandlerRGBField<pcl::PointXYZRGBNormal>;
-
-        ColorHandler Color_handler (normal_cloud);
-        static bool first_time = true;
-        if (!first_time)
-        {
-          viz.removePointCloud ("normalcloud");
-          viz.removePointCloud ("cloud");
-        }
-        else
-          first_time = false;
-
-        viz.addPointCloudNormals<pcl::PointXYZRGBNormal> (normal_cloud, 200, 0.1, "normalcloud");
-        viz.addPointCloud<pcl::PointXYZRGBNormal> (normal_cloud, Color_handler, std::string("cloud"), 0);
-        new_cloud = false;
-      }
-    }
-
-    template <template <typename> class Storage> void 
-    cloud_cb (const openni_wrapper::Image::Ptr& image,
-              const openni_wrapper::DepthImage::Ptr& depth_image,
-              float constant)
-    {
-      static unsigned count = 0;
-      static double last = pcl::getTime ();
-      double now = pcl::getTime ();
-      if (++count == 30 || (now - last) > 5)
-      {
-        std::cerr << "Average framerate: " << double(count)/double(now - last) << " Hz" <<  std::endl;
-        count = 0;
-        last = now;
-      }
-      //static unsigned int nr_planes_last_time = 0;
-
-      std::cerr << "received callback" << std::endl;
-      typename PointCloudAOS<Storage>::Ptr data;
-      typename SampleConsensusModel1PointPlane<Storage>::Ptr sac_model;
-      {
-      pcl::ScopeTime timer ("All: ");
-      // Compute the PointCloud on the device
-      d2c.compute<Storage> (depth_image, image, constant, data, true, 2);
-
-      {
-        pcl::ScopeTime t ("creating sac_model");
-        sac_model.reset (new SampleConsensusModel1PointPlane<Storage> (data));
-      }
-      MultiRandomSampleConsensus<Storage> sac (sac_model);
-      sac.setMinimumCoverage (0.90); // at least 95% points should be explained by planes
-      sac.setMaximumBatches (5);
-      sac.setIerationsPerBatch (1000);
-      sac.setDistanceThreshold (0.05);
-
-      {
-        pcl::ScopeTime timer ("computeModel: ");
-        if (!sac.computeModel (0))
-        {
-          std::cerr << "Failed to compute model" << std::endl;
-        }
-        else
-        {
-          if (use_viewer)
-          {
-            std::cerr << "getting inliers.. ";
-            
-            std::vector<typename SampleConsensusModel1PointPlane<Storage>::IndicesPtr> planes;
-//            thrust::host_vector<int> regions_host = region_mask;
-//            std::copy (regions_host.begin (), regions_host.end(), std::ostream_iterator<int>(std::cerr, " "));
-            {
-              ScopeTime t ("retrieving inliers");
-              planes = sac.getAllInliers ();
-            }
-            
-            typename Storage<int>::type region_mask;
-            markInliers<Storage> (data, region_mask, planes);
-            std::cerr << "image_size: " << data->width << " x " << data->height << " = " << region_mask.size () << std::endl;
-            
-            typename StoragePointer<Storage,uchar>::type ptr = StorageAllocator<Storage,uchar>::alloc (data->width * data->height);
-              
-            createIndicesImage<Storage> (ptr, region_mask);
-
-            typename ImageType<Storage>::type dst (data->height, data->width, CV_8UC1, thrust::raw_pointer_cast<char4>(ptr), data->width);
-            cv::imshow ("Result", cv::Mat(dst));
-            cv::waitKey (2);
-
-            std::vector<int> planes_inlier_counts = sac.getAllInlierCounts ();
-            std::vector<float4> coeffs = sac.getAllModelCoefficients ();
-            std::vector<float3> centroids = sac.getAllModelCentroids ();
-            std::cerr << "Found " << planes_inlier_counts.size () << " planes" << std::endl;
-            int best_plane_inliers_count = -1;
-
-            for (unsigned int i = 0; i < planes.size (); i++)
-            {
-              if (planes_inlier_counts[i] > best_plane_inliers_count)
-              {
-                best_plane_inliers_count = planes_inlier_counts[i];
-              }
-
-              typename SampleConsensusModel1PointPlane<Storage>::IndicesPtr inliers_stencil;
-              inliers_stencil = planes[i];//sac.getInliersStencil ();
-
-              OpenNIRGB color;
-              double trand = 255 / (RAND_MAX + 1.0);
-              //int idx = (int)(rand () * trand);
-
-              color.r = (int)(rand () * trand);
-              color.g = (int)(rand () * trand);
-              color.b = (int)(rand () * trand);
-              {
-                ScopeTime t ("coloring planes");
-                colorIndices<Storage> (data, inliers_stencil, color);
-              }
-            }
-          }
-        }
-      }
-
-    }
-      if (use_viewer)
-      {
-        typename Storage<float4>::type normals = sac_model->getNormals ();
-
-        std::lock_guard<std::mutex> l(m_mutex);
-        normal_cloud.reset (new pcl::PointCloud<pcl::PointXYZRGBNormal>);
-        pcl_cuda::toPCL (*data, normals, *normal_cloud);
-        new_cloud = true;
-      }
-
-    }
-    
-    void 
-    run (bool use_device, bool use_viewer)
-    {
-      this->use_viewer = use_viewer;
-      //cudaDeviceSetCacheConfig (cudaFuncCachePreferL1);
-      pcl::OpenNIGrabber interface {};
-
-      if (use_device)
-      {
-        std::cerr << "[RANSAC] Using GPU..." << std::endl;
-        std::function<void (const openni_wrapper::Image::Ptr& image, const openni_wrapper::DepthImage::Ptr& depth_image, float)> f = std::bind (&MultiRansac::cloud_cb<pcl_cuda::Device>, this, _1, _2, _3);
-        interface.registerCallback (f);
-      }
-      else
-      {
-        std::cerr << "[RANSAC] Using CPU..." << std::endl;
-        std::function<void (const openni_wrapper::Image::Ptr& image, const openni_wrapper::DepthImage::Ptr& depth_image, float)> f = std::bind (&MultiRansac::cloud_cb<pcl_cuda::Host>, this, _1, _2, _3);
-        interface.registerCallback (f);
-      }
-
-      if (use_viewer)
-        viewer.runOnVisualizationThread (std::bind(&MultiRansac::viz_cb, this, _1), "viz_cb");
-
-      interface.start ();
-
-      while (!viewer.wasStopped ())
-      {
-        sleep (1);
-      }
-
-      interface.stop ();
-    }
-
-    pcl::PointCloud<pcl::PointXYZRGB>::ConstPtr logo_cloud_;
-    pcl_cuda::DisparityToCloud d2c;
-    pcl::visualization::CloudViewer viewer;
-   
-    std::mutex m_mutex;
-    pcl::PointCloud<pcl::PointXYZRGBNormal>::Ptr normal_cloud;
-    bool new_cloud;
-    bool use_viewer;
-};
-
-int 
-main (int argc, char **argv)
-{
-  sleep (1);
-  bool use_device = false;
-  bool use_viewer = true;
-  if (argc >= 2)
-    use_device = true;
-  if (argc >= 3)
-    use_viewer = false;
-  MultiRansac v;
-  v.run (use_device, use_viewer);
-  return 0;
-}
diff --git a/cuda/apps/src/kinect_normals_cuda.cpp b/cuda/apps/src/kinect_normals_cuda.cpp
deleted file mode 100644
index 53adab03536..00000000000
--- a/cuda/apps/src/kinect_normals_cuda.cpp
+++ /dev/null
@@ -1,263 +0,0 @@
-/*
- * Software License Agreement (BSD License)
- *
- *  Copyright (c) 2010, Willow Garage, Inc.
- *  All rights reserved.
- *
- *  Redistribution and use in source and binary forms, with or without
- *  modification, are permitted provided that the following conditions
- *  are met:
- *
- *   * Redistributions of source code must retain the above copyright
- *     notice, this list of conditions and the following disclaimer.
- *   * Redistributions in binary form must reproduce the above
- *     copyright notice, this list of conditions and the following
- *     disclaimer in the documentation and/or other materials provided
- *     with the distribution.
- *   * Neither the name of Willow Garage, Inc. nor the names of its
- *     contributors may be used to endorse or promote products derived
- *     from this software without specific prior written permission.
- *
- *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- *  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- *  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
- *  FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
- *  COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
- *  INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
- *  BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
- *  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
- *  CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- *  LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
- *  ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
- *  POSSIBILITY OF SUCH DAMAGE.
- *
- * $Id$
- *
- */
-
-#include <pcl/memory.h>
-#include <pcl/pcl_macros.h>
-#include <pcl/point_cloud.h>
-#include <pcl/point_types.h>
-#include <pcl/cuda/features/normal_3d.h>
-#include <pcl/cuda/time_cpu.h>
-#include <pcl/cuda/time_gpu.h>
-#include <pcl/cuda/io/cloud_to_pcl.h>
-#include <pcl/cuda/io/extract_indices.h>
-#include <pcl/cuda/io/disparity_to_cloud.h>
-#include <pcl/cuda/io/host_device.h>
-#include <pcl/io/openni_grabber.h>
-#include <pcl/io/pcd_grabber.h>
-#include <pcl/visualization/cloud_viewer.h>
-
-#include <opencv2/opencv.hpp>
-#include <opencv2/gpu/gpu.hpp>
-
-#include <functional>
-#include <iostream>
-#include <mutex>
-
-
-using namespace pcl::cuda;
-
-class NormalEstimation
-{
-  public:
-    NormalEstimation () : viewer ("PCL CUDA - NormalEstimation"), new_cloud(false), go_on(true) {}
-
-    void viz_cb (pcl::visualization::PCLVisualizer& viz)
-    {
-      std::string cloud_name ("cloud");
-      std::lock_guard<std::mutex> l(m_mutex);
-      if (new_cloud)
-      {
-        //using ColorHandler = pcl::visualization::PointCloudColorHandlerRGBField<pcl::PointXYZRGBNormal>;
-        using ColorHandler = pcl::visualization::PointCloudColorHandlerGenericField <pcl::PointXYZRGBNormal>;
-        //ColorHandler Color_handler (normal_cloud);
-        ColorHandler Color_handler (normal_cloud,"curvature");
-        static bool first_time = true;
-        double psize = 1.0,opacity = 1.0,linesize =1.0;
-        if (!first_time)
-        {
-          viz.getPointCloudRenderingProperties(pcl::visualization::PCL_VISUALIZER_LINE_WIDTH, linesize, cloud_name);
-          viz.getPointCloudRenderingProperties(pcl::visualization::PCL_VISUALIZER_OPACITY, opacity, cloud_name);
-          viz.getPointCloudRenderingProperties(pcl::visualization::PCL_VISUALIZER_POINT_SIZE, psize, cloud_name);
-          //viz.removePointCloud ("normalcloud");
-          viz.removePointCloud ("cloud");
-        }
-        else
-          first_time = false;
-
-        //viz.addPointCloudNormals<pcl::PointXYZRGBNormal> (normal_cloud, 139, 0.1, "normalcloud");
-        viz.addPointCloud<pcl::PointXYZRGBNormal> (normal_cloud, Color_handler, std::string("cloud"), 0);
-        viz.setPointCloudRenderingProperties(pcl::visualization::PCL_VISUALIZER_LINE_WIDTH, linesize, cloud_name);
-        viz.setPointCloudRenderingProperties(pcl::visualization::PCL_VISUALIZER_OPACITY, opacity, cloud_name);
-        viz.setPointCloudRenderingProperties(pcl::visualization::PCL_VISUALIZER_POINT_SIZE, psize, cloud_name);
-        new_cloud = false;
-      }
-    }
-
-    template <template <typename> class Storage> void 
-    file_cloud_cb (const pcl::PointCloud<pcl::PointXYZRGB>::ConstPtr& cloud) 
-    {
-      pcl::PointCloud<pcl::PointXYZRGB>::Ptr output (new pcl::PointCloud<pcl::PointXYZRGB>);
-      PointCloudAOS<Host> data_host;
-      data_host.resize (cloud->points.size());
-      for (std::size_t i = 0; i < cloud->points.size (); ++i)
-      {
-        PointXYZRGB pt;
-        pt.x = (*cloud)[i].x;
-        pt.y = (*cloud)[i].y;
-        pt.z = (*cloud)[i].z;
-        // Pack RGB into a float
-        pt.rgb = *(float*)(&(*cloud)[i].rgb);
-        data_host[i] = pt;
-      }
-      data_host.width = cloud->width;
-      data_host.height = cloud->height;
-      data_host.is_dense = cloud->is_dense;
-      typename PointCloudAOS<Storage>::Ptr data = toStorage<Host, Storage> (data_host);
-
-      // we got a cloud in device..
-
-      shared_ptr<typename Storage<float4>::type> normals;
-      {
-        ScopeTimeCPU time ("Normal Estimation");
-        float focallength = 580/2.0;
-        normals = computePointNormals<Storage, typename PointIterator<Storage,PointXYZRGB>::type > (data->points.begin (), data->points.end (), focallength, data, 0.05, 30);
-      }
-      go_on = false;
-
-      std::lock_guard<std::mutex> l(m_mutex);
-      normal_cloud.reset (new pcl::PointCloud<pcl::PointXYZRGBNormal>);
-      toPCL (*data, *normals, *normal_cloud);
-      new_cloud = true;
-    }
-
-    template <template <typename> class Storage> void 
-    cloud_cb (const openni_wrapper::Image::Ptr& image,
-              const openni_wrapper::DepthImage::Ptr& depth_image,
-              float constant)
-    {
-      static int smoothing_nr_iterations = 10;
-      static int smoothing_filter_size = 2;
-      cv::namedWindow("Parameters", CV_WINDOW_NORMAL);
-      cvCreateTrackbar ("iterations", "Parameters", &smoothing_nr_iterations, 50, NULL);
-      cvCreateTrackbar ("filter_size", "Parameters", &smoothing_filter_size, 10, NULL);
-      cv::waitKey (2);
-
-      static unsigned count = 0;
-      static double last = getTime ();
-      double now = getTime ();
-      if (++count == 30 || (now - last) > 5)
-      {
-        std::cout << "Average framerate: " << double(count)/double(now - last) << " Hz..........................................." <<  std::endl;
-        count = 0;
-        last = now;
-      }
-
-      pcl::PointCloud<pcl::PointXYZRGB>::Ptr output (new pcl::PointCloud<pcl::PointXYZRGB>);
-      typename PointCloudAOS<Storage>::Ptr data;
-
-      ScopeTimeCPU timer ("All: ");
-      // Compute the PointCloud on the device
-      d2c.compute<Storage> (depth_image, image, constant, data, false, 1, smoothing_nr_iterations, smoothing_filter_size);
-      //d2c.compute<Storage> (depth_image, image, constant, data, true, 2);
-
-      shared_ptr<typename Storage<float4>::type> normals;      
-      {
-        ScopeTimeCPU time ("Normal Estimation");
-        normals = computeFastPointNormals<Storage> (data);
-        //float focallength = 580/2.0;
-        //normals = computePointNormals<Storage, typename PointIterator<Storage,PointXYZRGB>::type > (data->points.begin (), data->points.end (), focallength, data, 0.05, 30);
-      }
-
-      std::lock_guard<std::mutex> l(m_mutex);
-      normal_cloud.reset (new pcl::PointCloud<pcl::PointXYZRGBNormal>);
-      toPCL (*data, *normals, *normal_cloud);
-      new_cloud = true;
-    }
-    
-    void 
-    run (bool use_device, bool use_file)
-    {
-      if (use_file)
-      {
-
-        float frames_per_second = 1;
-        bool repeat = false;
-
-        std::string path = "./frame_0.pcd";
-        pcl::PCDGrabber<pcl::PointXYZRGB > filegrabber {path, frames_per_second, repeat};
-        
-        if (use_device)
-        {
-          std::cerr << "[NormalEstimation] Using GPU..." << std::endl;
-          std::function<void (const pcl::PointCloud<pcl::PointXYZRGB>::ConstPtr&)> f = std::bind (&NormalEstimation::file_cloud_cb<Device>, this, _1);
-          filegrabber.registerCallback (f);
-        }
-        else
-        {
-          std::cerr << "[NormalEstimation] Using CPU..." << std::endl;
-          std::function<void (const pcl::PointCloud<pcl::PointXYZRGB>::ConstPtr&)> f = std::bind (&NormalEstimation::file_cloud_cb<Host>, this, _1);
-          filegrabber.registerCallback (f);
-        }
-
-        filegrabber.start ();
-        while (go_on)//!viewer.wasStopped () && go_on)
-        {
-          pcl_sleep (1);
-        }
-        filegrabber.stop ();
-      }
-      else
-      {
-        pcl::OpenNIGrabber grabber {};
-
-        if (use_device)
-        {
-          std::cerr << "[NormalEstimation] Using GPU..." << std::endl;
-          std::function<void (const openni_wrapper::Image::Ptr& image, const openni_wrapper::DepthImage::Ptr& depth_image, float)> f = std::bind (&NormalEstimation::cloud_cb<Device>, this, _1, _2, _3);
-          grabber.registerCallback (f);
-        }
-        else
-        {
-          std::cerr << "[NormalEstimation] Using CPU..." << std::endl;
-          std::function<void (const openni_wrapper::Image::Ptr& image, const openni_wrapper::DepthImage::Ptr& depth_image, float)> f = std::bind (&NormalEstimation::cloud_cb<Host>, this, _1, _2, _3);
-          grabber.registerCallback (f);
-        }
-
-        viewer.runOnVisualizationThread (std::bind(&NormalEstimation::viz_cb, this, _1), "viz_cb");
-
-        grabber.start ();
-        
-        while (!viewer.wasStopped ())
-        {
-          pcl_sleep (1);
-        }
-
-        grabber.stop ();
-      }
-    }
-
-    pcl::PointCloud<pcl::PointXYZRGBNormal>::Ptr normal_cloud;
-    DisparityToCloud d2c;
-    pcl::visualization::CloudViewer viewer;
-    std::mutex m_mutex;
-    bool new_cloud, go_on;
-};
-
-int 
-main (int argc, char **argv)
-{
-  bool use_device = false;
-  bool use_file = false;
-  if (argc >= 2)
-    use_device = true;
-  if (argc >= 3)
-    use_file = true;
-  NormalEstimation v;
-  v.run (use_device, use_file);
-  return 0;
-}
-
diff --git a/cuda/apps/src/kinect_planes_cuda.cpp b/cuda/apps/src/kinect_planes_cuda.cpp
deleted file mode 100644
index c61c03364f2..00000000000
--- a/cuda/apps/src/kinect_planes_cuda.cpp
+++ /dev/null
@@ -1,320 +0,0 @@
-/*
- * Software License Agreement (BSD License)
- *
- *  Copyright (c) 2010, Willow Garage, Inc.
- *  All rights reserved.
- *
- *  Redistribution and use in source and binary forms, with or without
- *  modification, are permitted provided that the following conditions
- *  are met:
- *
- *   * Redistributions of source code must retain the above copyright
- *     notice, this list of conditions and the following disclaimer.
- *   * Redistributions in binary form must reproduce the above
- *     copyright notice, this list of conditions and the following
- *     disclaimer in the documentation and/or other materials provided
- *     with the distribution.
- *   * Neither the name of Willow Garage, Inc. nor the names of its
- *     contributors may be used to endorse or promote products derived
- *     from this software without specific prior written permission.
- *
- *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- *  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- *  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
- *  FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
- *  COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
- *  INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
- *  BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
- *  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
- *  CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- *  LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
- *  ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
- *  POSSIBILITY OF SUCH DAMAGE.
- *
- * $Id$
- *
- */
-
-// pcl::cuda includes
-#include <pcl/cuda/time_cpu.h>
-#include <pcl/cuda/time_gpu.h>
-#include <pcl/cuda/io/cloud_to_pcl.h>
-#include <pcl/cuda/io/extract_indices.h>
-#include <pcl/cuda/io/disparity_to_cloud.h>
-#include <pcl/cuda/sample_consensus/sac_model_1point_plane.h>
-#include <pcl/cuda/sample_consensus/multi_ransac.h>
-#include <pcl/cuda/segmentation/connected_components.h>
-#include <pcl/cuda/features/normal_3d.h>
-
-#include <pcl/point_cloud.h>
-#include <pcl/point_types.h>
-#include <pcl/pcl_macros.h>
-#include <pcl/io/openni_grabber.h>
-#include <pcl/io/pcd_grabber.h>
-#include <pcl/visualization/cloud_viewer.h>
-#include <pcl/visualization/point_cloud_handlers.h>
-#include <pcl/visualization/pcl_visualizer.h>
-
-#include <opencv2/opencv.hpp>
-#include <opencv2/gpu/gpu.hpp>
-
-#include <Eigen/Core>
-#include <Eigen/Geometry>
-
-#include <boost/filesystem.hpp>
-
-#include <functional>
-#include <iostream>
-#include <mutex>
-
-using namespace pcl::cuda;
-
-#undef interface
-
-class MultiRansac
-{
-  public:
-    MultiRansac () : viewer ("PCL CUDA - MultiSac"), new_cloud(false), use_viewer(true) {}
-
-    void logo_cb (const pcl::PointCloud<pcl::PointXYZRGB>::ConstPtr & cloud)
-    {
-      //logo_cloud_ = cloud;
-      //viewer.showCloud (logo_cloud_, "logo");
-      std::cerr << "got logo" << std::endl;
-    }
-
-    void viz_cb (pcl::visualization::PCLVisualizer& viz)
-    {
-      std::lock_guard<std::mutex> l(m_mutex);
-      if (new_cloud)
-      {
-        double psize = 1.0,opacity = 1.0,linesize =1.0;
-        std::string cloud_name ("cloud");
-        using ColorHandler = pcl::visualization::PointCloudColorHandlerRGBField<pcl::PointXYZRGBNormal>;
-
-        ColorHandler Color_handler (normal_cloud);
-        static bool first_time = true;
-        if (!first_time)
-        {
-          viz.getPointCloudRenderingProperties(pcl::visualization::PCL_VISUALIZER_LINE_WIDTH, linesize, cloud_name);
-          viz.getPointCloudRenderingProperties(pcl::visualization::PCL_VISUALIZER_OPACITY, opacity, cloud_name);
-          viz.getPointCloudRenderingProperties(pcl::visualization::PCL_VISUALIZER_POINT_SIZE, psize, cloud_name);
-          //viz.removePointCloud ("normalcloud");
-          viz.removePointCloud ("cloud");
-        }
-        else
-          first_time = false;
-
-        //viz.addPointCloudNormals<pcl::PointXYZRGBNormal> (normal_cloud, 139, 0.1, "normalcloud");
-        viz.addPointCloud<pcl::PointXYZRGBNormal> (normal_cloud, Color_handler, std::string("cloud"), 0);
-        viz.setPointCloudRenderingProperties(pcl::visualization::PCL_VISUALIZER_LINE_WIDTH, linesize, cloud_name);
-        viz.setPointCloudRenderingProperties(pcl::visualization::PCL_VISUALIZER_OPACITY, opacity, cloud_name);
-        viz.setPointCloudRenderingProperties(pcl::visualization::PCL_VISUALIZER_POINT_SIZE, psize, cloud_name);
-        new_cloud = false;
-      }
-    }
-
-    template <template <typename> class Storage> void 
-    cloud_cb (const openni_wrapper::Image::Ptr& image,
-              const openni_wrapper::DepthImage::Ptr& depth_image,
-              float constant)
-    {
-      static unsigned count = 0;
-      static double last = pcl::cuda::getTime ();
-      double now = pcl::cuda::getTime ();
-      if (++count == 30 || (now - last) > 5)
-      {
-        std::cerr << "Average framerate: " << double(count)/double(now - last) << " Hz" <<  std::endl;
-        count = 0;
-        last = now;
-      }
-      //static unsigned int nr_planes_last_time = 0;
-
-      std::cerr << "received callback" << std::endl;
-      typename PointCloudAOS<Storage>::Ptr data;
-      typename SampleConsensusModel1PointPlane<Storage>::Ptr sac_model;
-      {
-      ScopeTimeCPU timer ("All: ");
-      static int threshold_x100 = 25;
-      static int smoothing_nr_iterations = 10;
-      static int smoothing_filter_size = 2;
-      static int enable_coloring = 1;
-
-      // Compute the PointCloud on the device
-      //d2c.compute<Storage> (depth_image, image, constant, data, true, 2);
-      d2c.compute<Storage> (depth_image, image, constant, data, true, 2, smoothing_nr_iterations, smoothing_filter_size);
-
-      // Compute normals
-      shared_ptr<typename Storage<float4>::type> normals;
-      {
-        ScopeTimeCPU time ("Normal Estimation");
-        //normals = computeFastPointNormals<Storage> (data);
-        float focallength = 580/2.0;
-        //normals = computePointNormals<Storage> (data->points.begin (), data->points.end (), focallength, data, 0.11f, 36);
-        normals = computeFastPointNormals<Storage> (data);
-      }
-
-      // Create sac_model
-      {
-        ScopeTimeCPU t ("creating sac_model");
-        sac_model.reset (new SampleConsensusModel1PointPlane<Storage> (data));
-      }
-      sac_model->setNormals (normals);
-
-      MultiRandomSampleConsensus<Storage> sac (sac_model);
-      sac.setMinimumCoverage (0.90); // at least 95% points should be explained by planes
-      sac.setMaximumBatches (5);
-      sac.setIerationsPerBatch (1000);
-      sac.setDistanceThreshold (threshold_x100 / 100.0);
-
-      {
-        ScopeTimeCPU timer ("computeModel: ");
-        if (!sac.computeModel (0))
-        {
-          std::cerr << "Failed to compute model" << std::endl;
-        }
-        else
-        {
-          if (use_viewer)
-          {
-            std::cerr << "getting inliers.. ";
-            
-            std::vector<typename SampleConsensusModel1PointPlane<Storage>::IndicesPtr> planes;
-            typename Storage<int>::type region_mask;
-            markInliers<Storage> (data, region_mask, planes);
-            thrust::host_vector<int> regions_host;
-            std::copy (regions_host.cbegin (), regions_host.cend(), std::ostream_iterator<int>(std::cerr, " "));
-            {
-              ScopeTimeCPU t ("retrieving inliers");
-              planes = sac.getAllInliers ();
-            }
-            std::vector<int> planes_inlier_counts = sac.getAllInlierCounts ();
-            std::vector<float4> coeffs = sac.getAllModelCoefficients ();
-            std::vector<float3> centroids = sac.getAllModelCentroids ();
-            std::cerr << "Found " << planes_inlier_counts.size () << " planes" << std::endl;
-            int best_plane_inliers_count = -1;
-
-            for (unsigned int i = 0; i < planes.size (); i++)
-            {
-              if (planes_inlier_counts[i] > best_plane_inliers_count)
-              {
-                best_plane_inliers_count = planes_inlier_counts[i];
-              }
-
-              typename SampleConsensusModel1PointPlane<Storage>::IndicesPtr inliers_stencil;
-              inliers_stencil = planes[i];//sac.getInliersStencil ();
-
-              OpenNIRGB color;
-              double trand = 255 / (RAND_MAX + 1.0);
-
-              color.r = (int)(rand () * trand);
-              color.g = (int)(rand () * trand);
-              color.b = (int)(rand () * trand);
-              if (enable_coloring)
-              {
-                ScopeTimeCPU t ("coloring planes");
-                colorIndices<Storage> (data, inliers_stencil, color);
-              }
-            }
-          }
-
-          cv::namedWindow("Parameters", CV_WINDOW_NORMAL);
-          cvCreateTrackbar( "iterations", "Parameters", &smoothing_nr_iterations, 50, NULL);
-          cvCreateTrackbar( "filter_size", "Parameters", &smoothing_filter_size, 10, NULL);
-          cvCreateTrackbar( "enable_coloring", "Parameters", &enable_coloring, 1, NULL);
-          cvCreateTrackbar( "threshold", "Parameters", &threshold_x100, 100, NULL);
-          cv::waitKey (2);
-        }
-      }
-
-    }
-      if (use_viewer)
-      {
-        auto normals = sac_model->getNormals ();
-
-        std::lock_guard<std::mutex> l(m_mutex);
-        normal_cloud.reset (new pcl::PointCloud<pcl::PointXYZRGBNormal>);
-        toPCL (*data, *normals, *normal_cloud);
-        new_cloud = true;
-      }
-
-      //pcl::PointCloud<pcl::PointXYZRGB>::Ptr output (new pcl::PointCloud<pcl::PointXYZRGB>);
-      //toPCL (*data, *output);
-      //viewer.showCloud (output);
-    }
-    
-    void 
-    run (bool use_device, bool use_viewer)
-    {
-      this->use_viewer = use_viewer;
-      //cudaDeviceSetCacheConfig (cudaFuncCachePreferL1);
-      pcl::OpenNIGrabber interface {};
-
-      if (use_device)
-      {
-        std::cerr << "[RANSAC] Using GPU..." << std::endl;
-        std::function<void (const openni_wrapper::Image::Ptr& image, const openni_wrapper::DepthImage::Ptr& depth_image, float)> f = std::bind (&MultiRansac::cloud_cb<Device>, this, _1, _2, _3);
-        interface.registerCallback (f);
-      }
-      else
-      {
-        std::cerr << "[RANSAC] Using CPU..." << std::endl;
-        std::function<void (const openni_wrapper::Image::Ptr& image, const openni_wrapper::DepthImage::Ptr& depth_image, float)> f = std::bind (&MultiRansac::cloud_cb<Host>, this, _1, _2, _3);
-        interface.registerCallback (f);
-      }
-
-      if (use_viewer)
-        viewer.runOnVisualizationThread (std::bind(&MultiRansac::viz_cb, this, _1), "viz_cb");
-
-      interface.start ();
-
-      //--------------------- load pcl logo file
-      //float frames_per_second = 1;
-      //bool repeat = false;
-
-      //std::string path = "./pcl_logo.pcd";
-      //if (path.empty() || !boost::filesystem::exists (path))
-      //{
-      //  std::cerr << "did not find file" << std::endl;
-      //}
-      //pcl::PCDGrabber<pcl::PointXYZRGB> filegrabber {path, frames_per_second, repeat};
-      //
-      //std::function<void(const pcl::PointCloud<pcl::PointXYZRGB>::ConstPtr&) > f = std::bind (&MultiRansac::logo_cb, this, _1);
-      //boost::signals2::connection c1 = filegrabber.registerCallback (f);
-
-      //filegrabber.start ();
-      //------- END --------- load pcl logo file
-      //
-      while (!viewer.wasStopped ())
-      {
-        pcl_sleep (1);
-      }
-
-      //filegrabber.stop ();
-      interface.stop ();
-    }
-
-    pcl::PointCloud<pcl::PointXYZRGB>::ConstPtr logo_cloud_;
-    DisparityToCloud d2c;
-    pcl::visualization::CloudViewer viewer;
-   
-    std::mutex m_mutex;
-    pcl::PointCloud<pcl::PointXYZRGBNormal>::Ptr normal_cloud;
-    bool new_cloud;
-    bool use_viewer;
-};
-
-int 
-main (int argc, char **argv)
-{
-  pcl_sleep (1);
-  bool use_device = false;
-  bool use_viewer = true;
-  if (argc >= 2)
-    use_device = true;
-  if (argc >= 3)
-    use_viewer = false;
-  MultiRansac v;
-  v.run (use_device, use_viewer);
-  return 0;
-}
diff --git a/cuda/apps/src/kinect_ransac.cpp b/cuda/apps/src/kinect_ransac.cpp
deleted file mode 100644
index c4eeae5f1da..00000000000
--- a/cuda/apps/src/kinect_ransac.cpp
+++ /dev/null
@@ -1,232 +0,0 @@
-/*
- * Software License Agreement (BSD License)
- *
- *  Copyright (c) 2010, Willow Garage, Inc.
- *  All rights reserved.
- *
- *  Redistribution and use in source and binary forms, with or without
- *  modification, are permitted provided that the following conditions
- *  are met:
- *
- *   * Redistributions of source code must retain the above copyright
- *     notice, this list of conditions and the following disclaimer.
- *   * Redistributions in binary form must reproduce the above
- *     copyright notice, this list of conditions and the following
- *     disclaimer in the documentation and/or other materials provided
- *     with the distribution.
- *   * Neither the name of Willow Garage, Inc. nor the names of its
- *     contributors may be used to endorse or promote products derived
- *     from this software without specific prior written permission.
- *
- *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- *  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- *  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
- *  FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
- *  COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
- *  INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
- *  BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
- *  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
- *  CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- *  LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
- *  ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
- *  POSSIBILITY OF SUCH DAMAGE.
- *
- * $Id$
- *
- */
-
-#include <pcl/memory.h>
-#include <pcl/point_cloud.h>
-#include <pcl/point_types.h>
-#include <pcl/cuda/time_cpu.h>
-#include <pcl/cuda/time_gpu.h>
-#include <pcl/cuda/io/cloud_to_pcl.h>
-#include <pcl/cuda/io/disparity_to_cloud.h>
-#include <pcl/cuda/io/extract_indices.h>
-#include <pcl/cuda/io/host_device.h>
-#include <pcl/cuda/sample_consensus/ransac.h>
-#include <pcl/cuda/sample_consensus/sac_model_1point_plane.h>
-#include <pcl/io/openni_grabber.h>
-#include <pcl/io/pcd_grabber.h>
-#include <pcl/visualization/cloud_viewer.h>
-
-#include <functional>
-#include <iostream>
-#include <mutex>
-
-
-using namespace pcl_cuda;
-
-class SimpleKinectTool
-{
-  public:
-    SimpleKinectTool () : /*viewer ("KinectGrabber"),*/ go_on(true) {}
-
-    template <template <typename> class Storage> void 
-    file_cloud_cb (const pcl::PointCloud<pcl::PointXYZRGB>::ConstPtr& cloud) 
-    {
-      pcl::ScopeTime ttt ("all");
-      pcl::PointCloud<pcl::PointXYZRGB>::Ptr output (new pcl::PointCloud<pcl::PointXYZRGB>);
-      PointCloudAOS<Host> data_host;
-      data_host.resize (cloud->points.size());
-      for (std::size_t i = 0; i < cloud->points.size (); ++i)
-      {
-        PointXYZRGB pt;
-        pt.x = (*cloud)[i].x;
-        pt.y = (*cloud)[i].y;
-        pt.z = (*cloud)[i].z;
-        // Pack RGB into a float
-        pt.rgb = *(float*)(&(*cloud)[i].rgb);
-        data_host[i] = pt;
-      }
-      data_host.width = cloud->width;
-      data_host.height = cloud->height;
-      data_host.is_dense = cloud->is_dense;
-      typename PointCloudAOS<Storage>::Ptr data = toStorage<Host, Storage> (data_host);
-
-      typename SampleConsensusModel1PointPlane<Storage>::Ptr sac_model (new SampleConsensusModel1PointPlane<Storage> (data));
-      RandomSampleConsensus<Storage> sac (sac_model);
-      sac.setMaxIterations (10000);
-      sac.setDistanceThreshold (0.05);
-
-      {
-        pcl::ScopeTime timer ("computeModel: ");
-        if (!sac.computeModel (0))
-        {
-          std::cerr << "Failed to compute model" << std::endl;
-        }
-        else
-        {
-          //typename SampleConsensusModel1PointPlane<Storage>::IndicesPtr inliers_stencil;
-          //inliers_stencil = sac.getInliersStencil ();
-
-      //    OpenNIRGB color;
-      //    color.r = 253; color.g = 0; color.b = 0;
-      //    std::cerr << data->points.size() << " =?= " << inliers_stencil->size () << std::endl;
-      //    colorIndices<Storage> (data, inliers_stencil, color);
-        }
-      }
-     
-      go_on = false;
-      //std::cerr << "got here" << std::endl;
-      //pcl_cuda::toPCL (*data, *output);
-      //std::cerr << "not here" << std::endl;
-      //viewer.showCloud (output);
-    }
-
-    template <template <typename> class Storage> void 
-    cloud_cb (const openni_wrapper::Image::Ptr& image,
-              const openni_wrapper::DepthImage::Ptr& depth_image,
-              float constant)
-    {
-      pcl::PointCloud<pcl::PointXYZRGB>::Ptr output (new pcl::PointCloud<pcl::PointXYZRGB>);
-      typename PointCloudAOS<Storage>::Ptr data;
-      {
-      pcl::ScopeTime timer ("All: ");
-      // Compute the PointCloud on the device
-      d2c.compute<Storage> (depth_image, image, constant, data);
-
-      typename SampleConsensusModel1PointPlane<Storage>::Ptr sac_model (new SampleConsensusModel1PointPlane<Storage> (data));
-      RandomSampleConsensus<Storage> sac (sac_model);
-      sac.setMaxIterations (10000);
-      sac.setDistanceThreshold (0.05);
-
-      {
-        pcl::ScopeTime timer ("computeModel: ");
-        if (!sac.computeModel (0))
-        {
-          std::cerr << "Failed to compute model" << std::endl;
-        }
-        else
-        {
-          typename SampleConsensusModel1PointPlane<Storage>::IndicesPtr inliers_stencil;
-          inliers_stencil = sac.getInliersStencil ();
-
-          OpenNIRGB color;
-          color.r = 253; color.g = 0; color.b = 0;
-          colorIndices<Storage> (data, inliers_stencil, color);
-        }
-      }
-
-    }
-      pcl_cuda::toPCL (*data, *output);
-      //viewer.showCloud (output);
-    }
-    
-    void 
-    run (bool use_device)
-    {
-#if 1
-
-      float frames_per_second = 1;
-      bool repeat = false;
-
-      std::string path = "./frame_0.pcd";
-      pcl::PCDGrabber<pcl::PointXYZRGB > filegrabber (path, frames_per_second, repeat);
-      
-      if (use_device)
-      {
-        std::cerr << "[RANSAC] Using GPU..." << std::endl;
-        std::function<void (const pcl::PointCloud<pcl::PointXYZRGB>::ConstPtr&)> f = std::bind (&SimpleKinectTool::file_cloud_cb<pcl_cuda::Device>, this, _1);
-        filegrabber.registerCallback (f);
-      }
-      else
-      {
-        std::cerr << "[RANSAC] Using CPU..." << std::endl;
-        std::function<void (const pcl::PointCloud<pcl::PointXYZRGB>::ConstPtr&)> f = std::bind (&SimpleKinectTool::file_cloud_cb<pcl_cuda::Host>, this, _1);
-        filegrabber.registerCallback (f);
-      }
-
-      filegrabber.start ();
-      while (go_on)//!viewer.wasStopped () && go_on)
-      {
-        sleep (1);
-      }
-      filegrabber.stop ();
-
-      
-      //------- END --------- load pcl logo file
-#else
-      pcl::OpenNIGrabber interface {};
-
-      boost::signals2::connection c;
-      if (use_device)
-      {
-        std::cerr << "[RANSAC] Using GPU..." << std::endl;
-        std::function<void (const openni_wrapper::Image::Ptr& image, const openni_wrapper::DepthImage::Ptr& depth_image, float)> f = std::bind (&SimpleKinectTool::cloud_cb<pcl_cuda::Device>, this, _1, _2, _3);
-        c = interface.registerCallback (f);
-      }
-      else
-      {
-        std::cerr << "[RANSAC] Using CPU..." << std::endl;
-        std::function<void (const openni_wrapper::Image::Ptr& image, const openni_wrapper::DepthImage::Ptr& depth_image, float)> f = std::bind (&SimpleKinectTool::cloud_cb<pcl_cuda::Host>, this, _1, _2, _3);
-        c = interface.registerCallback (f);
-      }
-
-      //viewer.runOnVisualizationThread (fn, "viz_cb");
-      interface.start ();
-      while (!viewer.wasStopped ())
-      {
-        sleep (1);
-      }
-
-      interface.stop ();
-#endif 
-    }
-
-    pcl_cuda::DisparityToCloud d2c;
-    //pcl::visualization::CloudViewer viewer;
-    std::mutex mutex_;
-    bool go_on;
-};
-
-int 
-main (int argc, char **argv)
-{
-  bool use_device = false;
-  if (argc >= 2)
-    use_device = true;
-  SimpleKinectTool v;
-  v.run (use_device);
-  return 0;
-}
diff --git a/cuda/apps/src/kinect_segmentation_cuda.cpp b/cuda/apps/src/kinect_segmentation_cuda.cpp
deleted file mode 100644
index 2b0e242de9b..00000000000
--- a/cuda/apps/src/kinect_segmentation_cuda.cpp
+++ /dev/null
@@ -1,442 +0,0 @@
-/*
- * Software License Agreement (BSD License)
- *
- *  Copyright (c) 2010, Willow Garage, Inc.
- *  All rights reserved.
- *
- *  Redistribution and use in source and binary forms, with or without
- *  modification, are permitted provided that the following conditions
- *  are met:
- *
- *   * Redistributions of source code must retain the above copyright
- *     notice, this list of conditions and the following disclaimer.
- *   * Redistributions in binary form must reproduce the above
- *     copyright notice, this list of conditions and the following
- *     disclaimer in the documentation and/or other materials provided
- *     with the distribution.
- *   * Neither the name of Willow Garage, Inc. nor the names of its
- *     contributors may be used to endorse or promote products derived
- *     from this software without specific prior written permission.
- *
- *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- *  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- *  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
- *  FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
- *  COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
- *  INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
- *  BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
- *  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
- *  CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- *  LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
- *  ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
- *  POSSIBILITY OF SUCH DAMAGE.
- *
- * $Id$
- *
- */
-
-#include <pcl/memory.h>
-#include <pcl/pcl_macros.h>
-#include <pcl/point_cloud.h>
-#include <pcl/point_types.h>
-#include <pcl/cuda/features/normal_3d.h>
-#include <pcl/cuda/time_cpu.h>
-#include <pcl/cuda/time_gpu.h>
-#include <pcl/cuda/io/cloud_to_pcl.h>
-#include <pcl/cuda/io/extract_indices.h>
-#include <pcl/cuda/io/disparity_to_cloud.h>
-#include <pcl/cuda/io/host_device.h>
-#include <pcl/cuda/sample_consensus/sac_model_1point_plane.h>
-#include <pcl/cuda/sample_consensus/multi_ransac.h>
-#include <pcl/cuda/segmentation/connected_components.h>
-#include <pcl/io/openni_grabber.h>
-#include <pcl/io/pcd_grabber.h>
-#include <pcl/visualization/cloud_viewer.h>
-
-#include <opencv2/highgui/highgui.hpp>
-#include <opencv2/highgui/highgui_c.h>
-#include <opencv2/gpu/gpu.hpp>
-
-#include <functional>
-#include <iostream>
-#include <mutex>
-
-
-using namespace pcl::cuda;
-
-template <template <typename> class Storage>
-struct ImageType
-{
-  using type = void;
-};
-
-template <>
-struct ImageType<Device>
-{
-  using type = cv::gpu::GpuMat;
-  static void createContinuous (int h, int w, int typ, type &mat)
-  {
-    cv::gpu::createContinuous (h, w, typ, mat);
-  }
-};
-
-template <>
-struct ImageType<Host>
-{
-  using type = cv::Mat;
-  static void createContinuous (int h, int w, int typ, type &mat)
-  {
-    mat = cv::Mat (h, w, typ); // assume no padding at the end of line
-  }
-};
-
-class Segmentation
-{
-  public:
-    Segmentation () 
-      : viewer ("PCL CUDA - Segmentation"),
-      new_cloud(false), go_on(true), enable_color(1), normal_method(0), nr_neighbors (36), radius_cm (5), normal_viz_step(200)
-      , enable_normal_viz(false)
-    {}
-
-    void viz_cb (pcl::visualization::PCLVisualizer& viz)
-    {
-      static bool last_enable_normal_viz = enable_normal_viz;
-      std::lock_guard<std::mutex> l(m_mutex);
-      if (new_cloud)
-      {
-        double psize = 1.0,opacity = 1.0,linesize =1.0;
-        std::string cloud_name ("cloud");
-
-        static bool first_time = true;
-        if (!first_time)
-        {
-          viz.getPointCloudRenderingProperties(pcl::visualization::PCL_VISUALIZER_LINE_WIDTH, linesize, cloud_name);
-          viz.getPointCloudRenderingProperties(pcl::visualization::PCL_VISUALIZER_OPACITY, opacity, cloud_name);
-          viz.getPointCloudRenderingProperties(pcl::visualization::PCL_VISUALIZER_POINT_SIZE, psize, cloud_name);
-          if (last_enable_normal_viz)
-            viz.removePointCloud ("normalcloud");
-          viz.removePointCloud ("cloud");
-        }
-        else
-          first_time = false;
-
-        if (enable_normal_viz)
-          viz.addPointCloudNormals<pcl::PointXYZRGBNormal> (normal_cloud, normal_viz_step, 0.1, "normalcloud");
-
-        if (enable_color == 1)
-        {
-          using ColorHandler = pcl::visualization::PointCloudColorHandlerRGBField<pcl::PointXYZRGBNormal>;
-          ColorHandler Color_handler (normal_cloud);
-          viz.addPointCloud<pcl::PointXYZRGBNormal> (normal_cloud, Color_handler, std::string(cloud_name));
-        }
-        else
-        {
-          using ColorHandler = pcl::visualization::PointCloudColorHandlerGenericField <pcl::PointXYZRGBNormal>;
-          ColorHandler Color_handler (normal_cloud,"curvature");
-          viz.addPointCloud<pcl::PointXYZRGBNormal> (normal_cloud, Color_handler, cloud_name, 0);
-        }
-        viz.setPointCloudRenderingProperties(pcl::visualization::PCL_VISUALIZER_LINE_WIDTH, linesize, cloud_name);
-        viz.setPointCloudRenderingProperties(pcl::visualization::PCL_VISUALIZER_OPACITY, opacity, cloud_name);
-        viz.setPointCloudRenderingProperties(pcl::visualization::PCL_VISUALIZER_POINT_SIZE, psize, cloud_name);
-        new_cloud = false;
-      }
-      last_enable_normal_viz = enable_normal_viz;
-    }
-
-    template <template <typename> class Storage> void 
-    file_cloud_cb (const pcl::PointCloud<pcl::PointXYZRGB>::ConstPtr& cloud) 
-    {
-      pcl::PointCloud<pcl::PointXYZRGB>::Ptr output (new pcl::PointCloud<pcl::PointXYZRGB>);
-      PointCloudAOS<Host> data_host;
-      data_host.resize (cloud->points.size());
-      for (std::size_t i = 0; i < cloud->points.size (); ++i)
-      {
-        PointXYZRGB pt;
-        pt.x = (*cloud)[i].x;
-        pt.y = (*cloud)[i].y;
-        pt.z = (*cloud)[i].z;
-        // Pack RGB into a float
-        pt.rgb = *(float*)(&(*cloud)[i].rgb);
-        data_host[i] = pt;
-      }
-      data_host.width = cloud->width;
-      data_host.height = cloud->height;
-      data_host.is_dense = cloud->is_dense;
-      typename PointCloudAOS<Storage>::Ptr data = toStorage<Host, Storage> (data_host);
-
-      // we got a cloud in device..
-
-      shared_ptr<typename Storage<float4>::type> normals;
-      {
-        ScopeTimeCPU time ("Normal Estimation");
-        constexpr float focallength = 580/2.0;
-        normals = computePointNormals<Storage, typename PointIterator<Storage,PointXYZRGB>::type > (data->points.begin (), data->points.end (), focallength, data, 0.05, 30);
-      }
-      go_on = false;
-
-      std::lock_guard<std::mutex> l(m_mutex);
-      normal_cloud.reset (new pcl::PointCloud<pcl::PointXYZRGBNormal>);
-      toPCL (*data, *normals, *normal_cloud);
-      new_cloud = true;
-    }
-
-    template <template <typename> class Storage> void 
-    cloud_cb (const openni_wrapper::Image::Ptr& image,
-              const openni_wrapper::DepthImage::Ptr& depth_image,
-              float constant)
-    {
-      static double last = getTime ();
-      double now = getTime ();
-      {
-        std::cout << std::endl;
-        std::cout << "Average framerate: " << 1.0/double(now - last) << " Hz --- ";
-        last = now;
-      }
-
-      static int smoothing_nr_iterations = 10;
-      static int smoothing_filter_size = 2;
-      static int enable_visualization = 1;
-      static int enable_mean_shift = 0;
-      static int enable_plane_fitting = 0;
-      static int meanshift_sp=8;
-      static int meanshift_sr=20;
-      static int meanshift_minsize=100;
-
-      pcl::PointCloud<pcl::PointXYZRGB>::Ptr output (new pcl::PointCloud<pcl::PointXYZRGB>);
-      typename PointCloudAOS<Storage>::Ptr data;
-
-      //ScopeTimeCPU timer ("All: ");
-      ScopeTimeCPU time ("everything");
-      // Compute the PointCloud on the device
-      {
-        ScopeTimeCPU time ("disparity smoothing");
-        d2c.compute<Storage> (depth_image, image, constant, data, false, 1, smoothing_nr_iterations, smoothing_filter_size);
-      }
-
-      shared_ptr<typename Storage<float4>::type> normals;      
-      {
-        ScopeTimeCPU time ("Normal Estimation");
-        if (normal_method == 1)
-          normals = computeFastPointNormals<Storage> (data);
-        else
-        {
-          constexpr float focallength = 580/2.0;
-          normals = computePointNormals<Storage> (data->points.begin (), data->points.end (), focallength, data, radius_cm / 100.0f, nr_neighbors);
-        }
-        cudaDeviceSynchronize ();
-      }
-
-      // retrieve normals as an image..
-      typename ImageType<Storage>::type normal_image;
-      typename StoragePointer<Storage,char4>::type ptr;
-      {
-        ScopeTimeCPU time ("Matrix Creation");
-        ImageType<Storage>::createContinuous ((int)data->height, (int)data->width, CV_8UC4, normal_image);
-        ptr = typename StoragePointer<Storage,char4>::type ((char4*)normal_image.data);
-        createNormalsImage<Storage> (ptr, *normals);
-      }
-
-      //TODO: this breaks for pcl::cuda::Host
-      cv::Mat seg;
-      {
-        ScopeTimeCPU time ("Mean Shift");
-        if (enable_mean_shift == 1)
-        {
-          cv::gpu::meanShiftSegmentation (normal_image, seg, meanshift_sp, meanshift_sr, meanshift_minsize);
-          typename Storage<char4>::type new_colors ((char4*)seg.datastart, (char4*)seg.dataend);
-          colorCloud<Storage> (data, new_colors);
-        }
-      }
-
-      typename SampleConsensusModel1PointPlane<Storage>::Ptr sac_model;
-      if (enable_plane_fitting == 1)
-      {
-        // Create sac_model
-        {
-          ScopeTimeCPU t ("creating sac_model");
-          sac_model.reset (new SampleConsensusModel1PointPlane<Storage> (data));
-        }
-        sac_model->setNormals (normals);
-
-        MultiRandomSampleConsensus<Storage> sac (sac_model);
-        sac.setMinimumCoverage (0.90); // at least 95% points should be explained by planes
-        sac.setMaximumBatches (1);
-        sac.setIerationsPerBatch (1024);
-        sac.setDistanceThreshold (0.05);
-
-        {
-          ScopeTimeCPU timer ("computeModel: ");
-          if (!sac.computeModel (0))
-          {
-            std::cerr << "Failed to compute model" << std::endl;
-          }
-          else
-          {
-            if (enable_visualization)
-            {
-//              std::cerr << "getting inliers.. ";
-              
-              std::vector<typename SampleConsensusModel1PointPlane<Storage>::IndicesPtr> planes;
-              typename Storage<int>::type region_mask;
-              markInliers<Storage> (data, region_mask, planes);
-              thrust::host_vector<int> regions_host;
-              std::copy (regions_host.cbegin (), regions_host.cend(), std::ostream_iterator<int>(std::cerr, " "));
-              {
-                ScopeTimeCPU t ("retrieving inliers");
-                planes = sac.getAllInliers ();
-              }
-              std::vector<int> planes_inlier_counts = sac.getAllInlierCounts ();
-              std::vector<float4> coeffs = sac.getAllModelCoefficients ();
-              std::cerr << "Found " << planes_inlier_counts.size () << " planes" << std::endl;
-
-              for (unsigned int i = 0; i < planes.size (); i++)
-              {
-                typename SampleConsensusModel1PointPlane<Storage>::IndicesPtr inliers_stencil;
-                inliers_stencil = planes[i];//sac.getInliersStencil ();
-
-                OpenNIRGB color;
-                //double trand = 255 / (RAND_MAX + 1.0);
-
-                //color.r = (int)(rand () * trand);
-                //color.g = (int)(rand () * trand);
-                //color.b = (int)(rand () * trand);
-                color.r = (1.0f + coeffs[i].x) * 128;
-                color.g = (1.0f + coeffs[i].y) * 128;
-                color.b = (1.0f + coeffs[i].z) * 128;
-                {
-                  ScopeTimeCPU t ("coloring planes");
-                  colorIndices<Storage> (data, inliers_stencil, color);
-                }
-              }
-            }
-          }
-        }
-      }
-
-      {
-        ScopeTimeCPU time ("Vis");
-        cv::namedWindow("NormalImage", CV_WINDOW_NORMAL);
-        cv::namedWindow("Parameters", CV_WINDOW_NORMAL);
-        cvCreateTrackbar( "iterations", "Parameters", &smoothing_nr_iterations, 50, NULL);
-        cvCreateTrackbar( "filter_size", "Parameters", &smoothing_filter_size, 10, NULL);
-        cvCreateTrackbar( "enable_visualization", "Parameters", &enable_visualization, 1, NULL);
-        cvCreateTrackbar( "enable_color", "Parameters", &enable_color, 1, NULL);
-        cvCreateTrackbar( "normal_method", "Parameters", &normal_method, 1, NULL);
-        cvCreateTrackbar( "neighborhood_radius", "Parameters", &radius_cm, 50, NULL);
-        cvCreateTrackbar( "nr_neighbors", "Parameters", &nr_neighbors, 400, NULL);
-        cvCreateTrackbar( "normal_viz_step", "Parameters", &normal_viz_step, 1000, NULL);
-        cvCreateTrackbar( "enable_mean_shift", "Parameters", &enable_mean_shift, 1, NULL);
-        cvCreateTrackbar( "meanshift_sp", "Parameters", &meanshift_sp, 100, NULL);
-        cvCreateTrackbar( "meanshift_sr", "Parameters", &meanshift_sr, 100, NULL);
-        cvCreateTrackbar( "meanshift_minsize", "Parameters", &meanshift_minsize, 500, NULL);
-        cvCreateTrackbar( "enable_plane_fitting", "Parameters", &enable_plane_fitting, 1, NULL);
-        cvCreateTrackbar( "enable_normal_viz", "Parameters", &enable_normal_viz, 1, NULL);
-        if (enable_visualization == 1)
-        {
-
-          cv::Mat temp;
-          if (enable_mean_shift == 1)
-            cv::cvtColor(seg,temp,CV_BGR2RGB);
-          else
-            cv::cvtColor(cv::Mat(normal_image),temp,CV_BGR2RGB);
-          cv::imshow ("NormalImage", temp);
-
-          std::lock_guard<std::mutex> l(m_mutex);
-          normal_cloud.reset (new pcl::PointCloud<pcl::PointXYZRGBNormal>);
-          toPCL (*data, *normals, *normal_cloud);
-          new_cloud = true;
-        }
-        cv::waitKey (2);
-      }
-    }
-    
-    void 
-    run (bool use_device, bool use_file)
-    {
-      if (use_file)
-      {
-
-        float frames_per_second = 1;
-        bool repeat = false;
-
-        std::string path = "./frame_0.pcd";
-        pcl::PCDGrabber<pcl::PointXYZRGB > filegrabber {path, frames_per_second, repeat};
-        
-        if (use_device)
-        {
-          std::cerr << "[Segmentation] Using GPU..." << std::endl;
-          std::function<void (const pcl::PointCloud<pcl::PointXYZRGB>::ConstPtr&)> f = std::bind (&Segmentation::file_cloud_cb<Device>, this, _1);
-          filegrabber.registerCallback (f);
-        }
-        else
-        {
-//          std::cerr << "[Segmentation] Using CPU..." << std::endl;
-//          std::function<void (const pcl::PointCloud<pcl::PointXYZRGB>::ConstPtr&)> f = std::bind (&Segmentation::file_cloud_cb<Host>, this, _1);
-//          filegrabber.registerCallback (f);
-        }
-
-        filegrabber.start ();
-        while (go_on)//!viewer.wasStopped () && go_on)
-        {
-          pcl_sleep (1);
-        }
-        filegrabber.stop ();
-      }
-      else
-      {
-        pcl::OpenNIGrabber grabber {};
-
-        if (use_device)
-        {
-          std::cerr << "[Segmentation] Using GPU..." << std::endl;
-          std::function<void (const openni_wrapper::Image::Ptr& image, const openni_wrapper::DepthImage::Ptr& depth_image, float)> f = std::bind (&Segmentation::cloud_cb<Device>, this, _1, _2, _3);
-          grabber.registerCallback (f);
-        }
-        else
-        {
-//          std::cerr << "[Segmentation] Using CPU..." << std::endl;
-//          std::function<void (const openni_wrapper::Image::Ptr& image, const openni_wrapper::DepthImage::Ptr& depth_image, float)> f = std::bind (&Segmentation::cloud_cb<Host>, this, _1, _2, _3);
-//          grabber.registerCallback (f);
-        }
-
-        viewer.runOnVisualizationThread (std::bind(&Segmentation::viz_cb, this, _1), "viz_cb");
-
-        grabber.start ();
-        
-        while (!viewer.wasStopped ())
-        {
-          pcl_sleep (1);
-        }
-
-        grabber.stop ();
-      }
-    }
-
-    pcl::PointCloud<pcl::PointXYZRGBNormal>::Ptr normal_cloud;
-    DisparityToCloud d2c;
-    pcl::visualization::CloudViewer viewer;
-    std::mutex m_mutex;
-    bool new_cloud, go_on;
-    int enable_color;
-    int normal_method;
-    int nr_neighbors;
-    int radius_cm;
-    int normal_viz_step;
-    int enable_normal_viz;
-};
-
-int 
-main (int argc, char **argv)
-{
-  bool use_device = false;
-  bool use_file = false;
-  if (argc >= 2)
-    use_device = true;
-  if (argc >= 3)
-    use_file = true;
-  Segmentation s;
-  s.run (use_device, use_file);
-  return 0;
-}
-
diff --git a/cuda/apps/src/kinect_segmentation_planes_cuda.cpp b/cuda/apps/src/kinect_segmentation_planes_cuda.cpp
deleted file mode 100644
index cb7591b64a1..00000000000
--- a/cuda/apps/src/kinect_segmentation_planes_cuda.cpp
+++ /dev/null
@@ -1,311 +0,0 @@
-/*
- * Software License Agreement (BSD License)
- *
- *  Copyright (c) 2010, Willow Garage, Inc.
- *  All rights reserved.
- *
- *  Redistribution and use in source and binary forms, with or without
- *  modification, are permitted provided that the following conditions
- *  are met:
- *
- *   * Redistributions of source code must retain the above copyright
- *     notice, this list of conditions and the following disclaimer.
- *   * Redistributions in binary form must reproduce the above
- *     copyright notice, this list of conditions and the following
- *     disclaimer in the documentation and/or other materials provided
- *     with the distribution.
- *   * Neither the name of Willow Garage, Inc. nor the names of its
- *     contributors may be used to endorse or promote products derived
- *     from this software without specific prior written permission.
- *
- *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- *  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- *  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
- *  FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
- *  COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
- *  INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
- *  BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
- *  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
- *  CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- *  LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
- *  ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
- *  POSSIBILITY OF SUCH DAMAGE.
- *
- * $Id$
- *
- */
-
-#include <pcl/memory.h>
-#include <pcl/point_cloud.h>
-#include <pcl/point_types.h>
-#include <pcl/cuda/time_cpu.h>
-#include <pcl/cuda/time_gpu.h>
-#include <pcl/cuda/features/normal_3d.h>
-#include <pcl/cuda/io/cloud_to_pcl.h>
-#include <pcl/cuda/io/disparity_to_cloud.h>
-#include <pcl/cuda/io/extract_indices.h>
-#include <pcl/cuda/io/host_device.h>
-#include <pcl/cuda/segmentation/connected_components.h>
-#include <pcl/cuda/segmentation/mssegmentation.h>
-#include <pcl/io/openni_grabber.h>
-#include <pcl/io/pcd_grabber.h>
-#include <pcl/visualization/cloud_viewer.h>
-
-#include <opencv2/highgui/highgui.hpp>
-#include <opencv2/gpu/gpu.hpp>
-
-#include <fstream>
-#include <functional>
-#include <iostream>
-#include <mutex>
-
-
-using namespace pcl::cuda;
-
-template <template <typename> class Storage>
-struct ImageType
-{
-  using type = void;
-};
-
-template <>
-struct ImageType<Device>
-{
-  using type = cv::gpu::GpuMat;
-  static void createContinuous (int h, int w, int typ, type &mat)
-  {
-    cv::gpu::createContinuous (h, w, typ, mat);
-  }
-};
-
-template <>
-struct ImageType<Host>
-{
-  using type = cv::Mat;
-  static void createContinuous (int h, int w, int typ, type &mat)
-  {
-    mat = cv::Mat (h, w, typ); // assume no padding at the end of line
-  }
-};
-
-class Segmentation
-{
-  public:
-    Segmentation () 
-      : viewer ("PCL CUDA - Segmentation"),
-      new_cloud(false), go_on(true) {}
-
-    void viz_cb (pcl::visualization::PCLVisualizer& viz)
-    {
-      std::lock_guard<std::mutex> l(m_mutex);
-      if (new_cloud)
-      {
-        //using ColorHandler = pcl::visualization::PointCloudColorHandlerRGBField<pcl::PointXYZRGBNormal>;
-        using ColorHandler = pcl::visualization::PointCloudColorHandlerGenericField <pcl::PointXYZRGBNormal>;
-        ColorHandler Color_handler (normal_cloud,"curvature");
-        static bool first_time = true;
-        if (!first_time)
-        {
-          viz.removePointCloud ("normalcloud");
-          viz.removePointCloud ("cloud");
-        }
-        else
-          first_time = false;
-
-        viz.addPointCloudNormals<pcl::PointXYZRGBNormal> (normal_cloud, 200, 0.1, "normalcloud");
-        viz.addPointCloud<pcl::PointXYZRGBNormal> (normal_cloud, Color_handler, std::string("cloud"), 0);
-        new_cloud = false;
-      }
-    }
-
-    template <template <typename> class Storage> void 
-    file_cloud_cb (const pcl::PointCloud<pcl::PointXYZRGB>::ConstPtr& cloud) 
-    {
-      pcl::PointCloud<pcl::PointXYZRGB>::Ptr output (new pcl::PointCloud<pcl::PointXYZRGB>);
-      PointCloudAOS<Host> data_host;
-      data_host.resize (cloud->points.size());
-      for (std::size_t i = 0; i < cloud->points.size (); ++i)
-      {
-        PointXYZRGB pt;
-        pt.x = (*cloud)[i].x;
-        pt.y = (*cloud)[i].y;
-        pt.z = (*cloud)[i].z;
-        // Pack RGB into a float
-        pt.rgb = *(float*)(&(*cloud)[i].rgb);
-        data_host[i] = pt;
-      }
-      data_host.width = cloud->width;
-      data_host.height = cloud->height;
-      data_host.is_dense = cloud->is_dense;
-      typename PointCloudAOS<Storage>::Ptr data = toStorage<Host, Storage> (data_host);
-
-      // we got a cloud in device..
-
-      shared_ptr<typename Storage<float4>::type> normals;      
-      {
-        ScopeTimeCPU time ("TIMING: Normal Estimation");
-        constexpr float focallength = 580/2.0;
-        normals = computePointNormals<Storage, typename PointIterator<Storage,PointXYZRGB>::type > (data->points.begin (), data->points.end (), focallength, data, 0.05, 30);
-      }
-      go_on = false;
-
-      std::lock_guard<std::mutex> l(m_mutex);
-      normal_cloud.reset (new pcl::PointCloud<pcl::PointXYZRGBNormal>);
-      toPCL (*data, *normals, *normal_cloud);
-      new_cloud = true;
-    }
-
-    template <template <typename> class Storage> void 
-    cloud_cb (const openni_wrapper::Image::Ptr& image,
-              const openni_wrapper::DepthImage::Ptr& depth_image,
-              float constant)
-    {
-      static unsigned count = 0;
-      static double last = getTime ();
-      double now = getTime ();
-      if (++count == 30 || (now - last) > 5)
-      {
-        std::cout << "Average framerate: " << double(count)/double(now - last) << " Hz..........................................." <<  std::endl;
-        count = 0;
-        last = now;
-      }
-
-      pcl::PointCloud<pcl::PointXYZRGB>::Ptr output (new pcl::PointCloud<pcl::PointXYZRGB>);
-      typename PointCloudAOS<Storage>::Ptr data;
-
-      //ScopeTimeCPU timer ("All: ");
-      ScopeTimeCPU time ("TIMING: everything");
-      // Compute the PointCloud on the device
-      d2c.compute<Storage> (depth_image, image, constant, data, true, 2);
-
-      shared_ptr<typename Storage<float4>::type> normals;
-      {
-        ScopeTimeCPU time ("TIMING: Normal Estimation");
-        normals = computeFastPointNormals<Storage> (data);
-      }
-
-      // retrieve normals as an image..
-      // typename StoragePointer<Storage,char4>::type ptr = StorageAllocator<Storage,char4>::alloc (data->width * data->height);
-      // createNormalsImage<Storage> (ptr, normals);
-      // typename ImageType<Storage>::type normal_image (data->height, data->width, CV_8UC4, thrust::raw_pointer_cast<char4>(ptr), data->width);
-      typename ImageType<Storage>::type normal_image;
-      typename StoragePointer<Storage,char4>::type ptr;
-      {
-        ScopeTimeCPU time ("TIMING: Matrix Creation");
-      ImageType<Storage>::createContinuous ((int)data->height, (int)data->width, CV_8UC4, normal_image);
-      ptr = typename StoragePointer<Storage,char4>::type ((char4*)normal_image.data);
-      createNormalsImage<Storage> (ptr, *normals);
-      }
-
-      //TODO: this breaks for pcl::cuda::Host
-      pcl::cuda::detail::DjSets comps(0);
-      cv::Mat seg;
-      {
-        ScopeTimeCPU time ("TIMING: Mean Shift");
-        pcl::cuda::meanShiftSegmentation (normal_image, seg, 8, 20, 100, comps);
-      }
-      std::cerr << "time since callback: " << getTime () - now << std::endl;
-//      std::cout << "comps " << comps.parent.size () << " " << comps.rank.size () << " " << comps.size.size () << std::endl;
-//      std::cout << "parent" << std::endl;
-//      std::copy (comps.parent.begin (), comps.parent.end (), std::ostream_iterator<int>(std::cout, " "));
-//      std::cout << "rank"   << std::endl;
-//      std::copy (comps.rank.begin (), comps.rank.end (), std::ostream_iterator<int>(std::cout, " "));
-//      std::cout << "size"   << std::endl;
-//      std::copy (comps.size.begin (), comps.size.end (), std::ostream_iterator<int>(std::cout, " "));
-
-      {
-        ScopeTimeCPU time ("TIMING: Vis");
-      cv::namedWindow("NormalImage", CV_WINDOW_NORMAL);
-      //cv::imshow ("NormalImage", cv::Mat(normal_image));
-      cv::imshow ("NormalImage", seg);
-      cv::waitKey (2);
-
-      std::lock_guard<std::mutex> l(m_mutex);
-      normal_cloud.reset (new pcl::PointCloud<pcl::PointXYZRGBNormal>);
-      toPCL (*data, *normals, *normal_cloud);
-      new_cloud = true;
-      }
-    }
-    
-    void 
-    run (bool use_device, bool use_file)
-    {
-      if (use_file)
-      {
-        float frames_per_second = 1;
-        bool repeat = false;
-
-        std::string path = "./frame_0.pcd";
-        pcl::PCDGrabber<pcl::PointXYZRGB > filegrabber {path, frames_per_second, repeat};
-        
-        if (use_device)
-        {
-          std::cerr << "[Segmentation] Using GPU..." << std::endl;
-          std::function<void (const pcl::PointCloud<pcl::PointXYZRGB>::ConstPtr&)> f = std::bind (&Segmentation::file_cloud_cb<Device>, this, _1);
-          filegrabber.registerCallback (f);
-        }
-        else
-        {
-//          std::cerr << "[Segmentation] Using CPU..." << std::endl;
-//          std::function<void (const pcl::PointCloud<pcl::PointXYZRGB>::ConstPtr&)> f = std::bind (&Segmentation::file_cloud_cb<Host>, this, _1);
-//          filegrabber.registerCallback (f);
-        }
-
-        filegrabber.start ();
-        while (go_on)//!viewer.wasStopped () && go_on)
-        {
-          pcl_sleep (1);
-        }
-        filegrabber.stop ();
-      }
-      else
-      {
-        pcl::OpenNIGrabber grabber {};
-
-        if (use_device)
-        {
-          std::cerr << "[Segmentation] Using GPU..." << std::endl;
-          std::function<void (const openni_wrapper::Image::Ptr& image, const openni_wrapper::DepthImage::Ptr& depth_image, float)> f = std::bind (&Segmentation::cloud_cb<Device>, this, _1, _2, _3);
-          grabber.registerCallback (f);
-        }
-        else
-        {
-//          std::cerr << "[Segmentation] Using CPU..." << std::endl;
-//          std::function<void (const openni_wrapper::Image::Ptr& image, const openni_wrapper::DepthImage::Ptr& depth_image, float)> f = std::bind (&Segmentation::cloud_cb<Host>, this, _1, _2, _3);
-//          grabber.registerCallback (f);
-        }
-
-        viewer.runOnVisualizationThread (std::bind(&Segmentation::viz_cb, this, _1), "viz_cb");
-
-        grabber.start ();
-        
-        while (!viewer.wasStopped ())
-        {
-          pcl_sleep (1);
-        }
-
-        grabber.stop ();
-      }
-    }
-
-    pcl::PointCloud<pcl::PointXYZRGBNormal>::Ptr normal_cloud;
-    DisparityToCloud d2c;
-    pcl::visualization::CloudViewer viewer;
-    std::mutex m_mutex;
-    bool new_cloud, go_on;
-};
-
-int 
-main (int argc, char **argv)
-{
-  bool use_device = false;
-  bool use_file = false;
-  if (argc >= 2)
-    use_device = true;
-  if (argc >= 3)
-    use_file = true;
-  Segmentation s;
-  s.run (use_device, use_file);
-  return 0;
-}
-
diff --git a/cuda/apps/src/kinect_tool_standalone.cpp b/cuda/apps/src/kinect_tool_standalone.cpp
deleted file mode 100644
index aa741349f93..00000000000
--- a/cuda/apps/src/kinect_tool_standalone.cpp
+++ /dev/null
@@ -1,117 +0,0 @@
-/*
- * Software License Agreement (BSD License)
- *
- *  Copyright (c) 2010, Willow Garage, Inc.
- *  All rights reserved.
- *
- *  Redistribution and use in source and binary forms, with or without
- *  modification, are permitted provided that the following conditions
- *  are met:
- *
- *   * Redistributions of source code must retain the above copyright
- *     notice, this list of conditions and the following disclaimer.
- *   * Redistributions in binary form must reproduce the above
- *     copyright notice, this list of conditions and the following
- *     disclaimer in the documentation and/or other materials provided
- *     with the distribution.
- *   * Neither the name of Willow Garage, Inc. nor the names of its
- *     contributors may be used to endorse or promote products derived
- *     from this software without specific prior written permission.
- *
- *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- *  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- *  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
- *  FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
- *  COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
- *  INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
- *  BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
- *  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
- *  CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- *  LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
- *  ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
- *  POSSIBILITY OF SUCH DAMAGE.
- *
- * $Id$
- *
- */
-
-#include <pcl/memory.h>
-#include <pcl/point_cloud.h>
-#include <pcl/point_types.h>
-#include <pcl/cuda/io/cloud_to_pcl.h>
-#include <pcl/cuda/io/disparity_to_cloud.h>
-#include <pcl/cuda/time_cpu.h>
-#include <pcl/io/openni_grabber.h>
-#include <pcl/visualization/cloud_viewer.h>
-
-#include <functional>
-#include <iostream>
-#include <mutex>
-
-
-using pcl::cuda::PointCloudAOS;
-using pcl::cuda::Device;
-using pcl::cuda::Host;
-
-class SimpleKinectTool
-{
-  public:
-     SimpleKinectTool (bool downsample) : viewer ("KinectGrabber"), downsample_(downsample) {}
-
-    void cloud_cb_ (const openni_wrapper::Image::Ptr& image, const openni_wrapper::DepthImage::Ptr& depth_image, float constant)
-    {
-      PointCloudAOS<Device>::Ptr data;
-    	{
-        pcl::cuda::ScopeTimeCPU t ("time:");    
-        d2c.compute<Device> (depth_image, image, constant, data, downsample_);
-      }
-      //d2c.callback (depth_image, constant, *data);
-
-      pcl::PointCloud<pcl::PointXYZRGB>::Ptr output (new pcl::PointCloud<pcl::PointXYZRGB>);
-      pcl::cuda::toPCL (*data, *output);
-
-      viewer.showCloud (output);
-
-    }
-    
-    void run (const std::string& device_id)
-    {
-      pcl::Grabber* interface = new pcl::OpenNIGrabber(device_id);
-
-      std::function<void (const openni_wrapper::Image::Ptr& image, const openni_wrapper::DepthImage::Ptr& depth_image, float)> f = std::bind (&SimpleKinectTool::cloud_cb_, this, _1, _2, _3);
-
-      interface->registerCallback (f);
-
-      //viewer.runOnVisualizationThread (fn, "viz_cb");
-      interface->start ();
-      
-      while (true)
-      {
-        sleep (1);
-      }
-
-      interface->stop ();
-    }
-
-    pcl::cuda::DisparityToCloud d2c;
-    pcl::visualization::CloudViewer viewer;
-    std::mutex mutex_;
-    bool downsample_;
-};
-
-int main (int argc, char** argv)
-{
-	std::string device_id = "#1";
-  int downsample = false;
-	if (argc >= 2)
-	{
-		device_id = argv[1];
-	}
-	if (argc >= 3)
-	{
-		downsample = atoi (argv[2]);
-	}
-  SimpleKinectTool v (downsample);
-  v.run (device_id);
-  return 0;
-}