SM's profile - activity

I would like to know how I can apply point cloud RGB data with SURF features. With point cloud, I am subscribing to "camera/depth_registered/points", and in SURF /camera/rgb/image_rect. The objective is to do object recognition using the color and SURF features. So I had 2 approaches in mind (Approach1) Get a clean 3D segmented portion using point cloud and then work with these and 2D FURF features. So, based on the color information and the texture information obtained from point cloud and SURF, I can do object recognition. (Approach2): After the template matching is done nad the bounding box has been constructed, I go back to the template and extract the color information.

Any suggestions on how to go about this will be greatly appreciated. I am having a tough time in integrating point cloud with SURF. Can somebody please let me know how to combine them?

void 
cloud_cb (const sensor_msgs::PointCloud2ConstPtr& input)
{

    pcl::fromROSMsg (*input, *cloud);   
    // ... do data processing


     std::cout << "PointCloud before filtering has: " << cloud->points.size () << " data points." << std::endl; //*

      // Create the filtering object: downsample the dataset using a leaf size of 1cm
      pcl::VoxelGrid<pcl::PointXYZRGB> vg;
      pcl::PointCloud<pcl::PointXYZRGB>::Ptr cloud_filtered (new pcl::PointCloud<pcl::PointXYZRGB>);
  vg.setInputCloud (cloud);
  vg.setLeafSize (0.01f, 0.01f, 0.01f);
  vg.filter (*cloud_filtered);
  std::cout << "PointCloud after filtering has: " << cloud_filtered->points.size ()  << " data points." << std::endl; //*

  // Create the segmentation object for the planar model and set all the parameters

}



int
main (int argc, char** argv)
{
  // Initialize ROS
  ros::init (argc, argv, "euclideanclusters");
  ros::NodeHandle nh;

  // Create a ROS subscriber for the input point cloud
  ros::Subscriber sub = nh.subscribe ("camera/depth_registered/points", 1, cloud_cb);

  // Create a ROS publisher for the output point cloud
  pub = nh.advertise<sensor_msgs::PointCloud2> ("output", 1);

  // Spin
  ros::spin ();
}


SURF

public:
  ImageConverter()
    : it_(nh_)
  {
    // Subscrive to input video feed and publish output video feed
    image_sub_ = it_.subscribe("/camera/rgb/image_rect", 1, 
      &ImageConverter::imageCb, this);
    image_pub_ = it_.advertise("/image_converter/output_video", 1);

   cv::namedWindow(OPENCV_WINDOW1);

  }

  ~ImageConverter()
  {
    cv::destroyWindow(OPENCV_WINDOW1);

  }

  void imageCb(const sensor_msgs::ImageConstPtr& msg)
  {

 cv_bridge::CvImage cv_img;   // training image


 cv_bridge::CvImagePtr cv_ptr_frames;  // kinect frames

 cv::Mat objectMat = imread( "juice2575.png" );

 //  imshow( WINDOW1, object );

 cv_img.header.stamp = ros::Time::now();
 cv_img.header.frame_id=msg->header.frame_id;
 cv_img.encoding = "rgb8";
 cv_img.encoding = sensor_msgs::image_encodings::RGB8;
 cv_img.image = object;


  sensor_msgs::Image im;
  cv_img.toImageMsg(im);  //Conversion of Input image to ROS image



  try
  {
     cv_ptr_frames = cv_bridge::toCvCopy(msg, sensor_msgs::image_encodings::BGR8);
   }
    catch (cv_bridge::Exception& e)
    {
     ROS_ERROR("cv_bridge exception: %s", e.what());
     return;
  }
    cv:: Mat sceneMat;
   sceneMat = cv_ptr_frames;

   // SURF Object detection

        bool objectFound = false;
            float nndrRatio = 0.7f;
        //vector of keypoints  
        vector< cv::KeyPoint > keypointsO;
        vector< cv::KeyPoint > keypointsS;   

        Mat descriptors_object, descriptors_scene;     

       //-- Step 1: Extract keypoints
        SurfFeatureDetector surf(hessianValue);
        surf.detect(sceneMat,keypointsS);
        surf.detect(objectMat,keypointsO);


        //-- Step 2: Calculate descriptors (feature vectors)
      SurfDescriptorExtractor extractor;
      extractor.compute( sceneMat, keypointsS, descriptors_scene );
      extractor.compute( objectMat, keypointso, descriptors_object );

      //-- Step 3: Matching descriptor vectors using FLANN matcher
      FlannBasedMatcher matcher; 
      descriptors_scene.size(), keypointsO.size(), keypointsS.size());
      std::vector< vector< DMatch ...

I am trying to implement SURF. From the comment mentioned in Answer (sorry for not being able to publish links as I am not allowed) : //answers.ros.org/question/61462/how-to-publish-opencv-mat-image-in-ros-fuerte/, I have problem in understanding the lines mentioned in the command cv_img.header.frame_id = "your_camera_frame";

My Questions are (Q1) What should I use in cv_img.header.frame_id
(Q2) what is the substitute of VideoCapture in ROS so that I can capture the video frames and work with this code? thanx in advance

> #include <ros/ros.h>
> #include <image_transport/image_transport.h>
> #include <cv_bridge/cv_bridge.h>
> #include <sensor_msgs/image_encodings.h>
> #include <opencv2/imgproc/imgproc.hpp>
> #include <opencv2/highgui/highgui.hpp>
> #include <opencv2/nonfree/features2d.hpp>
> #include "opencv2/calib3d/calib3d.hpp"
> 
> static const std::string OPENCV_WINDOW
> = "Image window";
> 
> class ImageConverter {  
> ros::NodeHandle nh_;  
> image_transport::ImageTransport it_;  
> image_transport::Subscriber
> image_sub_;  
> image_transport::Publisher image_pub_;
> public:   ImageConverter()
>     : it_(nh_)   {
>     // Subscrive to input video feed and publish output video feed
>     image_sub_ = it_.subscribe("/camera/rgb/image_rect",
> 1, 
>       &ImageConverter::imageCb, this);
>     image_pub_ = it_.advertise("/image_converter/output_video",
> 1);
> 
>     cv::namedWindow(OPENCV_WINDOW);   }
> 
>   ~ImageConverter()   {
>     cv::destroyWindow(OPENCV_WINDOW);   }
> 
>   void imageCb(const
> sensor_msgs::ImageConstPtr& msg)
>             Mat object = imread( "book.png", CV_LOAD_IMAGE_GRAYSCALE );
> **cv_bridge::CvImage cv_img;   
> cv_img.header.stamp =
> ros::Time::now();   
> cv_img.header.frame_id=
> 
> cv_img.image = img_topub;** 
> 
> img_pub_.publish(cv_img.toImageMsg());
> 
>  //Detect the keypoints using SURF
> Detector
>     int minHessian = 500;
> 
>     SurfFeatureDetector detector( minHessian );
>     std::vector<KeyPoint> kp_object;
> 
>     detector.detect( object, kp_object );
> 
>     //Calculate descriptors (feature vectors)
>     SurfDescriptorExtractor extractor;
>     Mat des_object;
> 
>     extractor.compute( object, kp_object, des_object );
> 
>     FlannBasedMatcher matcher;
> 
>     VideoCapture cap(0);
> 
>     namedWindow("Good Matches");
> 
>     std::vector<Point2f> obj_corners(4);
> 
>     //Get the corners from the object
>     obj_corners[0] = cvPoint(0,0);
>     obj_corners[1] = cvPoint( object.cols, 0 );
>     obj_corners[2] = cvPoint( object.cols, object.rows );
>     obj_corners[3] = cvPoint( 0, object.rows );
> 
>     
>     int framecount = 0;
>     while (key != 27)   {
>        Mat frame;
>         cap >> frame;
> 
>         Mat des_image, img_matches;
>         std::vector<KeyPoint> kp_image;
>         std::vector<vector<DMatch > > matches;
>         std::vector<DMatch > good_matches;
>         std::vector<Point2f> obj;
>         std::vector<Point2f> scene;
>         std::vector<Point2f> scene_corners(4);
>         Mat H;
>              
> 
>         detector.detect( image, kp_image );
>         extractor.compute( image, kp_image, des_image ); 
> matcher.knnMatch(des_object,
> des_image, matches, 2);
> 
>         for(int i = 0; i < min(des_image.rows-1,(int)
> matches.size()); i++) //THIS LOOP IS
> SENSITIVE TO SEGFAULTS
>         {
>             if((matches[i][0].distance < 0.6*(matches[i][1].distance)) &&
> ((int) matches[i].size()<=2 && (int)
> matches[i].size()>0))
>             {
>                 good_matches.push_back(matches[i][0]);
>             }
>         }
> 
>         //Draw only "good" matches
>         drawMatches( object, kp_object, image, kp_image,
> good_matches, img_matches,
> Scalar::all(-1), Scalar::all(-1),
> vector<char>(),
> DrawMatchesFlags::NOT_DRAW_SINGLE_POINTS
> );
> 
>         if (good_matches.size() >= 4)
>         {
>             for( int i = 0; i < good_matches.size(); i++ )
>             {
>                 //Get the keypoints from the good matches
>                 obj.push_back( kp_object[ good_matches[i].queryIdx
> ].pt );
>                 scene.push_back( kp_image[ good_matches[i].trainIdx
> ].pt );
>             }
> 
>             H = findHomography( obj, scene, CV_RANSAC );
> 
>             perspectiveTransform( obj_corners, scene_corners, H);
> 
>             //Draw lines between the corners (the mapped object in the
> scene image )
>             line( img_matches, scene_corners[0] + Point2f(
> object.cols, 0), scene_corners[1] +
> Point2f( object.cols, 0), Scalar(0,
> 255, 0), 4 );
>             line( img_matches, scene_corners[1] + Point2f(
> object.cols, 0), scene_corners[2] +
> Point2f( object.cols, 0), Scalar( 0,
> 255, 0), 4 );
>             line( img_matches, scene_corners ...