object_recognition_helper.h

Go to the documentation of this file.

/* \author Bastian Steder */

#ifndef PCL_OBJECT_RECOGNITION_HELPER_H
#define PCL_OBJECT_RECOGNITION_HELPER_H

#include <vector>
#include <iostream>
//#include <pcl/io/openni_grabber.h>
#include "pcl/common/angles.h"
#include "pcl/io/pcd_io.h"
#include "object_model_list.h"
#include "pcl/range_image/range_image_planar.h"
#include "pcl/features/range_image_border_extractor.h"
#include "pcl/keypoints/narf_keypoint.h"
#include "pcl/common/poses_from_matches.h"
#include <narf_recognition/false_positives_filter.h>

namespace pcl {

class ObjectRecognitionHelper
{
  public:
    //-----TYPEDEFS-----
    

    //-----CLASSES/STRUCTS-----
    struct Parameters
    {
      Parameters() : verbose(true), max_no_of_threads(1), angular_resolution(deg2rad(0.5f)),
                     coordinate_frame(RangeImage::CAMERA_FRAME), set_unseen_to_max_range(false),
                     single_view_model(false), no_of_model_views(10),
                     no_of_surface_validation_points(50), no_of_border_validation_points(25),
                     feature_descriptor_size(36), use_rotation_invariance(false),
                     support_size(0.3), noise_level(0.05), max_descriptor_distance(0.07), use_kdtree(false),
                     max_validation_point_error_factor(0.15),
                     icp_max_distance_start_factor(0.15), icp_max_distance_end_factor(0.05),
                     view_sampling_first_layer(0), view_sampling_last_layer(0),
                     sample_views_3d(false), view_sampling_3D_resolution(deg2rad(50.0f))
      {}
      bool verbose;
      int max_no_of_threads;
      float angular_resolution;
      RangeImage::CoordinateFrame coordinate_frame;
      bool set_unseen_to_max_range;
      bool single_view_model;
      int no_of_model_views;
      int no_of_surface_validation_points;
      int no_of_border_validation_points;
      int feature_descriptor_size;
      bool use_rotation_invariance;
      float support_size;
      float noise_level;
      float max_descriptor_distance;
      bool use_kdtree;
      float max_validation_point_error_factor; // Factor regarding model radius
      float icp_max_distance_start_factor;     // Factor regarding model radius
      float icp_max_distance_end_factor;       // Factor regarding model radius
      int view_sampling_first_layer;
      int view_sampling_last_layer;
      bool sample_views_3d;
      float view_sampling_3D_resolution;
    };
    struct Timings
    {
      double scene_range_image_creation;
      double scene_interest_point_extraction;
      double scene_feature_extraction;
      double feature_matching;
      double initial_pose_estimation;
      double false_positives_filtering;
    };
    struct IntermediateElements {
      IntermediateElements() : spherical_scene_range_image_ptr(new RangeImage),
                               planar_scene_range_image_ptr(new RangeImagePlanar),
                               scene_range_image_ptr(spherical_scene_range_image_ptr)
      {
        interest_point_detector_model.setRangeImageBorderExtractor(&border_extractor_model);
        interest_point_detector_scene.setRangeImageBorderExtractor(&border_extractor_scene);
      }
      
      ObjectModelList object_models;
      std::vector<Narf*> database_features;
      std::vector<ObjectModelList::FeatureSource> database_feature_sources;
      KdTreeFLANN<Narf*> database_features_kdtree;
      RangeImageBorderExtractor border_extractor_model;
      NarfKeypoint interest_point_detector_model;
      boost::shared_ptr<RangeImage> spherical_scene_range_image_ptr;
      boost::shared_ptr<RangeImagePlanar> planar_scene_range_image_ptr;
      boost::shared_ptr<RangeImage> scene_range_image_ptr;
      Eigen::Affine3f transformation_into_original_coordinate_frame;
      RangeImageBorderExtractor border_extractor_scene;
      NarfKeypoint interest_point_detector_scene;
      std::vector<Narf*> scene_features;
      std::vector<std::vector<PointCorrespondences6DVector > > feature_matches;
      std::vector<PosesFromMatches::PoseEstimatesVector> pose_estimates_per_model;
    };
    
    //-----CONSTRUCTOR&DESTRUCTOR-----
    ObjectRecognitionHelper();
    ~ObjectRecognitionHelper();
    
    //-----METHODS-----
    bool
      addObjectModelsFromPcdFiles(std::vector<std::string>& file_names);
    
    bool
    extractModelFeatures();
    
    bool
      createRangeImageFromPcdFile(const std::string& file_name);

//    //! Create the range image given a depth map from an openni device
//    bool
//      createRangeImageFromOpenniDepthImage(const openni_wrapper::DepthImage& depth_map);
    
    bool
      createRangeImageFromPointCloud(const PointCloud<PointXYZ>& point_cloud,
                                     const PointCloud<PointWithViewpoint>* far_ranges=NULL);
    
    bool
      extractSceneFeatures();
    
    void
      extractPoseEstimates();
    
    std::vector<PosesFromMatches::PoseEstimatesVector>&
      filterFalsePositives();

    void
      printTimings() const;
    
    //-----GETTER-----
    Parameters&
      getParameters() { return parameters_;}

    Timings&
      getTimings () { return timings_;}
    
    IntermediateElements&
      getIntermediateElements () { return intermediate_elements_;}
    
    FalsePositivesFilter&
      getFalsePositivesFilter () { return false_positives_filter_;}

    //-----SETTER-----
    
  protected:
    //-----PROTECTED METHODS-----
    void
      clearSceneFeatures();

    void
      clearObjectModels();
    
    void
      clearModelFeatures();
    
    //-----PROTECTED VARIABLES-----
    Parameters parameters_;
    Timings timings_;
    IntermediateElements intermediate_elements_;
    FalsePositivesFilter false_positives_filter_;
    
  //public:
    //EIGEN_MAKE_ALIGNED_OPERATOR_NEW
};

} // namespace end

#endif