DataFilter.h

Go to the documentation of this file.

/**
* @file DataFilter.h
* @brief Filter definitions
*
* @author LMI Technologies
*/

#ifndef _DataFilter_h
#define _DataFilter_h

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

using namespace std;

/**
Data structure - Standard filter
*/
struct TFilterData
{
   MeasurementPreFilterType m_Type;                /**< Filter type */
   long m_lFilterLengthX;                          /**< Filter length X direction */
   long m_lFilterLengthY;                          /**< Filter length Y direction */
   eMC3DFilterDirection m_Direction;                  /**< Filter direction */

   TFilterData()
   {
      m_Type = MeasurementPreFilterType_None;
      m_lFilterLengthX = m_lFilterLengthY = 3;
      m_Direction = MC3DFilterDirection_XY;
   };
   TFilterData(MeasurementPreFilterType Type)
   {
      Init(Type);
   };

   virtual void Init(MeasurementPreFilterType Type)
   {
      m_Type = Type;
      m_lFilterLengthX = m_lFilterLengthY = 3;
      m_Direction = MC3DFilterDirection_XY;
   };

   virtual void Assign(TFilterData* pFilterData)
   {
      if (!pFilterData || pFilterData == this)
         return;

      m_Type = pFilterData->m_Type;
      m_lFilterLengthX = pFilterData->m_lFilterLengthX;
      m_lFilterLengthY = pFilterData->m_lFilterLengthY;
      m_Direction = pFilterData->m_Direction;
   };

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

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

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

   virtual bool FromIniFile(CIniFile *pIniFile, wstring stSec, int nIndex);

   virtual bool ToIniFile(CIniFile *pIniFile, wstring stSec, int nIndex);

   virtual bool IsEqual(TFilterData* pFilterData);
};

/**
Data structure - Filter "remove invalid"
*/
struct TFilterRemoveInvalidData : public TFilterData
{
   long m_lMaximalRadius;                          /**< Maximum radius of invalid range (in pixel) */
   bool m_bUseEdges;                            /**< Include areas on the edge? */
   long m_lEnlargeInvalid;                         /**< Increase invalid area (in pixel) */

   TFilterRemoveInvalidData() : TFilterData()
   {
      m_Type = MeasurementPreFilterType_RemoveInvalid;
      m_lMaximalRadius = 10;
      m_bUseEdges = false;
      m_lEnlargeInvalid = 2;
      m_lFilterLengthX = m_lFilterLengthY = 9;
      m_Direction = MC3DFilterDirection_X;
   };

   virtual void Init(MeasurementPreFilterType Type)
   {
      TFilterData::Init(Type);
      m_lMaximalRadius = 10;
      m_bUseEdges = false;
      m_lEnlargeInvalid = 2;
      m_lFilterLengthX = m_lFilterLengthY = 9;
      m_Direction = MC3DFilterDirection_X;
   };

   virtual void Assign(TFilterData* pFilterData)
   {
      TFilterRemoveInvalidData* pData = dynamic_cast<TFilterRemoveInvalidData*>(pFilterData);
      if (!pData || pData == this)
         return;

      m_Type = pData->m_Type;
      m_lFilterLengthX = pData->m_lFilterLengthX;
      m_lFilterLengthY = pData->m_lFilterLengthY;
      m_Direction = pData->m_Direction;
      m_lMaximalRadius = pData->m_lMaximalRadius;
      m_bUseEdges = pData->m_bUseEdges;
      m_lEnlargeInvalid = pData->m_lEnlargeInvalid;
   };

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

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

   virtual unsigned long GetBufferSize()
   {
      return 2 * sizeof(unsigned long)+4 * sizeof(long)+sizeof(bool);
   };

   virtual bool FromIniFile(CIniFile *pIniFile, wstring stSec, int nIndex);

   virtual bool ToIniFile(CIniFile *pIniFile, wstring stSec, int nIndex);

   virtual bool IsEqual(TFilterData* pFilterData);
};

typedef vector<TFilterData*> TFilterDataList;

/**
Data structure for prefilter set for data acquisition
*/
struct TDataAcquPreFilterSetData
{
   TFilterDataList m_pFilterList;                                      /**< Filter list */

   virtual ~TDataAcquPreFilterSetData()
   {
      Clear();
   };

   /**
   Clears the filter list
   */
   void Clear();

   void Assign(TDataAcquPreFilterSetData* pData);

   /**
   Initialize the filter list
   
   @param pFilterList Pointer to the filter list
   @param nNumFilter Filterlist size
   */
   void Initialize(TFilterData* pFilterList, int nNumFilter);

   /**
   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 byte
   
   @return Buffer size
   */
   unsigned long GetBufferSize();

   /**
   Read settings from INI file
   
   @param pIniFile  Pointer to INI file structure
   @param stSec      Sector
   @return Success
   */
   bool FromIniFile(CIniFile *pIniFile, wstring stSec);

   /**
   Write settings to INI file
   
   @param pIniFile  Pointer to INI file structure
   @param stSec      Sector
   @return Success
   */
   bool ToIniFile(CIniFile *pIniFile, wstring stSec);

   /**
   Is equal to an other data set?
   
   @param pFilterDataSet  Pointer to an other data set
   @return True if equal, otherwise false
   */
   bool IsEqual(TDataAcquPreFilterSetData* pFilterDataSet);

   TDataAcquPreFilterSetData& operator =(const TDataAcquPreFilterSetData& Data);
};

#endif // _DataFilter_h