ciElectronics.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:       Nov 2004
//
//
//

#if !defined(_ciELECTRONICS_H_)
#define _ciELECTRONICS_H_

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

#include "ciApi.h"
#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 ciElectronics  
{

public:     // methods


    // getFrameRate
    double getFrameRate() { return m_frameRate; }


    // setFrameRate
    void setFrameRate( double frameRate ) { m_frameRate = frameRate; }


    // getPreCutonFreq
    double getPreCutonFreq() { return m_preCutonFreq; }

    // setPreCutonFreq
    void setPreCutonFreq( double preCutonFreq ){ m_preCutonFreq = preCutonFreq; }
    // getPostCutoffFreq
    double getPostCutoffFreq() { return m_postCutoffFreq; }

    // setPostCutoffFreq
    void setPostCutoffFreq( double postCutoffFreq ){ m_postCutoffFreq = postCutoffFreq; }

    // getGain
    double getGain() { return m_gain; }

    // setGain
    void setGain( double gain ) { m_gain = gain; }

    //setAGCMaxGain
    void setAGCMaxGain(const double gain) {
        m_AGCMaxGain = gain;
    }

    //getAGCMaxGain
    double getAGCMaxGain(){return m_AGCMaxGain;}

    //setAGCMinGain
    void setAGCMinGain(const double gain) {
        m_AGCMinGain = gain;
    }

    //getAGCMinGain
    double getAGCMinGain(){return m_AGCMinGain;}

    //setAGCGainThreshold
    void setAGCGainThreshold(const double threshold) 
    {
        m_AGCGainThreshold = threshold;
    }

    //getAGCGainThreshold
    double getAGCGainThreshold()
    {
        return m_AGCGainThreshold;
    }

    //setAGCMode
    void setAGCMode(const int mode) {
      if(mode<0) m_AGCMode=0;
      else if(mode>3) m_AGCMode=3;
        else m_AGCMode = mode;
    }

    //getAGCMode
    int getAGCMode(){return m_AGCMode;}

    //setPercentGain
    void setPercentGain(double percent){m_percentGain = percent;}

    //getPercentGain
    double getPercentGain(){return m_percentGain;}

    //setPercentLevel
    void setPercentLevel(double percent){m_percentLevel = percent;}

    //getPercentLevel
    double getPercentLevel(){return m_percentLevel;}


    // getLevel
    double getLevel() { return m_level; }

    // setLevel
    void setLevel( double level ){ m_level = level; }
 
    //getColorMapType
   int   getColorMapType() { return m_colorMapType; }

    //setColorMapType
   void setColorMapType(int type) { m_colorMapType = type; }

    //getColorMapUserDefinedRadFile
   char* getColorMapUserDefinedRadFile() {   return m_colorMapUserDefinedRadFile; }

    //setColorMapUserDefinedRadFile
   void setColorMapUserDefinedRadFile(const char* filepath);

    //getColorMapEnable
   int getColorMapEnable() { return m_colorMapEnable; }

    //setColorMapEnable
   void setColorMapEnable(int enable) { m_colorMapEnable = enable; }

    //setBitDepthOutput
    void setBitDepthOutput( bool enable, float bitDepth )
    {
        m_bitDepthOutput = bitDepth;
        m_enableBitDepthOutput = enable;
    }

    //getBitDepthOutput
    void getBitDepthOutput(bool &enable, float &bitDepth) const
    {
        bitDepth = m_bitDepthOutput;
        enable = m_enableBitDepthOutput;
    }
   
    //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 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 *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 =
    ciElectronics operator = (ciElectronics &obj);

protected:  // methods

public:     // construction/destruction

    // ciElectronics
    ciElectronics();

    // ciElectronics
    ciElectronics(ciElectronics &obj);

    //~ciElectronics
    virtual ~ciElectronics();

protected:  // variables

    double  m_frameRate;      // frame rate [hz]
    double  m_preCutonFreq;      // pre-cuton frequency [hz]
    double  m_postCutoffFreq; // post-cutoff frequency [hz]
    double  m_gain;           // gain
    double  m_level;       // level
    double m_AGCMaxGain;      // maximum gain used by AGC
    double m_AGCMinGain;      // minimum level used by AGC
    double m_AGCGainThreshold;  // gain threshold used by AGC
   int      m_AGCMode;        // 0 = Max, 1 = Clipped, 2 = Histogram Equalization, 3 = Histogram Projection
    double  m_percentGain;
    double  m_percentLevel;
    int     m_sensorIndex;
   int      m_colorMapType;      //color map type. in seElectronics it is an enum
   char  m_colorMapUserDefinedRadFile[512]; //*.rad file
   int   m_colorMapEnable;   //Is color mapping turned enabled

    // Control for bit depth output to buffers and rendered image
    float   m_bitDepthOutput;
    bool    m_enableBitDepthOutput;

    clXMLNode* m_parentNode;

private: // variables

};

#endif // _ciELECTRONICS_H_