Function mono_tracking

example/run_image_slam.cc:52–177

#endif

void mono_tracking(const std::shared_ptr<PLPSLAM::config> &cfg,
                   const std::string &vocab_file_path, const std::string &image_dir_path, const std::string &mask_img_path,
                   const unsigned int frame_skip, const bool no_sleep, const bool auto_term,
                   const bool eval_log, const std::string &map_db_path)
{
    // load the mask image
    const cv::Mat mask = mask_img_path.empty() ? cv::Mat{} : cv::imread(mask_img_path, cv::IMREAD_GRAYSCALE);

    const image_sequence sequence(image_dir_path, cfg->camera_->fps_);
    const auto frames = sequence.get_frames();

    // build a SLAM system
    PLPSLAM::system SLAM(cfg, vocab_file_path);
    // startup the SLAM process
    SLAM.startup();

#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());

    // run the SLAM in another thread
    std::thread thread([&]()
                       {
                           for (unsigned int i = 0; i < frames.size(); ++i)
                           {
                               const auto &frame = frames.at(i);
                               const auto img = cv::imread(frame.img_path_, cv::IMREAD_UNCHANGED);

                               const auto tp_1 = std::chrono::steady_clock::now();

                               if (!img.empty() && (i % frame_skip == 0))
                               {
                                   // input the current frame and estimate the camera pose
                                   SLAM.feed_monocular_frame(img, frame.timestamp_, mask);
                               }

                               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)
                               {
                                   track_times.push_back(track_time);
                               }

                               // wait until the timestamp of the next frame
                               if (!no_sleep && i < frames.size() - 1)
                               {
                                   const auto wait_time = frames.at(i + 1).timestamp_ - (frame.timestamp_ + track_time);
                                   if (0.0 < wait_time)
                                   {
                                       std::this_thread::sleep_for(std::chrono::microseconds(static_cast<unsigned int>(wait_time * 1e6)));
                                   }
                               }