rfxOcclusionMessage.h

Go to the documentation of this file.

// ******************************************************************************
// ** Copyright (c) 2025 MAK Technologies
// ** All rights reserved.
// ******************************************************************************
 
//! \file rfxOcclusionMessage.h
//! \brief Defines the request and response messages for line-of-sight occlusion tests
//! \ingroup vreRadarFxShared
//!
//! This file contains message classes for requesting line-of-sight occlusion tests
//! between two points or entities, and receiving the visibility results. Occlusion
//! tests determine if there is an unobstructed view between the observer and target.
 
#pragma once
 
#include "export.h"
#include "rfxMessage.h"
 
#include <vlutil/vlString.h>
#include <matrix/vlVector.h>
 
namespace makRadarFx
{
//! \brief Request message for line-of-sight occlusion tests
//!
//! This class encapsulates a request for an occlusion test between an observer position
//! and a target position. The test determines if there is an unobstructed line of sight
//! between the two points, taking into account terrain and objects in the simulation.
//! Both the observer and target can be specified as absolute positions, entities in the
//! simulation, or using the current observer's position and view.
class RFX_DLL_SHARED DtOcclusionRequest : public DtBaseMessage
{
public:
   //! \brief Default constructor
   //!
   //! Initializes a new occlusion request message with default settings
   DtOcclusionRequest();
 
   //! \brief Virtual destructor
   virtual ~DtOcclusionRequest();
 
   //! \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 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;
 
   std::string myOwnshipName;
   std::string myTargetName;
   DtVector myOwnshipLocation;
   DtVector myTargetLocation;
};
 
//! \brief Response message containing line-of-sight occlusion test results
//!
//! This class encapsulates the response to an occlusion test request, providing
//! information about whether there is an unobstructed line of sight between the
//! observer position and the target position. If the line of sight is obstructed,
//! additional information about the obstruction may be included.
class RFX_DLL_SHARED DtOcclusionResponse : public DtBaseMessage
{
public:
   //! \brief Default constructor
   //!
   //! Initializes a new occlusion response message with default settings
   DtOcclusionResponse();
 
   //! \brief Virtual destructor
   virtual ~DtOcclusionResponse();
 
   //! \brief Returns whether or not the requesting platform has line of sight of the target location
   virtual void setOcclusion(bool occluded);
   virtual bool occluded();
 
   //! \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 myOcclusion;
};
} // namespace makRadarFx