crop_hull.h

Go to the documentation of this file.

 /*
  * Software License Agreement (BSD License)
  *
  *  Point Cloud Library (PCL) - www.pointclouds.org
  *  Copyright (c) 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.
  *
  */

#ifndef PCL_FILTERS_CROP_HULL_H_
#define PCL_FILTERS_CROP_HULL_H_

#include <pcl/point_types.h>
#include <pcl/Vertices.h>
#include <pcl/filters/filter_indices.h>

namespace pcl
{
  template<typename PointT>
  class CropHull: public FilterIndices<PointT>
  {
    using Filter<PointT>::filter_name_;
    using Filter<PointT>::indices_;
    using Filter<PointT>::input_;
    
    typedef typename Filter<PointT>::PointCloud PointCloud;
    typedef typename PointCloud::Ptr PointCloudPtr;
    typedef typename PointCloud::ConstPtr PointCloudConstPtr;

    public:

      typedef boost::shared_ptr< CropHull<PointT> > Ptr;
      typedef boost::shared_ptr< const CropHull<PointT> > ConstPtr;

      CropHull () :
        hull_polygons_(),
        hull_cloud_(),
        dim_(3),
        crop_outside_(true)
      {
        filter_name_ = "CropHull";
      }

      inline void
      setHullIndices (const std::vector<Vertices>& polygons)
      {
        hull_polygons_ = polygons;
      }

      std::vector<Vertices>
      getHullIndices () const
      {
        return (hull_polygons_);
      }
      
      inline void
      setHullCloud (PointCloudPtr points)
      {
        hull_cloud_ = points;
      }

      PointCloudPtr
      getHullCloud () const
      {
        return (hull_cloud_);
      }
    
      inline void
      setDim (int dim)
      {
        dim_ = dim;
      }
      
      inline void
      setCropOutside(bool crop_outside)
      {
        crop_outside_ = crop_outside;
      }

    protected:
      void
      applyFilter (PointCloud &output);

      void        
      applyFilter (std::vector<int> &indices);

    private:  
      Eigen::Vector3f
      getHullCloudRange ();
      
      template<unsigned PlaneDim1, unsigned PlaneDim2> void
      applyFilter2D (PointCloud &output); 

      template<unsigned PlaneDim1, unsigned PlaneDim2> void
      applyFilter2D (std::vector<int> &indices);

      void
      applyFilter3D (PointCloud &output);

      void
      applyFilter3D (std::vector<int> &indices);

      template<unsigned PlaneDim1, unsigned PlaneDim2> inline static bool
      isPointIn2DPolyWithVertIndices (const PointT& point,
                                      const Vertices& verts,
                                      const PointCloud& cloud);

      inline static bool
      rayTriangleIntersect (const PointT& point,
                            const Eigen::Vector3f& ray,
                            const Vertices& verts,
                            const PointCloud& cloud);


      std::vector<pcl::Vertices> hull_polygons_;

      PointCloudPtr hull_cloud_;

      int dim_;

      bool crop_outside_;
  };

} // namespace pcl

#ifdef PCL_NO_PRECOMPILE
#include <pcl/filters/impl/crop_hull.hpp>
#endif

#endif // ifndef PCL_FILTERS_CROP_HULL_H_