void filterFrame()

in source/depth_estimation/TemporalBilateralFilter.cpp [120:183]
57 lines of code
7 McCabe index (conditional complexity)

void filterFrame(const int curFrameIdx, const Camera::Rig& rigDst) {
  const size_t numDsts = rigDst.size();

  std::vector<std::vector<cv::Mat_<depth_estimation::PixelType>>> colorFrames(numDsts);
  std::vector<std::vector<cv::Mat_<float>>> disparities(numDsts);
  std::vector<std::vector<cv::Mat_<bool>>> masks(numDsts);

  const Camera& camRef = rigDst[0];
  int firstFrameIdx = 0;
  int lastFrameIdx = INT_MAX;
  populateMinMaxFrame(FLAGS_color, FLAGS_level, camRef, curFrameIdx, firstFrameIdx, lastFrameIdx);
  populateMinMaxFrame(
      FLAGS_disparity, FLAGS_level, camRef, curFrameIdx, firstFrameIdx, lastFrameIdx);
  if (FLAGS_use_foreground_masks) {
    populateMinMaxFrame(
        FLAGS_foreground_masks, FLAGS_level, camRef, curFrameIdx, firstFrameIdx, lastFrameIdx);
  }

  for (int frameIdx = firstFrameIdx; frameIdx <= lastFrameIdx; ++frameIdx) {
    const std::string frameName = image_util::intToStringZeroPad(frameIdx, 6);
    const std::vector<cv::Mat_<PixelType>> colorImages =
        loadLevelImages<PixelType>(FLAGS_color, FLAGS_level, rigDst, frameName, FLAGS_threads);
    const std::vector<cv::Mat_<float>> disparitiesImages =
        loadLevelImages<float>(FLAGS_disparity, FLAGS_level, rigDst, frameName, FLAGS_threads);

    std::map<int, cv::Size> sizes;
    getPyramidLevelSizes(sizes, FLAGS_color);
    const std::vector<cv::Mat_<bool>> foregroundMaskImages = FLAGS_use_foreground_masks
        ? loadLevelImages<bool>(
              FLAGS_foreground_masks, FLAGS_level, rigDst, frameName, FLAGS_threads)
        : cv_util::generateAllPassMasks(sizes.at(FLAGS_level), numDsts);
    const std::vector<cv::Mat_<bool>> fovMaskImages =
        generateFovMasks(rigDst, sizes.at(FLAGS_level), FLAGS_threads);

    for (size_t camIdx = 0; camIdx < numDsts; ++camIdx) {
      colorFrames[camIdx].push_back(colorImages[camIdx]);
      disparities[camIdx].push_back(disparitiesImages[camIdx]);
      masks[camIdx].push_back(foregroundMaskImages[camIdx] & fovMaskImages[camIdx]);
    }
  }

  LOG(INFO) << "Filtering images...";
  for (size_t camIdx = 0; camIdx < numDsts; ++camIdx) {
    cv::Mat_<float> disparity;
    const float scale = std::pow(depth_estimation::kLevelScale, FLAGS_level);
    const int spaceRadius = FLAGS_space_radius == -1
        ? std::max(std::ceil(kTemporalSpaceRadiusMax * scale), float(kTemporalSpaceRadiusMin))
        : FLAGS_space_radius;
    temporalJointBilateralFilter(
        colorFrames[camIdx],
        disparities[camIdx],
        masks[camIdx],
        curFrameIdx - firstFrameIdx,
        FLAGS_sigma,
        spaceRadius,
        FLAGS_weight_b,
        FLAGS_weight_g,
        FLAGS_weight_b,
        disparity,
        FLAGS_threads);

    saveDisparity(FLAGS_output_formats, disparity, rigDst[camIdx].id, curFrameIdx);
  }
}