sarSettingsRecord.h

Go to the documentation of this file.

/*****************************************************************************
 * Copyright (c) 2025 MAK Technologies
 * All rights reserved.
 *****************************************************************************/
 
//! \file sarSettingsRecord.h
//! \brief Defines the settings record for storing SAR configuration data
//! \ingroup sarClient
 
#pragma once
 
#include "sarClientPlugin.h"
 
#include <makArchives/makArchives.h>
 
namespace makVre
{
//! \brief Settings record for storing SAR configuration data
//!
//! DtSarSettingsRecord stores all configuration settings related to
//! Synthetic Aperture Radar (SAR) imagery. It provides storage for ownship
//! and target positions, image parameters, server settings, and other
//! SAR-specific options. This class is used for persisting settings and
//! transferring them between components.
//! \ingroup sarClient
class DT_DLL_sarClient DtSarSettingsRecord
{
public:
   //! \brief Enumeration for ownship positioning modes
   enum OwnshipMode
   {
      OwnshipModeEntity,   //!< Use an entity as the ownship position source
      OwnshipModeObserver, //!< Use an observer as the ownship position source
      OwnshipModeAbsolute  //!< Use absolute coordinates as the ownship position
   };
 
   //! \brief Enumeration for target positioning modes
   enum TargetMode
   {
      TargetModeEntity,     //!< Use an entity as the target position source
      TargetModeObserver,   //!< Use an observer as the target position source
      TargetModeAbsolute,   //!< Use absolute coordinates as the target position
      TargetModeMouseClick, //!< Use mouse-clicked position as the target position
      TargetModeSensor      //!< Use a sensor as the target position source
   };
 
   //! \brief Default constructor
   //!
   //! Initializes all settings to their default values
   DtSarSettingsRecord();
 
   //! \brief Copy constructor
   //! \param orig Source record to copy from
   //!
   //! Creates a new record that is a copy of the original
   DtSarSettingsRecord(const DtSarSettingsRecord& orig);
 
   //! \brief Assignment operator
   //! \param orig Source record to assign from
   //! \return Reference to this record
   //!
   //! Copies all settings from the original record
   DtSarSettingsRecord& operator=(const DtSarSettingsRecord& orig);
 
   //! \brief Virtual destructor
   virtual ~DtSarSettingsRecord();
 
   //! \brief Sets the ownship mode
   //! \param val Mode value (typically 0=Entity, 1=Observer, 2=Absolute Position)
   virtual void setOwnshipMode(int val);
 
   //! \brief Gets the current ownship mode
   //! \return Current ownship mode value
   virtual int ownshipMode() const;
 
   //! \brief Sets the ownship entity name
   //! \param val Entity name for the ownship
   virtual void setOwnshipEntityName(const std::string& val);
 
   //! \brief Gets the current ownship entity name
   //! \return Current ownship entity name
   virtual const std::string& ownshipEntityName() const;
 
   //! \brief Sets the ownship observer name
   //! \param val Observer name for the ownship
   virtual void setOwnshipObserverName(const std::string& val);
 
   //! \brief Gets the current ownship observer name
   //! \return Current ownship observer name
   virtual const std::string& ownshipObserverName() const;
 
   //! \brief Sets the ownship absolute latitude
   //! \param val Latitude value
   virtual void setOwnshipAbsoluteLat(double val);
 
   //! \brief Gets the current ownship absolute latitude
   //! \return Current ownship latitude
   virtual double ownshipAbsoluteLat() const;
 
   //! \brief Sets the ownship absolute longitude
   //! \param val Longitude value
   virtual void setOwnshipAbsoluteLon(double val);
 
   //! \brief Gets the current ownship absolute longitude
   //! \return Current ownship longitude
   virtual double ownshipAbsoluteLon() const;
 
   //! \brief Sets the ownship absolute altitude
   //! \param val Altitude value
   virtual void setOwnshipAbsoluteAlt(double val);
 
   //! \brief Gets the current ownship absolute altitude
   //! \return Current ownship altitude
   virtual double ownshipAbsoluteAlt() const;
 
   //! \brief Sets the target mode
   //! \param val Mode value (typically 0=Entity, 1=Observer, 2=Absolute Position, 3=MouseClick, 4=Sensor)
   virtual void setTargetMode(int val);
 
   //! \brief Gets the current target mode
   //! \return Current target mode value
   virtual int targetMode() const;
 
   //! \brief Sets the target entity name
   //! \param val Entity name for the target
   virtual void setTargetEntityName(const std::string& val);
 
   //! \brief Gets the current target entity name
   //! \return Current target entity name
   virtual const std::string& targetEntityName() const;
 
   //! \brief Sets the target observer name
   //! \param val Observer name for the target
   virtual void setTargetObserverName(const std::string& val);
 
   //! \brief Gets the current target observer name
   //! \return Current target observer name
   virtual const std::string& targetObserverName() const;
 
   //! \brief Sets the target sensor name
   //! \param val Sensor name for the target
   virtual void setTargetSensorName(const std::string& val);
 
   //! \brief Gets the current target sensor name
   //! \return Current target sensor name
   virtual const std::string& targetSensorName() const;
 
   //! \brief Sets the target absolute latitude
   //! \param val Latitude value
   virtual void setTargetAbsoluteLat(double val);
 
   //! \brief Gets the current target absolute latitude
   //! \return Current target latitude
   virtual double targetAbsoluteLat() const;
 
   //! \brief Sets the target absolute longitude
   //! \param val Longitude value
   virtual void setTargetAbsoluteLon(double val);
 
   //! \brief Gets the current target absolute longitude
   //! \return Current target longitude
   virtual double targetAbsoluteLon() const;
 
   //! \brief Sets the target absolute altitude
   //! \param val Altitude value
   virtual void setTargetAbsoluteAlt(double val);
 
   //! \brief Gets the current target absolute altitude
   //! \return Current target altitude
   virtual double targetAbsoluteAlt() const;
 
   //! \brief Sets the image X dimension (width)
   //! \param val Width in pixels
   virtual void setImageSizeX(int val);
 
   //! \brief Gets the current image X dimension
   //! \return Current image width in pixels
   virtual int imageSizeX() const;
 
   //! \brief Sets the image Y dimension (height)
   //! \param val Height in pixels
   virtual void setImageSizeY(int val);
 
   //! \brief Gets the current image Y dimension
   //! \return Current image height in pixels
   virtual int imageSizeY() const;
 
   //! \brief Sets the image rotation
   //! \param val Rotation angle in degrees
   virtual void setImageRotation(int val);
 
   //! \brief Gets the current image rotation
   //! \return Current image rotation in degrees
   virtual int imageRotation() const;
 
   //! \brief Sets the image format
   //! \param val Image format index
   virtual void setImageFormat(int val);
 
   //! \brief Gets the current image format
   //! \return Current image format index
   virtual int imageFormat() const;
 
   //! \brief Sets the image data type
   //! \param val Image data type index
   virtual void setImageDataType(int val);
 
   //! \brief Gets the current image data type
   //! \return Current image data type index
   virtual int imageDataType() const;
 
   //! \brief Sets the sensor to use for SAR imagery
   //! \param val Sensor name
   virtual void setSensorToUse(const std::string& val);
 
   //! \brief Gets the current sensor used for SAR imagery
   //! \return Current sensor name
   virtual const std::string& sensorToUse() const;
 
   //! \brief Sets whether to save SAR images on the server
   //! \param val True to save on server, false otherwise
   virtual void setSaveOnServer(bool val);
 
   //! \brief Gets whether SAR images are saved on the server
   //! \return True if saving on server is enabled, false otherwise
   virtual bool saveOnServer() const;
 
   //! \brief Sets the path where images are saved on the server
   //! \param val Server save path
   virtual void setServerSavePath(const std::string& val);
 
   //! \brief Gets the current server save path
   //! \return Path where images are saved on the server
   virtual const std::string& serverSavePath() const;
 
   //! \brief Sets the radar power level
   //! \param val Power level value
   virtual void setPower(double val);
 
   //! \brief Gets the current radar power level
   //! \return Current power level
   virtual double power() const;
 
   //! \brief Sets whether Automatic Gain Control is enabled for power
   //! \param isAgcPowerEnabled True to enable AGC, false otherwise
   virtual void setIsAgcPowerEnabled(bool isAgcPowerEnabled);
 
   //! \brief Gets whether Automatic Gain Control is enabled for power
   //! \return True if AGC is enabled, false otherwise
   virtual bool isAgcPowerEnabled() const;
 
   //! \brief Sets the crossrange distance
   //! \param val Crossrange value in meters
   virtual void setCrossrange(double val);
 
   //! \brief Gets the current crossrange distance
   //! \return Current crossrange in meters
   virtual double crossrange() const;
 
   //! \brief Sets the downrange distance
   //! \param val Downrange value in meters
   virtual void setDownrange(double val);
 
   //! \brief Gets the current downrange distance
   //! \return Current downrange in meters
   virtual double downrange() const;
 
   //! \brief Sets the ownship speed
   //! \param speed Speed value in meters per second
   //!
   //! Speed of the observer when the SAR image is requested
   void setOwnshipSpeed(float speed);
 
   //! \brief Gets the current ownship speed
   //! \return Current ownship speed in meters per second
   float ownshipSpeed() const;
 
   //! \brief Sets the RadarFx server IP address
   //! \param val IP address string
   virtual void setServerIp(const std::string& val);
 
   //! \brief Gets the current RadarFx server IP address
   //! \return Current server IP address
   virtual const std::string& serverIp() const;
 
   //! \brief Sets the RadarFx server port
   //! \param val Port number
   virtual void setServerPort(int val);
 
   //! \brief Gets the current RadarFx server port
   //! \return Current server port number
   virtual int serverPort() const;
 
   //! \brief Sets whether to automatically open the SAR response window
   //! \param val True to open window, false otherwise
   virtual void setOpenSarResponseWindow(bool val);
 
   //! \brief Gets whether the SAR response window opens automatically
   //! \return True if window opens automatically, false otherwise
   virtual bool openSarResponseWindow() const;
 
protected:
   //! \brief Grants access to boost serialization
   friend class boost::serialization::access;
 
   //! \brief Serializes the settings record to/from an archive
   //! \tparam Archive Type of archive (input or output)
   //! \param ar Reference to the archive
   //! \param version Version number for the serialization format
   //!
   //! When the Archive corresponds to an output archive, the & operator
   //! is defined similar to <<. Likewise, when the Archive is a type of
   //! input archive, the & operator is defined similar to >>.
   template <class Archive>
   void serialize(Archive& ar, const unsigned int version)
   {
      ar& BOOST_SERIALIZATION_NVP(myOwnshipMode);
      ar& BOOST_SERIALIZATION_NVP(myOwnshipEntityName);
      ar& BOOST_SERIALIZATION_NVP(myOwnshipObserverName);
      ar& BOOST_SERIALIZATION_NVP(myOwnshipAbsoluteLat);
      ar& BOOST_SERIALIZATION_NVP(myOwnshipAbsoluteLon);
      ar& BOOST_SERIALIZATION_NVP(myOwnshipAbsoluteAlt);
 
      ar& BOOST_SERIALIZATION_NVP(myTargetMode);
      ar& BOOST_SERIALIZATION_NVP(myTargetEntityName);
      ar& BOOST_SERIALIZATION_NVP(myTargetObserverName);
      ar& BOOST_SERIALIZATION_NVP(myTargetSensorName);
      ar& BOOST_SERIALIZATION_NVP(myTargetAbsoluteLat);
      ar& BOOST_SERIALIZATION_NVP(myTargetAbsoluteLon);
      ar& BOOST_SERIALIZATION_NVP(myTargetAbsoluteAlt);
 
      ar& BOOST_SERIALIZATION_NVP(myImageSizeX);
      ar& BOOST_SERIALIZATION_NVP(myImageSizeY);
      ar& BOOST_SERIALIZATION_NVP(myImageRotation);
      ar& BOOST_SERIALIZATION_NVP(myImageFormat);
      ar& BOOST_SERIALIZATION_NVP(myImageDataType);
      ar& BOOST_SERIALIZATION_NVP(mySensorToUse);
 
      ar& BOOST_SERIALIZATION_NVP(mySaveOnServer);
      ar& BOOST_SERIALIZATION_NVP(myServerSavePath);
 
      ar& BOOST_SERIALIZATION_NVP(myIsAgcPowerEnabled);
      ar& BOOST_SERIALIZATION_NVP(myPower);
 
      ar& BOOST_SERIALIZATION_NVP(myCrossrange);
      ar& BOOST_SERIALIZATION_NVP(myDownrange);
 
      ar& BOOST_SERIALIZATION_NVP(myServerIp);
      ar& BOOST_SERIALIZATION_NVP(myServerPort);
 
      ar& BOOST_SERIALIZATION_NVP(myOwnshipSpeed);
 
      ar& BOOST_SERIALIZATION_NVP(myOpenSarResponseWindow);
   }
 
protected:
   //! \brief Ownship positioning mode
   //! 1=simulated entity location
   //! 2=observer location
   //! 3=geodetic (deg) location
   int myOwnshipMode;
 
   //! \brief Name of the entity to use for ownship positioning
   std::string myOwnshipEntityName;
 
   //! \brief Name of the observer to use for ownship positioning
   std::string myOwnshipObserverName;
 
   //! \brief Absolute latitude for ownship positioning (degrees)
   double myOwnshipAbsoluteLat;
 
   //! \brief Absolute longitude for ownship positioning (degrees)
   double myOwnshipAbsoluteLon;
 
   //! \brief Absolute altitude for ownship positioning (meters)
   double myOwnshipAbsoluteAlt;
 
   //! \brief Target positioning mode
   //! 1=simulated entity location
   //! 2=observer location
   //! 3=geodetic (deg) location
   //! 4=mouse click location
   //! 5=sensor location
   int myTargetMode;
 
   //! \brief Name of the entity to use for target positioning
   std::string myTargetEntityName;
 
   //! \brief Name of the observer to use for target positioning
   std::string myTargetObserverName;
 
   //! \brief Name of the sensor to use for target positioning
   std::string myTargetSensorName;
 
   //! \brief Absolute latitude for target positioning (degrees)
   double myTargetAbsoluteLat;
 
   //! \brief Absolute longitude for target positioning (degrees)
   double myTargetAbsoluteLon;
 
   //! \brief Absolute altitude for target positioning (meters)
   double myTargetAbsoluteAlt;
 
   //! \brief Image width in pixels
   int myImageSizeX;
 
   //! \brief Image height in pixels
   int myImageSizeY;
 
   //! \brief Image rotation in degrees
   int myImageRotation;
 
   //! \brief Image format index
   int myImageFormat;
 
   //! \brief Image data type index
   int myImageDataType;
 
   //! \brief Name of the sensor to use for imaging
   std::string mySensorToUse;
 
   //! \brief Flag indicating if images should be saved on the server
   bool mySaveOnServer;
 
   //! \brief Path where images are saved on the server
   std::string myServerSavePath;
 
   //! \brief Flag indicating if Automatic Gain Control is enabled for power
   bool myIsAgcPowerEnabled;
 
   //! \brief Radar power level
   double myPower;
 
   //! \brief Downrange distance in meters
   //!
   //! Distance in direction of aircraft heading
   double myDownrange;
 
   //! \brief Crossrange distance in meters
   //!
   //! Distance perpendicular to aircraft heading
   double myCrossrange;
 
   //! \brief Ownship speed in meters per second when SAR image is requested
   float myOwnshipSpeed;
 
   //! \brief RadarFx server IP address
   std::string myServerIp;
 
   //! \brief RadarFx server port number
   int myServerPort;
 
   //! \brief Flag indicating if SAR response window should automatically open
   bool myOpenSarResponseWindow;
};
 
} // namespace makVre
 
//! \brief Set the version number for boost serialization of DtSarSettingsRecord
//!
//! This macro sets the version number to 0 for the class's serialization format
BOOST_CLASS_VERSION(makVre::DtSarSettingsRecord, 0)