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
    };

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);

    //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);
    SensorType getSensorType(int idx = 0);

    // setType
    void setType(int type, int idx = 0);
    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);
    //getSampleScale
    double getSampleScale(int idx = 0){return m_sensorList[idx].sampleScale;}
    //setSampleScale
    void setSampleScale(double scale, int idx = 0){m_sensorList[idx].sampleScale = scale;}

    // 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);

    // 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);

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

    //getDopplerColoring
    bool getDopplerColoring(int idx = 0);
  
    //setDopplerSpatialEffects
    void setDopplerSpatialEffects(bool flag, int idx = 0);

    //getDopplerSpatialEffects
    bool getDopplerSpatialEffects(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 mrad, int idx = 0);

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

   //
   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);

    // 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; }
    //setSarReprojection
    void setSarReprojection(bool flag, int idx = 0);
    //getSarReprojection
    bool getSarReprojection(int idx = 0);


    void setSarBoresightROI(double x, double y, double width, double height, int idx = 0);
    void getSarBoresightROI(double &x, double &y, double &width, double &height, int idx = 0);
    void setSarIntegrationPathlength(double length, int idx = 0);
    void getSarIntegrationPathlength(double &length, int idx = 0);
    void setSarShadowOrientationDown(bool flag, int idx = 0);
    bool getSarShadowOrientationDown(int idx = 0);
    void setIsarIntegrationTime(double time, int idx = 0);
    void getIsarIntegrationTime(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);

    // 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; }

   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;  }

 

    //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;            
        double sampleScale;
        int senSimFlag;
        bool automaticRadiance;
        bool dopplerColoring;
      bool dopplerSpatialEffects;
        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
        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 PersistenceTime;        // [s]                  TA status persistence time
        double Gain;             // [unitless 0-1]       Gain 
        double Level;               // [unitless 0-1]       Level 
        bool sarReprojection;
        double sarBoresightRoiX; 
        double sarBoresightRoiY;
        double sarBoresightRoiWidth;
        double sarBoresightRoiHeight;
        double sarIntegrationPathlength;
      bool sarShadowOrientationDown;
        double isarIntegrationTime;
      double intensityModulationGain;
        
        bool mtiRadarReturn;

      //ppi mode display params
      double   minWedgeExtent;
      double   maxWedgeExtent;
      double   displayRange;
      bool  enableBacksweep;
      bool  showOtwView;


        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_