void upsampleFrame()

in source/depth_estimation/UpsampleDisparity.cpp [63:142]
73 lines of code
12 McCabe index (conditional complexity)

void upsampleFrame(const Camera::Rig& rigSrc, const Camera::Rig& rigDst, const std::string& frame) {
  const std::string exts = FLAGS_output_formats.empty() ? "pfm" : FLAGS_output_formats;
  std::vector<std::string> outputFormats;
  folly::split(",", exts, outputFormats);
  const std::vector<cv::Mat_<float>> disps =
      image_util::loadImages<float>(FLAGS_disparity, rigDst, frame, FLAGS_threads);
  CHECK_GT(disps.size(), 0);
  std::vector<cv::Mat_<PixelType>> colors;
  if (!FLAGS_color.empty()) {
    colors = image_util::loadImages<PixelType>(FLAGS_color, rigDst, frame, FLAGS_threads);
  }

  std::vector<cv::Mat_<float>> backgroundDispsUp;
  if (!FLAGS_background_disp.empty()) {
    backgroundDispsUp = image_util::loadImages<float>(
        FLAGS_background_disp, rigDst, FLAGS_background_frame, FLAGS_threads);
  } else {
    cv::Mat_<float> temp;
    std::vector<cv::Mat_<float>> backgroundDispsUpTemp(int(rigDst.size()), temp);
    backgroundDispsUp = backgroundDispsUpTemp;
  }

  int height;
  if (FLAGS_height == -1) {
    height =
        std::round(float(rigDst[0].resolution.y()) / rigDst[0].resolution.x() * FLAGS_resolution);
    height += height % 2; // force even height
  } else {
    height = FLAGS_height;
  }
  const cv::Size sizeUp(FLAGS_resolution, height);

  const bool useForegroundMasks = !FLAGS_foreground_masks_in.empty();
  std::vector<cv::Mat_<bool>> masks = useForegroundMasks
      ? image_util::loadImages<bool>(FLAGS_foreground_masks_in, rigDst, frame, FLAGS_threads)
      : cv_util::generateAllPassMasks(disps[0].size(), int(rigDst.size()));

  const std::vector<cv::Mat_<bool>> masksUp = !FLAGS_foreground_masks_out.empty()
      ? image_util::loadImages<bool>(FLAGS_foreground_masks_out, rigDst, frame, FLAGS_threads)
      : cv_util::generateAllPassMasks(sizeUp, int(rigDst.size()));

  std::vector<cv::Mat_<float>> dispsUp = upsampleDisparities(
      rigDst, disps, backgroundDispsUp, masks, masksUp, sizeUp, useForegroundMasks, FLAGS_threads);
  for (ssize_t i = 0; i < ssize(rigDst); ++i) {
    if (!FLAGS_color.empty()) {
      const int radius = getRadius(masks[i].size(), sizeUp);
      LOG(INFO) << folly::sformat(
          "Applying filter with radius {} to {}x{} disparity to {}...",
          radius,
          sizeUp.width,
          sizeUp.height,
          rigDst[i].id);
      const cv::Mat_<PixelType> colorUp = cv_util::resizeImage(colors[i], sizeUp);
      dispsUp[i] = depth_estimation::generalizedJointBilateralFilter<float, PixelType>(
          dispsUp[i],
          colorUp,
          colorUp,
          masksUp[i],
          radius,
          FLAGS_sigma,
          FLAGS_weight_b,
          FLAGS_weight_g,
          FLAGS_weight_r,
          FLAGS_threads);
    }

    LOG(INFO) << "Saving output images...";
    for (const std::string& ext : outputFormats) {
      const std::string frameFn = ext[0] == '.' ? frame + ext : frame + '.' + ext;
      const filesystem::path fn = filesystem::path(FLAGS_output) / rigDst[i].id / frameFn;
      boost::filesystem::create_directories(fn.parent_path());

      if (ext != "pfm") {
        cv_util::imwriteExceptionOnFail(fn, cv_util::convertTo<uint16_t>(dispsUp[i]));
      } else {
        cv_util::writeCvMat32FC1ToPFM(fn, dispsUp[i]);
      }
    }
  }
}