MeasurementDefs.h

Go to the documentation of this file.

/**
* @file MeasurementDefs.h
* @brief Defines for measurement module for sensors with 1 projector and 1 camera
*
* @author LMI Technologies
*/

#ifndef _MeasurementDefs_h
#define _MeasurementDefs_h

#include <vector>
#include <string>
#include "MC3DDefs.h"

using namespace std;

/**
List of the IDs of all available sensor types
*/
enum SensorTypeID
{
   SensorTypeID_None = 0,              /**< No type */
#ifdef __DUMMY_ALLOWED__
   SensorTypeID_Dummy = 1,             /**< Dummy sensor */
#endif
   SensorTypeID_DSP = 2,               /**< DSP sensor */
   SensorTypeID_AlligatorPylon1394 = 3,   /**< Sensor Projector: Alligator, Camera Pylon Basler IEEE1394 */
   SensorTypeID_AlligatorPylonGigE = 4,   /**< Sensor Projector: Alligator, Camera Pylon Basler GigE */
   SensorTypeID_AlligatorVimba = 5,    /**< Sensor Projector: Alligator, Camera Vimba AVT */

   SensorTypeID_Last,
};

/**
Sensor operating mode
*/
enum SensorOperatingMode
{
   SensorOperatingMode_Measure = 0,                        /**< Initialized for measurements only                  */
   SensorOperatingMode_SimpleCalib = 1,                    /**< Initialized for simple calibration and measurement */
};

/**
Sensor with separate camera and projector
*/

/**
Projector driver type (Alligator...)
*/
enum ProjectorDriverTypeID
{
   ProjectorDriverTypeID_None = 0,                         /**< No projector */
   ProjectorDriverTypeID_Alligator = 1,                    /**< Alligator */

   ProjectorDriverTypeID_Last,
};

/**
Cameras driver type (Pylon, Vimba...)
*/
enum CameraDriverTypeID
{
   CameraDriverTypeID_None = 0,                            /**< No camera */
   CameraDriverTypeID_Pylon1394 = 1,                       /**< Pylon Basler (IEEE 1394) */
   CameraDriverTypeID_PylonGigE = 2,                       /**< Pylon Basler (GigE) */
   CameraDriverTypeID_Vimba = 3,                           /**< Vimba AVT */

   CameraDriverTypeID_Last,
};


/**
Description for sensors with separate projector and camera
*/
struct TSensorDescription
{
   long m_lDeviceID;                                       /**< Device ID (May be the sensor number, not necessary) */
   bool m_bDescSet;                                        /**< All description inputs set? */
   unsigned long m_dwSensorNo;                             /**< Sensor number */
   ProjectorDriverTypeID m_ProjectorDriverTypeID;          /**< Projector type ID */
   CameraDriverTypeID m_CameraDriverTypeID;                /**< Camera type ID */
   string m_stProjectorID;                                 /**< Projector ID */
   string m_stCameraID;                                    /**< Camera ID */

   TSensorDescription()
   {
      m_lDeviceID = -1;
      m_bDescSet = false;
      m_dwSensorNo = 0;
      m_ProjectorDriverTypeID = ProjectorDriverTypeID_None;
      m_CameraDriverTypeID = CameraDriverTypeID_None;
      m_stProjectorID = m_stCameraID = "";
   };

   TSensorDescription& operator =(TSensorDescription& Descr)
   {
      if (&Descr == this)
         return *this;

      m_lDeviceID = Descr.m_lDeviceID;
      m_bDescSet = Descr.m_bDescSet;
      m_dwSensorNo = Descr.m_dwSensorNo;
      m_ProjectorDriverTypeID = Descr.m_ProjectorDriverTypeID;
      m_CameraDriverTypeID = Descr.m_CameraDriverTypeID;
      m_stProjectorID = Descr.m_stProjectorID;
      m_stCameraID = Descr.m_stCameraID;

      return *this;
   };
};

typedef vector<TSensorDescription> TSensorDescriptionList;

/**
Version information structure for one sensor
*/
struct TSensorVersionInfo
{
   unsigned long m_dwModuleVersion;                /**< Version of the module (DLL) */
   unsigned long m_dwFirmwareVersion;              /**< Version of the sensor firmware */
   unsigned long m_dwInterfaceVersion;             /**< Version of the interface (protocol) to hardware */
   SensorTypeID m_SensorTypeID;              /**< Sensor type ID */

   TSensorVersionInfo()
   {
      m_dwModuleVersion = m_dwInterfaceVersion = m_dwFirmwareVersion = 0;
      m_SensorTypeID = SensorTypeID_None;
   };
};

/**
Version information structure for all
*/
struct TMeasurementVersionInfo
{
   unsigned long m_dwModuleVersion;                /**< Version of the measurement module (DLL) */
   unsigned long m_dwInterfaceVersion;             /**< Version of the measurement interface (protocol) to hardware */
   vector<TSensorVersionInfo> m_SensorVersionInfo; /**< List with version info of all available sensor types */

   TMeasurementVersionInfo()
   {
      m_dwModuleVersion = m_dwInterfaceVersion = 0;
   };
};

/**
Parameter setting
*/

/**
Available flags
*/
#define MEAS_PARAMETER_NOT_AVAILABLE 0                ///< Measurement parameter not available
#define MEAS_PARAMETER_AVAILABLE_READ 1               ///< Measurement parameter is available to read
#define MEAS_PARAMETER_AVAILABLE_WRITE 2              ///< Measurement parameter is available to write

/**
Parameter IDs
*/
enum MeasurementParameterID
{
   /** Integer parameter */

   MeasurementParameterID_CurrCameraSizeX = 0,         /**< Current camera size in X direction (in pixel) */
   MeasurementParameterID_CurrCameraSizeY = 1,         /**< Current camera size in Y direction (in pixel) */
   MeasurementParameterID_CurrCameraX0 = 2,            /**< Current camera origin in X direction (in pixel) */
   MeasurementParameterID_CurrCameraY0 = 3,            /**< Current camera origin in Y direction (in pixel) */
   MeasurementParameterID_MaxCameraSizeX = 4,          /**< Maximum camera size in X direction (in pixel) */
   MeasurementParameterID_MaxCameraSizeY = 5,          /**< Maximum camera size in Y direction (in pixel) */
                                           
   MeasurementParameterID_CurrProjectorSizeX = 10,     /**< Current projector size in X direction (in pixel) */
   MeasurementParameterID_CurrProjectorSizeY = 11,     /**< Current projector size in Y direction (in pixel) */
   MeasurementParameterID_CurrProjectorX0 = 12,        /**< Current projector origin in X direction (in pixel) */
   MeasurementParameterID_CurrProjectorY0 = 13,        /**< Current projector origin in Y direction (in pixel) */
   MeasurementParameterID_MaxProjectorSizeX = 14,      /**< Maximum projector size in X direction (in pixel) */
   MeasurementParameterID_MaxProjectorSizeY = 15,      /**< Maximum projector size in Y direction (in pixel) */
                                           
   MeasurementParameterID_CameraShutter = 101,         /**< Camera shutter */
   MeasurementParameterID_CameraShutterTimeBase = 102, /**< Camera shutter time base */
   MeasurementParameterID_CameraGain = 103,            /**< Camera gain */
                                           
   MeasurementParameterID_ProjectorBrightness = 151,   /**< Projector brightness (e.g. LED power) */
   MeasurementParameterID_ProjectorSwitchOnOff = 152,  /**< Projector switch on/off */
                                           
   MeasurementParameterID_SensorBrightness = 160,      /**< Sensor brightness combined from camera shutter, camera gain, projector brightness ... */
   MeasurementParameterID_Dynamic = 165,               /**< Dynamic - measurement with 2 or 3 brightness parameter sets (HDR mode , Super HDR mode) */
    MeasurementParameterID_BrightnessOffsetHDRMode = 166,       /**< Brightness offset for HDR mode (Dynamic 2) */
    MeasurementParameterID_BrightnessOffsetSuperHDRMode = 167,  /**< Brightness offset for Super HDR mode (Dynamic 3) */

   MeasurementParameterID_SensorSwitchOnOff = 201,     /**< Sensor switch on/off */

    MeasurementParameterID_UseTexture = 801,            /**< Use texture acquisition ? */

    MeasurementParameterID_MirrorMode = 821,            /**< Mirror mode for all images */

   MeasurementParameterID_NumPattern = 901,            /**< Number of predefined pattern */
   MeasurementParameterID_NumStripes = 902,            /**< Number of predefined stripe pattern */
                                           
   /** Float parameter */

    MeasurementParameterID_TextureCorrFactorRed = 802,   /** Color factor red share (only Texture mode "projection color" */
    MeasurementParameterID_TextureCorrFactorGreen = 803, /** Color factor green share (only Texture mode "projection color" */
    MeasurementParameterID_TextureCorrFactorBlue = 804,  /** Color factor blue share (only Texture mode "projection color" */
    MeasurementParameterID_TextureCorrFactorBrightness = 805,  /** Brightness factor for texture (all modes) */

   MeasurementParameterID_ScaleX = 1000,           /**< Scaling X */
   MeasurementParameterID_ScaleY = 1001,           /**< Scaling Y */
   MeasurementParameterID_ScaleZ = 1002,           /**< Scaling Z */
                                           
   MeasurementParameterID_MaxProjectionAreaX = 1011,   /**< Maximum of projection area percental X */
   MeasurementParameterID_MaxProjectionAreaY = 1012,   /**< Maximum of projection area percental Y */

    Measurement_ParameterID_LEDTemperature    = 2001,      /**< LED temperature, only available on some systems */
    Measurement_ParameterID_SystemTemperature = 2002,      /**< System/Camera temperature, only available on some systems */
    Measurement_ParameterID_ProjectorStatus   = 2003,      /**< Projector status, only available on some systems */
};

/**
Double word list
*/
typedef vector<unsigned long> TDWordList;

/**
String list
*/
typedef vector<string> TStringList;

/**
Measurement mode
*/
enum MeasurementMode
{
   MeasurementMode_None = 0,           /**< No measurement mode */
   MeasurementMode_GrayCodePhaseShift = 1,   /**< Gray code + phase shift */
   MeasurementMode_PhaseShift = 2,        /**< Phase shift only */
   MeasurementMode_PhaseCode = 3,         /**< Phase code*/
};

/**
Prefilter type
*/
enum MeasurementPreFilterType
{
   MeasurementPreFilterType_None = 0,                  /**< No type */
   MeasurementPreFilterType_RemoveInvalid = 1,         /**< Remove invalid values */
   MeasurementPreFilterType_Gaussian = 2,              /**< Gaussian filter */
   MeasurementPreFilterType_Average = 3,               /**< Average filter */
   MeasurementPreFilterType_Median = 4,                /**< Median filter */
   MeasurementPreFilterType_RemovePeaks = 5,           /**< Remove peaks */

   MeasurementPreFilterType_Last,                      /**< Last item */
};

/**
Pattern types
*/
enum MeasurementPattern
{
   MeasurementPattern_Bright = 0,                     /**< Bright image (255) */
   MeasurementPattern_Dark = 1,                       /**< Dark image (0) */
   MeasurementPattern_MeasRange = 2,                  /**< Measurement range */
   MeasurementPattern_Sqare = 3,                      /**< Square */
   MeasurementPattern_Circle = 4,                     /**< Circle */
    MeasurementPattern_SqareCross = 5,                 /**< Square with cross */
    MeasurementPattern_CircleCross = 6,                /**< Circle with cross */
};

/**
Stripes types
*/
enum MeasurementStripePattern
{
   MeasurementStripePattern_None = 0,                 /**> No stripes, bright image (255 or invers 0) */
   MeasurementStripePattern_1 = 1,                    /**> 1 stripe */
   MeasurementStripePattern_2 = 2,                    /**> 2 stripes */
   MeasurementStripePattern_4 = 3,                    /**> 4 stripes */
   MeasurementStripePattern_8 = 4,                    /**> 5 stripes */
   MeasurementStripePattern_16 = 5,                   /**> 16 stripes */
   MeasurementStripePattern_32 = 6,                   /**> 32 stripes */
   MeasurementStripePattern_64 = 7,                   /**> 64 stripes */
   MeasurementStripePattern_128 = 8,                  /**> 128 stripes */
   MeasurementStripePattern_256 = 9,                  /**> 256 stripes */
   MeasurementStripePattern_512 = 10,                 /**> 512 stripes */
   MeasurementStripePattern_1024 = 11,                /**> 2024 stripes */
};

/**
Projector lamp state
*/
enum ProjectorLampState
{
   ProjectorLampState_Indefinite,   /**< Indefinite - No projector lamp switch on / off possible */
   ProjectorLampState_On,        /**< Lamp on */
   ProjectorLampState_Off,       /**< Lamp off */
};

/**
Pre-filter definition
*/
struct TMeasProgFilterData
{
   long m_lFilterLengthX;                                            /**< Filter length X direction */
   long m_lFilterLengthY;                                            /**< Filter length Y direction */
   eMC3DFilterDirection m_Direction;                                    /**< Filter direction */

   TMeasProgFilterData()
   {
      m_lFilterLengthX = m_lFilterLengthY = 3;
      m_Direction = MC3DFilterDirection_XY;
   };
};

/**
Pre-filter - remove invalid
*/
struct TMeasProgRemoveInvalidFilterData
{
   long m_lFilterLengthX;                                            /**< Filter length X direction */
   long m_lFilterLengthY;                                            /**< Filter length Y direction */
   eMC3DFilterDirection m_Direction;                                    /**< Filter direction */
   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) */

   TMeasProgRemoveInvalidFilterData()
   {
      m_lFilterLengthX = m_lFilterLengthY = 9;
      m_Direction = MC3DFilterDirection_XY;
      m_lMaximalRadius = 10;
      m_bUseEdges = false;
      m_lEnlargeInvalid = 2;
   };
};

/**
Calibration states
*/
#define SIMPLE_CALIB_STATE_NONE 0
#define SIMPLE_CALIB_STATE_PLANE 1
#define SIMPLE_CALIB_STATE_GRID 2
#define SIMPLE_CALIB_STATE_GROOVE 4

/**
Calibration modes
*/
enum CalibrationMode
{
   CalibrationMode_None = 0,                         /**< No calibration */
   CalibrationMode_Simple = 1,                       /**< Simple calibration */
   CalibrationMode_MultiLevel = 2,                   /**< Multi level calibration */

   CalibrationMode_Last,
};

/**
Calibration types
*/
enum CalibrationType
{
   CalibrationType_None = 0,
   CalibrationType_GrooveStandard = 11,
   CalibrationType_AdditionalGroove = 12,
   CalibrationType_GrooveTelecentric = 1,
   CalibrationType_AdditionalGrooveTelecentric = 2,
   CalibrationType_MultiLevel = 21,
};

/**
Projector position to camera
*/
enum ProjectorPositionToCamera
{
   ProjectorPositionToCamera_Right,
   ProjectorPositionToCamera_Left,
   ProjectorPositionToCamera_Top,
   ProjectorPositionToCamera_Bottom,
};

/**
Measuring program for calibration
*/
enum CalibrationMeasProgram
{
   CalibrationMeasProgram_32_8,                       /**< Stripes width 32, 8 images */
   CalibrationMeasProgram_32_16,                      /**< Stripes width 32, 16 images */
   CalibrationMeasProgram_32_32,                      /**< Stripes width 32, 32 images */
   CalibrationMeasProgram_32_64,                      /**< Stripes width 32, 64 images */
   CalibrationMeasProgram_32_128,                     /**< Stripes width 32, 128 images */
};

/**
Configuration data transfer mode
*/
enum ConfigDataTransferMode
{
   ConfigDataTransferMode_InitialParameter,                /**< Initial parameters */
   ConfigDataTransferMode_MeasProgramSet,                  /**< Measurement program set */
   ConfigDataTransferMode_Calibration,                     /**< Calibration */
                                              
   ConfigDataTransferMode_AllWithoutCalibration = 0xfffe,  /**< All without calibration */
   ConfigDataTransferMode_All = 0xffff,               /**< All */
};

/**
Trigger event types
*/
enum SensorEventType
{
   SensorEventType_None = 0,                         /**< No event type */
   SensorEventType_ProjectionEnd = 1,                /**< Called on projection end */
   SensorEventType_ExternalTrigger = 2,              /**< Called on external trigger event */
};

/**
Trigger events return types
*/
enum SensorEventReturnType
{
   SensorEventReturnType_None = 0,                   /**< No return */
   SensorEventReturnType_Int = 1,                    /**< Integer */
   SensorEventReturnType_Float = 2,                  /**< Double */
   SensorEventReturnType_String = 3,                 /**< Zero terminated string */
};

/**
Trigger event buffer size
*/
#define SENSOR_EVENT_RETURN_VALUE_BUFFER_SIZE 10240 ///< Buffer size

/*/
Prototype for the event function

@param EventType     Type of the event
@param ReturnType    Type of the return value
@param pcReturnBuffer   Pointer to return buffer
*/
typedef void(__stdcall *MikroCADEventFunc)(SensorEventType EventType, SensorEventReturnType ReturnType,
   char* pcReturnBuffer);

/**
Callback prototype for MikroCAD_SetUSBCommErrorHandler
*/
typedef void(__stdcall *COMM_ERROR)();

/**
Texture mode (Gray or color projection)
*/
enum MeasurementTextureMode
{
    MeasurementTextureMode_ProjectGray,          // Gray projection (default)
    MeasurementTextureMode_ProjectColor,         // Color projection 

    MeasurementTextureMode_Last,                 // Last item
};

#endif // _MeasurementDefs_h