$search

vfh_recognition.cpp

Go to the documentation of this file.

#include "vfh_recognizer_db/vfh_recognition.h"
#include <pcl/filters/statistical_outlier_removal.h>
#include <pcl/filters/radius_outlier_removal.h>

namespace vfh_recognizer_db
{
  template<template<class > class Distance>
  bool
  VFHRecognizerDB<Distance>::getPointCloudFromId (pcl::PointCloud<pcl::PointNormal> & cloud, std::string vfh_id)
  {
    if (cache_enabled_)
    {
      std::map<int, pcl::PointCloud<pcl::PointNormal> >::iterator it = view_cache_.find (atoi (vfh_id.c_str ()));

      if (it != view_cache_.end ())
      {
        cloud = it->second;
        return (true);
      }
    }

    boost::shared_ptr<household_objects_database::DatabaseView> view;

    if (!database->getViewFromVFHId (atoi (vfh_id.c_str ()), view))
      return (false);

    boost::shared_array<uint8_t> bufferRead (new uint8_t[view->view_point_cloud_data_.data ().size ()]);
    memcpy (&bufferRead[0], &(view->view_point_cloud_data_.data ()[0]), view->view_point_cloud_data_.data ().size ());
    ser::IStream streamIn (bufferRead.get (), view->view_point_cloud_data_.data ().size ());
    ser::deserialize (streamIn, cloud);

    return (true);
  }

  template<template<class > class Distance>
  bool
  VFHRecognizerDB<Distance>::getVFHHistogramFromVFHId (pcl::PointCloud<pcl::VFHSignature308> & vfh_descriptor,
                                                       std::string vfh_id)
  {

    std::map<int, pcl::PointCloud<pcl::VFHSignature308> >::iterator it = vfh_cache_.find (atoi (vfh_id.c_str ()));

    if (it != vfh_cache_.end ())
    {
      vfh_descriptor = it->second;
      return (true);
    }

    std::vector<boost::shared_ptr<household_objects_database::DatabaseVFH> > vfhs;
    std::stringstream where;
    where << "vfh_id =" << vfh_id;
    std::string where_clause (where.str ());
    if (!database->getList (vfhs, where_clause))
    {
      return false;
    }

    if (!database->loadFromDatabase (&vfhs[0]->vfh_descriptor_))
    {
      ROS_ERROR ("Failed to load VFH descriptor with id %s", vfh_id.c_str ());
    }

    boost::shared_array<uint8_t> bufferRead (new uint8_t[vfhs[0]->vfh_descriptor_.data ().size ()]);
    memcpy (&bufferRead[0], &(vfhs[0]->vfh_descriptor_.data ()[0]), vfhs[0]->vfh_descriptor_.data ().size ());
    ser::IStream streamIn (bufferRead.get (), vfhs[0]->vfh_descriptor_.data ().size ());
    ser::deserialize (streamIn, vfh_descriptor);

    return true;
  }

  template<template<class > class Distance>
  bool
  VFHRecognizerDB<Distance>::getVFHCentroidFromVFHid (std::vector<float> & centroid, std::string id)
  {

    std::map<int, std::vector<float> >::iterator it = cluster_centroids_cache_.find (atoi (id.c_str ()));

    if (it != cluster_centroids_cache_.end ())
    {
      centroid = it->second;
      return (true);
    }

    std::vector<boost::shared_ptr<household_objects_database::DatabaseVFH> > vfhs;
    std::stringstream where;
    where << "vfh_id =" << id;
    std::string where_clause (where.str ());
    if (!database->getList (vfhs, where_clause))
    {
      return false;
    }

    centroid = vfhs[0]->centroid_.data ();
    return true;
  }

  template<template<class > class Distance>
  bool
  VFHRecognizerDB<Distance>::getViewCentroidFromVFHid (std::vector<float> & centroid, std::string id)
  {
    boost::shared_ptr<household_objects_database::DatabaseView> view;

    if (!database->getViewFromVFHId (atoi (id.c_str ()), view))
      return (false);

    centroid = view->centroid_.data ();
    return true;
  }

  template<template<class > class Distance>
  bool
  VFHRecognizerDB<Distance>::getVFHRollOrientationFromId (
                                                          pcl::PointCloud<pcl::VFHSignature308> & vfh_orientation_signature,
                                                          std::string vfh_id)
  {
    if (cache_enabled_)
    {
      std::map<int, pcl::PointCloud<pcl::VFHSignature308> >::iterator it = roll_cache_.find (atoi (vfh_id.c_str ()));

      if (it != roll_cache_.end ())
      {
        vfh_orientation_signature = it->second;
        return (true);
      }
    }

    boost::shared_ptr<household_objects_database::DatabaseVFHOrientation> roll_histogram;
    if (!database->getOrientationRollFromVFHId (atoi (vfh_id.c_str ()), roll_histogram))
      return (false);

    boost::shared_array<uint8_t> bufferRead (new uint8_t[roll_histogram->vfh_orientation_descriptor_.data ().size ()]);
    memcpy (&bufferRead[0], &(roll_histogram->vfh_orientation_descriptor_.data ()[0]),
            roll_histogram->vfh_orientation_descriptor_.data ().size ());
    ser::IStream streamIn (bufferRead.get (), roll_histogram->vfh_orientation_descriptor_.data ().size ());
    ser::deserialize (streamIn, vfh_orientation_signature);

    return (true);
  }

  template<template<class > class Distance>
  bool
  VFHRecognizerDB<Distance>::getVFHRollOrientationFromIdThroughView (
                                                                     pcl::PointCloud<pcl::VFHSignature308> & vfh_orientation_signature,
                                                                     std::string vfh_id)
  {
    if (cache_enabled_)
    {
      std::map<int, pcl::PointCloud<pcl::VFHSignature308> >::iterator it = roll_cache_.find (atoi (vfh_id.c_str ()));

      if (it != roll_cache_.end ())
      {
        vfh_orientation_signature = it->second;
        return (true);
      }
    }

    boost::shared_ptr<household_objects_database::DatabaseVFHOrientation> roll_histogram;
    if (!database->getOrientationRollFromVFHThroughViewId (atoi (vfh_id.c_str ()), roll_histogram))
      return (false);

    boost::shared_array<uint8_t> bufferRead (new uint8_t[roll_histogram->vfh_orientation_descriptor_.data ().size ()]);
    memcpy (&bufferRead[0], &(roll_histogram->vfh_orientation_descriptor_.data ()[0]),
            roll_histogram->vfh_orientation_descriptor_.data ().size ());
    ser::IStream streamIn (bufferRead.get (), roll_histogram->vfh_orientation_descriptor_.data ().size ());
    ser::deserialize (streamIn, vfh_orientation_signature);

    return (true);
  }

  template<template<class > class Distance>
  int
  VFHRecognizerDB<Distance>::getVFHId (std::string id)
  {
    return atoi (id.c_str ());
  }
  ;

  template<template<class > class Distance>
  bool
  VFHRecognizerDB<Distance>::getPoseFromId (std::string id, geometry_msgs::Pose & pose)
  {

    std::map<int, geometry_msgs::Pose>::iterator it = pose_cache_.find (atoi (id.c_str ()));

    if (it != pose_cache_.end ())
    {
      pose = it->second;
      return (true);
    }

    boost::shared_ptr<household_objects_database::DatabaseView> view;
    if (!database->getViewFromVFHIdNoData (atoi (id.c_str ()), view))
      return (false);

    pose = view->view_transform_.data ().pose_;
    return true;
  }

  template<template<class > class Distance>
  std::string
  VFHRecognizerDB<Distance>::getModelId (std::string id)
  {

    std::map<int, std::string>::iterator it = scaled_model_id_cache_.find (atoi (id.c_str ()));

    if (it != scaled_model_id_cache_.end ())
    {
      return it->second;
    }

    boost::shared_ptr<household_objects_database::DatabaseView> view;
    if (!database->getViewFromVFHIdNoData (atoi (id.c_str ()), view))
      return (false);

    std::stringstream model_id;
    model_id << view->scaled_model_id_.data ();
    return model_id.str ();
  }

  template<template<class > class Distance>
  int
  VFHRecognizerDB<Distance>::initializeFromViews (std::vector<boost::shared_ptr<
      household_objects_database::DatabaseView> > & views)
  {
    int minid = buildTreeFromViews (views);
    index_ = new flann::Index<DistT> (data_, flann::LinearIndexParams ());
    index_->buildIndex ();
    return minid;
  }

  template<template<class > class Distance>
  bool
  VFHRecognizerDB<Distance>::initialize (bool useDB, bf::path dpath, int linear, int iteration, bool no_save)
  {

    //cache from DB poses, ids and centroids...
    household_objects_database::ObjectsDatabase database_init ("wgs36.willowgarage.com", "5432", "willow", "willow",
                                                               "household_objects");

    if (!database_init.isConnected ())
    {
      std::cerr << "Database failed to connect \n";
      return false;
    }
    std::cerr << "Database connected successfully \n";

    //Read VFH descriptor and build tree...
    std::vector<boost::shared_ptr<household_objects_database::DatabaseVFH> > vfhs;
    std::stringstream where;
    where << "iteration = " << iteration;
    std::string where_clause (where.str ());
    database_init.getList (vfhs, where_clause);
    std::cerr << "Number of vfhs:" << vfhs.size () << "\n";

    for (size_t i = 0; i < vfhs.size (); i++)
    {
      cluster_centroids_cache_[vfhs[i]->vfh_id_.data ()] = vfhs[i]->centroid_.data ();
      std::cout << "Loading cluster" << i << std::endl;

      boost::shared_ptr<household_objects_database::DatabaseView> view;
      if (!database_init.getViewFromVFHIdNoData (vfhs[i]->vfh_id_.data (), view))
        ROS_WARN ("No view returned");

      pose_cache_[vfhs[i]->vfh_id_.data ()] = view->view_transform_.data ().pose_;

      std::stringstream model_id;
      model_id << view->scaled_model_id_.data ();
      scaled_model_id_cache_[vfhs[i]->vfh_id_.data ()] = model_id.str ();

      //cache also the VFH descriptor
      if (!database_init.loadFromDatabase (&vfhs[i]->vfh_descriptor_))
      {
        ROS_ERROR ("Failed to load VFH descriptor");
      }

      pcl::PointCloud < pcl::VFHSignature308 > vfh_descriptor;
      boost::shared_array<uint8_t> bufferRead (new uint8_t[vfhs[i]->vfh_descriptor_.data ().size ()]);
      memcpy (&bufferRead[0], &(vfhs[i]->vfh_descriptor_.data ()[0]), vfhs[i]->vfh_descriptor_.data ().size ());
      ser::IStream streamIn (bufferRead.get (), vfhs[i]->vfh_descriptor_.data ().size ());
      ser::deserialize (streamIn, vfh_descriptor);
      vfh_cache_[vfhs[i]->vfh_id_.data ()] = vfh_descriptor;

    }

    bf::path training_data_h5_file_name = dpath / "training_data.h5";
    bf::path training_data_list_file_name = dpath / "training_data.list";
    bf::path index_filename = dpath / "kdtree.idx";

    if (useDB || !boost::filesystem::exists (training_data_h5_file_name)
        || !boost::filesystem::exists (training_data_list_file_name) || !boost::filesystem::exists (index_filename))
    {
      //read training data from DB and build kdtree
      buildTreeFromDB (iteration);
      std::cout << "Tree build from DB:" << models_.size () << " " << data_.rows << std::endl;
      index_ = new flann::Index<DistT> (data_, flann::LinearIndexParams ());
      index_->buildIndex ();

      if (useDB && !no_save)
      {
        //files could exists, try to delete them
        if (boost::filesystem::exists (training_data_h5_file_name))
          boost::filesystem::remove (training_data_h5_file_name);

        if (boost::filesystem::exists (training_data_list_file_name))
          boost::filesystem::remove (training_data_list_file_name);

        if (boost::filesystem::exists (index_filename))
          boost::filesystem::remove (index_filename);
      }

      if (!boost::filesystem::exists (dpath))
      {
        ROS_WARN ("%s does not exist. Not able to save training_data!", dpath.string ().c_str ());
      }
      else
      {
        if (no_save)
        {
          ROS_WARN ("Data wont be saved, user asked for that...");
        }
        else
        {
          //SAVE the kdtree + training_list to the database
          flann::save_to_file (data_, training_data_h5_file_name.string ().c_str (), "training_data");
          saveFileList (models_, training_data_list_file_name.string ().c_str ());
          index_->save (index_filename.string ().c_str ());
        }
      }
    }
    else
    {
      loadFileList (models_, training_data_list_file_name.string ());
      flann::load_from_file (data_, training_data_h5_file_name.string (), "training_data");
      index_ = new flann::Index<DistT> (data_, flann::SavedIndexParams (index_filename.string ().c_str ()));
      index_->buildIndex ();
    }

    if (cache_enabled_)
      buildCachesFromDB (dpath, iteration);

    //Connect to database
    database = new household_objects_database::ObjectsDatabase ("wgs36.willowgarage.com", "5432", "willow", "willow",
                                                                "household_objects");

    return true;
  }

  template<template<class > class Distance>
  bool
  VFHRecognizerDB<Distance>::detect (const sensor_msgs::PointCloud2ConstPtr& msg, int nModels,
                                     std::vector<int>& model_ids, std::vector<geometry_msgs::Pose> & poses,
                                     std::vector<float>& confidences, bool use_fitness_score, std::vector<
                                         boost::shared_ptr<household_objects_database::DatabaseView> >* views,
                                     std::vector<std::string> * vfh_ids_vec)
  {

    std::vector<std::string> vfh_ids;
    std::vector<std::string> model_ids_string;

    this->detect_ (msg, nModels, model_ids_string, poses, confidences, vfh_ids, use_fitness_score);

    for (size_t i = 0; i < model_ids_string.size (); i++)
    {
      model_ids.push_back (atoi (model_ids_string[i].c_str ()));
    }

    if (views != NULL)
    {
      for (size_t i = 0; i < vfh_ids.size (); i++)
      {
        boost::shared_ptr<household_objects_database::DatabaseView> view;
        database->getViewFromVFHId (atoi (vfh_ids[i].c_str ()), view);
        views->push_back (view);

        if (vfh_ids_vec != NULL)
        {
          vfh_ids_vec->push_back (vfh_ids[i]);
        }
      }
    }

    return true;
  }

  template<template<class > class Distance>
  inline int
  VFHRecognizerDB<Distance>::buildTreeFromViews (std::vector<
      boost::shared_ptr<household_objects_database::DatabaseView> > & views)
  {
    household_objects_database::ObjectsDatabase database ("wgs36.willowgarage.com", "5432", "willow", "willow",
                                                          "household_objects");

    if (!database.isConnected ())
    {
      std::cerr << "Database failed to connect \n";
      return -1;
    }
    std::cerr << "Database connected successfully" << views.size () << "\n";

    //get min-id
    int minid = std::numeric_limits<int>::max ();

    for (size_t i = 0; i < views.size (); i++)
    {
      std::cerr << views[i]->view_id_.data () << "\n";
      std::vector<boost::shared_ptr<household_objects_database::DatabaseVFH> > vfhs;
      std::stringstream where;
      where << "view_id = " << views[i]->view_id_.data ();
      std::string where_clause (where.str ());
      database.getList (vfhs, where_clause);

      if (!database.loadFromDatabase (&vfhs[0]->vfh_descriptor_))
        std::cerr << "Load data failed\n";
      else
        std::cerr << "Succeeded" << i << " " << vfhs[0]->vfh_descriptor_.data ().size () << std::endl;

      if (vfhs[0]->vfh_descriptor_.data ().size () > 308 * sizeof(float))
      {
        //deserialize vfh descriptor
        pcl::PointCloud < pcl::VFHSignature308 > vfh_signature;
        boost::shared_array<uint8_t> bufferRead (new uint8_t[vfhs[0]->vfh_descriptor_.data ().size ()]);
        memcpy (&bufferRead[0], &(vfhs[0]->vfh_descriptor_.data ()[0]), vfhs[0]->vfh_descriptor_.data ().size ());
        ser::IStream streamIn (bufferRead.get (), vfhs[0]->vfh_descriptor_.data ().size ());
        ser::deserialize (streamIn, vfh_signature);

        std::stringstream vfh_id_str;
        vfh_id_str << vfhs[0]->vfh_id_.data ();
        std::cout << "vfh_id_str:" << vfh_id_str.str () << std::endl;

        vfh_model_db vfh;
        vfh.first = vfh_id_str.str ();
        vfh.second.resize (308);
        memcpy (&vfh.second[0], &vfh_signature.points[0].histogram[0], 308 * sizeof(float));
        models_.push_back (vfh);

        minid = (std::min) (minid, vfhs[0]->vfh_id_.data ());
      }
    }

    convertToFLANN (models_, data_);
    return minid;
  }

  template<template<class > class Distance>
  inline bool
  VFHRecognizerDB<Distance>::buildTreeFromDB (int iteration)
  {
    household_objects_database::ObjectsDatabase database ("wgs36.willowgarage.com", "5432", "willow", "willow",
                                                          "household_objects");

    if (!database.isConnected ())
    {
      std::cerr << "Database failed to connect \n";
      return false;
    }
    std::cerr << "Database connected successfully \n";

    //Read VFH descriptor and build tree...
    std::vector<boost::shared_ptr<household_objects_database::DatabaseVFH> > vfhs;
    std::stringstream where;
    where << "iteration = " << iteration;
    std::string where_clause (where.str ());
    database.getList (vfhs, where_clause);
    //database.getList (vfhs);
    std::cerr << "Number of vfhs:" << vfhs.size () << "\n";

    for (size_t i = 0; i < vfhs.size (); i++)
    {
      if (!database.loadFromDatabase (&vfhs[i]->vfh_descriptor_))
        std::cerr << "Load data failed\n";
      else
        std::cerr << "Succeeded" << i << " " << vfhs[i]->vfh_descriptor_.data ().size () << std::endl;

      if (vfhs[i]->vfh_descriptor_.data ().size () > 308 * sizeof(float))
      {
        //deserialize vfh descriptor
        pcl::PointCloud < pcl::VFHSignature308 > vfh_signature;
        boost::shared_array<uint8_t> bufferRead (new uint8_t[vfhs[i]->vfh_descriptor_.data ().size ()]);
        memcpy (&bufferRead[0], &(vfhs[i]->vfh_descriptor_.data ()[0]), vfhs[i]->vfh_descriptor_.data ().size ());
        ser::IStream streamIn (bufferRead.get (), vfhs[i]->vfh_descriptor_.data ().size ());
        ser::deserialize (streamIn, vfh_signature);

        std::stringstream vfh_id_str;
        vfh_id_str << vfhs[i]->vfh_id_.data ();

        vfh_model_db vfh;
        vfh.first = vfh_id_str.str ();
        vfh.second.resize (308);
        memcpy (&vfh.second[0], &vfh_signature.points[0].histogram[0], 308 * sizeof(float));
        models_.push_back (vfh);
      }
    }

    convertToFLANN (models_, data_);
    return true;
  }

  template<template<class > class Distance>
  inline bool
  VFHRecognizerDB<Distance>::buildCachesFromDB (bf::path dpath, int iteration)
  {
    std::stringstream ss;
    ss << "iteration" << iteration;
    bf::path view_cache_dir = dpath / ss.str () / "views";
    bf::path roll_cache_dir = dpath / ss.str () / "roll";

    std::cout << "buildCachesFromDB" << std::endl;

    if (!boost::filesystem::exists (view_cache_dir) || !boost::filesystem::exists (roll_cache_dir))
    {
      if (!bf::exists(dpath)) bf::create_directory (dpath);
      if (!bf::exists(dpath / ss.str())) bf::create_directory (dpath / ss.str() );
      bf::create_directory (view_cache_dir);
      bf::create_directory (roll_cache_dir);
      std::cerr << "Building Caches from DB \n";
      household_objects_database::ObjectsDatabase database ("wgs36.willowgarage.com", "5432", "willow", "willow",
                                                            "household_objects");

      if (!database.isConnected ())
      {
        std::cerr << "Database failed to connect \n";
        return false;
      }
      std::cerr << "Database connected successfully \n";

      //Read VFH descriptor and build tree...
      std::vector<boost::shared_ptr<household_objects_database::DatabaseVFH> > vfhs;
      std::stringstream where;
      where << "iteration = " << iteration;
      std::string where_clause (where.str ());
      database.getList (vfhs, where_clause);
      std::cerr << "Number of vfhs:" << vfhs.size () << "\n";

      for (size_t i = 0; i < vfhs.size (); i++)
      {
        // get view
        boost::shared_ptr<household_objects_database::DatabaseView> view;

        if (database.getViewFromVFHId (vfhs[i]->vfh_id_.data (), view))
        {
          std::cerr << "Writing view ";
          pcl::PointCloud < pcl::PointNormal > cloud;
          boost::shared_array<uint8_t> bufferRead (new uint8_t[view->view_point_cloud_data_.data ().size ()]);
          memcpy (&bufferRead[0], &(view->view_point_cloud_data_.data ()[0]),
                  view->view_point_cloud_data_.data ().size ());
          ser::IStream streamIn (bufferRead.get (), view->view_point_cloud_data_.data ().size ());
          ser::deserialize (streamIn, cloud);
          std::stringstream file_name;
          file_name << view_cache_dir.string ();
          file_name << "/view_" << vfhs[i]->vfh_id_.data () << ".pcd";
          std::cerr << file_name.str () << std::endl;
          pcl::io::savePCDFile (file_name.str (), cloud, true);
          view_cache_[vfhs[i]->vfh_id_.data ()] = cloud;
        }

        // get roll hist
        boost::shared_ptr<household_objects_database::DatabaseVFHOrientation> roll_histogram;
        if (database.getOrientationRollFromVFHId (vfhs[i]->vfh_id_.data (), roll_histogram))
        {
          std::cerr << "Writing roll ";
          pcl::PointCloud < pcl::VFHSignature308 > vfh_orientation_signature;
          boost::shared_array<uint8_t>
                                       bufferRead (
                                                   new uint8_t[roll_histogram->vfh_orientation_descriptor_.data ().size ()]);
          memcpy (&bufferRead[0], &(roll_histogram->vfh_orientation_descriptor_.data ()[0]),
                  roll_histogram->vfh_orientation_descriptor_.data ().size ());
          ser::IStream streamIn (bufferRead.get (), roll_histogram->vfh_orientation_descriptor_.data ().size ());
          ser::deserialize (streamIn, vfh_orientation_signature);
          std::stringstream file_name;
          file_name << roll_cache_dir.string ();
          file_name << "/roll_" << vfhs[i]->vfh_id_.data () << ".pcd";
          std::cerr << file_name.str () << std::endl;
          pcl::io::savePCDFile (file_name.str (), vfh_orientation_signature, true);
          roll_cache_[vfhs[i]->vfh_id_.data ()] = vfh_orientation_signature;
        }
        else
        {
          //if the roll is not found, we can search through view
          if (database.getOrientationRollFromVFHThroughViewId (vfhs[i]->vfh_id_.data (), roll_histogram))
          {
            std::cerr << "Writing roll ";
            pcl::PointCloud < pcl::VFHSignature308 > vfh_orientation_signature;
            boost::shared_array<uint8_t>
                                         bufferRead (
                                                     new uint8_t[roll_histogram->vfh_orientation_descriptor_.data ().size ()]);
            memcpy (&bufferRead[0], &(roll_histogram->vfh_orientation_descriptor_.data ()[0]),
                    roll_histogram->vfh_orientation_descriptor_.data ().size ());
            ser::IStream streamIn (bufferRead.get (), roll_histogram->vfh_orientation_descriptor_.data ().size ());
            ser::deserialize (streamIn, vfh_orientation_signature);
            std::stringstream file_name;
            file_name << roll_cache_dir.string ();
            file_name << "/roll_" << vfhs[i]->vfh_id_.data () << ".pcd";
            std::cerr << file_name.str () << std::endl;
            pcl::io::savePCDFile (file_name.str (), vfh_orientation_signature, true);
            roll_cache_[vfhs[i]->vfh_id_.data ()] = vfh_orientation_signature;
          }
        }
      }
    }
    else
    {
      std::cerr << "Building Caches from filesystem : " << std::endl;
      // load from files ...
      bf::directory_iterator end_itr;
      pcl::PointCloud < pcl::PointNormal > cloud;
      pcl::PointCloud < pcl::VFHSignature308 > roll;
      for (bf::directory_iterator itr (view_cache_dir); itr != end_itr; ++itr)
      {
        if (!bf::is_directory (itr->status ()))
        {
          std::string full_file_name = itr->path ().string ();
          //std::cerr << "opening " << full_file_name.c_str() << std::endl;
          std::vector<std::string> strs;
#if (!defined BOOST_FILESYSTEM_VERSION) || (BOOST_FILESYSTEM_VERSION<=2)
          std::string file_name = itr->path ().filename ();
#else
          std::string file_name = itr->path ().filename ().string ();
#endif
          boost::split (strs, file_name, boost::is_any_of ("_."));
          if (strs.size () == 3)
          {
            if (strs[0] == "view")
            {
              pcl::io::loadPCDFile (full_file_name, cloud);
              view_cache_[atoi (strs[1].c_str ())] = cloud;
            }
          }
        }
      }
      for (bf::directory_iterator itr (roll_cache_dir); itr != end_itr; ++itr)
      {
        if (!bf::is_directory (itr->status ()))
        {
          std::string full_file_name = itr->path ().string ();
#if (!defined BOOST_FILESYSTEM_VERSION) || (BOOST_FILESYSTEM_VERSION<=2)
          std::string file_name = itr->path ().filename ();
#else
          std::string file_name = itr->path ().filename ().string ();
#endif
          //std::cerr << "opening " << full_file_name.c_str() << std::endl;
          std::vector<std::string> strs;
          boost::split (strs, file_name, boost::is_any_of ("_."));
          if (strs.size () == 3)
          {
            if (strs[0] == "roll")
            {
              pcl::io::loadPCDFile (full_file_name, roll);
              roll_cache_[atoi (strs[1].c_str ())] = roll;
            }
          }
        }
      }
    }
    std::cerr << "cache contains " << roll_cache_.size () << " roll histograms and " << view_cache_.size ()
        << " views." << std::endl;

    return true;
  }

  template class VFHRecognizerDB<flann::ChiSquareDistance> ;
  template class VFHRecognizerDB<flann::L2> ;
  template class VFHRecognizerDB<flann::HistIntersectionDistance> ;
  template class VFHRecognizerDB<flann::HistIntersectionUnionDistance> ;
}

---

vfh_recognizer_db
Author(s): Aitor Aldoma
autogenerated on Tue Mar 5 15:26:31 2013