seDetector.h

Go to the documentation of this file.

// Copyright JRM Enterprises, Inc. 2004 - 2010
// 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:     Ken George     Date: October 2004

#ifndef _seDetector_
#define _seDetector_

//#include "seIncAll.h"

#include "sedllexport.h"

class SENSOREFFECTS_API seDetector
{
public:

   enum ScanDirectionType  
    { 
        InvalidScanDirection     = -1,
      ScanDirectionNone       =  0,
        HorizontalScanDirection      =  1,
      VerticalScanDirection      =  2,
      FullImageScan           =  3,
        NumScanDirection            =  4    // Handy enumeration count. Always keep as last entry.
   };

   enum AntiBloomingType 
   {
        ANTI_BLOOMING_NONE,
        ANTI_BLOOMING_HORIZONTAL,
        ANTI_BLOOMING_VERTICAL,
        ANTI_BLOOMING_NUM
    };

    //   seDetector
    seDetector();

    //seDetector
    ~seDetector();


    //loadDefaults
    void loadDefaults();


    //setBandpass
   void setBandpass(const double ax, const double bx);

    //getBandpass
    void getBandpass(double &ax, double &bx) const
    {
        ax = m_ax;
        bx = m_bx;
    }

    //setNumDetectors
    void setNumDetectors(const long width, const long height) {
        if ((m_detectorWidth != width) ||
            (m_detectorHeight != height)) {
                m_detectorWidth = width;
                m_detectorHeight = height;
                setDirty();
            }
    }

    //getNumDetectors
    void getNumDetectors(long &width, long &height) const
    {
        width = m_detectorWidth;
        height = m_detectorHeight;
    }



    //setPitchDetectors
    void setPitchDetectors(const double pitchHorz, const double pitchVert) {
      if (m_horizontalPitch != pitchHorz ||
         m_verticalPitch != pitchVert) 
      {
            m_horizontalPitch = pitchHorz;
            m_verticalPitch = pitchVert;
         setDirty();
      }
    }

    //getPitchDetectors
    void getPitchDetectors(double &pitchHorz, double &pitchVert) const
    {
        pitchHorz = m_horizontalPitch;
        pitchVert = m_verticalPitch;
    }

    //setSampleSize
    void setSampleSize(const double Horz, const double Vert);

    //getSampleSize
    void getSampleSize(double &Horz, double &Vert) const
    {
        Horz = m_horizontalSampleSize;
        Vert = m_verticalSampleSize;
    }


    //setDwellTime
    void setDwellTime(const double dwellTime) {
        if (m_dwellTime != dwellTime) {
            m_dwellTime = dwellTime;
            setDirty();
        }
    }

    //getDwellTime
    double getDwellTime() const {return m_dwellTime;}

    //setJitterAmplitude
    void setJitterAmplitude(const double amplitudeX, const double amplitudeY) 
    {
        bool dirty = false;
        if (m_jitterAmplitudeX != amplitudeX) 
        {
            m_jitterAmplitudeX = amplitudeX;
            dirty = true;
        }
        if (m_jitterAmplitudeY != amplitudeY) 
        {
            m_jitterAmplitudeY = amplitudeY;
            dirty = true;
        }

        if ( dirty )
            setDirty();
    }

    //getJitterAmplitude
    void getJitterAmplitude(double &jitterAmplitudeX, double &jitterAmplitudeY) const 
    {
        jitterAmplitudeX = m_jitterAmplitudeX;
        jitterAmplitudeY = m_jitterAmplitudeY;
    }

    //setJitterFrequency
    void setJitterFrequency(const double jitterfrequencyX, const double jitterfrequencyY) 
    {
        bool dirty = false;
        if (m_jitterFrequencyX != jitterfrequencyX) 
        {
            m_jitterFrequencyX = jitterfrequencyX;
            dirty = true;
        }
        if (m_jitterFrequencyY != jitterfrequencyY) 
        {
            m_jitterFrequencyY = jitterfrequencyY;
            dirty = true;
        }

        if ( dirty )
            setDirty();
    }

    //getJitterFrequency
    void getJitterFrequency(double &jitterFrequencyX, double &jitterFrequencyY) const 
    {
        jitterFrequencyX = m_jitterFrequencyX;
        jitterFrequencyY = m_jitterFrequencyY;
    }


    //setNoiseFrequencyKnee
    void setNoiseFrequencyKnee(const double freqKnee) {
        if (m_noiseFrequencyKnee != freqKnee) {
            m_noiseFrequencyKnee = freqKnee;
            setDirty();
        }
    }
    //setPoissonNoisePercent
    void setPoissonNoisePercent(double percent){m_percentPoisson = percent;}

    //getPoissonNoisePercent
    double getPoissonNoisePercent() const {return m_percentPoisson;}

    //setFInverseNoisePercent
    void setFInverseNoisePercent(double percent){m_percentFInverse = percent;}

    //getFInverseNoisePercent
    double getFInverseNoisePercent() const {return m_percentFInverse;}  

    //getNoiseFrequencyKnee
    double getNoiseFrequencyKnee() const {return m_noiseFrequencyKnee;}


    //setNoiseFrequencyExp
    void setNoiseFrequencyExp(const double freqExp) {
        if (m_noiseFrequencyExp != freqExp) {
            m_noiseFrequencyExp = freqExp;
            setDirty();
        }
    }

    //getNoiseFrequencyExp
    double getNoiseFrequencyExp() const {return m_noiseFrequencyExp;}


    //setNoiseEquivalentTemp
    void setNoiseEquivalentTemp(const double temp) {
        if (m_noiseEquivalentTemp != temp) {
            m_noiseEquivalentTemp = temp;
            setDirty();
        }
    }

    //getNoiseEquivalentTemp
    double getNoiseEquivalentTemp() const {return m_noiseEquivalentTemp;}


    //setBackgroundTemp
    void setBackgroundTemp(const double temp);

    //getBackgroundTemp
    double getBackgroundTemp() const {return m_BackgroundTemp;}

    //getBackgroundRadiance
    double getBackgroundRadiance() const {return m_BackgroundRadiance;}


    //setFixedPatternNoisePercent
    void setFixedPatternNoisePercent(double temp) {
        m_percentFixedNoise = temp;
    }

    //getFixedPatternNoisePercent
    double getFixedPatternNoisePercent() const {return m_percentFixedNoise;}


    //setNoiseEquivalentRadiance
    void setNoiseEquivalentRadiance(double temp) {
        if (m_noiseEquivRadiance != temp) {
            m_noiseEquivRadiance = temp;
            setDirty();
        }
    }

    //getNoiseEquivalentRadiance
    double getNoiseEquivalentRadiance() const {return m_noiseEquivRadiance;}


    //setPercentPixelFill
    void setPercentPixelFill(double temp) {
        if (m_percentPixelFill != temp) {
            m_percentPixelFill = temp;
            m_percentHorzPixelFill = temp;
            m_percentVertPixelFill = temp;
            setDirty();
        }
    }

    //getPercentPixelFill
    double getPercentPixelFill() const {return m_percentPixelFill;}

    //setPercentPixelFill
    void setPercentPixelFill(double fillHorz, double fillVert);

    //getPercentPixelFill
    void getPercentPixelFill(double &fillHorz, double &fillVert) const 
    {
        fillHorz = m_percentHorzPixelFill;
        fillVert = m_percentVertPixelFill;
    }


    //setPercentDeadPixel
    void setPercentDeadPixel(double temp) {
        m_percentDeadPixel = temp;
    }

    //getPercentDeadPixel
    double getPercentDeadPixel() const {return m_percentDeadPixel;}


    //setNoiseEnable
    void setNoiseEnable(const bool flag) {
        m_noiseEnable = flag;
    }

    //isFullColorEnable
    bool isFullColorEnable() const {return m_FullColorEnable;}

    //setFullColorEnable
    void setFullColorEnable(const bool flag) {
        if (m_FullColorEnable != flag) {
            m_FullColorEnable = flag;
            setDirty();
        }
    }

    //getChannelSelects
    void getChannelSelects(float &redSelect, float &greenSelect, float &blueSelect ) const
    {
      redSelect = m_redSelect;
      greenSelect = m_greenSelect;
      blueSelect = m_blueSelect;
   }

    //setChannelSelects
    void setChannelSelects(float redSelect, float greenSelect, float blueSelect ) {
      m_redSelect = redSelect;
      m_greenSelect = greenSelect;
      m_blueSelect = blueSelect;
   }


    //isScanningSensorEnable
    bool isScanningSensorEnable() const {return m_scanningSensorEnable;}

    //setScanningSensorEnable
    void setScanningSensorEnable(const bool flag) {
        m_scanningSensorEnable = flag;
    }

   //getNonUniformityEnable
   bool getNonUniformityEnable() const { return m_nonUniformityEnable; }

   //setNonUniformityEnable
   void setNonUniformityEnable(const bool flag)
   {
      m_nonUniformityEnable = flag;
   }

    //setScanMaskFilename
    inline void setScanMaskFilename(char *scanMaskFileName) { setScanMaskGainFilename(scanMaskFileName); }

    //getScanMaskImage
    inline char *getScanMaskFilename() { return getScanMaskGainFilename(); }


    //setScanMaskGainFilename
    void setScanMaskGainFilename(char *scanMaskFileName);

    //getScanMaskGainImage
    char *getScanMaskGainFilename();

    //setScanMaskLevelFilename
    void setScanMaskLevelFilename(char *scanMaskFileName);

    //getScanMaskLevelImage
    char *getScanMaskLevelFilename();

    //setScanMask
    void setScanMask(float minGain, float maxGain, ScanDirectionType scanDirection, int lineSpacing = 1, float minLevel = 0.0, float maxLevel = 0.0);

    //getScanMaskMaxGain
    float getScanMaskMaxGain() const {return m_scanMaskMaxGain;}

    //setScanMaskMaxGain
    void setScanMaskMaxGain(float val);

    //getScanMaskMinGain
    float getScanMaskMinGain() const {return m_scanMaskMinGain;}

    //setScanMaskMinGain
    void setScanMaskMinGain(float val);

    //getScanMaskMaxLevel
    float getScanMaskMaxLevel() const {return m_scanMaskMaxLevel;}

    //setScanMaskMaxLevel
    void setScanMaskMaxLevel(float val);

    //getScanMaskMinLevel
    float getScanMaskMinLevel() const {return m_scanMaskMinLevel;}

    //setScanMaskMinLevel
    void setScanMaskMinLevel(float val);

    //getScanMaskDirection
   ScanDirectionType getScanMaskDirection() const {return m_scanMaskDirection;}

    //setScanMaskMaskDirection
    void setScanMaskDirection(ScanDirectionType val);

    //getScanMaskLineSpacing
   int getScanMaskLineSpacing() const {return m_scanMaskLineSpacing;}
 
    //setScanMaskLineSpacing
    void setScanMaskLineSpacing(int val);

    //getScanMaskLevelAdjustment
    void setScanMaskLevelAdjustment(double adjustment) {
        m_scanMaskLevelAdjustment = adjustment;
    }
    //getScanMaskLevelAdjustment
    double getScanMaskLevelAdjustment() const {return m_scanMaskLevelAdjustment;}

    //getScanMaskUserDefined
   bool getScanMaskUserDefined() const;

    //setScanMaskUserDefined
   void setScanMaskUserDefined(bool userDefined);

   //getUserDefinedNonUniformityGainData
   float *getUserDefinedNonUniformityGainData() const;

   //setUserDefinedNonUniformityGainData
   void setUserDefinedNonUniformityGainData(float *data);

   //getUserDefinedNonUniformityLevelData
   float *getUserDefinedNonUniformityLevelData() const;

   //setUserDefinedNonUniformityLevelData
   void setUserDefinedNonUniformityLevelData(float *data);

    //isNoiseEnable
    bool isNoiseEnable() const {return m_noiseEnable;}

    //setNoiseAdjustment
    void setNoiseAdjustment(double adjustment) {
        m_noiseAdjustment = adjustment;
    }

    double getNoiseAdjustment() const {return m_noiseAdjustment;}

    // setMotionBlurEnable
    void setMotionBlurEnable (const bool flag) {
        m_motionBlurEnable = flag;
    }

    // isMotionBlurEnable
    bool isMotionBlurEnable() const { return m_motionBlurEnable; }

    // setMotionBlurWeight
    void setMotionBlurWeight(double weight) {
       if ((weight >= 0.0) &&
      (weight <= 1.0))
          m_motionBlurWeight = weight;
    }
    // getMotionBlurWeight
    double getMotionBlurWeight() const { return m_motionBlurWeight; }


    //setWeightThreshold 
    void setWeightThreshold(double threshold) {
        if (m_weightThreshold != threshold) {
            m_weightThreshold = threshold;
            setDirty();
        }
    }
    
    //getWeightThreshold
    double getWeightThreshold() const {return m_weightThreshold;}

    //getChargeWellCapacity
    double getChargeWellCapacity() const 
    {
        return m_chargeWellCapacity;
    }

    //setChargeWellCapacity
    void setChargeWellCapacity(double threshold) 
    {
        if (m_chargeWellCapacity != threshold) 
        {
            m_chargeWellCapacity = threshold;
            setDirty();
        }
    }

    //getQuantumEfficiency
    double getQuantumEfficiency() const 
    {
        return m_quantumEfficiency;
    }

    //setQuantumEfficiency
    void setQuantumEfficiency(double efficiency) 
    {
        if (m_quantumEfficiency != efficiency) 
        {
            m_quantumEfficiency = efficiency;
            setDirty();
        }
    }

    //getAntiBloomingType
    AntiBloomingType getAntiBloomingType() const 
    {
        return m_antiBloomDirection;
    }

    //setAntiBloomingType
    void setAntiBloomingType(AntiBloomingType antibloomDirection) 
    {
        if (m_antiBloomDirection != antibloomDirection) 
        {
            m_antiBloomDirection = antibloomDirection;
            setDirty();
        }
    }

    //getMaterialWavelengthCutOnCutOff
    void getMaterialWavelengthCutOnCutOff(double &cuton, double &cutoff) const 
    {
        cuton = m_wavelengthCutOn;
        cutoff = m_wavelengthCutOff;
    }

    //setMaterialWavelengthCutOnCutOff
    void setMaterialWavelengthCutOnCutOff(double cuton, double cutoff) 
    {
        if (m_wavelengthCutOn != cuton) 
        {
            m_wavelengthCutOn = cuton;
            setDirty();
        }

        if (m_wavelengthCutOff != cutoff) 
        {
            m_wavelengthCutOff = cutoff;
            setDirty();
        }
    }

    //getMicroChannelPlateDistance
    double getMicroChannelPlateDistance() const 
    {
        return m_microChannelPlateDistance;
    }

    //setMicroChannelPlateDistance
    void setMicroChannelPlateDistance(double distance) 
    {
        if (m_microChannelPlateDistance != distance) 
        {
            m_microChannelPlateDistance = distance;
            setDirty();
        }
    }

    //getPhotoCathodeVoltage
    double getPhotoCathodeVoltage() const 
    {
        return m_photoCathodeVoltage;
    }

    //setPhotoCathodeVoltage
    void setPhotoCathodeVoltage(double voltage) 
    {
        if (m_photoCathodeVoltage != voltage) 
        {
            m_photoCathodeVoltage = voltage;
            setDirty();
        }
    }

    //getReadoutNoiseNumElectron
    double getReadoutNoiseNumElectron() const 
    {
        return m_electronReadoutNoise;
    }

    //setReadoutNoiseNumElectron
    void setReadoutNoiseNumElectron(double electrons) 
    {
        if (m_electronReadoutNoise != electrons) 
        {
            m_electronReadoutNoise = electrons;
            setDirty();
        }
    }

    //getWellCapacityPercentage
    double getWellCapacityPercentage() const 
    {
        return m_wellCapacityPercentage;
    }

    //setWellCapacityPercentage
    void setWellCapacityPercentage(double percentage);

    //get3DNoiseEnable
    bool get3DNoiseEnable() const 
    {
        return m_enable3DNoise;
    }

    //set3DNoiseEnable
    void set3DNoiseEnable(bool enable)
    {
        if (m_enable3DNoise != enable) 
        {
            m_enable3DNoise = enable;
            setDirty();
        }
    }

    //get3DNoiseSigmaH
    float get3DNoiseSigmaH() const 
    {
        return m_3DNoiseSigmaH;
    }

    //set3DNoiseSigmaH
    void set3DNoiseSigmaH(float STD) 
    {
        if (m_3DNoiseSigmaH != STD) 
        {
            m_3DNoiseSigmaH = STD;
            setDirty();
        }
    }

    //get3DNoiseSigmaV
    float get3DNoiseSigmaV() const 
    {
        return m_3DNoiseSigmaV;
    }

    //set3DNoiseSigmaV
    void set3DNoiseSigmaV(float STD) 
    {
        if (m_3DNoiseSigmaV != STD) 
        {
            m_3DNoiseSigmaV = STD;
            setDirty();
        }
    }

    //get3DNoiseSigmaVH
    float get3DNoiseSigmaVH() const 
    {
        return m_3DNoiseSigmaVH;
    }

    //set3DNoiseSigmaVH
    void set3DNoiseSigmaVH(float STD) 
    {
        if (m_3DNoiseSigmaVH != STD) 
        {
            m_3DNoiseSigmaVH = STD;
            setDirty();
        }
    }

    //get3DNoiseSigmaT
    float get3DNoiseSigmaT() const 
    {
        return m_3DNoiseSigmaT;
    }

    //set3DNoiseSigmaT
    void set3DNoiseSigmaT(float STD) 
    {
        if (m_3DNoiseSigmaT != STD) 
        {
            m_3DNoiseSigmaT = STD;
            setDirty();
        }
    }

    //get3DNoiseSigmaTH
    float get3DNoiseSigmaTH() const 
    {
        return m_3DNoiseSigmaTH;
    }

    //set3DNoiseSigmaTH
    void set3DNoiseSigmaTH(float STD) 
    {
        if (m_3DNoiseSigmaTH != STD) 
        {
            m_3DNoiseSigmaTH = STD;
            setDirty();
        }
    }

    //get3DNoiseSigmaTV
    float get3DNoiseSigmaTV() const 
    {
        return m_3DNoiseSigmaTV;
    }

    //set3DNoiseSigmaTV
    void set3DNoiseSigmaTV(float STD) 
    {
        if (m_3DNoiseSigmaTV != STD) 
        {
            m_3DNoiseSigmaTV = STD;
            setDirty();
        }
    }

    //get3DNoiseSigmaTVH
    float get3DNoiseSigmaTVH() const 
    {
        return m_3DNoiseSigmaTVH;
    }

    //set3DNoiseSigmaTVH
    void set3DNoiseSigmaTVH(float STD) 
    {
        if (m_3DNoiseSigmaTVH != STD) 
        {
            m_3DNoiseSigmaTVH = STD;
            setDirty();
        }
    }

    //computeVariables
    void computeVariables(double focalLen, double horzFOV, double vertFOV, double frameRate);

    //getDetectorAngularSubtense
    void getDetectorAngularSubtense(double &DASHorz, double &DASVert) const 
    {
        DASHorz = m_DASHorz;
        DASVert = m_DASVert;
    }

    //getNyquistSamplingFrequency
    void getNyquistSamplingFrequency(double &nyquistHorz, double &nyquistVert) const 
    {
        nyquistHorz = m_nyquistHorz;
        nyquistVert = m_nyquistVert;
    }

    //getScanVelocity
    double getScanVelocity() const 
    {
        return m_scanVelocity;
    }

    //isDirty
    bool isDirty() const {return m_dirty;}

    //setDirty
    void setDirty() {m_dirty = true;}
    //clrDirty
    void clrDirty() {m_dirty = false;}

    //isScanMaskDirty
    bool isScanMaskDirty() const {return m_scanMaskDirty;}
    //setScanMaskDirty
    void setScanMaskDirty() {m_scanMaskDirty = true;}
    //clrScanMaskDirty
    void clrScanMaskDirty() {m_scanMaskDirty = false;}

private:

    double m_ax;              
    double m_bx;              
    long m_detectorWidth;        
    long m_detectorHeight;       
    double m_horizontalPitch;    
    double m_verticalPitch;         
    double m_horizontalSampleSize;  
    double m_verticalSampleSize;    
    double m_dwellTime;          
    double m_scanVelocity;          
    double m_DASHorz;               
    double m_DASVert;               
    double m_nyquistHorz;           
    double m_nyquistVert;           
    double m_noiseFrequencyKnee; 
    double m_noiseFrequencyExp;     
    double m_noiseEquivalentTemp;   
    double m_BackgroundTemp;     
    double m_BackgroundRadiance;    
    double m_percentFixedNoise;     
    double m_noiseEquivRadiance; 
    double m_electronReadoutNoise;  
    double m_percentPixelFill;      
    double m_percentHorzPixelFill;  
    double m_percentVertPixelFill;  
    double m_percentDeadPixel;      
    double m_percentPoisson;        
    double m_percentFInverse;       
    bool m_noiseEnable;             
    double m_noiseAdjustment;       
    double m_weightThreshold;    
    double m_jitterAmplitudeX;      
    double m_jitterAmplitudeY;      
    double m_jitterFrequencyX;      
    double m_jitterFrequencyY;      
    
    bool m_motionBlurEnable;        
    double m_motionBlurWeight;      

    bool m_FullColorEnable;         
   float m_redSelect;              
   float m_greenSelect;            
   float m_blueSelect;             
    
   bool m_scanningSensorEnable;            
   bool m_nonUniformityEnable;            
   char m_scanMaskGainFileName[255]; // Set to 255 to match SIGSIM_STRING_SIZE       ///< A single channel *.bmp for per channel gain
   char m_scanMaskLevelFileName[255];      

   ScanDirectionType m_scanMaskDirection;  
   float m_scanMaskMinGain;                
   float m_scanMaskMaxGain;                
   float m_scanMaskMinLevel;               
   float m_scanMaskMaxLevel;               
   int   m_scanMaskLineSpacing;            
   bool m_scanMaskDirty;               
   double m_scanMaskLevelAdjustment;       
   bool m_scanMaskUserDefined;             
   float *m_userDefinedNonUniformityGain; 
   float *m_userDefinedNonUniformityLevel;   

    double m_chargeWellCapacity;            
    double m_quantumEfficiency;             
    AntiBloomingType m_antiBloomDirection;  
    double m_wavelengthCutOn;               
    double m_wavelengthCutOff;              
    double m_microChannelPlateDistance;     
    double m_photoCathodeVoltage;           
    double m_wellCapacityPercentage;        

    bool m_enable3DNoise;                   
    float m_3DNoiseSigmaH;                  
    float m_3DNoiseSigmaV;                  
    float m_3DNoiseSigmaVH;                 
    float m_3DNoiseSigmaT;                  
    float m_3DNoiseSigmaTH;                 
    float m_3DNoiseSigmaTV;                 
    float m_3DNoiseSigmaTVH;                


   bool m_dirty;                      

};


#endif // _seDetector_