rfxIsarMessage.h

Go to the documentation of this file.

// ******************************************************************************
// ** Copyright (c) 2025 MAK Technologies
// ** All rights reserved.
// ******************************************************************************
 
//! \file rfxIsarMessage.h
//! \brief Defines the request and response messages for Inverse Synthetic Aperture Radar (ISAR) images
//! \ingroup vreRadarFxShared
//!
//! This file contains message classes for requesting Inverse Synthetic Aperture Radar (ISAR)
//! images from the server and processing the image responses. ISAR differs from SAR in that
//! it focuses on imaging moving targets rather than stationary terrain. 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 Inverse Synthetic Aperture Radar (ISAR) images
//!
//! This class encapsulates a request for an Inverse Synthetic Aperture Radar (ISAR) image from
//! the RadarFX server. It contains parameters that specify the sensor platform position,
//! target entity, radar system settings, and image format settings. ISAR images provide
//! detailed radar imagery of moving objects and vehicles, using the target's motion to
//! create the synthetic aperture.
class RFX_DLL_SHARED DtIsarRequest : public DtImageRequest
{
public:
   //! \brief Default constructor
   //!
   //! Initializes a new ISAR image request message with default settings
   DtIsarRequest();
 
   //! \brief Virtual destructor
   virtual ~DtIsarRequest();
 
   //! \brief calling this function causes the message to use the current observer's position and orientation for
   //! the SAR 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 data type of the returned image data.  Only available for RAW/NITF image types
   virtual void setImageDataType(DtImageDataType type);
   virtual DtImageDataType imageDataType();
 
   //! \brief Requested format of the returned image data
   virtual void setImageFormat(DtImageFormat format);
   virtual DtImageFormat imageFormat();
 
   //! \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 accessors for the number of images/responses to generate
   virtual int numRequestedImages();
   virtual void setNumRequestedImages(int numImages);
 
   //! \brief accessors for the view magnification to use for this request
   virtual float viewMagnification();
   virtual void setViewMagnification(float zoom);
 
   //! \brief accessors for the integratino time to use for this request.
   virtual double integrationTime();
   virtual void setIntegrationTime(double time);
 
 
   //! \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 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;
   unsigned int myReturnMethod;
   std::string myImageSavePath;
   std::string myImageFilename;
   int myNumRequestedImages;
   float myViewMagnification;
 
   double myIntegrationTime;
};
 
 
//! \brief DtIsarResponse is the returned image data by the server
class RFX_DLL_SHARED DtIsarResponse : public DtImageResponse
{
public:
   //! \brief CTOR/DTOR
   DtIsarResponse();
   virtual ~DtIsarResponse();
 
   //! \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 0 starting index for this image response
   virtual void setImageIndex(int index);
   virtual int imageIndex();
 
   //! \brief ownship location at the time of the request being processed
   virtual void setOwnshipLocation(DtVector location);
   virtual DtVector ownshipLocation();
 
   //! \brief ownship orientation at the time of the request being processed
   virtual void setOwnshipOrientation(DtTaitBryan orientation);
   virtual DtTaitBryan ownshipOrientation();
 
   //! \brief UTC time of the request being processed
   virtual void setSystemTime(double time);
   virtual double systemTime();
 
   //! \brief the center hit point of the view vector for this response
   virtual void setCenterPosition(double lat, double lon, double alt);
   virtual void getCenterPosition(double& lat, double& lon, double& alt);
 
   //! \brief the sensor view direction is azimuth from north and elevation from level in Radians.
   virtual void setSensorViewDirection(double azimuth, double elevation);
   virtual void getSensorViewDirection(double& azimuth, double& elevation);
 
   //! \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;
   int myImageIndex;
   DtVector myOwnshipLocation;
   DtTaitBryan myOwnshipOrientation;
   double mySystemTime;
   double myCenterLat;
   double myCenterLon;
   double myCenterAlt;
   double mySensorDirectionAzimuth;
   double mySensorDirectionElevation;
};
} // namespace makRadarFx