sarSettingsManager.h

Go to the documentation of this file.

/*****************************************************************************
 * Copyright (c) 2025 MAK Technologies
 * All rights reserved.
 *****************************************************************************/
 
//! \file sarSettingsManager.h
//! \brief Defines the settings manager for SAR configuration
//! \ingroup sarClient
 
#pragma once
 
#include "sarClientPlugin.h"
#include "sarSettingsRecord.h"
 
#include <vrvCore/DtElementData.h>
#include <vrvUtil/DtBaseSettingsManager.h>
 
#include <matrix/vlVector.h>
 
namespace makVrv
{
//! \brief Forward declaration of the display element class
class DtDe;
 
//! \brief Forward declaration of the observer class
class DtObserver;
 
//! \brief Forward declaration of the record settings backup interface
class DtRecordSettingsBackupInterface;
} // namespace makVrv
 
namespace makVre
{
//! \brief Type definition for entity name-ID pairs
using DtEntityNameIdPair = std::pair<std::string, std::string>;
 
//! \brief Type definition for a collection of entity name-ID pairs
using DtEntityNameIdPairs = std::vector<DtEntityNameIdPair>;
 
//! \brief Manager for SAR settings configuration
//!
//! DtSarSettingsManager is responsible for maintaining SAR settings state,
//! providing validation, and notifying interested components of changes to settings.
//! It manages ownship and target configurations, image parameters, server settings,
//! and other SAR-specific options required for synthetic aperture radar imagery.
//! \ingroup sarClient
class DT_DLL_sarClient DtSarSettingsManager : public makVrv::DtBaseSettingsManager<DtSarSettingsRecord>
{
public:
   //! \brief Gets the singleton instance of the settings manager
   //! \param de Reference to the display element
   //! \return Reference to the singleton instance
   //!
   //! This method implements the singleton pattern, creating the instance if it doesn't exist
   static DtSarSettingsManager& instance(makVrv::DtDe& de);
 
   //! \brief Virtual destructor
   virtual ~DtSarSettingsManager() override;
 
   //! \brief Initializes the settings manager
   //! \param de Reference to the display element
   //! \return True if initialization was successful, false otherwise
   virtual bool initialize(makVrv::DtDe& de);
 
   //! \brief Checks if the ownship configuration is valid
   //! \return True if ownship settings are valid, false otherwise
   virtual bool ownshipIsValid();
 
   //! \brief Checks if the target configuration is valid
   //! \return True if target settings are valid, false otherwise
   virtual bool targetIsValid();
 
   //! \brief Updates the settings validity state and notifies listeners
   //!
   //! Validates all settings and emits appropriate signals if validity changes
   virtual void updateSettingsAreValid();
 
   //! @name Setters/getters for settings
   //! @{
 
   //! \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 Checks if entity mode is active for ownship
   //! \return True if ownship mode is set to entity, false otherwise
   virtual bool useEntityAsOwnship() const { return ownshipMode() == DtSarSettingsRecord::OwnshipModeEntity; };
 
   //! \brief Checks if observer mode is active for ownship
   //! \return True if ownship mode is set to observer, false otherwise
   virtual bool useObserverAsOwnship() const { return ownshipMode() == DtSarSettingsRecord::OwnshipModeObserver; };
 
   //! \brief Checks if absolute position mode is active for ownship
   //! \return True if ownship mode is set to absolute position, false otherwise
   virtual bool useAbsoluteAsOwnship() const { return ownshipMode() == DtSarSettingsRecord::OwnshipModeAbsolute; };
 
   //! \brief Checks if entity mode is active for target
   //! \return True if target mode is set to entity, false otherwise
   virtual bool useEntityAsTarget() const { return targetMode() == DtSarSettingsRecord::TargetModeEntity; };
 
   //! \brief Checks if sensor mode is active for target
   //! \return True if target mode is set to sensor, false otherwise
   virtual bool useSensorAsTarget() const { return targetMode() == DtSarSettingsRecord::TargetModeSensor; };
 
   //! \brief Checks if absolute position mode is active for target
   //! \return True if target mode is set to absolute position, false otherwise
   virtual bool useAbsoluteAsTarget() const { return targetMode() == DtSarSettingsRecord::TargetModeAbsolute; };
 
   //! \brief Checks if mouse click mode is active for target
   //! \return True if target mode is set to mouse click, false otherwise
   virtual bool useMouseClickAsTarget() const { return targetMode() == DtSarSettingsRecord::TargetModeMouseClick; };
 
   //! \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 ownship absolute location vector
   //! \param val Vector containing lat/lon/alt coordinates
   virtual void setOwnshipAbsoluteLocation(const DtVector& val);
 
   //! \brief Gets the current ownship absolute location vector
   //! \return Current ownship location as a vector
   virtual DtVector ownshipAbsoluteLocation() const;
 
   //! \brief Sets the target mode
   //! \param val Mode value (typically 0=Entity, 1=Sensor, 2=Absolute Position, 3=MouseClick)
   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 target absolute location vector
   //! \param val Vector containing lat/lon/alt coordinates
   virtual void setTargetAbsoluteLocation(const DtVector& val);
 
   //! \brief Gets the current target absolute location vector
   //! \return Current target location as a vector
   virtual DtVector targetAbsoluteLocation() 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 whether Automatic Gain Control is enabled for power
   //! \param val True to enable AGC, false otherwise
   virtual void setIsAcgPowerEnabled(bool val);
 
   //! \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 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 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 val Speed value in meters per second
   virtual void setOwnshipSpeed(float val);
 
   //! \brief Gets the current ownship speed
   //! \return Current ownship speed in meters per second
   virtual 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;
 
   //! @}
 
   //! \brief Sets the connection status to RadarFx server
   //! \param connected True if connected, false otherwise
   virtual void setIsConnected(bool connected);
 
   //! \brief Gets the current connection status to RadarFx server
   //! \return True if connected, false otherwise
   virtual bool isConnected() const;
 
   //! @name Boost signals for changed settings
   //! @{
   //! \brief Signal emitted when ownship mode changes
   boost::signalslib::signal<void(int)> signal_ownshipModeSet;
 
   //! \brief Signal emitted when ownship entity name changes
   boost::signalslib::signal<void(std::string)> signal_ownshipEntityNameSet;
 
   //! \brief Signal emitted when ownship observer name changes
   boost::signalslib::signal<void(std::string)> signal_ownshipObserverNameSet;
 
   //! \brief Signal emitted when ownship absolute latitude changes
   boost::signalslib::signal<void(double)> signal_ownshipAbsoluteLatSet;
 
   //! \brief Signal emitted when ownship absolute longitude changes
   boost::signalslib::signal<void(double)> signal_ownshipAbsoluteLonSet;
 
   //! \brief Signal emitted when ownship absolute altitude changes
   boost::signalslib::signal<void(double)> signal_ownshipAbsoluteAltSet;
 
   //! \brief Signal emitted when target mode changes
   boost::signalslib::signal<void(int)> signal_targetModeSet;
 
   //! \brief Signal emitted when target entity name changes
   boost::signalslib::signal<void(std::string)> signal_targetEntityNameSet;
 
   //! \brief Signal emitted when target observer name changes
   boost::signalslib::signal<void(std::string)> signal_targetObserverNameSet;
 
   //! \brief Signal emitted when target sensor name changes
   boost::signalslib::signal<void(std::string)> signal_targetSensorNameSet;
 
   //! \brief Signal emitted when target absolute latitude changes
   boost::signalslib::signal<void(double)> signal_targetAbsoluteLatSet;
 
   //! \brief Signal emitted when target absolute longitude changes
   boost::signalslib::signal<void(double)> signal_targetAbsoluteLonSet;
 
   //! \brief Signal emitted when target absolute altitude changes
   boost::signalslib::signal<void(double)> signal_targetAbsoluteAltSet;
 
   //! \brief Signal emitted when image X size changes
   boost::signalslib::signal<void(int)> signal_imageSizeXSet;
 
   //! \brief Signal emitted when image Y size changes
   boost::signalslib::signal<void(int)> signal_imageSizeYSet;
 
   //! \brief Signal emitted when image rotation changes
   boost::signalslib::signal<void(int)> signal_imageRotationSet;
 
   //! \brief Signal emitted when image format changes
   boost::signalslib::signal<void(int)> signal_imageFormatSet;
 
   //! \brief Signal emitted when image data type changes
   boost::signalslib::signal<void(int)> signal_imageDataTypeSet;
 
   //! \brief Signal emitted when sensor to use changes
   boost::signalslib::signal<void(std::string)> signal_sensorToUseSet;
 
   //! \brief Signal emitted when save on server setting changes
   boost::signalslib::signal<void(bool)> signal_saveOnServerSet;
 
   //! \brief Signal emitted when server save path changes
   boost::signalslib::signal<void(std::string)> signal_serverSavePathSet;
 
   //! \brief Signal emitted when AGC power enabled setting changes
   boost::signalslib::signal<void(double)> signal_isAgcPowerEnabledSet;
 
   //! \brief Signal emitted when radar power changes
   boost::signalslib::signal<void(double)> signal_powerSet;
 
   //! \brief Signal emitted when downrange changes
   boost::signalslib::signal<void(double)> signal_downrangeSet;
 
   //! \brief Signal emitted when crossrange changes
   boost::signalslib::signal<void(double)> signal_crossrangeSet;
 
   //! \brief Signal emitted when ownship speed changes
   boost::signalslib::signal<void(double)> signal_ownshipSpeedSet;
 
   //! \brief Signal emitted when server IP changes
   boost::signalslib::signal<void(std::string)> signal_serverIpSet;
 
   //! \brief Signal emitted when server port changes
   boost::signalslib::signal<void(int)> signal_serverPortSet;
 
   //! \brief Signal emitted when open SAR response window setting changes
   boost::signalslib::signal<void(bool)> signal_openSarResponseWindowSet;
 
   //! \brief Signal emitted when RadarFx connection status changes
   //!
   //! Used to update connection status text in SAR Settings dialog
   boost::signalslib::signal<void(bool)> signal_isConnectedSet;
 
   //! \brief Signal emitted when settings validity changes
   //! \param valid Whether the settings are valid
   //! \param tooltip Error message explaining why settings are invalid
   boost::signalslib::signal<void(bool, const std::string&)> signal_areSettingsValid;
 
   //! \brief Signal emitted when the list of valid ownship entities changes
   boost::signalslib::signal<void(const std::vector<std::string>&)> signal_validOwnshipEntitiesChanged;
 
   //! \brief Signal emitted when the list of valid target entities changes
   boost::signalslib::signal<void(const std::vector<std::string>&)> signal_validTargetEntitiesChanged;
 
   //! \brief Signal emitted when the list of valid observers changes
   boost::signalslib::signal<void(const std::vector<std::string>&)> signal_validObserversChanged;
 
   //! \brief Signal emitted when the list of valid target sensors changes
   boost::signalslib::signal<void(const std::vector<std::string>&)> signal_validTargetSensorsChanged;
 
   //! \brief Handles simulation element addition/removal
   //!
   //! Updates lists of available entities, observers, and sensors when
   //! elements are added or removed from the simulation
   void onElementsAddedOrRemoved();
 
   //! \brief Handles element initialization
   //! \param elements List of element IDs that have been initialized
   void slot_elementsInitialized(const makVrv::DtElementData::ElementIdList& elements);
 
   //! \brief Handles element removal
   //! \param elements List of element IDs that will be removed
   void slot_elementsToBeRemoved(const makVrv::DtElementData::ElementIdList& elements);
 
   //! \brief Handles observer addition
   //! \param observerName Name of the added observer
   void slot_observerAdded(const std::string& observerName);
 
   //! \brief Handles observer removal
   //! \param observerName Name of the removed observer
   void slot_observerRemoved(const std::string& observerName);
 
   //! \brief Handles observer mode changes
   //! \param observer Pointer to the observer that changed
   //! \param newMode New observer mode value
   void slot_observerModeChanged(makVrv::DtObserver* observer, int newMode);
 
   //! @}
 
   //! @name Setting Persistence Methods
   //! @{
 
   //! \brief Sets the current settings state from the given record
   //! \param rec Settings record to load from
   //!
   //! Loads all settings values from the provided record
   virtual void setFromRecord(const DtSarSettingsRecord& rec) override;
 
   //! \brief Stores the current settings state in the given record
   //! \param rec Settings record to store to
   //!
   //! Saves all current settings values to the provided record
   virtual void getRecord(DtSarSettingsRecord& rec) const override;
 
   //! @}
 
protected:
   //! \brief Befriend the manager instance functions for instance retrieval/creation
   //! \tparam ManagerClass Type of manager class
   template <typename ManagerClass>
   friend ManagerClass& makVrv::defaultManagerInstanceFunction(makVrv::DtDe&, bool);
 
   //! \brief Befriend the manager instance functions for instance registration
   //! \tparam ManagerClass Type of manager class
   template <typename ManagerClass>
   friend void makVrv::defaultManagerRegisterInstanceFunction(makVrv::DtDe&, ManagerClass*);
 
   //! \brief Protected constructor
   //! \param de Reference to the display element
   //!
   //! Constructor is protected to enforce the singleton pattern
   DtSarSettingsManager(makVrv::DtDe& de);
 
   //! \brief Gets overrides to the factory record, if any
   //! \param rec Reference to the record to apply overrides to
   //! \return True if overrides were applied, false otherwise
   //!
   //! This is an internal utility function used by VR-Vantage engineers to update factory defaults.
   //! As a result, this function returns false in releases but can be overriden by toolkit users
   //! if desired; however, generally toolkit users can and should use
   //! DtDeInitializer::addDefaultSettingsRecord(...) instead.
   virtual bool applyFactoryOverrides(DtSarSettingsRecord& rec) const override;
 
protected:
   //! \brief Current settings record containing all SAR settings
   DtSarSettingsRecord mySettingsRecord;
 
   //! \brief Flag indicating if connected to RadarFx server
   bool myIsConnected;
 
   //! \brief Element ID of the current ownship entity
   makVrv::DtElementID myOwnshipElementId;
 
   //! \brief Element ID of the current target entity
   makVrv::DtElementID myTargetElementId;
 
   //! \brief Flag indicating if ownship observer is valid
   bool myOwnshipObserverValid;
 
   //! \brief Flag indicating if target observer is valid
   bool myTargetObserverValid;
};
} // namespace makVre