WsfOpticalSensor.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 WSFOPTICALSENSOR_HPP
#define WSFOPTICALSENSOR_HPP
 
#include "wsf_mil_export.h"
 
#include <map>
#include <memory>
#include <vector>
 
#include "UtAtmosphere.hpp"
#include "WsfEM_Antenna.hpp"
#include "WsfEM_Rcvr.hpp"
class WsfPlatform;
#include "WsfSensor.hpp"
#include "WsfSensorMode.hpp"

 
class WSF_MIL_EXPORT WsfOpticalSensor : public WsfSensor
{
public:
   WsfOpticalSensor(WsfScenario& aScenario);
   WsfOpticalSensor(const WsfOpticalSensor& aSrc);
   WsfOpticalSensor& operator=(const WsfOpticalSensor&) = delete;
 
   WsfSensor* Clone() const override;
   bool       Initialize(double aSimTime) override;
   void       Update(double aSimTime) override;
 
   size_t      GetEM_RcvrCount() const override;
   WsfEM_Rcvr& GetEM_Rcvr(size_t aIndex) const override;
 
   void PlatformDeleted(WsfPlatform* aPlatformPtr) override;

   class OpticalMode : public WsfSensorMode
   {
   public:
      OpticalMode(WsfScenario& aScenario);
      OpticalMode(const OpticalMode& aSrc);
      OpticalMode& operator=(const OpticalMode&) = delete;
      ~OpticalMode() override                    = default;
 
      WsfMode* Clone() const override;
      bool     Initialize(double aSimTime) override;
      bool     ProcessInput(UtInput& aInput) override;
 
      bool AttemptToDetect(double aSimTime, WsfPlatform* aTargetPtr, Settings& aSettings, WsfSensorResult& aResult) override;
 
      void Deselect(double aSimTime) override;
      void Select(double aSimTime) override;
 
      virtual void PlatformDeleted(WsfPlatform* aPlatformPtr);
 
      double ComputeAtmosphericTransmittance(WsfSensorResult& aResult);
 
      double ComputeProbabilityOfDetection(double aSize, double aContrast, size_t aTgtIndex);
 
      double ComputeSimpleTransmittance(double aAttenuationPerMeter,
                                        double aHeightMSL_1,
                                        double aHeightMSL_2,
                                        double aGroundRange);
 
      std::unique_ptr<WsfEM_Antenna> mAntenna;
      std::unique_ptr<WsfEM_Rcvr>    mRcvr;

      double mGlimpseTime;

      double mReacquireTime;

      double mAtmosphericAttenuation;

      double mBackgroundRadiance;

      double mPathRadiance;
 
      bool mVerbose;

      UtAtmosphere mAtmosphere;

      double mRhoSeaLevel;

      struct CumPd
      {
         CumPd(double aSearchPd = 1.0, double aReacquirePd = 0.0, double aTrackPd = 0.0)
            : mSearchPd(aSearchPd)
            , mReacquirePd(aReacquirePd)
            , mTrackPd(aTrackPd)
         {
         }
 
         double mSearchPd;
         double mReacquirePd;
         double mTrackPd;
      };

      class GlimpseProbability
      {
      public:
         GlimpseProbability();
         GlimpseProbability(const GlimpseProbability& aSrc) = default;
         GlimpseProbability& operator=(const GlimpseProbability&) = delete;
         virtual ~GlimpseProbability()                            = default;
 
         virtual GlimpseProbability* Clone() const;
         virtual bool                Initialize();
         virtual bool                ProcessInput(UtInput& aInput);
         virtual double              ProbabilityOfDetection(double aSize, double aContrast);

         double mAzimuthFOV;

         double mMinElevation;

         double mMaxElevation;

         int mNumIterations;

         double mMagnification;

         double mApparentHalfAngle;

         double mResolution;

         double mGain;

         double mOcularIntegration;
 
      protected:
         virtual void   ComputeProbabilityDistribution();
         virtual double ContrastRatioToPd(double aRatio);
         virtual double InterpolateDistribution(double aThetaMin, double aThetaMax);
         virtual double ContrastThreshold(double aSolidAngle, double aAngle);
         virtual double ContrastThreshold0(double aAlpha);
         virtual double ContrastThreshold1(double aAlpha);

         std::vector<double> mProbabilityDistribution;
      };
 
   protected:
      std::map<size_t, CumPd> mPdMap;

      GlimpseProbability mSearch;
      GlimpseProbability mReacquire;
      GlimpseProbability mTrack;
   };
 
protected:
   std::vector<OpticalMode*> mOpticalModeList;
};
 
#endif