ciSensor.h

Go to the documentation of this file.

// Copyright JRM Enterprises, Inc. 2004 - 2012
// 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:  Nikolai Fedoroff
// Date:       Oct 2004
//

#if !defined(_ciSensor_h_)
#define _ciSensor_h_
#include "ciApi.h"

#include "clXML.h"
#include <stdio.h>
#include <memory.h>
#include <malloc.h>
#include <string.h>
#include <assert.h>
#include <iostream>
#include <fstream>
#include "ciOptics.h"
#include "ciElectronics.h"
#include "ciDetector.h"
#include "ciSenSim.h"
#include "clXMLNode.h"

class CI_API ciSensor  
{
public:     // enumerations

    enum SensorType
    {
        DEFAULT = 0,
        IR = 1,
        NVG = 2,
        RADAR = 3,
      SONAR = 4,
      COMM = 5
    };

public:     // methods

    // save
    bool archive(std::ofstream &outf);

    // serialize
    int serialize(char *filepath);

    //
    // loadXML
    //
    // \par Description:
    // Loads attributes from an XML node
    //
    // \param clXMLNode* childNode
    // \return bool
    //
    bool loadXML(clXMLNode* childNode);

    //
    // parseXML
    //
    // \par Description:
    // Parses an XML document for specific tags
    //
    // \param clXML xmlDocument
    // \return bool
    //
    bool parseXML(clXML& xmlDocument);

    //loadXMLNode
    bool loadXMLNode(std::string tag, char *nodeString);

    //loadXMLNode
    bool loadXMLNode(std::string tag, bool *nodeBool);
    //loadXMLNode
    bool loadXMLNode(std::string tag, int *nodeBool);
    //loadXMLNode
    bool loadXMLNode(std::string tag, double *nodeBool);

    //
    // saveXML
    //
    // \par Description:
    // Saves XML nodes to an XML document
    //
    // \param clXML* xmlDocument
    //
    void saveXML(clXML* xmlDocument);
   void saveXML(clXML* xmlDocument, int sensorIndex, int SigSimActive, int SenSimActive);

    //serializeCheck
    int   serializeCheck(char *filepath);

    // add
    virtual bool add(ciSensor sensor);

    // insert
    virtual bool insert(ciSensor sensor, int idx = -1);

    // remove
    virtual bool remove(int idx);

    // getName
    char *getName(int idx = 0);

    // setName
    void setName(const char *name, int idx = 0);

    // getType
    int getType(int idx = 0);


   // getSensorType
    SensorType getSensorType(int idx = 0);

    // setType
    void setType(int type, int idx = 0);


   // setSensorType
   void setSensorType(SensorType type, int idx = 0);

    // setBandInfo
    void setBandInfo(double lowerBandLim, double upperBandLim, int nBands, int idx = 0);

    // setBandInfo
    void setBandInfo(double lowerBandLim, double upperBandLim, double dx, int idx = 0);

    // getBandInfo
    void getBandInfo(double &lowerBandLim, double &upperBandLim, int &nBands, int idx = 0);

    // getBandInfo
    void getBandInfo(double &lowerBandLim, double &upperBandLim, double &dx, int idx = 0);

    // setFOVDegrees
    void setFOVDegrees(double horz, double vert, int idx = 0);

    // getFOVDegrees
    void getFOVDegrees(double &horz, double &vert, int idx = 0);

    // setFOVPixels
    void setFOVPixels(int horz, int vert, int idx = 0);

    // getFOVPixels
    void getFOVPixels(int &horz, int &vert, int idx = 0);

    //setDetectorScaleFactor
    void setDetectorScaleFactor(double horizontalScaleFactor, double verticalScaleFactor, int idx = 0);

    //getDetectorScaleFactor
    void getDetectorScaleFactor(double &horizontalScaleFactor, double &verticalScaleFactor, int idx = 0);

    //setScreenOffset
    void setScreenOffset(int horizontalScreenOffset, int verticalScreenOffset, int idx = 0);

    //getScreenOffset
    void getScreenOffset(int &horizontalScreenOffset, int &verticalScreenOffset, int idx = 0);

    // setTemperatureLimits
    void setTemperatureLimits(double tMax, double tMin, int idx = 0);

    // getTemperatureLimits
    void getTemperatureLimits(double &tMax, double &tMin, int idx = 0);

    // setMaxLightLevel
    void setMaxLightLevel(double maxLightLevel, int idx = 0);

    // getMaxLightLevel
    double getMaxLightLevel(int idx = 0);

    // setSaturationRatio
    void setSaturationRatio(double satRatio, int idx = 0);

    // getSaturationRatio
    double getSaturationRatio(int idx = 0);

    // getQEResponseFile
    char *getQEResponseFile(int idx = 0);

    // setQEResponseFile
    void setQEResponseFile(char *filename, int idx = 0);

    // getTrackfile
    char *getTrackfile(int idx = 0);

    // setTrackfile
    void setTrackfile(char *filename, int idx = 0);

    // setIndex
    void setIndex(int index) {m_sensorList[0].index = index;}

    // getIndex
    int getIndex() {return m_sensorList[0].index;}

    // getNumSensors
    int getNumSensors() {return m_nSensors;}
    //setNumSensors
    void setNumSensors(int nSensors) {m_nSensors = nSensors;}
    //setAutomaticRadience
    void setAutomaticRadiance(bool flag, int idx = 0);
    //setAutomaticRadience
    bool getAutomaticRadiance(int idx = 0);
    //setDopplerSpatialEffects
    void setDopplerSpatialEffects(bool flag, int idx = 0);

    //getDopplerSpatialEffects
    bool getDopplerSpatialEffects(int idx = 0);

    //setDopplerBeamSharpening
    void setDopplerBeamSharpening(bool flag, int idx = 0);
    //getDopplerBeamSharpening
    bool getDopplerBeamSharpening(int idx = 0);

    // setGain
    void setGain(double gain, int idx = 0);

    // getGain
    double getGain(int idx = 0);

    // setLevel
    void setLevel(double level, int idx = 0);

    // getLevel
    double getLevel(int idx = 0);

    // setPemitterW
    void setPemitterW(double PemitterW, int idx = 0);

    // getPemitterW
    double getPemitterW(int idx = 0);

    // setTransmitterGain
    void setTransmitterGain(double AntGain, int idx = 0);

    // getTransmitterGain
    double getTransmitterGain(int idx = 0);

    // setReceiverGain
    void setReceiverGain(double AntGain, int idx = 0);

    // getReceiverGain
    double getReceiverGain(int idx = 0);

    // setGainPattern
   void setGainPattern(int pattern, int idx = 0);

    // getGainPattern
   int getGainPattern(int idx);


    // setFCemitterHz
    void setFCemitterHz(double FCemitterHz, int idx = 0);

    // getFCemitterHz
    double getFCemitterHz(int idx = 0);

    // setBWemitterHz
    void setBWemitterHz(double BWemitterHz, int idx = 0);

    // getBWemitterHz
    double getBWemitterHz(int idx = 0);

    // setChannelResolutionHz
    void setChannelResolutionHz(double ChannelResolutionHz, int idx = 0);

    // getChannelResolutionHz
    double getChannelResolutionHz(int idx = 0);

    // setPulseWidth
    void setPulseWidth(double PulseWidth, int idx = 0);

    // getPulseWidth
    double getPulseWidth(int idx = 0);

    // setPRF
    void setPRF(double PRF, int idx = 0);

    // getPRF
    double getPRF(int idx = 0);

    // setNFPRF
   void setNFPRF(double PRF, int idx = 0);

    // getNFPRF
   double getNFPRF(int idx = 0);

    // setTPolAngle
    void setTPolAngle(double PolAngle, int idx = 0);

    // getTPolAngle
    double getTPolAngle(int idx = 0);

    // setRPolAngle
    void setRPolAngle(double PolAngle, int idx = 0);

    // getRPolAngle
    double getRPolAngle(int idx = 0);

    // setSysTempK
   void setSysTempK(double degK, int idx = 0);

    // getSysTempK
   double getSysTempK(int idx);

    // setBeamWidth
   void setBeamWidth(double rad, int idx = 0);

    // getBeamWidth
   double getBeamWidth(int idx = 0);

    // setRangeCompensation
   void setRangeCompensation(bool rangeCompensation, int idx = 0);

    // getRangeCompensation
   bool getRangeCompensation(int idx = 0) const;

   //
   void setFRDAngularVelocity(double Yradpersec, double Pradpersec, double Rradpersec, int idx = 0);

   //
   void getFRDAngularVelocity(double &Yradpersec, double &Pradpersec, double &Rradpersec, int idx = 0);

   //
   void setSpotfile(char *filename, int idx = 0);

   //
   char *getSpotfile(int idx);


    // setTAprops
    void setTAprops(double ThreshDetect, double ThreshClassify, double ThreshRecognize, double ThreshIdentify, double PersistenceTime, int idx = 0);

    // getTAprops
    void getTAprops(double &ThreshDetect, double &ThreshClassify, double &ThreshRecognize, double &ThreshIdentify, double &PersistenceTime, int idx = 0);

    // setDopplerThreshold
    void setDopplerThreshold(double threshold, int idx = 0);

    // getDopplerThreshold
    double getDopplerThreshold(int idx = 0);

    // setDopplerThresholdMin
    void setDopplerThresholdMin(double threshold, int idx = 0);

    // getDopplerThresholdMin
    double getDopplerThresholdMin(int idx = 0);

    // setDopplerThresholdMax
    void setDopplerThresholdMax(double threshold, int idx = 0);

    // getDopplerThresholdMax
    double getDopplerThresholdMax(int idx = 0);

    // setClutterReductionMode
    void setClutterReductionMode(int CRMode, int idx = 0);

    // getClutterReductionMode
    int getClutterReductionMode(int idx = 0);

    // setClutterReductionFactor
    void setClutterReductionFactor(double CRFactor, int idx = 0);

    // getClutterReductionFactor
    double getClutterReductionFactor(int idx = 0);

    // setUseTrackfile
    void setUseTrackfile(bool useTrackfile, int idx = 0);

    // getUseTrackfile
    bool getUseTrackfile(int idx = 0);

    // setWorldPosition
   void setWorldPosition(double x, double y, double z, int i = 0);

    // getWorldPosition
   void getWorldPosition(double& x, double& y, double& z, int i = 0);

    // setGeodeticPosition
    void setGeodeticPosition(double latitude, double longitude, double altitude, int idx = 0);

    // getGeodeticPosition
    void getGeodeticPosition(double &latitude, double &longitude, double &altitude, int idx = 0);

    // setNEDOrientation
    void setNEDOrientation(double heading, double pitch, double roll, int idx = 0);

    // getNEDOrientation
    void getNEDOrientation(double &heading, double &pitch, double &roll, int idx = 0);

    // setNEDLinearVelocity
    void setNEDLinearVelocity(double n, double e, double d, int idx = 0);

    // getNEDLinearVelocity
    void getNEDLinearVelocity(double &n, double &e, double &d, int idx = 0);

    // SetActive
    void SetActive(bool isActive, int idx = 0);

    // GetActive
    bool GetActive(int idx = 0);

    //setRGBColor
    void setRGBColor(int color, int idx = 0) { m_sensorList[idx].m_sensorRGBColor = color; }
    //getRGBColor
    int getRGBColor(int idx = 0) { return m_sensorList[idx].m_sensorRGBColor; }
    //setReprojection
    void setReprojection(bool flag, int idx = 0);
    //getReprojection
    bool getReprojection(int idx = 0);


    void setBoresightROI(double x, double y, double width, double height, int idx = 0);
    void getBoresightROI(double &x, double &y, double &width, double &height, int idx = 0);
    void setIntegrationPathlength(double length, int idx = 0);
    void getIntegrationPathlength(double &length, int idx = 0);
    void setShadowOrientationDown(bool flag, int idx = 0);
    bool getShadowOrientationDown(int idx = 0);
    void setIntegrationTime(double time, int idx = 0);
    void getIntegrationTime(double &time, int idx = 0);

   void setIntensityModulationGain(double imodGain, int idx = 0);
   double getIntensityModulationGain(int idx = 0);

    //setMtiRadarReturn
    void setMtiRadarReturn(bool flag, int idx = 0);
    //getMtiRadarReturn
    bool getMtiRadarReturn(int idx = 0);

    //setDisplayType
    void setDisplayType(int displayType, int idx = 0);

    //getDisplayType
    int getDisplayType(int idx = 0);

    // setRadianceScaleEnable
   void setRadianceScaleEnable( bool enable, int idx = 0 )
    { 
        m_sensorList[idx].applyRadianceScale = enable;
    }

    // getRadianceScaleEnable
    bool getRadianceScaleEnable(int idx = 0) const
    { 
        return m_sensorList[idx].applyRadianceScale;
    }

    // getPPIMaxDownRangeResolution
    int getPPIMaxDownRangeResolution(int idx = 0) const
    { 
        return m_sensorList[idx].m_ppiMaxDownRangeResolution;
    }

    // setPPIMaxDownRangeResolution
   void setPPIMaxDownRangeResolution( int samples, int idx = 0 )
    { 
        m_sensorList[idx].m_ppiMaxDownRangeResolution = samples;
    }

    // getPPIMaxCrossRangeResolution
    int getPPIMaxCrossRangeResolution(int idx = 0) const
    { 
        return m_sensorList[idx].m_ppiMaxCrossRangeResolution;
    }

    // setPPIMaxCrossRangeResolution
   void setPPIMaxCrossRangeResolution( int samples, int idx = 0 )
    { 
        m_sensorList[idx].m_ppiMaxCrossRangeResolution = samples;
    }

    // getMinWedgeExtent
    double getMinWedgeExtent(int idx = 0) { return m_sensorList[idx].minWedgeExtent; }

    // setMinWedgeExtent
    void setMinWedgeExtent( double angle, int idx = 0 )
    { 
        if( angle >= -360.0 && angle < m_sensorList[idx].maxWedgeExtent && angle < 360.0 )   
            m_sensorList[idx].minWedgeExtent = angle; 
    }

    // getMaxWedgeExtent
    double getMaxWedgeExtent(int idx = 0) { return m_sensorList[idx].maxWedgeExtent; }

    // setMaxWedgeExtent
    void setMaxWedgeExtent( double angle, int idx = 0 )
    { 
        if( angle > -360.0 && angle > m_sensorList[idx].minWedgeExtent && angle <= 360.0 )   
            m_sensorList[idx].maxWedgeExtent = angle; 
    }


   
    // getDisplayRange
   double getDisplayRange(int idx = 0){ return m_sensorList[idx].displayRange; }

    // setDisplayRange
   void setDisplayRange( double range, int idx = 0 ){ if( range > 0.0 ) m_sensorList[idx].displayRange = range; }


    // getMaxRadarRangeScale
    double getMaxRadarRangeScale(int idx = 0) const;

    // setMaxRadarRangeScale
   void setMaxRadarRangeScale( double rangeScale, int idx = 0 );

   bool getBacksweepState( int idx = 0 ){  return m_sensorList[idx].enableBacksweep;  }

   void enableBacksweep( bool backsweep, int idx = 0 ){ m_sensorList[idx].enableBacksweep = backsweep; }

   bool getOtwViewState(int idx = 0){ return m_sensorList[idx].showOtwView ;}

   void showOtwView( bool show, int idx = 0 ){  m_sensorList[idx].showOtwView = show;  }

    void setPPIDisplayOffsetScale(int offsetX, int offsetY, double scaleX, double scaleY, int idx = 0);
    void getPPIDisplayOffsetScale(int &offsetX, int &offsetY, double &scaleX, double &scaleY, int idx = 0);
    void setPPIRadarReturnColor(double red, double green, double blue, int idx = 0);
    void getPPIRadarReturnColor(double &red, double &green, double &blue, int idx = 0);
    void setPPISARTRadarColor(double red, double green, double blue, int idx = 0);
    void getPPISARTRadarColor(double &red, double &green, double &blue, int idx = 0);
   void setPPITurbulenceRadarColor(double red, double green, double blue, int idx = 0);
   void getPPITurbulenceRadarColor(double &red, double &green, double &blue, int idx = 0);

    void setPPIRangeRingRenderEnable( bool renderEnable, int idx = 0 )
    { 
        m_sensorList[idx].m_rangeRingRenderEnable = renderEnable; 
    }
    bool getPPIRangeRingRenderEnable( int idx = 0 ) const
    { 
        return m_sensorList[idx].m_rangeRingRenderEnable;   
    }

    void setPPIRadarArmSweepRenderEnable( bool renderEnable, int idx = 0 )
    { 
        m_sensorList[idx].m_radarArmSweepRenderEnable = renderEnable;   
    }
    bool getPPIRadarArmSweepRenderEnable( int idx = 0 ) const
    { 
        return m_sensorList[idx].m_radarArmSweepRenderEnable;  
    }

    void setPPIRadarCursorEnable( bool renderEnable, int idx = 0 )
    { 
        m_sensorList[idx].m_PPIradarCursorEnable = renderEnable;  
    }
    bool getPPIRadarCursorEnable( int idx = 0 ) const
    { 
        return m_sensorList[idx].m_PPIradarCursorEnable; 
    }

    void setPPILineWidth( double lineWidth, int idx = 0 )
    { 
        m_sensorList[idx].m_lineWidth = lineWidth; 
    }
    double getPPILineWidth( int idx = 0 ) const
    { 
        return m_sensorList[idx].m_lineWidth;   
    }

    // getDBSangleExtent
   double getDBSangleExtent(int idx = 0){ return m_sensorList[idx].DBSangleExtent; }

    // setDBSangleExtent
   void setDBSangleExtent( double angle, int idx = 0 ){ if( angle > 0.0 ) m_sensorList[idx].DBSangleExtent = angle; }

    // getActiveSectorWidth
   double getActiveSectorWidth(int idx = 0){ return m_sensorList[idx].m_activeSectorWidth; }

    // setActiveSectorWidth
   void setActiveSectorWidth( double angle, int idx = 0 ){ if( angle > 0.0 ) m_sensorList[idx].m_activeSectorWidth = angle; }

    void setDBScenter(double centerX, double centerY, int idx = 0);
    void getDBScenter(double &centerX, double &centerY, int idx = 0);

    // getGMTIMode
    int getGMTIMode(int idx = 0) const
    { 
        return m_sensorList[idx].m_gmtiMode;
    }

    // setGMTIMode
   void setGMTIMode( int mode, int idx = 0 )
    { 
        m_sensorList[idx].m_gmtiMode = mode;
    }

    // getGMTITrackFilterMode
    int getGMTITrackFilterMode(int idx = 0) const
    { 
        return m_sensorList[idx].m_gmtiTrackFilterMode;
    }

    // setGMTITrackFilterMode
   void setGMTITrackFilterMode( int mode, int idx = 0 )
    { 
        m_sensorList[idx].m_gmtiTrackFilterMode = mode;
    }

    // getGMTITrackFilterID
    int getGMTITrackFilterID(int idx = 0) const
    { 
        return m_sensorList[idx].m_gmtiTrackFilterID;
    }

    // setGMTITrackFilterID
   void setGMTITrackFilterID( int id, int idx = 0 )
    { 
        m_sensorList[idx].m_gmtiTrackFilterID = id;
    }

    // getScaleMTItargetIndicators
    void getScaleMTItargetIndicators(double &x, double &y, int idx = 0) const
    { 
        x = m_sensorList[idx].m_mtiScaleX;
        y = m_sensorList[idx].m_mtiScaleY;
    }

    // setScaleMTItargetIndicators
   void setScaleMTItargetIndicators( double x, double y, int idx = 0 )
    { 
        m_sensorList[idx].m_mtiScaleX = x;
        m_sensorList[idx].m_mtiScaleY = y;
    }

    // getAirToAirMode
    int getAirToAirMode(int idx = 0) const
    { 
        return m_sensorList[idx].m_airToAirMode;
    }

    // setAirToAirMode
   void setAirToAirMode( int mode, int idx = 0 )
    { 
        m_sensorList[idx].m_airToAirMode = mode;
    }

    // getMaxMTItargets
    int getMaxMTItargets(int idx = 0) const
    { 
        return m_sensorList[idx].m_maxMTItargets;
    }

    // setMaxMTItargets
   void setMaxMTItargets( int maxTargets, int idx = 0 )
    { 
        m_sensorList[idx].m_maxMTItargets = maxTargets;
    }

    // getMaxAirToAirVelocity
    double getMaxAirToAirVelocity(int idx = 0) const
    { 
        return m_sensorList[idx].m_maxA2Avelocity;
    }

    // setMaxAirToAirVelocity
   void setMaxAirToAirVelocity( double maxVelocity, int idx = 0 )
    { 
        m_sensorList[idx].m_maxA2Avelocity = maxVelocity;
    }

    // getCagedModeHeadingPitch
    void getCagedModeHeadingPitch(double &heading, double &pitch, int idx = 0) const
    { 
        heading = m_sensorList[idx].m_cagedModeHeading;
        pitch =  m_sensorList[idx].m_cagedModePitch;
    }

    // setCagedModeHeadingPitch
   void setCagedModeHeadingPitch( double heading, double pitch, int idx = 0 )
    { 
        m_sensorList[idx].m_cagedModeHeading = heading;
        m_sensorList[idx].m_cagedModePitch = pitch;
    }

    // getTransponderReceiverFrequency
    double getTransponderReceiverFrequency(int idx = 0) const
    { 
        return m_sensorList[idx].m_transponderReceiverFrequency;
    }

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

    // getTrackLifeTime
    double getTrackLifeTime(int idx = 0) const
    { 
        return m_sensorList[idx].m_trackLifeTime;
    }

    // setTrackLifeTime
   void setTrackLifeTime( double lifetime, int idx = 0 )
    { 
        m_sensorList[idx].m_trackLifeTime = lifetime;
    }

   //getRadarColorMapFileName
   char* getRadarColorMapFileName(int idx = 0) const
   { 
      return m_sensorList[idx].m_radarColorMapFileName;
   }

   //setRadarColorMapFileName
   void setRadarColorMapFileName(const char* filepath, int idx = 0);

    // getMaxMTIhistory
    int getMaxMTIhistory(int idx = 0) const
    { 
        return m_sensorList[idx].m_maxMTIhistory;
    }

    // setMaxMTIhistory
   void setMaxMTIhistory( int history, int idx = 0 )
    { 
        m_sensorList[idx].m_maxMTIhistory = history;
    }

    //setSensorOptics
    void setSensorOptics(ciOptics optics, int idx = 0);
    //getSensorOptics
    ciOptics &getSensorOptics(int idx = 0);
    //setSensorElectronics
    void setSensorElectronics(ciElectronics electronics, int idx = 0);
    //getSensorElectronics
    ciElectronics &getSensorElectronics(int idx = 0);
    //setSensorDetector
    void setSensorDetector(ciDetector detector, int idx = 0);
    //getSensorDetector
    ciDetector &getSensorDetector(int idx = 0);
    //setSensorSenSim
    void setSensorSenSim(ciSenSim senSim, int idx = 0);
    //getSensorSenSim
    ciSenSim &getSensorSenSim(int idx = 0);


    // operator =
    ciSensor operator = (ciSensor &obj);

    // operator []
    ciSensor & operator [] (int idx);

    //public:     // methods

    // ciSensor
    ciSensor();

    // ciSensor
    ciSensor(ciSensor &obj);

    // ~ciSensor
    virtual ~ciSensor();

protected:  // variables

    // structSensorData
public:
    struct structSensorData
    {
        int index;
        char   name[128];
        int     type;
        double lowerBandLim;
        double upperBandLim;
        double dx;
        int nBands;
        double hFOVDeg;
        double vFOVDeg;
        int hFOVPixels;
        int vFOVPixels;
        double minTemperature;
        double maxTemperature;
        double maxLightLevel;
        double satRatio;            // [unitless 1->infty] S/N Ratio at saturation for radar.
        bool   useTrackfile;
        char   trackFilepath[512];
        double worldX;              
        double worldY;              
        double worldZ;              
        double latitude;            
        double longitude;           
        double altitude;            
        double heading;          
        double pitch;               
        double roll;             
        double  velN;                                   
        double  velE;                                   
        double  velD;                                   
        bool   isActive;            
        int m_sensorRGBColor;            
        int screenOffsetHorz;
        int screenOffsetVert;
        double detectorScaleFactorHorz;
        double detectorScaleFactorVert;
        int senSimFlag;
        bool automaticRadiance;
      char QEResponseFile[512];
        double PemitterW;           // [W]         Power of active sensor antenna
        double TGain;               // [unitless]  Directional transmitter antenna Gain
        double RGain;               // [unitless]  Directional receiver antenna Gain
      int GainPattern;           // [0=Unity, 1=Lobe, 2=Rect] Gain Pattern of the antenna
        double FCemitterHz;            // [Hz]        Center frequency of emitter
        double BWemitterHz;            // [Hz]        Bandwidth of emitter
        double ChannelResolutionHz;    // [Hz]        Receiver Channel resolution
        double PulseWidth;              // [s]          Pulse width in seconds
        double PRF;                     // [Hz]         Pulse repetition frequency (foveal)
        double NFPRF;               // [Hz]        Pulse repetition frequency (nonfoveal)
      double TpolAngle;          // [deg]    Transmittter Polarization Angle {H=0, V=90, U=45}
      double RpolAngle;          // [deg]    Receiver Polarization Angle {H=0, V=90, U=45}
      double SysTempK;           // [degK]      Radar System Temperature
        double BeamWidth;           // [rad]    Beam or spot width
        bool   RangeCompensation;       // [unitless]   Flag for controlling range compensation
        double velY;             // [rad/s]     FRD Yaw (horizontal) sensor rotation frequency
        double velP;             // [rad/s]     FRD Pitch (vertical) sensor rotation frequency
        double velR;             // [rad/s]     FRD Roll (helica) sensor rotation frequency
        char   spotFilepath[512];         
        double ThreshDetect;        // [unitless 0-1]       Detection probability 
        double ThreshClassify;         // [unitless 0-1]       Classification probability 
        double ThreshRecognize;        // [unitless 0-1]       Recognition probability 
        double ThreshIdentify;         // [unitless 0-1]       Identification probability 
        double DopplerThreshold;        // [unitless]           Doppler threshold
        double DopplerThresholdMin;     // [unitless]           Minimum doppler threshold
        double DopplerThresholdMax;     // [unitless]           Maximum doppler threshold (replaces dopplerThreshold)
        double PersistenceTime;        // [s]                  TA status persistence time
        double Gain;             // [unitless 0-1]       Gain 
        double Level;               // [unitless 0-1]       Level 
        bool reprojection;
        double boresightRoiX; 
        double boresightRoiY;
        double boresightRoiWidth;
        double boresightRoiHeight;
        double IntegrationPathlength;
      bool shadowOrientationDown;
        double IntegrationTime;
      double intensityModulationGain;
        int displayType;
        bool applyRadianceScale;
        int clutterReductionMode;
        double clutterReductionFactor;
        
        bool mtiRadarReturn;

      //ppi mode display params
        int     m_ppiMaxDownRangeResolution;
        int     m_ppiMaxCrossRangeResolution;
      double   minWedgeExtent;
      double   maxWedgeExtent;
      double   displayRange;
        double  maxRadarRangeScale;
      bool  enableBacksweep;
      bool  showOtwView;
        int     m_offsetWidth;
        int     m_offsetHeight;
        double  m_scaleWidth;
        double  m_scaleHeight;
        bool    m_rangeRingRenderEnable;
        bool    m_radarArmSweepRenderEnable;
        bool    m_PPIradarCursorEnable;
        double  m_renderColorR;
        double  m_renderColorG;
        double  m_renderColorB;
        double  m_SARTColorR;
        double  m_SARTColorG;
        double  m_SARTColorB;
      double  m_turbulenceColorR;
      double  m_turbulenceColorG;
      double  m_turbulenceColorB;
        double  m_lineWidth;
      bool    dopplerSpatialEffects;
        bool    dopplerBeamSharpening;
        double  DBSangleExtent;
        double  m_activeSectorWidth;
        double  DBScenterX;
        double  DBScenterY;
        int     m_gmtiMode;
        int     m_gmtiTrackFilterMode;
        int     m_gmtiTrackFilterID;
        int     m_airToAirMode;
        int     m_maxMTItargets;
        int     m_maxMTIhistory;
        double  m_mtiScaleX;
        double  m_mtiScaleY;
        double  m_maxA2Avelocity;
        double  m_cagedModePitch;
        double  m_cagedModeHeading;
        double  m_transponderReceiverFrequency;
        double  m_trackLifeTime;
      char  m_radarColorMapFileName[768];

        SensorType sensorType;
        ciSenSim  senSim;
        ciOptics  optics;
        ciElectronics   electronics;
        ciDetector   detector;
      //ciDisplay display;
    } *m_sensorList; 
    int     m_nSensors;
    clXML m_xml;
    clXMLNode* m_parentNode;
private: // variables

};

#endif // _ciSensor_h_