vslam.h

Go to the documentation of this file.

#ifndef VSLAM_SYSTEM_VSLAM_H
#define VSLAM_SYSTEM_VSLAM_H

#include <vslam_system/vo.h>
#include <vslam_system/place_recognizer.h>
#include <posest/pe3d.h>
#include <posest/peh.h>
#include <sba/sba.h>
#include <frame_common/frame.h>

namespace vslam {

class VslamSystem
{
  public: 
    frame_common::FrameProc frame_processor_; 

    std::vector<frame_common::Frame, Eigen::aligned_allocator<frame_common::Frame> > frames_;
    sba::SysSBA sba_;    
    vslam::voSt vo_;   
    vslam::PlaceRecognizer place_recognizer_; 
#ifndef HOWARD
    pe::PoseEstimator3d pose_estimator_;      
#else
    pe::PoseEstimatorH pose_estimator_;
#endif
    
    boost::shared_ptr<frame_common::PointcloudProc> pointcloud_processor_;
    std::vector<cv::DMatch> pointcloud_matches_;
    bool doPointPlane;         // true if we want to process point clouds

  public:
    VslamSystem(const std::string& vocab_tree_file, const std::string& vocab_weights_file,
                int min_keyframe_inliers=0, double min_keyframe_distance=0.2, 
                double min_keyframe_angle=0.1);

    bool addFrame(const frame_common::CamParams& camera_parameters,
                  const cv::Mat& left, const cv::Mat& right, int nfrac = 0,
                  bool setPointCloud = false);
    
    bool addFrame(const frame_common::CamParams& camera_parameters,
             const cv::Mat& left, const cv::Mat& right, 
             const pcl::PointCloud<pcl::PointXYZRGB>& ptcloud, int nfrac = 0);
             
    void addKeyframe(frame_common::Frame& next_frame);

    void refine(int initial_runs=3);

    int prInliers;  
    int numPRs;                 
    int nSkip;      

    // parameters settings
    void setPlaceInliers(int n) { prInliers = n; }; 
    void setPRSkip(int n) { nSkip = n; };           
    void setKeyInliers(int n) { vo_.mininls = n; }; 
    void setKeyDist(double n) { vo_.mindist = n; }; 
    void setKeyAngle(double n) { vo_.minang = n; }; 
    void setNDisp(int n) { frame_processor_.ndisp = n; }; 
    void setPRRansacIt(int n) { pose_estimator_.numRansac = n; }; 
    void setPRPolish(bool n) { pose_estimator_.polish = n; }; 
    void setVORansacIt(int n) { vo_.pose_estimator_->numRansac = n; }; 
    void setVOPolish(bool n) { vo_.pose_estimator_->polish = n; }; 
    void setPRWindow(int x, int y) { pose_estimator_.wx = x; pose_estimator_.wy = y; }; 
    void setVOWindow(int x, int y) { vo_.pose_estimator_->wx = x; vo_.pose_estimator_->wy = y; }; 
    void setHuber(double x) { sba_.huber = x; vo_.sba.huber = x; }
    
    
    
    void setPointcloudProc(boost::shared_ptr<frame_common::PointcloudProc> proc)
    {
      pointcloud_processor_ = proc;
      vo_.pointcloud_proc_ = proc;
    }
};

} // namespace vslam

#endif