ciDetector.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(_ciDETECTOR_H_)
#define _ciDETECTOR_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 ciDetector  
{
public:     // methods

    // getDwellTime
    double getDwellTime() { return m_dwellTime; }

    // setDwellTime
    void setDwellTime( double dwellTime ){ m_dwellTime = dwellTime; }

    // getNET
    double getNET() { return m_NET; }

    // setNET
    void setNET( double NET ) { m_NET = NET; }

    // getFixedPatternNoisePercentNEDT
    double getFixedPatternNoisePercent( ) { return m_FixedNoisePercent;  }

    // setFixedPatternNoisePercentNEDT
    void setFixedPatternNoisePercent( double percentNoise ) {
        m_FixedNoisePercent = percentNoise;
    }

    // getNER
    double getNER()  { return m_NER; }
    // setNER
    void setNER(double NER)  { m_NER = NER; }

    // getNoiseFreqKnee
    double getNoiseFreqKnee( ) { return m_noiseFreqKnee; }

    // setNoiseFreqKnee
    void setNoiseFreqKnee( double noiseFreqKnee ) { m_noiseFreqKnee = noiseFreqKnee;  }

    // getNoiseFreqExp
    double getNoiseFreqExp( ) { return m_noiseFreqExp; }

    // setNoiseFreqExp
    void setNoiseFreqExp( double noiseFreqExp ) { m_noiseFreqExp = noiseFreqExp;  }

    // getResolutionScale
    double getResolutionScale() { return m_resolutionScale; }

    // setNumDetStaresV
    void setResolutionScale( double resolutionScale ) { 
        if (resolutionScale == 0) 
            resolutionScale = .000001; 
        m_resolutionScale = resolutionScale; }

    // getPitchDetH
    double getPitchDetH() { return m_pitchDetH; }

    // setPitchDetH
    void setPitchDetH( double pitchDetH ) { m_pitchDetH = pitchDetH; }

    // getPitchDetV
    double getPitchDetV() { return m_pitchDetV; }

    // setSizeDetV
    void setPitchDetV( double pitchDetV ) { m_pitchDetV = pitchDetV; }

    // getBackTemp
    double getBackTemp() { return m_backTemp; }


    // setBackTemp
    void setBackTemp( double backTemp ) { m_backTemp = backTemp; }


    // getPercentPixelFill
    double getPercentPixelFill() { return m_percentPixelFill; }


    // setPercentPixelFill
    void setPercentPixelFill( double pixelFill ) { m_percentPixelFill = pixelFill; }

    // getPercentDeadPixel
    double getPercentDeadPixel() { return m_percentDeadPixel; }


    // setPercentDeadPixel
    void setPercentDeadPixel( double deadPixel ) { m_percentDeadPixel = deadPixel; }

    //getNumDetStaresH
    long getNumDetStaresH() { return m_numDetStaresV; }

    //setNumDetStaresH
    void setNumDetStaresH( long numDetStaresH ) { m_numDetStaresH = numDetStaresH; }

    // getNumDetStaresV
    long getNumDetStaresV() { return m_numDetStaresV; }

    // setNumDetStaresV
    void setNumDetStaresV( long numDetStaresV ) { m_numDetStaresV = numDetStaresV; }

    // getStartWavelength
    double getStartWavelength() { return m_startWavelength; }

    // setStartWavelength
    void setStartWavelength( double startWavelength ) { m_startWavelength = startWavelength; }
    // getEndWavelength
    double getEndWavelength() { return m_endWavelength; }

    // setEndWavelength
    void setEndWavelength( double endWavelength ) { m_endWavelength = endWavelength; }

    //setPoissonNoisePercent
    void setPoissonNoisePercent(double percent){m_percentPoisson = percent;}

    //getPoissonNoisePercent
    double getPoissonNoisePercent(){return m_percentPoisson;}

    //setFInverseNoisePercent
    void setFInverseNoisePercent(double percent){m_percentFInverse = percent;}

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

    //setScanMaskMinGain
   void setScanMaskMinGain(float minGain) { m_scanMaskMinGain = minGain; }

    //getScanMaskMinGain
   float getScanMaskMinGain() { return m_scanMaskMinGain; }

    //setScanMaskMaxGain
   void setScanMaskMaxGain(float maxGain) { m_scanMaskMaxGain = maxGain; }

    //getScanMaskMaxGain
   float getScanMaskMaxGain() { return m_scanMaskMaxGain; }

    //setScanMaskMinLevel
   void setScanMaskMinLevel(float minLevel) { m_scanMaskMinLevel = minLevel; }

    //getScanMaskMinLevel
   float getScanMaskMinLevel() { return m_scanMaskMinLevel; }

    //setScanMaskMaxLevel
   void setScanMaskMaxLevel(float maxLevel) { m_scanMaskMaxLevel = maxLevel; }

    //getScanMaskMaxLevel
   float getScanMaskMaxLevel() { return m_scanMaskMaxLevel; }

    //setScanMaskLineSpacing
   void setScanMaskLineSpacing(int lineSpacing) { m_scanMaskLineSpacing = lineSpacing; }

    //getScanMaskLineSpacing
   int getScanMaskLineSpacing() { return m_scanMaskLineSpacing; }

    //setScanMaskEnable
   void setScanMaskEnable(bool enable) { m_scanMaskEnable = enable; }

    //getScanMaskEnable
   bool getScanMaskEnable() { return m_scanMaskEnable; }

    //setScanMaskGainFilename
   void setScanMaskGainFilename(char* gainFilename);

    //getScanMaskGainFilename
   char * getScanMaskGainFilename() { return m_scanMaskGainFilename; }

    //setScanMaskevelFilename
   void setScanMaskLevelFilename(char* levelFilename);

    //getScanMaskLevelFilename
   char * getScanMaskLevelFilename() { return m_scanMaskLevelFilename; }

    //setScanMaskDirection
   void setScanMaskDirection(int direction) { m_scanMaskDirection = direction; }

    //getScanMaskDirection
   int getScanMaskDirection() { return m_scanMaskDirection; }

    //setScanMaskUserDefined
   void setScanMaskUserDefined(bool userDefined) { m_scanMaskUserDefined = userDefined; }

    //getScanMaskUserDefined
   bool getScanMaskUserDefined() { return m_scanMaskUserDefined; }

    //setFullColorEnable
   void setFullColorEnable(bool enable) { m_fullColorEnable = enable; }

    //getFullColorEnable
   bool getFullColorEnable() { return m_fullColorEnable; }

    // 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 =
    ciDetector operator = (ciDetector &obj);

protected:  // methods

public:     // construction/destruction

    // ciDetector
    ciDetector();

    // ciDetector
    ciDetector(ciDetector &obj);

    virtual ~ciDetector();

protected:  // variables

    double  m_startWavelength;      
    double  m_endWavelength;        
    double  m_dwellTime;         
    double  m_NET;               
    double  m_FixedNoisePercent; 
    double  m_noiseFreqExp;         
    double  m_noiseFreqKnee;        
    long m_numDetStaresH;        
    long m_numDetStaresV;        
    double  m_pitchDetH;         
    double  m_pitchDetV;          
    double  m_backTemp;          
    double  m_NER;               
    double  m_percentPixelFill;     
    double  m_percentDeadPixel;     
    double  m_resolutionScale;
    double  m_percentPoisson;
    double  m_percentFInverse;

   bool m_scanMaskEnable;    // set as scanning sensor and cause scanning streaks in image.
   char m_scanMaskGainFilename[512]; // A single channel *.bmp for per channel gain
   char m_scanMaskLevelFilename[512]; // A single channel *.bmp for per channel level 
   int m_scanMaskDirection;
   float m_scanMaskMinGain;
   float m_scanMaskMaxGain;
   float m_scanMaskMinLevel;
   float m_scanMaskMaxLevel;
   int   m_scanMaskLineSpacing;
   bool m_scanMaskUserDefined;

    bool m_fullColorEnable;  // set for full color sensor with sensor effects.

   int m_sensorIndex;
   


    clXMLNode* m_parentNode;

private: // variables

};

#endif // _ciDETECTOR_H_