rfxMmwMessage.h

Go to the documentation of this file.

// ******************************************************************************
// ** Copyright (c) 2025 MAK Technologies
// ** All rights reserved.
// ******************************************************************************
 
//! \file rfxMmwMessage.h
//! \brief Defines the request and response messages for Millimeter Wave (MMW) radar images
//! \ingroup vreRadarFxShared
//!
//! This file contains message classes for requesting Millimeter Wave (MMW) radar
//! images from the server and processing the image responses. MMW radar operates
//! at frequencies between 30-300 GHz, providing high-resolution imagery with the ability
//! to penetrate certain materials. These classes extend the base image request and
//! response classes from rfxImageMessage.h.
 
#pragma once
 
#include "export.h"
#include "rfxMessage.h"
#include "vreRadarFxShared/rfxImageMessage.h"
#include <matrix/vlVector.h>
#include <matrix/vlTaitBryan.h>
 
#include <string>
 
namespace makRadarFx
{
 
//! \brief Request message for Millimeter Wave (MMW) radar images
//!
//! This class encapsulates a request for a Millimeter Wave radar image from
//! the RadarFX server. It contains parameters that specify the sensor platform position,
//! target location, radar system settings, and image format settings. MMW radar
//! provides high-resolution imagery with material penetration capabilities,
//! making it useful for detection of objects through certain obscurants.
class RFX_DLL_SHARED DtMmwRequest : public DtImageRequest
{
public:
   //! \brief Default constructor
   //!
   //! Initializes a new MMW image request message with default settings
   DtMmwRequest();
 
   //! \brief Virtual destructor
   virtual ~DtMmwRequest();
 
   //! \brief calling this function causes the message to use the current observer's position and orientation for
   //! the MMW image setup.  The client doees not need to set an ownship location or target location if using this
   //! method to orient the sensor.
   virtual void useObserverAsHost();
 
   //! \brief if the ownship is not hosted in the simulation system, we can explicitly state where we want to
   //! perform the elevation test from
   virtual void setOwnshipLocation(DtVector location);
   virtual DtVector ownshipLocation();
 
   //! \brief If the ownship is hosted by the simulation system, we can use its global simulation name
   //! to look it up
   virtual void setOwnshipEntityId(const std::string& name);
   virtual std::string ownshipEntityId();
 
   //! \brief functions to determine how to place the sensor
   virtual bool isUsingObserverAsHost();
   virtual bool isUsingEntityAsHost();
   virtual bool isUsingAbsoluteLocation();
 
   //! \brief calling this function causes the message to use the current observer's view to determine the target for
   //! the SAR image setup.
   virtual void useObserverForTarget();
 
   //! \brief If the ownship is the target of the sensor, we can use its global simulation name
   //! to look it up
   virtual void setTargetEntityId(const std::string& name);
   virtual std::string targetEntityId();
 
   //! \brief this is the target that we would like to look at.  Location format is latitude/longitude/altitude (in
   //! degrees/meters). the altitude of the target location is not required.
   virtual void setTargetLocation(DtVector location);
   virtual DtVector targetLocation();
 
   //! \brief functions to determine how to place the target
   virtual bool isUsingObserverForTarget();
   virtual bool isUsingEntityForTarget();
   virtual bool isUsingLocationForTarget();
 
   //! \brief the offset location of the sensor on the hosting entity.  Only valid when a hosting entity is
   //! defined
   virtual void setRadarOffsetLocation(DtVector offset);
   virtual DtVector radarOffsetLocation();
 
   //! \brief the offset orientation of the sensor from the hosting entite's orientation.  Only valid when a hosting
   //! entity is defined
   virtual void setRadarOffsetOrientation(DtTaitBryan offsetOrientation);
   virtual DtTaitBryan radarOffsetOrientation();
 
   //! \brief The name of the sensor system to use.  This must match one of the sensors that the RadarFX server has
   //! configured
   virtual void setRadarSystemName(const std::string& name);
   virtual std::string radarSystemName();
 
   //! \brief Whether or not to use AGC for Power
   virtual void setIsAgcPowerEnabled(bool isAgcPowerEnabled);
   virtual bool isAgcPowerEnabled() const;
 
   //! \brief Radar system power setting in Watts
   virtual void setPower(float power);
   virtual float power();
 
   //! \brief Requested image pixel size.  This may not be the returned size due to image rotation
   virtual void setImageSize(const DtImageSize& size);
   virtual DtImageSize imageSize();
 
   //! \brief Requested format of the returned image data
   virtual void setImageFormat(DtImageFormat format);
   virtual DtImageFormat imageFormat();
 
   //! \brief Requested data type of the returned image data.  Only available for RAW/NITF image types
   virtual void setImageDataType(DtImageDataType type);
   virtual DtImageDataType imageDataType();
 
   //! \brief Requested rotation of the image
   virtual void setImageRotation(DtImageRotation rotate);
   virtual DtImageRotation imageRotation();
 
   //! \brief Bitfield for image data return types.
   virtual void setImageReturnMethod(unsigned int returnFlags);
   virtual unsigned int imageReturnMethod();
 
   //! \brief Requested path for image if it is to be saved by the server
   //! If the path does not exist, the server will attempt to create it.
   virtual void setImageSavePath(const std::string& filename);
   virtual std::string imageSavePath();
 
   //! \brief Requested filename for image if it is to be saved by the server
   //! If this is not set, then the date/timestamp will be used as the filename
   //! if this is set, then the filename will be used plus a date/time stamp
   //! and the extension will be determined automatically
   virtual void setImageFilename(const std::string& filename);
   virtual std::string imageFilename();
 
   //! \brief Lets the server know that it should restore the display/window/observer state after
   //! an image capture process is completed.
   virtual void setRestoreState(bool restoreState);
   virtual bool restoreState();
 
   //! \brief lets the server know if it should render the sky or not with this request.
   virtual void setEnableSky(bool enableSky);
   virtual bool enableSky();
 
   //! \brief size of the message
   virtual int messageSize();
   //! \brief decode a message.  Used by the factory
   static DtBaseMessage* decode(unsigned char* buffer, int length);
   //! \brief clone a message.  Caller of function is responsible managing this memory
   virtual DtBaseMessage* clone();
 
 
protected:
   virtual void serialize(DtStreamWriter& writer);
   virtual void deserialize(DtStreamReader& reader);
 
 
   bool myUseObserverAsHost;
   bool myUseEntityAsHost;
   bool myUseAbsoluteOwnship;
   bool myUseObserverForTarget;
   bool myUseEntityAsTarget;
   bool myUseAbsoluteTarget;
   bool myEnableSky;
   bool myIsAgcPowerEnabled;
 
   std::string myOwnshipName;
   std::string myTargetName;
   DtVector myOwnshipLocation;
   DtVector myTargetLocation;
 
   DtVector myRadarOffsetLocation;
   DtTaitBryan myRadarOffsetOrientation;
   std::string myRadarName;
   float myPower;
   DtImageSize myImageSize;
   DtImageFormat myImageFormat;
   DtImageDataType myImageDataType;
   DtImageRotation myImageRotation;
   unsigned int myReturnMethod;
 
   bool myRestoreState;
 
   std::string myImageSavePath;
   std::string myImageFilename;
};
 
 
//! \brief DtMmwResponse is the returned image data by the server
class RFX_DLL_SHARED DtMmwResponse : public DtImageResponse
{
public:
   //! \brief CTOR/DTOR
   DtMmwResponse();
   virtual ~DtMmwResponse();
 
   //! \brief Error value if there is one
   virtual void setError(DtImageError error);
   virtual DtImageError error();
 
   //! \brief Warning value if there is one
   virtual void setWarning(DtImageWarning error);
   virtual DtImageWarning warning();
 
   //! \brief Image return method that is used
   virtual void setReturnMethod(unsigned int method);
   virtual unsigned int returnMethod();
 
   //! \brief Image return format
   virtual void setImageFormat(DtImageFormat format);
   virtual DtImageFormat imageFormat();
 
   //! \brief Size of the image returned by the server
   virtual void setImageSize(const DtImageSize& size);
   virtual DtImageSize imageSize();
 
   //! \brief Image data type Only available for RAW/NITF image types
   virtual void setImageDataType(DtImageDataType type);
   virtual DtImageDataType imageDataType();
 
   //! \brief filename of saved image if it was saved on the server
   virtual void setFilename(const std::string& filename);
   virtual std::string filename();
 
   //! \brief Size of data for the returned image
   virtual int dataLength();
 
   //! \brief Image data returned by the server.  This message class will manage this memory.
   virtual void setData(unsigned char* buffer, int length);
   virtual unsigned char* data();
 
   //! \brief size of the message
   virtual int messageSize();
   //! \brief decode a message.  Used by the factory
   static DtBaseMessage* decode(unsigned char* buffer, int length);
   //! \brief clone a message.  Caller of function is responsible managing this memory
   virtual DtBaseMessage* clone();
 
protected:
   virtual void serialize(DtStreamWriter& writer);
   virtual void deserialize(DtStreamReader& reader);
 
   DtImageError myError;
   DtImageWarning myWarning;
   DtImageSize myImageSize;
   unsigned int myReturnMethod;
   DtImageFormat myImageFormat;
   DtImageDataType myImageDataType;
   std::string myFilename;
   int myDataLength;
   unsigned char* myData;
};
} // namespace makRadarFx