config.hpp

Go to the documentation of this file.

 
#ifndef CAMCOM_TESTBENCH_CONFIG_HPP
#define CAMCOM_TESTBENCH_CONFIG_HPP
 
#include <string>
#include <map>
#include <vector>
#include <optional>
 
namespace camcom::server {

struct AdapterConfig {
    std::string library;                          // Required: library name (e.g., "libcamcom_genicam_arv.so")
    std::string class_name;                       // Optional: adapter class name
    std::string factory_symbol{"CreateAdapter"};  // Optional: factory function name
    bool auto_connect{false};                     // Optional: auto-connect on server start
    std::string profile;                          // Optional: GenICam XML profile path (for emulator)
    std::map<std::string, std::string> preconfig; // Optional: camera-specific params to set on connect
    std::map<std::string, std::string> properties; // Optional: adapter-specific properties passed via Initialise()
};

using SetValues = std::map<std::string, std::string>;

struct HttpServerConfig {
    std::string host{"0.0.0.0"};
    int port{8080};
    std::optional<std::string> basic_auth; // Optional: "user:hash"
};

struct WebInterfaceConfig {
    bool enabled{true};
    int max_image_width{640};
    int max_image_height{480};
    int max_fps{5};
    std::string compression{"raw"}; // "raw" (native pixels) or "jpeg" (legacy 8-bit)
    int quality{85}; // JPEG quality 0-100
};

struct StreamingConfig {
    bool enabled{false};
    std::string protocol{"websocket"}; // "websocket", "webrtc", "rtsp"
};

struct RecordingConfig {
    std::string directory;                      // Output directory
    std::string format{"fits"};                 // fits, fits:cube, fits:mef
    std::string compression{"none"};            // none, rice, gzip, hcompress, plio
    std::string file_id{"CamCom"};              // User-defined file identifier
    std::string filename_pattern{"${file_id}_${camera_name}_${timestamp}_${frame_id}.fits"};
    // Stop conditions (0 = disabled, recording stops when ANY enabled limit is reached)
    int nb_of_frames{10};                       // Max frames to record
    double period{0};                           // Max duration in seconds
    int max_size{0};                            // Max size in MB
    // Recording buffer
    int max_frames_buffer{100};                 // Max frames queued for recording
    bool skip_silently{true};                   // true = drop silently; false = log every 10s
    std::string overwrite_policy{"increment"};  // overwrite, increment
    bool cube_timestamp_table{false};           // Write a binary table with per-frame timestamps (cube mode)
    // Scheduled recording
    std::string trigger{"immediate"};           // immediate, delay, absolute
    int delay{0};                               // Delay in seconds (trigger=delay)
    std::string start_time;                     // ISO8601 time (trigger=absolute)
};

struct TelemetryConfig {
    bool enabled{true};                       // Toggle telemetry sampling on/off
    double sampling_period{2.0};              // Seconds between samples
    bool disable_during_acquisition{false};   // Pause sampling while acquiring
    bool disable_during_recording{false};     // Pause sampling while recording
    bool sample_read_only_pars{true};         // Auto-sample parameters with write_access=false
    std::vector<std::string> parameters;      // Explicit list of extra parameters to sample
    int history_depth{100};                   // Samples to keep per parameter
};

struct StatisticsConfig {
    bool enabled{true};            // Toggle statistics computation on/off
    int window_size{100};          // Number of samples in the sliding window
};

struct LoggingConfig {
    std::string level{"INFO"};
    std::optional<std::string> file;
    std::string rotation{"daily"}; // "daily", "weekly", "size"
    int max_files{7};
};

struct SetupConfig {
    // Auto-adjust exposure/frame_rate when contradictory (uses BasicParams from adapter)
    bool auto_adjust_expo_time_rate{true};
    // Stop acquisition around parameter writes and restart afterwards if it was active
    bool auto_stop_acq_on_par_write{false};
    // Skip write-protected parameters with a warning instead of failing
    bool ignore_write_protected_pars{false};
};

struct AcquisitionConfig {
    int frame_queue_size{10};      // Max frames in the capture->publisher queue
    bool skip_silently{true};      // true = drop frames silently when queue full; false = warn every 10s with drop count
};

struct GuiConfig {
    bool start_srv{true};                 // Auto-start server on GUI launch
    std::string srv_config{};             // Server config to use (if empty, use current config)
    bool auto_restart{true};              // Auto-restart server on crash
    int restart_timeout{5};               // Seconds before restart attempt
    std::string log_level{"INFO"};        // GUI log level
    std::string log_file{};               // Log file path (empty = no file)
    double statistics_poll_period{2.0};   // Seconds between GUI statistics fetches
    std::vector<std::string> primary_parameters; // Parameters shown first in Set Values tab
    // Note: server_host, server_port, connection_timeout come from http_server config
};

struct ServerConfig {
    // Included config files (processed first, then overridden by main config)
    std::vector<std::string> includes;
 
    // CamCom section
    std::string camera_name;
    std::string uri;
    int timeout{10}; // seconds
 
    // Component configs
    AdapterConfig adapter;
    SetValues set_values;
    SetValues initial_set_values;  // Original values from config file, for reset
    SetupConfig setup;
    HttpServerConfig http_server;
    WebInterfaceConfig web_interface;
    StreamingConfig streaming;
    AcquisitionConfig acquisition;
    RecordingConfig recording;
    TelemetryConfig telemetry;
    StatisticsConfig statistics;
    LoggingConfig logging;
    GuiConfig gui;
};

ServerConfig loadConfig(const std::string& filename, bool require_camcom = true, const std::string& base_dir = "");

bool validateConfig(const ServerConfig& config);
 
} // namespace camcom::server
 
#endif // CAMCOM_TESTBENCH_CONFIG_HPP