WsfFusionStrategy.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 WSFFUSIONSTRATEGY_HPP
#define WSFFUSIONSTRATEGY_HPP
 
#include "wsf_export.h"
 
#include <string>
 
class UtInput;
#include "UtMatrix.hpp"
#include "WsfException.hpp"
class WsfLocalSensorResult;
class WsfLocalTrack;
#include "WsfObject.hpp"
#include "WsfObjectTypeList.hpp"
class WsfProcessor;
class WsfSensorResult;
class WsfSimulation;
#include "WsfStringId.hpp"
class WsfTrack;
class WsfTrackManager;
#include "WsfTypes.hpp"

class WSF_EXPORT WsfFusionStrategy : public WsfObject
{
public:
   ~WsfFusionStrategy() override = default;

   WsfFusionStrategy* Clone() const override = 0; // pure virtual

   bool ProcessInput(UtInput& aInput) override { return false; }

   virtual bool Initialize(WsfTrackManager* aTrackManagerPtr)
   {
      mTrackManagerPtr = aTrackManagerPtr;
      return true;
   };

   virtual bool Initialize(WsfProcessor* aProcessorPtr)
   {
      mProcessorPtr = aProcessorPtr;
      return true;
   };

   virtual bool DebugEnabled() const;

   virtual bool UpdateLocalTrackFromNonLocalTrack(double          aSimTime,
                                                  WsfLocalTrack&  aLocalTrack,
                                                  const WsfTrack& aNonLocalTrack) = 0;

   virtual bool UpdateLocalResultFromNonLocalResult(double                 aSimTime,
                                                    WsfLocalSensorResult&  aLocalResult,
                                                    const WsfSensorResult& aNonLocalResult) = 0;

   virtual bool InitializeLocalTrackFromNonLocalTrack(double aSimTime, WsfLocalTrack& aLocalTrack, const WsfTrack& aNonLocalTrack)
   {
      return false;
   };

   virtual bool InitializeLocalResultFromNonLocalResult(double                 aSimTime,
                                                        WsfLocalSensorResult&  aLocalResult,
                                                        const WsfSensorResult& aNonLocalResult)
   {
      return false;
   };

   virtual void ReviewTrack(WsfLocalTrack& aLocalTrack) = 0;
 
   virtual bool UpdateNonKinematicData(double aSimTime, WsfLocalTrack& aLocalTrack, const WsfTrack& aNonLocalTrack);
 
   static bool UpdateNonKinematicData(double           aSimTime,
                                      WsfTrackManager& aTracManager,
                                      WsfLocalTrack&   aLocalTrack,
                                      const WsfTrack&  aNonLocalTrack);
 
   using FusionStrategyTypes = WsfObjectTypeList<WsfFusionStrategy>;
 
   WsfSimulation* GetSimulation() const;
   double         GetSimTime();
   WsfPlatform*   GetPlatform() const;

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

   WsfProcessor& GetProcessor() { return *mProcessorPtr; }
 
protected:
   WsfFusionStrategy();
   WsfFusionStrategy(const WsfFusionStrategy& aSrc);
   WsfFusionStrategy& operator=(const WsfFusionStrategy&) = delete;

   void SetTrackManager(WsfTrackManager& aTrackManager) { mTrackManagerPtr = &aTrackManager; }

   void SetProcessor(WsfProcessor& aProcessor) { mProcessorPtr = &aProcessor; }
 
   virtual bool UpdateIFF_Status(double aSimTime, WsfLocalTrack& aLocalTrack, const WsfTrack& aNonLocalTrack)
   {
      return false;
   }
 
   virtual bool UpdateSide(double aSimTime, WsfLocalTrack& aLocalTrack, const WsfTrack& aNonLocalTrack)
   {
      return false;
   }
 
   virtual bool UpdateType(double aSimTime, WsfLocalTrack& aLocalTrack, const WsfTrack& aNonLocalTrack)
   {
      return false;
   }
 
   virtual bool UpdateSpatialDomain(double aSimTime, WsfLocalTrack& aLocalTrack, const WsfTrack& aNonLocalTrack)
   {
      return false;
   }
 
   virtual bool UpdateTrackQuality(double aSimTime, WsfLocalTrack& aLocalTrack, const WsfTrack& aNonLocalTrack)
   {
      return false;
   }
 
   virtual bool UpdateSignalToNoise(double aSimTime, WsfLocalTrack& aLocalTrack, const WsfTrack& aNonLocalTrack)
   {
      return false;
   }
 
   virtual bool UpdateSignalList(double aSimTime, WsfLocalTrack& aLocalTrack, const WsfTrack& aNonLocalTrack)
   {
      return false;
   }
 
   virtual bool UpdateAuxData(double aSimTime, WsfLocalTrack& aLocalTrack, const WsfTrack& aNonLocalTrack)
   {
      return false;
   }
 
   // Some fusion-specific utilities that derived classes may use:
   static void FuseEstimates(const UtMatrixd& aEstimate1,
                             const UtMatrixd& aEstimate2,
                             const UtMatrixd& aCovar1,
                             const UtMatrixd& aCovar2,
                             UtMatrixd&       aEstimateOut,
                             UtMatrixd&       aCovarOut);
 
   static void NormalizeAzRangeEstimate(const UtMatrixd& aEstimate,
                                        const UtMatrixd& aCovar,
                                        const double&    aElevation,
                                        UtMatrixd&       aNormEstimate,
                                        UtMatrixd&       aNormCovar);
 
   static void NormalizeElRangeEstimate(const UtMatrixd& aEstimate,
                                        const UtMatrixd& aCovar,
                                        const double&    aAzimuth,
                                        UtMatrixd&       aNormEstimate,
                                        UtMatrixd&       aNormCovar);
 
private:
   static FusionStrategyTypes* mTypesPtr;
 
   WsfTrackManager* mTrackManagerPtr;
   WsfProcessor*    mProcessorPtr;
};
 
#endif