seOptics.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: October 2004

#ifndef _seOptics_
#define _seOptics_

//#include "seIncAll.h"
#include "sedllexport.h"

// class: seOptics
//
//
class SENSOREFFECTS_API seOptics
{
public:

   enum shapeType 
   {
        Circular = 0,
        Rectangular = 1,
    };

   enum HaloType 
   {
        HALO_TYPE_PMT,
        HALO_TYPE_CCD,
        HALO_TUPE_NUM
    };


    //   seOptics
    seOptics();

    //seOptics
    ~seOptics();


    //loadDefaults
    void loadDefaults();


    //setApertureWidth
    void setApertureWidth(const double dim) {
        if (m_apertureWidth != dim) {
         if (dim < 0.0000001)  // aperture can't be zero
            m_apertureWidth = 0.0000001; 
         else 
            m_apertureWidth = dim;
            setDirty();
        }
    }

    //getApertureWidth
    double getApertureWidth(){return m_apertureWidth;}


    //setApertureShape
    void setApertureShape(shapeType shape) {
        if (m_apertureShape != shape) {
            m_apertureShape = shape;
            setDirty();
        }
    }

    //getApertureShape
    shapeType getApertureShape(){return m_apertureShape;}


    //setApertureAspectRatio
    void setApertureAspectRatio(const double ratio) {
        if (m_apertureAspectRatio != ratio) {
            m_apertureAspectRatio = ratio;
            setDirty();
        }
    }

    //getApertureAspectRatio
    double getApertureAspectRatio(){return m_apertureAspectRatio;}


    //setBlurSpotDiameter 
    void setBlurSpotDiameter (const double size) {
        if (m_blurSpotDiameter != size) {
            m_blurSpotDiameter = size;
            setDirty();
        }
    }

    //getBlurSpotDiameter
    double getBlurSpotDiameter(){return m_blurSpotDiameter;}


    //setFOVdegs
    void setFOVdegs(const double horzFov, const double vertFov) {
        if ((m_horizontalFov != horzFov) ||
            (m_verticalFov != vertFov)) {
                m_horizontalFov = horzFov;
                m_verticalFov = vertFov;
                setDirty();
            }
    }


    //getFOVdegs
    void getFOVdegs(double &horzFov, double &vertFov){
        horzFov = m_horizontalFov;
        vertFov = m_verticalFov;
    }


    //setMtfMotionBlurSize 
    void setMtfMotionBlurSize (const double size) {
        if (m_mtfMotionBlurSize != size) {
            m_mtfMotionBlurSize = size;
            setDirty();
        }
    }

    //getMtfMotionBlurSize
    double getMtfMotionBlurSize(){return m_mtfMotionBlurSize;}

    //setLensTransmittance 
    void setLensTransmittance (const double transmittance) {
        if (m_lensTransmittance != transmittance) {
            m_lensTransmittance = transmittance;
            setDirty();
        }
    }

    //getLensTransmittance
    double getLensTransmittance(){return m_lensTransmittance;}

    //setImageMaskRadius 
   void setImageMaskRadius(const double radius);

    //getImageMaskRadius
   double getImageMaskRadius() const;

   //setImageMaskScale
   void setImageMaskScale(const double scaleX, const double scaleY);

   //getImageMaskScale
   void getImageMaskScale(double &scaleX, double &scaleY) const;

    //setFocalLength 
    void setFocalLength (double focalLength, double pixelPitchX, double pixelPitchY, 
                            double numPixelsX, double numPixelsY, double fillX,
                            double fillY);

    //getFocalLength
    double getFocalLength() const;

    //setFNumber 
    void setFNumber (const double fNumber);

    //getFNumber
    double getFNumber() const;


    //setFilterEnable
    void setFilterEnable(const bool flag) {
        m_filterEnable = flag;
    }

    //isFilterEnable
    bool isFilterEnable(){return m_filterEnable;}

    //setOptimizedFilterEnable
    void setOptimizedFilterEnable(const bool flag) {
        if (m_optimizedFilterEnable != flag) {
            m_optimizedFilterEnable = flag;
            setDirty();
        }
    }

    //isOptimizedFilterEnable
    bool isOptimizedFilterEnable(){return m_optimizedFilterEnable;}

    //setFilterAdjustment 
    void setFilterAdjustment(double adjustment) {
        m_filterAdjustment = adjustment;
    }
    //getFilterAdjustment
    double getFilterAdjustment(){return m_filterAdjustment;}

    //setHaloEnable
    void setHaloEnable(const bool flag) {
        m_haloEnable = flag;
    }

    //isHaloEnable
    bool isHaloEnable(){return m_haloEnable;}


    //setHaloThreshold 
    void setHaloThreshold (const double value) {
        m_haloThreshold = value;
    }

    //getHaloThreshold
    double getHaloThreshold(){return m_haloThreshold;}


    //setHaloRadius 
    void setHaloRadius (const double value);

    //getHaloRadius
    double getHaloRadius(){return m_haloRadius;}


    //setHaloIntensity 
    void setHaloIntensity (const double intensity) {
        m_haloIntensity = intensity;
    }

    //getHaloIntensity
    double getHaloIntensity(){return m_haloIntensity;}

    //setHaloType 
    void setHaloType (HaloType type) 
    {
        m_haloType = type;
    }

    //getHaloType
    HaloType getHaloType() const
    {
        return m_haloType;
    }

    //setSeparableKernelEnable
    void setSeparableKernelEnable(bool enable);

    //getSeparableKernelEnable
    bool getSeparableKernelEnable() const
    {
        return m_enableSeparableKernel;
    }

    //setAberrationsEnable
    void setAberrationsEnable (bool enable);

    //getAberrationsEnable
    bool getAberrationsEnable() const
    {
        return m_aberrationsEnable;
    }

    //setDefocusCoefficient
    void setDefocusCoefficient (const double defocus) 
    {
        m_W020 = defocus;
        setDirty();
    }

    //getDefocusCoefficient
    double getDefocusCoefficient() const
    {
        return m_W020;
    }

    //setSphericalAberrationCoefficient
    void setSphericalAberrationCoefficient (const double sphericalAberration) 
    {
        m_W040 = sphericalAberration;
        setDirty();
    }

    //getSphericalAberrationCoefficient
    double getSphericalAberrationCoefficient() const
    {
        return m_W040;
    }

    //setComaCoefficient
    void setComaCoefficient (const double coma) 
    {
        m_W131 = coma;
        setDirty();
    }

    //getComaCoefficient
    double getComaCoefficient() const
    {
        return m_W131;
    }

    //setAstigmatismCoefficient
    void setAstigmatismCoefficient (const double astigmatism) 
    {
        m_W222 = astigmatism;
        setDirty();
    }

    //getAstigmatismCoefficient
    double getAstigmatismCoefficient() const
    {
        return m_W222;
    }

    //setFieldCurvatureCoefficient
    void setFieldCurvatureCoefficient (const double fieldCurvature) 
    {
        m_W220 = fieldCurvature;
        setDirty();
    }

    //getFieldCurvatureCoefficient
    double getFieldCurvatureCoefficient() const
    {
        return m_W220;
    }

    //setDistortionCoefficient
    void setDistortionCoefficient (const double distortion) 
    {
        m_W311 = distortion;
        setDirty();
    }

    //getDistortionCoefficient
    double getDistortionCoefficient() const
    {
        return m_W311;
    }

    //setFPASubDivisions
    void setFPASubDivisions(int subdivisions);

    //getFPAKernelSubDivisions
    int getFPASubDivisions() const
    {
        return m_maxKernelSize;
    }

    //setUserDefinedKernelEnable
    void setUserDefinedKernelEnable(bool enable);

    //getUserDefinedKernelEnable
    bool getUserDefinedKernelEnable() const
    {
        return m_enableUserDefinedKernel;
    }

    //setUserDefinedKernelRootFilename
    //
   void setUserDefinedKernelRootFilename(char* filename);

    //getUserDefinedKernelRootFilename
   char * getUserDefinedKernelRootFilename();


    //setAperturePercentage
    void setAperturePercentage(const double aperSizeX, const double aperSizeY) 
    {
      // If optics param changes are not performed solely when the new & current values differ, 
      // this produces a situation in which the noise texture is not updated on a per-pixel basis,
      // so the whole image goes light & dark with time, not individual pixels.
      if ((m_horzAperturePercentage != aperSizeX) || (m_vertAperturePercentage != aperSizeY))
      {
         m_horzAperturePercentage = aperSizeX;
         m_vertAperturePercentage = aperSizeY;
         setDirty();
      }
    }

    //getAperturePercentage
    void getAperturePercentage(double *aperSizeX, double *aperSizeY) const
    {
        *aperSizeX = m_horzAperturePercentage;
        *aperSizeY = m_vertAperturePercentage;
    }

    //setHaloThresholdAdjustment
    void setHaloThresholdAdjustment(double threshold) {
        m_haloThresholdAdjustment = threshold;
    }

    //getHaloThresholdAdjustment
    double getHaloThresholdAdjustment(){return m_haloThresholdAdjustment;}

    //setMeanWavelength 
    void setMeanWavelength (const double wavelength) 
    {
      // If optics param changes are not performed solely when the new & current values differ, 
      // this produces a situation in which the noise texture is not updated on a per-pixel basis,
      // so the whole image goes light & dark with time, not individual pixels.
      if (m_lamdaMean != wavelength)
      {
         m_lamdaMean = wavelength;
         setDirty();
      }
    }

    //getMeanWavelength 
    double getMeanWavelength() const
    {
        return m_lamdaMean;
    }

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

    //setUserDefinedMTFenable
   void setUserDefinedMTFenable(bool enable) { m_userDefinedMTFenable = enable; }

    //getUserDefinedMTFenable
   bool getUserDefinedMTFenable() { return m_userDefinedMTFenable; }

    //setUserDefinedMTFfilename
    //
   void setUserDefinedMTFfilename(char* filename);

    //getUserDefinedMTFfilename
   char * getUserDefinedMTFfilename() { return m_userDefinedMTFfilename; }

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

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

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

    bool getUserDefinedKernelDataLoaded() const
    {
        return m_userDefinedKernelsLoaded;
    }

private:

    friend class seFilter;
    void setUserDefinedKernelDataLoaded(bool kernelsLoaded)
    {
        m_userDefinedKernelsLoaded = kernelsLoaded;
    }

    double m_apertureWidth;
    double m_focalLength;
    double m_FNumber;
    double m_lamdaMean;
    shapeType m_apertureShape;
    double m_apertureAspectRatio;
    double m_blurSpotDiameter;
    double m_horizontalFov;
    double m_verticalFov;
    double m_mtfMotionBlurSize;
   double m_lensTransmittance;
    bool m_filterEnable;         
    bool m_optimizedFilterEnable;   
    double m_filterAdjustment;      
    // Halo parameters
    bool m_haloEnable;
    double m_haloThreshold;
    double m_haloRadius;
    double m_haloIntensity;
    HaloType m_haloType;
    double m_haloThresholdAdjustment;
    double m_DASHorz;
    double m_DASVert;
    double m_ImageClipRadius;
   double m_ImageClipScaleHorz;
   double m_ImageClipScaleVert;

    bool m_userDefinedMTFenable;
   char m_userDefinedMTFfilename[512];
   char m_userDefinedRootKernelfilename[512];

    bool   m_aberrationsEnable;         // Aberration Enable flag
    double m_W020;                      // Defocus aberration
    double m_W040;                      // Spherical aberration
    double m_W131;                      // Coma aberration
    double m_W222;                      // Astigmatism aberration
    double m_W220;                      // Field Curvature aberration
    double m_W311;                      // Distortion aberration
    int    m_maxKernelSize;             // Max FPA subdivision for kernels
    bool   m_enableUserDefinedKernel;   // Enable FPA dependent kernel processing
    bool   m_enableSeparableKernel;     // Enable use of separable kernels
    double m_horzAperturePercentage;    // pupil plane relative size
    double m_vertAperturePercentage;    // pupil plane relative size

    bool m_userDefinedKernelsLoaded;
    bool m_dirty;             
};


#endif // _seOptics_