main.cpp File Reference

Example application using the irsol library to initialize logging, connect to a camera, and capture a sequence of images. More...

#include "irsol/irsol.hpp"
#include <chrono>
#include <unordered_map>

Go to the source code of this file.

Classes
struct	Params
	Command-line parameters for the program. More...

Macros
#define	PROGRAM_NAME   "loading-images-demo"

Functions
const std::string	getProgramName ()
	Returns the program name, typically used for logging. If PROGRAM_NAME is not defined at compile time, returns "loading-images-demo".
Params	getParams (int argc, char **argv)
	Parses command-line arguments using args library.
void	runCapture (irsol::camera::Interface &cam)
	Captures a single image using the provided camera interface, logs metadata and performance stats.
int	main (int argc, char **argv)
	Program entrypoint.

Detailed Description

Example application using the irsol library to initialize logging, connect to a camera, and capture a sequence of images.

This program serves as a minimal working example for new developers to understand how to interact with the core components of the irsol library. It demonstrates:

• Command-line argument parsing
• Logging setup and log level configuration
• Camera interface initialization
• Repeated image acquisition with basic performance metrics

Build system integration is expected to define PROGRAM_NAME for logging.

Definition in file main.cpp.

Macro Definition Documentation

PROGRAM_NAME

#define PROGRAM_NAME   "loading-images-demo"

Function Documentation

getParams()

Params getParams	(	int	argc,
		char **	argv
	)

Parses command-line arguments using args library.

Supported arguments:

• --log-level, -l: Set logging level (trace, debug, info, warn, error)
• --frames-count, -f: Set number of frames to capture
• --help, -h: Show help message and exit

Parameters

argc	Argument count
argv	Argument vector

Returns

Filled Params struct

Definition at line 54 of file main.cpp.

{
  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;
}

getProgramName()

const std::string getProgramName

(

)

Returns the program name, typically used for logging. If PROGRAM_NAME is not defined at compile time, returns "loading-images-demo".

Definition at line 22 of file main.cpp.

{
#ifndef PROGRAM_NAME
#define PROGRAM_NAME "loading-images-demo"
#endif
  return PROGRAM_NAME;
}

main()

int main	(	int	argc,
		char **	argv
	)

Program entrypoint.

• Initializes logging and assertions
• Selects camera resolution based on build mode
• Captures a user-defined number of frames
• Logs image statistics and performance

Definition at line 113 of file main.cpp.

{
  // 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;
}

runCapture()

void runCapture

(

irsol::camera::Interface &

cam

)

Captures a single image using the provided camera interface, logs metadata and performance stats.

Parameters

cam	Reference to an initialized irsol::camera::Interface instance.

Definition at line 95 of file main.cpp.

{
  auto image = cam.captureImage();
 
  if(image.IsEmpty()) {
    IRSOL_LOG_WARN("Image is empty.");
  }
 
  IRSOL_LOG_INFO("{}x{}, {} bytes", image.GetHeight(), image.GetWidth(), image.GetSize());
}