WsfTrack.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 WSFTRACK_HPP
#define WSFTRACK_HPP
 
#include "wsf_export.h"
 
#include <memory>
#include <vector>
 
class UtInput;
class UtInputBlock;
#include "UtMatrix.hpp"
#include "UtReferenceTracked.hpp"
#include "UtScriptAccessible.hpp"
#include "UtVec3.hpp"
#include "WsfAuxDataEnabled.hpp"
class WsfGeoPoint;
#include "WsfKinematicStateExtrapolation.hpp"
#include "WsfMeasurement.hpp"
class WsfObject;
class WsfPlatform;
class WsfScenario;
class WsfSimulation;
#include "WsfStringId.hpp"
class WsfTrack;
#include "WsfTrackId.hpp"
#include "WsfTypes.hpp"

class WSF_EXPORT WsfTrack_Signal
{
public:
   WsfTrack_Signal();
   WsfTrack_Signal(double aFrequency);
   WsfTrack_Signal(double aLowerFreq, double aUpperFreq);
   WsfTrack_Signal(double aLowerFreq, double aUpperFreq, double aPRI, double aPW);

   bool operator==(const WsfTrack_Signal& aRhs) const;

   template<typename T>
   void Serialize(T& aBuff)
   {
      aBuff& mLowerFrequency& mUpperFrequency& mPulseRepetitionInterval& mPulseWidth;
   }
 
   double      mLowerFrequency;
   double      mUpperFrequency;
   double      mPulseRepetitionInterval;
   double      mPulseWidth;
   WsfStringId mEmitterTruthId;
   WsfStringId mEmitterDerivedId;
};

struct WsfTrack_SignalList
{
   std::vector<WsfTrack_Signal> mSignalList;

   template<typename T>
   void Serialize(T& aBuff)
   {
      aBuff& mSignalList;
   }
};

 
class WSF_EXPORT WsfTrack : public UtScriptAccessible, public UtReferenceTracked, public WsfMeasurement, public WsfAuxDataEnabled
{
public:
   using Signal = WsfTrack_Signal;

   enum TrackType
   {
      cUNFILTERED_SENSOR,
      cFILTERED_SENSOR,
      cPREDEFINED,
      cPROCESSED,
      cSTATIC_IMAGE,
      cPSEUDO_SENSOR
   };

   enum IFF_Status
   {
      cIFF_UNKNOWN,
      cIFF_AMBIGUOUS,
      cIFF_FOE,
      cIFF_FRIEND,
      cIFF_NEUTRAL
   };

   class EmitterTypeData
   {
   public:
      EmitterTypeData()
         : mEmitterTruthId()
         , mEmitterDerivedId()
         , mSignalIndices()
      {
      }
 
      EmitterTypeData(WsfStringId aTruthEmitterTypeId, WsfStringId aEmitterTypeId)
         : mEmitterTruthId(aTruthEmitterTypeId)
         , mEmitterDerivedId(aEmitterTypeId)
         , mSignalIndices()
      {
      }
 
      int GetSignalIndexEntry(unsigned int aIndex)
      {
         int signalIndex(0);
         if ((aIndex < mSignalIndices.size()))
         {
            signalIndex = mSignalIndices[aIndex];
         }
         return signalIndex;
      }

      template<typename T>
      void Serialize(T& aBuff)
      {
         aBuff& mEmitterTruthId& mEmitterDerivedId& mSignalIndices;
      }
 
      WsfStringId      mEmitterTruthId;
      WsfStringId      mEmitterDerivedId;
      std::vector<int> mSignalIndices;
   };

   struct EmitterTypeIdList
   {
      std::vector<EmitterTypeData> mEmitterTypeIdList;

      template<typename T>
      void Serialize(T& aBuff)
      {
         aBuff& mEmitterTypeIdList;
      }
   };

   enum CopyCaller
   {
      cCC_COPY_CONSTRUCTOR,

      cCC_ASSIGNMENT,

      cCC_REPLACEMENT_UPDATE
   };
 
   WsfTrack();
   WsfTrack(WsfStringId aOriginatorNameId, WsfStringId aOriginatorTypeId);
   WsfTrack(TrackType aTrackType, WsfObject* aOriginatingProcessorOrSensor, WsfPlatform* aOriginatingPlatform);
   WsfTrack(const WsfTrack& aSrc);
 
   ~WsfTrack() override;
 
   WsfTrack*    Clone() const override;
   virtual void Initialize(double aSimTime, const WsfTrackId& aTrackId, WsfSimulation& aSimulation);
   void         SetSimulation(WsfSimulation* aSimulationPtr);
   void         Update(double aSimTime) override;
   void         KinematicUpdate(double aSimTime) override;
   virtual void ReplacementUpdate(const WsfTrack& aSource);
   virtual void UpdateFromMeasurement(double aSimTime, const WsfTrack& aMeasurement);
 
   const char* GetScriptClassName() const override;

   bool IsTrack() const override { return true; }
 
   void SetPlatformOriginator(WsfPlatform* aPlatformPtr);
   void SetProcessorOriginator(WsfObject* aProcessorPtr, WsfPlatform* aPlatformPtr);
   void SetSensorOriginator(WsfObject* aSensorPtr, WsfPlatform* aPlatformPtr);
   void SetSensorOriginator(WsfStringId aSensorNameId, WsfStringId aSensorTypeId);

   const WsfTrackId& GetTrackId() const { return mTrackId; }

   void SetTrackId(const WsfTrackId& aTrackId) { mTrackId = aTrackId; }

   TrackType GetTrackType() const { return mTrackType; }

   void SetTrackType(TrackType aTrackType);

   bool IsPredefinedTrack() const { return (mTrackType == cPREDEFINED); }

   double GetStartTime() const { return mStartTime; }

   void SetStartTime(double aStartTime) { mStartTime = aStartTime; }

   double GetUpdateTime() const { return mUpdateTime.Get(); }

   double GetLastUpdateInterval() const { return (mLastUpdateTime.Get() - mUpdateTime.Get()); }

   // void SetUpdateTime(double aUpdateTime)               { mUpdateTime = aUpdateTime; }

   int GetUpdateCount() const { return mUpdateCount; }

   void SetUpdateCount(int aUpdateCount) { mUpdateCount = aUpdateCount; }

   double GetMessageDataTag() const { return mMessageDataTag; }

   void SetMessageDataTag(double aMessageDataTag) { mMessageDataTag = aMessageDataTag; }

   WsfStringId GetOriginatorNameId() const { return mOriginatorNameId; }

   size_t GetOriginatorIndex() const { return mOriginatorPlatformIndex; }

   WsfStringId GetOriginatorTypeId() const { return mOriginatorTypeId; }

   WsfStringId GetProcessorNameId() const { return mProcessorNameId; }

   WsfStringId GetProcessorTypeId() const { return mProcessorTypeId; }

   WsfStringId GetSensorNameId() const { return mSensorNameId; }

   WsfStringId GetSensorTypeId() const { return mSensorTypeId; }

   WsfStringId GetSensorModeId() const { return mSensorModeId; }

   void SetSensorModeId(WsfStringId aSensorModeId) { mSensorModeId = aSensorModeId; }

   bool IsFusible() const { return mIsFusible; }

   void SetFusible(bool aIsFusible) { mIsFusible = aIsFusible; }

   virtual void SetPurgeable(bool aIsPurgeable) { mIsPurgeable = aIsPurgeable; }

   bool IsPurgeable() const { return mIsPurgeable; }

   bool IsStale() const { return mIsStale; }

   void SetStale(bool aIsStale) { mIsStale = aIsStale; }



   bool IsReportable() const { return mIsReportable; }
 
   void IsReportable(bool aIsReportable);
 
   bool Is3D() const;

   void Set3D(bool aIs3D) { mIs3D = aIs3D; }

   void SetReportable(bool aIsReportable) { mIsReportable = aIsReportable; }
 
   using History = std::vector<std::unique_ptr<WsfMeasurement>>; // track history type
 
   bool             HasHistory() const;
   virtual History& GetHistory() const;


 
   bool IFF_StatusValid() const { return mIFF_Status.IsValid(); }
 
   IFF_Status GetIFF_Status() const { return (const IFF_Status)mIFF_Status.Get(); }

   void SetIFF_Status(IFF_Status aIFF_Status)
   {
      mIFF_Status.Set(aIFF_Status);
      mIFF_Status.SetValid(true);
   }

 



   double GetTrackQuality() const;

   double GetTrackQuality(double aSimTime) const;
 
   void SetTrackQuality(double aTrackQuality);




   double GetQuality() const;

   double GetQuality(double aSimTime) const;

   double GetExpectedLocationError() const;

   double GetExpectedLocationError(double aSimTime) const;



 
   using SignalList = WsfTrack_SignalList;
   const SignalList* GetSignalList() const { return mSignalListPtr.Get(); }
 
   void         AddSignal(const Signal& aSignal);
   unsigned int GetSignalCount() const;
   void         GetSignalEntry(unsigned int aIndex, Signal& aSignal) const;
   void         MergeSignalLists(const WsfTrack& aOtherTrack);
   void         SetSignalList(const std::vector<Signal>& aSignalList);
 
   double GetFrequency() const;
   void   SetFrequency(double aFrequency);
 
   bool FrequencyValid() const;
   void SetFrequencyValid(bool aFrequencyValid);



 
   void         AddEmitterTypeId(const EmitterTypeData& aEmitterTypeData);
   void         AddEmitterTypeId(WsfStringId aTruthEmitterTypeId, WsfStringId aEmitterTypeId);
   unsigned int GetEmitterTypeIdCount() const;
   void         GetEmitterTypeIdEntry(unsigned int aIndex, EmitterTypeData& aEmitterTypeData) const;
   void         MergeEmitterTypeIdLists(const WsfTrack& aOtherTrack);
   void         SetEmitterTypeIdList(const std::vector<EmitterTypeData>& aEmitterTypeIdList);
 

   bool EmitterTypeIdValid() const { return mEmitterTypeIdListPtr.IsValid(); }
   void SetEmitterTypeIdValid(bool aEmitterTypeIdValid) { mEmitterTypeIdListPtr.SetValid(aEmitterTypeIdValid); }




   double GetSignalToNoise() const { return mSignalToNoise.Get(); }
   void SetSignalToNoise(double aSignalToNoise) { mSignalToNoise.Set(aSignalToNoise); }

   bool SignalToNoiseValid() const { return mSignalToNoise.IsValid(); }
   void SetSignalToNoiseValid(bool aSignalToNoiseValid) { mSignalToNoise.SetValid(aSignalToNoiseValid); }




   double GetPixelCount() const { return mPixelCount.Get(); }
   void SetPixelCount(double aPixelCount) { mPixelCount.Set(aPixelCount); }


   // Set as a UtMatrix.
   const UtMatrixd* GetResidualCovarianceMatrix() const;
 
   // Set as a covariance object.
   const UtCovariance* GetResidualCovariance() const { return mResidualCovariancePtr.Get(); }
   void                SetResidualCovariance(const UtCovariance& aResidualCovarianceMatrix);
   void                SetResidualCovariance(UtCovariance* aResidualCovarianceMatrixPtr);
   bool                ResidualCovarianceValid() const;
   void                SetResidualCovarianceValid(bool aStateCovarianceValid);
 
   bool ProcessNoiseVariancesValid() const;
   void GetProcessNoiseVariancesECS(double aProcessNoiseVariancesECS[3]) const;
   void SetProcessNoiseVariancesECS(double aProcessNoiseVariancesECS[3]);
   int  GetProcessNoiseModel() const;



   void SetIsCandidate(bool aIsCandidate) { mIsCandidate = aIsCandidate; }

   bool IsCandidate() const { return mIsCandidate; }




   void SetIsFalseTarget(bool aIsFalseTarget) { mIsFalseTarget = aIsFalseTarget; }

   bool IsFalseTarget() const { return mIsFalseTarget; }



   void SetIsStrobe(bool aIsStrobe) { mIsStrobe = aIsStrobe; }

   bool IsStrobe() const { return mIsStrobe; }

   //


   void SetTarget(const WsfPlatform& aTarget);

   void SetTargetIndex(size_t aTargetIndex) { mTargetIndex = aTargetIndex; }

   size_t GetTargetIndex() const;

   void SetTargetName(WsfStringId aTargetName) { mTargetName = aTargetName; }

   WsfStringId GetTargetName() const { return mTargetName; }

   void SetTargetType(WsfStringId aTargetType) { mTargetType = aTargetType; }

   WsfStringId GetTargetType() const;



   void SetLastSourceName(WsfStringId aSourceName) const { mLastSourceName = aSourceName; }

   WsfStringId GetLastSourceName() const { return mLastSourceName; }


 
   bool ProcessInput(UtInput& aInput) override;
   void ProcessInputBlock(const WsfScenario& aScenario, UtInputBlock& aInputBlock);
   static bool LoadTrackInstance(const WsfScenario& aScenario, UtInput& aInput, WsfPlatform* aPlatformPtr, WsfTrack*& aTrackPtr);
 
   WsfTrack& operator=(const WsfTrack& aRhs);


   void SetGlobalTrackNumber(int aNumber) { mGlobalTrackNumber = aNumber; }
   int  GetGlobalTrackNumber() const { return mGlobalTrackNumber; }
 
   WsfSimulation* GetSimulation() const { return mSimulationPtr; }

   bool LineOfSightRatesFrom(double aSimTime, WsfPlatform* aObserver, double& aLOSR_Az, double& aLOSR_El);
 
   // ================================= WARNING: New member variables ===========================
   //
   //    This class is transmitted over the network. If you add a new member variable, it is
   //    YOUR RESPONSIBILITY to verify that the member is serialized correctly.
   //    Please see the implementation of WsfTrack::SerializeP in xio/WsfXIO_SerializeTypes.cpp
   //
   // ===========================================================================================

   template<typename T>
   void SerializeP(T& aBuff);
 
protected:
   bool UseQuantitativeTrackQuality() const;
 
   WsfTrackId          mTrackId;
   TrackType           mTrackType;
   WsfStringId         mOriginatorNameId;
   size_t              mOriginatorPlatformIndex;
   WsfStringId         mOriginatorTypeId;
   WsfStringId         mProcessorNameId;
   WsfStringId         mProcessorTypeId;
   WsfStringId         mSensorNameId;
   WsfStringId         mSensorTypeId;
   WsfStringId         mSensorModeId;
   int                 mUpdateCount;
   double              mStartTime;
   UtDoubleInformation mLastUpdateTime;
   int                 mGlobalTrackNumber;
 
   // The 'data tag' to be attached to a message containing this track.
   double mMessageDataTag;
 
   // Target track data are all UtAttribute-based.
   // Actual location of the originator at the time of the report.
   // The following pointers are always valid.
   // I am intentionally excepting the standard that pointer variable names end in "Ptr"
   using IFF_StatusInformation       = UtInformation<int>;
   using SignalListPtrInformation    = UtInformation<SignalList*>;
   using EmitterTypeIdPtrInformation = UtInformation<EmitterTypeIdList*>;
 
   UtDoubleInformation         mTrackQuality;
   UtDoubleInformation         mSignalToNoise;
   UtDoubleInformation         mPixelCount;
   IFF_StatusInformation       mIFF_Status;
   SignalListPtrInformation    mSignalListPtr;
   EmitterTypeIdPtrInformation mEmitterTypeIdListPtr;
   UtCovariancePtrInformation  mResidualCovariancePtr;
 
   union
   {
      struct
      {
         bool mIsFusible : 1;
         bool mIsPurgeable : 1;
         bool mIsStale : 1;
         bool mIs3D : 1;
         bool mIsReportable : 1;
         bool mIsCandidate : 1;
         bool mIsStrobe : 1;      // The track is a strobe detection from an interference possibly.
         bool mIsFalseTarget : 1; // The track is a spurious target, w/no real target platform.
      };
 
      unsigned int mFlags;
   };
 
   int mFalseTargetId; // Implementation-defined unique ID for this false target.

   mutable WsfStringId mLastSourceName;
 
   mutable History mHistory; // optional track history (possibly to be maintained by the tracker itself).
 
private:
   void ConstructInformation();
   void InitializeMemberData();
   void CopyMemberData(const WsfTrack& aSrc, CopyCaller aCaller);
 
   // The following are deprecated and should remain private.
   void SetResidualCovarianceMatrix(const UtMatrixd& aResidualCovarianceMatrix);
 
   // These values may need to be computed when requested, accessors should be used to get values
   mutable size_t      mTargetIndex; // Platform index of the target platform
   WsfStringId         mTargetName;
   mutable WsfStringId mTargetType;
};
 
#endif