seElectronics.h

Go to the documentation of this file.

// Copyright JRM Enterprises, Inc. 2004
// 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: Oct 2004
#ifndef _seElectronics_
#define _seElectronics_

//#include "seIncAll.h"

#include "sedllexport.h"

class SENSOREFFECTS_API seElectronics
{
public:
    typedef enum {  
      Undefined_ColorMap   = -1,
        UserDefined_ColorMap =  0,
        LADAR_ColorMap      =  1,
        NVG_ColorMap     =  2,
        RG16_ColorMap        =  3,
        LogScale_ColorMap    =  4,
        UserDefinedRG_ColorMap = 5,
        RG16_RB16_ColorMap   = 6,
        UserDefinedRG_RB_ColorMap = 7,
        NUM_ColorMap        = 8
    } ColorMapType ;


public:

    //seElectronics
    seElectronics();

    //seElectronics
    ~seElectronics();


    //loadDefaults
    void loadDefaults();


    //setFrameRate
    void setFrameRate(const double rate) {
        if (m_frameRate != rate) {
            m_frameRate = rate;
            setDirty();
        }
    }

    //getFrameRate
    double getFrameRate(){return m_frameRate;}


    //setPostCutoffFreq
    void setPostCutoffFreq(const double freq) {
        if (m_postCutoffFreq != freq) {
            m_postCutoffFreq = freq;
            setDirty();
        }
    }

    //getPostCutoffFreq
    double getPostCutoffFreq(){return m_postCutoffFreq;}


    //setPreCutonFreq
    void setPreCutonFreq(const double freq) {
        if (m_preCutonFreq != freq) {
            m_preCutonFreq = freq;
            setDirty();
        }
    }

    //getPreCutonFreq
    double getPreCutonFreq(){return m_preCutonFreq;}


    //setManualGain
    void setManualGain(const double gain) {
        m_manualGain = gain;
    }

    //getManualGain
    double getManualGain(){return m_manualGain;}


    //setManualLevel
    void setManualLevel(const double level) {
        m_manualLevel = level;
    }

    //getManualLevel
    double getManualLevel(){return m_manualLevel;}

    //setPreGain
    void setPreGain(const double gain) {
        m_preGain = gain;
    }

    //getPreGain
    double getPreGain(){return m_preGain;}


    //setPreLevel
    void setPreLevel(const double level) {
        m_preLevel = level;
    }

    //getPreLevel
    double getPreLevel(){return m_preLevel;}

    //setAGCMaxGain
    void setAGCMaxGain(const double gain) {
        m_AGCMaxGain = gain;
    }

    //getAGCMaxGain
    double getAGCMaxGain(){return m_AGCMaxGain;}

    //setAGCMinGain
    void setAGCMinGain(const double gain) {
        m_AGCMinGain = gain;
    }

    //getAGCMinGain
    double getAGCMinGain(){return m_AGCMinGain;}

    //setAGCGainThreshold
    void setAGCGainThreshold(const double threshold) 
    {
        m_AGCGainThreshold = threshold;
    }

    //getAGCGainThreshold
    double getAGCGainThreshold() const
    {
        return m_AGCGainThreshold;
    }

    //setMaxRadiance
    void setMaxRadiance(const double maxRad) {
        m_maxRadiance = maxRad;
    }

    //getMaxRadiance
    double getMaxRadiance(){return m_maxRadiance;}

    //setMinRadiance
    void setMinRadiance(const double minRad) {
        m_minRadiance = minRad;
    }

    //getMinRadiance
    double getMinRadiance(){return m_minRadiance;}

    //setMaxLutRadiance
    void setMaxLutRadiance(const double maxLutRad) {
        m_maxLutRadiance = maxLutRad;
    }

    //getMaxLutRadiance
    double getMaxLutRadiance(){return m_maxLutRadiance;}

    //setMinRadiance
    void setMinLutRadiance(const double minLutRad) {
        m_minLutRadiance = minLutRad;
    }

    //getMinLutRadiance
    double getMinLutRadiance(){return m_minLutRadiance;}

    //setBitDepthOutput
    void setBitDepthOutput( bool enable, float bitDepth = -1.0f );

    //getBitDepthOutput
    void getBitDepthOutput(bool &enable, float &bitDepth) const;

    //setLogScaleEnable
    void setLogScaleEnable(const bool flag) {
        m_logScaleEnable = flag;
    }

    //isLogScaleEnable
    bool isLogScaleEnable(){return m_logScaleEnable;}

    //setBlackHotEnable
    void setBlackHotEnable(const bool flag) {
        m_enableBlackHot = flag;
    }

    //isBlackHotEnable
    bool isBlackHotEnable(){return m_enableBlackHot;}

    //setGainEnable
    void setGainEnable(const bool flag) {
        m_gainEnable = flag;
    }

    //isGainEnable
    bool isGainEnable(){return m_gainEnable;}


    //setInternalGainEnable
    void setInternalGainEnable(const bool flag) {
        m_internalGainEnable = flag;
    }

    //isInternalGainEnable
    bool isInternalGainEnable(){return m_internalGainEnable;}


    //setACcouplingEnable
    void setACcouplingEnable(const bool flag) {
        m_ACcouplingEnable = flag;
    }

    //isACcouplingEnable
    bool isACcouplingEnable(){return m_ACcouplingEnable;}


    //setAGCEnable
    void setAGCEnable(const bool flag) {
        m_AGCEnable = flag;
    }

    //isAGCEnable
    bool isAGCEnable(){return m_AGCEnable;}

    //setAGCMode
    void setAGCMode(const int mode) {
      if(mode<0) m_AGCMode=0;
      else if(mode>3) m_AGCMode=3;
        else m_AGCMode = mode;
    }

    //getAGCMode
    int getAGCMode(){return m_AGCMode;}



    //setGainAdjustment
    void setGainAdjustment(double adjustment) {
        if (adjustment > 0.0)
            m_gainAdjustment = adjustment;   
        else
            m_gainAdjustment = 0.01;   
    }
    //getGainAdjustment
    double getGainAdjustment(){return m_gainAdjustment;}

    //setLevelAdjustment
    void setLevelAdjustment(double adjustment) {
        m_levelAdjustment = adjustment;
    }
    //getLevelAdjustment
    double getLevelAdjustment(){return m_levelAdjustment;}


    //setNumDisplayPixels
    void setNumDisplayPixels(const long width, const long height) {
        if ((m_displayWidth != width) ||
            (m_displayHeight != height)) {
                m_displayWidth = width;
                m_displayHeight = height;
                setDirty();
        }
    }

    //getNumDisplayPixels
    void getNumDisplayPixels(long &width, long &height){
        width = m_displayWidth;
        height = m_displayHeight;
    }

    //setDisplayOffset
    void setDisplayOffset(const long offsetX, const long offsetY, bool clearBuffer=true) {
        if ((m_displayOffsetX != offsetX) ||
            (m_displayOffsetY != offsetY) ||
            (m_clearBufferFlag != clearBuffer)) {
                m_displayOffsetX = offsetX;
                m_displayOffsetY = offsetY;
                m_clearBufferFlag = clearBuffer;
                setDirty();
        }
    }

    //getDisplayOffset
    void getDisplayOffset(long &offsetX, long &offsetY, bool &clearBuffer){
        offsetX = m_displayOffsetX;
        offsetY = m_displayOffsetY;
        clearBuffer = m_clearBufferFlag;
    }

    //getDisplayOffset
    void getDisplayOffset(long &offsetX, long &offsetY){
        offsetX = m_displayOffsetX;
        offsetY = m_displayOffsetY;
    }

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

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

    //setColorMapType
    void setColorMapType(ColorMapType newColorMapType) { 
        if (m_currentColorMapType != newColorMapType) { 
            m_currentColorMapType = newColorMapType; 
            setDirty();
        }
    }

    //getColorMapType
    ColorMapType getColorMapType() { return m_currentColorMapType; }

    //setColorMapEnable
    void setColorMapEnable(const int flag) {
        m_colorMapEnable = flag;
        setDirty();
    }

    //getColorMapEnable
    int getColorMapEnable() { return m_colorMapEnable; }

    //setFullColorOutputEnable
    void setFullColorOutputEnable(const bool flag) {
        m_fullColorOutputEnable = flag;
    }

    //isFullColorOutputEnable
    bool isFullColorOutputEnable() { return m_fullColorOutputEnable; }

    //  getBayerFilterMapWidth
    inline int getBayerFilterMapWidth(); 

    //  getBayerFilterMapHeight
    inline int getBayerFilterMapHeight(); 

    //  loadUserDefinedRadianceLUT
    bool loadUserDefinedRadianceLUT(char *filename);

    //  getColorMapUserDefinedRadFile
    char* getColorMapUserDefinedRadFile(); 
  
    //  setColorMapUserDefinedRadFile
   void setColorMapUserDefinedRadFile(const char* filepath);

    // loadColorMap
    void loadColorMap(unsigned int *textureId);

    // loadBayerFilterMap
    void loadBayerFilterMap(unsigned int *textureId, bool flip);

    // loadHistogramEqualizationMap
    void loadHistogramEqualizationMap(unsigned int *textureId, float *mapData, int size);

private:

    double m_frameRate;
    double m_postCutoffFreq;
    double m_preCutonFreq;
    double m_manualGain;
    double m_manualLevel;
    double m_preGain;
    double m_preLevel;
    double m_AGCMaxGain;
    double m_AGCGainThreshold;
    double m_AGCMinGain;
    double m_maxRadiance;
    double m_minRadiance;
    double m_maxLutRadiance;
    double m_minLutRadiance;
    float  m_bitDepthOutput;
    bool   m_enableBitDepthOutput;
    bool m_logScaleEnable;
    bool m_enableBlackHot;
    bool m_gainEnable;
    bool m_internalGainEnable;
    bool m_ACcouplingEnable;
    bool m_AGCEnable;
    double m_gainAdjustment;
    double m_levelAdjustment;
    long m_displayWidth;
    long m_displayHeight;
    long m_displayOffsetX;
    long m_displayOffsetY;
    bool m_clearBufferFlag;
    bool m_dirty;
    bool m_bayerFilterFlipState;

   int m_AGCMode; // 0 = Max, 1 = Clipped, 2 = Histogram Equalization, 3 = Histogram Projection

    int m_colorMapEnable;
    ColorMapType m_currentColorMapType;
    char m_colorMapUserDefinedRadFile[512];
    unsigned int  m_ColorMapSize;
    float       *m_ColorMapData;
    float       *m_BayerFilterMapData;
    float *m_pHistogramEqMap;
    bool m_fullColorOutputEnable;

    float *m_userdefLUTScaledRad;

};

#endif /* _seElectronics_ */