Function SelectViews

src/colmap/mvs/texture_mapping.cc:272–401

#endif  // COLMAP_CGAL_ENABLED

std::vector<int> SelectViews(const PlyMesh& mesh,
                             const std::vector<Eigen::Vector3f>& face_normals,
                             const std::vector<Image>& images,
                             const FaceAdjacencyMap& adjacency,
                             const MeshTextureMappingOptions& options) {
  const size_t num_faces = mesh.faces.size();
  const size_t num_images = images.size();

  if (num_faces == 0 || num_images == 0) {
    return std::vector<int>(num_faces, -1);
  }

#if defined(COLMAP_CGAL_ENABLED)
  OcclusionTester occlusion_tester;
  occlusion_tester.Build(mesh);
#endif

  // Flat score buffer: scores[fi * num_images + ii].
  std::vector<double> scores(num_faces * num_images, -1.0);

#ifdef _OPENMP
  [[maybe_unused]] const int num_threads =
      options.num_threads > 0
          ? options.num_threads
          : std::max(1, static_cast<int>(omp_get_max_threads()));
#pragma omp parallel for schedule(dynamic) num_threads(num_threads)
#endif
  for (int64_t fi = 0; fi < static_cast<int64_t>(num_faces); ++fi) {
    const Eigen::Vector3f& normal = face_normals[fi];
    if (normal.squaredNorm() < 1e-10f) continue;

    const std::array<size_t, 3> idx = GetFaceIndices(mesh.faces[fi]);
    const Eigen::Vector3f v0 = GetVertex(mesh, idx[0]);
    const Eigen::Vector3f v1 = GetVertex(mesh, idx[1]);
    const Eigen::Vector3f v2 = GetVertex(mesh, idx[2]);
    const Eigen::Vector3f centroid = (v0 + v1 + v2) / 3.0f;
    const std::array<Eigen::Vector3f, 3> verts = {v0, v1, v2};

    for (size_t ii = 0; ii < num_images; ++ii) {
      const Image& img = images[ii];
      const Eigen::Vector3f cam_center =
          ComputeCameraCenter(img.GetR(), img.GetT());

      const Eigen::Vector3f view_dir = (cam_center - centroid).normalized();
      const float cos_angle = normal.dot(view_dir);
      if (cos_angle < static_cast<float>(options.min_cos_normal_angle)) {
        continue;
      }

      int visible_count = 0;
      std::array<Eigen::Vector2f, 3> proj;
      bool behind_camera = false;
      for (int vi = 0; vi < 3; ++vi) {
        const float depth = ProjectPointDepth(img.GetP(), verts[vi]);
        if (depth <= 0) {
          behind_camera = true;
          break;
        }