gaussian.h

Go to the documentation of this file.

/*
 * Software License Agreement (BSD License)
 *
 *  Point Cloud Library (PCL) - www.pointclouds.org
 *  Copyright (c) 2010-2011, 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 the copyright holder(s) 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$
 *
 */

#ifndef PCL_GAUSSIAN_KERNEL
#define PCL_GAUSSIAN_KERNEL

#include <sstream>
#include <pcl/common/eigen.h>
#include <pcl/point_cloud.h>
#include <boost/function.hpp>

namespace pcl
{
  class PCL_EXPORTS GaussianKernel
  {
    public:

      GaussianKernel () {}

      static const unsigned MAX_KERNEL_WIDTH = 71;
      void
      compute (float sigma, 
               Eigen::VectorXf &kernel,
               unsigned kernel_width = MAX_KERNEL_WIDTH) const;

      void
      compute (float sigma, 
               Eigen::VectorXf &kernel, 
               Eigen::VectorXf &derivative, 
               unsigned kernel_width = MAX_KERNEL_WIDTH) const;

      void
      convolveRows (const pcl::PointCloud<float> &input,
                    const Eigen::VectorXf &kernel,
                    pcl::PointCloud<float> &output) const;

     template <typename PointT> void
     convolveRows (const pcl::PointCloud<PointT> &input,
                   boost::function <float (const PointT& p)> field_accessor,
                   const Eigen::VectorXf &kernel,
                   pcl::PointCloud<float> &output) const;

      void
      convolveCols (const pcl::PointCloud<float> &input,
                    const Eigen::VectorXf &kernel,
                    pcl::PointCloud<float> &output) const;

      template <typename PointT> void
      convolveCols (const pcl::PointCloud<PointT> &input,
                    boost::function <float (const PointT& p)> field_accessor,
                    const Eigen::VectorXf &kernel,
                    pcl::PointCloud<float> &output) const;

      inline void
      convolve (const pcl::PointCloud<float> &input,
                const Eigen::VectorXf &horiz_kernel,
                const Eigen::VectorXf &vert_kernel,
                pcl::PointCloud<float> &output) const
      {
        std::cout << ">>> convolve cpp" << std::endl;
        pcl::PointCloud<float> tmp (input.width, input.height) ;
        convolveRows (input, horiz_kernel, tmp);        
        convolveCols (tmp, vert_kernel, output);
        std::cout << "<<< convolve cpp" << std::endl;
      }

      template <typename PointT> inline void
      convolve (const pcl::PointCloud<PointT> &input,
                boost::function <float (const PointT& p)> field_accessor,
                const Eigen::VectorXf &horiz_kernel,
                const Eigen::VectorXf &vert_kernel,
                pcl::PointCloud<float> &output) const
      {
        std::cout << ">>> convolve hpp" << std::endl;
        pcl::PointCloud<float> tmp (input.width, input.height);
        convolveRows<PointT>(input, field_accessor, horiz_kernel, tmp);
        convolveCols(tmp, vert_kernel, output);
        std::cout << "<<< convolve hpp" << std::endl;
      }
      
      inline void
      computeGradients (const pcl::PointCloud<float> &input,
                        const Eigen::VectorXf &gaussian_kernel,
                        const Eigen::VectorXf &gaussian_kernel_derivative,
                        pcl::PointCloud<float> &grad_x,
                        pcl::PointCloud<float> &grad_y) const
      {
        convolve (input, gaussian_kernel_derivative, gaussian_kernel, grad_x);
        convolve (input, gaussian_kernel, gaussian_kernel_derivative, grad_y);
      }

      template <typename PointT> inline void
      computeGradients (const pcl::PointCloud<PointT> &input,
                        boost::function <float (const PointT& p)> field_accessor,
                        const Eigen::VectorXf &gaussian_kernel,
                        const Eigen::VectorXf &gaussian_kernel_derivative,
                        pcl::PointCloud<float> &grad_x,
                        pcl::PointCloud<float> &grad_y) const
      {
        convolve<PointT> (input, field_accessor, gaussian_kernel_derivative, gaussian_kernel, grad_x);
        convolve<PointT> (input, field_accessor, gaussian_kernel, gaussian_kernel_derivative, grad_y);
      }
      
      inline void
      smooth (const pcl::PointCloud<float> &input,
              const Eigen::VectorXf &gaussian_kernel,
              pcl::PointCloud<float> &output) const
      {
        convolve (input, gaussian_kernel, gaussian_kernel, output);
      }

      template <typename PointT> inline void
      smooth (const pcl::PointCloud<PointT> &input,
              boost::function <float (const PointT& p)> field_accessor,
              const Eigen::VectorXf &gaussian_kernel,
              pcl::PointCloud<float> &output) const
      {
        convolve<PointT> (input, field_accessor, gaussian_kernel, gaussian_kernel, output);
      }
  };
}

#include <pcl/common/impl/gaussian.hpp>

#endif // PCL_GAUSSIAN_KERNEL