hand_search.h

Go to the documentation of this file.

/*
 * Software License Agreement (BSD License)
 *
 *  Copyright (c) 2015, Andreas ten Pas
 *  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.
 *
 *  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 HAND_SEARCH_H
#define HAND_SEARCH_H


#include <Eigen/Dense>

#include <pcl/filters/random_sample.h>
#include <pcl/kdtree/kdtree_flann.h>
#include <pcl/point_cloud.h>

#include <agile_grasp/finger_hand.h>
#include <agile_grasp/grasp_hypothesis.h>
#include <agile_grasp/plot.h>
#include <agile_grasp/quadric.h>
#include <agile_grasp/rotating_hand.h>


typedef pcl::PointCloud<pcl::PointXYZRGBA> PointCloud;


class HandSearch
{
  public:
    
    HandSearch(double finger_width, double hand_outer_diameter, 
      double hand_depth, double hand_height, double init_bite, int num_threads, 
      int num_samples, const Eigen::Matrix4d& cam_tf_left, bool plots_hands) : finger_width_(finger_width), 
      hand_outer_diameter_(hand_outer_diameter), hand_depth_(hand_depth), 
      hand_height_(hand_height), init_bite_(init_bite), 
      num_threads_(num_threads), num_samples_(num_samples), cam_tf_left_(cam_tf_left), 
      plots_hands_(plots_hands), plots_samples_(false), 
      plots_local_axes_(false), uses_determinstic_normal_estimation_(false), 
      nn_radius_taubin_(0.03), nn_radius_hands_(0.08) { }
    
    std::vector<GraspHypothesis> findHands(const PointCloud::Ptr cloud, 
      const Eigen::VectorXi& pts_cam_source, const std::vector<int>& indices,
      const PointCloud::Ptr cloud_plot, bool calculates_antipodal, 
      bool uses_clustering);
      
  
  private:
    
    std::vector<Quadric> findQuadrics(const PointCloud::Ptr cloud, const Eigen::VectorXi& pts_cam_source,
                        const pcl::KdTreeFLANN<pcl::PointXYZRGBA>& kdtree, const std::vector<int>& indices);
                
    std::vector<GraspHypothesis> findHands(const PointCloud::Ptr cloud, const Eigen::VectorXi& pts_cam_source,
                        const std::vector<Quadric>& quadric_list, const Eigen::VectorXi& hands_cam_source, 
      const pcl::KdTreeFLANN<pcl::PointXYZRGBA>& kdtree);
    
    Eigen::Matrix4d cam_tf_left_, cam_tf_right_; 
    
    double finger_width_;
    double hand_outer_diameter_; 
    double hand_depth_; 
    double hand_height_; 
    double init_bite_; 
    int num_threads_; 
    int num_samples_; 
    
    Eigen::Matrix3Xd cloud_normals_; 
    Plot plot_; 
    
    bool uses_determinstic_normal_estimation_; 
    bool tolerant_antipodal_; 
    
    bool plots_samples_; 
    bool plots_camera_sources_; 
    bool plots_local_axes_; 
    bool plots_hands_; 
    
    double nn_radius_taubin_; 
    double nn_radius_hands_; 
};

#endif /* HAND_SEARCH_H */