rgbd_keyframe.cpp

Go to the documentation of this file.

#include "rgbdtools/rgbd_keyframe.h"

namespace rgbdtools {

RGBDKeyframe::RGBDKeyframe():
  manually_added(false)
{
 
}

RGBDKeyframe::RGBDKeyframe(const RGBDFrame& frame):
  RGBDFrame(),
  manually_added(false)
{
  // copies the data
  rgb_img   = frame.rgb_img.clone();
  depth_img = frame.depth_img.clone();
  intr      = frame.intr.clone();
  dist      = frame.dist.clone();
  header    = frame.header;
  
  // this preserves the index number of the original frame
  index = frame.index;
}

bool RGBDKeyframe::save(
  const RGBDKeyframe& keyframe, 
  const std::string& path)
{  
  std::string pose_filename  = path + "/pose.yaml";
  std::string prop_filename  = path + "/properties.yaml"; 

  // save frame  
  bool save_frame_result = RGBDFrame::save(keyframe, path);
  if (!save_frame_result) return false;
  
  // save pose as OpenCV rmat and tvec
  cv::Mat rmat, tvec;
  eigenAffineToOpenCVRt(keyframe.pose, rmat, tvec);

  cv::FileStorage fs_m(pose_filename, cv::FileStorage::WRITE);
  fs_m << "rmat" << rmat;
  fs_m << "tvec" << tvec;
 
  // save other class members 
  cv::FileStorage fs_p(prop_filename, cv::FileStorage::WRITE);
  fs_p << "manually_added"      << keyframe.manually_added;
  fs_p << "path_length_linear"  << keyframe.path_length_linear;
  fs_p << "path_length_angular" << keyframe.path_length_angular;

  return true;
}

bool RGBDKeyframe::load(RGBDKeyframe& keyframe, const std::string& path)
{
  // load frame
  bool load_frame_result = RGBDFrame::load(keyframe, path);
  if (!load_frame_result) return false;

  // set up filenames
  std::string pose_filename  = path + "/pose.yaml";
  std::string prop_filename  = path + "/properties.yaml"; 

  // check if files exist
  if (!boost::filesystem::exists(pose_filename)  ||
      !boost::filesystem::exists(prop_filename)  )
  {
    std::cerr << "files for loading keyframe not found" <<std::endl;
    return false;
  }

  // load pose
  cv::FileStorage fs_m(pose_filename, cv::FileStorage::READ);

  cv::Mat rmat, tvec;
  fs_m["rmat"] >> rmat;
  fs_m["tvec"] >> tvec;

  openCVRtToEigenAffine(rmat, tvec, keyframe.pose);

  // load other class members
  cv::FileStorage fs_p(prop_filename, cv::FileStorage::READ);
  fs_p["manually_added"]      >> keyframe.manually_added;
  fs_p["path_length_linear"]  >> keyframe.path_length_linear;
  fs_p["path_length_angular"] >> keyframe.path_length_angular;
  return true;
}

bool saveKeyframes(
  const KeyframeVector& keyframes, 
  const std::string& path)
{
  for (unsigned int kf_idx = 0; kf_idx < keyframes.size(); ++kf_idx)
  {
    std::stringstream ss_idx;
    ss_idx << std::setw(4) << std::setfill('0') << kf_idx;
    
    std::string kf_path = path + "/" + ss_idx.str();

    bool save_result = RGBDKeyframe::save(keyframes[kf_idx], kf_path); 
    if (!save_result) return false;
  }

  return true;
}

bool loadKeyframes(
  KeyframeVector& keyframes, 
  const std::string& path)
{
  keyframes.clear();

  int kf_idx = 0;

  while(true)
  {
    std::stringstream ss_idx;
    ss_idx << std::setw(4) << std::setfill('0') << kf_idx;

    std::string path_kf = path + "/" + ss_idx.str();

    if (boost::filesystem::exists(path_kf))
    {
      std::cout << "Loading " << path_kf << std::endl;
      RGBDKeyframe keyframe;
      bool result_load = RGBDKeyframe::load(keyframe, path_kf);
      if (result_load) keyframes.push_back(keyframe);
      else
      {
        std::cerr << "Error loading" << std::endl; 
        return false;
      }
    } 
    else break;

    kf_idx++;
  }
  for(u_int i = 0; i< keyframes.size(); i++)
  {
      keyframes[i].used = true;
  }
  return true;
}

} // namespace rgbdtools