Method FindNextImages

src/colmap/sfm/incremental_mapper_impl.cc:309–379

}

std::vector<image_t> IncrementalMapperImpl::FindNextImages(
    const IncrementalMapper::Options& options,
    const ObservationManager& obs_manager,
    const std::unordered_set<frame_t>& filtered_frames,
    std::unordered_map<image_t, size_t>& num_reg_trials,
    bool structure_less) {
  THROW_CHECK(options.Check());
  const Reconstruction& reconstruction = obs_manager.Reconstruction();

  std::function<float(image_t, const ObservationManager&)> rank_image_func;
  if (structure_less) {
    rank_image_func = [](image_t image_id,
                         const ObservationManager& obs_manager) {
      return static_cast<float>(
          obs_manager.NumVisibleCorrespondences(image_id));
    };
  } else {
    switch (options.image_selection_method) {
      case IncrementalMapper::Options::ImageSelectionMethod::
          MAX_VISIBLE_POINTS_NUM:
        rank_image_func = RankNextImageMaxVisiblePointsNum;
        break;
      case IncrementalMapper::Options::ImageSelectionMethod::
          MAX_VISIBLE_POINTS_RATIO:
        rank_image_func = RankNextImageMaxVisiblePointsRatio;
        break;
      case IncrementalMapper::Options::ImageSelectionMethod::MIN_UNCERTAINTY:
        rank_image_func = RankNextImageMinUncertainty;
        break;
    }
  }

  std::vector<std::pair<image_t, float>> image_ranks;
  std::vector<std::pair<image_t, float>> other_image_ranks;

  // Append images that have not failed to register before.
  for (const auto& [image_id, image] : reconstruction.Images()) {
    // Skip images that are already registered.
    if (image.HasPose()) {
      continue;
    }

    // Only consider images with a sufficient number of visible points.
    if (obs_manager.NumVisiblePoints3D(image_id) <
        static_cast<size_t>(options.abs_pose_min_num_inliers)) {
      continue;
    }

    // Only try registration for a certain maximum number of times.
    const size_t image_num_reg_trials = num_reg_trials[image_id];
    if (image_num_reg_trials >= static_cast<size_t>(options.max_reg_trials)) {
      continue;
    }

    // If image has been filtered or failed to register, place it in the
    // second bucket and prefer images that have not been tried before.
    const float rank = rank_image_func(image_id, obs_manager);
    const frame_t frame_id = image.FrameId();