Function mono_tracking

example/run_slam_planeSeg.cc:55–200

#endif

void mono_tracking(const std::shared_ptr<PLPSLAM::config> &cfg,
                   const std::string &vocab_file_path,
                   const std::string &sequence_dir_path,
                   const unsigned int frame_skip,
                   const bool no_sleep,
                   const bool auto_term,
                   const bool eval_log,
                   const std::string &map_db_path)
{
    // FW: here, the second paramter *false* means:
    // for now we don't have CNN-predicted depth image, leave it false
    ImageSequence_withPlaneSeg sequence(sequence_dir_path, false);
    const auto frames = sequence.get_frames();

    // FW: the third parameter *true* means:
    // we have segmentation mask as auxiliary input -> a boolean variable _b_seg_or_not = true
    // this boolean variable is passed to system.cc
    // after that, a planar_mapping module will be activated
    // after that, a same boolean variable will be set as true in map_db, which used to control all the functionalities related to plane
    PLPSLAM::system SLAM(cfg, vocab_file_path, true); // build a SLAM system

    // startup the SLAM process, create multi-thread
    SLAM.startup();

    // create a viewer object
    // and pass the frame_publisher and the map_publisher
#ifdef USE_PANGOLIN_VIEWER
    pangolin_viewer::viewer viewer(cfg, &SLAM, SLAM.get_frame_publisher(), SLAM.get_map_publisher());
#elif USE_SOCKET_PUBLISHER
    socket_publisher::publisher publisher(cfg, &SLAM, SLAM.get_frame_publisher(), SLAM.get_map_publisher());
#endif

    std::vector<double> track_times;
    track_times.reserve(frames.size());

    // FW: start the SLAM in the main thread (i.e. tracking thread)
    std::thread thread([&]()
                       {
                           for (unsigned int i = 0; i < frames.size(); ++i)
                           {
                               const auto &frame = frames.at(i);
                               const auto rgb_img = cv::imread(frame.rgb_img_path_, cv::IMREAD_UNCHANGED);

                               // FW: read planar segmentation mask
                               const auto seg_mask_img = cv::imread(frame.mask_img_path_, cv::IMREAD_UNCHANGED);
                               assert(rgb_img.rows == seg_mask_img.rows);
                               assert(rgb_img.cols == seg_mask_img.cols);

                               const auto tp_1 = std::chrono::steady_clock::now();
                               if (!rgb_img.empty() && (i % frame_skip == 0) && !seg_mask_img.empty())
                               {
                                   // input the current frame and estimate the camera pose
                                   SLAM.feed_monocular_frame(rgb_img, seg_mask_img, frame.timestamp_);
                               }
                               const auto tp_2 = std::chrono::steady_clock::now();

                               const auto track_time = std::chrono::duration_cast<std::chrono::duration<double>>(tp_2 - tp_1).count();
                               if (i % frame_skip == 0)