Method CreateFromCache

src/colmap/scene/database_cache.cc:312–422

}

std::shared_ptr<DatabaseCache> DatabaseCache::CreateFromCache(
    const DatabaseCache& database_cache, const Options& options) {
  auto cache = std::make_shared<DatabaseCache>();

  // Collect candidate image ids matching the name filter.
  // Empty image_names means use all images.
  std::unordered_set<image_t> candidate_image_ids;
  for (const auto& [image_id, image] : database_cache.Images()) {
    if (options.image_names.empty() ||
        options.image_names.count(image.Name()) > 0) {
      candidate_image_ids.insert(image_id);
    }
  }

  const auto& source_graph = database_cache.CorrespondenceGraph();

  std::unordered_set<image_t> connected_image_ids;
  if (!options.load_all_images) {
    for (const auto& [pair_id, num_matches] :
         source_graph->NumMatchesBetweenAllImages()) {
      const auto [image_id1, image_id2] = PairIdToImagePair(pair_id);
      if (candidate_image_ids.count(image_id1) == 0 ||
          candidate_image_ids.count(image_id2) == 0) {
        continue;
      }
      const TwoViewGeometry two_view_geometry =
          source_graph->ExtractTwoViewGeometry(
              image_id1, image_id2, /*extract_inlier_matches=*/false);
      if (!UseInlierMatchesCheck(
              options, two_view_geometry.config, num_matches)) {
        continue;
      }
      connected_image_ids.insert(image_id1);
      connected_image_ids.insert(image_id2);
    }
  }

  const std::unordered_set<image_t>& load_image_ids =
      options.load_all_images ? candidate_image_ids : connected_image_ids;

  // Collect frame ids for images to load.
  std::unordered_set<frame_t> filtered_frame_ids;
  for (const image_t image_id : load_image_ids) {
    const auto& image = database_cache.Image(image_id);
    filtered_frame_ids.insert(image.FrameId());
  }

  // Copy all images of filtered frames (not just the images matching the
  // name filter). This is needed for multi-camera rigs where the generalized
  // pose solver needs all images of a frame.
  std::unordered_set<camera_t> filtered_camera_ids;
  for (const auto& [image_id, image] : database_cache.Images()) {
    if (filtered_frame_ids.count(image.FrameId()) > 0) {
      cache->images_.emplace(image_id, image);
      filtered_camera_ids.insert(image.CameraId());
    }
  }