main-opencv.cpp

Go to the documentation of this file.

 
 
#include "irsol/irsol.hpp"
 
#include <chrono>
#include <opencv2/opencv.hpp>
#include <unordered_map>
 
const std::string
getProgramName()
{
#ifndef PROGRAM_NAME
#define PROGRAM_NAME "loading-images-opencv-demo"
#endif
  return PROGRAM_NAME;
}
 
struct Params
{
  spdlog::level::level_enum logLevel{spdlog::level::info};
 
  uint64_t numFrames{10};
 
  double fps = -1;
};
 
Params
getParams(int argc, char** argv)
{
  args::ArgumentParser parser(getProgramName());
  args::HelpFlag       help(parser, "help", "Display this help menu", {'h', "help"});
 
  args::MapFlag<std::string, spdlog::level::level_enum> logLevelArg(
    parser, "level", "Log level", {'l', "log-level"}, irsol::levelNameToLevelMap);
 
  args::ValueFlag<uint64_t> numFramesArg(
    parser, "#frames", "Number of frames to iterate over", {'n', "frames-count"});
 
  args::ValueFlag<double> fpsArg(parser, "fps", "Desired FPS for capturing image", {'f', "fps"});
 
  try {
    parser.ParseCLI(argc, argv);
  } catch(args::Help) {
    std::cerr << parser.Help() << std::endl;
    std::exit(0);
  } catch(args::ParseError e) {
    std::cerr << "Error parsing command-line arguments:\n" << e.what() << "\n\n" << parser.Help();
    std::exit(1);
  }
 
  Params params{};
  if(logLevelArg) {
    params.logLevel = args::get(logLevelArg);
  }
  if(numFramesArg) {
    params.numFrames = args::get(numFramesArg);
  }
  if(fpsArg) {
    params.fps = args::get(fpsArg);
  }
  return params;
}
 
void
runCapture(irsol::camera::Interface& cam)
{
  auto image = cam.captureImage();
 
  if(image.IsEmpty()) {
    IRSOL_LOG_WARN("Image is empty.");
  }
 
  auto cvMat = irsol::opencv::convertNeoImageToCvMat(image);
 
  IRSOL_LOG_INFO("{}x{}, {} bytes", image.GetHeight(), image.GetWidth(), image.GetSize());
  cv::imshow(getProgramName(), cvMat);
  cv::waitKey(1);
}
 
int
main(int argc, char** argv)
{
  // Parse command-line parameters
  auto params = getParams(argc, argv);
 
  // Construct log file path based on program name
  std::string logPath = "logs/" + getProgramName() + ".log";
  irsol::initLogging(logPath.c_str(), params.logLevel);
 
  // Enable custom assertion handler
  irsol::initAssertHandler();
 
  // Choose camera resolution based on build type
#ifdef DEBUG
  auto cameraInterface = irsol::camera::Interface::FullResolution();
#else
  auto cameraInterface = irsol::camera::Interface::HalfResolution();
#endif
 
  // Ensure the camera is connected before continuing
  IRSOL_ASSERT_FATAL(cameraInterface.isConnected(), "Camera is not connected");
 
  // Log camera metadata for debugging purposes
  IRSOL_LOG_INFO("\n{}", cameraInterface.cameraInfoAsString());
  IRSOL_LOG_INFO("\n{}", cameraInterface.cameraStatusAsString());
 
  // Start a monitoring thread to log camera status
  irsol::camera::StatusMonitor monitor(cameraInterface, std::chrono::milliseconds(500));
  monitor.start();
 
  // Capture and log a sequence of frames
  auto       lastTick = irsol::types::clock_t::now();
  const auto desiredDt =
    params.fps > 0.0 ? std::chrono::microseconds(static_cast<uint64_t>(1000000.0 / params.fps))
                     : std::chrono::microseconds(0);
  for(size_t i = 0; i < params.numFrames; ++i) {
    const auto t0 = irsol::types::clock_t::now();
    runCapture(cameraInterface);
    const auto nextTick = lastTick + desiredDt;
    lastTick            = nextTick;
    std::this_thread::sleep_until(nextTick);
    const auto loopDuration = irsol::types::clock_t::now() - t0;
    const auto measuredFps =
      1000000.0 / std::chrono::duration_cast<std::chrono::microseconds>(loopDuration).count();
    IRSOL_LOG_INFO("Desired FPS: {:.4f}, measured FPS: {:.4f}", params.fps, measuredFps);
  }
 
  return 0;
}