rwRadarStateInfo.h

Go to the documentation of this file.

/*******************************************************************************
** Copyright (c) 2025 MAK Technologies
** All rights reserved.
*******************************************************************************/
 
//! \file rwRadarStateInfo.h
//! \ingroup vreVrfMessages
//! \brief Defines radar state information structure
//!
//! This file contains the DtRwRadarStateInfo class which represents the
//! current operating state of a radar system in the simulation, including mode,
//! antenna parameters, and scan pattern information.
 
#pragma once
 
#include "export.h"
 
#include <readerWriter/readerWriter.h>
#include <readerWriter/rwReal.h>
#include <readerWriter/rwInt.h>
#include <vrfUtil/rwTemplatedList.h>
 
// class DtReaderWriterRegistry;
//! \brief Radar state information class for radar system configurations
//!
//! This class represents the current operational state of a radar system,
//! including its mode, scan patterns, and antenna parameters. It is a
//! readable/writable class that can store itself and read itself from a file.
//! This enables persistent storage of radar configuration between scenario runs.
 
class VRFMESSAGES_DLL DtRwRadarStateInfo : public DtReaderWriter
{
public:
   //! \brief Default constructor
   //!
   //! Initializes a radar state info object with default values.
   DtRwRadarStateInfo();
 
   //! \brief Constructor with name
   //! \param name The name of the radar state
   //! \param parentRegistry Optional reader-writer registry for serialization
   DtRwRadarStateInfo(const DtString& name, DtReaderWriterRegistry* const parentRegistry = NULL);
 
   //! \brief Constructor with symbol name
   //! \param name The symbol name of the radar state
   //! \param parentRegistry Optional reader-writer registry for serialization
   DtRwRadarStateInfo(const DtSymbolString& name, DtReaderWriterRegistry* const parentRegistry = NULL);
 
   //! \brief Copy constructor
   //! \param orig The radar state info to copy from
   //! \param parentRegistry Optional reader-writer registry for serialization
   DtRwRadarStateInfo(const DtRwRadarStateInfo& orig, DtReaderWriterRegistry* const parentRegistry = NULL);
 
   //! \brief Virtual destructor
   virtual ~DtRwRadarStateInfo() override;
 
   //! \brief Assignment operator
   //! \param orig The radar state info to copy from
   //! \return Reference to this object after assignment
   DtRwRadarStateInfo& operator=(const DtRwRadarStateInfo& orig);
 
   //! \brief Sets the radar's operating mode
   //! \param val The mode string to set (e.g., "Search", "Track", "Standby")
   //!
   //! Sets the primary operational mode of the radar system.
   virtual void setMode(const DtString& val);
 
   //! \brief Gets the radar's operating mode
   //! \return The current radar mode
   virtual DtString mode() const;
 
   //! \brief Sets the radar's operating submode
   //! \param val The submode string to set
   //!
   //! Sets the submode within the current operational mode.
   virtual void setSubmode(const DtString& val);
 
   //! \brief Gets the radar's operating submode
   //! \return The current radar submode
   virtual DtString submode() const;
 
   //! \brief Sets the antenna center azimuth angle
   //! \param val The center azimuth angle in degrees
   //!
   //! Sets the center of the radar's azimuth scan pattern.
   virtual void setAntennaCenterAzimuth(double val);
 
   //! \brief Gets the antenna center azimuth angle
   //! \return The center azimuth angle in degrees
   virtual double antennaCenterAzimuth() const;
 
   //! \brief Sets the antenna center elevation angle
   //! \param val The center elevation angle in degrees
   //!
   //! Sets the center of the radar's elevation scan pattern.
   virtual void setAntennaCenterElevation(double val);
 
   //! \brief Gets the antenna center elevation angle
   //! \return The center elevation angle in degrees
   virtual double antennaCenterElevation() const;
 
   //! \brief Sets the antenna minimum elevation angle
   //! \param val The minimum elevation angle in degrees
   //!
   //! Sets the lower limit of the radar's elevation scan pattern.
   virtual void setAntennaMinElevation(double val);
 
   //! \brief Gets the antenna minimum elevation angle
   //! \return The minimum elevation angle in degrees
   virtual double antennaMinElevation() const;
 
   //! \brief Sets the antenna maximum elevation angle
   //! \param val The maximum elevation angle in degrees
   //!
   //! Sets the upper limit of the radar's elevation scan pattern.
   virtual void setAntennaMaxElevation(double val);
 
   //! \brief Gets the antenna maximum elevation angle
   //! \return The maximum elevation angle in degrees
   virtual double antennaMaxElevation() const;
 
   //! \brief Sets the antenna gate size
   //! \param val The gate size in degrees
   //!
   //! Sets the angular size of the radar's detection gate.
   virtual void setAntennaGateSize(double val);
 
   //! \brief Gets the antenna gate size
   //! \return The gate size in degrees
   virtual double antennaGateSize() const;
 
   //! \brief Sets the antenna current azimuth angle
   //! \param val The current azimuth angle in degrees
   //!
   //! Sets the current instantaneous azimuth angle of the radar beam.
   virtual void setAntennaCurrentAzimuth(double val);
 
   //! \brief Gets the antenna current azimuth angle
   //! \return The current azimuth angle in degrees
   virtual double antennaCurrentAzimuth() const;
 
   //! \brief Sets the antenna current elevation angle
   //! \param val The current elevation angle in degrees
   //!
   //! Sets the current instantaneous elevation angle of the radar beam.
   virtual void setAntennaCurrentElevation(double val);
 
   //! \brief Gets the antenna current elevation angle
   //! \return The current elevation angle in degrees
   virtual double antennaCurrentElevation() const;
 
   //! \brief Sets the antenna current azimuth scan rate
   //! \param val The current azimuth scan rate in degrees per second
   //!
   //! Sets the rate at which the radar beam is currently sweeping in azimuth.
   virtual void setAntennaCurrentAzimuthRate(double val);
 
   //! \brief Gets the antenna current azimuth scan rate
   //! \return The current azimuth scan rate in degrees per second
   virtual double antennaCurrentAzimuthRate() const;
 
   //! \brief Sets the number of scan bars
   //! \param val The number of scan bars
   //!
   //! Sets the number of horizontal scan bars in the radar's scan pattern.
   virtual void setBarCount(int val);
 
   //! \brief Gets the number of scan bars
   //! \return The number of scan bars
   virtual int barCount() const;
 
   //! \brief Creates a deep copy of this object
   //! \return Pointer to a newly created clone of this class
   //!
   //! Returns a dynamically allocated copy of this radar state info.
   virtual DtRwRadarStateInfo* clone() const;
 
   //! \brief Equality comparison operator
   //! \param other The radar state info to compare with
   //! \return True if the objects are equal, false otherwise
   bool operator==(const DtRwRadarStateInfo& other) const;
 
   //! \brief Inequality comparison operator
   //! \param rhs The radar state info to compare with
   //! \return True if the objects are not equal, false otherwise
   bool operator!=(const DtRwRadarStateInfo& rhs) { return !(*this == rhs); };
 
   //! \brief Encodes this object to a buffer
   //! \param buffer The buffer to encode into
   //! \return Pointer to the buffer after the encoded data
   virtual char* encode(char* buffer) const;
 
   //! \brief Decodes this object from a buffer
   //! \param buffer The buffer to decode from
   //! \return Pointer to the buffer after the decoded data
   virtual const char* decode(const char* buffer);
 
   //! \brief Gets the size of the encoded data in bytes
   //! \return The size in bytes
   virtual int getSize() const;
 
protected:
   //! \brief Primary mode of radar operation (e.g., "Search", "Track")
   DtRwString myMode;
 
   //! \brief Submode of radar operation within the primary mode
   DtRwString mySubmode;
 
   //! \brief Center azimuth angle of the radar scan pattern (degrees)
   DtRwReal myAntennaCenterAzimuth;
 
   //! \brief Center elevation angle of the radar scan pattern (degrees)
   DtRwReal myAntennaCenterElevation;
 
   //! \brief Minimum elevation angle of the radar scan pattern (degrees)
   DtRwReal myAntennaMinElevation;
 
   //! \brief Maximum elevation angle of the radar scan pattern (degrees)
   DtRwReal myAntennaMaxElevation;
 
   //! \brief Angular size of the radar detection gate (degrees)
   DtRwReal myAntennaGateSize;
 
   //! \brief Current instantaneous azimuth angle of the radar beam (degrees)
   DtRwReal myAntennaCurrentAzimuth;
 
   //! \brief Current instantaneous elevation angle of the radar beam (degrees)
   DtRwReal myAntennaCurrentElevation;
 
   //! \brief Current rate of azimuth scanning (degrees/second)
   DtRwReal myAntennaCurrentAzimuthRate;
 
   //! \brief Number of horizontal scan bars in the radar scan pattern
   DtRwInt myBarCount;
};
 
//! \brief List type for storing multiple radar state information entries
using DtRwSensorStateInfoList = DtRwTemplatedListPtr<DtRwRadarStateInfo, true>;
 
//! \brief Namespace containing serialization functions for buffer operations
namespace DtBufferSerialize
{
//! \brief Gets the number of bytes required to encode the value
//! \param info The radar state info to calculate size for
//! \return The number of bytes required for encoding
VRFMESSAGES_DLL int getSize(const DtRwRadarStateInfo& info);
 
//! \brief Serializes the provided data into a buffer
//! \param info The radar state info to encode
//! \param buffer The buffer to serialize into
//! \return Pointer to the buffer after the serialization
//!
//! Serializes the provided radar state info into the buffer.
//! The buffer must have at least the number of bytes returned by getSize().
VRFMESSAGES_DLL char* encode(const DtRwRadarStateInfo& info, char* buffer);
 
//! \brief Deserializes data from a buffer into the provided object
//! \param info The radar state info to populate
//! \param buffer The buffer to deserialize from
//! \return Pointer to the buffer after the deserialization
VRFMESSAGES_DLL const char* decode(DtRwRadarStateInfo& info, const char* buffer);
} // namespace DtBufferSerialize