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,      
        HorizontalScanDirection      =  0,
      VerticalScanDirection      =  1,
      FullImageScan           =  2,
        NumScanDirection            =  3    // Handy enumeration count. Always keep as last entry.
   };

    //   seDetector
    seDetector();

    //seDetector
    ~seDetector();


    //loadDefaults
    void loadDefaults();


    //setBandpass
    void setBandpass(const double ax, const double bx) {
        if ((m_ax != ax) ||
            (m_bx != bx)) {
                m_ax = ax;
                m_bx = bx;
                setDirty();
            }
    }

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


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

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


    //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) {
        if (m_BackgroundTemp != temp) {
            m_BackgroundTemp = temp;
            setDirty();
        }
    }

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


    //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_precentPixelFill != temp) {
            m_precentPixelFill = temp;
            setDirty();
        }
    }

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


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

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

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


    //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_dwellTime;          
    double m_noiseFrequencyKnee; 
    double m_noiseFrequencyExp;     
    double m_noiseEquivalentTemp;   
    double m_BackgroundTemp;     
    double m_percentFixedNoise;     
    double m_noiseEquivRadiance; 
    double m_precentPixelFill;      
    double m_percentDeadPixel;      
    double m_percentPoisson;        
    double m_percentFInverse;       
    bool m_noiseEnable;             
    double m_noiseAdjustment;       
    double m_weightThreshold;    
    
    bool m_motionBlurEnable;        
    double m_motionBlurWeight;      

    bool m_FullColorEnable;         
   float m_redSelect;              
   float m_greenSelect;            
   float m_blueSelect;             
    
   bool m_scanningSensorEnable;            
   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;             

   bool m_dirty;                      

};


#endif // _seDetector_