WsfDefaultSensorTracker.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 WSFDEFAULTSENSORTRACKER_HPP
#define WSFDEFAULTSENSORTRACKER_HPP
 
#include "wsf_export.h"
 
#include <map>
 
class WsfFilter;
#include "WsfSensor.hpp"
#include "WsfSensorTracker.hpp"
#include "WsfTrackId.hpp"
#include "WsfUtil.hpp"

 
class WSF_EXPORT WsfDefaultSensorTracker : public WsfSensorTracker
{
public:
   WsfDefaultSensorTracker(WsfScenario& aScenario);
 
   ~WsfDefaultSensorTracker() override;
 
   WsfSensorTracker* Clone() const override;
 
   unsigned int GetActiveTrackCount() const override;
 
   void GetActiveTrackList(WsfTrackList& aActiveTrackList) override;
 
   unsigned int GetMaximumTrackCount() const override;
 
   bool GetTargetState(double aSimTime, const WsfTrackId& aRequestId, TargetState& aTargetState) override;
 
   void GetRequestDataForTarget(size_t aObjectId, WsfTrackId& aRequestId, size_t& aModeIndex, WsfTrackId& aTrackId) const override;
 
   bool Initialize(double aSimTime, WsfSensor* aSensorPtr, WsfSensorScheduler* aSchedulerPtr) override;
 
   bool ProcessInput(UtInput& aInput) override;
 
   void SchedulerModeChange(double            aSimTime,
                            const WsfTrackId& aRequestId,
                            size_t            aObjectId,
                            WsfPlatform*      aTargetPtr,
                            WsfStringId       aNewModeName) override;
 
   void StopTracking(double aSimTime, const WsfTrackId& aRequestId) override;
 
   virtual void TargetBlocked(double aSimTime, const Settings& aSettings, const WsfTrackId& aRequestId, unsigned int aObjectId);
 
   bool TargetDeleted(double aSimTime, const Settings& aSettings, const WsfTrackId& aRequestId, size_t aObjectId) override;
 
   void TargetDetected(double            aSimTime,
                       const Settings&   aSettings,
                       const WsfTrackId& aRequestId,
                       size_t            aObjectId,
                       WsfPlatform*      aTargetPtr,
                       WsfSensorResult&  aResult) override;
 
   bool TargetSkipped(double aSimTime, const Settings& aSettings, const WsfTrackId& aRequestId, size_t aObjectId) override;
 
   void TargetUndetected(double            aSimTime,
                         const Settings&   aSettings,
                         const WsfTrackId& aRequestId,
                         size_t            aObjectId,
                         WsfPlatform*      aTargetPtr,
                         WsfSensorResult&  aResult) override;
 
   void TurnOff(double aSimTime) override;
 
   WsfScenario* GetScenario() const { return mScenarioPtr; }

   class WSF_EXPORT State
   {
   public:
      State(const WsfTrackId& aRequestId, const WsfSensor::Result& aResult);
      ~State();

      WsfTrackId mRequestId;

      WsfFilter* mFilterPtr{nullptr};

      WsfTrack* mTrackPtr{nullptr};

      double mLockonTime{-1.0};
 
      static constexpr size_t cINVALID_TARGET_INDEX = ut::npos;

      size_t mTargetIndex{cINVALID_TARGET_INDEX};

      size_t mModeIndex{0};

      size_t mXmtrIndex{0};

      size_t mRcvrIndex{0};

      unsigned int mDetectionHistory{0};

      int mFailuresUntilDrop{-1};

      bool mModeSwitchActive{false};

      bool mFalseTargetTrack{false};
   };
 
protected:
   WsfDefaultSensorTracker(const WsfDefaultSensorTracker& aSrc);
   WsfDefaultSensorTracker& operator=(const WsfDefaultSensorTracker&) = delete;
 
   void CheckForAutoModeSwitch(double aSimTime, size_t aObjectId, WsfPlatform* aTargetPtr, size_t aNewModeIndex);
 
   virtual void DropTrack(double aSimTime, State* aStatePtr);
 
   bool SwitchMode(double aSimTime, State* aStatePtr, size_t aNewModeIndex);
 
   void ProcessSensorDetectionChanged(double aSimTime, const State& aState, unsigned int aStatus);
 
   WsfScenario* mScenarioPtr;

   unsigned int mMaximumTrackCount;

   unsigned int mActiveTrackCount;

   WsfFilter* mFilterPtr;

   std::vector<WsfSensorMode*> mModeList;

   using StateList = std::map<size_t, State*>;
   StateList mStateList;

   using StateListIter = StateList::iterator;

   bool mSendTrackDropOnTurnOff;

   bool mTurnOffInProgress;
};
 
#endif