viewer_client_gi.cpp File Reference

Example client that repeatedly sends gi (get image) commands to the camera server. More...

#include "irsol/args.hpp"
#include "irsol/irsol.hpp"
#include <atomic>
#include <csignal>
#include <opencv2/opencv.hpp>
#include <optional>

Go to the source code of this file.

Functions
void	signalHandler (int signal)
std::optional< std::pair< size_t, cv::Mat > >	queryImage (irsol::types::connector_t &conn)
std::optional< irsol::types::connector_t >	createConnectionWithRetry (const std::string &host, irsol::types::port_t port, std::chrono::seconds retryTimeout=std::chrono::seconds(1))
void	run (double inFps)
int	main (int argc, char **argv)

Variables
std::atomic< bool >	g_terminate {false}

Detailed Description

Example client that repeatedly sends gi (get image) commands to the camera server.

This executable connects to the camera server and requests single image frames using the gi command. Each received image is displayed using OpenCV, and the measured FPS is annotated on the image.

Command-line options: -f, –fps <fps> Set the polling frequency (default: 0.5 FPS)

Usage: ./06-client-server-interaction-image-commands-viewer-gi [-f <fps>]

The client can be interrupted with Ctrl+C or by pressing 'q' in the OpenCV window. All logging is written to logs/viewer-client-gi.log.

Definition in file viewer_client_gi.cpp.

Function Documentation

createConnectionWithRetry()

std::optional< irsol::types::connector_t > createConnectionWithRetry	(	const std::string &	host,
		irsol::types::port_t	port,
		std::chrono::seconds	retryTimeout = std::chrono::seconds(1)
	)

Definition at line 142 of file viewer_client_gi.cpp.

{
  std::error_code ec;
  while(!g_terminate.load()) {
    irsol::types::connector_t conn({host, port}, ec);
    if(ec) {
      IRSOL_LOG_WARN(
        "Failed to connect to server at {}:{}: {}, retrying in {} seconds",
        host,
        port,
        ec.message(),
        retryTimeout.count());
      std::this_thread::sleep_for(retryTimeout);
      continue;
    } else {
      return std::move(conn);
    }
  }
  return std::nullopt;
}

main()

int main	(	int	argc,
		char **	argv
	)

Definition at line 284 of file viewer_client_gi.cpp.

{
  irsol::initLogging("logs/viewer-client-gi.log");
  irsol::initAssertHandler();
 
  // Register signal handler
  std::signal(SIGTERM, signalHandler);
  std::signal(SIGINT, signalHandler);  // Also handle Ctrl+C
 
  args::ArgumentParser    parser("TCP client viewer");
  args::HelpFlag          help(parser, "help", "Display this help menu", {'h', "help"});
  args::ValueFlag<double> listen_fps_flag(parser, "fps", "The FPS at which to listen.", {'f'});
  try {
    parser.ParseCLI(argc, argv);
  } catch(args::Help) {
    IRSOL_LOG_INFO("{0:s}", parser.Help());
    return 0;
  } catch(args::ParseError e) {
    IRSOL_LOG_ERROR("Error parsing command-line arguments: {}\n", e.what(), parser.Help());
    return 1;
  } catch(args::ValidationError e) {
    IRSOL_LOG_ERROR("Error parsing command-line arguments: {}\n", e.what(), parser.Help());
    return 1;
  }
  double listen_fps = 0.5;
  if(listen_fps_flag) {
    listen_fps = args::get(listen_fps_flag);
  }
 
  run(listen_fps);
}

queryImage()

std::optional< std::pair< size_t, cv::Mat > > queryImage

(

irsol::types::connector_t &

conn

)

Definition at line 41 of file viewer_client_gi.cpp.

{
  conn.write("gi\n");
 
  // Loop until we get the correct header start
  while(true) {
    std::string headerTitle;
    char        ch;
    while(true) {
      auto res = conn.read(&ch, 1);
      if(res.value() <= 0)
        return std::nullopt;
      if(ch == '\n' || ch == '=')
        break;
      headerTitle += ch;
    }
 
    if(headerTitle == "gi;") {
      IRSOL_LOG_INFO("Received success confirmation from server");
    } else if(headerTitle == "isn") {
      std::string isnStr;
      while(ch != '\n') {
        conn.read(&ch, 1);
        isnStr.insert(isnStr.end(), ch);
      }
      uint64_t isn = std::stoull(isnStr);
      IRSOL_LOG_INFO("Received input sequence number {}", isn);
    } else if(headerTitle == "img") {
      IRSOL_LOG_INFO("Received 'img' header");
 
      // --- Parse image metadata ---
      uint32_t imageHeight{0};
      uint32_t imageWidth{0};
 
      // Wait for SOH (start of header) byte
      while(true) {
        auto res = conn.read(&ch, 1);
        if(res.value() <= 0) {
          IRSOL_LOG_ERROR("Failed to read image metadata");
          return std::nullopt;
        }
        if(ch == irsol::utils::bytesToString({irsol::protocol::Serializer::SpecialBytes::SOH})[0]) {
          break;
        }
      }
 
      // Parse image shape: [height,width]
      while(ch != '[') {
        conn.read(&ch, 1);
      }
      std::string heightStr;
      while(ch != ',') {
        conn.read(&ch, 1);
        heightStr.insert(heightStr.end(), ch);
      }
      imageHeight = std::stol(heightStr);
 
      std::string widthStr;
      while(ch != ']') {
        conn.read(&ch, 1);
        widthStr.insert(widthStr.end(), ch);
      }
      imageWidth = std::stol(widthStr);
 
      // Skip image attributes until STX (start of text) byte
      while(ch !=
            irsol::utils::bytesToString({irsol::protocol::Serializer::SpecialBytes::STX})[0]) {
        conn.read(&ch, 1);
      }
 
      // --- Read image data ---
      uint64_t             expectedSize = imageHeight * imageWidth * 2;  // 2 bytes per pixel
      std::vector<uint8_t> buffer(expectedSize);
 
      size_t totalRead = 0;
      while(totalRead < expectedSize) {
        auto res = conn.read(buffer.data() + totalRead, expectedSize - totalRead);
        if(res.value() <= 0) {
          IRSOL_LOG_ERROR("Error reading image data");
          return std::nullopt;
        }
        totalRead += res.value();
      }
 
      // --- Convert image data to OpenCV Mat ---
      return std::make_pair(
        1, irsol::opencv::createCvMatFromIrsolServerBuffer(buffer.data(), imageHeight, imageWidth));
    } else {
 
      IRSOL_LOG_WARN("Skipping unknown header: '{}'", headerTitle);
      // Skip the rest of the line
      while(ch != '\n') {
        auto res = conn.read(&ch, 1);
        if(res.value() <= 0)
          return std::nullopt;
      }
    }
  }
}

run()

void run

(

double

inFps

)

Definition at line 167 of file viewer_client_gi.cpp.

{
 
  IRSOL_LOG_INFO("TCP client viewer (gi)");
 
  std::string          server_host = "localhost";
  irsol::types::port_t port        = 15099;  // port used by existing clients
 
  sockpp::initialize();
 
  irsol::types::connector_t conn;
  if(auto connOpt = createConnectionWithRetry(server_host, port); !connOpt.has_value()) {
    return;
  } else {
    conn = std::move(connOpt.value());
  }
 
  IRSOL_LOG_INFO("Connected to server");
 
  // Set a timeout for the responses
  if(auto res = conn.read_timeout(std::chrono::seconds(10)); !res) {
    IRSOL_LOG_ERROR("Error setting TCP read timeout: {}", res.error_message());
  } else {
    IRSOL_LOG_DEBUG("Read timeout set to 10 seconds");
  }
 
  auto lastTimeShown = irsol::types::clock_t::now() - std::chrono::seconds(1000);
 
  bool firstFrame = true;
 
  // Start listening for incoming images
 
  IRSOL_LOG_INFO("Starting frame polling with FPS: {}", inFps);
 
  while(!g_terminate.load()) {
    auto frameStart = irsol::types::clock_t::now();
 
    // --- Query image ---
    auto imageOpt = queryImage(conn);
 
    if(!imageOpt.has_value()) {
      IRSOL_LOG_ERROR("Failed to receive image, waiting 1 second..");
      std::this_thread::sleep_for(std::chrono::seconds(1));
      continue;
    }
 
    auto [imageId, image] = std::move(imageOpt.value());
    if(image.empty()) {
      IRSOL_LOG_INFO("Received empty image, waiting 1 second..");
      std::this_thread::sleep_for(std::chrono::seconds(1));
      continue;
    }
 
    // --- Annotate ---
    if(firstFrame) {
      IRSOL_LOG_INFO(
        "Image {} received: {}x{} with {} channels",
        imageId,
        image.rows,
        image.cols,
        image.channels());
      firstFrame = false;
    }
 
    cv::putText(
      image,
      "ImageID: " + std::to_string(imageId),
      {20, 80},
      cv::FONT_HERSHEY_COMPLEX,
      1.0,
      {irsol::camera::Pixel<16>::max(),
       irsol::camera::Pixel<16>::max(),
       irsol::camera::Pixel<16>::max()},
      1,
      cv::LINE_AA);
 
    // Show current measured FPS
    auto   frameNow  = irsol::types::clock_t::now();
    double actualFps = 1.0 / std::chrono::duration<double>(frameNow - lastTimeShown).count();
    lastTimeShown    = frameNow;
 
    IRSOL_LOG_DEBUG("Measured FPS: {:.2f}", actualFps);
 
    cv::putText(
      image,
      "Measured FPS: " + std::to_string(actualFps),
      {20, 160},
      cv::FONT_HERSHEY_COMPLEX,
      1.0,
      {irsol::camera::Pixel<16>::max(),
       irsol::camera::Pixel<16>::max(),
       irsol::camera::Pixel<16>::max()},
      1,
      cv::LINE_AA);
 
    // --- Display ---
    cv::imshow("Viewer", image);
    int key = cv::waitKey(1) & 0xFF;
    if(key == 27 || key == 'q') {
      IRSOL_LOG_INFO("Exit requested via keyboard");
      g_terminate.store(true);
    }
 
    // --- Frame duration regulation ---
    auto frameEnd      = irsol::types::clock_t::now();
    auto frameDuration = frameEnd - frameStart;
 
    auto desiredFrameTime = std::chrono::microseconds(static_cast<int64_t>(1'000'000.0 / inFps));
    if(frameDuration < desiredFrameTime) {
      std::this_thread::sleep_for(desiredFrameTime - frameDuration);
    }
  }
 
  IRSOL_LOG_INFO("Exiting viewer");
}

signalHandler()

void signalHandler

(

int

signal

)

Definition at line 32 of file viewer_client_gi.cpp.

{
  if(signal == SIGTERM || signal == SIGINT) {
    IRSOL_LOG_INFO("Signal {} received, shutting down gracefully...", signal);
    g_terminate = true;
  }
}

Variable Documentation

g_terminate

std::atomic<bool> g_terminate {false}

Definition at line 28 of file viewer_client_gi.cpp.

{false};