WsfMeasurement.hpp

Go to the documentation of this file.

// ****************************************************************************
// CUI
//
// The Advanced Framework for Simulation, Integration, and Modeling (AFSIM)
//
// Copyright 2016 Infoscitex, a DCS 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 WSFMEASUREMENT_HPP
#define WSFMEASUREMENT_HPP
 
#include "wsf_export.h"
 
#include <map>
#include <string>
 
#include "UtCloneablePtr.hpp"
class UtInput;
#include "UtMeasurementData.hpp"
#include "UtMemory.hpp"
class WsfFilter;
class WsfSimulation;
#include "WsfTrackExtrapolation.hpp"
#include "WsfTrackExtrapolators.hpp"
#include "WsfTypes.hpp"

class WSF_EXPORT WsfMeasurement : public UtMeasurementData
{
public:
   WsfMeasurement();
   WsfMeasurement(const WsfMeasurement& aSrc) = default;
   virtual WsfMeasurement* Clone() const;
 
   virtual bool ProcessInput(UtInput& aInput);
   virtual void Update(double aSimTime){};
 
   virtual bool IsTrack() const { return false; }



   virtual WsfFilter* GetFilter() { return nullptr; }

   virtual const WsfFilter* GetFilter() const { return nullptr; }
   //


 
   virtual bool GetExtrapolatedLocationWCS(double aSimTime, double aLocationWCS[3]) const;

   template<typename T>
   bool GetExtrapolatedData(double aSimTime, const std::string& aExtrapolationType, T& aData) const
   {
      const wsf::TrackExtrapolators* extrapolatorsPtr = GetTrackExtrapolators();
      if (extrapolatorsPtr != nullptr)
      {
         const wsf::TrackExtrapolationBase* extrapolatorBasePtr = extrapolatorsPtr->Find(aExtrapolationType);
         if (extrapolatorBasePtr != nullptr)
         {
            auto extrapolatorPtr = dynamic_cast<const wsf::TrackExtrapolation<T>*>(extrapolatorBasePtr);
            std::unique_ptr<UtAttribute<T>> dataPtr = extrapolatorPtr->Extrapolate(aSimTime, *this);
            if (dataPtr != nullptr)
            {
               aData = dataPtr->Get();
               return true;
            }
         }
      }
      return false;
   }

 
   virtual void KinematicUpdate(double aSimTime);

   WsfSimulation* GetSimulation() const { return mSimulationPtr; }

   void SetSimulation(WsfSimulation& aSimulation) { mSimulationPtr = &aSimulation; }
 
   void SetSphericalMeasurement(double aSimTime, double aAzimuth, double aElevation, double aRange, double aRangeRate);




   WsfSpatialDomain GetSpatialDomain() const { return (WsfSpatialDomain)mSpatialDomain.Get(); }
   void SetSpatialDomain(const WsfSpatialDomain& aSpatialDomain) { mSpatialDomain.Set(aSpatialDomain); }
   double GetDefaultAltitude() const { return WsfMeasurement::GetDefaultAltitude(GetSpatialDomain()); }
 
protected:
   // Default altitude methods for estimating location from range-bearing tracks
   static double GetDefaultAltitude(WsfSpatialDomain aDomain);
 
   using WsfSpatialDomainInformation = UtInformation<int>;
 
   WsfSpatialDomainInformation    mSpatialDomain;
   const wsf::TrackExtrapolators* GetTrackExtrapolators() const;
 
   WsfSimulation* mSimulationPtr{nullptr};
 
private:
   static double cDEFAULT_ALTITUDE_LAND;       
   static double cDEFAULT_ALTITUDE_AIR;        
   static double cDEFAULT_ALTITUDE_SPACE;      
   static double cDEFAULT_ALTITUDE_SURFACE;    
   static double cDEFAULT_ALTITUDE_SUBSURFACE; 
 
   mutable ut::CloneablePtr<wsf::TrackExtrapolators> mExtrapolatorsPtr{nullptr};
};
 
#endif