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


    //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
   bool getColorMapEnable() { return m_colorMapEnable; }

    //setColorMapEnable
   void setColorMapEnable(bool enable) { m_colorMapEnable = enable; }
   
    //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_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
   bool  m_colorMapEnable;   //Is color mapping turned enabled
    clXMLNode* m_parentNode;

private: // variables

};

#endif // _ciELECTRONICS_H_