WsfTrackProcessor.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 WSFTRACKPROCESSOR_HPP
#define WSFTRACKPROCESSOR_HPP
 
#include "wsf_export.h"
 
#include <unordered_map>
 
#include "UtCallbackHolder.hpp"
#include "WsfEvent.hpp"
class WsfLocalTrack;
#include "script/WsfScriptProcessor.hpp"
class WsfTrack;
#include "WsfTrackId.hpp"
class WsfTrackManager;
class WsfTrackReportingStrategy;
class WsfScriptMessageHandler;

class WSF_EXPORT WsfTrackProcessor : public WsfScriptProcessor
{
public:
   WsfTrackProcessor(const WsfScenario& aScenario);
   WsfTrackProcessor& operator=(const WsfTrackProcessor&) = delete;
   ~WsfTrackProcessor() override;
 
   WsfProcessor* Clone() const override;
   bool          Initialize(double aSimTime) override;
   bool          ProcessInput(UtInput& aInput) override;
   bool          ProcessMessage(double aSimTime, const WsfMessage& aMessage) override;
   const char*   GetScriptClassName() const override;

   WsfTrackManager& GetTrackManager() const { return *mTrackManagerPtr; }

   wsf::ExternalLinks& GetExternalLinks() { return mExternalLinks; }
 
   bool InitializeMemberData(double aSimTime);
 
   void ConnectCallbacks();
 
   bool IsMasterTrackManager() const { return mMasterTrackProcessor; }
 
   virtual void SendTrack(double aSimTime, const WsfTrack& aTrack);
 
   virtual void SendTrack(double aSimTime, const WsfLocalTrack& aLocalTrack);


   virtual void PerformTrackPurging(double aSimTime);
   virtual void PerformTrackHistoryPurging(double aSimTime);
   virtual void PerformTrackReporting(double aSimTime);
   double       GetReportingInterval() const { return mReportInterval; }    // TODO-AWK HACK for Scenario Analyzer
   double       GetPurgeInterval() const { return mPurgeInterval; }         // TODO-AWK HACK for Scenario Analyzer
   bool         GetReportFusedTracks() const { return mReportFusedTracks; } // TODO-AWK HACK for Scenario Analyzer
   bool         GetReportRawTracks() const { return mReportRawTracks; }     // TODO-AWK HACK for Scenario Analyzer
 
protected:
   WsfTrackProcessor(const WsfTrackProcessor& aSrc);
 
   virtual bool IsTrackReportable(double aSimTime, const WsfTrack* aTrackPtr);
 
   virtual void NotifyPlatform(double aSimTime, const WsfTrack* aChangedTrackPtr, int aChangedReason);
 
   void ProcessInboundFilterBlock(UtInput& aInput);
 
   void SelectNonMasterTrackProcessor();
 
   virtual void SendTrackP(double aSimTime, const WsfTrack& aTrack);
 
   virtual bool ShouldProcessInboundReport(double aSimTime, const WsfTrack& aTrack);
 
private:

   void CandidateTrackPromoted(double aSimTime, const WsfLocalTrack* aLocalTrackPtr);
 
   void CurrentTargetChanged(double aSimTime, const WsfLocalTrack* aLocalTrackPtr);
 
   void LocalTrackDropped(double aSimTime, const WsfLocalTrack* aLocalTrackPtr);
 
   void LocalTrackInitiated(double aSimTime, const WsfLocalTrack* aLocalTrackPtr, const WsfTrack* aRawTrackPtr);
 
   void LocalTrackUpdated(double aSimTime, const WsfLocalTrack* aLocalTrackPtr, const WsfTrack* aRawTrackPtr);
 
   void RawTrackDropped(double aSimTime, const WsfTrack* aRawTrackPtr);
 
   void RawTrackReceived(double aSimTime, const WsfTrack* aRawTrackPtr);
 
   void SendTrackDropMessage(double aSimTime, const WsfTrack* aTrackPtr);
 
   void SendTrackNotifyMessage(double aSimTime, const WsfTrack* aTrackPtr, int aReason);
 
   void SendTrackUpdateMessage(double aSimTime, const WsfTrack* aTrackPtr);
 
   void TrackManagerChanged(double aSimTime, WsfTrackManager* aNewManagerPtr);
 
   void WriteTrackDebugMessage(double aSimTime, const WsfTrack* aTrackPtr, const std::string& aReason);
 
   void SelectMasterTrackProcessor(UtInput& aInput);
 
   void SelectNonMasterTrackProcessor(UtInput& aInput);


   double mPurgeInterval;
   double mTrackHistoryRetentionInterval;

   double mImagePurgeMultiplier;

   double mReportInterval;
 
   bool mReportFusedTracks;
   bool mReportCandidateTracks;
   bool mReportRawTracks;
   bool mReportUnchangedTracks;
   bool mReportPassThrough;
   bool mMasterTrackProcessor;
   bool mTrackManagerTypeSelected;
 
   bool mRejectCircularReports;
   bool mRejectNonSensorReports;
 
   bool mReportOnUpdate;
   bool mUpdateOnReport;
   bool mUpdateOnReportSet;
 
   WsfStringId                mReportingStrategyName;
   WsfTrackReportingStrategy* mReportingStrategyPtr;
 
   UtCallbackHolder mCallbacks;

   WsfTrackManager* mTrackManagerPtr;

   UtScript* mIsTrackReportableScriptPtr;

   using DroppedRawTrackList = std::unordered_map<WsfTrackId, double, WsfTrackId>;
   DroppedRawTrackList mDroppedRawTrackList;

   WsfStringId mSourceId;
 
   using LastReportTimeMap = std::unordered_map<WsfTrackId, double, WsfTrackId>;
   LastReportTimeMap mLastReportTime;
};

class WsfTrackProcessor_PurgeTracksEvent : public WsfEvent
{
public:
   WsfTrackProcessor_PurgeTracksEvent() = default;
   WsfTrackProcessor_PurgeTracksEvent(double aSimTime, WsfTrackProcessor* aProcessorPtr, double aPurgeInterval);
 
   EventDisposition Execute() override;
 
protected:
   double             mPurgeInterval;
   WsfTrackProcessor* mProcessorPtr;
   size_t             mPlatformIndex;
};

class WsfTrackProcessor_PurgeTrackHistoryEvent : public WsfTrackProcessor_PurgeTracksEvent
{
public:
   WsfTrackProcessor_PurgeTrackHistoryEvent() = default;
   WsfTrackProcessor_PurgeTrackHistoryEvent(double aSimTime, WsfTrackProcessor* aProcessorPtr, double aPurgeInterval);
 
   EventDisposition Execute() override;
};

class WsfTrackProcessor_ReportTracksEvent : public WsfEvent
{
public:
   WsfTrackProcessor_ReportTracksEvent() = default;
   WsfTrackProcessor_ReportTracksEvent(double aSimTime, WsfTrackProcessor* aProcessorPtr, double aReportInterval);
 
   EventDisposition Execute() override;
 
private:
   double             mReportInterval;
   WsfTrackProcessor* mProcessorPtr;
   size_t             mPlatformIndex;
};
 
#endif