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


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


    //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) {
        m_haloRadius = value;
    }

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


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

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

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

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

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

private:

    double m_apertureWidth;
    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;
    double m_haloThresholdAdjustment;

    bool m_userDefinedMTFenable;
   char m_userDefinedMTFfilename[512];


    bool m_dirty;             
};


#endif // _seOptics_