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

    // getJitterAmplitudeH
    double getJitterAmplitudeH() const { return m_jitterAmpH; }

    // setJitterAmplitudeH
    void setJitterAmplitudeH( double jitterAmpH ) { m_jitterAmpH = jitterAmpH; }

    // getJitterAmplitudeV
    double getJitterAmplitudeV() const { return m_jitterAmpV; }

    // setJitterAmplitudeV
    void setJitterAmplitudeV( double jitterAmpV ) { m_jitterAmpV = jitterAmpV; }

    // getJitterFrequencyH
    double getJitterFrequencyH() const { return m_jitterFreqH; }

    // setJitterFrequencyH
    void setJitterFrequencyH( double jitterFreqH ) { m_jitterFreqH = jitterFreqH; }

    // getJitterFrequencyV
    double getJitterFrequencyV() const { return m_jitterFreqV; }

    // setJitterFrequencyV
    void setJitterFrequencyV( double jitterFreqV ) { m_jitterFreqV = jitterFreqV; }

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

    //setNonUniformityEnable
   void setNonUniformityEnable(bool enable) { m_nonUniformityEnable = enable; }

    //getNonUniformityEnable
   bool getNonUniformityEnable() { return m_nonUniformityEnable; }

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

    //setChargeWellCapacity
    void setChargeWellCapacity(double threshold) 
    {
        m_chargeWellCapacity = threshold;
    }
    
    //getChargeWellCapacity
    double getChargeWellCapacity() const 
    {
        return m_chargeWellCapacity;
    }

    //setQuantumEfficiency
    void setQuantumEfficiency(double efficiency) 
    {
        m_quantumEfficiency = efficiency;
    }

    //getQuantumEfficiency
    double getQuantumEfficiency() const 
    {
        return m_quantumEfficiency;
    }

    //setAntiBloomingType
    void setAntiBloomingType(int antibloomDirection) 
    {
        m_antiBloomDirection = antibloomDirection;
    }

    //getAntiBloomingType
    int getAntiBloomingType() const 
    {
        return m_antiBloomDirection;
    }

    //setMaterialWavelengthCutOnCutOff
    void setMaterialWavelengthCutOnCutOff(double cuton, double cutoff) 
    {
        m_wavelengthCutOn = cuton;
        m_wavelengthCutOff = cutoff;
    }

    //getMaterialWavelengthCutOnCutOff
    void getMaterialWavelengthCutOnCutOff(double &cuton, double &cutoff) const 
    {
        cuton = m_wavelengthCutOn;
        cutoff = m_wavelengthCutOff;
    }

    //setMicroChannelPlateDistance
    void setMicroChannelPlateDistance(double distance) 
    {
        m_microChannelPlateDistance = distance;
    }

    //getMicroChannelPlateDistance
    double getMicroChannelPlateDistance() const 
    {
        return m_microChannelPlateDistance;
    }

    //setPhotoCathodeVoltage
    void setPhotoCathodeVoltage(double voltage) 
    {
        m_photoCathodeVoltage = voltage;
    }

    //getPhotoCathodeVoltage
    double getPhotoCathodeVoltage() const 
    {
        return m_photoCathodeVoltage;
    }

    //getWellCapacityPercentage
    double getWellCapacityPercentage() const 
    {
        return m_wellCapacityPercentage;
    }

    //setWellCapacityPercentage
    void setWellCapacityPercentage(double percentage)
    {
        m_wellCapacityPercentage = (float)percentage;
    }

    //getReadoutNoiseNumElectron
    double getReadoutNoiseNumElectron() const 
    {
        return m_electronReadoutNoise;
    }

    //setReadoutNoiseNumElectron
    void setReadoutNoiseNumElectron(double electrons) 
    {
        m_electronReadoutNoise = (float)electrons;
    }

    //get3DNoiseEnable
    bool get3DNoiseEnable() const 
    {
        return m_enable3DNoise;
    }

    //set3DNoiseEnable
    void set3DNoiseEnable(bool enable)
    {
        m_enable3DNoise = enable;
    }

    //get3DNoiseSigmaH
    float get3DNoiseSigmaH() const 
    {
        return m_3DNoiseSigmaH;
    }

    //set3DNoiseSigmaH
    void set3DNoiseSigmaH(float STD) 
    {
        m_3DNoiseSigmaH = STD;
    }

    //get3DNoiseSigmaV
    float get3DNoiseSigmaV() const 
    {
        return m_3DNoiseSigmaV;
    }

    //set3DNoiseSigmaV
    void set3DNoiseSigmaV(float STD) 
    {
        m_3DNoiseSigmaV = STD;
    }

    //get3DNoiseSigmaVH
    float get3DNoiseSigmaVH() const 
    {
        return m_3DNoiseSigmaVH;
    }

    //set3DNoiseSigmaVH
    void set3DNoiseSigmaVH(float STD) 
    {
        m_3DNoiseSigmaVH = STD;
    }

    //get3DNoiseSigmaT
    float get3DNoiseSigmaT() const 
    {
        return m_3DNoiseSigmaT;
    }

    //set3DNoiseSigmaT
    void set3DNoiseSigmaT(float STD) 
    {
        m_3DNoiseSigmaT = STD;
    }

    //get3DNoiseSigmaTH
    float get3DNoiseSigmaTH() const 
    {
        return m_3DNoiseSigmaTH;
    }

    //set3DNoiseSigmaTH
    void set3DNoiseSigmaTH(float STD) 
    {
        m_3DNoiseSigmaTH = STD;
    }

    //get3DNoiseSigmaTV
    float get3DNoiseSigmaTV() const 
    {
        return m_3DNoiseSigmaTV;
    }

    //set3DNoiseSigmaTV
    void set3DNoiseSigmaTV(float STD) 
    {
        m_3DNoiseSigmaTV = STD;
    }

    //get3DNoiseSigmaTVH
    float get3DNoiseSigmaTVH() const 
    {
        return m_3DNoiseSigmaTVH;
    }

    //set3DNoiseSigmaTVH
    void set3DNoiseSigmaTVH(float STD) 
    {
        m_3DNoiseSigmaTVH = STD;
    }

    // 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_jitterAmpH;           
    double  m_jitterAmpV;           
    double  m_jitterFreqH;          
    double  m_jitterFreqV;          
    double  m_backTemp;          
    double  m_NER;               
    double  m_percentPixelFill;     
    double  m_percentDeadPixel;     
    double  m_resolutionScale;
    double  m_percentPoisson;
    double  m_percentFInverse;

   bool m_nonUniformityEnable;    // set as non uniformity sensor and cause scanning streaks or pixel variations 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;

    double m_chargeWellCapacity;            
    double m_quantumEfficiency;             
    int    m_antiBloomDirection;            
    double m_wavelengthCutOn;               
    double m_wavelengthCutOff;              
    double m_microChannelPlateDistance;     
    double m_photoCathodeVoltage;           

    float   m_electronReadoutNoise;
    float   m_wellCapacityPercentage;

    bool m_enable3DNoise;                   
    float m_3DNoiseSigmaH;                  
    float m_3DNoiseSigmaV;                  
    float m_3DNoiseSigmaVH;                 
    float m_3DNoiseSigmaT;                  
    float m_3DNoiseSigmaTH;                 
    float m_3DNoiseSigmaTV;                 
    float m_3DNoiseSigmaTVH;                

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

   int m_sensorIndex;
   


    clXMLNode* m_parentNode;

private: // variables

};

#endif // _ciDETECTOR_H_