ssSensor.h

Go to the documentation of this file.

// Copyright JRM Enterprises, Inc. 2004 - 2011
// All rights reserved.
//
// This code is the intellectual property of JRM Enterprises, Inc.
// It may not be used or released as source or compiled binary form
// without the prior written consent of JRM Enterprises, Inc.
//
// Original Author:     Eric Olson     Date: May 2004

#ifndef _ssSensor_
#define _ssSensor_

#include "ssdllexport.h"

#include "ssIncAll.h"
#include "platform.h" //QueryPerformanceCounter

class ssRadarSymbology;
// class: ssSensor
class SIGSIMRT_API ssSensor 
{
public:

    //ssSensor
    ssSensor();

    //ssSensor
    ssSensor(const ssSensor &old_sensor);

    //ssSensor
    ssSensor& operator= (const ssSensor &obj);

    //~ssSensor
    virtual ~ssSensor();

    //setBand
    bool setBand(double lower, double upper, int numBins);

    //getBand
    bool getBand(double &lower, double &upper, int &numBins);

    //getMinRadiance
    double getMinRadiance() const;

    //getMaxRadiance
    double getMaxRadiance() const;

    // getMinRange
    double getMinRange() const;

    // getMaxRange
    double getMaxRange() const;

   // getDisplayRange
   double getDisplayRange();

   // getPPIcurrentTime
    double getPPIcurrentTime(){return m_time;};

   // setDisplayRange
   void setDisplayRange(double range);

   // getMaxRadarRangeScale
   double getMaxRadarRangeScale();

   // setMaxRadarRangeScale
   void setMaxRadarRangeScale(double scale);

    // getMinWedgeExtent
    double getMinWedgeExtent() { return m_minWedgeExtent; }

    // setMinWedgeExtent
    void setMinWedgeExtent( double angle );

    // getMaxWedgeExtent
    double getMaxWedgeExtent() { return m_maxWedgeExtent; }

    // setMaxWedgeExtent
    void setMaxWedgeExtent( double angle);

    // getActiveSectorWidth
    double getActiveSectorWidth() { return m_activeSectorWidth; }

    // setActiveSectorWidth
    void setActiveSectorWidth( double angle);  

    // getMinCurScanExtent
    double getMinCurScanExtent() { return m_minCurScanExtent; }

    // getMaxCurScanExtent
    double getMaxCurScanExtent() { return m_maxCurScanExtent; }


    // getPrevMinCurScanExtent
    double getPrevMinCurScanExtent() { return m_prevMinCurScanExtent; }

    // getPrevMaxCurScanExtent
    double getPrevMaxCurScanExtent() { return m_prevMaxCurScanExtent; }

    // getBacksweepState
   bool getBacksweepState( ){  return m_enableBacksweep;  }

    // setBacksweepState
   void setBacksweepState( bool backsweep ){ m_enableBacksweep = backsweep; }

    // getStripAngleSize()
   double getStripAngleSize();

    
    // getPPIminVertAngle
   double getPPIminVertAngle( ){  return m_minVertAngle;  }

    // PPIscanControl
    void PPIscanControl();


    // getPrevStripAngleSize()
    double getPrevStripAngleSize(){ return m_prevStripAngleSize;}


    // getPrevHeadingOffset()
    double getPrevHeadingOffset(){ return m_prevHeadingOffset;}

    // getPrevRadarVertFOV()
    double getPrevRadarVertFOV(){ return m_prevRadarVertFOV;}

    
    // getPrevMinVertAngle()
    double getPrevMinVertAngle(){ return m_prevMinVertAngle;}

    // getOtwViewState
   bool getOtwViewState(){ return m_showOtwView ;}

    // setOtwViewState
   void setOtwViewState( bool show ){  m_showOtwView = show;   }

    // getSweepDoneFlag
    bool getSweepDoneFlag(){ return m_sweepDoneFlag;}

    // setSweepDoneFlag
    void setSweepDoneFlag(bool flag){ m_sweepDoneFlag = flag;}

    // getLastStripFlag
    bool getLastStripFlag(){ return m_lastStripFlag;}

    // getHeadingOffset
   double getHeadingOffset(){ return m_headingOffset ;}

    // setHeadingOffset
   void setHeadingOffset( double offset ){m_prevHeadingOffset = m_headingOffset; m_headingOffset = offset;  }

    // getPitchOffset
    double getPitchOffset(){ return m_pitchOffset ;}
    
    // setPitchOffset
    void setPitchOffset( double offset ){ m_pitchOffset = offset; }

    // getRadarVertFOV
    double getRadarVertFOV(){ return m_radarVertFOV ;}
    
    // setRadarVertFOV
    void setRadarVertFOV( double fov ){   m_prevRadarVertFOV = m_radarVertFOV; m_radarVertFOV = fov;  }

    // getRadarAspectRatio
    double getRadarAspectRatio(){ return m_radarAspectRatio ;}
         
    // setRadarAspectRatio
    void setRadarAspectRatio( double ratio ){   m_radarAspectRatio = ratio;   }

    // getMinVertAngle
    double getMinVertAngle(){ return m_minVertAngle ;}
    
    // setMinVertAngle
    void setMinVertAngle( double angle ){ m_prevMinVertAngle = m_minVertAngle; m_minVertAngle = angle;   }

    // isPPIresetMode
    bool isPPIresetMode(){ return m_PPIresetMode ;}

    // setPPIresetMode
   void setPPIresetMode( bool flag ){  m_PPIresetMode = flag;  }

    // getPPIOverrideReset
    bool getPPIOverrideReset() const
    {
        return m_overrideReset;
    }

    // resetPPIOverride
    void resetPPIOverride()
    {
        m_overrideReset = false;
    }

    // setPPIDisplayOffsetScale
    void setPPIDisplayOffsetScale(int offsetWidth = 0, int offsetHeight = 0, float scaleWidth = 1.0f, float scaleHeight = 1.0f)
    {
        m_PPIoffsetWidth = offsetWidth;
        m_PPIoffsetHeight = offsetHeight;
        m_PPIscaleWidth = scaleWidth;
        m_PPIscaleHeight = scaleHeight;
    }

    // getPPIDisplayOffsetScale
    void getPPIDisplayOffsetScale(int &offsetWidth, int &offsetHeight, float &scaleWidth, float &scaleHeight)
    {
        offsetWidth = m_PPIoffsetWidth;
        offsetHeight = m_PPIoffsetHeight;
        scaleWidth = m_PPIscaleWidth;
        scaleHeight = m_PPIscaleHeight;
    }
    
    // setDBScenter
    void setDBScenter(double centerX, double centerY);

    // getStripBufferSize
    void getStripBufferSize(int &crossRangeSize, int &downRangeSize)
    {
        downRangeSize = m_downRangeBinSize;
        crossRangeSize = m_crossRangeBinSize;
    }

    // getPrevStripBufferSize
    void getPrevStripBufferSize(int &crossRangeSize, int &downRangeSize)
    {
        downRangeSize = m_prevDownRangeBinSize;
        crossRangeSize = m_prevCrossRangeBinSize;
    }

    // getDBScenter
    void getDBScenter(double &centerX, double &centerY)
    {
        centerX = m_DBScenterX;
        centerY = m_DBScenterY;
    }

    // setGMTIMode
    void setGMTIMode(int mode);

    // getGMTIMode
    int getGMTIMode() const
    {
        return m_gmtiMode;
    }

    // setGMTITrackFilterMode
    void setGMTITrackFilterMode(int mode)
    {
        m_gmtiTrackFilterMode = mode;
    }

    // getGMTITrackFilterMode
    int getGMTITrackFilterMode() const
    {
        return m_gmtiTrackFilterMode;
    }

    // setGMTITrackFilterID
    void setGMTITrackFilterID(int id)
    {
        m_gmtiTrackFilterID = id;
    }

    // getGMTITrackFilterID
    int getGMTITrackFilterID() const
    {
        return m_gmtiTrackFilterID;
    }

    // setScaleMTItargetIndicators
    void setScaleMTItargetIndicators(double x, double y)
    {
        m_mtiScaleX = x;
        m_mtiScaleY = y;
    }

    // getScaleMTItargetIndicators
    void getScaleMTItargetIndicators(double &x, double &y) const
    {
        x = m_mtiScaleX;
        y = m_mtiScaleY;
    }
    
    // getPPIorientation
   double getPPIorientation(){return m_PPIorientation;   }

    // setPPIorientation
   void setPPIorientation( double angle ){m_PPIorientation = angle;  }



    // getPPIWedgeParameters
    void getPPIWedgeParameters(double &offsetX, double &offsetY, double &scaleX, double &scaleY)
    {
        offsetX = m_wedgeOffsetX;
        offsetY = m_wedgeOffsetY;
        scaleX = m_wedgeScaleX;
        scaleY = m_wedgeScaleY;
    }


    // getPrevPPIWedgeParameters
    void getPrevPPIWedgeParameters(double &offsetX, double &offsetY, double &scaleX, double &scaleY)
    {
        offsetX = m_prevWedgeOffsetX;
        offsetY = m_prevWedgeOffsetY;
        scaleX = m_prevWedgeScaleX;
        scaleY = m_prevWedgeScaleY;
    }


    // setPPIRangeRingRenderEnable
    void setPPIRangeRingRenderEnable(bool enable)
    {
        m_PPIrangeRingRenderEnable = enable;
    }

    // getPPIRangeRingRenderEnable
    bool getPPIRangeRingRenderEnable() const
    {
        return m_PPIrangeRingRenderEnable;
    }

    // setPPIArcRingRenderEnable
    void setPPIArcRingRenderEnable(bool enable)
    {
        m_PPIarcRingRenderEnable = enable;
    }

    // getPPIArcRingRenderEnable
    bool getPPIArcRingRenderEnable() const
    {
        return m_PPIarcRingRenderEnable;
    }

    // setPPIRadarArmSweepRenderEnable
    void setPPIRadarArmSweepRenderEnable(bool enable)
    {
        m_PPIradarArmSweepRenderEnable = enable;
    }

    // getPPIRadarArmSweepRenderEnable
    bool getPPIRadarArmSweepRenderEnable() const
    {
        return m_PPIradarArmSweepRenderEnable;
    }

    // setPPIRadarCursorEnable
    void setPPIRadarCursorEnable(bool enable)
    {
        m_PPIradarCursorEnable = enable;
    }

    // getPPIRadarCursorEnable
    bool getPPIRadarCursorEnable() const
    {
        return m_PPIradarCursorEnable;
    }

    // setPPIRadarReturnColor
    void setPPIRadarReturnColor(float red = 0.0f, float green = 1.0f, float blue = 0.0f)
    {
        m_PPIrenderColorR = (float)Croplohi(red, 0.0, 1.0);
        m_PPIrenderColorG = (float)Croplohi(green, 0.0, 1.0);
        m_PPIrenderColorB = (float)Croplohi(blue, 0.0, 1.0);
    }

    // getPPIRadarReturnColor
    void getPPIRadarReturnColor(float &red, float &green, float &blue)
    {
        red = m_PPIrenderColorR;
        green = m_PPIrenderColorG;
        blue = m_PPIrenderColorB;
    }

    // setPPISARTRadarColor
    void setPPISARTRadarColor(float red = 0.0f, float green = 1.0f, float blue = 0.0f)
    {
        m_PPISARTColorR = (float)Croplohi(red, 0.0, 1.0);
        m_PPISARTColorG = (float)Croplohi(green, 0.0, 1.0);
        m_PPISARTColorB = (float)Croplohi(blue, 0.0, 1.0);
    }

    // getPPISARTRadarColor
    void getPPISARTRadarColor(float &red, float &green, float &blue)
    {
        red = m_PPISARTColorR;
        green = m_PPISARTColorG;
        blue = m_PPISARTColorB;
    }

   // setPPITurbulenceRadarColor
   void setPPITurbulenceRadarColor(float red = 1.0f, float green = 0.0f, float blue = 0.0f)
   {
      m_PPIturbulenceColorR = (float)Croplohi(red, 0.0, 1.0);
      m_PPIturbulenceColorG = (float)Croplohi(green, 0.0, 1.0);
      m_PPIturbulenceColorB = (float)Croplohi(blue, 0.0, 1.0);
   }

   // getPPITurbulenceRadarColor
   void getPPITurbulenceRadarColor(float &red, float &green, float &blue)
   {
      red = m_PPIturbulenceColorR;
      green = m_PPIturbulenceColorG;
      blue = m_PPIturbulenceColorB;
   }

    // setPPIRangeRingArmSweepLineWidth
    void setPPIRangeRingArmSweepLineWidth(float width = 1.0f)
    {
        m_PPIlineWidth = width;
    }

    // getPPIRangeRingArmSweepLineWidth
    float getPPIRangeRingArmSweepLineWidth() const
    {
        return m_PPIlineWidth;
    }

    // setDBSSectorCorralArea
    void setDBSSectorCorralArea(float llx, float lly, float lrx, float lry, float urx, float ury, float ulx, float uly);

    // getDBSSectorCorralArea
    void getDBSSectorCorralArea(float &llx, float &lly, float &lrx, float &lry, float &urx, float &ury, float &ulx, float &uly);

    // setDBSPatchCorralArea
    void setDBSPatchCorralArea(float llx, float lly, float lrx, float lry, float urx, float ury, float ulx, float uly);

    // getDBSPatchCorralArea
    void getDBSPatchCorralArea(float &llx, float &lly, float &lrx, float &lry, float &urx, float &ury, float &ulx, float &uly);

    // setMRSARCorralArea
    void setMRSARCorralArea(float llx, float lly, float lrx, float lry, float urx, float ury, float ulx, float uly);

    // getMRSARCorralArea
    void getMRSARCorralArea(float &llx, float &lly, float &lrx, float &lry, float &urx, float &ury, float &ulx, float &uly);

    // getDBSSymbologyData
    void getDBSSymbologyData(double &angleExtent, double &centerX, double &centerY, double &sectorWidth, double &coverWidth);

    // setCorralAreaRenderMode
    void setCorralAreaRenderMode(int mode)
    {
        m_corralAreaRenderMode = mode;
    }

    // getCorralAreaRenderMode
    int getCorralAreaRenderMode() const
    {
        return m_corralAreaRenderMode;
    }

    // setStabilizationCuePoint
    void setStabilizationCuePoint(float rangeX, float rangeY, float scale = 1.0f);

    // getStabilizationCuePoint
    void getStabilizationCuePoint(float &rangeX, float &rangeY, float &scale);

    // setDesignationCursorPoint
    void setDesignationCursorPoint(float rangeX, float rangeY);

    // getDesignationCursorPoint
    void getDesignationCursorPoint(float &rangeX, float &rangeY);

    // setCursorRenderMode
    void setCursorRenderMode(int mode)
    {
        m_cursorRenderMode = mode;
    }

    // getCursorRenderMode
    int getCursorRenderMode() const
    {
        return m_cursorRenderMode;
    }

    // setUseSymbology
    void setUseSymbology(bool symbology)
    {
        m_useSymbology = symbology;
    }

    // getUseSymbology
    bool getUseSymbology() const
    {
        return m_useSymbology;
    }

    // setRecomputeDBSRegions
    void setRecomputeDBSRegions(bool recompute)
    {
        m_recomputeDBSRegions = recompute;
    }

    // getRecomputeDBSRegions
    bool getRecomputeDBSRegions() const
    {
        return m_recomputeDBSRegions;
    }

    // setDBSPatchEnable
    void setDBSPatchEnable(bool patchMode)
    {
        if ( m_useSymbology )
            m_DBSPatchEnable = patchMode;
    }

    // getDBSPatchEnable
    bool getDBSPatchEnable() const
    {
        return m_DBSPatchEnable;
    }

   //getMinVelocity
   double getMinVelocity() const;

   //getMaxVelocity
   double getMaxVelocity() const;


    // getDownRangeResolution
    double getDownrangeResolution();

    // getCrossrangeResolution
    double getCrossrangeResolution();

    // setTerrainSlantRange
    void setTerrainSlantRange(double slantRange);

    // getTerrainSlantRange
    double getTerrainSlantRange();


    //setMinMaxTemp
    bool setMinMaxTemp(double minTemp, double maxTemp);

    //getMinTemp 
    double getMinTemp();

    //getMaxTemp 
    double getMaxTemp();

    //setMaxLightLevel
    void setMaxLightLevel(double maxLightLevel);

    //getMaxLightLevel 
    const double getMaxLightLevel();


    //getMaxPower 
    const double getMaxPower();


    //getNumberWavelengths
    unsigned int getNumberWavelengths();

    //*getWavelengthsArray
    double *getWavelengthsArray();

    //getWavelength
    double getWavelength(int i);

    //setFrequencyAttributes
    void setFrequencyAttributes(double freqMin, double freqMax, int numBins);

    //getEmitterCenterFrequency
    double getEmitterCenterFrequency();

    //setBandpass
    bool setBandpass(double ax, double bx, double dx);

    //getBandpass
    bool getBandpass(double &ax, double &bx, double &dx);

    //setPemitterW
    bool setPemitterW(double PemitterW);

    //getPemitterW 
    double getPemitterW();

    //setTransmitterGain
    bool setTransmitterGain(double AntGain);

    //getTransmitterGain 
    double getTransmitterGain();

    //setReceiverGain
    bool setReceiverGain(double AntGain);

    //getReceiverGain 
    double getReceiverGain();

   //setSysTempK
   bool setSysTempK(double degK);

   //getSysTempK 
   double getSysTempK();

   //setRadarBand
   bool setRadarBand(double FCemitterHz, double BWemitterHz, double ChannelResolutionHz);

    //setFCemitterHz
    bool setFCemitterHz(double FCemitterHz);


    //setFCemitterWavelength
    bool setFCemitterWavelength(double wavelength);   // [m]

    //getFCemitterHz 
    double getFCemitterHz();

    //getFCemitterWavelength 
    double getFCemitterWavelength();   // [m]

    //getBWemitterHz 
    double getBWemitterHz() const;

    //setChannelResolutionHz
    bool setChannelResolutionHz(double ChannelResolutionHz);

    //getChannelResolutionHz 
    double getChannelResolutionHz();

    //setPulseWidth
    bool setPulseWidth(double PulseWidth);

    //getPulseWidth 
    double getPulseWidth();

    //setPRF
    bool setPRF(double PRF);

    //getPRF 
    double getPRF();

   //setNFPRF
   bool setNFPRF(double PRF);

   //getNFPRF 
   double getNFPRF();

   //setTransmitterPolarizationAngle
   bool setTransmitterPolarizationAngle(double PolarizationAngle_deg);

   //getTransmitterPolarizationAngle 
   double getTransmitterPolarizationAngle();

   //setReceiverPolarizationAngle
   bool setReceiverPolarizationAngle(double PolarizationAngle_deg);

   //getReceiverPolarizationAngle 
   double getReceiverPolarizationAngle();

   //setBeamWidth
   bool setBeamWidth(double rad);

   //getBeamWidth
   double getBeamWidth();

   //setRangeCompensation
   void setRangeCompensation(bool rangeCompensation)
    {
        m_rangeCompensation = rangeCompensation;
    }

   //getRangeCompensation
   bool getRangeCompensation() const
    {
        return m_rangeCompensation;
    }

   //setGainPattern
   void setGainPattern(int pattern);

   //getGainPattern
   const int getGainPattern();

   //setDisplayType
   void setDisplayType(int type);

   //getDisplayType
   const int getDisplayType();



    //*getTerrainFollowArray
    float *getTerrainFollowArray();

    //setNumTerrainFollowingBins
    void setNumTerrainFollowingBins(int num);

    //getNumTerrainFollowingBins
    int getNumTerrainFollowingBins();

    // setTAprops
    bool setTAprops(double ThreshDetect, double ThreshClassify, double ThreshRecognize, double ThreshIdentify, double PersistenceTime);

    // getTAprops
    bool getTAprops(double &ThreshDetect, double &ThreshClassify, double &ThreshRecognize, double &ThreshIdentify, double &PersistenceTime);



   // getPersistenceTime
    double getPersistenceTime();  

   // setSaturationRatio
   void setSaturationRatio(double satRatio);

   // getSaturationRatio
   double getSaturationRatio();

   // getRadarIFOVNoisePower
   double getRadarIFOVNoisePower();

   // getRadarReceiverArea()
   double getRadarReceiverArea();

   // getRadarIFOVNominalReturnPower
   double getRadarIFOVNominalReturnPower();

   
   // getSonarIFOVNominalReturnPower
   double getSonarIFOVNominalReturnPower();

    //isVisualBand
    bool isVisualBand();

    //isNearIRBand
    bool isNearIRBand();

   //isMWIRBand
   bool isMWIRBand();

    //isLongWaveBand
    bool isLongWaveBand();

    //isRadarBand
    bool isRadarBand();
    
    //isLadar
    bool isLadar();


    //getSensorSelect
    void getSensorSelect(float &w1, float &w2, float &w3, float &visSensor);

    //setNumberSamples
    void setNumberSamples(unsigned int hsamples, unsigned int vsamples);

    //setNumberHorizontalSamples
    void setNumberHorizontalSamples(unsigned int hsamples);

    //getNumberHorizontalSamples
    unsigned int getNumberHorizontalSamples();

    //setNumberVerticalSamples
    void setNumberVerticalSamples(unsigned int vsamples);

    //getNumberVerticalSamples
    unsigned int getNumberVerticalSamples();

    //setFOV
    void setFOV(double horizontalFOV, double verticalFOV);

    //getFOV
    void getFOV(double &horizontalFOV, double &verticalFOV);

    //setFOVScaleFactor
    void setFOVScaleFactor(double scale)
    {
        m_fovScaleFactor = scale;
    }

    //getFOVScaleFactor
    double getFOVScaleFactor() const
    {
        return m_fovScaleFactor;
    }

    //setDetectorScaleFactor
    void setDetectorScaleFactor(double horizontalScaleFactor, double verticalScaleFactor);

    //getDetectorScaleFactor
    void getDetectorScaleFactor(double &horizontalScaleFactor, double &verticalScaleFactor);

    //setScreenOffset
    void setScreenOffset(int horizontalScreenOffset, int verticalScreenOffset);

    //getScreenOffset
    void getScreenOffset(int &horizontalScreenOffset, int &verticalScreenOffset);

    //getType
    int getType(); 


   //setType
   void setType(int type);


    //getUniqueID
    int getUniqueID();

    //setUniqueID
    void setUniqueID(int id);

    //*getPlanckIntegralTable
    float *getPlanckIntegralTable();

    //setMaximumPlanckTableTemperature
    void setMaximumPlanckTableTemperature(int max);

    //getMaximumPlanckTableTemperature
    int getMaximumPlanckTableTemperature();

    //setNumberPlanckTableTemperatures
    void setNumberPlanckTableTemperatures(unsigned int num);

    //getNumberPlanckTableTemperatures
    unsigned int getNumberPlanckTableTemperatures();

    //getAutoMaxTemperature
    double getAutoMaxTemperature();

    //getAutoMinTemperature
    double getAutoMinTemperature();

    //getAutoMaxDiurnalLight
    double getAutoMaxDiurnalLight();

    //getAutoMinDiurnalLight
    double getAutoMinDiurnalLight();

    //isAutoRadianceScale
    bool isAutoRadianceScale();

    //setAutoRadianceScale
    void setAutoRadianceScale(bool flag);

   bool isAGCEnable();

   void setAGCEnable(bool flag);

    //isDirty
    bool isDirty();

    //isTimeChanged
    bool isTimeChanged();

    //setGeocentricLocation
    void setGeocentricLocation(
        double x, 
        double y, 
        double z);

    //getGeocentricLocation
    void getGeocentricLocation(
        double &x, 
        double &y, 
        double &z);

    //setGeodeticLocation
    void setGeodeticLocation(
        double lat, 
        double lon, 
        double alt);

    //getGeodeticLocation
    void getGeodeticLocation(
        double &lat, 
        double &lon, 
        double &alt);

    //setOrientation
    void setOrientation(
        double h, 
        double p, 
        double r);

    //getOrientation
    void getOrientation(
        double &h, 
        double &p, 
        double &r);


    //setLinearVelocity
    void setLinearVelocity(double e, 
        double n, 
        double u);

    //getLinearVelocity
    void getLinearVelocity(double &e, 
        double &n, 
        double &u);

    //setLinearAcceleration
    void setLinearAcceleration(double e, 
        double n, 
        double u);

    //getLinearAcceleration
    void getLinearAcceleration(double &e, 
        double &n, 
        double &u);

    //setAngularVelocity
    void setAngularVelocity(double e, 
        double n, 
        double u);

    //getAngularVelocity
    void getAngularVelocity(double &e, 
        double &n, 
        double &u);


   void setFRDAngularVelocity(double y, 
                           double p, 
                           double r);


   void getFRDAngularVelocity(double &y, 
                           double &p, 
                           double &r);


   // setHeightAboveTerrain
    void setHeightAboveTerrain(double alt);

   // getHeightAboveTerrain
    double getHeightAboveTerrain();

   // setTerrainAltitudeExtremes
    void setTerrainAltitudeExtremes(double minAlt, double maxAlt);

   // getTerrainAltitudeExtremes
    void getTerrainAltitudeExtremes(double &minAlt, double &maxAlt);    

   // setSpotfile
   void setSpotfile(char *filename);


   // getSpotfile
   char *getSpotfile();

   // setQEResponseFile
   void setQEResponseFile(char *filename);


   // getQEResponseFile
   char *getQEResponseFile();

   // setRadarColorMapFile
   void setRadarColorMapFile(char *filename);


   // getRadarColorMapFile
   char *getRadarColorMapFile();



    //setAngularAcceleration
    void setAngularAcceleration(double e, 
        double n, 
        double u);

    //getAngularAcceleration
    void getAngularAcceleration(double &e, 
        double &n, 
        double &u);

    //convertRUB2NED
    void convertRUB2NED(int hpix, int vpix, float range, float *vector);

    // setTrack
    void setTrack(TRACK *track, int numTracks);

    // setTrackfileUpdate
    void setTrackfileUpdate(double simTime, ::ellipsoid *ellipsoid);

    //computePlanckIntegral
    double computePlanckIntegral (double lowerWaveLength, 
        double upperWaveLength, 
        double temperature);
 
    //computePlanckIntegral
    double computePlanckIntegral (double temperature);

    //getGain
    double getGain();

    //getLevel
    double getLevel();

    //setGain
    void setGain(double gain);

    //setLevel
    void setLevel(double level);


    //*getName
    char *getName();


    //setName
    void setName(const char *name);

    //*getSensorPtr
    SENSOR *getSensorPtr();

    //setSensorPtr
    void setSensorPtr(SENSOR *sensorPtr);

    //setWorldLocation
   void setWorldLocation(double x, double y, double z);

    //getWorldLocation
    void getWorldLocation(double& x, double& y, double& z);

    //setReprojection
    void setReprojection(bool flag);

    //getReprojection
    bool getReprojection();

    //isRadar
    bool isRadar();

    //isComm
    bool isComm();

   //isEOIR
   bool isEOIR();


    //isSonar
    bool isSonar();

    //isSss
    bool isSss();

    //isSar
    bool isSar();

    //isIsar
    bool isIsar();

    //isPpi
    bool isPpi();

    //isCwr
    bool isCwr();

    //isAirToAir
    bool isAirToAir();

   //isDopplerSpatialEffects
   bool isDopplerSpatialEffects();

   //setDopplerSpatialEffects
   void setDopplerSpatialEffects(bool state);


   //isDopplerBeamSharpening
   bool isDopplerBeamSharpening();

   //setDopplerBeamSharpening
   void setDopplerBeamSharpening(bool state);

   // setDBSangleExtent
   //
   // description: sets DBS angle extent - DBS has a constant angle extent (degrees)
   //
   void setDBSangleExtent(double angle);

   // getDBSangleExtent
   //
   // description: gets  DBS angle extent - DBS has a constant angle extent (degrees)
   //
   double getDBSangleExtent();

   // setDopplerThreshold
   //
   // description: sets Doppler threshold (0-1)
   //
   void setDopplerThreshold(double thresh);

   // getDopplerThreshold
   //
   // description: gets Doppler threshhold (0-1) 
   //
   double getDopplerThreshold();

    // setDopplerThresholdMin
    void setDopplerThresholdMin(double threshold);

    // getDopplerThresholdMin
    double getDopplerThresholdMin();

    // setDopplerThresholdMax
    void setDopplerThresholdMax(double threshold);

    // getDopplerThresholdMax
    double getDopplerThresholdMax();

    // setClutterReductionMode
    void setClutterReductionMode(int CRMode);

    // getClutterReductionMode
    int getClutterReductionMode();

    // setClutterReductionFactor
    void setClutterReductionFactor(double CRFactor);

    // getClutterReductionFactor
    double getClutterReductionFactor();

    // getTransponderReceiverFrequency
    double getTransponderReceiverFrequency() const
    { 
        return m_transponderReceiverFrequency;
    }

    // setTransponderReceiverFrequency
   void setTransponderReceiverFrequency( double frequency, int idx = 0 )
    { 
        m_transponderReceiverFrequency = frequency;
    }

   // setApplyPPIReset
   //
   // description: allows whether the PPI scan will reset when other parameters about the scan are changed
   //
   void setApplyPPIReset(bool reset)
    {
        m_applyPPIReset = reset;
    }

   // getApplyPPIReset
   //
   // description: gets the PPI scan state on whether the scan will reset when other parameters about the scan are changed
   //
   bool getApplyPPIReset() const
    {
        return m_applyPPIReset;
    }

   // setAirToAirMode
   //
   // description: sets the air to air mode display
   //
    void setAirToAirMode(int mode)
    {
        if ( m_AirToAirMode != mode )
        {
            m_AirToAirMode = mode;
            m_PPIresetMode = true;
            setDirty();
        }
    }

   // getAirToAirMode
   //
   // description: gets the current air to air mode display 
   //
    int getAirToAirMode() const
    {
        return m_AirToAirMode;
    }

   // setMaxMTItargets
   //
   // description: sets the max number of MTI targets to display
   //
    void setMaxMTItargets(int max)
    {
        m_maxMTItargets = max;
    }

   // getMaxMTItargets
   //
   // description: gets the current max number of MTI targets displayed
   //
    int getMaxMTItargets() const
    {
        return m_maxMTItargets;
    }

   // setMaxMTIhistory
   //
   // description: sets the max number of elements for an MTI entry
   //
    void setMaxMTIhistory(int history)
    {
        m_maxMTIhistory = history;
    }

   // getMaxMTIhistory
   //
   // description: gets the max number of MTI elements for a target entry
   //
    int getMaxMTIhistory() const
    {
        return m_maxMTIhistory;
    }

   // setMaxAirToAirVelocity
   //
   // description: sets the max velocity for Air to Air velocity search mode
   //
    void setMaxAirToAirVelocity(double velocity)
    {
        if ( m_maxA2Avelocity != velocity )
        {
            m_maxA2Avelocity = velocity;
            m_PPIresetMode = true;
            setDirty();
        }
    }

   // getMaxAirToAirVelocity
   //
   // description: gets the maximum velocity for scaling the velocity search a2a mode display
   //
    double getMaxAirToAirVelocity() const
    {
        return m_maxA2Avelocity;
    }

    // getCagedModeHeadingPitch
    //
   // description: gets the caged Mode heading and pitch angle specification
   //
    void getCagedModeHeadingPitch(double &heading, double &pitch) const
    { 
        heading = m_cagedModeHeading;
        pitch = m_cagedModePitch;
    }

    // setCagedModeHeadingPitch
    //
   // description: sets the caged Mode heading and pitch angle specification
   //
   void setCagedModeHeadingPitch( double heading, double pitch )
    {
        m_cagedModeHeading = heading;
        m_cagedModePitch = pitch;
    }

    // gettrackLifeTime
    //
    // description: gets the maximum lifetime for a track to persist for air to air operations [s]
    //
    double getTrackLifeTime() const
    { 
        return m_trackLifeTime;
    }

    // setTrackLifeTime
    //
    // description: sets the maximum lifetime for a track to persist for air to air operations [s]
    //
   void setTrackLifeTime( double lifetime )
    { 
        m_trackLifeTime = lifetime;
    }

    //setBoresightROI
    void setBoresightROI(double x, double y, double width, double height);
   
    //getBoresightROI
    void getBoresightROI(double &x, double &y, double &width, double &height);

    //setIntegrationPathlength
    void setIntegrationPathlength(double length);

    //getIntegrationPathlength
    double getIntegrationPathlength();

    //setShadowOrientationDown
    void setShadowOrientationDown(bool flag);

    //getShadowOrientationDown
    bool getShadowOrientationDown();

    //setIFOVSolidAngle
   void setIFOVSolidAngle(double ifovsr);

    //getIFOVSolidAngle
   double getIFOVSolidAngle();

    //setIntegrationTime
    void setIntegrationTime(double time);

    //getIntegrationTime
    double getIntegrationTime();

    //computeBinning
    void computeBinning(VECTOR *DownRange, VECTOR *CrossRange, VECTOR *DownVelocity, VECTOR *CrossVelocity, 
            double *downRangeBinning, double *crossRangeBinning, double *downRangeBinningMax, double *crossRangeBinningMax, double *crossSegments);

    //getIntensityModulationGain
   double getIntensityModulationGain();

    //setIntensityModulationGain
   void setIntensityModulationGain(double imodGain);

    //setNumSpectralBins
   void setNumSpectralBins(int sbins);

    //getNumSpectralBins
   int getNumSpectralBins();

   //set the terrain sampling resolution
   //
   void setTerrainSamplingResolution(int n);

   //Get terrain sampling resolution
   //
   int getTerrainSamplingResolution();

   //set whether or not the sensor has a TAA backend.
   //
   void setHasTAABackEnd(bool state);

   //Gets whether the sensor has a TAA backend.
   //
   bool hasTAABackEnd();

   //Sets whether to apply the radiance scaling. Allows direct rendering of raw radiance values
   //
    void setRadianceScaleEnable(bool enable)
    {
        m_applyRadianceScale = enable;
    }

   //Gets whether to apply the radiance scaling.
   //
    bool getRadianceScaleEnable() const
    {
        return m_applyRadianceScale;
    }

   //Sets whether to enable MTI processing
   //
    void setEnableMTIprocessing(bool enable)
    {
        m_enableMTIprocessing = enable;
    }

   //Gets whether to apply the MTI processing.
   //
    bool getEnableMTIprocessing() const
    {
        return m_enableMTIprocessing;
    }

   //Sets enable/disable the REACT mode radar processing
   // weatherThreshold defines the intensity for thesholding REACT mode
   //  reactFilterAdjust allows adjustments to the pixels that are marked as REACT regions
   //
    void setReactModeEnable(bool enable, float weatherThreshold = -1.0f, float reactFilterAdjust = 0.0f)
    {
        m_reactModeEnable = enable;
      m_reactWeatherThreshold = weatherThreshold;
      m_reactFilterAdjust = reactFilterAdjust;
    }

   //Gets whether REACT mode radar processing is enabled or not
   //
    void getReactModeEnable(bool &enable, float & weatherThreshold, float &filterAdjust) const
    {
        enable = m_reactModeEnable;
      weatherThreshold = m_reactWeatherThreshold;
        filterAdjust = m_reactFilterAdjust;
    }

   // Sets user defined details for the PPI strip size, down range and cross range sample sizes.
    // The strip size is specified in degrees.
   //
    void setUserDefinedStripBinSize(double stripSize = -1.0, int downRange = -1, int crossRange = -1)
    {
        m_userDefinedStripAngleSize = stripSize;
        m_userDefinedDownRangeBinSize = downRange;
        m_userDefinedCrossRangeBinSize = crossRange;
    }

   // Gets user defined details for the PPI strip size, down range and cross range sample sizes.
    // The strip size returned will be in degrees
   //
    void getUserDefinedStripBinSize(double &stripSize, int &downRange, int &crossRange) const
    {
        stripSize = m_userDefinedStripAngleSize;
        downRange = m_userDefinedDownRangeBinSize;
        crossRange = m_userDefinedCrossRangeBinSize;
    }

   // Sets the maximum resolution that the first pass renders to for PPI radar modes
   //
    void setPPIMaxRadarResolution(int downRange, int crossRange)
    {
        m_ppiMaxDownRangeResolution = downRange;
        m_ppiMaxCrossRangeResolution = crossRange;
    }

   // Gets the maximum resolution that the first pass renders to for PPI radar modes
   //
    void getPPIMaxRadarResolution(int &downRange, int &crossRange) const
    {
        downRange = m_ppiMaxDownRangeResolution;
        crossRange = m_ppiMaxCrossRangeResolution;
    }

private:

    //initialize
    bool initialize();

    //setAutoMaxTemperature
    void setAutoMaxTemperature(double temp);

    //setAutoMinTemperature
    void setAutoMinTemperature(double temp);

    //setAutoMaxDiurnalLight
    void setAutoMaxDiurnalLight(double light);

    //setAutoMinDiurnalLight
    void setAutoMinDiurnalLight(double light);

    //recomputeMinMaxRadiance
    void recomputeMinMaxRadiance();

    //recomputeMinMaxRange
   void recomputeMinMaxRange();

   // recomputeMinMaxVelocity
   //
   // description: recomputes the min and max velocity 
   //
   void recomputeMinMaxVelocity();

    //updatePlanckIntegralTable
    void updatePlanckIntegralTable();

    //degreesToMilliradians
    double degreesToMilliradians(double deg);
    double degreesToRadians(double deg);
    double radiansToDegrees(double rad);

    //clrTimeChanged
    void clrTimeChanged();

    //setTimeChanged
    void setTimeChanged();

    //clrDirty
    void clrDirty();

    //setDirty
    void setDirty();

    //computeStripSize
    void computeStripSize( double frameTime = -1.0, int direction = -1 );


    int m_id;

   double m_minRange; // Meters
   double m_maxRange; // Meters
   double m_minVel;  // [m/s]
   double m_maxVel;  // [m/s]

    double m_minRadiance;   // [W/cm2/sr]
    double m_maxRadiance;   // [W/cm2/sr]
    float *m_planckTable;
    int m_maxTemperature;
    unsigned int m_numTemperatures;
    SENSOR *m_sensorPtr;

    RF_POWER_DENSITY *m_powerDensity;

    double m_autoMaxTemperature;
    double m_autoMinTemperature;
    double m_maxDiurnalLight; // [W/cm2]
    double m_minDiurnalLight; // [W/cm2]
    bool m_autoRadianceScale;
    bool m_AGCEnable;
    bool m_dirty;
    bool m_timeChanged;
    double m_transmitterGain;
   double m_receiverGain;
    double m_pEmitterW;
   double m_sysTempK;
    double m_maxPower;
   double m_satRatio;
   bool m_dopplerSpatialFXState;
    bool m_dopBeamSharpening;
    double m_DBSangleExtent;

    char m_spotFilepath[512];
   char m_QEResponseFile[512];
    
    double m_worldXCoord;
    double m_worldYCoord;
    double m_worldZCoord;

    // Height Above Terrain
    double m_heightAboveTerrain;
    
    double m_minTerrainAltitude;
    double m_maxTerrainAltitude;

    // Sar projection
    bool m_reprojection;

    // SAR Boresight ROI
    double m_boresightRoiX;
    double m_boresightRoiY;
    double m_boresightRoiWidth;
    double m_boresightRoiHeight;
    //  Integration Path length
    double m_IntegrationPathlength;
    // terrain slant range used for SAR
    double  m_terrainSlantRange;
    // integration time
    double m_IntegrationTime;

    bool m_rangeCompensation;

   double m_ifovsr;  // [sr] sampling ifov solid angle

    // SAR shadow orientation
    bool m_shadowOrientationDown;

   int m_gainPattern;      // For radar modes: 0=Unity, 1=Lobe, 2=Rect
   int m_displayType;      // For radar modes: 0=radiance, 1=power, 2=effective RCS, 3=Doppler Coloring, 4=Terrain Avoidance, 5=Freeze
    float *m_terrainFollowArray;
    int m_numTerrainFollowingBins;

   //ppi mode display params
   double   m_minWedgeExtent;  // minimum angle of the full scan area in degrees
   double   m_maxWedgeExtent;  // maximum angle of the full scan area in degrees
    double  m_activeSectorWidth;  // active area within the wedge in degrees
    double  m_minCurScanExtent;  // current scan extent - could be wedge or active sector or DBS/SAR sector
    double  m_maxCurScanExtent;  // current scan extent - could be wedge or active sector or DBS/SAR sector
    double  m_prevMinCurScanExtent;  // current scan extent - could be wedge or active sector or DBS/SAR sector
    double  m_prevMaxCurScanExtent;  // current scan extent - could be wedge or active sector or DBS/SAR sector
    double  m_displayRange;
    double  m_maxRadarRangeScale;
   bool  m_enableBacksweep;
   bool  m_showOtwView;
    double  m_headingOffset;
    double  m_prevHeadingOffset;
    double  m_pitchOffset;
   double   m_dopplerThreshold;
    double  m_dopplerThresholdMin;
    double  m_dopplerThresholdMax;
    double  m_clutterReductionFactor;
    int     m_clutterReductionMode;
    double  m_transponderReceiverFrequency;
    double  m_prevStripAngleSize;
    double  m_stripAngleSize;
    int     m_downRangeBinSize;
    int     m_crossRangeBinSize;
    int     m_prevDownRangeBinSize;
    int     m_prevCrossRangeBinSize;
    int     m_userDefinedDownRangeBinSize;
    int     m_userDefinedCrossRangeBinSize;
    double  m_userDefinedStripAngleSize;        // in units of degrees
    int     m_ppiMaxDownRangeResolution;
    int     m_ppiMaxCrossRangeResolution;

    int     m_PPIoffsetWidth;
    int     m_PPIoffsetHeight;
    float   m_PPIscaleWidth;
    float   m_PPIscaleHeight;
    bool    m_PPIrangeRingRenderEnable;
    bool    m_PPIarcRingRenderEnable;
    bool    m_PPIradarArmSweepRenderEnable;
    bool    m_PPIradarCursorEnable;
    float   m_PPIrenderColorR;
    float   m_PPIrenderColorG;
    float   m_PPIrenderColorB;
    float   m_PPISARTColorR;
    float   m_PPISARTColorG;
    float   m_PPISARTColorB;
   float m_PPIturbulenceColorR;
   float m_PPIturbulenceColorG;
   float m_PPIturbulenceColorB;
    float   m_PPIlineWidth;
    bool    m_PPIresetMode; // reset the PPI mode/display
    bool    m_applyPPIReset;
    bool    m_overrideReset;
    double  m_prevMaxHeadingRad;
    double  m_prevMinHeadingRad;
    bool    m_reactModeEnable;
    float   m_reactFilterAdjust;
   float m_reactWeatherThreshold;

    double m_radarVertFOV;  //The PPI/radar computed vertical FOV
    double m_prevRadarVertFOV; 
    double m_radarAspectRatio; //The PPI/radar computed aspect ratio

    double m_wedgeOffsetX;
    double m_wedgeOffsetY;
    double m_wedgeScaleX;
    double m_wedgeScaleY;

    double m_prevWedgeOffsetX;
    double m_prevWedgeOffsetY;
    double m_prevWedgeScaleX;
    double m_prevWedgeScaleY;

    double m_DBScenterX;
    double m_DBScenterY;
    double m_PPIorientation;
    int    m_gmtiMode;
    int    m_gmtiTrackFilterMode;
    int    m_gmtiTrackFilterID;
    double m_mtiScaleX;
    double m_mtiScaleY;

    int    m_AirToAirMode;
    int    m_maxMTItargets;
    int    m_maxMTIhistory;
    double m_maxA2Avelocity;
    double m_cagedModePitch;
    double m_cagedModeHeading;
    double m_trackLifeTime;
   char m_radarColorMapFile[512];

   LARGE_INTEGER m_frequency;
   LARGE_INTEGER m_start;
    LARGE_INTEGER m_end;
    double m_time;

   int m_direction;
    bool m_sweepDoneFlag;
    bool m_lastStripFlag;
    double m_minVertAngle;
    double m_prevMinVertAngle;


   double m_intensityModulationGain;

   int m_numSpectralBins;

    int m_screenOffsetHorz;
    int m_screenOffsetVert;
    double m_detectorScaleFactorHorz;
    double m_detectorScaleFactorVert;
    double m_fovScaleFactor;

   int m_terrainSamplingResolution; // [1] To distinguish 1st-pass sampling resolution from display resolution

   bool m_hasTaaBackend;            // [bool] Enable green-channel ObjectID override in jrmApplySensors
    bool m_applyRadianceScale;
    bool m_enableMTIprocessing;

    // For generating the unique id
    static int s_sensorId;

    ssRadarSymbology *m_symbologyData;
    bool m_useSymbology;
    bool m_recomputeDBSRegions;
    bool m_DBSPatchEnable;
    int m_corralAreaRenderMode;
    int m_cursorRenderMode;

    friend class SigSimRT;
    friend class ssEnvironment;
    friend class ssMaterialSet;
    friend class ssAtmosphericTable;
    //friend class MixedSigSimRT;   // CF091221 : Not ready yet for ATM LUT merging code.

};

#endif // _ssSensor_