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

    enum OutputImageArrayType
    {
        OUTPUT_TYPE_RADIANCE,
        OUTPUT_TYPE_PHOTONS,
        OUTPUT_TYPE_COUNTS,
        OUTPUT_TYPE_NUM
    };


//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 AGCenable, 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());
         m_electronics->setAGCEnable(AGCenable);
      } 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);
         m_electronics->setAGCEnable(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);

//applyGpuSensorEffects
   void applyGpuSensorEffects(int inputTextureId, bool usePreviousFBO = false,
                                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);

   //isAeroDynamicHeatingEnable
   bool isAeroDynamicHeatingEnable() const;

   //setAeroDynamicHeatingEnable
   void setAeroDynamicHeatingEnable(bool flag);

   //getAeroDynamicHeatingGimbalMode
   int getAeroDynamicHeatingGimbalMode() const;

   //setAeroDynamicHeatingGimbalMode
   void setAeroDynamicHeatingGimbalMode(int flag);

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

    //setColorMapType
   void setColorMapType(seElectronics::ColorMapType newColorMapType);

   //getColorMapType
   seElectronics::ColorMapType getColorMapType() const;

   //setColorMapEnable
   void setColorMapEnable(int flag);

   //getColorMapEnable
   int getColorMapEnable() const;

   //isFullColorEnable
   bool isFullColorEnable() const;

   //setFullColorEnable
   void setFullColorEnable(bool flag);

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

   //setStopContinuous
   void setStopContinuous();

    //setSaveImageFileName
    void setSaveImageFileName(char *saveFileName);

    //setSavePreApertureImage
    void setSavePreApertureImage(bool preAperture);

    //setSaveContinuousImages
    void setSaveContinuousImages(bool continuous);

    //setFlipSaveImages
    void setFlipSaveImages(bool flip);

    //setSaveImagesAtDetectorResolution
    void setSaveImagesAtDetectorResolution(bool flag);

   //setSaveRadianceImageEnable
   void setSaveRadianceImageEnable();

   //setSaveRadianceImageArrayEnable
   void setSaveRadianceImageArrayEnable( bool enable );

    //applyAeroDynamicHeating
    void applyAeroDynamicHeating(float azimuthOffset, float elevationOffset, float speed, float aeroDynamicHeating);


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

    //setNumberSubloadRows
    void setNumberSubloadRows(int numberOfRows)
    {
        m_gpuProcessor->setNumberSubloadRows(numberOfRows);
    }

    //setOutputImageArrayType
    void setOutputImageArrayType( OutputImageArrayType type );

    //getOutputImageArrayType
    OutputImageArrayType getOutputImageArrayType() const;

   // initializeLicense
   bool initializeLicense();

    //licenseCheck
    bool licenseCheck() const;


    // openGLCheck
    bool openGLCheck() const;

   //getVersion
   const char * getVersion() const;

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

    bool getUsePreviousFBO() const
    {
        return m_usePreviousFBO;
    }

   void setFilteringMode(int mode = 1) {}
   int getFilteringMode() const { return 0; }
    
    void setMaxLightLevel(double maxLightLevel)
    {
        m_gpuProcessor->setMaxLightLevel(maxLightLevel);
    }

   //setMaxRadiance
   void setMaxRadiance(double maxRadiance);

   //setMinRadiance
   void setMinRadiance(double minRadiance);

   //setApertureWidth
   void setApertureWidth(double apertureWidth);

   //setApertureAspectRatio
   void setApertureAspectRatio(double apertureWidth);

   //setNoiseEquivalentTemp
   void setNoiseEquivalentTemp(double apertureWidth);

   //setNoiseEquivalentRadiance
   void setNoiseEquivalentRadiance(double apertureWidth);

protected:

   //getDistortionScaleFactor
   double getDistortionScaleFactor() const
    {
        return m_gpuProcessor->getDistortionScaleFactor();
    }

    void setHaloQEResponse(double QEResponse)
    {
        m_gpuProcessor->setHaloQEResponse(QEResponse);
    }

    double m_haloQEResponse;
    bool m_usePreviousFBO;

private:

   bool  m_enableSensorEffects;
   bool  m_enableGPUSensorEffects;
   bool  m_enableFilterEffects;
   bool  m_enableGainEffects;
   bool  m_enableNoiseEffects;
   bool  m_enableMotionBlurEffects;
   bool  m_enableHaloEffects;
   bool  m_enableAeroDynamicHeatingEffects;
   int       m_aeroDynamicHeatingGimbalMode;
   
   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_