WsfTrackManager.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 WSFTRACKMANAGER_HPP
#define WSFTRACKMANAGER_HPP
 
#include "wsf_export.h"
 
#include <map>
#include <memory>
#include <string>
 
#include "UtCallback.hpp"
class UtInput;
class UtScriptTypes;
 
class WsfCorrelationStrategy;
class WsfFilter;
class WsfFusionStrategy;
class WsfLocalTrack;
class WsfPlatform;
class WsfScenario;
#include "WsfSimpleComponent.hpp"
class WsfSimulation;
#include "WsfTrackList.hpp"

class WSF_EXPORT WsfTrackManager : public WsfSimplePlatformComponent
{
public:
   static std::unique_ptr<UtScriptClass> CreateScriptClass(const std::string& aClassName, UtScriptTypes* aScriptTypesPtr);
 
   WsfTrackManager() = default;
   WsfTrackManager(const WsfScenario& aScenario);
   WsfTrackManager(const WsfTrackManager& aSrc);
   ~WsfTrackManager() override;


   WsfComponent* CloneComponent() const override { return Clone(); }
   void*         QueryInterface(int aRole) override { return (aRole == mRoles[0]) ? this : nullptr; }
   int           GetComponentInitializationOrder() const override { return cWSF_INITIALIZE_ORDER_TRACK_MANAGER; }
   void          ComponentParentChanged(WsfPlatform* aPlatformPtr) override { mPlatformPtr = aPlatformPtr; }

   virtual WsfTrackManager* Clone() const { return new WsfTrackManager(*this); }
 
   bool ProcessInput(UtInput& aInput) override;
   bool Initialize(double aSimTime) override;
   bool Initialize2(double aSimTime) override;
 
   virtual bool Initialize(double aSimTime, WsfPlatform* aPlatformPtr);

   WsfPlatform* GetPlatform() const { return mPlatformPtr; }

   WsfCorrelationStrategy&       GetCorrelationStrategy() { return *mCorrelationStrategyPtr; }
   const WsfCorrelationStrategy& GetCorrelationStrategy() const { return *mCorrelationStrategyPtr; }

   WsfFusionStrategy&       GetFusionStrategy() { return *mFusionStrategyPtr; }
   const WsfFusionStrategy& GetFusionStrategy() const { return *mFusionStrategyPtr; }

   void SetCorrelationStrategy(WsfStringId aTypeName);

   void SetFusionStrategy(WsfStringId aTypeName);

   void SetDropUncorrelatedTracks(bool aDropUncorrelatedTracks) { mDropUncorrelatedTracks = aDropUncorrelatedTracks; }

   void SetDebug(bool aDebug) { mDebug = aDebug; }

   bool DebugEnabled() const { return mDebug; }

   void SetInitiateLocalTracks(bool aInitiateLocalTracks) { mInitiateLocalTracks = aInitiateLocalTracks; }

   bool LocalTracksInitiated() const { return mInitiateLocalTracks; }


   virtual void PurgeInactiveTracks(double aSimTime, double aInactivityTimeLimit);
 
   virtual void PurgeInactiveRawTracks(double aSimTime, double aInactivityTimeLimit, double aStaticInactivityTimeLimit);
 
   virtual void PurgeLocalTrackHistory(double aSimTime, double aKeepTimeInterval);

   void SetWillPurgeInactiveTracks(bool aWillPurgeInactiveTracks)
   {
      mWillPurgeInactiveTracks = aWillPurgeInactiveTracks;
   }

   bool WillPurgeInactiveTracks() const { return mWillPurgeInactiveTracks; }



   virtual void LockTrack(double aSimTime, const WsfTrackId& aLocalTrackId);
 
   virtual void LockTrack(double aSimTime, WsfLocalTrack* aLocalTrackPtr);
 
   virtual void UnlockTrack(double aSimTime, const WsfTrackId& aLocalTrackId);
 
   virtual void UnlockTrack(double aSimTime, WsfLocalTrack* aLocalTrackPtr);

   //{@
   virtual void StartFrame();
 
   virtual void EndFrame();
 
   virtual WsfLocalTrack* AddTrackReport(double aSimTime, const WsfTrack& aTrackUpdate);
 
   virtual WsfTrack* AddRawTrackReport(double aSimTime, const WsfTrack& aRawTrack);
 
   virtual void DropTrack(double aSimTime, const WsfTrackId& aRawTrackId);
 
   std::unique_ptr<WsfLocalTrack> RemoveTrack(const WsfTrackId& aTrackId);
 
   virtual WsfLocalTrack* FindCorrelatedTrack(const WsfTrackId& aRawTrackId);
 
   static WsfLocalTrack* FindCorrelatedTrack(const WsfTrackId& aRawTrackId, WsfLocalTrackList& aLocalTrackList);


   virtual WsfLocalTrack* AddTrack(double aSimTime, const WsfTrack& aTrack);
 
   void AddInitialTrack(const WsfTrack& aTrack);
 
   virtual WsfLocalTrack* InitiateTrack(double aSimTime, const WsfTrack& aRawTrack);
 
   WsfLocalTrack* InitiateTrackSilent(double aSimTime, const WsfTrack& aRawTrack);

   WsfLocalTrack* InitiateAndCorrelateTrack(double aSimTime, const WsfTrack& aRawTrack)
   {
      return InitiateTrackSilent(aSimTime, aRawTrack);
   }




   unsigned int GetTrackCount() const { return mTrackList->GetTrackCount(); }

   WsfLocalTrack* GetTrackEntry(unsigned int aEntryIndex) { return mTrackList->GetTrackEntry(aEntryIndex); }

   unsigned int GetRawTrackCount() { return mRawTrackList->GetTrackCount(); }

   WsfTrack* GetRawTrackEntry(unsigned int aEntryIndex) { return mRawTrackList->GetTrackEntry(aEntryIndex); }

   WsfLocalTrack* FindTrack(const WsfTrackId& aLocalTrackId) { return mTrackList->FindTrack(aLocalTrackId); }

   WsfTrack* FindRawTrack(const WsfTrackId& aRawTrackId) { return mRawTrackList->FindTrack(aRawTrackId); }

   WsfLocalTrackList& GetTrackList() { return *mTrackList; }

   WsfTrackList& GetRawTrackList() { return *mRawTrackList; }

   WsfLocalTrackList& GetLocalTrackList() { return *mTrackList; }

   WsfLocalTrackList& GetFilteredRawTrackList() { return *mFilteredRawTrackList; }

   const WsfLocalTrackList& GetFilteredRawTrackList() const { return *mFilteredRawTrackList; }
 
   WsfTrack* GetRawTrack(const WsfLocalTrack* aLocalTrackPtr, unsigned int aRawTrackEntry);
 
   bool HasFilter() { return (mPrototypeFilterPtr != nullptr); }



   const WsfTrack* GetCurrentTarget();

   const WsfTrackId GetCurrentTargetTrackId() const { return mCurrentTargetId; }
 
   WsfTrackId SetCurrentTarget(double aSimTime, const WsfTrack& aTrack);

   void ClearCurrentTarget() { mCurrentTargetId.Null(); }



   void NotifyOfCandidateTrackPromoted(double aSimTime, const WsfLocalTrack* aLocalTrackPtr);
 
   void NotifyOfCurrentTargetChanged(double aSimTime, const WsfLocalTrack* aRawTrackPtr);
 
   void NotifyOfLocalTrackCorrelation(double aSimTime, const WsfLocalTrack* aTrackPtr, const WsfTrackId& aRawTrackId);
 
   void NotifyOfLocalTrackDecorrelation(double aSimTime, const WsfLocalTrack* aLocalTrackPtr, const WsfTrackId& aRawTrackId);
 
   void NotifyOfLocalTrackDropped(double aLocalSimTime, const WsfLocalTrack* aTrackPtr);
 
   void NotifyOfLocalTrackInitiated(double aSimTime, const WsfLocalTrack* aLocalTrackPtr, const WsfTrack* aRawTrackPtr);
 
   void NotifyOfLocalTrackUpdated(double aSimTime, const WsfLocalTrack* aLocalTrackPtr, const WsfTrack* aRawTrackPtr);
 
   void NotifyOfRawTrackDropped(double aSimTime, const WsfTrack* aTrack);
 
   void NotifyOfRawTrackReceived(double aSimTime, const WsfTrack* aRawTrackPtr);
 
   void NotifyOfTrackManagerChanged(double aSimTime, WsfTrackManager* aNewManagerPtr);


   UtCallbackListN<void(double, const WsfLocalTrack*)>                    CandidateTrackPromoted;
   UtCallbackListN<void(double, const WsfLocalTrack*)>                    CurrentTargetChanged;
   UtCallbackListN<void(double, const WsfLocalTrack*, const WsfTrackId&)> LocalTrackCorrelation;
   UtCallbackListN<void(double, const WsfLocalTrack*, const WsfTrackId&)> LocalTrackDecorrelation;
   UtCallbackListN<void(double, const WsfLocalTrack*, const WsfTrack*)>   LocalTrackInitiated;
   UtCallbackListN<void(double, const WsfLocalTrack*)>                    LocalTrackDropped;
   UtCallbackListN<void(double, const WsfLocalTrack*, const WsfTrack*)>   LocalTrackUpdated;
   UtCallbackListN<void(double, const WsfTrack*)>                         RawTrackDropped;
   UtCallbackListN<void(double, const WsfTrack*)>                         RawTrackReceived;
   UtCallbackListN<void(double, WsfTrackManager*)>                        TrackManagerChanged;
 
   bool UpdateAuxData(double aSimTime, WsfLocalTrack& aLocalTrack, const WsfTrack& aNonLocalTrack);

   enum TrackStatusIndication
   {
      cNONE,                     
      cCREATED,                  
      cUPDATED,                  
      cDROPPED,                  
      cCANDIDATE_TRACK_PROMOTED, 
      cRAW_TRACK_DROPPED,        
      cRAW_TRACK_RECEIVED,       
      cCURRENT_TARGET_CHANGED,   
      cCORRELATED,               
      cDECORRELATED              
   };
 
   enum AuxDataFusionRule
   {
      cADF_PRIVATE,
      cADF_ONLY_LOCAL,
      cADF_PREFER_LOCAL
   };
 
   WsfSimulation* GetSimulation() const;
 
protected:
   WsfLocalTrack* InitiateTrackP(double aSimTime, const WsfTrack& aTrack);
 
   void AssessTrackQuality(double aSimTime, WsfTrack* aTrackPtr);
 
   WsfLocalTrack* CorrelateTrack(double aSimTime, const WsfTrack& aNonLocalTrack);
 
   void FuseTrack(double aSimTime, const WsfTrack& aNonLocalTrack, WsfLocalTrack& aLocalTrackPtr);
 
   WsfLocalTrack* AddMeasurement(double aSimTime, const WsfTrack& aMeasurement);
 
   WsfLocalTrack* GetPrototypeTrack() const { return mPrototypeTrackPtr; }
 
   const WsfScenario& GetScenario() const { return mScenario; }
 
private:
   WsfTrackManager& operator=(const WsfTrackManager&) = delete; // not implemented
 
   using AuxDataFusionRules = std::map<WsfStringId, AuxDataFusionRule>;
 
   void DecorrelateLocalTrack(double aSimTime, WsfLocalTrack& aLocalTrack, const WsfTrackId& aRawTrack);
 
   void CorrelateLocalTrack(double aSimTime, WsfLocalTrack& aLocalTrack, const WsfTrackId& aRawTrack);
 
   void DeleteCorrelatedRawTracks(double aSimTime, WsfLocalTrack& aLocalTrack);
 
   bool RemoveRawTrack(double aSimTime, const WsfTrackId& aTrackId);
 
   bool CanUpdateAuxData(WsfStringId aNameId, WsfLocalTrack& aLocalTrack, const WsfTrack& aNonLocalTrack);
 
   void ProcessAuxDataFusionInput(UtInput& aInput);
 
   const WsfScenario& mScenario;

   WsfPlatform* mPlatformPtr;

   bool mIsInitialized;

   bool mWillPurgeInactiveTracks;

   bool mDropUncorrelatedTracks;

   bool mRetainRawTracks;

   bool mMaintainTrackHistory;

   bool mIsFramed;
   bool mFrameStarted;

   bool mDebug;
   bool mInitiateLocalTracks;

   WsfLocalTrack* mPrototypeTrackPtr;

   WsfLocalTrackList* mTrackList; // This is the 'master' or primary track list maintained.
   WsfLocalTrackList* mFilteredRawTrackList;
   WsfTrackList*      mRawTrackList;

   WsfTrackId mCurrentTargetId;

   using InitialTrackList = std::vector<WsfTrack*>;
   InitialTrackList mInitialTracks;
   WsfTrackId       mInitialTargetId;

   WsfCorrelationStrategy* mCorrelationStrategyPtr;
   WsfFusionStrategy*      mFusionStrategyPtr;
   WsfFilter*              mPrototypeFilterPtr;
 
   AuxDataFusionRules mAuxDataFusionRules;
};
 
WSF_DECLARE_COMPONENT_ROLE_TYPE(WsfTrackManager, cWSF_COMPONENT_TRACK_MANAGER)
 
#endif