int main()

in source/render/SimpleMeshRenderer.cpp [432:545]
88 lines of code
14 McCabe index (conditional complexity)

int main(int argc, char* argv[]) {
  gflags::SetUsageMessage(kUsage);
  system_util::initDep(argc, argv);

  // Load and filter cameras
  CHECK_NE(FLAGS_rig, "");
  const Camera::Rig rig = filterDestinations(Camera::loadRig(FLAGS_rig), FLAGS_cameras);
  CHECK_GT(rig.size(), 0);

  verifyInputs(rig);

  const int first = std::stoi(FLAGS_first);
  const int last = std::stoi(FLAGS_last);

  // On and off screen rendering
  SimpleMeshWindow window(FLAGS_format.empty() ? GlWindow::ON_SCREEN : GlWindow::OFF_SCREEN);

  for (int iFrame = first; iFrame <= last; ++iFrame) {
    const std::string frameName = image_util::intToStringZeroPad(iFrame, 6);
    LOG(INFO) << folly::sformat("Processing frame {}...", frameName);

    // Load disparities
    const std::vector<cv::Mat_<float>> disparities = loadPfmImages(FLAGS_disparity, rig, frameName);
    CHECK_EQ(ssize(disparities), ssize(rig));

    // Load colors
    const cv::Size& dummySize = disparities[0].size();
    const std::vector<cv::Mat_<cv::Vec4f>> colors = loadColors(rig, frameName, dummySize);
    CHECK_EQ(ssize(colors), ssize(rig));

    // Disparities need to be used as colors when we want to show disparity maps
    bool needDisparitiesAsColors;
    const std::vector<cv::Mat_<cv::Vec4f>> disparitiesAsColors =
        loadDisparitiesAsColors(rig, disparities, needDisparitiesAsColors);
    CHECK_EQ(ssize(disparitiesAsColors), ssize(rig));

    if (FLAGS_format.empty()) {
      const std::shared_ptr<CanopyScene> sceneColor(new CanopyScene(
          rig, disparities, needDisparitiesAsColors ? disparitiesAsColors : colors));

      window.sceneColor = sceneColor;

      // Render loop
      window.mainLoop();

      // Leave the loop
      break;
    }

    // Update the scene
    const std::shared_ptr<CanopyScene> sceneColor(new CanopyScene(rig, disparities, colors, false));
    const std::shared_ptr<CanopyScene> sceneDisp(
        new CanopyScene(rig, disparities, disparitiesAsColors, false));

    window.sceneColor = sceneColor;
    window.sceneDisp = sceneDisp;

    auto it = std::find(formats.begin(), formats.end(), FLAGS_format);
    const int formatIdx = std::distance(formats.begin(), it);

    cv::Mat_<cv::Vec4f> outputImage;
    const Eigen::Vector3f position = decodeVector(FLAGS_position);
    const float ipdDefault = 0.0f;

    switch (formatIdx) {
      case int(Format::eqrcolor): {
        outputImage = window.generate(
            sceneColor->equirect(FLAGS_height, position, ipdDefault, !FLAGS_ignore_alpha_blend));
        break;
      }
      case int(Format::eqrdisp): {
        outputImage = window.generate(
            sceneDisp->equirect(FLAGS_height, position, ipdDefault, !FLAGS_ignore_alpha_blend));
        break;
      }
      case int(Format::cubecolor): {
        outputImage = window.generate(
            sceneColor->cubemap(FLAGS_height, position, ipdDefault, !FLAGS_ignore_alpha_blend));
        break;
      }
      case int(Format::cubedisp): {
        outputImage = window.generate(
            sceneDisp->cubemap(FLAGS_height, position, ipdDefault, !FLAGS_ignore_alpha_blend));
        break;
      }
      case int(Format::lr180):
      case int(Format::tbstereo): {
        outputImage = window.generate(window.stereo(formatIdx, FLAGS_height, position));
        break;
      }
      case int(Format::tb3dof): {
        outputImage = window.generate(window.tb3dof(FLAGS_height, position));
        break;
      }
      case int(Format::snapcolor): {
        outputImage = window.generate(window.snapshot(false));
        break;
      }
      case int(Format::snapdisp): {
        outputImage = window.generate(window.snapshot(true));
        break;
      }
      default: {
        CHECK(false) << "Invalid format " << FLAGS_format;
      }
    }

    const filesystem::path filename =
        filesystem::path(FLAGS_output) / (frameName + "." + FLAGS_file_type);
    save(filename, outputImage);
    LOG(INFO) << "File saved in " << filename;
  }
  return EXIT_SUCCESS;
}