MeasProgram.h

Go to the documentation of this file.

/** 
* @file MeasProgram.h
* @brief Measurement programs
*
* @author LMI Technologies
*/

#ifndef _MeasProgram_h
#define _MeasProgram_h

#include "Windows.h"
#include "DataFilter.h"
#include "MeasurementDefs.h"
#include "IniFiles.h"
#include "FileFunc.h"
#include <string>
#include <vector>

using namespace std;

/** 
Maximum measurement program name
*/
#define MEAS_PROG_NAME_LENGTH 255

/** 
Abstract base struct
*/
struct TMeasurementParameter
{
   MeasurementMode m_MeasurementMode;  /**< Measurement mode */
   unsigned long m_dwVersion;       /**< Version number */

   TMeasurementParameter()
   {
      m_MeasurementMode = MeasurementMode_None;
      m_dwVersion = 0;
   };

   virtual void Assign(TMeasurementParameter* pParameter) = 0;

   virtual bool FromBuffer(PBYTE& pbyBuffer, DWORD& dwCurrBufferSize) = 0;

   virtual bool ToBuffer(PBYTE& pbyBuffer, DWORD& dwCurrBufferSize) = 0;

   virtual unsigned long GetBufferSize() = 0;

   virtual bool FromIniFile(CIniFile *pIniFile, int nIndex = -1) = 0;

   virtual bool ToIniFile(CIniFile *pIniFile, int nIndex = -1) = 0;

   virtual bool IsEqual(TMeasurementParameter *pMeasurementParameter)
   {
      return pMeasurementParameter != NULL && m_MeasurementMode == pMeasurementParameter->m_MeasurementMode;
   };
};

/**
Phase shift parameter
*/
struct TMeasurementParameterPhaseShiftItem
{
   long m_lPhaseShiftNumImg;                                   /**< Phase shift - number of images */
   long m_lPhaseShiftStripesWidth;                                /**< Phase shift - stripes width */

   TMeasurementParameterPhaseShiftItem()
   {
      m_lPhaseShiftNumImg = m_lPhaseShiftStripesWidth = 0;
   };

   bool FromBuffer(PBYTE& pbyBuffer, DWORD& dwCurrBufferSize);

   bool ToBuffer(PBYTE& pbyBuffer, DWORD& dwCurrBufferSize);

   static unsigned long GetBufferSize()
   {
      return 2 * sizeof(long);
   };

   bool FromIniFile(CIniFile *pIniFile, int nPhaseShiftIndex, int nIndex = -1);

   bool ToIniFile(CIniFile *pIniFile, int nPhaseShiftIndex, int nIndex = -1);

   TMeasurementParameterPhaseShiftItem& operator =(const TMeasurementParameterPhaseShiftItem& Item)
   {
      if (&Item == this)
         return *this;

      m_lPhaseShiftNumImg = Item.m_lPhaseShiftNumImg;
      m_lPhaseShiftStripesWidth = Item.m_lPhaseShiftStripesWidth;

      return *this;
   };

   bool operator ==(const TMeasurementParameterPhaseShiftItem& Item)
   {
      return m_lPhaseShiftNumImg == Item.m_lPhaseShiftNumImg &&  m_lPhaseShiftStripesWidth
         == Item.m_lPhaseShiftStripesWidth;
   };
};


/**
Measurement program with Gray code + phase shift
*/
struct TMeasurementParameterGrayCodePhaseShift : public TMeasurementParameter
{
   long m_lGrayCodeStart;                                /**< Gray code stripes width start */
   long m_lGrayCodeNumPlanes;                            /**< Gray code number of planes */
   vector<TMeasurementParameterPhaseShiftItem> m_PhaseShiftList;  /**< Phase shift list */

   TMeasurementParameterGrayCodePhaseShift() : TMeasurementParameter()
   {
      m_MeasurementMode = MeasurementMode_GrayCodePhaseShift;
      m_lGrayCodeStart = m_lGrayCodeNumPlanes = 0;
   };

   virtual void Assign(TMeasurementParameter* pParameter);

   virtual bool FromBuffer(PBYTE& pbyBuffer, DWORD& dwCurrBufferSize);

   virtual bool ToBuffer(PBYTE& pbyBuffer, DWORD& dwCurrBufferSize);

   virtual unsigned long GetBufferSize();

   virtual bool FromIniFile(CIniFile *pIniFile, int nIndex = -1);

   virtual bool ToIniFile(CIniFile *pIniFile, int nIndex = -1);

   virtual bool IsEqual(TMeasurementParameter *pMeasurementParameter);

private:

   TMeasurementParameterPhaseShiftItem m_PhaseShiftItem;
};

/**
Measurement program with phase shift only
*/
struct TMeasurementParameterPhaseShift : public TMeasurementParameter
{
   vector<TMeasurementParameterPhaseShiftItem> m_PhaseShiftList; /**< Phase shift list */

   TMeasurementParameterPhaseShift() : TMeasurementParameter()
   {
      m_MeasurementMode = MeasurementMode_PhaseShift;
   };

   virtual void Assign(TMeasurementParameter* pParameter);

   virtual bool FromBuffer(PBYTE& pbyBuffer, DWORD& dwCurrBufferSize);

   virtual bool ToBuffer(PBYTE& pbyBuffer, DWORD& dwCurrBufferSize);

   virtual unsigned long GetBufferSize();

   virtual bool FromIniFile(CIniFile *pIniFile, int nIndex = -1);

   virtual bool ToIniFile(CIniFile *pIniFile, int nIndex = -1);

   virtual bool IsEqual(TMeasurementParameter *pMeasurementParameter);

private:

   TMeasurementParameterPhaseShiftItem m_PhaseShiftItem;
};

/**
Measurement parameter phase code
*/
struct TMeasurementParameterPhaseCode : public TMeasurementParameter
{
   TMeasurementParameterPhaseCode()
   {
   };
};

/**
Measurement parameter set
*/
struct TMeasurementParameterSet
{
   TMeasurementParameter *m_pParameter;

   TMeasurementParameterSet()
   {
      m_pParameter = NULL;
   };
   TMeasurementParameterSet(MeasurementMode Mode)
   {
      m_pParameter = NULL;
      CreateParameter(Mode);
   };

   virtual ~TMeasurementParameterSet()
   {
      if (m_pParameter)
         delete m_pParameter;
   };

   void Assign(TMeasurementParameter* pParameter);

   bool CreateParameter(MeasurementMode Mode);

   bool FromBuffer(PBYTE& pbyBuffer, DWORD& dwCurrBufferSize);

   bool ToBuffer(PBYTE& pbyBuffer, DWORD& dwCurrBufferSize);

   unsigned long GetBufferSize();

   bool FromIniFile(CIniFile *pIniFile, int nIndex = -1);

   bool ToIniFile(CIniFile *pIniFile, int nIndex = -1);

   bool IsEqual(TMeasurementParameterSet* pSet);
};

/**
Measurement program class
*/
class CMeasProgram
{
public:

   /**
   Constructor
   */
   CMeasProgram()
   {
      m_dwThesholdPowerSpectrum = 10;
   };

   /**
   Destructor
   */
   virtual ~CMeasProgram() {};

   /**
   Sets the measurement parameter
   
   @param MeasMode      Measurement mode
   @param pParameter Pointer to measurement parameter (typ depends on measurement mode)
   @return Error code
   */
   long SetMeasurementParameter(MeasurementMode MeasMode, void* pParameter);

   /**
   Adds a prefilter parameter set to the list
   
   @param FilterType Filter type
   @param pParameter Pointer to prefilter parameter (type depends on filter type)
   @param bClear     Delete list
   @return Error code
   */
   long AddPreFilterParameter(MeasurementPreFilterType FilterType, void* pParameter, bool bClear = false);

   /**
   Read from buffer
   
   @param pbyBuffer     Pointer to buffer (Pointer will incremented)
   @param dwCurrBufferSize Current buffer size (will decremented)
   @return  Success
   */
   bool FromBuffer(PBYTE& pbyBuffer, DWORD& dwCurrBufferSize);

   /**
   Write to buffer
   
   @param pbyBuffer     Pointer to buffer (Pointer will incremented)
   @param dwCurrBufferSize Current buffer size (will decremented)
   @return Success
   */
   bool ToBuffer(PBYTE& pbyBuffer, DWORD& dwCurrBufferSize);

   /**
   Returns the buffer size in bytes
   */
   unsigned long GetBufferSize();

   /**
   Returns a pointer to measurement parameter
   */
   TMeasurementParameterSet* GetMeasurementParameter()
   {
      return &m_MeasParameter;
   };

   /**
   Returns a pointer to prefilter parameter
   */
   TDataAcquPreFilterSetData* GetPreFilterParameter()
   {
      return &m_PreFilter;
   };

   /**
   Sets threshold for power spectrum
   
   @param dwThres Threshold (1...200)
   */
   void SetThesholdPowerSpectrum(unsigned long dwThres)
   {
      if (dwThres < 1)
         dwThres = 1;
      if (dwThres > 200)
         dwThres = 200;
      m_dwThesholdPowerSpectrum = dwThres;
   };

   /**
   Returns threshold for power spectrum
   */
   unsigned long GetThesholdPowerSpectrum()
   {
      return m_dwThesholdPowerSpectrum;
   };

   /**
   Assign from an other measurement program
   */
   void Assign(CMeasProgram* pMeasProg);

   /**
   Sets the default parameters
   */
   void SetDefaults();

   /**
   Read settings from INI file
   
   @param pIniFile      Pointer to INI file structure
   @param nIndex     Index in measurement program list, < 0 default measprogram
   @return Success
   */
   bool FromIniFile(CIniFile* pIniFile, int nIndex = -1);

   /**
   Write settings to INI file
   
   @param pIniFile   Pointer to INI file structure
   @param nIndex  Index in measurement program list, < 0 default measprogram
   @return: Success - true
   */
   bool ToIniFile(CIniFile* pIniFile, int nIndex = -1);

   /**
   Test equality

   @param pMeasProg  Pointer to an other data set
   @return: Equality
   */
   bool IsEqual(CMeasProgram* pMeasProg);

private:

   TMeasurementParameterSet m_MeasParameter;
   TDataAcquPreFilterSetData m_PreFilter;
   unsigned long m_dwThesholdPowerSpectrum;
};

/**
Measurement program list item
*/
struct TMeasProgListItem
{
   CMeasProgram *m_pMeasProgram;                         /**< Pointer to measurement program */
   string m_stMeasProgramName;                           /**< Measurement program name */

   TMeasProgListItem()
   {
      m_pMeasProgram = new CMeasProgram;
      m_stMeasProgramName = "";
   };
   TMeasProgListItem(string stMeasProgramName);
   TMeasProgListItem(string stMeasProgramName, CMeasProgram *pMeasProgram);

   virtual ~TMeasProgListItem();

   void Assign(TMeasProgListItem* pMeasProg);
};

typedef vector<TMeasProgListItem*> TMeasProgList;

/**
Measurement program set class
*/
class CMeasProgramSet
{
public:

   /**
   Constructor
   */
   CMeasProgramSet()
   {
      m_lCurrMeasProgIndex = -1;
      m_DefMeasProg.SetDefaults();
      m_dwVersion = 0;
      m_byOnSensor = 1;
   };

   /**
   Destructor
   */
   virtual ~CMeasProgramSet()
   {
      Clear();
   };

   /**
   Deletes all measurement programs
   */
   void Clear();

   /**
   Adds a new measurement programs
   
   @param stMeasProgName Measurement program name (not case sensitive)
   @return Error code
   */
   long AddMeasurementProgram(string stMeasProgName);

   /**
   Selects the current measurement program
   
   @param stMeasProgName Measurement program name (not case sensitive) - "" - default program
   @return Error code
   */
   long SelectCurrentMeasurementProgram(string stMeasProgName = "");

   /**
   Get current measurement program index (< 0 - Default measurement program)
   */
   long GetCurrentMeasurementProgramIndex()
   {
      return m_lCurrMeasProgIndex;
   };

   /**
   Get current measurement program ("" - Default measurement program)
   */
   string GetCurrentMeasurementProgram()
   {
      return m_lCurrMeasProgIndex >= 0 ? GetParameterSetName((unsigned long)m_lCurrMeasProgIndex) : "";
   };

   /**
   Deletes a new measurement programs
   
   @param stMeasProgName Measurement program name (not case sensitive)
   */
   void DeleteMeasurementProgram(string stMeasProgName);

   /**
   Sets the measurement parameter
   
   @param stMeasProgName   Measurement program name (not case sensitive)
   @param MeasMode         Measurement mode
   @param pParameter    Pointer to measurement parameter (typ depends on measurement mode)
   @return Error code
   */
   long SetMeasurementParameter(string stMeasProgName, MeasurementMode MeasMode, void* pParameter);

   /**
   Sets the measurement parameter for the default set
   
   @param MeasMode      Measurement mode
   @param pParameter Pointer to measurement parameter (typ depends on measurement mode)
   @return Error code
   */
   long SetMeasurementParameterDef(MeasurementMode MeasMode, void* pParameter);

   /**
   Adds a prefilter parameter set to the list
   
   @param stMeasProgName   Measurement program name (not case sensitive)
   @param FilterType    Filter type
   @param pParameter    Pointer to prefilter parameter (typ depends on filter type)
   @param bClear        Delete list?
   @return Error code
   */
   long AddPreFilterParameter(string stMeasProgName, MeasurementPreFilterType FilterType, void* pParameter,
      bool bClear = false);

   /**
   Adds a prefilter parameter set to the default set list
   
   @param FilterType Filter type
   @param pParameter Pointer to prefilter parameter (typ depends on filter type)
   @param bClear     Delete list?
   @return Error code
   */
   long AddPreFilterParameterDef(MeasurementPreFilterType FilterType, void* pParameter, bool bClear = false);

   /**
   Read from buffer
   pbyBuffer - Pointer to buffer (Pointer will incremented !!!)
   dwCurrBufferSize  -  Current buffer size (will decremented)
   @return Success - true
   */
   bool FromBuffer(PBYTE& pbyBuffer, DWORD& dwCurrBufferSize);

   /**
   Write to buffer
   
   @param pbyBuffer     Pointer to buffer (Pointer will incremented)
   @param dwCurrBufferSize Current buffer size (will decremented)
   @return Success - true
   */
   bool ToBuffer(PBYTE& pbyBuffer, DWORD& dwCurrBufferSize);

   /**
   Returns the buffer size in byte
   */
   unsigned long GetBufferSize();

   /**
   Returns the number of measurement parameter sets
   */
   unsigned long GetNumParameterSets();

   /**
   Returns the name of the measurement parameter set on index
   */
   string GetParameterSetName(unsigned long dwIndex);

   /**
   Returns a pointer to measurement parameter
   stMeasProgName -  Measurement program name (not case sensitive) - "" - selected program
   */
   TMeasurementParameterSet* GetMeasurementParameter(string stMeasProgName = "");

   /**
   Returns a pointer to prefilter parameter
   
   @param stMeasProgName Measurement program name (not case sensitive) - "" - selected program
   */
   TDataAcquPreFilterSetData* GetPreFilterParameter(string stMeasProgName = "");

   /**
   Sets threshold for power spectrum
   @param dwThres       Threshold (1...200)
   @param stMeasProgName   Measurement program name (not case sensitive) - "" - selected program
   */
   void SetThesholdPowerSpectrum(unsigned long dwThres, string stMeasProgName = "");

   /**
   Returns threshold for power spectrum
   @param stMeasProgName Measurement program name (not case sensitive) - "" - selected program
   */
   unsigned long GetThesholdPowerSpectrum(string stMeasProgName = "");

   /**
   Which measuring program is identical to the default measuring program
   
   @return Measurement program name or -1, if no measurement program is identical
   */
   string GetDefaultMeasProgramName();

   /**
   Height image calculation on sensor or sensor DLL if possible. Always true for normal cases, false for development or tests
   
   @return True if height image calculation is done on the sensor, otherwise false
   */
   bool GetOnSensorFlag()
   {
      return m_byOnSensor != 0;
   };

   /**
   Set height image calculation on sensor or sensor DLL if possible. For development or tests.

   @param bOnSenor True if height image calculation is done on the sensor, otherwise false
   */
   void SetOnSensorFlag(bool bOnSenor)
   {
      m_byOnSensor = bOnSenor ? 1 : 0;
   };

   /**
   Read settings from INI file, filename is default ini file name
   
   @return Success
   */
   bool FromIniFile();

   /**
   Read settings from INI file, filename is default ini file name
   
   @param stIniFileName Ini file name (with path)
   @return Success
   */
   bool FromIniFile(string stIniFileName);

   /**
   Write settings to INI file, filename is default ini file name
   
   @return Success
   */
   bool ToIniFile();

   /**
   Write settings to INI file, filename is default ini file name
   
   @param stIniFileName - Ini file name (with path)
   @return Success
   */
   bool ToIniFile(string stIniFileName);

   /**
   Load from binary file
   @param pFile Pointer to file
   @return Error code
   */
   long LoadFromBinaryFile(CDataFile* pFile);

   /**
   Save to binary file
   
   @param pFile Pointer to file
   @return Error code
   */
   long SaveToBinaryFile(CDataFile* pFile);

   /**
   Assign from an other measurement program set
   */
   void Assign(CMeasProgramSet* pMeasProgset);

   /**
   Returns the current version
   */
   static unsigned long GetCurrentVersion();

private:

   string GetIniFileName();

private:

   long m_lCurrMeasProgIndex;
   TMeasProgList m_pMeasProgList;
   CMeasProgram m_DefMeasProg;
   unsigned long m_dwVersion;
   unsigned char m_byOnSensor;
};

#endif