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

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

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

    //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_mtfMotionBlur;     
    double  m_haloThreshold;
    double  m_haloRadius;
    double  m_haloIntensity;
    double  m_percentHaloIntensity;
    bool m_userDefinedMTFenable;
   char m_userDefinedMTFfilename[512];

    int     m_sensorIndex;
    clXMLNode* m_parentNode;

private: // variables

};

#endif // _ciOPTICS_H_