rfxSarMessage.h

Go to the documentation of this file.

// ******************************************************************************
// ** Copyright (c) 2025 MAK Technologies
// ** All rights reserved.
// ******************************************************************************
 
//! \file rfxSarMessage.h
//! \brief Defines the request and response messages for Synthetic Aperture Radar (SAR) images
//! \ingroup vreRadarFxShared
//!
//! This file contains message classes for requesting Synthetic Aperture Radar (SAR)
//! images from the server and processing the image responses. 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 Synthetic Aperture Radar (SAR) images
//!
//! This class encapsulates a request for a Synthetic Aperture Radar (SAR) image from
//! the RadarFX server. It contains parameters that specify the sensor platform position,
//! target location, radar system settings, and image format settings. SAR images provide
//! a top-down radar view of terrain and objects.
class RFX_DLL_SHARED DtSarRequest : public DtImageRequest
{
public:
   //! \brief Default constructor
   //!
   //! Initializes a new SAR image request message with default settings
   DtSarRequest();
 
   //! \brief Virtual destructor
   virtual ~DtSarRequest();
 
   //! \brief Uses the current observer's position and orientation for the radar platform
   //!
   //! When called, this function configures the request to use the current observer's
   //! position and orientation as the radar platform location. The client does not need
   //! to set an ownship location or orientation if using this method to position the sensor.
   virtual void useObserverAsHost();
 
   //! \brief Sets an absolute position for the radar platform
   //! \param location Vector containing the radar platform position (latitude, longitude, altitude)
   //!
   //! If the radar platform is not hosted in the simulation system, this method allows
   //! explicit specification of the platform position for the SAR imagery.
   virtual void setOwnshipLocation(DtVector location);
 
   //! \brief Gets the absolute radar platform position
   //! \return Vector containing the radar platform position (latitude, longitude, altitude)
   //!
   //! Returns the currently set absolute position for the radar platform.
   virtual DtVector ownshipLocation();
 
   //! \brief Sets an entity ID to use for the radar platform position
   //! \param name String identifier of the entity to use as the radar platform
   //!
   //! If the radar platform is hosted by the simulation system, this method allows
   //! specification of the entity by its global simulation name or ID.
   virtual void setOwnshipEntityId(const std::string& name);
 
   //! \brief Gets the entity ID used for the radar platform position
   //! \return String identifier of the entity used as the radar platform
   //!
   //! Returns the entity identifier that will be used to locate the radar platform.
   virtual std::string ownshipEntityId();
 
   //! \name Radar Platform Placement Mode Queries
   //! @{
   //! \brief Methods to determine how the radar platform is being positioned
 
   //! \brief Checks if using the observer position for the radar platform
   //! \return True if the observer is being used as the radar platform host
   virtual bool isUsingObserverAsHost();
 
   //! \brief Checks if using an entity as the radar platform
   //! \return True if an entity ID is being used for the radar platform host
   virtual bool isUsingEntityAsHost();
 
   //! \brief Checks if using an absolute position for the radar platform
   //! \return True if absolute coordinates are being used for the radar platform position
   virtual bool isUsingAbsoluteLocation();
   //! @}
 
   //! \brief Uses the current observer's view direction to determine the target location
   //!
   //! When called, this function configures the request to use the current observer's
   //! view direction to determine the target location for the SAR image. The system
   //! will cast a ray along the view direction to find the intersection with terrain.
   virtual void useObserverForTarget();
 
   //! \brief Sets an entity ID to use as the target location
   //! \param name String identifier of the entity to use as the target
   //!
   //! Specifies an entity by its global simulation name or ID to use as the
   //! target location for the SAR image. The center of the image will be
   //! positioned at this entity's location.
   virtual void setTargetEntityId(const std::string& name);
 
   //! \brief Gets the entity ID used as the target location
   //! \return String identifier of the entity used as the target
   //!
   //! Returns the entity identifier that will be used to locate the target.
   virtual std::string targetEntityId();
 
   //! \brief Sets an absolute position for the target location
   //! \param location Vector containing the target position (latitude, longitude, altitude)
   //!
   //! Specifies the absolute coordinates for the target location of the SAR image.
   //! Location format is latitude/longitude/altitude (in degrees/meters).
   //! The altitude component is optional and will be determined by terrain height
   //! if not specified.
   virtual void setTargetLocation(DtVector location);
 
   //! \brief Gets the absolute target position
   //! \return Vector containing the target position (latitude, longitude, altitude)
   //!
   //! Returns the currently set target position for the SAR image.
   virtual DtVector targetLocation();
 
   //! \name Target Placement Mode Queries
   //! @{
   //! \brief Methods to determine how the target is being positioned
 
   //! \brief Checks if using the observer view for the target position
   //! \return True if the observer view is being used to determine the target location
   virtual bool isUsingObserverForTarget();
 
   //! \brief Checks if using an entity as the target
   //! \return True if an entity ID is being used for the target location
   virtual bool isUsingEntityForTarget();
 
   //! \brief Checks if using an absolute position for the target
   //! \return True if absolute coordinates are being used for the target location
   virtual bool isUsingLocationForTarget();
   //! @}
 
   //! \brief Sets the offset location of the radar sensor on the hosting entity
   //! \param offset Vector containing the offset position in entity-relative coordinates
   //!
   //! Specifies the position offset of the radar sensor relative to the hosting entity's
   //! reference point. This is only valid when a hosting entity is defined using
   //! setOwnshipEntityId().
   virtual void setRadarOffsetLocation(DtVector offset);
 
   //! \brief Gets the radar sensor offset location
   //! \return Vector containing the offset position in entity-relative coordinates
   //!
   //! Returns the currently set position offset of the radar sensor relative to
   //! the hosting entity's reference point.
   virtual DtVector radarOffsetLocation();
 
   //! \brief Sets the offset orientation of the radar sensor on the hosting entity
   //! \param offsetOrientation Tait-Bryan angles representing the orientation offset
   //!
   //! Specifies the orientation offset of the radar sensor relative to the hosting entity's
   //! reference orientation. This is only valid when a hosting entity is defined using
   //! setOwnshipEntityId().
   virtual void setRadarOffsetOrientation(DtTaitBryan offsetOrientation);
 
   //! \brief Gets the radar sensor offset orientation
   //! \return Tait-Bryan angles representing the orientation offset
   //!
   //! Returns the currently set orientation offset of the radar sensor relative to
   //! the hosting entity's reference orientation.
   virtual DtTaitBryan radarOffsetOrientation();
 
   //! \brief Sets the radar system name to use for the SAR image
   //! \param name String identifier of the radar system configuration
   //!
   //! Specifies the name of the radar system configuration to use for generating the
   //! SAR image. This must match one of the predefined radar systems that the
   //! RadarFX server has configured. Different radar systems have different
   //! capabilities and characteristics.
   virtual void setRadarSystemName(const std::string& name);
 
   //! \brief Gets the radar system name
   //! \return String identifier of the radar system configuration
   //!
   //! Returns the currently set radar system name.
   virtual std::string radarSystemName();
 
   //! \brief Sets the crossrange size for the SAR image
   //! \param width Size of the crossrange in meters
   //!
   //! Sets the width (crossrange dimension) of the target area for the SAR image
   //! in meters. This controls the horizontal field of view of the radar image.
   virtual void setCrossrange(float width);
 
   //! \brief Gets the crossrange size
   //! \return Size of the crossrange in meters
   //!
   //! Returns the currently set width (crossrange dimension) of the target area.
   virtual float crossrange();
 
   //! \brief Sets the downrange size for the SAR image
   //! \param height Size of the downrange in meters
   //!
   //! Sets the height (downrange dimension) of the target area for the SAR image
   //! in meters. This controls the vertical field of view of the radar image.
   virtual void setDownrange(float height);
 
   //! \brief Gets the downrange size
   //! \return Size of the downrange in meters
   //!
   //! Returns the currently set height (downrange dimension) of the target area.
   virtual float downrange();
 
   //! \brief Enables or disables Automatic Gain Control (AGC) for radar power
   //! \param isAgcPowerEnabled True to enable AGC, false to disable
   //!
   //! When enabled, Automatic Gain Control will dynamically adjust the radar
   //! power level to optimize the image quality based on the scene content.
   //! When disabled, the power level is fixed at the value set by setPower().
   virtual void setIsAgcPowerEnabled(bool isAgcPowerEnabled);
 
   //! \brief Checks if Automatic Gain Control is enabled
   //! \return True if AGC is enabled, false if disabled
   //!
   //! Returns the current state of the Automatic Gain Control setting.
   virtual bool isAgcPowerEnabled() const;
 
   //! \brief Sets the radar system power level
   //! \param power Radar transmitter power in Watts
   //!
   //! Sets the power level of the radar transmitter in Watts. Higher power levels
   //! generally result in better signal-to-noise ratio but may cause saturation
   //! for strong reflectors. This setting is only used when AGC is disabled.
   virtual void setPower(float power);
 
   //! \brief Gets the radar system power level
   //! \return Radar transmitter power in Watts
   //!
   //! Returns the currently set power level of the radar transmitter.
   virtual float power();
 
   //! \brief Sets the requested image dimensions
   //! \param size The desired image dimensions in pixels
   //!
   //! Sets the desired dimensions of the SAR image in pixels. The actual
   //! dimensions of the returned image may differ due to image rotation or
   //! other processing requirements.
   //!
   //! \note The default size is 512x512 pixels if not specified.
   virtual void setImageSize(const DtImageSize& size);
 
   //! \brief Gets the requested image dimensions
   //! \return The currently set image dimensions in pixels
   //!
   //! Returns the currently set dimensions for the SAR image.
   virtual DtImageSize imageSize();
 
   //! \brief Sets the requested image format
   //! \param format The desired image format enumeration value
   //!
   //! Sets the format to use for the returned SAR image data. Different formats
   //! have different characteristics in terms of compression, metadata support,
   //! and compatibility with various applications.
   virtual void setImageFormat(DtImageFormat format);
 
   //! \brief Gets the requested image format
   //! \return The currently set image format enumeration value
   //!
   //! Returns the currently set format for the SAR image.
   virtual DtImageFormat imageFormat();
 
   //! \brief Sets the requested image data type
   //! \param type The desired image data type enumeration value
   //!
   //! Sets the data type to use for the pixel values in the returned SAR image.
   //! This setting is only applicable for RAW and NITF image formats.
   //! Different data types provide different dynamic range and precision.
   virtual void setImageDataType(DtImageDataType type);
 
   //! \brief Gets the requested image data type
   //! \return The currently set image data type enumeration value
   //!
   //! Returns the currently set data type for the SAR image pixels.
   virtual DtImageDataType imageDataType();
 
   //! \brief Sets the requested image orientation
   //! \param rotate The desired image orientation enumeration value
   //!
   //! Sets the orientation to use for the returned SAR image. The orientation
   //! determines whether north is at the top of the image (NORTH_UP) or the
   //! platform's direction of travel is at the top (TRACK_UP).
   virtual void setImageRotation(DtImageRotation rotate);
 
   //! \brief Gets the requested image orientation
   //! \return The currently set image orientation enumeration value
   //!
   //! Returns the currently set orientation for the SAR image.
   virtual DtImageRotation imageRotation();
 
   //! \brief Sets the requested image delivery method
   //! \param returnFlags Bitfield of DtImageReturnMethod values
   //!
   //! Sets how the SAR image data should be delivered. This can be set to return
   //! the image data directly in the message (STREAM), save the image to a file
   //! and return the file path (FILESYSTEM), or both. Use bitwise OR to combine
   //! multiple flags.
   virtual void setImageReturnMethod(unsigned int returnFlags);
 
   //! \brief Gets the requested image delivery method
   //! \return Bitfield of currently set delivery methods
   //!
   //! Returns the currently set delivery method for the SAR image.
   virtual unsigned int imageReturnMethod();
 
   //! \brief Sets the directory path for saving the image on the server
   //! \param filename Path to the directory where the image should be saved
   //!
   //! Sets the directory path where the image should be saved on the server when
   //! using the FILESYSTEM return method. If the specified directory does not exist,
   //! the server will attempt to create it.
   //!
   //! \note This setting is only used when the FILESYSTEM return method is selected.
   virtual void setImageSavePath(const std::string& filename);
 
   //! \brief Gets the image save directory path
   //! \return Path to the directory where the image will be saved
   //!
   //! Returns the currently set directory path for saving the image.
   virtual std::string imageSavePath();
 
   //! \brief Sets the base filename for saving the image on the server
   //! \param filename Base name to use for the saved image file
   //!
   //! Sets the base filename to use when saving the image on the server when
   //! using the FILESYSTEM return method. If not set, a timestamp will be used
   //! as the filename. If set, the specified name will be used as a prefix,
   //! followed by a timestamp. The file extension will be determined automatically
   //! based on the selected image format.
   //!
   //! \note This setting is only used when the FILESYSTEM return method is selected.
   virtual void setImageFilename(const std::string& filename);
 
   //! \brief Gets the image base filename
   //! \return Base name that will be used for the saved image file
   //!
   //! Returns the currently set base filename for saving the image.
   virtual std::string imageFilename();
 
   //! \brief Controls whether the server restores its state after image capture
   //! \param restoreState True to restore state, false otherwise
   //!
   //! When set to true, this instructs the server to restore the display, window, and
   //! observer state after the SAR image capture process is completed. This is useful
   //! when the server needs to temporarily modify its state for image generation but
   //! should return to its previous state afterward.
   virtual void setRestoreState(bool restoreState);
 
   //! \brief Checks if state restoration is enabled
   //! \return True if state restoration is enabled, false otherwise
   //!
   //! Returns whether the server will restore its state after image capture.
   virtual bool restoreState();
 
   //! \brief Sets the platform speed for the SAR image request
   //! \param speed Speed of the platform in meters per second
   //!
   //! Sets the speed of the platform (ownship) for the SAR image request.
   //! This affects the SAR processing parameters and can impact the quality
   //! of the resulting image. Only used when not using an entity as the host.
   void setOwnshipSpeed(float speed);
 
   //! \brief Gets the platform speed
   //! \return Speed of the platform in meters per second
   //!
   //! Returns the currently set speed of the platform (ownship).
   float ownshipSpeed();
 
   //! \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 myCrossrange;
   float myDownrange;
   float myPower;
   DtImageSize myImageSize;
   DtImageFormat myImageFormat;
   DtImageDataType myImageDataType;
   DtImageRotation myImageRotation;
   unsigned int myReturnMethod;
 
   bool myRestoreState;
 
   float myOwnshipSpeed;
 
   std::string myImageSavePath;
   std::string myImageFilename;
};
 
 
//! \brief Response message containing Synthetic Aperture Radar (SAR) image data
//!
//! This class encapsulates the response from the RadarFX server to a SAR image
//! request. It contains the image data itself (or a file path to the saved image),
//! metadata about the image, and any error or warning information. The class also
//! provides methods to access the platform position, orientation, and other
//! contextual information at the time the image was captured.
class RFX_DLL_SHARED DtSarResponse : public DtImageResponse
{
public:
   //! \brief Default constructor
   //!
   //! Initializes a new SAR image response message with default settings
   DtSarResponse();
 
   //! \brief Virtual destructor
   //!
   //! Cleans up the response resources, including any allocated image data
   virtual ~DtSarResponse();
 
   //! \brief Sets the error code for this response
   //! \param error The error code to set
   //!
   //! Sets the error status for this SAR image response. Use IMAGE_NO_ERROR
   //! if the image was generated successfully.
   virtual void setError(DtImageError error);
 
   //! \brief Gets the error code for this response
   //! \return The current error code
   //!
   //! Returns the error status for this SAR image response.
   virtual DtImageError error();
 
   //! \brief Sets the warning code for this response
   //! \param error The warning code to set
   //!
   //! Sets the warning status for this SAR image response. Unlike errors,
   //! warnings indicate that the image was generated but there may be
   //! quality issues or other non-critical problems.
   virtual void setWarning(DtImageWarning error);
 
   //! \brief Gets the warning code for this response
   //! \return The current warning code
   //!
   //! Returns the warning status for this SAR image response.
   virtual DtImageWarning warning();
 
   //! \brief Sets the image delivery method used
   //! \param method Bitfield of DtImageReturnMethod values
   //!
   //! Sets the delivery method actually used for this SAR image response.
   //! This may differ from what was requested if there were problems with
   //! the requested method.
   virtual void setReturnMethod(unsigned int method);
 
   //! \brief Gets the image delivery method used
   //! \return Bitfield of delivery methods used
   //!
   //! Returns the delivery method that was actually used for this SAR image.
   virtual unsigned int returnMethod();
 
   //! \brief Sets the image format used
   //! \param format The image format enumeration value used
   //!
   //! Sets the format that was actually used for the returned SAR image data.
   //! This may differ from what was requested if there were compatibility issues.
   virtual void setImageFormat(DtImageFormat format);
 
   //! \brief Gets the image format used
   //! \return The image format enumeration value used
   //!
   //! Returns the format that was actually used for the SAR image.
   virtual DtImageFormat imageFormat();
 
   //! \brief Sets the actual dimensions of the returned image
   //! \param size The actual image dimensions in pixels
   //!
   //! Sets the actual dimensions of the returned SAR image in pixels.
   //! This may differ from what was requested due to image rotation or
   //! other processing requirements.
   virtual void setImageSize(const DtImageSize& size);
 
   //! \brief Gets the actual dimensions of the returned image
   //! \return The actual image dimensions in pixels
   //!
   //! Returns the actual dimensions of the returned SAR image.
   virtual DtImageSize imageSize();
 
   //! \brief Sets the image data type used
   //! \param type The image data type enumeration value used
   //!
   //! Sets the data type that was actually used for the pixel values in the
   //! SAR image. This is only relevant for RAW and NITF image formats and may
   //! differ from what was requested if there were compatibility issues.
   virtual void setImageDataType(DtImageDataType type);
 
   //! \brief Gets the image data type used
   //! \return The image data type enumeration value used
   //!
   //! Returns the data type that was actually used for the SAR image pixels.
   virtual DtImageDataType imageDataType();
 
   //! \brief Sets the full path of the saved image
   //! \param filename Full path to the saved image file
   //!
   //! Sets the full path of the image file that was saved on the server.
   //! This is only applicable when the FILESYSTEM return method was used.
   virtual void setFilename(const std::string& filename);
 
   //! \brief Gets the full path of the saved image
   //! \return Full path to the saved image file
   //!
   //! Returns the full path of the image file that was saved on the server.
   //! This will be empty if the FILESYSTEM return method was not used or
   //! if the save operation failed.
   virtual std::string filename();
 
   //! \brief Gets the size of the image data in bytes
   //! \return Size of the image data in bytes
   //!
   //! Returns the size of the binary image data in bytes. This is only
   //! applicable when the STREAM return method was used.
   virtual int dataLength();
 
   //! \brief Sets the binary image data
   //! \param buffer Pointer to the image data buffer
   //! \param length Length of the image data in bytes
   //!
   //! Sets the binary image data for this response. This message class
   //! will take ownership of the buffer and manage its memory.
   //! This is only applicable when the STREAM return method is used.
   virtual void setData(unsigned char* buffer, int length);
 
   //! \brief Gets the binary image data
   //! \return Pointer to the image data buffer
   //!
   //! Returns a pointer to the binary image data. This will be nullptr
   //! if the STREAM return method was not used or if there was an error.
   //! The caller should not attempt to free this memory, as it is owned
   //! by this message object.
   virtual unsigned char* data();
 
   //! \brief Sets the platform position at the time of image capture
   //! \param location Vector containing the platform position (latitude, longitude, altitude)
   //!
   //! Sets the position of the platform (ownship) at the time when the SAR
   //! image was captured. This provides context for the image and can be
   //! used for geolocation purposes.
   virtual void setOwnshipLocation(DtVector location);
 
   //! \brief Gets the platform position at the time of image capture
   //! \return Vector containing the platform position (latitude, longitude, altitude)
   //!
   //! Returns the position of the platform (ownship) at the time the image was captured.
   virtual DtVector ownshipLocation();
 
   //! \brief Sets the platform orientation at the time of image capture
   //! \param orientation Tait-Bryan angles representing the platform orientation
   //!
   //! Sets the orientation of the platform (ownship) at the time when the SAR
   //! image was captured. This provides context for the image and can be
   //! used for geolocation purposes.
   virtual void setOwnshipOrientation(DtTaitBryan orientation);
 
   //! \brief Gets the platform orientation at the time of image capture
   //! \return Tait-Bryan angles representing the platform orientation
   //!
   //! Returns the orientation of the platform (ownship) at the time the image was captured.
   virtual DtTaitBryan ownshipOrientation();
 
   //! \brief Sets the UTC time when the image was captured
   //! \param time UTC time value (seconds since Unix epoch)
   //!
   //! Sets the UTC time when the SAR image was captured. This provides temporal
   //! context for the image and can be used for synchronization with other data.
   virtual void setSystemTime(double time);
 
   //! \brief Gets the UTC time when the image was captured
   //! \return UTC time value (seconds since Unix epoch)
   //!
   //! Returns the UTC time when the SAR image was captured.
   virtual double systemTime();
 
   //! \brief Sets the center position of the SAR image
   //! \param lat Latitude in degrees
   //! \param lon Longitude in degrees
   //! \param alt Altitude in meters
   //!
   //! Sets the geographic coordinates of the center point of the SAR image.
   //! This is the point where the sensor's view vector intersects with the terrain.
   virtual void setCenterPosition(double lat, double lon, double alt);
 
   //! \brief Gets the center position of the SAR image
   //! \param lat Reference to store the latitude in degrees
   //! \param lon Reference to store the longitude in degrees
   //! \param alt Reference to store the altitude in meters
   //!
   //! Retrieves the geographic coordinates of the center point of the SAR image.
   virtual void getCenterPosition(double& lat, double& lon, double& alt);
 
   //! \brief Sets the sensor view direction
   //! \param azimuth Azimuth angle in radians (clockwise from north)
   //! \param elevation Elevation angle in radians (from horizontal)
   //!
   //! Sets the direction in which the radar sensor was pointing when the
   //! SAR image was captured. The azimuth is measured clockwise from north,
   //! and the elevation is measured from the horizontal plane.
   virtual void setSensorViewDirection(double azimuth, double elevation);
 
   //! \brief Gets the sensor view direction
   //! \param azimuth Reference to store the azimuth angle in radians
   //! \param elevation Reference to store the elevation angle in radians
   //!
   //! Retrieves the direction in which the radar sensor was pointing when
   //! the SAR image was captured.
   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:
   //! \brief Serializes the message data to a stream writer
   //! \param writer Reference to the stream writer to write the data to
   //!
   //! Writes the message data to the provided stream writer. This protected method
   //! is called by the encode() method to convert the object to a byte array.
   virtual void serialize(DtStreamWriter& writer);
 
   //! \brief Deserializes message data from a stream reader
   //! \param reader Reference to the stream reader to read the data from
   //!
   //! Reads the message data from the provided stream reader. This protected method
   //! is called by the decode() method to convert a byte array back to an object.
   virtual void deserialize(DtStreamReader& reader);
 
   //! \brief Error code for this response
   DtImageError myError;
 
   //! \brief Warning code for this response
   DtImageWarning myWarning;
 
   //! \brief Actual dimensions of the returned image
   DtImageSize myImageSize;
 
   //! \brief Delivery method used for the image
   unsigned int myReturnMethod;
 
   //! \brief Format used for the image data
   DtImageFormat myImageFormat;
 
   //! \brief Data type used for the image pixels
   DtImageDataType myImageDataType;
 
   //! \brief Full path to the saved image file
   std::string myFilename;
 
   //! \brief Length of the image data in bytes
   int myDataLength;
 
   //! \brief Pointer to the binary image data
   unsigned char* myData;
 
   //! \brief Platform position at time of image capture
   DtVector myOwnshipLocation;
 
   //! \brief Platform orientation at time of image capture
   DtTaitBryan myOwnshipOrientation;
 
   //! \brief UTC time of image capture
   double mySystemTime;
 
   //! \brief Latitude of the image center point
   double myCenterLat;
 
   //! \brief Longitude of the image center point
   double myCenterLon;
 
   //! \brief Altitude of the image center point
   double myCenterAlt;
 
   //! \brief Azimuth angle of the sensor view direction
   double mySensorDirectionAzimuth;
 
   //! \brief Elevation angle of the sensor view direction
   double mySensorDirectionElevation;
};
} // namespace makRadarFx