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

/* \author Bastian Steder */

#ifndef PCL_NARF_KEYPOINT_H_
#define PCL_NARF_KEYPOINT_H_

#include <pcl/pcl_macros.h>
#include <pcl/point_cloud.h>
#include <pcl/point_types.h>
#include <pcl/keypoints/keypoint.h>

namespace pcl {

// Forward declarations
class RangeImage;
class RangeImageBorderExtractor;

class PCL_EXPORTS NarfKeypoint : public Keypoint<PointWithRange, int>
{
  public:
    typedef boost::shared_ptr<NarfKeypoint> Ptr;
    typedef boost::shared_ptr<const NarfKeypoint> ConstPtr;

    // =====TYPEDEFS=====
    typedef Keypoint<PointWithRange, int> BaseClass;
    
    typedef Keypoint<PointWithRange, int>::PointCloudOut PointCloudOut;

    // =====PUBLIC STRUCTS=====
    struct Parameters
    {
      Parameters() : support_size(-1.0f), max_no_of_interest_points(-1), min_distance_between_interest_points(0.25f),
                     optimal_distance_to_high_surface_change(0.25), min_interest_value(0.45f),
                     min_surface_change_score(0.2f), optimal_range_image_patch_size(10),
                     distance_for_additional_points(0.0f), add_points_on_straight_edges(false),
                     do_non_maximum_suppression(true), no_of_polynomial_approximations_per_point(0),
                     max_no_of_threads(1), use_recursive_scale_reduction(false),
                     calculate_sparse_interest_image(true) {}
      
      float support_size;  
      int max_no_of_interest_points;  
      float min_distance_between_interest_points;  
      float optimal_distance_to_high_surface_change;  
      float min_interest_value;  
      float min_surface_change_score;  
      int optimal_range_image_patch_size;  
      // TODO:
      float distance_for_additional_points;  
      bool add_points_on_straight_edges;  
      bool do_non_maximum_suppression;  
      bool no_of_polynomial_approximations_per_point; 
      int max_no_of_threads;  
      bool use_recursive_scale_reduction;  
      bool calculate_sparse_interest_image;  
    };
    
    // =====CONSTRUCTOR & DESTRUCTOR=====
    NarfKeypoint (RangeImageBorderExtractor* range_image_border_extractor=NULL, float support_size=-1.0f);
    virtual ~NarfKeypoint ();
    
    // =====PUBLIC METHODS=====
    void
      clearData ();
    
    void
      setRangeImageBorderExtractor (RangeImageBorderExtractor* range_image_border_extractor);
    
    RangeImageBorderExtractor*
      getRangeImageBorderExtractor ()  { return range_image_border_extractor_; }
    
    void
      setRangeImage (const RangeImage* range_image);
    
    float*
      getInterestImage () { calculateInterestImage(); return interest_image_;}
    
    const ::pcl::PointCloud<InterestPoint>&
      getInterestPoints () { calculateInterestPoints(); return *interest_points_;}
    
    const std::vector<bool>&
      getIsInterestPointImage () { calculateInterestPoints(); return is_interest_point_image_;}
    
    Parameters&
      getParameters () { return parameters_;}
    
    const RangeImage&
      getRangeImage ();
    
    void
      compute (PointCloudOut& output);
    
  protected:
    // =====PROTECTED METHODS=====
    void
      calculateScaleSpace ();
    void
      calculateInterestImage ();
    void
      calculateCompleteInterestImage ();
    void
      calculateSparseInterestImage ();
    void
      calculateInterestPoints ();
    //void
      //blurInterestImage ();
    virtual void
      detectKeypoints (PointCloudOut& output);
    
    // =====PROTECTED MEMBER VARIABLES=====
    using BaseClass::name_;
    RangeImageBorderExtractor* range_image_border_extractor_;
    Parameters parameters_;
    float* interest_image_;
    ::pcl::PointCloud<InterestPoint>* interest_points_;
    std::vector<bool> is_interest_point_image_;
    std::vector<RangeImage*> range_image_scale_space_;
    std::vector<RangeImageBorderExtractor*> border_extractor_scale_space_;
    std::vector<float*> interest_image_scale_space_;
};

inline std::ostream&
  operator << (std::ostream& os, const NarfKeypoint::Parameters& p)
{
  os << PVARC(p.support_size) << PVARC(p.min_distance_between_interest_points)
     << PVARC(p.min_interest_value) << PVARN(p.distance_for_additional_points);
  return (os);
}

}  // end namespace pcl

#endif  //#ifndef PCL_NARF_KEYPOINT_H_