seSenSim.h

Go to the documentation of this file.

// Copyright JRM Enterprises, Inc. 2004 - 2011
// 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 _seSenSim_
#define _seSenSim_

// SenSim headers
#include <stdlib.h>
#include "seDetector.h"
#include "seOptics.h"
#include "seElectronics.h"
#include "seGainLevel.h"
#include "seFilter.h"
#include "seNoise.h"
#include "seGpuProcessor.h"

#include "sedllexport.h"

#define PRODUCT_VERSION "SenSimRT"
#ifndef VERSIONNUMBER
#define VERSIONNUMBER 100   
#endif

   


class SENSOREFFECTS_API seSenSim
{

public:

// seSenSim
   seSenSim();

//seSenSim
   ~seSenSim();


//initialize
   bool initialize();


//outputImage
   void outputImage(char *filename, float *inputImage, long numCols,
                     long numRows);

//applyCpuSensorEffects
   void applyCpuSensorEffects(float *inputImage, long numCols, long numRows);
    // Helpers


//getFocalLength
   double getFocalLength() const;


//getFNumber
   double getFNumber() const;


//*getDetector
   seDetector *getDetector() const;

//*getOptics
   seOptics *getOptics() const;

//*getFilter
   seFilter *getFilter(){return m_filter;}

//*getNoise
// seNoise *getNoise(){return m_noise;}

//*getElectronics
   seElectronics *getElectronics() const;

//*getGainLevel
   seGainLevel *getGainLevel() const;

//setSensorEffectsFlags
   void setSensorEffectsFlags(bool enable, bool gpuEnable, bool filterEnable, bool noiseEnable, bool gainEnable, bool haloEnable, bool motionBlurEnable = false) { 
      m_enableSensorEffects = enable;
      m_enableGPUSensorEffects = gpuEnable;
      m_enableFilterEffects = filterEnable;
      m_enableGainEffects = gainEnable;
      m_enableNoiseEffects = noiseEnable;
      m_enableHaloEffects = haloEnable;
      m_enableMotionBlurEffects = motionBlurEnable;
      if (m_enableSensorEffects) {
         m_optics->setFilterEnable(isFilterOn());
         m_detector->setNoiseEnable(isNoiseOn());
         m_optics->setHaloEnable(isHaloOn());
         m_detector->setMotionBlurEnable(isMotionBlurOn());
         m_electronics->setGainEnable(isGainOn());
      } else {  // xxx this is probably not necessary since if sensor effects are off then these flags aren't used.
         m_optics->setFilterEnable(false);
         m_detector->setNoiseEnable(false);
         m_optics->setHaloEnable(false);
         m_electronics->setGainEnable(false);
         m_detector->setMotionBlurEnable(false);
      }
   }

//isSensorEffectsOn
   bool isSensorEffectsOn() const { 
        return m_enableSensorEffects; 
   }

    //setInputSize
   void setInputSize(int w, int h, bool use888Encoding = false);

    //setInputOffset
    void setInputOffset(int x, int y);

    //setDisplaySize
    void setDisplaySize(int w, int h);

    //setDisplayOffset
    void setDisplayOffset(int x, int y, bool clearBuffer=true);


    //applyGpuSensorEffects
   void applyGpuSensorEffects(int inputTextureId, float *inputImage=NULL, bool swapBuffer = false, bool useTextureRect = false, int outputTextureId = 0);

    //getMTFSamples
   void getMTFSamples (int numSamples, double &xCutoffFreq, double &yCutoffFreq,
                       double *xMTF, double *yMTF) const;


//isFilterOn
   bool isFilterOn() const { return m_enableFilterEffects; }
//isNoiseOn
   bool isNoiseOn() const { return m_enableNoiseEffects; }
//isHaloOn
   bool isHaloOn() const { return m_enableHaloEffects; }
//isMotionBlurOn
   bool isMotionBlurOn() const { return m_enableMotionBlurEffects; }
//isGainOn
   bool isGainOn() const { return m_enableGainEffects; }

//isGpuSensorEffectsOn
   bool isGpuSensorEffectsOn() const { return m_enableGPUSensorEffects; }

   //setFilterAdjustment
   void setFilterAdjustment(double adjustment);

   //setNoiseAdjustment
   void setNoiseAdjustment(double adjustment);

   //setGainAdjustment
   void setGainAdjustment(double adjustment);

   //setLevelAdjustment
   void setLevelAdjustment(double adjustment);

   //getFilterAdjustment
   double getFilterAdjustment() const;

   //getNoiseAdjustment
   double getNoiseAdjustment() const;

   //getGainAdjustment
   double getGainAdjustment() const;

   //getLevelAdjustment
   double getLevelAdjustment() const;

   //isBlackHotEnable
   bool isBlackHotEnable() const;

   //setBlackHotEnable
   void setBlackHotEnable(bool flag);

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

   //isFullColorEnable
   bool isFullColorEnable() const;

   //setFullColorEnable
   void setFullColorEnable(bool flag);

    //setSaveImage
    void setSaveImage(char *saveFileName, bool preAperture = false, bool continuous = false, bool flip = true);

   //setStopContinuous
   void setStopContinuous();

    //setSaveImageFileName
    void setSaveImageFileName(char *saveFileName);

    //setSavePreApertureImage
    void setSavePreApertureImage(bool preAperture);

    //setSaveContinuousImages
    void setSaveContinuousImages(bool continuous);

    //setFlipSaveImages
    void setFlipSaveImages(bool flip);

   //setSaveRadianceImageEnable
   void setSaveRadianceImageEnable();

   //setSaveRadianceImageArrayEnable
   void setSaveRadianceImageArrayEnable( bool enable );


    //getRadianceImageArray
    float* getRadianceImageArray() const;

    //getObjectIDImageArray
    float* getObjectIDImageArray() const;


    //getDownSampledRadianceImageArray
    float* getDownSampledRadianceImageArray() const;

    //getDownSampledObjectIDImageArray
    float* getDownSampledObjectIDImageArray() const;


    //getDownSampledImageSize
    void getDownSampledImageSize( int &width, int &height ) const
    {
        m_gpuProcessor->getDownSampledImageSize( width, height);
    }

    //setDownSampledImagesEnable
    void setDownSampledImagesEnable( bool bEnable )
    {
        m_gpuProcessor->setDownSampledImagesEnable(bEnable);
    }

    //getDownSampledImagesEnable
    bool getDownSampledImagesEnable() const
    {
        return m_gpuProcessor->getDownSampledImagesEnable();
    }

    //setObjectIDRenderingEnable
    void setObjectIDRenderingEnable(bool bEnable)
    {
        m_gpuProcessor->setObjectIDRenderingEnable(bEnable);
    }
    //getObjectIDRenderingEnable
    bool getObjectIDRenderingEnable() const
    {
        return m_gpuProcessor->getObjectIDRenderingEnable();
    }


   // initializeLicense
   bool initializeLicense();

    //licenseCheck
    bool licenseCheck() const;


    // openGLCheck
    bool openGLCheck() const;

   //getVersion
   const char * getVersion() const;

   //setDisplayTextureID
   void setDisplayTextureID(GLuint textureID, bool enable = true);



private:

   bool  m_enableSensorEffects;
   bool  m_enableGPUSensorEffects;
   bool  m_enableFilterEffects;
   bool  m_enableGainEffects;
   bool  m_enableNoiseEffects;
   bool  m_enableMotionBlurEffects;
   bool  m_enableHaloEffects; 
   
   bool m_license;
   seDetector *m_detector;
   seOptics *m_optics;
   seElectronics *m_electronics;
   seGainLevel *m_gainLevel;

   seFilter *m_filter;
   seNoise *m_noise;
   seGpuProcessor *m_gpuProcessor;

    struct Implementation;
   Implementation *m_impl;


};


#endif // _seSenSim_