ciOptics.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:  Mike Ortalano
// Date:       Oct 2004
//
//
//

#if !defined(_ciOPTICS_H_)
#define _ciOPTICS_H_
#include "ciApi.h"

#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000

#ifndef JRM_PI
#define JRM_PI                3.14159265358979323846264338327950288419716939937511
#endif
#ifndef DEG2RAD
#define DEG2RAD            (JRM_PI/180.0)
#endif

#include <stdio.h>
#include <string.h>
#include <fstream>
#include <iostream>
#include <assert.h>
#include <string.h>
#include "clXML.h"
#include "clXMLNode.h"

class CI_API ciOptics  
{
public:     // enumerations

    // enum aperture Shape Type
    enum enumApertureShapeType
    {
        ELLIPTICAL,  
        RECTANGULAR  
    };

public:     // methods

    // getAspectRatio
    double getAspectRatio() { return m_aspectRatio; }

    // setAspectRatio
    void setAspectRatio( double aspectRatio ) { m_aspectRatio = aspectRatio; }

    // getWidthDimension
    double getWidthDimension() { return m_widthDimension; }

    // setWidthDimension
    void setWidthDimension( double widthDimension ){ m_widthDimension = widthDimension; }

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

    // setApertureShape
    void setApertureShape( int apertureShape ) { m_apertureShape = apertureShape; }

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

    // setBlurSpotDiameter
    void setBlurSpotDiameter( double blurSpotDiameter ) { m_blurSpotDiameter = blurSpotDiameter;  }

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

    // setMtfMotionBlurSize
    void setMtfMotionBlurSize( double mtfMotionBlur ) { m_mtfMotionBlur = mtfMotionBlur;  }

    // getHorizFOV
    double getHorizFOV() { return m_horizFOV; }

    // setHorizFOV
    void setHorizFOV( double horizFOV ) { m_horizFOV = horizFOV; }

    // getVertFOV
    double getVertFOV() { return m_vertFOV; }

    // setLensTransmittance
    void setLensTransmittance( double trans ) { m_lensTransmittance = trans; }

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

    // setVertFOV
    void setVertFOV( double vertFOV ) { m_vertFOV = vertFOV; }

    //setHaloThreshold
    void setHaloThreshold(double threshold ){m_haloThreshold = threshold;}
    //getHaloThreshold
    double getHaloThreshold(){return m_haloThreshold;}
    //setHaloRadius
    void setHaloRadius(double radius){m_haloRadius = radius;}
    //getHaloRadius
    double getHaloRadius(){return m_haloRadius;}
    //setHaloIntensity
    void setHaloIntensity(double intensity){m_haloIntensity = intensity;}
    //getHaloIntensity
    double getHaloIntensity(){return m_haloIntensity;}
    //setPercentHaloIntensity
    void setPercentHaloIntensity(double percent){m_percentHaloIntensity = percent;}
    //getPercentHaloIntensity
    double getPercentHaloIntensity(){return m_percentHaloIntensity;}

    //setUseSeparableKernelEnable
    void setUseSeparableKernelEnable(bool enable)
    {
        m_enableSeparableKernel = enable;
    }

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

    //setAberrationsEnable
    void setAberrationsEnable (bool enable) 
    {
        m_aberrationsEnable = enable;
    }

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

    //setMeanWavelength
    void setMeanWavelength(const double wavelength) 
    {
        m_wavelength = wavelength;
    }

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

    //setAperturePercentageHorz
    void setAperturePercentageHorz(const double aperSizeX) 
    {
        m_horzAperturePercentage = aperSizeX;
    }

    //getAperturePercentageHorz
    double getAperturePercentageHorz() const
    {
        return m_horzAperturePercentage;
    }

    //setAperturePercentageVert
    void setAperturePercentageVert(const double aperSizeY) 
    {
        m_vertAperturePercentage = aperSizeY;
    }

    //getAperturePercentageVert
    double getAperturePercentageVert() const
    {
        return m_vertAperturePercentage;
    }

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

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

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

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

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

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

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

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

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

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

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

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

    //setFPASubDivisions
    void setFPASubDivisions(int subdivisions) 
    {
        m_FPASubDivisions = subdivisions;
    }

    //getFPASubDivisions
    int getFPASubDivisions() const 
    {
        return m_FPASubDivisions;
    }

    //setUserDefinedKernelEnable
    void setUserDefinedKernelEnable(bool enable)
    {
        m_enableUserDefinedKernel = enable;
    }

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

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

    //getUserDefinedKernelRootFilename
   char * getUserDefinedKernelRootFilename() { return m_userDefinedRootKernelfilename; }

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

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

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

    //setImageMaskRadius 
    void setImageMaskRadius (double radius) 
    {
        m_ImageClipRadius = (radius > -1.0) ? radius : -1.0; // max(radius, -1.0);
    }

    //getImageMaskRadius
    double getImageMaskRadius() const
    {
        return m_ImageClipRadius;
    }

   //setImageMaskScaleHorizontal 
   void setImageMaskScaleHorizontal(double scale)
   {
      m_ImageClipScaleHorz = scale;
   }

   //getImageMaskScaleHorizontal 
   double getImageMaskScaleHorizontal() const
   {
      return m_ImageClipScaleHorz;
   }

   //setImageMaskScaleVertical 
   void setImageMaskScaleVertical(double scale)
   {
      m_ImageClipScaleVert = scale;
   }

   //getImageMaskScaleVertical 
   double getImageMaskScaleVertical() const
   {
      return m_ImageClipScaleVert;
   }

    //setSensorIndex
    void setSensorIndex(int sensorIndex){m_sensorIndex = sensorIndex;}
    //getSensorIndex
    int getSensorIndex(){return m_sensorIndex;}

    // archive
    bool archive(std::ofstream &outf, int idx = 0);

    // serialize
    int serialize(char *filepath, int idx);

    //
    // loadXML
    //
    // \par Description:
    // Loads attributes from an XML node
    //
    // \param clXMLNode* xmlParentNode
    // \return bool
    //
    bool loadXML(clXMLNode* xmlParentNode);

    //
    // parseXML
    //
    // \par Description:
    // Parses an XML document for specfic tags
    //
    // \param clXML xmlDocument
    // \return bool
    //
    bool parseXML(clXML& xmlDocument);

    //loadXMLNode
    bool loadXMLNode(std::string tag, char *nodeString);
    //loadXMLNode
    bool loadXMLNode(std::string tag, bool *nodeBool);
    //loadXMLNode
    bool loadXMLNode(std::string tag, int *nodeInt);
    //loadXMLNode
    bool loadXMLNode(std::string tag, long *nodeLong);
    //loadXMLNode
    bool loadXMLNode(std::string tag, double *nodeDouble);

    //
    // saveXML
    //
    // \par Description:
    // Saves XML nodes to an XML document
    //
    // \param clXML* xmlDocument
    //
    void saveXML(clXML* xmlDocument);

    //serializeCheck
    int   serializeCheck(char *filepath);

    // operator =
    ciOptics operator = (ciOptics &obj);

protected:  // methods

public:     // construction/destruction

    // ciOptics
    ciOptics();

    // ciOptics
    ciOptics(ciOptics &obj);

    virtual ~ciOptics();

protected:  // variables

    double  m_aspectRatio;       
    double  m_widthDimension;    
    int     m_apertureShape;     
    double  m_blurSpotDiameter;     
    double  m_horizFOV;          
    double  m_vertFOV;           
    double  m_lensTransmittance; 
    double  m_mtfMotionBlur;     
    double  m_haloThreshold;
    double  m_haloRadius;
    double  m_haloIntensity;
    double  m_percentHaloIntensity;
    int     m_haloType;

    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
    double m_horzAperturePercentage;    // pupil plane relative size
    double m_vertAperturePercentage;    // pupil plane relative size
    double m_wavelength;                // Central Wavelength
    double m_ImageClipRadius;           // radius to define the clipped region of an image display
   double m_ImageClipScaleHorz;     // scales the clip regioning in the horizontal direction
   double m_ImageClipScaleVert;     // scales the clip regioning in the vertical direction
    int    m_FPASubDivisions;           // subdivisions of FPA for spatially dependent kernel processing
    bool   m_enableUserDefinedKernel;
    bool   m_enableSeparableKernel;     // support for separable kernels

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

    int     m_sensorIndex;
    clXMLNode* m_parentNode;

private: // variables

};

#endif // _ciOPTICS_H_