WsfLOS_Manager.hpp

Go to the documentation of this file.

// ****************************************************************************
// CUI
//
// The Advanced Framework for Simulation, Integration, and Modeling (AFSIM)
//
// Copyright 2003-2015 The Boeing Company. All rights reserved.
//
// The use, dissemination or disclosure of data in this file is subject to
// limitation or restriction. See accompanying README and LICENSE for details.
// ****************************************************************************
 
#ifndef WSFLOSMANAGER_HPP
#define WSFLOSMANAGER_HPP
 
#include "wsf_export.h"
 
#include <list>
#include <map>
#include <mutex>
#include <set>
 
#include "UtCallbackHolder.hpp"
class UtInput;
#include "UtVec3.hpp"
 
class WsfArticulatedPart;
class WsfEM_Antenna;
class WsfPlatform;
#include "WsfScenarioExtension.hpp"
#include "WsfSimulationExtension.hpp"
#include "WsfThread.hpp"

struct WSF_EXPORT WsfLOS_ManagerData
{
   WsfLOS_ManagerData();
 
   struct ThreadData
   {
      ThreadData();
 
      unsigned int mNumPriorityQueues;     
      unsigned int mMaxCountPriorityQueue; 
      unsigned int mProcessingRate; 
      bool         mDebugEnabled;
   };

   bool ProcessInput(UtInput& aInput);

   double mMaxAllowableLocDelta;

   bool mMultiThreaded;

   bool mDebugEnabled;

   bool mVegLayerMaskingEnabled;
 
   bool mUseHeightForGroundPlatforms;
 
   ThreadData mThreadData;
};

class WSF_EXPORT WsfLOS_ManagerExtension : public WsfScenarioExtension
{
public:
   WsfLOS_ManagerExtension() {}
 
   void SimulationCreated(WsfSimulation& aSimulation) override;
 
   bool ProcessInput(UtInput& aInput) override;
 
private:
   WsfLOS_ManagerData mData;
};

class WSF_EXPORT WsfLOS_Manager : public WsfSimulationExtension, public WsfLOS_ManagerData
{
public:
   static WsfLOS_Manager* Find(const WsfSimulation& aSimulation);
 
   WsfLOS_Manager(WsfLOS_ManagerData& aData);
   ~WsfLOS_Manager() override;

   bool Initialize() override;

   void PlatformDeleted(double aSimTime, WsfPlatform* aPlatformPtr);

   void Update(double aSimTime);

   bool DebugEnabled() const { return mDebugEnabled; }

   void SetDebugEnabled(bool aDebugEnabled) { mDebugEnabled = aDebugEnabled; }


 
   bool IsTargetVisible(WsfPlatform* aPlatformPtr, WsfPlatform* aTargetPtr, double aMaxRange = 0.0, double aRadiusScale = 1.0);
 
   bool IsTargetVisible(WsfEM_Antenna* aAntennaPtr, WsfPlatform* aTargetPtr, double aMaxRange = 0.0, double aRadiusScale = 1.0);
 
   bool IsTargetVisible(WsfEM_Antenna* aAntennaPtr,
                        WsfEM_Antenna* aTargetPtr,
                        double         aMaxRange    = 0.0,
                        double         aRadiusScale = 1.0);


 
   bool MaskedByTerrain(WsfPlatform* aPlatformPtr, WsfPlatform* aTargetPtr, double aMaxRange = 0.0, double aRadiusScale = 1.0);
 
   bool MaskedByTerrain(WsfEM_Antenna* aAntennaPtr, WsfPlatform* aTargetPtr, double aMaxRange = 0.0, double aRadiusScale = 1.0);
 
   bool MaskedByTerrain(WsfEM_Antenna* aAntennaPtr,
                        WsfEM_Antenna* aTargetPtr,
                        double         aMaxRange    = 0.0,
                        double         aRadiusScale = 1.0);



 
   bool MaskedByVegetation(WsfPlatform* aPlatformPtr,
                           WsfPlatform* aTargetPtr,
                           double       aMaxRange    = 0.0,
                           double       aRadiusScale = 1.0);
 
   bool MaskedByVegetation(WsfEM_Antenna* aAntennaPtr,
                           WsfPlatform*   aTargetPtr,
                           double         aMaxRange    = 0.0,
                           double         aRadiusScale = 1.0);
 
   bool MaskedByVegetation(WsfEM_Antenna* aAntennaPtr,
                           WsfEM_Antenna* aTargetPtr,
                           double         aMaxRange    = 0.0,
                           double         aRadiusScale = 1.0);


   class State
   {
   public:
      State()
         : mPlatformIndex(0)
         , mTime(-1.0)
         , mMoved(true)
      {
         UtVec3d::Set(mLocationWCS, 0.0);
         UtVec3d::Set(mLLA, 0.0);
      };
      virtual ~State(){};
 
      size_t mPlatformIndex;  // Platform index
      double mTime;           // Sim time of location data update
      double mLocationWCS[3]; // Location in WCS
      double mLLA[3];         // Latitude, longitude, altitude
      bool   mMoved;          // True if the platform has moved
   };
 
   typedef std::map<unsigned int, State>           StateMapType;
   typedef std::map<unsigned int, State>::iterator StateMapTypeIterator;
   typedef std::pair<unsigned int, State>          StateMapTypePair;

   StateMapType& GetStateData() { return mStateData; };

   class LOS_Key
   {
   public:
      LOS_Key(unsigned int aUniqueId1, unsigned int aUniqueId2);
      virtual ~LOS_Key(){};
 
      bool operator<(const LOS_Key& aRhs) const;
      bool operator==(const LOS_Key& aRhs) const;
      bool operator==(const unsigned int& aRhs) const;
      bool operator!=(const LOS_Key& aRhs) const;
 
      unsigned int mID1;
      unsigned int mID2;
   };
 
   typedef std::map<LOS_Key, bool>           LOS_MapType;
   typedef std::map<LOS_Key, bool>::iterator LOS_MapTypeIterator;
   typedef std::pair<LOS_Key, bool>          LOS_MapTypePair;
 
   typedef std::list<unsigned int>           LOS_RequestType;
   typedef std::list<unsigned int>::iterator LOS_RequestTypeIterator;
 
   typedef std::map<unsigned int, unsigned int>           PriorityQueueType;
   typedef std::map<unsigned int, unsigned int>::iterator PriorityQueueTypeIterator;
   typedef std::pair<unsigned int, unsigned int>          PriorityQueueTypePair;
 
protected:

 
   bool IsTargetVisibleNow(WsfPlatform* aPlatformPtr,
                           WsfPlatform* aTargetPtr,
                           double       aMaxRange    = 0.0,
                           double       aRadiusScale = 1.0);
 
   bool IsTargetVisibleNow(WsfEM_Antenna* aAntennaPtr,
                           WsfPlatform*   aTargetPtr,
                           double         aMaxRange    = 0.0,
                           double         aRadiusScale = 1.0);
 
   bool IsTargetVisibleNow(WsfEM_Antenna* aAntennaPtr,
                           WsfEM_Antenna* aTargetPtr,
                           double         aMaxRange    = 0.0,
                           double         aRadiusScale = 1.0);


   bool Moved(WsfEM_Antenna* aAntennaPtr);
   bool Moved(WsfPlatform* aPlatformPtr);

   bool LOS_DataExists(/*input*/ unsigned int aID1, unsigned int aID2);
   bool LOS_DataExists(/*input*/ unsigned int aID1, unsigned int aID2, /*output*/ LOS_MapTypeIterator& aIter);
   bool LOS_DataExists(/*input*/ unsigned int          aID1,
                       unsigned int                    aID2,
                       LOS_MapType&                    aLOS_Map,
                       /*output*/ LOS_MapTypeIterator& aIter);

   bool StateDataExists(/*input*/ unsigned int aID);
   bool StateDataExists(/*input*/ unsigned int aID, /*output*/ StateMapTypeIterator& iter);

   bool SetLOS_Data(/*input*/ unsigned int aID1, unsigned int aID2, bool aVisible);
   bool SetLOS_Data(/*input*/ unsigned int aID1, unsigned int aID2, bool aVisible, /*output*/ LOS_MapTypeIterator& aIter);

   bool SetStateData(/*input*/ unsigned int aID, State& aNewState);
   bool SetStateData(/*input*/ unsigned int aID, State& aNewState, /*output*/ StateMapTypeIterator& aIter);

   void DeleteLOS_Data(unsigned int aID, LOS_MapType& aLOS_Map);

   void UpdateStateData(/*output*/ LOS_RequestType& aLOS_RequestQueue);


 
   bool PlatformMoved(WsfPlatform* aPlatformPtr);
   bool PlatformMoveCheck(WsfPlatform* aPlatformPtr, StateMapTypeIterator& aIter);
 
   bool PartMoved(WsfArticulatedPart* aPartPtr);
   bool PartMoveCheck(WsfArticulatedPart* aPartPtr, StateMapTypeIterator& aIter);

 
private:
   WsfLOS_Manager(const WsfLOS_Manager& aSrc);

   WsfLOS_Manager& operator=(const WsfLOS_Manager& aRhs) = delete;

   class LOS_Thread : public WsfThread, public WsfLOS_ManagerData::ThreadData
   {
   public:
      LOS_Thread(WsfLOS_ManagerData::ThreadData& aData);
      ~LOS_Thread() override{};
 
      FunctionType DoWork() override;
      FunctionType Pause() override { return AVAILABLE; };

      void Initialize(WsfLOS_Manager* aManagerPtr);
 
      typedef std::set<unsigned int>           IdSetType;
      typedef std::set<unsigned int>::iterator IdSetTypeIterator;

      void ProcessRequests();

      void ProcessPriorityQueue(/*output*/ IdSetType& aIdSet);

      void ProcessThreadLOSData(/*input*/ IdSetType& aIdSet);

      void ProcessRequest(unsigned int aID);

      void CleanUpPriorityQueues(unsigned int aID);

      bool SetThreadLOS_Data(LOS_Key aLOS_Key, bool aVisible);

      bool NoWork();
 
      WsfLOS_Manager* mManagerPtr;
      double          mTime;         
      LOS_RequestType mRequestQueue; 
 
      IdSetType mIdsToDelete; 
 
      std::vector<PriorityQueueType> mPriorityQueues;
 
 
      LOS_MapType mThreadLOS_Data; 
   };

   double mLOS_Time;

   LOS_MapType mLOS_Data;

   StateMapType mStateData;

   UtCallbackHolder mCallbacks;

   LOS_Thread mWorkerThread;

   mutable std::recursive_mutex mMutex;
};
 
#endif