ciSenSim.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:  Tim George
// Date:       Oct 2005
//
//
//

#if !defined(_CISENSIM_H_)
#define _CISENSIM_H_

#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000
#include "ciApi.h"

#include "clXML.h"

#include <stdio.h>
#include <iostream>
#include <fstream>

#include <iostream>
#include <fstream>
#include <string.h>
#include "clXMLNode.h"

class CI_API ciSenSim 
{
public:     // methods

    //getEnableSenSim
    bool getEnableSenSim(){return m_enableSenSim;}
    //setEnableSenSim
    void setEnableSenSim(bool flag){m_enableSenSim = flag;}

    //getEnableGPUSenSim
    bool getEnableGPUSenSim(){return m_enableGPUSenSim;}
    //setEnableGPUSenSim
    void setEnableGPUSenSim(bool flag){m_enableGPUSenSim = flag;}

    //getEnableNoise
    bool getEnableNoise(){return m_enableNoise;}
    //setEnableNoise
    void setEnableNoise(bool flag){m_enableNoise = flag;}

    //getEnableFilter
    bool getEnableFilter(){return m_enableFilter;}
    //setEnableFilter
    void setEnableFilter(bool flag){m_enableFilter = flag;}

    //getEnableGainLevel
    bool getEnableGainLevel(){return m_enableGainLevel;}
    //setEnableGainLevel
    void setEnableGainLevel(bool flag){m_enableGainLevel = flag;}

    //getEnableHalos
    bool getEnableHalos(){return m_enableHalos;}
    //setEnableHalos
    void setEnableHalos(bool flag){m_enableHalos = flag;}

    //getEnableMotionBlur
    bool getEnableMotionBlur(){return m_enableMotionBlur;}
    //setEnableMotionBlur
    void setEnableMotionBlur(bool flag){m_enableMotionBlur = flag;}


    //getEnableACCoupling
    bool getEnableACCoupling(){return m_enableACCoupling;}
    //setEnableACCoupling
    void setEnableACCoupling(bool flag){m_enableACCoupling = flag;}

    //getEnableBlackHot
    bool getEnableBlackHot(){return m_enableBlackHot;}

    //setEnableBlackHot
    void setEnableBlackHot(bool flag){m_enableBlackHot = flag;}

    //getEnableAGC
    bool getEnableAGC(){return m_enableAGC;}
    //setEnableAGC
    void setEnableAGC(bool flag){m_enableAGC = flag;}

    //getPercentBlur
    double  getPercentBlur(){return m_percentBlur;}
    //setPercentBlur
    void setPercentBlur(double flag){m_percentBlur = flag;}

    //getPercentNoise
    double  getPercentNoise(){return m_percentNoise;}
    //setPercentNoise
    void setPercentNoise(double flag){m_percentNoise = flag;}

    //getPercentGain
    double  getPercentGain(){return m_percentGain;}
    //setPercentGain
    void setPercentGain(double flag){m_percentGain = flag;}

    //getPercentLevel
    double  getPercentLevel(){return m_percentLevel;}
    //setPercentLevel
    void setPercentLevel(double flag){m_percentLevel = flag;}

    //getPercentHaloThreshold
    double  getPercentHaloThreshold(){return m_percentHaloThreshold;}
    //setPercentHaloThreshold
    void setPercentHaloThreshold(double flag){m_percentHaloThreshold = flag;}
    //setSensorIndex
    void setSensorIndex(int sensorIndex){m_sensorIndex = sensorIndex;}
    //getSensorIndex
    int getSensorIndex(){return m_sensorIndex;}

    //getEnableAeroDynamicHeating
    bool getEnableAeroDynamicHeating()
    {
        return m_enableAeroDynamicHeating;
    }
    //setEnableAeroDynamicHeating
    void setEnableAeroDynamicHeating(bool flag)
    {
        m_enableAeroDynamicHeating = flag;
    }

    //getAeroDynamicHeatingGimbalMode
    int  getAeroDynamicHeatingGimbalMode()
    {
        return m_aeroDynamicHeatingGimbalMode;
    }
    //setAeroDynamicHeatingGimbalMode
    void setAeroDynamicHeatingGimbalMode(int flag)
    {
        m_aeroDynamicHeatingGimbalMode = flag;
    }

   //getAeroDynamicHeatingWindowCurvature
   float getAeroDynamicHeatingWindowCurvature()
   {
      return m_aeroDynamicHeatingWindowCurvature;
   }
   //setAeroDynamicHeatingWindowCurvature
   void  setAeroDynamicHeatingWindowCurvature(float curvature)
   {
      m_aeroDynamicHeatingWindowCurvature = curvature;
   }

   //getAeroDynamicHeatingAzimuthOffset
   float getAeroDynamicHeatingAzimuthOffset()
   {
      return m_aeroDynamicHeatingAzimuthOffset;
   }
   //setAeroDynamicHeatingAzimuthOffset
   void  setAeroDynamicHeatingAzimuthOffset(float azimuth)
   {
      m_aeroDynamicHeatingAzimuthOffset = azimuth;
   }

   //getAeroDynamicHeatingElevationOffset
   float getAeroDynamicHeatingElevationOffset()
   {
      return m_aeroDynamicHeatingElevationOffset;
   }
   //setAeroDynamicHeatingElevationOffset
   void  setAeroDynamicHeatingElevationOffset(float elevation)
   {
      m_aeroDynamicHeatingElevationOffset = elevation;
   }

    //getSamplingSpatialFrequencyX
    double  getSamplingSpatialFrequencyX()
    {
        return m_samplingSpatialFrequencyX;
    }
    //setSamplingSpatialFrequencyX
    void setSamplingSpatialFrequencyX(double frequency)
    {
        m_samplingSpatialFrequencyX = frequency;
    }

    //getSamplingSpatialFrequencyX
    double  getSamplingSpatialFrequencyY()
    {
        return m_samplingSpatialFrequencyY;
    }
    //setSamplingSpatialFrequencyX
    void setSamplingSpatialFrequencyY(double frequency)
    {
        m_samplingSpatialFrequencyY = frequency;
    }

   //getFilterMode
   int   getFilterMode() const
   {
      return m_filterMode;
   }

   //setFilterMode
   void  setFilterMode(int mode)
   {
      m_filterMode = mode;
   }

   //getRenderMode
   int   getRenderMode() const
   {
      return m_renderMode;
   }

   //setRenderMode
   void  setRenderMode(int mode)
   {
      m_renderMode = mode;
   }

   //setNumberSubloadRows
   void setNumberSubloadRows(int numberOfRows)
   {
      m_numberOfRowsToSubload = numberOfRows;
   }

   //getNumberSubloadRows
   int getNumberSubloadRows() const
   {
      return m_numberOfRowsToSubload;
   }

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

    // serialize
    bool serialize(char *filepath, int idx = 0);

    //
    // 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 specific 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 *nodeBool);
    //loadXMLNode
    bool loadXMLNode(std::string tag, double *nodeBool);

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

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

protected:  // methods

public:     // construction/destruction

    //ciSenSim
    ciSenSim();

    //ciSenSim
    ciSenSim(ciSenSim &obj);

    //~ciSenSim
    virtual ~ciSenSim();

protected:  // variables

    bool m_enableSenSim;
    bool m_enableGPUSenSim;
    bool m_enableFilter;
    bool m_enableNoise;
    bool m_enableGainLevel;
    bool m_enableHalos;
    bool m_enableMotionBlur;
    double  m_percentBlur;
    double  m_percentNoise;
    double  m_percentGain;
    double  m_percentLevel;
    double  m_percentHaloThreshold;
    double  m_samplingSpatialFrequencyX;
    double  m_samplingSpatialFrequencyY;
    bool m_enableACCoupling;
    bool m_enableBlackHot;
    bool m_enableAGC;
    bool m_enableAeroDynamicHeating;
    int     m_aeroDynamicHeatingGimbalMode;
   float m_aeroDynamicHeatingWindowCurvature;
   float m_aeroDynamicHeatingAzimuthOffset;
   float m_aeroDynamicHeatingElevationOffset;
   int      m_filterMode;
   int      m_numberOfRowsToSubload;
    int     m_sensorIndex;
   int      m_renderMode;
    clXMLNode* m_parentNode;
private: // variables

};

#endif 
// _ciSCENARIO_H_