Function ReconstructBlocks

src/colmap/mvs/advancing_front_meshing.cc:708–823

Assign points to spatial blocks and reconstruct each block independently.

// Assign points to spatial blocks and reconstruct each block independently.
colmap::PlyMesh ReconstructBlocks(
    const std::vector<colmap::PlyPoint>& points,
    const VisibilityData& vis_data,
    const colmap::mvs::AdvancingFrontMeshingOptions& options) {
  const auto grid =
      ComputeBlockGrid(points, options.block_size, options.block_overlap);

  LOG(INFO) << "Block-wise processing: " << grid.nx << "x" << grid.ny << "x"
            << grid.nz << " = " << grid.NumBlocks()
            << " blocks (size=" << grid.block_size
            << ", overlap=" << grid.overlap << ").";

  const auto block_point_indices = AssignPointsToBlocks(points, grid);

  // Build all visibility rays and pre-assign to blocks by AABB intersection.
  const bool use_vis =
      options.visibility_filtering && !vis_data.cam_positions.empty();
  std::vector<K::Segment_3> all_rays;
  std::vector<std::vector<size_t>> block_ray_indices(grid.NumBlocks());

  if (use_vis) {
    all_rays = BuildVisibilityRays(points,
                                   vis_data.cam_positions,
                                   vis_data.point_visibility,
                                   {},
                                   options.visibility_ray_trim_offset);
    LOG(INFO) << "Built " << all_rays.size()
              << " visibility rays. Assigning to blocks...";
    block_ray_indices = AssignRaysToBlocks(all_rays, block_point_indices, grid);
  }

  colmap::PlyMesh merged_mesh;
  std::mutex merge_mutex;
  std::atomic<int> blocks_completed{0};
  int num_active_blocks = 0;
  for (int i = 0; i < grid.NumBlocks(); ++i) {
    if (!block_point_indices[i].empty()) {
      ++num_active_blocks;
    }
  }

  const int num_threads = colmap::GetEffectiveNumThreads(options.num_threads);
  colmap::ThreadPool thread_pool(num_threads);

  for (int block_idx = 0; block_idx < grid.NumBlocks(); ++block_idx) {
    if (block_point_indices[block_idx].empty()) {
      continue;
    }

    thread_pool.AddTask([&, block_idx]() {
      // Disable OMP parallelism within each block task to avoid
      // oversubscription since ThreadPool handles inter-block parallelism.
      omp_set_num_threads(1);
#ifdef _MSC_VER
      omp_set_nested(0);
#else
      omp_set_max_active_levels(1);
#endif