iss_3d.h

Go to the documentation of this file.

/*
 * 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.
 *
 */

#ifndef PCL_ISS_3D_H_
#define PCL_ISS_3D_H_

#include <pcl/keypoints/keypoint.h>

namespace pcl
{
  template <typename PointInT, typename PointOutT, typename NormalT = pcl::Normal>
  class ISSKeypoint3D : public Keypoint<PointInT, PointOutT>
  {
    public:
      typedef boost::shared_ptr<ISSKeypoint3D<PointInT, PointOutT, NormalT> > Ptr;
      typedef boost::shared_ptr<const ISSKeypoint3D<PointInT, PointOutT, NormalT> > ConstPtr;

      typedef typename Keypoint<PointInT, PointOutT>::PointCloudIn PointCloudIn;
      typedef typename Keypoint<PointInT, PointOutT>::PointCloudOut PointCloudOut;

      typedef typename pcl::PointCloud<NormalT> PointCloudN;
      typedef typename PointCloudN::Ptr PointCloudNPtr;
      typedef typename PointCloudN::ConstPtr PointCloudNConstPtr;

      typedef typename pcl::octree::OctreePointCloudSearch<PointInT> OctreeSearchIn;
      typedef typename OctreeSearchIn::Ptr OctreeSearchInPtr;

      using Keypoint<PointInT, PointOutT>::name_;
      using Keypoint<PointInT, PointOutT>::input_;
      using Keypoint<PointInT, PointOutT>::surface_;
      using Keypoint<PointInT, PointOutT>::tree_;
      using Keypoint<PointInT, PointOutT>::search_radius_;
      using Keypoint<PointInT, PointOutT>::search_parameter_;

      ISSKeypoint3D (double salient_radius = 0.0001)
      : salient_radius_ (salient_radius)
      , non_max_radius_ (0.0)
      , normal_radius_ (0.0)
      , border_radius_ (0.0)
      , gamma_21_ (0.975)
      , gamma_32_ (0.975)
      , third_eigen_value_ (0)
      , edge_points_ (0)
      , min_neighbors_ (5)
      , normals_ (new pcl::PointCloud<NormalT>)
      , angle_threshold_ (static_cast<float> (M_PI) / 2.0f)
      , threads_ (0)
      {
        name_ = "ISSKeypoint3D";
        search_radius_ = salient_radius_;
      }

      void
      setSalientRadius (double salient_radius);

      void
      setNonMaxRadius (double non_max_radius);

      void
      setNormalRadius (double normal_radius);

      void
      setBorderRadius (double border_radius);

      void
      setThreshold21 (double gamma_21);

      void
      setThreshold32 (double gamma_32);

      void
      setMinNeighbors (int min_neighbors);

      void
      setNormals (const PointCloudNConstPtr &normals);

      inline void
      setAngleThreshold (float angle)
      {
        angle_threshold_ = angle;
      }

      inline void
      setNumberOfThreads (unsigned int nr_threads = 0) { threads_ = nr_threads; }

    protected:

      bool*
      getBoundaryPoints (PointCloudIn &input, double border_radius, float angle_threshold);

      void
      getScatterMatrix (const int &current_index, Eigen::Matrix3d &cov_m);

      bool
      initCompute ();

      void
      detectKeypoints (PointCloudOut &output);


      double salient_radius_;

      double non_max_radius_;

      double normal_radius_;

      double border_radius_;

      double gamma_21_;

      double gamma_32_;

      double *third_eigen_value_;

      bool *edge_points_;

      int min_neighbors_;

      PointCloudNConstPtr normals_;

      float angle_threshold_;

      unsigned int threads_;

  };

}

#include <pcl/keypoints/impl/iss_3d.hpp>

#endif /* PCL_ISS_3D_H_ */