rwRadarContactInfo.h

Go to the documentation of this file.

/*******************************************************************************
** Copyright (c) 2025 MAK Technologies
** All rights reserved.
*******************************************************************************/
 
//! \file rwRadarContactInfo.h
//! \ingroup vreVrfMessages
//! \brief Defines radar contact information structure
//!
//! This file contains the DtRwRadarContactInfo class which represents detailed
//! information about radar contacts in the simulation. It includes data about
//! contact position, signal strength, and other radar-specific attributes.
 
#pragma once
 
#include "export.h"
 
#include <vrfutil/rwSensorContactInfo.h>
 
//! \brief Extended radar contact information class
//!
//! This class provides detailed information about radar contacts for use with
//! Radar Scope and EWAWS (Electronic Warfare and Avionics Weapon Systems) extended
//! radar functionality. It contains all relevant positional, signal, and identification
//! information needed for radar simulation and display.
 
class VRFMESSAGES_DLL DtRwRadarContactInfo : public DtRwSensorContactInfo
{
public:
   //! \brief Default constructor
   //!
   //! Initializes a radar contact info object with default values.
   DtRwRadarContactInfo();
 
   //! \brief Constructor with name
   //! \param name The name of the radar contact
   //! \param parentRegistry Optional reader-writer registry for serialization
   DtRwRadarContactInfo(const DtString& name, DtReaderWriterRegistry* const parentRegistry = NULL);
 
   //! \brief Constructor with symbol name
   //! \param name The symbol name of the radar contact
   //! \param parentRegistry Optional reader-writer registry for serialization
   DtRwRadarContactInfo(const DtSymbolString& name, DtReaderWriterRegistry* const parentRegistry = NULL);
 
   //! \brief Copy constructor
   //! \param orig The radar contact info to copy from
   //! \param parentRegistry Optional reader-writer registry for serialization
   DtRwRadarContactInfo(const DtRwRadarContactInfo& orig, DtReaderWriterRegistry* const parentRegistry = NULL);
 
   //! \brief Virtual destructor
   virtual ~DtRwRadarContactInfo() override;
 
   //! \brief Assignment operator
   //! \param orig The radar contact info to copy from
   //! \return Reference to this object after assignment
   DtRwRadarContactInfo& operator=(const DtRwRadarContactInfo& orig);
 
   //! \brief Checks if this contact is designated by the radar scope
   //! \return True if the contact is designated, false otherwise
   virtual bool isDesignated() const;
 
   //! \brief Sets whether this contact is designated
   //! \param val True to designate the contact, false otherwise
   virtual void setIsDesignated(bool val);
 
   //! \brief Gets the target's priority in the radar scope
   //! \return The target priority value
   //!
   //! Higher values typically indicate higher priority targets.
   virtual int targetPriority() const;
 
   //! \brief Sets the target's priority in the radar scope
   //! \param val The priority value to set
   virtual void setTargetPriority(int val);
 
   //! \brief Gets the radar track ID
   //! \return The track ID value
   //!
   //! This is a unique identifier for the radar track.
   virtual int trackId() const;
 
   //! \brief Sets the radar track ID
   //! \param val The track ID value to set
   virtual void setTrackId(int val);
 
   //! \brief Gets the contact's label
   //! \return The contact label string
   //!
   //! This is typically a string representation of the entity type,
   //! e.g., "29" for a MiG-29 contact.
   virtual std::string contactLabel() const;
 
   //! \brief Sets the contact's label
   //! \param val The contact label to set
   virtual void setContactLabel(std::string val);
 
   //! \brief Gets the contact's azimuth in degrees
   //! \return The azimuth angle in degrees
   //!
   //! Contact azimuth (degrees) relative to the platform's heading.
   //! Negative azimuth is towards the left.
   virtual double azimuth() const;
 
   //! \brief Sets the contact's azimuth
   //! \param val The azimuth angle in degrees
   virtual void setAzimuth(double val);
 
   //! \brief Gets the contact's elevation in degrees
   //! \return The elevation angle in degrees
   //!
   //! Contact elevation (degrees) relative to the platform's pitch.
   virtual double elevation() const;
 
   //! \brief Sets the contact's elevation
   //! \param val The elevation angle in degrees
   virtual void setElevation(double val);
 
   //! \brief Gets the range to the contact in meters
   //! \return The range in meters
   //!
   //! Straight-line distance from the platform to the contact.
   virtual double range() const;
 
   //! \brief Sets the range to the contact
   //! \param val The range in meters
   virtual void setRange(double val);
 
   //! \brief Gets the contact's altitude in meters
   //! \return The altitude in meters
   //!
   //! Altitude of the contact above mean sea level.
   virtual double altitude() const;
 
   //! \brief Sets the contact's altitude
   //! \param val The altitude in meters
   virtual void setAltitude(double val);
 
 
   //! \brief Gets the closure rate to the contact in meters per second
   //! \return The closure rate in m/s
   //!
   //! Closure rate of the target in meters per second.
   //! Positive values mean that the distance is decreasing.
   //! Negative values mean that the distance is increasing.
   virtual double closureRate() const;
 
   //! \brief Sets the closure rate to the contact
   //! \param val The closure rate in m/s
   virtual void setClosureRate(double val);
 
 
   //! \brief Gets the signal strength in Watts
   //! \return The signal strength in Watts
   //!
   //! Detection signal power in Watts. Higher values indicate
   //! stronger radar returns.
   virtual double signalStrength() const;
 
   //! \brief Sets the signal strength
   //! \param val The signal strength in Watts
   virtual void setSignalStrength(double val);
 
 
   //! \brief Gets the target aspect angle in degrees
   //! \return The aspect angle in degrees
   //!
   //! Aspect angle of the target relative to the contact's heading.
   //! Return value is in [-180,180] range. If the return value is negative, then the
   //! radar-carrying platform has a left aspect (i.e., on the left hemisphere of the target).
   virtual double targetAspectAngle() const;
 
   //! \brief Sets the target aspect angle
   //! \param val The aspect angle in degrees
   virtual void setTargetAspectAngle(double val);
 
   //! \brief Gets the contact's speed in Mach number
   //! \return The speed in Mach number
   //!
   //! Speed of the contact measured in Mach numbers.
   virtual double machNumber() const;
 
   //! \brief Sets the contact's speed in Mach number
   //! \param val The speed in Mach number
   virtual void setMachNumber(double val);
 
   //! \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;
 
   //! \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 contact info.
   virtual DtRwRadarContactInfo* clone() const override;
 
   //! \brief Equality comparison operator
   //! \param other The radar contact info to compare with
   //! \return True if the objects are equal, false otherwise
   bool operator==(const DtRwRadarContactInfo& other) const;
 
protected:
   //! \brief Flag indicating if this contact is designated by the radar scope
   DtRwBoolean myIsDesignated;
 
   //! \brief The target's priority in the radar scope, if designated
   DtRwInt myTargetPriority;
 
   //! \brief Radar Track ID for unique identification
   DtRwInt myTrackId;
 
   //! \brief The label of the contact's entity type (e.g., "29" for a MiG-29)
   DtRwString myContactLabel;
 
   //! \brief Angle to contact relative to observer's heading (degrees)
   DtRwReal myAzimuth;
 
   //! \brief Angle to contact relative to observer's pitch (degrees)
   DtRwReal myElevation;
 
   //! \brief Range to contact (meters)
   DtRwReal myRange;
 
   //! \brief Altitude of contact (meters)
   DtRwReal myAltitude;
 
   //! \brief Closure rate between observer and target (meters/second)
   DtRwReal myClosureRate;
 
   //! \brief Detection signal strength (watts)
   DtRwReal mySignalStrength;
 
   //! \brief Angle to observer relative to contact's heading (degrees)
   DtRwReal myTargetAspectAngle;
 
   //! \brief Speed of contact in Mach number
   DtRwReal myMachNumber;
};
 
//! \brief Namespace containing serialization functions for buffer operations
namespace DtBufferSerialize
{
//! \brief Gets the number of bytes required to encode the value
//! \param data The radar contact info to calculate size for
//! \return The number of bytes required for encoding
VRFMESSAGES_DLL int getSize(const DtRwRadarContactInfo& data);
 
//! \brief Serializes the provided data into a buffer
//! \param data The radar contact info to encode
//! \param buffer The buffer to serialize into
//! \return Pointer to the buffer after the serialization
//!
//! Serializes the provided value data into buffer. The buffer must have
//! at least the number of bytes returned by getSize() for the same
//! parameter. No length checking is done on the buffer.
VRFMESSAGES_DLL char* encode(const DtRwRadarContactInfo& data, char* buffer);
 
//! \brief Deserializes data from a buffer into the provided object
//! \param data The radar contact info to populate
//! \param buffer The buffer to deserialize from
//! \return Pointer to the buffer after the deserialization
//!
//! Decodes a value from buffer and places the result in data.
//! Buffer must contain a value created by the corresponding call to encode().
VRFMESSAGES_DLL const char* decode(DtRwRadarContactInfo& data, const char* buffer);
} // namespace DtBufferSerialize
 
//! \brief List type for storing multiple radar contact information entries
using DtRadarDataEntryList = std::vector<DtRwRadarContactInfo>;