//-----------------------------------------------------------------------------
#ifndef mvDriverBaseEnumsH
#if !defined(DOXYGEN_SHOULD_SKIP_THIS) && !defined(WRAP_ANY)
	#define mvDriverBaseEnumsH mvDriverBaseEnumsH
#endif // DOXYGEN_SHOULD_SKIP_THIS && WRAP_ANY
//-----------------------------------------------------------------------------

#if !defined(DOXYGEN_SHOULD_SKIP_THIS) && !defined(WRAP_ANY)
#	ifdef _WIN32
#		ifdef __BORLANDC__
#			pragma option push -b // force enums to the size of integer
#		endif // __BORLANDC__
#	endif // _WIN32
#endif // #if !defined(DOXYGEN_SHOULD_SKIP_THIS) && !defined(WRAP_ANY)

#if defined(BUILD_MVBLUECOUGAR_DOCUMENTATION)
#	define IGNORE_MVBLUEFOX_SPECIFIC_DOCUMENTATION
#	define IGNORE_MVBLUELYNX_SPECIFIC_DOCUMENTATION
#	define IGNORE_MVGRABBER_SPECIFIC_DOCUMENTATION
#	define IGNORE_MVVIRTUALDEVICE_SPECIFIC_DOCUMENTATION
#	if defined(BUILD_MVBLUECOUGARP_DOCUMENTATION)
#		define IGNORE_MVBLUECOUGARS_SPECIFIC_DOCUMENTATION
#		define IGNORE_MVBLUELYNXM7_SPECIFIC_DOCUMENTATION
#	elif defined(BUILD_MVBLUECOUGARS_DOCUMENTATION)
#		define IGNORE_MVBLUECOUGARP_SPECIFIC_DOCUMENTATION
#		define IGNORE_MVBLUELYNXM7_SPECIFIC_DOCUMENTATION
#	elif defined(BUILD_MVBLUELYNXM7_DOCUMENTATION)
#		define IGNORE_MVBLUECOUGARP_SPECIFIC_DOCUMENTATION
#		define IGNORE_MVBLUECOUGARS_SPECIFIC_DOCUMENTATION
#	endif
#elif defined(BUILD_MVBLUEFOX_DOCUMENTATION)
#	define IGNORE_MVBLUECOUGAR_SPECIFIC_DOCUMENTATION
#	define IGNORE_MVBLUELYNX_SPECIFIC_DOCUMENTATION
#	define IGNORE_MVGRABBER_SPECIFIC_DOCUMENTATION
#	define IGNORE_MVVIRTUALDEVICE_SPECIFIC_DOCUMENTATION
#elif defined(BUILD_MVBLUELYNX_DOCUMENTATION)
#	define IGNORE_MVBLUECOUGAR_SPECIFIC_DOCUMENTATION
#	define IGNORE_MVBLUEFOX_SPECIFIC_DOCUMENTATION
#	define IGNORE_MVGRABBER_SPECIFIC_DOCUMENTATION
#	define IGNORE_MVVIRTUALDEVICE_SPECIFIC_DOCUMENTATION
#elif defined(BUILD_MVGRABBER_DOCUMENTATION)
#	define IGNORE_MVBLUECOUGAR_SPECIFIC_DOCUMENTATION
#	define IGNORE_MVBLUEFOX_SPECIFIC_DOCUMENTATION
#	define IGNORE_MVBLUELYNX_SPECIFIC_DOCUMENTATION
#	define IGNORE_MVVIRTUALDEVICE_SPECIFIC_DOCUMENTATION
#elif defined(BUILD_MVVIRTUALDEVICE_DOCUMENTATION)
#	define IGNORE_MVBLUECOUGAR_SPECIFIC_DOCUMENTATION
#	define IGNORE_MVBLUEFOX_SPECIFIC_DOCUMENTATION
#	define IGNORE_MVBLUELYNX_SPECIFIC_DOCUMENTATION
#	define IGNORE_MVGRABBER_SPECIFIC_DOCUMENTATION
#endif // device specific documentation macros


#if !defined(DOXYGEN_SHOULD_SKIP_THIS) && !defined(WRAP_ANY) && !defined(WRAP_DOTNET)
#	ifndef MV_CUSTOM_IMAGE_BUFFER_PIXEL_FORMATS
#		define MV_CUSTOM_IMAGE_BUFFER_PIXEL_FORMATS
#	endif
#	ifndef MV_CUSTOM_IMAGE_DESTINATION_PIXEL_FORMATS
#		define MV_CUSTOM_IMAGE_DESTINATION_PIXEL_FORMATS
#	endif
#endif // #if !defined(DOXYGEN_SHOULD_SKIP_THIS) && !defined(WRAP_ANY) && !defined(WRAP_DOTNET)

#ifdef __cplusplus
	extern "C" {
#endif // __cplusplus

#if defined(WRAP_DOTNET) || defined(MVIMPACT_ACQUIRE_H_) || defined(DOXYGEN_CPP_DOCUMENTATION)
	namespace mvIMPACT {
		namespace acquire {
#endif // #if defined(WRAP_DOTNET) || defined(MVIMPACT_ACQUIRE_H_) || defined(DOXYGEN_CPP_DOCUMENTATION)

//-----------------------------------------------------------------------------
/// \brief Defines which field triggers the start of the acquisition.
enum TAcquisitionField
//-----------------------------------------------------------------------------
{
	/// \brief Controlled by the camera parameter.
	afAuto		= 0,
	/// \brief Only odd fields will be digitised.
	afOdd		= 1,
	/// \brief Only even fields will be digitised.
	afEven		= 2,
	/// \brief Odd and even fields will be digitised.
	afAny		= afOdd | afEven
};

#ifndef IGNORE_MVBLUECOUGAR_SPECIFIC_DOCUMENTATION
	//-----------------------------------------------------------------------------
	/// \brief Defines valid acquisition modes
	///
	/// \note This feature might change in future releases! Use it with care and 
	/// be ready to change your code later.
	enum TAcquisitionMode
	//-----------------------------------------------------------------------------
	{
		/// \brief Continuous mode. This is the recommended mode when image data shall either
		/// be transferred constantly or when working with an externally triggered setup.
		amContinuous = 1,
		/// \brief In this mode \a AcquisitionFrameCount images will transferred by the device.
		///
		/// When \a AcquisitionFrameCount have been send by the device, it will automatically stop
		/// to send more data
		amMultiFrame = 2,
		/// \brief In this mode the device always will always just send a single image when a data stream 
		/// is started.
		///
		/// This mode can be interessting, when the devices acquisition parameters change from image to
		/// image or when a lot of devices will be operated in the same system an bandwidth resources are
		/// limited.
		amSingleFrame = 3
	};
#endif // #ifndef IGNORE_MVBLUECOUGAR_SPECIFIC_DOCUMENTATION

#ifndef IGNORE_MVBLUEFOX_SPECIFIC_DOCUMENTATION
	//-----------------------------------------------------------------------------
	/// \brief Defines the footer mode of the <b>mvBlueFOX</b>.
	enum TAdvancedImageInfo
	//-----------------------------------------------------------------------------
	{
		/// \brief Advanced image information off.
		aiiOff			= 0,
		/// \brief Generate image average.
		aiiStats		= 1
	};
#endif // #ifndef IGNORE_MVBLUEFOX_SPECIFIC_DOCUMENTATION

//-----------------------------------------------------------------------------
/// \brief Defines valid white balance calibration modes.
enum TAoiMode
//-----------------------------------------------------------------------------
{
	/// \brief Use a small centred window for image processing.
	///
	/// In this mode, a device and processing function dependent window in the middle of
	/// the AOI captured from the device will be used for the processing function.
	///
	/// Example:
	///
	/// - Assume a device that can deliver 640 x 480 pixels.
	/// - The user selects to capture an rectangular AOI starting at 100/100 with a width of 200*200
	///
	/// Now in the centered AOI mode a processing function will use a window smaller then the AOI in the middle
	/// of the user defined AOI. This e.g. could be a rectangle starting at 150/150 with a width of 100*100.
	///
	///\code
	///            640
	/// |--------------------------------|
	/// |    100                         |
	/// | 100|-----------------|         |
	/// |    |   150           |         |
	/// |    |150|--------|    |         |
	/// |    |   |        |100 |200      |480
	/// |    |   |--------|    |         |
	/// |    |      100        |         |
	/// |    |-----------------|         |
	/// |           200                  |
	/// |                                |
	/// |--------------------------------|
	///\endcode
	amCentered = 0,
	/// \brief Use the complete image for image processing.
	amFull,
	/// \brief Use a user defined AOI window for image processing.
	amUseAoi
};

//-----------------------------------------------------------------------------
/// \brief Defines valid AutoControlSpeed modes.
///
/// Auto control speed modes define the time in which the controller tries to adapt it's parameters to
/// reach the desired result.
enum TAutoControlSpeed
//-----------------------------------------------------------------------------
{
	/// \brief The controller will converge slowly to the desired value.
	acsSlow = 0,
	/// \brief The controller will converge to the desired value at medium speed.
	acsMedium,
	/// \brief The controller will converge fast to the desired value.
	acsFast,
	/// \brief In this mode the user can control the behaviour of the closed loop(control circuit).
	acsUserDefined
};

//-----------------------------------------------------------------------------
/// \brief Defines valid auto control modes.
enum TAutoControlMode
//-----------------------------------------------------------------------------
{
	/// \brief The standard auto control mode.
	acmStandard,
	/// \brief A device specific auto control mode.
	acmDeviceSpecific
};

//-----------------------------------------------------------------------------
/// \brief Defines valid AEC( <b>A</b>utomatic <b>E</b>xposure <b>C</b>ontrol ) modes.
enum TAutoExposureControl
//-----------------------------------------------------------------------------
{
	/// \brief AEC is switched off.
	aecOff = 0,
	/// \brief AEC is switched on.
	aecOn
};

//-----------------------------------------------------------------------------
/// \brief Defines valid AGC( <b>A</b>utomatic <b>G</b>ain <b>C</b>ontrol ) modes.
enum TAutoGainControl
//-----------------------------------------------------------------------------
{
	/// \brief AGC is switched off.
	agcOff = 0,
	/// \brief AGC is switched on.
	agcOn
};

//-----------------------------------------------------------------------------
/// \brief Defines valid offset calibration modes.
enum TAutoOffsetCalibration
//-----------------------------------------------------------------------------
{
	/// \brief The automatic offset calibration is switched off.
	///
	/// In this mode the offset can be adjusted manually.
	aocOff = 0,
	/// \brief The automatic offset calibration is switched on.
	aocOn
};

//-----------------------------------------------------------------------------
/// \brief Defines valid bayer formats.
enum TBayerMosaicParity
//-----------------------------------------------------------------------------
{
	/// \brief It is not known whether the buffer or image contains raw bayer data or the
	/// buffer or image does NOT contain raw bayer data.
	bmpUndefined = -1,
	/// \brief The buffer or image starts with a green-red line starting with a green pixel.
	bmpGR,
	/// \brief The buffer or image starts with a green-red line starting with a red pixel.
	bmpRG,
	/// \brief The buffer or image starts with a green-blue line starting with a blue pixel.
	bmpBG,
	/// \brief The buffer or image starts with a green-blue line starting with a green pixel.
	bmpGB
};

//-----------------------------------------------------------------------------
/// \brief Defines valid results of a white balance calibration.
enum TBayerWhiteBalanceResult
//-----------------------------------------------------------------------------
{
	/// \brief No white balance calibration has been performed since start up.
	bwbrUnknown = 0,
	/// \brief The white balance calibration has been performed successfully for the
	/// selected setting.
	bwbrOK = 1,
	/// \brief An unknown error occurred during the white balance calibration for the
	/// selected setting.
	bwbrErrorUnknown = 2,
	/// \brief <b>DEPRECATED</b>! Use <b>mvIMPACT::acquire::bwbrErrorTooDark</b>
	bwbrErrorToDark = 3,
	/// \brief The previous white balance calibration failed because the reference image
	/// used for the calibration was too dark.
	bwbrErrorTooDark = 3,
	/// \brief <b>DEPRECATED</b>! Use <b>mvIMPACT::acquire::bwbrErrorTooBright</b>
	bwbrErrorToBright = 4,
	/// \brief The previous white balance calibration failed because the reference image
	/// used for the calibration was too bright.
	bwbrErrorTooBright = 4
};

#ifndef IGNORE_MVBLUEFOX_SPECIFIC_DOCUMENTATION
	//-----------------------------------------------------------------------------
	/// \brief Defines valid thresholds( in Volt ) for the digital inputs of the
	/// <b>mvBlueFOX</b> cameras.
	enum TBlueFOXDigitalInputThreshold
	//-----------------------------------------------------------------------------
	{
		/// \brief This input is assumed as logic '1' when the voltage applied to the
		/// input lies above about 2 Volts.
		bfdit2V = 2,
		/// \brief This input is assumed as logic '1' when the voltage applied to the
		/// input lies above about 10 Volts.
		bfdit10V = 10
	};

	//-----------------------------------------------------------------------------
	/// \brief Defines the footer mode of the mvBlueFOX.
	enum TBlueFOXFooterMode
	//-----------------------------------------------------------------------------
	{
		/// \brief No footer.
		bffmOff			= 0,
		/// \brief A 64 Byte footer (standard).
		bffm64B			= 64,
		/// \brief A long 512 Byte footer.
		bffm512B		= 512
	};

	//-----------------------------------------------------------------------------
	/// \brief Defines the version of the kernel driver the mvBlueFOX is running with.
	enum TBlueFOXKernelDriver
	//-----------------------------------------------------------------------------
	{
		/// \brief The first version of the kernel driver.
		bfkdmvBlueFOX,
		/// \brief The second version of the kernel driver.
		///
		/// Under Windows&reg; this driver results in less CPU load, Under Linux
		/// this driver is currently not available, however the first version of the
		/// Linux kernel driver provides the same performance as the second version
		/// under Windows&reg;.
		bfkdmvBlueFOX2
	};

	//-----------------------------------------------------------------------------
	/// \brief Defines Offset Auto Calibration Controller Speed.
	///
	/// These are relative values, that might result in a different behaviour depending
	/// on the sensor type used.
	enum TBlueFOXOffsetAutoBlackSpeed
	//-----------------------------------------------------------------------------
	{
		/// \brief Fastest Setting
		bfoablFastest  = 0,
		/// \brief Very fast Setting
		bfoablVeryFast = 1,
		/// \brief Fast Setting
		bfoablFast     = 2,
		/// \brief Medium Setting
		bfoablMedium   = 3,
		/// \brief Slow Setting
		bfoablSlow     = 4,
		/// \brief Very slow Setting
		bfoablVerySlow = 6,
		/// \brief Slowest Setting
		bfoablSlowest  = 7
	};

	//-----------------------------------------------------------------------------
	/// \brief Sensor timing options
	enum TBlueFOXSensorTiming
	//-----------------------------------------------------------------------------
	{
		/// \brief Standard Timing
		bfstStandard = 0,
		/// \brief Fast line skip timing
		///
		/// In this mode a faster line skip timing will be used. This will result in a higher 
		/// framerate in partial scan mode, but might affect the image quality.
		///
		/// \note
		/// This mode is not available for every mvBlueFOX camera.
		bfstFastLineSkip = 1
	};

	//-----------------------------------------------------------------------------
	/// \brief Defines the block size used for the USB transfer of the mvBlueFOX.
	enum TBlueFOXTransferSize
	//-----------------------------------------------------------------------------
	{
		/// \brief 16KB blocks.
		bfts16KB	= 16*1024,
		/// \brief 32KB blocks.
		bfts32KB	= 32*1024,
		/// \brief 64KB blocks.
		bfts64KB	= 64*1024,
		/// \brief 128KB blocks.
		bfts128KB	= 128*1024,
		/// \brief 256KB blocks.
		bfts256KB	= 256*1024,
		/// \brief 512KB blocks.
		bfts512KB	= 512*1024,
		/// \brief 1024KB blocks.
		bfts1024KB	= 1024*1024,
		/// \brief 2048KB blocks.
		bfts2048KB	= 2048*1024
	};
#endif // #ifndef IGNORE_MVBLUEFOX_SPECIFIC_DOCUMENTATION

#ifndef IGNORE_MVBLUELYNX_SPECIFIC_DOCUMENTATION
	//-----------------------------------------------------------------------------
	/// \brief Defines the pixel data clip mode on the <b>mvBlueLYNX</b> cameras.
	enum TBlueLYNXCameraDataClipMode
	//-----------------------------------------------------------------------------
	{
		/// \brief Disable the <i>data clip</i> mode.
		/// All pixel values <b>[0-255]</b> will be returned in the image.
		blcdcmOff	= 0,
		/// \brief Enable the <i>data clip</i> mode.
		/// The image pixel values will be clipped to <b>247</b>. The other values
		/// <b>[248-255]</b> can be used for color display.
		blcdcmOn	= 1
	};

	//-----------------------------------------------------------------------------
	/// \brief Defines the flash mode on the <b>mvBlueLYNX</b> cameras.
	enum TBlueLYNXCameraFlashMode
	//-----------------------------------------------------------------------------
	{
		/// \brief Disable the <i>flash</i>.
		blcfmOff		= 0,
		/// \brief Enable the <i>flash</i>.
		blcfmOn			= 1,
		/// \brief Enable the special mode: <i>software flash</i>.
		blcfmSoftware	= 2
	};

	//-----------------------------------------------------------------------------
	/// \todo document me
	enum TBlueLYNXVideoOutMode
	//-----------------------------------------------------------------------------
	{
		blvomOff = 0,
		blvom50Hz,
		blvom60Hz,
		blvomVGA_640_480_75Hz,
		blvomVGA_800_600_60Hz,
		blvomVGA_800_600_72Hz,
		blvomVGA_1024_768_60Hz
	};
#endif // IGNORE_MVBLUELYNX_SPECIFIC_DOCUMENTATION

//-----------------------------------------------------------------------------
/// \brief Defines a boolean value type
enum TBoolean
//-----------------------------------------------------------------------------
{
	/// \brief Off, false or logical low.
	bFalse = 0,
	/// \brief On, true or logical high.
	bTrue = 1
};

//-----------------------------------------------------------------------------
/// \brief Defines the camera Aoi modes.
enum TCameraAoiMode
//-----------------------------------------------------------------------------
{
	/// \brief Use the complete Aoi window defined by the hardware ( sensor, camera ).
	camFull = 0,
	/// \brief Use an user defined AOI window.
	camUser
};

//-----------------------------------------------------------------------------
/// \brief Defines valid binning modes for the camera.
///
/// \note
/// Binning might be available for color sensors that do not support color
/// binning. This will result in incorrect color information when the data
/// is converted from a bayer sensor. However under some circumstances this feature
/// might be useful( e.g. when taking image in a very dark surrounding or at night
/// where almost no color information will be contained in the image anyway thus
/// resulting in useful images again). Therefore this feature has deliberately
/// left available. \n \n
/// \image html Binning_modes.png \n
enum TCameraBinningMode
//-----------------------------------------------------------------------------
{
	/// \brief No Binning.
	cbmOff = 0x0,
	/// \brief Horizontal Binning (combines 2 adjacent columns).
	cbmBinningH = 0x1,
	/// \brief Vertical Binning (combines 2 adjacent rows).
	cbmBinningV = 0x2,
	/// \brief Combines <b>mvIMPACT::acquire::cbmBinningH</b> and <b>mvIMPACT::acquire::cbmBinningV</b>.
	cbmBinningHV = cbmBinningH | cbmBinningV,
	/// \brief Horizontal Binning (combines 4 adjacent columns).
	cbmBinning3H = 0x10,
	/// \brief Vertical Binning (combines 4 adjacent rows).
	cbmBinning3V = 0x20,
	/// \brief Combines <b>mvIMPACT::acquire::cbmBinning3H</b> and <b>mvIMPACT::acquire::cbmBinning3V</b>.
	cbmBinning3H3V = cbmBinning3H | cbmBinning3V
};

#ifndef IGNORE_MVGRABBER_SPECIFIC_DOCUMENTATION
	//-----------------------------------------------------------------------------
	/// \brief Defines the data format the camera is sending
	enum TCameraDataFormat
	//-----------------------------------------------------------------------------
	{
		/// \brief This is an unknown type.
		cdfUnknown = 0,
		/// \brief This is a mono data format.
		cdfMono,
		/// \brief This is a Bayer format.
		cdfBayer,
		/// \brief This is a RGB format.
		cdfRGB
	};
#endif // #ifndef IGNORE_MVGRABBER_SPECIFIC_DOCUMENTATION

//-----------------------------------------------------------------------------
/// \brief Defines recognized camera sensor expose modes.
enum TCameraExposeMode
//-----------------------------------------------------------------------------
{
	/// \brief Standard sequential mode.
	///
	/// In this mode the sensor first is exposed and then afterwards the image readout
	/// is performed.
	cemStandard = 0,
	/// \brief Overlapped mode, expose during image readout.
	///
	/// This only affects the behaviour of the acquisition in <b>mvIMPACT::acquire::TCameraTriggerMode</b>
	/// is set to <b>mvIMPACT::acquire::ctmContinuous</b>.
	///
	/// In this mode the flash output should <b>NOT</b> be used. In any case the flash output will <b>NOT</b>
	/// work like in <b>mvIMPACT::acquire::cemStandard</b> but only a short pulse will be send to
	/// the output.
	cemOverlapped,
	/// \brief 'No shutter' mode, switch off exposure control.
	///
	/// This only affects the behaviour of the acquisition in <b>mvIMPACT::acquire::TCameraTriggerMode</b>
	/// is set to <b>mvIMPACT::acquire::ctmContinuous</b>. In this case the shutter of the camera is
	/// never closed. Thus the exposure time in this mode is equal to the reciprocal value of the 
	/// current frame rate.
	cemNoShutter
};

#ifndef IGNORE_MVGRABBER_SPECIFIC_DOCUMENTATION
	//-----------------------------------------------------------------------------
	/// \brief Some grabbers are able to get the video signal and sync signals ( HD-IN, VD-IN ) on seperate lines.
	/// The user can define this for non standard cameras.
	enum TCameraExternalSyncEdge
	//-----------------------------------------------------------------------------
	{
		// \brief The sync signal is expected within the video signal.
		ceseNo = 0,
		// \brief The falling edge of external sync signal is used ( HD-IN,VD-IN )
		ceseFallingEdge = 1,
		// \brief The rising edge of external sync signal is used ( HD-IN,VD-IN )
		ceseRisingEdge = 2
	};

	//-----------------------------------------------------------------------------
	/// \brief Some grabbers are able to get the video signal and the sync signal on different input pins.
	/// The user can select this for non standard cameras.
	enum TCameraExternalSyncOutput
	//-----------------------------------------------------------------------------
	{
		// \brief The sync signal is expected on the selected video channel.
		// If RGB is used the sync signal is expected on the 'green' channel ( SyncOnGreen )
		cesoAuto = 0,
		// \brief The sync signal is expected on the first ('red') video channel ( mvTITAN-RGB only )
		cesoRed = 1,
		// \brief The sync signal is expected on the second ('green') video channel ( mvTITAN-RGB only )
		cesoGreen = 2,
		// \brief The sync signal is expected on the third ('blue') video channel ( mvTITAN-RGB only )
		cesoBlue = 3,
		// \brief The sync signal is expected on the fourth ('extern') video channel ( mvTITAN-RGB only )
		cesoExtern = 4
	};
#endif // #ifndef IGNORE_MVGRABBER_SPECIFIC_DOCUMENTATION

//-----------------------------------------------------------------------------
/// \brief Defines valid camera flash modes.
///
/// These enums may be 'ored' together.
enum TCameraFlashMode
//-----------------------------------------------------------------------------
{
	/// \brief Do not use the cameras flash output.
	cfmOff = 0,
	/// \brief Output 0 will be active during the exposure period.
	cfmDigout0 = 0x1,
	/// \brief Output 1 will be active during the exposure period.
	cfmDigout1 = 0x2
};

//-----------------------------------------------------------------------------
/// \brief Defines valid camera flash control types.
enum TCameraFlashType
//-----------------------------------------------------------------------------
{
	/// \brief Flash signal is on while the shutter is open on a frame shutter sensor or 
	/// during the complete exposure period of a rolling shutter sensor.
	cftStandard = 0,
	/// \brief Flash signal is only on during the time all lines of a rolling shutter sensor are 
	/// exposed. 
	///
	/// This time is always smaller or equal to the time defined by <b>mvIMPACT::acquire::cftStandard</b>.
	cftRollingShutterFlash = 1
};

//-----------------------------------------------------------------------------
/// \brief Defines valid camera <b>H</b>igh <b>D</b>ynamic <b>R</b>ange modes.
enum TCameraHDRMode
//-----------------------------------------------------------------------------
{
	/// \brief The normal 'linear response' mode.
	chmOff = 0,
	/// \brief hdrc mode on, parameters fixed, param set 1.
	chmFixed1 = 1,
	/// \brief hdrc mode on, parameters fixed, param set 2.
	chmFixed2 = 2,
	///, \brief hdrc mode on, controlled by additional parameters.
	chmUser = 10
};

//-----------------------------------------------------------------------------
/// \brief Defines how the camera transmits it's video signal.
enum TCameraInterlacedType
//-----------------------------------------------------------------------------
{
	/// \brief The video signal is transmitted non interlaced, meaning that a complete
	/// image is transferred without interruption.
	citNone,
	/// \brief The video signal is transferred interlaced.
	///
	/// Here the camera transmits the video signal in two consecutive frames that form a complete
	/// image. The first frame contains all the even lines (0, 2, 4, ... ) of the image, while 
	/// the second frame contains all odd lines of the image.
	citInterlaced,
	/// \brief The video signal is transferred interlaced with the two frames in reversed order.
	///
	/// Here the camera transmits the video signal in two consecutive frames that form a complete
	/// image. The first frame contains all the odd lines (0, 2, 4, ... ) of the image, while 
	/// the second frame contains all even lines of the image.
	citInvertedInterlaced
};

#ifndef IGNORE_MVGRABBER_SPECIFIC_DOCUMENTATION
	//-----------------------------------------------------------------------------
	/// \brief Multitap cameras can transmit data in different ways. This enum can be used to
	/// define how the camera transmits a line of pixels.
	enum TCameraTapsXGeometry
	//-----------------------------------------------------------------------------
	{
		/// \brief One tap. Pixels are transmitted from left to right.
		cltxg1X = 0,
		/// \brief Two taps. Pixels are transmitted from left to right.
		///
		/// Adjacent pixels are transmitted with one pixel clock.
		///
		/// <table>
		/// <tr><td class="header">clock cycle</td><td class="header">Pixel from Tap 1</td><td class="header">Pixel from Tap 2</td></tr>
		/// <tr><td class="indexvalue">1</td><td class="indexvalue">1</td><td class="indexvalue">2</td></tr>
		/// <tr><td class="indexvalue">2</td><td class="indexvalue">3</td><td class="indexvalue">4</td></tr>
		/// <tr><td class="indexvalue">...</td><td class="indexvalue">...</td><td class="indexvalue">...</td></tr>
		/// <tr><td class="indexvalue">W/2</td><td class="indexvalue">W-1</td><td class="indexvalue">W</td></tr>
		/// </table>
		cltxg1X2 = 1,
		/// \brief Two taps. Sorting of data needed.
		///
		/// The first tap will transmit the first half of each line, the second tap will transmit the second half
		/// of each line. Both taps will transmit pixels from left to right.
		///
		/// <table>
		/// <tr><td class="header">clock cycle</td><td class="header">Pixel from Tap 1</td><td class="header">Pixel from Tap 2</td></tr>
		/// <tr><td class="indexvalue">1</td><td class="indexvalue">1</td><td class="indexvalue">W/2+1</td></tr>
		/// <tr><td class="indexvalue">2</td><td class="indexvalue">2</td><td class="indexvalue">W/2+2</td></tr>
		/// <tr><td class="indexvalue">...</td><td class="indexvalue">...</td><td class="indexvalue">...</td></tr>
		/// <tr><td class="indexvalue">W/2</td><td class="indexvalue">W/2</td><td class="indexvalue">W</td></tr>
		/// </table>
		cltxg2X = 2,
		/// \brief Two taps. Sorting of data needed.
		///
		/// The first tap will transmit the first half of each line from left to right, the second tap will transmit the
		/// second half of the line from right to left.
		///
		/// <table>
		/// <tr><td class="header">clock cycle</td><td class="header">Pixel from Tap 1</td><td class="header">Pixel from Tap 2</td></tr>
		/// <tr><td class="indexvalue">1</td><td class="indexvalue">1</td><td class="indexvalue">W</td></tr>
		/// <tr><td class="indexvalue">2</td><td class="indexvalue">2</td><td class="indexvalue">W-1</td></tr>
		/// <tr><td class="indexvalue">...</td><td class="indexvalue">...</td><td class="indexvalue">...</td></tr>
		/// <tr><td class="indexvalue">W/2</td><td class="indexvalue">W/2</td><td class="indexvalue">W/2+1</td></tr>
		/// </table>
		cltxg2XE = 3,
		/// \brief Two taps. Sorting of data needed.
		///
		/// The first tap will transmit the first half of each line from right to left, the second tap will transmit the
		/// second half of the line from left to right.
		///
		/// <table>
		/// <tr><td class="header">clock cycle</td><td class="header">Pixel from Tap 1</td><td class="header">Pixel from Tap 2</td></tr>
		/// <tr><td class="indexvalue">1</td><td class="indexvalue">W/2</td><td class="indexvalue">W/2+1</td></tr>
		/// <tr><td class="indexvalue">2</td><td class="indexvalue">W/2-1</td><td class="indexvalue">W/2+2</td></tr>
		/// <tr><td class="indexvalue">...</td><td class="indexvalue">...</td><td class="indexvalue">...</td></tr>
		/// <tr><td class="indexvalue">W/2</td><td class="indexvalue">1</td><td class="indexvalue">W</td></tr>
		/// </table>
		cltxg2XM = 4,
		/// \brief Three taps. Pixels are transmitted from left to right.
		///
		/// Adjacent pixels are transmitted with one pixel clock.
		///
		/// <table>
		/// <tr><td class="header">clock cycle</td><td class="header">Pixel from Tap 1</td><td class="header">Pixel from Tap 2</td><td class="header">Pixel from Tap 3</td></tr>
		/// <tr><td class="indexvalue">1</td><td class="indexvalue">1</td><td class="indexvalue">2</td><td class="indexvalue">3</td></tr>
		/// <tr><td class="indexvalue">2</td><td class="indexvalue">4</td><td class="indexvalue">5</td><td class="indexvalue">6</td></tr>
		/// <tr><td class="indexvalue">...</td><td class="indexvalue">...</td><td class="indexvalue">...</td><td class="indexvalue">...</td></tr>
		/// <tr><td class="indexvalue">W/3</td><td class="indexvalue">W-2</td><td class="indexvalue">W-1</td><td class="indexvalue">W</td></tr>
		/// </table>
		cltxg1X3 = 5,
		/// \brief Three taps. Each tap will transmit one third of each line, pixel are transmitted from left to right. Sorting of data needed.
		///
		/// The first tap will transmit the first third of each line, the second tap will transmit the second third and the third tap will transmit the 
		/// last third of each line from left to right.
		///
		/// <table>
		/// <tr><td class="header">clock cycle</td><td class="header">Pixel from Tap 1</td><td class="header">Pixel from Tap 2</td><td class="header">Pixel from Tap 3</td></tr>
		/// <tr><td class="indexvalue">1</td><td class="indexvalue">1</td><td class="indexvalue">W/3+1</td><td class="indexvalue">2W/3+1</td></tr>
		/// <tr><td class="indexvalue">2</td><td class="indexvalue">2</td><td class="indexvalue">W/3+2</td><td class="indexvalue">2W/3+2</td></tr>
		/// <tr><td class="indexvalue">...</td><td class="indexvalue">...</td><td class="indexvalue">...</td><td class="indexvalue">...</td></tr>
		/// <tr><td class="indexvalue">W/3</td><td class="indexvalue">W/3</td><td class="indexvalue">2W/3</td><td class="indexvalue">W</td></tr>
		/// </table>
		cltxg3X = 6,
		/// \brief Four taps. Pixels are transmitted from left to right.
		///
		/// Adjacent pixels are transmitted with one pixel clock.
		///
		/// <table>
		/// <tr><td class="header">clock cycle</td><td class="header">Pixel from Tap 1</td><td class="header">Pixel from Tap 2</td><td class="header">Pixel from Tap 3</td><td class="header">Pixel from Tap 4</td></tr>
		/// <tr><td class="indexvalue">1</td><td class="indexvalue">1</td><td class="indexvalue">2</td><td class="indexvalue">3</td><td class="indexvalue">4</td></tr>
		/// <tr><td class="indexvalue">2</td><td class="indexvalue">5</td><td class="indexvalue">6</td><td class="indexvalue">7</td><td class="indexvalue">8</td></tr>
		/// <tr><td class="indexvalue">...</td><td class="indexvalue">...</td><td class="indexvalue">...</td><td class="indexvalue">...</td><td class="indexvalue">...</td></tr>
		/// <tr><td class="indexvalue">W/4</td><td class="indexvalue">W-3</td><td class="indexvalue">W-2</td><td class="indexvalue">W-1</td><td class="indexvalue">W</td></tr>
		/// </table>
		cltxg1X4 = 7,
		/// \brief Four taps. Each tap will transmit one fourth of each line, pixel are transmitted from left to right. Sorting of data needed.
		///
		/// The first tap will transmit the first quarter of each line, the second tap will transmit the second quarter etc.
		///
		/// <table>
		/// <tr><td class="header">clock cycle</td><td class="header">Pixel from Tap 1</td><td class="header">Pixel from Tap 2</td><td class="header">Pixel from Tap 3</td><td class="header">Pixel from Tap 4</td></tr>
		/// <tr><td class="indexvalue">1</td><td class="indexvalue">1</td><td class="indexvalue">W/4+1</td><td class="indexvalue">2W/4+1</td><td class="indexvalue">3W/4+1</td></tr>
		/// <tr><td class="indexvalue">2</td><td class="indexvalue">2</td><td class="indexvalue">W/4+2</td><td class="indexvalue">2W/4+2</td><td class="indexvalue">3W/4+2</td></tr>
		/// <tr><td class="indexvalue">...</td><td class="indexvalue">...</td><td class="indexvalue">...</td><td class="indexvalue">...</td><td class="indexvalue">...</td></tr>
		/// <tr><td class="indexvalue">W/4</td><td class="indexvalue">W/4</td><td class="indexvalue">2W/4</td><td class="indexvalue">3W/4</td><td class="indexvalue">W</td></tr>
		/// </table>
		cltxg4X = 8,
		/// \brief Four taps. The first two taps will transmit the first half of the line, while the second two taps will transmit the second half of the line.
		/// Sorting of data needed.
		///
		/// Both tap pairs will transmit their data from left to right.
		///
		/// <table>
		/// <tr><td class="header">clock cycle</td><td class="header">Pixel from Tap 1</td><td class="header">Pixel from Tap 2</td><td class="header">Pixel from Tap 3</td><td class="header">Pixel from Tap 4</td></tr>
		/// <tr><td class="indexvalue">1</td><td class="indexvalue">1</td><td class="indexvalue">2</td><td class="indexvalue">W/2+1</td><td class="indexvalue">W/2+2</td></tr>
		/// <tr><td class="indexvalue">2</td><td class="indexvalue">3</td><td class="indexvalue">4</td><td class="indexvalue">W/2+3</td><td class="indexvalue">W/2+4</td></tr>
		/// <tr><td class="indexvalue">...</td><td class="indexvalue">...</td><td class="indexvalue">...</td><td class="indexvalue">...</td><td class="indexvalue">...</td></tr>
		/// <tr><td class="indexvalue">W/4</td><td class="indexvalue">W/2-1</td><td class="indexvalue">W/2</td><td class="indexvalue">W-1</td><td class="indexvalue">W</td></tr>
		/// </table>
		cltxg2X2 = 9,
		/// \brief Four taps. The first two taps will transmit the first half of the line, while the second two taps will transmit the second half of the line.
		/// Sorting of data needed.
		///
		/// The first tap pair will transmit the data from left to right, while the second pair of taps will transfer the data from right to left.
		///
		/// <table>
		/// <tr><td class="header">clock cycle</td><td class="header">Pixel from Tap 1</td><td class="header">Pixel from Tap 2</td><td class="header">Pixel from Tap 3</td><td class="header">Pixel from Tap 4</td></tr>
		/// <tr><td class="indexvalue">1</td><td class="indexvalue">1</td><td class="indexvalue">2</td><td class="indexvalue">W-1</td><td class="indexvalue">W</td></tr>
		/// <tr><td class="indexvalue">2</td><td class="indexvalue">3</td><td class="indexvalue">4</td><td class="indexvalue">W-3</td><td class="indexvalue">W-2</td></tr>
		/// <tr><td class="indexvalue">...</td><td class="indexvalue">...</td><td class="indexvalue">...</td><td class="indexvalue">...</td><td class="indexvalue">...</td></tr>
		/// <tr><td class="indexvalue">W/4</td><td class="indexvalue">W/2-1</td><td class="indexvalue">W/2</td><td class="indexvalue">W/2+1</td><td class="indexvalue">W/2+2</td></tr>
		/// </table>
		cltxg2X2E = 10,
		/// \brief Four taps. The first two taps will transmit the first half of the line, while the second two taps will transmit the second half of the line.
		/// Sorting of data needed.
		///
		/// The first tap pair will transmit the data from right to left, while the second pair of taps will transfer the data from left to right.
		///
		/// <table>
		/// <tr><td class="header">clock cycle</td><td class="header">Pixel from Tap 1</td><td class="header">Pixel from Tap 2</td><td class="header">Pixel from Tap 3</td><td class="header">Pixel from Tap 4</td></tr>
		/// <tr><td class="indexvalue">1</td><td class="indexvalue">W/2-1</td><td class="indexvalue">W/2</td><td class="indexvalue">W/2+1</td><td class="indexvalue">W/2+2</td></tr>
		/// <tr><td class="indexvalue">2</td><td class="indexvalue">W/2-3</td><td class="indexvalue">W/2-2</td><td class="indexvalue">W/2+3</td><td class="indexvalue">W/2+4</td></tr>
		/// <tr><td class="indexvalue">...</td><td class="indexvalue">...</td><td class="indexvalue">...</td><td class="indexvalue">...</td><td class="indexvalue">...</td></tr>
		/// <tr><td class="indexvalue">W/4</td><td class="indexvalue">1</td><td class="indexvalue">2</td><td class="indexvalue">W-1</td><td class="indexvalue">W</td></tr>
		/// </table>
		cltxg2X2M = 11,
		/// \brief Four taps. Each tap will transmit one quarter of the image. Sorting of data needed.
		///
		/// The first two taps will transmit the data from left to right, while the second two taps will transfer the data from right to to left.
		///
		/// <table>
		/// <tr><td class="header">clock cycle</td><td class="header">Pixel from Tap 1</td><td class="header">Pixel from Tap 2</td><td class="header">Pixel from Tap 3</td><td class="header">Pixel from Tap 4</td></tr>
		/// <tr><td class="indexvalue">1</td><td class="indexvalue">1</td><td class="indexvalue">W/4+1</td><td class="indexvalue">3W/4</td><td class="indexvalue">W</td></tr>
		/// <tr><td class="indexvalue">2</td><td class="indexvalue">2</td><td class="indexvalue">W/4+2</td><td class="indexvalue">3W/4-1</td><td class="indexvalue">W-1</td></tr>
		/// <tr><td class="indexvalue">...</td><td class="indexvalue">...</td><td class="indexvalue">...</td><td class="indexvalue">...</td><td class="indexvalue">...</td></tr>
		/// <tr><td class="indexvalue">W/4</td><td class="indexvalue">W/4</td><td class="indexvalue">W/2</td><td class="indexvalue">W/2+1</td><td class="indexvalue">3W/4+1</td></tr>
		/// </table>
		cltxg4XE = 12,
		/// \brief Eight taps. Pixels are transmitted from left to right.
		///
		/// Adjacent pixels are transmitted with one pixel clock.
		/// <table>
		/// <tr><td class="header">clock cycle</td><td class="header">Pixel from Tap 1</td><td class="header">Pixel from Tap 2</td><td class="header">Pixel from Tap 3</td><td class="header">Pixel from Tap 4</td><td class="header">Pixel from Tap 5</td><td class="header">Pixel from Tap 6</td><td class="header">Pixel from Tap 7</td><td class="header">Pixel from Tap 8</td></tr>
		/// <tr><td class="indexvalue">1</td><td class="indexvalue">1</td><td class="indexvalue">2</td><td class="indexvalue">3</td><td class="indexvalue">4</td><td class="indexvalue">5</td><td class="indexvalue">6</td><td class="indexvalue">7</td><td class="indexvalue">8</td></tr>
		/// <tr><td class="indexvalue">2</td><td class="indexvalue">9</td><td class="indexvalue">10</td><td class="indexvalue">11</td><td class="indexvalue">12</td><td class="indexvalue">13</td><td class="indexvalue">14</td><td class="indexvalue">15</td><td class="indexvalue">16</td></tr>
		/// <tr><td class="indexvalue">...</td><td class="indexvalue">...</td><td class="indexvalue">...</td><td class="indexvalue">...</td><td class="indexvalue">...</td><td class="indexvalue">...</td><td class="indexvalue">...</td><td class="indexvalue">...</td><td class="indexvalue">...</td></tr>
		/// <tr><td class="indexvalue">W/8</td><td class="indexvalue">W-7</td><td class="indexvalue">W-6</td><td class="indexvalue">W-5</td><td class="indexvalue">W-4</td><td class="indexvalue">W-3</td><td class="indexvalue">W-2</td><td class="indexvalue">W-1</td><td class="indexvalue">W</td></tr>
		/// </table>
		cltxg1X8 = 13,
		/// \brief Eight taps. Each tap will transmit one eighth of each line, pixel are transmitted from left to right. Sorting of data needed.
		///
		/// The first tap will transmit the first eighth of each line, the second tap will transmit the second eighth etc.
		///
		/// <table>
		/// <tr><td class="header">clock cycle</td><td class="header">Pixel from Tap 1</td><td class="header">Pixel from Tap 2</td><td class="header">Pixel from Tap 3</td><td class="header">Pixel from Tap 4</td><td class="header">Pixel from Tap 5</td><td class="header">Pixel from Tap 6</td><td class="header">Pixel from Tap 7</td><td class="header">Pixel from Tap 8</td></tr>
		/// <tr><td class="indexvalue">1</td><td class="indexvalue">1</td><td class="indexvalue">W/8+1</td><td class="indexvalue">2W/8+1</td><td class="indexvalue">3W/8+1</td><td class="indexvalue">4W/8+1</td><td class="indexvalue">5W/8+1</td><td class="indexvalue">6W/8+1</td><td class="indexvalue">7W/8+1</td></tr>
		/// <tr><td class="indexvalue">2</td><td class="indexvalue">2</td><td class="indexvalue">W/8+2</td><td class="indexvalue">2W/8+2</td><td class="indexvalue">3W/8+2</td><td class="indexvalue">4W/8+2</td><td class="indexvalue">5W/8+2</td><td class="indexvalue">6W/8+2</td><td class="indexvalue">7W/8+2</td></tr>
		/// <tr><td class="indexvalue">...</td><td class="indexvalue">...</td><td class="indexvalue">...</td><td class="indexvalue">...</td><td class="indexvalue">...</td><td class="indexvalue">...</td><td class="indexvalue">...</td><td class="indexvalue">...</td><td class="indexvalue">...</td></tr>
		/// <tr><td class="indexvalue">W/8</td><td class="indexvalue">W/8</td><td class="indexvalue">2W/8</td><td class="indexvalue">3W/8</td><td class="indexvalue">4W/8</td><td class="indexvalue">5W/8</td><td class="indexvalue">6W/8</td><td class="indexvalue">7W/8</td><td class="indexvalue">W</td></tr>
		/// </table>
		cltxg8X = 14
	};

	//-----------------------------------------------------------------------------
	/// \brief Multitap cameras can transmit data in different ways. This enum can be used to
	/// define how the camera transmits the lines of pixels.
	enum TCameraTapsYGeometry
	//-----------------------------------------------------------------------------
	{
		/// \brief Lines from top to bottom.
		cltyg1Y = 0,
		/// \brief Two neighbored lines are transmitted during one FVAL
		cltyg1Y2 = 1,
		/// \brief One line from top and one line from bottom are transmitted during one FVAL
		cltyg2YE = 2,
	};

	//-----------------------------------------------------------------------------
	/// \brief Defines how the camera transmits the <b>DVAL</b> signal defined in the
	/// <b>CameraLink&reg; standard</b>.
	enum TCameraLinkDataValidMode
	//-----------------------------------------------------------------------------
	{
		/// \brief The camera transmits a data valid (<b>DVAL</b>) signal, that should
		/// be evaluated by the frame grabber.
		cldvmActive = 0,
		/// \brief The camera does not transmit a data valid (<b>DVAL</b>) signal, that should
		/// be evaluated by the frame grabber.
		cldvmInactive
	};

	//-----------------------------------------------------------------------------
	/// \brief Defines valid ways a camera can offer image data to a capture device.
	enum TCameraOutput
	//-----------------------------------------------------------------------------
	{
		/// \brief Specifies an undefined output.
		coUndefined = -1,
		/// \brief Auto mode. Here the capture device tries to guess how the data is transmitted. 
		coAuto = 0,
		/// \brief The camera will offer an analogue composite video signal.
		coComposite = 1,
		/// \brief The camera will offer <b>CameraLink&reg; Base</b> compliant image data.
		coBase = 2,
		/// \brief The camera will offer digital image data.
		coDigital = 3,
		/// \brief The camera will offer an analogue SVideo signal.
		coSVideo = 4,
		/// \brief The camera will offer <b>CameraLink&reg; Medium</b> compliant image data.
		coMedium = 5,
		/// \brief The camera will offer an analogue RGB signal.
		coRGB = 6,
		/// \brief Two cameras will offer two synchronous analogue signals.
		co2xComposite = 7,
		/// \brief Three cameras will offer three synchronous analogue signals.
		co3xComposite = 8,
		/// \brief Four cameras will offer four synchronous analogue signals.
		co4xComposite = 9,
		/// \brief The camera will offer <b>CameraLink&reg; Full</b> compliant image data.
		coFull = 10
	};

#endif // #ifndef IGNORE_MVGRABBER_SPECIFIC_DOCUMENTATION

//-----------------------------------------------------------------------------
/// \brief Defines valid camera pixel frequencies.
enum TCameraPixelClock
//-----------------------------------------------------------------------------
{
	/// \brief Standard sensor clocking.
	///
	/// This is a backward compatible mode used by some devices only.
	cpcStandard = 0,
	/// \brief High speed sensor clocking.
	///
	/// This is a backward compatible mode used by some devices only.
	cpcHighSpeed = 1,
	/// \brief 6 MHz pixel clock.
	cpc6000KHz = 6000,
	/// \brief 8 MHz pixel clock.
	cpc8000KHz = 8000,
	/// \brief 10 MHz pixel clock.
	cpc10000KHz = 10000,
	/// \brief 12 MHz pixel clock.
	cpc12000KHz = 12000,
	/// \brief 13.5 MHz pixel clock.
	cpc13500KHz = 13500,
	/// \brief 20 MHz pixel clock.
	cpc20000KHz = 20000,
	/// \brief 24 MHz pixel clock.
	cpc24000KHz = 24000,
	/// \brief 27 MHz pixel clock.
	cpc27000KHz = 27000,
	/// \brief 32 MHz pixel clock.
	cpc32000KHz = 32000,
	/// \brief 37.6 MHz pixel clock.
	cpc37600KHz = 37600,
	/// \brief 40 MHz pixel clock.
	cpc40000KHz = 40000,
	/// \brief 50 MHz pixel clock.
	cpc50000KHz = 50000,
	/// \brief 57.6 MHz pixel clock.
	cpc57600KHz = 57600
};

//-----------------------------------------------------------------------------
/// \brief Defines valid scan modes for the a camera.
enum TCameraScanMode
//-----------------------------------------------------------------------------
{
	/// \brief The connected camera is an area scan camera.
	csmArea = 0,
	/// \brief The connected camera is an line scan camera.
	csmLine
};

#ifndef IGNORE_MVGRABBER_SPECIFIC_DOCUMENTATION
	//-----------------------------------------------------------------------------
	/// \brief Defines valid baud rates for serial port communication between
	/// frame grabber and camera.
	enum TCameraSerialPortBaudRate
	//-----------------------------------------------------------------------------
	{
		/// \brief 9600 baud
		cspbr9600 = 9600,
		/// \brief 19200 baud
		cspbr19200 = 19200,
		/// \brief 38400 baud
		cspbr38400 = 38400,
		/// \brief 57600 baud
		cspbr57600 = 57600,
		/// \brief 115200 baud
		cspbr115200 = 115200,
		/// \brief 230400 baud
		cspbr230400 = 230400,
		/// \brief 460800 baud
		cspbr460800 = 460800,
		/// \brief 921600 baud
		cspbr921600 = 921600
	};
#endif // #ifndef IGNORE_MVGRABBER_SPECIFIC_DOCUMENTATION

//-----------------------------------------------------------------------------
/// \brief Defines valid transmission modes for the camera.
enum TCameraTestMode
//-----------------------------------------------------------------------------
{
	/// \brief The 'normal' camera image will be transmitted.
	ctmOff = 0,
	/// \brief A grey gradient will be transmitted by the camera.
	ctmGreyRamp = 1,
	/// \brief A color test image with some moving components in it will be displayed.
	ctmMovingColor = 2,
	/// \brief A raw white bayer image will be transmitted.
	ctmWBTest = 3
};

//-----------------------------------------------------------------------------
/// \brief Defines valid camera sensor trigger modes.
///
/// \anchor TCameraTriggerMode_Enum
enum TCameraTriggerMode
//-----------------------------------------------------------------------------
{
	/// \brief Don't wait for trigger. In this mode the camera continuously exposes images with
	/// the current settings.
	///
	/// However images are not transferred to the host system automatically in this mode, 
	/// so <b>NO</b> CPU load or whatsoever is produced in this mode when the driver isn't asked
	/// for images by the user.
	///
	/// This mode is recommended for most applications and will be available for every image sensor.
	///
	/// When the user requests an image the image <b>AFTER</b> the next frame start will be returned.
	/// In applications that need fast but <b>NOT</b> continuous image transfer the <b>mvIMPACT::acquire::ctmOnDemand</b>
	/// therefore might be more interesting.
	ctmContinuous = 0,
	/// \brief Start frame expose when the software asks for an image.
	///
	/// Here without image requests by the user the image sensor will not expose images. An exposure
	/// and image transmission will start immediately after at least one images has been requested
	/// by the user.
	///
	/// When e.g. a camera in free running mode captures 30 images per sec. and the user needs
	/// an image every 40 ms (25 fps) this mode might be more suitable then <b>mvIMPACT::acquire::ctmContinuous</b>
	/// as in the continuous mode when asking for an image every 40 ms the user might need to wait
	/// for the next frame start which at 30 Hz in the worst case would result in a capture time
	/// of (1/30Hz)*2 = 66.6 ms when an image start has just been missed. In 
	/// <b>mvIMPACT::acquire::ctmOnDemand</b> however the image exposure will be started immediately
	/// after the request reaches the camera thus no delay will be introduced.
	///
	/// \note
	/// In applications where the capture time can be disregarded because either the transfer time is
	/// much higher or the capture frequency is very low the difference between the 
	/// <b>mvIMPACT::acquire::ctmOnDemand</b> and the <b>mvIMPACT::acquire::ctmContinuous</b> can
	/// be disregarded as well. However in this case <b>mvIMPACT::acquire::ctmContinuous</b> is recommended
	/// as this mode will be available for every sensor type and is more universal.
	ctmOnDemand,
	/// \brief Start the exposure of a frame when the trigger input is below the trigger threshold.
	///
	/// Each time an image is requested and the trigger signal is below the trigger threshold a image will be captured.
	ctmOnLowLevel,
	/// \brief Start the exposure of a frame when the trigger input is above the trigger threshold.
	///
	/// Each time an image is requested and the trigger signal is above the trigger threshold a image will be captured.
	ctmOnHighLevel,
	/// \brief Start the exposure of a frame when the trigger input level changes from high to low.
	ctmOnFallingEdge,
	/// \brief Start the exposure of a frame when the trigger input level changes from low to high.
	ctmOnRisingEdge,
	/// \brief Start frame expose when the trigger input level rises above the trigger threshold and
	/// expose while the trigger input level remains above this threshold.
	ctmOnHighExpose,
	/// \brief Start frame expose when the trigger input level falls below the trigger threshold and
	/// expose while the trigger input level remains below this threshold.
	ctmOnLowExpose,
	/// \brief Start the exposure of a frame when the trigger input level changes from high to low or from low to high.
	ctmOnAnyEdge
};

//-----------------------------------------------------------------------------
/// \brief Defines recognized camera sensor shutter modes.
enum TCameraShutterMode
//-----------------------------------------------------------------------------
{
	/// \brief Standard Frame-Shutter mode.
	///
	/// Start and stop of integration occures at the same time for all pixels
	csmFrameShutter = 0,
	/// \brief Electronic rolling shutter mode (ERS)
	///
	/// Start and stop of integration occures on a line by line base. Integration time is the same for all lines bit timing is slightly different
	csmElectronicRollingShutter,
	/// \brief Global reset release shutter (GRR)
	///
	/// Start of integration occures at the same time for all pixels. End of integration happens on a line per line base like with ERS. 
	/// This is only usful with special ligthing or an mechanical extra shutter
	csmGlobalResetRelease,
};

//-----------------------------------------------------------------------------
/// \brief Sensor trigger source.
enum TCameraTriggerSource
//-----------------------------------------------------------------------------
{
	/// \brief Uses digital input 0 as the source for the trigger signal.
	ctsDigIn0 = 0,
	/// \brief Use digital input 1 as the source for the trigger signal.
	ctsDigIn1,
	/// \brief Use real time controller (RTCtrl) as the source for the trigger signal.
	ctsRTCtrl,
	/// \brief Uses digital output 0 as the source for the trigger signal (this allows a SW controlled trigger (or exposure)).
	ctsDigOut0,
	/// \brief Uses digital output 1 as the source for the trigger signal (this allows a SW controlled trigger (or exposure)).
	ctsDigOut1,
	/// \brief Uses digital output 2 as the source for the trigger signal (this allows a SW controlled trigger (or exposure)).
	ctsDigOut2,
	/// \brief Uses digital output 3 as the source for the trigger signal (this allows a SW controlled trigger (or exposure)).
	ctsDigOut3
};

#ifndef IGNORE_MVGRABBER_SPECIFIC_DOCUMENTATION
	//-----------------------------------------------------------------------------
	/// \brief Clamp signal means, that a AC coupled video signal is clamped on the porch
	///	to get a signal transfer with less noise and independent from the d.c. voltage portion.
	/// The clamp pulse width is always 0.5 micro sec.
	enum TClampMode
	//-----------------------------------------------------------------------------
	{
		/// \brief Clamp pulse starts at 80 % of ActiveVideoAoi.X .
		ecmAuto, 
		/// \brief The user can set the clamp start time in micro sec. after the falling edge of the 
		/// video signals' vsync.
		ecmUser
	};
#endif // IGNORE_MVGRABBER_SPECIFIC_DOCUMENTATION

//-----------------------------------------------------------------------------
/// \brief Defines the color processing mode.
enum TColorProcessingMode
//-----------------------------------------------------------------------------
{
	/// \brief The driver decides (depending on the connected camera) what kind of
	/// color processing has to be applied.
	cpmAuto = 0,
	/// \brief No color processing will be performed.
	cpmRaw,
	/// \brief A Bayer color conversion will be applied before the image is transferred
	/// to the user.
	cpmBayer,
	/// \brief A Bayer to mono conversion will be applied before the image is transferred
	/// to the user.
	cpmBayerToMono,
	/// \brief No color processing will be performed but the packed raw bayer data will be re-arranged
	/// within the buffer.
	///
	/// In the resulting image the top left quarter of the image will contain the red pixels,
	/// the top right quarter the blue pixels, the lower left quarter the green pixels from the
	/// red line and the lower right quarter the green pixels from the blue line:
	///
	///\code
	/// // w: width, h: height
	/// R(0, 0)          R(0, 1), ...          R(0, (w-1)/2)          B(0, 0)          B(0, 1), ...          B(0, (w-1)/2)
	/// R(1, 0)          R(1, 1), ...          R(1, (w-1)/2)          B(1, 0)          B(1, 1), ...          B(1, (w-1)/2)
	///           .
	///           .
	///           .
	/// R((h-1/2), 0)    R((h-1/2), 1), ...    R((h-1/2), (w-1)/2)    B((h-1/2), 0)    B((h-1/2), 1), ...    B((h-1/2), (w-1)/2)
	/// G(R)(0, 0)       G(R)(0, 1), ...       G(R)(0, (w-1)/2)       G(B)(0, 0)       G(B)(0, 1), ...       G(B)(0, (w-1)/2)
	/// G(R)(1, 0)       G(R)(1, 1), ...       G(R)(1, (w-1)/2)       G(B)(1, 0)       G(B)(1, 1), ...       G(B)(1, (w-1)/2)
	///           .
	///           .
	///           .
	/// G(R)((h-1/2), 0) G(R)((h-1/2), 1), ... G(R)((h-1/2), (w-1)/2) G(B)((h-1/2), 0) G(B)((h-1/2), 1), ... G(B)((h-1/2), (w-1)/2)
	///\endcode
	cpmRawToPlanes
};

//-----------------------------------------------------------------------------
/// \brief Defines the different test modes for continuous whitebalancecalibration.
enum TContinuousWhiteBalanceMode
//-----------------------------------------------------------------------------
{
	/// \brief Continuous WhiteBalance using ColorTemperature.
	cwbColorTemperature,
	/// \brief Continuous WhiteBalance using ColorDifferences.
	cwbColorDifferences,
	/// \brief Continuous WhiteBalance using Bright Regions.
	cwbBrightRegions
};

//-----------------------------------------------------------------------------
/// \brief Defines valid modes for the dark current filter.
enum TDarkCurrentFilterMode
//-----------------------------------------------------------------------------
{
	/// \brief This filter is switched off.
	dcfmOff = 0,
	/// \brief This filter is switched on.
	dcfmOn,
	/// \brief The next frame will be taken for dark current adjustment.
	dcfmCalibrateDarkCurrent
#if !defined(DOXYGEN_SHOULD_SKIP_THIS) && !defined(WRAP_ANY) && !defined(WRAP_DOTNET)
	// for internal use only
	, dcfmLastDarkCurrentFilterMode
#endif // #if !defined(DOXYGEN_SHOULD_SKIP_THIS) && !defined(WRAP_ANY) && !defined(WRAP_DOTNET)
};

//-----------------------------------------------------------------------------
/// \brief Defines valid modes for defective pixels filter.
enum TDefectivePixelsFilterMode
//-----------------------------------------------------------------------------
{
	/// \brief This filter is switched off.
	dpfmOff = 0,
	/// \brief The filter is active, detected defective pixels will be replaced with the average value from the left and right neighbour  pixel.
	dpfm3x1Average,
	/// \brief The filter is active, detected defective pixels will be replaced with the median value calculated from the nearest neighbours(3x3).
	dpfm3x3Median,
	/// \brief reset the calibration, delete all internal lists.
	dpfmResetCalibration,
	/// \brief Detect defective leaky pixels within the next frame captured.
	///
	/// These are pixels that produce a higher read out value than average when the sensor is not exposed.
	dpfmCalibrateLeakyPixel,
	/// \brief Detect defective cold pixels within the next frame captured.
	///
	/// These are pixels that produce a lower read out code than average when the sensor is exposed to light.
	dpfmCalibrateColdPixel
};

//-----------------------------------------------------------------------------
/// \brief Defines valid device capabilities.
///
/// Values of these enum type may be 'OR'ed together.
enum TDeviceCapability
//-----------------------------------------------------------------------------
{
	/// \brief A dummy constant to indicate, that this device does not have any capabilities defined by other
	/// constants belonging to this enumeration.
	dcNone = 0x0,
	/// \brief This is a device that supports hotplugging.
	dcHotplugable = 0x1,
	/// \brief This is a device, that has more then one video input channel.
	dcSelectableVideoInputs = 0x2,
	/// \brief This device has non volatile memory, the user can write to and read from.
	dcNonVolatileUserMemory = 0x4,
	/// \brief This device supports camera descriptions.
	///
	/// This is a feature mainly interessting for frame grabbers.
	dcCameraDescriptionSupport = 0x8,
	/// \brief This device supports events.
	dcEventSupport = 0x10
};

//-----------------------------------------------------------------------------
/// \brief Defines valid generic device classes
enum TDeviceClass
//-----------------------------------------------------------------------------
{
	/// \brief A generic device
	dcGeneric,
	/// \brief A plain camera device
	dcCamera,
	/// \brief An intelligent camera device
	dcIntelligentCamera,
	/// \brief A frame grabber device
	dcFrameGrabber
};

//-----------------------------------------------------------------------------
/// \brief Defines grabber specific digital output modes.
enum TDeviceDigitalOutputMode
//-----------------------------------------------------------------------------
{
	/// \brief The digital output can be switched manually.
	ddomManual = 0,
	/// \brief A single pulse will be generated on the digital output.
	ddomPulse,
	/// \brief A user defined signal will be generated on the digital output.
	ddomUser,
	/// \brief The digital output will be change its state during the active exposure period
	/// of the image sensor.
	ddomExposureActive,
	/// \brief A signal connected to a digital input is passed through to this digital output.
	ddomDigitalSignalPassThrough,
	/// \brief A signal connected to a digital input is inverted and passed to this digital output.
	ddomDigitalSignalPassThroughInv,
	/// \brief An internal VD sync. signal will be passed to this digital output.
	///
	/// In case of a camera this e.g. might be the cameras internal VD signal. This then can be used to
	/// synchronize two or more cameras.
	ddomInternalVD,
	/// \brief The digital output is controlled by a <b>R</b>eal <b>T</b>ime <b>C</b>ontroller.
	ddomRealTimeController
};

//-----------------------------------------------------------------------------
/// \brief Defines valid event state.
///
/// A driver might offer to inform the user about certain events that occur
/// at runtime. This e.g. might be unpluggin the device if it's PnP compliant or
/// the detection of a digital input change.
enum TDeviceEventMode
//-----------------------------------------------------------------------------
{
	/// \brief This event won't be signalled in this state even if the underlying
	/// event has been noticed by the device driver.
	demIgnore,
	/// \brief This event will be notified whenever the underlying event
	/// has been detected by the device driver.
	demNotify
};

//-----------------------------------------------------------------------------
/// \brief Defines valid device event types.
///
/// \note
/// Not every device will support every event.
enum TDeviceEventType
//-----------------------------------------------------------------------------
{
	/// \brief A dummy constant to specify \a no event where an event type must be specified.
	detNone = 0,
	/// \brief An event of this type will be signalled (<b>if desired</b>) each time a
	/// hotplug compliant device recognized by the mvIMPACT acquire device 
	/// manager has been connected to the system.
	detPnPArrival = 0x1,
	/// \brief An event of this type will be signalled (<b>if desired</b>) each time a
	/// hotplug compliant device recognized by the mvIMPACT acquire device 
	/// manager has been disconnected to the system.
	detPnPRemoval = 0x2,
	/// \brief An event of this type will be signalled (<b>if desired</b>) each time the
	/// start of a new image has been detected by the device.
	///
	/// \note
	/// This is currently only supported by mvTITAN/mvGAMMA devices.
	detFrameStart = 0x4,
	/// \brief An event of this type will be signalled (<b>if desired</b>) each time the
	/// the histogramm is calculated.
	///
	/// \note
	/// This is currently only supported by OEM devices.
	detHistogramReady = 0x8,
	/// \brief A combination of all event types, which can be used as a mask.
	detAll = detPnPArrival | detPnPRemoval | detFrameStart | detHistogramReady
};

#ifndef IGNORE_MVGRABBER_SPECIFIC_DOCUMENTATION
	//-----------------------------------------------------------------------------
	/// \brief Defines acquisition start event if using pulse sequences.
	enum TDeviceImageTrigger
	//-----------------------------------------------------------------------------
	{
		/// \brief Acquisition starts with trigger event as fast as possible.
		ditImmediately = 0,
		/// \brief Acquisition starts after all defined signals have been generated on the digital outputs.
		ditAfterDigOutSignals
	};
#endif // IGNORE_MVGRABBER_SPECIFIC_DOCUMENTATION

//-----------------------------------------------------------------------------
/// \brief Defines valid interface layouts for the device.
///
/// The device interface layout defines what kind of features will be available
/// after the device driver has been opened and where these features will be 
/// located.
enum TDeviceInterfaceLayout
//-----------------------------------------------------------------------------
{
	/// \brief A generic interface layout shall be used.
	///
	/// This interface layout might be available when a third party hardware is
	/// (or claims to be) compliant with a certain standard and the used device
	/// driver also implements this standard. The main purpose of this interface
	/// layout is to grant access to third party devices without having in-depth
	/// information about the device.
	///
	/// As an example a device might be GenICam compliant and the device driver also
	/// implements access to a GenICam&trade; layer via a certain transport layer protocol
	/// driver (e.g. GigE Vision&trade;). In that case any third party device that
	/// is compliant with these standards can be operated using the generic interface layout.
	dilGeneric,
	/// \brief A device specific interface shall be used.
	///
	/// For most devices supported by this user API this will be the only layout
	/// available. In this interface layout also most of the features will have
	/// the same name and location for every device even if a device is operated
	/// using another device driver. However this interface layout requires the
	/// driver to have detailed information about the underlying hardware, thus
	/// it will not be avaialble for third party hardware, that can be used with
	/// this device driver.
	dilDeviceSpecific
};

//-----------------------------------------------------------------------------
/// \brief Defines valid modes for the loading of settings during initialisation.
///
/// Whenever a <b>mvIMPACT::acquire::Device</b> is initialised this enum type defines the mode the
/// <b>mvIMPACT::acquire::Device</b> tries to restore settings from a previously stored session.
enum TDeviceLoadSettings
//-----------------------------------------------------------------------------
{
	/// \brief Tries to load settings automatically following an internal procedure.
	///
	/// The load cycle at initialisation time is like this:
	///
	///\code
	/// look for a setting for this particular device (via serial number)
	/// if not found
	///   look for a setting for this device type (via string in property 'Product' )
	///   if not found
	///     look for a setting for this device family (via string in property 'Family' )
	///     if not found
	///       use the default settings
	///\endcode
	///
	/// Under Linux&reg; the current directory will be searched for files named &lt;serialNumber&gt;.xml,
	/// &lt;productString&gt;.xml and &lt;familyString.xml&gt; while under Windows&reg; the registry will
	/// be searched for keys with these names. This only happens once (when the device is opened)
	dlsAuto = 0,
	/// \brief No stored settings will be loaded at startup. The device will be
	/// initialized with the drivers default values.
	dlsNoLoad
	//, dlsFamily,
	//dlsProduct,
	//dlsCameraLocal
};

#ifndef IGNORE_MVBLUEFOX_SPECIFIC_DOCUMENTATION
	//-----------------------------------------------------------------------------
	/// \brief Defines the power mode for this device
	enum TDevicePowerMode
	//-----------------------------------------------------------------------------
	{
		/// \brief This device is switched on
		dpmOn,
		/// \brief This device is switched off.
		///
		/// This might save a considerable amount of energy if the device isn't
		/// needed for a certain amount of time.
		dpmOff
	};
#endif // #ifndef IGNORE_MVBLUEFOX_SPECIFIC_DOCUMENTATION

#ifndef IGNORE_MVGRABBER_SPECIFIC_DOCUMENTATION
	//-----------------------------------------------------------------------------
	/// \brief Scan rate mode
	enum TDeviceScanRateMode
	//-----------------------------------------------------------------------------
	{
		/// \brief Auto, scan rate of camera used.
		dsrmAuto,
		/// \brief User, scan rate must be set manually.
		dsrmUser
	};

	//-----------------------------------------------------------------------------
	/// \brief Defines valid moments to start the signal generation on the digital outputs.
	enum TDeviceSignalOutputStartEvent
	//-----------------------------------------------------------------------------
	{
		/// \brief The signal generation on the digital outputs starts with the next frame start signal ( e.g.: VSync ).
		dsoseFrame,
		/// \brief The signal generation on the digital outputs starts with the event defined in setting->camera->trigger.
		dsoseTrigger,
		/// \brief The signal generation on the digital outputs starts with next frame signal after the event defined in setting->camera->trigger.
		dsoseFrameAfterTrigger,
		/// \brief The signal generation on the digital outputs starts with the rising edge of SyncIn - signal. <b>CameraLink&reg;</b> only!!!
		dsoseSyncInRisingEdge,
		/// \brief The signal generation on the digital outputs starts with the falling edge of SyncIn - signal. <b>CameraLink&reg;</b> only!!!
		dsoseSyncInFallingEdge,
		/// \brief The SyncIn - signal is passed to the selected digital output. <b>CameraLink&reg;</b> only!!!
		dsoseSyncInPassThrough,
		/// \brief The SyncIn - signal is inverted and passed to the selected digital output. <b>CameraLink&reg;</b> only!!!
		dsoseSyncInPassThroughInv,
		/// \brief The signal generation on the digital outputs starts periodically. <b>CameraLink&reg;</b> only!!!
		dsosePeriodically,
		/// \brief The TriggerIn - signal is passed to the selected digital output. <b>CameraLink&reg;</b> only!!!
		dsoseTriggerInPassThrough,
		/// \brief The TriggerIn - signal is inverted and passed to the selected digital output. <b>CameraLink&reg;</b> only!!!
		dsoseTriggerInPassThroughInv,
		/// \brief The FVAL - signal is passed to the selected digital output. <b>CameraLink&reg;</b> only!!!
		dsoseFVALPassThrough,
		/// \brief The FVAL - signal is inverted and passed to the selected digital output. <b>CameraLink&reg;</b> only!!!
		dsoseFVALPassThroughInv,
		/// \brief The signal generation on the digital outputs starts with the rising edge of FVAL - signal. <b>CameraLink&reg;</b> only!!!
		dsoseFVALRisingEdge
	};
#endif // IGNORE_MVGRABBER_SPECIFIC_DOCUMENTATION

//-----------------------------------------------------------------------------
/// \brief Defines valid <b>Device</b> states.
enum TDeviceState
//-----------------------------------------------------------------------------
{
	/// \brief The <b>mvIMPACT::acquire::Device</b> has been unplugged.
	///
	/// The <b>mvIMPACT::acquire::Device</b> has present been since the <b>mvIMPACT::acquire::DeviceManager</b> has been initialised,
	/// but has been unplugged now and the driver has detected the unplugging of the device. Automatic detection of unplugging events
	/// is only possible for devices that support plug and play, other device drivers will only check if a device is still present
	/// if an application triggered this check.
	dsAbsent = 0,
	/// \brief The <b>mvIMPACT::acquire::Device</b> is currently connected and initialised.
	dsPresent,
	/// \brief The <b>mvIMPACT::acquire::Device</b> is connected and is currently initialising.
	dsInitializing,
	/// \brief This device is recognized, but can't be accessed currently.
	///
	/// This e.g. can be the case, if this is a device connected via a network and the device
	/// does not respond to one of the recognized network protocols or if another client is already
	/// connected to this device and the device does not support multiple clients.
	dsUnreachable,
	/// \brief This device is present, but currently switched into a low power consumption mode
	dsPowerDown
};

#ifndef IGNORE_MVGRABBER_SPECIFIC_DOCUMENTATION
	//-----------------------------------------------------------------------------
	/// \brief Valid sync. signal output modes for frame grabbers.
	///
	/// Currently only <b>mvTITAN-RGB</b> boards support this feature.
	enum TDeviceSyncOutMode
	//-----------------------------------------------------------------------------
	{
		/// \brief Sync. signals off.
		dsomOff = 0,
		/// \brief A non interlaced HD-out/VD-out signal is generated.
		dsomNonInterlaced,
		/// \brief A interlaced HD-out/VD-out signal is generated.
		dsomInterlaced
	};
#endif // IGNORE_MVGRABBER_SPECIFIC_DOCUMENTATION

//-----------------------------------------------------------------------------
/// \brief Defines which trigger interface is currently active for the device.
///
/// A device might offer different views on the properties that can be used to
/// configure trigger signals and events.
enum TDeviceTriggerInterface
//-----------------------------------------------------------------------------
{
	/// \brief The standard trigger interface.
	///
	/// When this trigger interface is used, the configuration of an external trigger
	/// signal can be done very easy. However more complex scenarios might not be
	/// possible using this view on the trigger configuration.
	dtiStandard = 0,
	/// \brief The advanced view on the trigger interface.
	///
	/// When this view on the interface is selected, all features offered by the device
	/// regarding the creation of trigger events will be visible. This allows to configure
	/// everything, but requires more knowledege about the hardware.
	dtiAdvanced
};

#ifndef IGNORE_MVGRABBER_SPECIFIC_DOCUMENTATION
	//-----------------------------------------------------------------------------
	/// \brief Valid trigger modes for grabbers.
	enum TDeviceTriggerMode
	//-----------------------------------------------------------------------------
	{
		/// \brief Trigger off
		dtmOff = 0,
		/// \brief Trigger on
		dtmOn,
		/// \brief Trigger on falling edge of an external signal.
		dtmFallingEdge,
		/// \brief Trigger on rising edge of an external signal.
		dtmRisingEdge,
		/// \brief Timer is used to simulate trigger.
		dtmPeriodically,
		/// \brief Request simulates trigger.
		dtmOnDemand,
		/// \brief Line scan mode: Acquisition starts with rising edge and stops with falling edge of trigger ( mvTITAN/mvGAMMA-CL only )
		dtmStartRisingStopFalling,
		/// \brief Line scan mode: Acquisition starts with falling edge and stops with rising edge of trigger ( mvTITAN/mvGAMMA-CL only )
		dtmStartFallingStopRising,
		/// \brief Trigger valid as long as the level of the source signal is high.
		dtmLevelHigh,
		/// \brief Trigger valid as long as the level of the source signal is low.
		dtmLevelLow
	};
#endif // IGNORE_MVGRABBER_SPECIFIC_DOCUMENTATION

//-----------------------------------------------------------------------------
/// \brief Specifies the type trigger overlap permitted with the previous frame.
///
/// This defines when a valid trigger will be accepted (or latched) for a new frame.
enum TDeviceTriggerOverlap
//-----------------------------------------------------------------------------
{
	/// \brief No trigger overlap is permitted.
	dtoOff,
	/// \brief Trigger is accepted immediately after the exposure period.
	dtoReadOut,
	/// \brief Trigger is accepted at any time during the capture of the previous frame.
	dtoPreviousFrame
};

//-----------------------------------------------------------------------------
/// \brief Defines valid digital I/O states.
enum TDigIOState
//-----------------------------------------------------------------------------
{
	/// \brief Digital I/O is in 'logic 0' state.
	digioOff = 0,
	/// \brief Digital I/O is in 'logic 1' state.
	digioOn = 1,
	/// \brief Digital Input is in 'ignore' state.
	digioIgnore = 2,
	/// \brief Digital Output is kept in unchanged state.
	digioKeep = 3
};

#ifndef IGNORE_MVGRABBER_SPECIFIC_DOCUMENTATION
	//-----------------------------------------------------------------------------
	/// \brief Defines valid ways to create signals on a digital output.
	enum TDigitalOutputControlMode
	//-----------------------------------------------------------------------------
	{
		/// \brief The digital output signal is generated by the onboard processor.
		docmSoftware = 0,
		/// \brief The digital output signal is generated by a <b>R</b>eal <b>T</b>ime <b>C</b>ontroller
		/// that is part of the used hardware device.
		docmRTC
	};

	//-----------------------------------------------------------------------------
	/// \brief Defines valid digital source signal constants that can be used to
	/// configure a devices behaviour in certain digital I/O related modes.
	///
	/// As these parameters are highly device dependent, no direct name like
	/// \a dsTriggerJ8/12 are defined here. However when the translation dictionary for
	/// a property with this type is queried, the string representation for the
	/// enum value will contain a more descriptive name for the digital signal.
	enum TDigitalSignal
	//-----------------------------------------------------------------------------
	{
		/// \brief A dummy value to undefine a mask or signal configuration.
		dsNone = 0x00000000,
		/// \brief A constant for digital signal 1.
		dsSignal1 = 0x00000001,
		/// \brief A constant for digital signal 2.
		dsSignal2 = 0x00000002,
		/// \brief A constant for digital signal 3.
		dsSignal3 = 0x00000004,
		/// \brief A constant for digital signal 4.
		dsSignal4 = 0x00000008,
		/// \brief A constant for digital signal 5.
		dsSignal5 = 0x00000010,
		/// \brief A constant for digital signal 6.
		dsSignal6 = 0x00000020,
		/// \brief A constant for digital signal 7.
		dsSignal7 = 0x00000040,
		/// \brief A constant for digital signal 8.
		dsSignal8 = 0x00000080,
		/// \brief A constant for digital signal 9.
		dsSignal9 = 0x00000100,
		/// \brief A constant for digital signal 10.
		dsSignal10 = 0x00000200,
		/// \brief A constant for digital signal 11.
		dsSignal11 = 0x00000400,
		/// \brief A constant for digital signal 12.
		dsSignal12 = 0x00000800,
		/// \brief A constant for digital signal 13.
		dsSignal13 = 0x00001000,
		/// \brief A constant for digital signal 14.
		dsSignal14 = 0x00002000,
		/// \brief A constant for digital signal 15.
		dsSignal15 = 0x00004000,
		/// \brief A constant for digital signal 16.
		dsSignal16 = 0x00008000
	};
#endif // #ifndef IGNORE_MVGRABBER_SPECIFIC_DOCUMENTATION

//-----------------------------------------------------------------------------
/// \brief Errors reported by the device manager.
///
/// These are errors which might occur in connection with the device manager
/// itself or while working with the single devices.
enum TDMR_ERROR // no_property_type
//-----------------------------------------------------------------------------
{
	/// \brief The function call was executed successfully.
	DMR_NO_ERROR = 0,
	/// \brief A dummy constant to mark the first valid error code for device and device
	/// manager related errors.
	DMR_FIRST_ERROR_CODE = -2100,
	/// \brief the specified device can't be found.
	///
	/// This error occurs either if an invalid device ID has been passed to the
	/// device manager or if the caller tried to close a device which currently
	/// isn't initialised.
	DMR_DEV_NOT_FOUND = DMR_FIRST_ERROR_CODE,
	/// \brief The device manager couldn't be initialised.
	///
	/// This is an internal error.
	DMR_INIT_FAILED = -2101,
	/// \brief The device is already in use.
	///
	/// This error will occur if this or another process has initialized this
	/// device already and an application tries to open the device once more.
	DMR_DRV_ALREADY_IN_USE = -2102,
	/// \brief The specified device couldn't be initialised.
	DMR_DEV_CANNOT_OPEN = -2103,
	/// \brief The device manager or another module hasn't been initialised properly.
	///
	/// This error occurs if the user tries e.g. to close the device manager without
	/// having initialised it before or if a library used internally has not been initialised properly.
	DMR_NOT_INITIALIZED = -2104,
	/// \brief A device could not be initialised.
	///
	/// In this case the log-file will contain detailed information about the source of the
	/// problem.
	DMR_DRV_CANNOT_OPEN = -2105,
	/// \brief The devices request queue is empty.
	///
	/// This error e.g. occurs if the user waits for an image request to become available at a
	/// result queue without having send an image request to the device before.
	///
	/// It might also arise when trying to trigger an image with a software trigger mechanism
	/// before the acquisition engine has been completely started. In this case a small delay and
	/// then again calling the software trigger function will succeed.
	DMR_DEV_REQUEST_QUEUE_EMPTY = -2106,
	/// \brief A request object couldn't be created.
	///
	/// The creation of a request object failed. This might e.g. happen, if the system
	/// runs extremely low on memory.
	DMR_DEV_REQUEST_CREATION_FAILED = -2107,
	/// \brief An invalid parameter has been passed to a function.
	///
	/// This might e.g. happen if a function requiring a pointer to a structure has been passed
	/// an unassigned pointer or if a value has been passed, that is either too large or too small in
	/// that context.
	DMR_INVALID_PARAMETER = -2108,
	/// \brief One or more symbols needed in a detected driver library couldn't be resolved.
	///
	/// In most cases this is an error handled internally. So the user will not receive this error
	/// code as a result of a call to an API function. However when the user tries to get access
	/// to an <b>IMPACT</b> buffer type while the needed <b>IMPACT Base libraries</b> are not installed
	/// on the target system this error code also might be returned to the user.
	DMR_EXPORTED_SYMBOL_NOT_FOUND = -2109,
	/// \brief An unknown error occurred while processing a user called
	/// driver function.
	DEV_UNKNOWN_ERROR = -2110,
	/// \brief A driver function has been called with an invalid device handle.
	DEV_HANDLE_INVALID = -2111,
	/// \brief A driver function has been called but one or more of the input
	/// parameters are invalid.
	///
	/// Threre are several possible reasons for this error:
	/// - an unassigned pointer has been passed to a function, that requires a valid pointer
	/// - one or more of the passed parameters are of an incorrect type
	/// - one or more parameters contain an invalid value (e.g. a filename that points to a file that can't
	/// be found, a value, that is larger or smaller then the allowed values.
	DEV_INPUT_PARAM_INVALID = -2112,
	/// \brief A function has been called with an invalid number of input parameters.
	DEV_WRONG_INPUT_PARAM_COUNT = -2113,
	/// \brief The creation of a setting failed.
	///
	/// This can either happen, when a setting with the same name as the one the user
	/// tried to create already exists or if the system can't allocate memory for the
	/// new setting.
	DEV_CREATE_SETTING_FAILED = -2114,
	/// \brief <b>DEPRECATED</b>! Use <b>mvIMPACT::acquire::DEV_REQUEST_CANT_BE_UNLOCKED</b> instead.
	DEV_REQUEST_CANT_UNLOCKED = -2115,
	/// \brief The unlock for a <b>mvIMPACT::acquire::Request</b> object failed.
	///
	/// This might happen, if the <b>mvIMPACT::acquire::Request</b> is
	/// not locked at the time of calling the unlock function. It either has been unlocked by the
	/// user already or this request has never been locked as the request so far has not been used to
	/// capture image data into its buffer. Another reason for this error might be that the user tries to
	/// unlock a request that is currently processed by the device driver.
	DEV_REQUEST_CANT_BE_UNLOCKED = -2115,
	/// \brief The number for the <b>mvIMPACT::acquire::Request</b> object is invalid.
	///
	/// The max. number for a <b>mvIMPACT::acquire::Request</b> object is
	/// the value of the property \a RequestCount in the <b>SystemBase</b> list - 1.
	DEV_INVALID_REQUEST_NUMBER = -2116,
	/// \brief A Request that hasn't been unlocked has been passed back to the driver.
	///
	/// This error might occur if the user requested an image from the driver but hasn't
	/// unlocked the <b>mvIMPACT::acquire::Request</b> that will be used for this new
	/// image.
	DEV_LOCKED_REQUEST_IN_QUEUE = -2117,
	/// \brief The user requested a new image, but no free <b>mvIMPACT::acquire::Request</b>
	/// object is available to process this request.
	DEV_NO_FREE_REQUEST_AVAILABLE = -2118,
	/// \brief The wait for a request failed.
	///
	/// This might have several reasons:
	///
	/// - the user waited for an image, but no image has been requested before.
	/// - the user waited for a requested image, but the image is still not ready(e.g. because of
	/// a short timeout and a long exposure time).
	/// - a triggered image has been requested but no trigger signal has been detected within the
	/// wait period.
	/// - a plug and play device(e.g. an USB device) has been unplugged an therefore can't deliver
	/// images anymore. In this case the \a 'state' property should be checked to find out if the
	/// device is still present or not.
	DEV_WAIT_FOR_REQUEST_FAILED = -2119,
	/// \brief The user tried to get/set a parameter, which is not supported by this device.
	DEV_UNSUPPORTED_PARAMETER = -2120,
	/// \brief The requested real time controller is not available for this device.
	DEV_INVALID_RTC_NUMBER = -2121,
	/// \brief Some kind of internal error occurred.
	///
	/// More information can be found in the *.log-file or the debug output.
	DMR_INTERNAL_ERROR = -2122,
	/// \brief The user allocated input buffer is to small to accommodate the result.
	DMR_INPUT_BUFFER_TOO_SMALL = -2123,
	/// \brief Some kind of internal error occurred in the device driver.
	///
	/// More information can be found in the *.log-file or the debug output.
	DEV_INTERNAL_ERROR = -2124,
	/// \brief One or more needed libraries are not installed on the system.
	DMR_LIBRARY_NOT_FOUND = -2125,
	/// \brief The called function is not available for this device.
	DMR_FUNCTION_NOT_IMPLEMENTED = -2126,
	/// \brief The feature in question is not available for this device or driver.
	///
	/// More information can be found in the *.log-file or the debug output.
	DMR_FEATURE_NOT_AVAILABLE = -2127,
	/// \brief The user is not permitted to perform the requested operation.
	///
	/// This e.g. might happen if the user tried to delete user data without specifying the
	/// required password.
	DMR_EXECUTION_PROHIBITED = -2128,
	/// \brief The specified file can't be found.
	///
	/// This might e.g. happen if the current working directory doesn't contain the file specified.
	DMR_FILE_NOT_FOUND = -2129,
	/// \brief The licence doesn't match the device it has been assigned to.
	///
	/// When e.g. upgrading a device feature each licence file is bound to a certain device. If the
	/// device this file has been assigned to has a different serial number then the one used
	/// to create the licence this error will occur.
	DMR_INVALID_LICENCE = -2130,
	/// \brief There is no sensor found or the found sensor type is wrong or not supported.
	DEV_SENSOR_TYPE_ERROR = -2131,
	/// \brief A function call was associated with a camera description, that is invalid.
	///
	/// One possible reason might be, that the camera description has been deleted(driver closed?).
	DMR_CAMERA_DESCRIPTION_INVALID = -2132,
	/// \brief A suitable driver library to work with the device manager has been detected, but
	/// it is too old to work with this version of the mvDeviceManager library.
	///
	/// This might happen if two different drivers have been installed on the target system and
	/// one introduces a newer version of the device manager that is not compatible with the older
	/// driver installed on the system. In this case this error message will be written into the
	/// log-file together with the name of the library that is considered to be too old.
	///
	/// The latest drivers will always be available online under <b>www.matrix-vision.de</b>. There
	/// will always be an updated version of the library considered to be too old for download from
	/// here.
	DMR_NEWER_LIBRARY_REQUIRED = -2133,
	/// \brief A general timeout occurred.
	///
	/// This is the typical result of functions that wait for some condition to be met with a timeout
	/// amoung their parameters.
	DMR_TIMEOUT = -2134,
	/// \brief A wait operation has been aborted.
	///
	/// This e.g. might occurr if the user waited for some message to be returned by the driver and the
	/// device driver is closed within another thread. In order to inform the user that this waiting operation
	/// terminated in an unusual wait, \a DMR_WAIT_ABANDONED will be returned then.
	DMR_WAIT_ABANDONED = -2135,
	/// \brief The execution of a method object failed.
	///
	/// More information can be found in the log-file.
	DMR_EXECUTION_FAILED = -2136,
	/// \brief This request is currently used by the driver
	///
	/// This error may occurr if the user tries to send a certain request object to the driver by a call to the
	/// corresponding image request function.
	DEV_REQUEST_ALREADY_IN_USE = -2137,
	/// \brief A request has been configured to use a user supplied buffer, but the buffer pointer associated with
	/// the request is invalid.
	DEV_REQUEST_BUFFER_INVALID = -2138,
	/// \brief A request has been configured to use a user supplied buffer, but the buffer pointer associated with
	/// the request has an incorrect alignment.
	///
	/// Certain devices need aligned memory to perform efficiently thus when a user supplied buffer shall be used to
	/// capture data into this buffer must follow these alignment constraints
	DEV_REQUEST_BUFFER_MISALIGNED = -2139,
	/// \brief The requested access to a device could not be granted.
	///
	/// This might e.g. happen if an application tries to access a device exclusively that is already open in another
	/// process. This could also happen if a network device has already been opened by another computer.
	DEV_ACCESS_DENIED = -2140,
	/// \brief A preload condition for loading a device driver failed.
	///
	/// Certain device drivers may depent on certain changes applied to the system in order to operate correctly.
	/// E.g. a device driver might need a certain environment variable to exist. When the device manager tries
	/// to load a device driver it performs some basic checks to detect problems like this. When one of these checks
	/// fails the device manager will not try to load the device driver and an error message will be written
	/// to the selected log outputs.
	DMR_PRELOAD_CHECK_FAILED = -2141,
	/// \brief One or more of the camera descriptions parameters are invalid for the grabber it is used with.
	///
	/// There are multiple reasons for this error code. Detailed information can be found in the *.log-file.
	///
	/// <b>POSSIBLE CAUSES:</b>
	/// 
	/// - The TapsXGeometry or TapsYGeometry parameter of the selected camera description cannot be used with a user defined AOI.
	/// - A scan standard has been selected, that is not supported by this device.
	/// - An invalid scan rate has been selected.
	/// - ...
	///
	/// This error code will be returned by frame grabbers only.
	DMR_CAMERA_DESCRIPTION_INVALID_PARAMETER = -2142,
	/// \brief A general error returned whenever there has been a problem with accessing a file.
	///
	/// There can be multiple reasons for this error and a detailed error message will be send to the log-output
	/// whenever this error code is returned.
	///
	/// <b>POSSIBLE CAUSES:</b>
	/// 
	/// - The driver tried to modify a file, for which it has no write access
	/// - The driver tried to read from a file, for which it has no read access
	/// - ...
	DMR_FILE_ACCESS_ERROR = -2143,

	// If new error codes must be added this happens HERE!
	// When adding a new value here NEVER forget to update the internal string AND/OR exception table!
#if !defined(DOXYGEN_SHOULD_SKIP_THIS) && !defined(WRAP_ANY) && !defined(WRAP_DOTNET)
	/// \brief Needed for compile time checks for invalid error code values
	DMR_PSEUDO_LAST_ASSIGNED_ERROR_CODE,
	/// \brief A dummy constant to mark the last valid error code for device and device manager 
	/// related errors.
	DMR_LAST_ASSIGNED_ERROR_CODE = DMR_PSEUDO_LAST_ASSIGNED_ERROR_CODE - 2,
#endif // #if !defined(DOXYGEN_SHOULD_SKIP_THIS) && !defined(WRAP_ANY) && !defined(WRAP_DOTNET)
	/// \brief Defines the last valid error code value for device and device manager 
	/// related errors.
	DMR_LAST_VALID_ERROR_CODE = -2199
};

#ifndef IGNORE_MVGRABBER_SPECIFIC_DOCUMENTATION
	//-----------------------------------------------------------------------------
	/// \brief The fieldgate is used to detect the field ( odd or even ) for interlaced videosignals.
	enum TFieldGateMode
	//-----------------------------------------------------------------------------
	{
		/// \brief Fieldgate starts at 1/3 of a line and ends at 2/3 of a line.
		efmAuto,
		/// \brief FieldGateStart and FieldGateWidth can be set in pixels.
		efmUser
	};
#endif // IGNORE_MVGRABBER_SPECIFIC_DOCUMENTATION

//-----------------------------------------------------------------------------
/// \brief Defines a certain filter type. Currently unsupported.
enum TFilterType
//-----------------------------------------------------------------------------
{
	/// \brief Currently unsupported.
	ftBayer = 0
};

//-----------------------------------------------------------------------------
/// \brief Defines valid modes for the flat field filter.
enum TFlatFieldFilterMode
//-----------------------------------------------------------------------------
{
	/// \brief The filter is switched off.
	fffmOff = 0,
	/// \brief The filter is switched on.
	fffmOn,
	/// \brief The next frame will be taken as flat field.
	fffmCalibrateFlatField
#if !defined(DOXYGEN_SHOULD_SKIP_THIS) && !defined(WRAP_ANY) && !defined(WRAP_DOTNET)
	// for internal use only
	, fffmLastFlatFieldFilterMode
#endif // #if !defined(DOXYGEN_SHOULD_SKIP_THIS) && !defined(WRAP_ANY) && !defined(WRAP_DOTNET)
};

//-----------------------------------------------------------------------------
/// \brief Defines valid <b>Device</b> HW update results.
///
/// This defines valid result e.g. of a user executed firmware update.
enum THWUpdateResult
//-----------------------------------------------------------------------------
{
	/// \brief No update has been performed for this <b>mvIMPACT::acquire::Device</b>.
	///
	/// No update has been performed in the current process since this device driver 
	/// has been loaded in the current process address space.
	urNoUpdatePerformed = 0,
	/// \brief <b>DEPRECATED</b>! Use <b>mvIMPACT::acquire::urNoUpdatePerformed</b>
	urNothing = urNoUpdatePerformed,
	/// \brief The <b>mvIMPACT::acquire::Device</b> is currently updating firmware.
	urUpdateFW,
	/// \brief The <b>mvIMPACT::acquire::Device</b> indicates an error during updating firmware.
	urUpdateFWError,
	/// \brief The requested update couldn't be performed as the device is already in use.
	///
	/// If another (or even the same) process uses the device, this hardware update can't be performed.
	/// To perform the requested update this device needs to be closed.
	urDevAlreadyInUse,
	/// \brief The <b>mvIMPACT::acquire::Device</b> indicates that the firmware has been updated successfully.
	urUpdateFWOK,
	/// \brief The <b>mvIMPACT::acquire::Device</b> is currently setting device ID.
	urSetDevID,
	/// \brief The <b>mvIMPACT::acquire::Device</b> signalled an error when setting device ID.
	urSetDevIDError,
	/// \brief An invalid device ID has been specified.
	///
	/// Valid device ID lie within 0 and 250 including the upper and lower limit.
	urSetDevIDInvalidID,
	/// \brief The <b>mvIMPACT::acquire::Device</b> has successfully been assigned a new ID.
	urSetDevIDOK,
	/// \brief Size Error in writing User Data to <b>mvIMPACT::acquire::Device</b> .
	urSetUserDataSizeError,
	/// \brief Write Error in writing User Data to <b>mvIMPACT::acquire::Device</b> .
	urSetUserDataWriteError,
	/// \brief Writing user data to <b>mvIMPACT::acquire::Device</b> was successful.
	urSetUserDataWriteOK,
	/// \brief Reading user data from an <b>mvIMPACT::acquire::Device</b> failed.
	urGetUserDataReadError,
	/// \brief The <b>mvIMPACT::acquire::Device</b> indicates an error during verifying firmware.
	urVerifyFWError,
	/// \brief The <b>mvIMPACT::acquire::Device</b> indicates that the firmware has been verified successfully.
	urVerifyFWOK
};

//-----------------------------------------------------------------------------
/// \brief Valid image buffer pixel formats.
enum TImageBufferPixelFormat
//-----------------------------------------------------------------------------
{
	/// \brief An unprocessed block of data.
	ibpfRaw = 0,
	/// \brief A single channel 8 bit per pixel format.
	ibpfMono8 = 1,
	/// \brief A single channel 16 bit per pixel format.
	ibpfMono16 = 2,
	/// \brief A three channel RGB image with 32 bit per pixel containing one fill byte per pixel.
	///
	/// This is an interleaved pixel format suitable for most display functions. The data
	/// is stored pixel-wise. When accessed 4-byte wise the data layout in memory can be
	/// interpreted like this (starting with the MSB):
	///
	///\code
	/// 4 bytes             4 bytes             etc.
	/// B(1) G(1) R(1) A(1) B(2) G(2) R(2) A(2) etc.
	/// .......................................
	///                     B(n) G(n) R(n) A(n)
	///\endcode
	///
	/// <b>ImageBuffer::vpData</b> will point to B1 when using a byte pointer. When working with a
	/// 32 bit size pointer, the LSB of the dereferenced pointer will contain the blue component of the
	/// pixel.
	ibpfRGBx888Packed = 3,
	/// \brief This is a YUV422 packed image with 32 bit for a pair of pixels.
	///
	/// This format uses 2:1 horizontal downsampling, which means that the Y component is
	/// sampled at each pixel, while U(Cb) and V(Cr) components are sampled every 2 pixels in
	/// horizontal direction. If each component takes 8 bits, the pair of pixels requires 32 bits.
	///
	/// Two consecutive pixels (32 bit, 0xaabbccdd ) contain 8 bit luminance of pixel 1(aa),
	/// 8 bit chrominance blue of pixel 1 and 2(bb), 8 bit luminance of pixel 2(cc) and finally 8 bit chrominance red of pixels 1 and 2(dd).
	///
	/// Thus in memory the data will be stored like this:
	///
	///\code
	/// 4 bytes                   4 bytes                         etc.
	/// Y(1) Cb(1,2) Y(2) Cr(1,2) Y(3)   Cb(3,4)   Y(4) Cr(3,4)   etc.
	/// ..........................Y(n-1) Cb(n-1,n) Y(n) Cr(n-1,n)
	///\endcode
	///
	/// <b>ImageBuffer::vpData</b> will point to Y(1).
	ibpfYUV422Packed = 4,
	/// \brief The image will be transferred as an RGB image in planar format.
	///
	/// This is a format best suitable for most image processing functions.
	/// The image will be converted into four planes(a plane for each color component and one
	/// alpha plane).
	///
	///\code
	/// R(1) R(2) R(3) R(4) etc.
	/// ...................
	/// .............. R(n)
	/// G(1) G(2) G(3) G(4) etc.
	/// ...................
	/// .............. G(n)
	/// B(1) B(2) B(3) B(4) etc.
	/// ...................
	/// .............. B(n)
	/// A(1) A(2) A(3) A(4) etc.
	/// ...................
	/// .............. A(n)
	///\endcode
	///
	/// <b>ImageBuffer::vpData</b> will point to R(1).
	ibpfRGBx888Planar = 5,
	/// \brief A single channel 10 bit per pixel format.
	ibpfMono10 = 6,
	/// \brief A single channel 12 bit per pixel format.
	ibpfMono12 = 7,
	/// \brief A single channel 14 bit per pixel format.
	ibpfMono14 = 8,
	/// \brief The image will be transferred as an RGB image with 24 bit per pixel.
	///
	/// This is an interleaved pixel format suitable for most display and processing functions.
	/// The data is stored pixel-wise:
	///
	///\code
	/// 3 bytes        3 bytes        3 bytes      etc.
	/// B(1)G(1)R(1)   B(2)G(2)R(2)   B(3)G(3)R(3) etc.
	/// ..........................................
	/// ...........................   B(n)G(n)R(n)
	///\endcode
	///
	/// <b>ImageBuffer::vpData</b> will point to B(1) when using a byte pointer. When working with a
	/// 32 bit size pointer, the LSB of the dereferenced pointer will contain the blue component of the
	/// first pixel, the MSB will contain the blue component of the second pixel (0xB2R1G1B1).
	ibpfRGB888Packed = 9,
	/// \brief This is a YUV444 planar image with 24 bit per pixels.
	///
	/// A planar YUV format. In memory the data will be stored plane-wise like this:
	///
	///\code
	/// Y(1)    Y(2)    Y(3)    Y(4) etc.
	/// ............................
	/// ..............  Y(n-1)  Y(n)
	/// Cr(1)   Cr(2)   Cr(3)   Cr(4) etc.
	/// ............................
	/// ..............  Cr(n-1) Cr(n)
	/// Cb(1)   Cb(2)   Cb(3)   Cb(4) etc.
	/// ............................
	/// .............   Cb(n-1) Cb(n)
	///\endcode
	///
	/// <b>ImageBuffer::vpData</b> will point to Y(1).
	ibpfYUV444Planar = 10,
	/// \brief A single channel 32 bit per pixel format.
	ibpfMono32 = 11,
	/// \brief This is a YUV422 planar image with 32 bit for a pair of pixels.
	///
	/// This format uses 2:1 horizontal downsampling, which means that the Y component is
	/// sampled at each pixel, while U(Cb) and V(Cr) components are sampled every 2 pixels in
	/// horizontal direction. If each component takes 8 bits, the pair of pixels requires 32 bits.
	///
	/// In memory the data will be stored like this:
	///
	///\code
	/// Y(1)    Y(2)    Y(3)    Y(4) etc.
	/// ............................
	/// ..............  Y(n-1)  Y(n)
	/// Cr(1,2) Cr(3,4) etc.
	/// ...............
	/// ....... Cr(n/2)
	/// Cb(1,2) Cb(3,4) etc.
	/// ...............
	/// ....... Cb(n/2)
	///\endcode
	///
	/// Thus the Y planes size in bytes equals the sum of the 2 other planes.
	///
	/// <b>ImageBuffer::vpData</b> will point to Y(1).
	ibpfYUV422Planar = 12,
	/// \brief The image will be transferred as an RGB image with 30 bit of 
	/// usable data per pixel.
	///
	/// This is an interleaved pixel format with 2 bytes per color component.
	/// The data is stored pixel-wise:
	///
	///\code
	/// 6 bytes        6 bytes        6 bytes      etc.
	/// B(1)G(1)R(1)   B(2)G(2)R(2)   B(3)G(3)R(3) etc.
	/// ..........................................
	/// ...........................   B(n)G(n)R(n)
	///\endcode
	///
	/// The data of each color component will be LSB aligned, thus the 6 MSB of each 16 bit will
	/// not contain valid data.
	///
	/// <b>ImageBuffer::vpData</b> will point to B(1) when using a 16 bit pointer.
	ibpfRGB101010Packed = 13,
	/// \brief The image will be transferred as an RGB image with 36 bit of 
	/// usable data per pixel.
	///
	/// This is an interleaved pixel format with 2 bytes per color component.
	/// The data is stored pixel-wise:
	///
	///\code
	/// 6 bytes        6 bytes        6 bytes      etc.
	/// B(1)G(1)R(1)   B(2)G(2)R(2)   B(3)G(3)R(3) etc.
	/// ..........................................
	/// ...........................   B(n)G(n)R(n)
	///\endcode
	///
	/// The data of each color component will be LSB aligned, thus the 4 MSB of each 16 bit will
	/// not contain valid data.
	///
	/// <b>ImageBuffer::vpData</b> will point to B(1) when using a 16 bit pointer.
	ibpfRGB121212Packed = 14,
	/// \brief The image will be transferred as an RGB image with 42 bit of 
	/// usable data per pixel.
	///
	/// This is an interleaved pixel format with 2 bytes per color component.
	/// The data is stored pixel-wise:
	///
	///\code
	/// 6 bytes        6 bytes        6 bytes      etc.
	/// B(1)G(1)R(1)   B(2)G(2)R(2)   B(3)G(3)R(3) etc.
	/// ..........................................
	/// ...........................   B(n)G(n)R(n)
	///\endcode
	///
	/// The data of each color component will be LSB aligned, thus the 2 MSB of each 16 bit will
	/// not contain valid data.
	///
	/// <b>ImageBuffer::vpData</b> will point to B(1) when using a 16 bit pointer.
	ibpfRGB141414Packed = 15,
	/// \brief The image will be transferred as an RGB image with 48 bit of 
	/// usable data per pixel.
	///
	/// This is an interleaved pixel format with 2 bytes per color component.
	/// The data is stored pixel-wise:
	///
	///\code
	/// 6 bytes        6 bytes        6 bytes      etc.
	/// B(1)G(1)R(1)   B(2)G(2)R(2)   B(3)G(3)R(3) etc.
	/// ..........................................
	/// ...........................   B(n)G(n)R(n)
	///\endcode
	///
	/// The data of each color component will be LSB aligned.
	///
	/// <b>ImageBuffer::vpData</b> will point to B(1) when using a 16 bit pointer.
	ibpfRGB161616Packed = 16,
	/// \brief This is a YUV422 packed image with 32 bit for a pair of pixels.
	///
	/// This format uses 2:1 horizontal downsampling, which means that the Y component is
	/// sampled at each pixel, while U(Cb) and V(Cr) components are sampled every 2 pixels in
	/// horizontal direction. If each component takes 8 bits, the pair of pixels requires 32 bits.
	///
	/// Two consecutive pixels (32 bit, 0xaabbccdd ) will contain 8 bit chrominance blue of pixel 1 and 2(aa),
	/// 8 bit luminance of pixel 1(bb), 8 bit chrominance red of pixel 1 and 2 (cc) and finally 8 bit luminance of pixel 2(dd).
	///
	/// Thus in memory the data will be stored like this:
	///
	///\code
	/// 4 bytes                   4 bytes                         etc.
	/// Cb(1,2) Y(1) Cr(1,2) Y(2) Cb(3,4)   Y(3)   Cr(3,4)   Y(4)    etc.
	/// ..........................Cb(n-1,n) Y(n-1) Cr(n-1,n) Y(n)
	///\endcode
	///
	/// <b>ImageBuffer::vpData</b> will point to Cb(1,2).
	ibpfYUV422_UYVYPacked = 17,
#if !defined(DOXYGEN_SHOULD_SKIP_THIS) && !defined(WRAP_ANY) && !defined(WRAP_DOTNET)
	ibpfLAST,
	ibpfCUSTOM = 0x80000000,
	MV_CUSTOM_IMAGE_BUFFER_PIXEL_FORMATS
#endif // #if !defined(DOXYGEN_SHOULD_SKIP_THIS) && !defined(WRAP_ANY) && !defined(WRAP_DOTNET)
	/// \brief The driver will decide which format will be used.
	ibpfAuto = 0xFFFFFFFF
};

//-----------------------------------------------------------------------------
/// \brief Defines the pixel format of the result image.
enum TImageDestinationPixelFormat
//-----------------------------------------------------------------------------
{
	/// \brief The driver will decide which destination format will be used.
	idpfAuto = 0,
	/// \brief The image will be transferred as an unprocessed block of data.
	idpfRaw = 1,
	/// \brief The image will be transferred as a mono channel 8 bit per pixel image.
	idpfMono8 = 2,
	/// \brief The image will be transferred as an RGB image with 32 bit per pixel containing one fill byte per pixel.
	///
	/// This is an interleaved pixel format suitable for most display functions. The data
	/// is stored pixel-wise. When accessed 4-byte wise the data layout in memory can be
	/// interpreted like this (starting with the MSB):
	///
	///\code
	/// 4 bytes             4 bytes             etc.
	/// B(1) G(1) R(1) A(1) B(2) G(2) R(2) A(2) etc.
	/// .......................................
	///                     B(n) G(n) R(n) A(n)
	///\endcode
	///
	/// <b>ImageBuffer::vpData</b> will point to B1 when using a byte pointer. When working with a
	/// 32 bit size pointer, the LSB of the dereferenced pointer will contain the blue component of the
	/// pixel.
	idpfRGBx888Packed = 3,
	/// \brief This is a YUV422 packed image with 32 bit for a pair of pixels.
	///
	/// This format uses 2:1 horizontal downsampling, which means that the Y component is
	/// sampled at each pixel, while U(Cb) and V(Cr) components are sampled every 2 pixels in
	/// horizontal direction. If each component takes 8 bits, the pair of pixels requires 32 bits.
	///
	/// Two consecutive pixels (32 bit, 0xaabbccdd ) contain 8 bit luminance of pixel 1(aa),
	/// 8 bit chrominance blue of pixel 1 and 2(bb), 8 bit luminance of pixel 2(cc) and finally 8 bit chrominance red of pixels 1 and 2(dd).
	///
	/// Thus in memory the data will be stored like this:
	///
	///\code
	/// 4 bytes                   4 bytes                         etc.
	/// Y(1) Cb(1,2) Y(2) Cr(1,2) Y(3)   Cb(3,4)   Y(4) Cr(3,4)   etc.
	/// ..........................Y(n-1) Cb(n-1,n) Y(n) Cr(n-1,n)
	///\endcode
	///
	/// <b>ImageBuffer::vpData</b> will point to Y(1).
	idpfYUV422Packed = 4,
	/// \brief The image will be transferred as an RGB image in planar format.
	///
	/// This is a format best suitable for most image processing functions.
	/// The image will be converted into four planes(a plane for each color component and one
	/// alpha plane).
	///
	///\code
	/// R(1) R(2) R(3) R(4) etc.
	/// ...................
	/// .............. R(n)
	/// G(1) G(2) G(3) G(4) etc.
	/// ...................
	/// .............. G(n)
	/// B(1) B(2) B(3) B(4) etc.
	/// ...................
	/// .............. B(n)
	/// A(1) A(2) A(3) A(4) etc.
	/// ...................
	/// .............. A(n)
	///\endcode
	///
	/// <b>ImageBuffer::vpData</b> will point to R(1).
	idpfRGBx888Planar = 5,
	/// \brief The image will be transferred as a mono channel 10 bit per pixel image.
	idpfMono10 = 6,
	/// \brief The image will be transferred as a mono channel 12 bit per pixel image.
	idpfMono12 = 7,
	/// \brief The image will be transferred as a mono channel 14 bit per pixel image.
	idpfMono14 = 8,
	/// \brief The image will be transferred as a mono channel 16 bit per pixel image.
	idpfMono16 = 9,
	/// \brief The image will be transferred as an RGB image with 24 bit per pixel.
	///
	/// This is an interleaved pixel format suitable for most display and processing functions.
	/// The data is stored pixel-wise:
	///
	///\code
	/// 3 bytes        3 bytes        3 bytes      etc.
	/// B(1)G(1)R(1)   B(2)G(2)R(2)   B(3)G(3)R(3) etc.
	/// ..........................................
	/// ...........................   B(n)G(n)R(n)
	///\endcode
	///
	/// <b>ImageBuffer::vpData</b> will point to B(1) when using a byte pointer. When working with a
	/// 32 bit size pointer, the LSB of the dereferenced pointer will contain the blue component of the
	/// first pixel, the MSB will contain the blue component of the second pixel (0xB2R1G1B1).
	idpfRGB888Packed = 10,
	/// \brief The image will be transferred as a YUV422 image with 16 bit per pixel.
	///
	/// This format uses 2:1 horizontal downsampling, which means that the Y component is
	/// sampled at each pixel, while U(Cb) and V(Cr) components are sampled every 2 pixels in
	/// horizontal direction. If each component takes 8 bits, the pair of pixels requires 32 bits.
	///
	/// In memory the data will be stored like this:
	///
	///\code
	/// Y(1)    Y(2)    Y(3)    Y(4) etc.
	/// ............................
	/// ..............  Y(n-1)  Y(n)
	/// Cr(1,2) Cr(3,4) etc.
	/// ...............
	/// ....... Cr(n/2)
	/// Cb(1,2) Cb(3,4) etc.
	/// ...............
	/// ....... Cb(n/2)
	///\endcode
	///
	/// Thus the Y planes size in bytes equals the sum of the 2 other planes.
	///
	/// <b>ImageBuffer::vpData</b> will point to Y(1).
	idpfYUV422Planar = 13,
	/// \brief The image will be transferred as an RGB image with 30 bit of 
	/// usable data per pixel.
	///
	/// This is an interleaved pixel format with 2 bytes per color component.
	/// The data is stored pixel-wise:
	///
	///\code
	/// 6 bytes        6 bytes        6 bytes      etc.
	/// B(1)G(1)R(1)   B(2)G(2)R(2)   B(3)G(3)R(3) etc.
	/// ..........................................
	/// ...........................   B(n)G(n)R(n)
	///\endcode
	///
	/// The data of each color component will be LSB aligned, thus the 6 MSB of each 16 bit will
	/// not contain valid data.
	///
	/// <b>ImageBuffer::vpData</b> will point to B(1) when using a 16 bit pointer.
	idpfRGB101010Packed = 14,
	/// \brief The image will be transferred as an RGB image with 36 bit of 
	/// usable data per pixel.
	///
	/// This is an interleaved pixel format with 2 bytes per color component.
	/// The data is stored pixel-wise:
	///
	///\code
	/// 6 bytes        6 bytes        6 bytes      etc.
	/// B(1)G(1)R(1)   B(2)G(2)R(2)   B(3)G(3)R(3) etc.
	/// ..........................................
	/// ...........................   B(n)G(n)R(n)
	///\endcode
	///
	/// The data of each color component will be LSB aligned, thus the 4 MSB of each 16 bit will
	/// not contain valid data.
	///
	/// <b>ImageBuffer::vpData</b> will point to B(1) when using a 16 bit pointer.
	idpfRGB121212Packed = 15,
	/// \brief The image will be transferred as an RGB image with 42 bit of 
	/// usable data per pixel.
	///
	/// This is an interleaved pixel format with 2 bytes per color component.
	/// The data is stored pixel-wise:
	///
	///\code
	/// 6 bytes        6 bytes        6 bytes      etc.
	/// B(1)G(1)R(1)   B(2)G(2)R(2)   B(3)G(3)R(3) etc.
	/// ..........................................
	/// ...........................   B(n)G(n)R(n)
	///\endcode
	///
	/// The data of each color component will be LSB aligned, thus the 2 MSB of each 16 bit will
	/// not contain valid data.
	///
	/// <b>ImageBuffer::vpData</b> will point to B(1) when using a 16 bit pointer.
	idpfRGB141414Packed = 16,
	/// \brief The image will be transferred as an RGB image with 48 bit of 
	/// usable data per pixel.
	///
	/// This is an interleaved pixel format with 2 bytes per color component.
	/// The data is stored pixel-wise:
	///
	///\code
	/// 6 bytes        6 bytes        6 bytes      etc.
	/// B(1)G(1)R(1)   B(2)G(2)R(2)   B(3)G(3)R(3) etc.
	/// ..........................................
	/// ...........................   B(n)G(n)R(n)
	///\endcode
	///
	/// The data of each color component will be LSB aligned.
	///
	/// <b>ImageBuffer::vpData</b> will point to B(1) when using a 16 bit pointer.
	idpfRGB161616Packed = 17,
	/// \brief This is a YUV422 packed image with 32 bit for a pair of pixels.
	///
	/// This format uses 2:1 horizontal downsampling, which means that the Y component is
	/// sampled at each pixel, while U(Cb) and V(Cr) components are sampled every 2 pixels in
	/// horizontal direction. If each component takes 8 bits, the pair of pixels requires 32 bits.
	///
	/// Two consecutive pixels (32 bit, 0xaabbccdd ) will contain 8 bit chrominance blue of pixel 1 and 2(aa),
	/// 8 bit luminance of pixel 1(bb), 8 bit chrominance red of pixel 1 and 2 (cc) and finally 8 bit luminance of pixel 2(dd).
	///
	/// Thus in memory the data will be stored like this:
	///
	///\code
	/// 4 bytes                   4 bytes                         etc.
	/// Cb(1,2) Y(1) Cr(1,2) Y(2) Cb(3,4)   Y(3)   Cr(3,4)   Y(4)    etc.
	/// ..........................Cb(n-1,n) Y(n-1) Cr(n-1,n) Y(n)
	///\endcode
	///
	/// <b>ImageBuffer::vpData</b> will point to Cb(1,2).
	idpfYUV422_UYVYPacked = 18
#if !defined(DOXYGEN_SHOULD_SKIP_THIS) && !defined(WRAP_ANY) && !defined(WRAP_DOTNET)
	, idpfLAST,
	idpfCUSTOM = 0x8000000,
	MV_CUSTOM_IMAGE_DESTINATION_PIXEL_FORMATS
#endif // #if !defined(DOXYGEN_SHOULD_SKIP_THIS) && !defined(WRAP_ANY) && !defined(WRAP_DOTNET)
};

//-----------------------------------------------------------------------------
/// \brief Defines valid filters which can be applied to the captured image before it
/// is transferred to the user.
enum TImageProcessingFilter
//-----------------------------------------------------------------------------
{
	/// \brief No filter function will be applied to the image.
	ipfOff = 0,
	/// \brief A sharpen filter will be applied to the image.
	ipfSharpen
};

//-----------------------------------------------------------------------------
/// \brief Defines the behaviour of an <b>mvIMPACT::acquire::ImageRequestControl</b>.
enum TImageRequestControlMode
//-----------------------------------------------------------------------------
{
	/// \brief The standard mode for image requests.
	///
	/// In this mode one image will be captured from the hardware for each request 
	/// that is send to the device driver. The image will be taken with respect to the
	/// current parameters as defined in the setting selected in the corresponding
	/// image request control.
	ircmManual,
	/// \brief Reserved. Currently not implemented.
	ircmLive,
	/// \brief Reserved. Currently not implemented.
	ircmCounting,
	/// \brief In this mode no 'real' image will be captured, but the whole 
	/// processing chain will be traversed once.
	///
	/// This mode can be used either to find out what the image format and parameters
	/// after an image capture would be with the current settings or to prepare
	/// the hardware before starting the first image acquisiton to save time when 
	/// real image data is processed.
	///
	/// When requesting an image in this mode, the corresponding wait function will return 
	/// a complete request object with pixel format, dimensions and image buffer that contains
	/// some dummy data.
	ircmTrial,
	/// \brief In this mode no 'real' image will be captured, but the whole 
	/// processing chain will be traversed once.
	///
	/// This mode can be used either to find out what the image format and parameters
	/// after an image capture would be with the current settings or to prepare
	/// the hardware before starting the first image acquisiton to save time when 
	/// real image data is processed.
	///
	/// In this mode, no wait function must be called. When the image request function has 
	/// returned successfully, the current destination buffer layout will be available as part
	/// of the general infomation properties.
	ircmUpdateBufferLayout
};

//-----------------------------------------------------------------------------
/// \brief Defines Image Result Configuration.
enum TImageResultConfiguration
//-----------------------------------------------------------------------------
{
	/// \brief Result is switched off.
	ircOff = 0,
	/// \brief Result is switched on.
	ircOn
};

//-----------------------------------------------------------------------------
/// \brief Defines the type of camera sensor.
enum TInfoSensorColorMode
//-----------------------------------------------------------------------------
{
	/// \brief This is an unknown type of sensor.
	iscmUnknown = 0,
	/// \brief This is a mono sensor.
	iscmMono,
	/// \brief This is a Bayer color sensor.
	iscmBayer,
	/// \brief This is a color sensor.
	iscmColor,
	/// \brief This is a sensor sensitve in the near IF spectrum only.
	iscmNIR
};

//-----------------------------------------------------------------------------
/// \brief Defines the bayer pattern of the sensor.
enum TInfoSensorColorPattern
//-----------------------------------------------------------------------------
{
	/// \brief This sensor starts to transmit a green pixel from a green and red line.
	///
	/// The raw image therefore is structured like this:
	///
	/// GRGRGRGRGRGRG etc.<br>
	/// BGBGBGBGBGBGB etc.<br>
	/// GRGRGRGRGRGRG etc.<br>
	/// etc.<br>
	iscpGreenRed,
	/// \brief This sensor starts to transmit a red pixel from a green and red line.
	///
	/// The raw image therefore is structured like this:
	///
	/// RGRGRGRGRGRGR etc.<br>
	/// GBGBGBGBGBGBG etc.<br>
	/// RGRGRGRGRGRGR etc.<br>
	/// etc.<br>
	iscpRedGreen,
	/// \brief This sensor starts to transmit a green pixel from a green and blue line.
	///
	/// The raw image therefore is structured like this:
	///
	/// GBGBGBGBGBGBG etc.<br>
	/// RGRGRGRGRGRGR etc.<br>
	/// GBGBGBGBGBGBG etc.<br>
	/// etc.<br>
	iscpBlueGreen,
	/// \brief This sensor starts to transmit a blue pixel from a green and blue line.
	///
	/// The raw image therefore is structured like this:
	///
	/// BGBGBGBGBGBGB etc.<br>
	/// GRGRGRGRGRGRG etc.<br>
	/// BGBGBGBGBGBGB etc.<br>
	/// etc.<br>
	iscpGreenBlue,
	/// \brief Nothing is known about the way the sensor transmits data.
	iscpUnknown
};

//-----------------------------------------------------------------------------
/// \brief Defines the type of camera sensor.
enum TInfoSensorType
//-----------------------------------------------------------------------------
{
	/// \brief This is an unknown type of sensor.
	istUnknown = 0,
	/// \brief This is a CCD sensor.
	istCCD = 0x1,
	/// \brief This is a CMOS sensor.
	istCMOS = 0x2,
};

//-----------------------------------------------------------------------------
/// \brief Defines how to handle interlaced image data.
///
/// Image data might be transmitted as fields. These later can either be combined
/// back into a full frame or can be handled individually.
enum TInterlacedMode
//-----------------------------------------------------------------------------
{
	/// \brief Enable the interlaced function.
	///
	/// The device will re-construct the interlaced data into a full frame.
	/// InvInterlaced/Interlaced is controlled by the camera parameter.
	imOn = 0,
	/// \brief Disable the interlaced function.
	imOff = 1
};

#ifndef IGNORE_MVGRABBER_SPECIFIC_DOCUMENTATION
	//-----------------------------------------------------------------------------
	/// \brief Currently available for mvTITAN/mvGAMMA-CL.
	///
	/// If <b>mvIMPACT::acquire::lcOn</b> is used of 
	/// <b>mvIMPACT::acquire::RequestInfo</b> structure contains the line count
	/// of the first line of the <b>mvIMPACT::acquire::Request::infoLineCounter</b>.
	///
	/// <b>mvTITAN/mvGAMMA-CL</b>: The counter is implemented in the hardware. All incoming lines will be counted.
	/// A detected signal on the trigger input will reset the counter. In addition to the the result
	/// the line count will be encoded in bit 0 of the first 32 Words (2-byte) of every line (watermark).
	///
	/// To decode the line counter from a line of image data something like this is needed(pseudo-code):
	///
	///\code
	/// unsigned integer getWatermark( pointer pData )
	/// {
	///   unsigned integer result = 0
	///   do
	///   {
	///     result = result OR ( pData[i multiplied by 2] AND 0x1 ) shift_left_by(i)
	///     i + 1
	///   } while( i < 32 )
	///   return result
	/// }
	///\endcode
	enum TLineCounter
	//-----------------------------------------------------------------------------
	{
		/// \brief Disables line counter.
		lcOff = 0,
		/// \brief Enables line counter.
		lcOn = 1
	};
#endif // IGNORE_MVGRABBER_SPECIFIC_DOCUMENTATION

//-----------------------------------------------------------------------------
/// \brief Defines valid LUT(<b>L</b>ook<b>U</b>p <b>T</b>able) gamma modes.
enum TLUTGammaMode
//-----------------------------------------------------------------------------
{
	/// \brief Default gamma mode.
	///
	/// Maps an image by applying intensity transformation with gamma correction to the complete intensity range of the LUT.
	LUTgmStandard,
	/// \brief Maps an image by applying a liear interpolation in the lower intensity range of the LUT and an 
	/// intensity transformation with gamma correction to the upper intensity range of the LUT.
	LUTgmLinearStart
};

//-----------------------------------------------------------------------------
/// \brief Defines valid LUT(<b>L</b>ook<b>U</b>p <b>T</b>able) implementations.
enum TLUTImplementation
//-----------------------------------------------------------------------------
{
	/// \brief the mapping of the image data will be done in hardware.
	///
	/// This feature will no be available for every device.
	LUTiHardware,
	/// \brief the mapping of the image data will be done with a optimized software algorithm.
	LUTiSoftware
};

//-----------------------------------------------------------------------------
/// \brief Defines valid LUT(<b>L</b>ook<b>U</b>p <b>T</b>able) interpolation modes.
enum TLUTInterpolationMode
//-----------------------------------------------------------------------------
{
	/// \brief Maps an image by applying intensity transformation based on a set of given threshold values.
	LUTimThreshold,
	/// \brief Maps an image by applying intensity transformation with linear interpolation.
	LUTimLinear,
	/// \brief Maps an image by applying intensity transformation with cubic interpolation.
	LUTimCubic
};

//-----------------------------------------------------------------------------
/// \brief Defines valid LUT(<b>L</b>ook<b>U</b>p <b>T</b>able) mapping modes.
enum TLUTMapping
//-----------------------------------------------------------------------------
{
	/// \brief 8 bit input data will be mapped to 8 bit output data.
	LUTm8To8   = (  8 << 16 ) | 8,
	/// \brief 10 bit input data will be mapped to 8 bit output data.
	LUTm10To8  = ( 10 << 16 ) | 8,
	/// \brief 10 bit input data will be mapped to 10 bit output data.
	LUTm10To10 = ( 10 << 16 ) | 10,
	/// \brief 12 bit input data will be mapped to 12 bit output data.
	LUTm12To12 = ( 12 << 16 ) | 12
};

//-----------------------------------------------------------------------------
/// \brief Defines valid LUT(<b>L</b>ook<b>U</b>p <b>T</b>able) modes.
enum TLUTMode
//-----------------------------------------------------------------------------
{
	/// \brief Maps an image by applying interpolated intensity transformation between a set of given sampling points.
	LUTmInterpolated,
	/// \brief Maps an image by applying intensity transformation with gamma correction.
	LUTmGamma,
	/// \brief Maps an image by applying intensity transformation.
	LUTmDirect
};

//-----------------------------------------------------------------------------
/// \brief Defines valid modes to operate the memory manager in.
enum TMemoryManagerMode
//-----------------------------------------------------------------------------
{
	/// \brief Automatic mode.
	///
	/// In this mode the DMA memory is only used as intermediate buffer. The user has no direct access to it
	/// instead he get always a copy of the image that resides on the heap. Internally the DMA memory is organized as
	/// ring buffer. It decouples the autonomous grabbing of the board from the application. The size of the 
	/// memory should be big enough to hold as many images as requests are used in the application. 
	mmmAuto = 0,
	/// \brief Pool Mode
	///
	/// This mode allows direct access to the DMA memory. So its not necessary for the driver to make copies
	/// of the images. This improves the performance of the system. But there is one disadvantage: The
	/// partitioning of the DMA memory is fixed and has to be done by the user. The block size must be set 
	/// to the image size in bytes. Additional the block count must be set. Before these parameters can be 
	/// changed it must be sure that all ImageBuffers are returned and the grabber is stopped.
	mmmPool = 1
};

//-----------------------------------------------------------------------------
/// \brief Defines the pool mode of memory manager.
enum TMemoryManagerPoolMode
//-----------------------------------------------------------------------------
{
	/// \brief Dont use Pool
	mmpmOff = 0,
	/// \brief Use Pool in Manual Mode
	mmpmFixed = 1,
	/// \brief Use Pool in Automatic Mode
	mmpmAuto = 2
};

//-----------------------------------------------------------------------------
/// \brief Defines valid mirror modes.
///
/// These enums may be 'ored' together.
enum TMirrorMode
//-----------------------------------------------------------------------------
{
	/// \brief No Mirroring.
	mmOff = 0,
	/// \brief The resulting image will be flipped around a horizontal axis.
	mmTopDown = 0x1,
	/// \brief The resulting image will be flipped around a vertical axis.
	mmLeftRight = 0x2,
	/// \brief The resulting image will be both around a horizontal and vertical axis.
	mmTopDownAndLeftRight = mmTopDown | mmLeftRight
};

//-----------------------------------------------------------------------------
/// \brief Defines valid network protocols.
enum TNetworkProtocol
//-----------------------------------------------------------------------------
{
	/// \brief This device is recognized as a supported device but doesn't respond
	/// to one of the recognized network protocols.
	npUnrecognized = 0,
	/// \brief This device will answer to the mvServer protocol.
	npmvServer = 1,
	/// \brief This device will answer to the GigE(TM) Vision protocol.
	npGigEVision = 2
};

#ifndef IGNORE_MVGRABBER_SPECIFIC_DOCUMENTATION
	//-----------------------------------------------------------------------------
	/// \brief Defines valid modes for the handling of the device' on board memory
	/// (if available)
	enum TOnBoardMemoryMode
	//-----------------------------------------------------------------------------
	{
		/// \brief The device will work with reasonable default values.
		///
		/// This option will be the right choice for most of the user. 
		obmmDefault,
		/// \brief The user can define how the on board memory of the device will
		/// be used.
		///
		/// This is for advanced user only and will not be necessary in most of
		/// the cases.
		obmmUser
	};
#endif // IGNORE_MVGRABBER_SPECIFIC_DOCUMENTATION

//-----------------------------------------------------------------------------
enum TPulseStartTrigger
//-----------------------------------------------------------------------------
{
	/// \brief Changes on one or more digital inputs will trigger the output of the pulse or pulse sequence.
	pstDigitalSignal = 0,
	/// \brief The output of a pulse or pulse sequence will be done periodically.
	pstPeriodically
};

//-----------------------------------------------------------------------------
/// \brief Defines valid image modes for request objects
enum TRequestImageMemoryMode
//-----------------------------------------------------------------------------
{
	/// \brief Automatic mode.
	///
	/// In this mode the driver will decide what kind of memory will be used,
	/// when it will be allocated and when it will be freed.
	rimmAuto,
	/// \brief User supplied memory mode.
	///
	/// A request in this mode can capture data directly into a user supplied
	/// buffer.
	///
	/// The user can assign a buffer to each request that has been set into this
	/// mode. However some devices require the capture memory to be aligned thus
	/// then the buffer supplied by the user must be aligned to the requirements
	/// of the driver as well. To find out, which alignment is needed, the property
	/// \a captureBufferAlignment must be queried.
	rimmUser
};

//-----------------------------------------------------------------------------
/// \brief Defines the current state of this <b>mvIMPACT::acquire::Request</b>.
enum TRequestState
//-----------------------------------------------------------------------------
{
	/// \brief This <b>mvIMPACT::acquire::Request</b> is currently unused.
	rsIdle,
	/// \brief This <b>mvIMPACT::acquire::Request</b> has been send into the drivers image request queue and
	/// currently wait to be processed.
	rsWaiting,
	/// \brief This <b>mvIMPACT::acquire::Request</b> is currently being processed.
	rsCapturing,
	/// \brief This <b>mvIMPACT::acquire::Request</b> has been processed.
	///
	/// The user is now responsible for this request. Before this <b>mvIMPACT::acquire::Request</b> is not unlocked
	/// again it can't be used by the driver. A <b>mvIMPACT::acquire::Request</b> in this state can safely be processed
	/// by the user. It's data will remain valid until either the <b>mvIMPACT::acquire::Request</b> is unlocked by
	/// the user or the device is closed.
	rsReady,
	/// \brief This <b>mvIMPACT::acquire::Request</b> is currently in configuration mode.
	///
	/// Within this mode certain properties of the request object will become writeable, which
	/// e.g. will allow the user to pass a capture buffer to the request object.
	rsBeingConfigured
};

//-----------------------------------------------------------------------------
/// \brief Defines valid result of an image request.
///
/// Whenever during the processing of the capture parameters but well before the actual
/// image capture and error is detected the MSB of this enum will be set to 1.
/// In this case almost everytime the current input parameters can't lead to a 
/// correct image and have to be changed.
enum TRequestResult
//-----------------------------------------------------------------------------
{
	/// \brief This image request has been processed successfully.
	rrOK = 0,
	/// \brief This image request resulted in a timeout. No image has been captured during
	/// the allowed period of time.
	rrTimeout = 1,
	/// \brief An error occurred during the processing of this request.
	///
	/// \if BUILD_MVBLUEFOX_DOCUMENTATION
	/// This error typically results in some kind of USB transmission problem. The log-file will contain
	/// more information in that case.
	/// \endif
	rrError = 2,
	/// \brief <b>DEPRECATED</b>! Use <b>mvIMPACT::acquire::rrRequestAborted</b>
	rrSnapAborted = 3,
	/// \brief This request has been aborted either because there are no free internal buffers
	/// or the user itself caused this abort e.g. by clearing the request queue.
	rrRequestAborted = 3,
	/// \brief An incomplete frame was transferred.
	///
	/// This can have several reasons, however the one most likely is that the transfer channel couldn't cope with
	/// the amount of data that was transmitted resulting in parts of the frame or in the waorst case the complete
	/// frame being lost.
	///
	/// This e.g. might happen if several network devices transmit at the same time or a single device (e.g. connected
	/// to a PCI bus transfers more data then the PCI bus can pass to the receiving end until a temporary buffer on the
	/// device runs full. The log output will contain additional information
	rrFrameIncomplete = 4,
	/// \brief The access to the device has been lost.
	///
	/// In this case no further access to the device will succeed. Only closing and re-opening the device
	/// will fix this problem. There can be numerous reasons for this error to occur, however the most likely one
	/// is that a device, that a timeout register inside the device, that needs to be resetted constantly by
	/// the driver hasn't been resetted during the timeout period. In this case the device will disconnect
	/// itself from the driver. This e.g. can happen if a network device is used and the application is operated in
	/// debug mode. For debugging the corresponding timeout register must be set to an appropriate value.
	rrDeviceAccessLost = 5,
	/// \brief A complete buffer has been delivered, but it did fail to pass the internal validation check.
	///
	/// This e.g. might happen with drivers that transmit buffers that contain more then a pure block of pixel
	/// data. Examples for this might be run-length encoded images, or buffers with additional information
	/// somewhere in the buffer that will be interpreted by the device driver. This error is most likely a
	/// result of a device that doesn't transfer data in the requested format. The log output will contain
	/// additional information.
	rrInconsistentBufferContent = 6,
	/// \brief The device has reported that an image acquisition did fail on the device side thus <b>BEFORE</b> the data transfer.
	///
	/// This e.g. might happen if a device is running low on local memory or because of some other problem detected
	/// on the device itself. This result status is just meant for information. The associated buffer will not contain
	/// valid image data.
	rrFrameCorrupt = 7,
	/// \brief This request is not processible.
	///
	/// If this flag (the MSB) is set this either indicates that the current input parameters 
	/// can't be used to capture an image (in that case the result will not be the MSB alone)
	/// or that an internal error occurred during the process of this request.
	rrUnprocessibleRequest = 0x80000000,
	/// \brief No free buffer available to process this request.
	///
	/// To get more memory either some old requests should be unlocked or the size of the
	/// DMA memory (frame grabbers only) could be increased using the tools provided.
	rrNoBufferAvailable = rrUnprocessibleRequest | 1,
	/// \brief There is not enough memory available to the driver to process the current
	/// image request.
	///
	/// To get more memory either some old requests should be unlocked or the size of the
	/// DMA memory (frame grabbers only) could be increased using the tools provided.
	rrNotEnoughMemory = rrUnprocessibleRequest | 2,
	/// \brief <b>DEPRECATED</b>! Will be removed in future versions.
	///
	/// This error code was generated when requesting an image with invalid parameters. Now the image request
	/// function will return <b>mvIMPACT::acquire::DMR_CAMERA_DESCRIPTION_INVALID_PARAMETER</b> in such a situation.
	rrScanStandardNotSupported = rrUnprocessibleRequest | 3,
	/// \brief <b>DEPRECATED</b>! Will be removed in future versions.
	///
	/// This error code was generated when requesting an image with invalid parameters. Now the image request
	/// function will return <b>mvIMPACT::acquire::DMR_CAMERA_DESCRIPTION_INVALID_PARAMETER</b> in such a situation.
	rrScanRateInvalid = rrUnprocessibleRequest | 4,
	/// \brief The current camera description is not supported by the capture device.
	///
	/// This error code currently is relevant for frame grabbers only and might occur e.g.
	/// when selecting a <b>MEDIUM CameraLink&reg;</b> camera description for a grabber,
	/// that only supports <b>BASE</b> cameras.
	rrCameraNotSupported = rrUnprocessibleRequest | 5,
	/// \brief <b>DEPRECATED</b>! Will be removed in future versions.
	///
	/// This error code was generated when requesting an image with invalid parameters. Now the image request
	/// function will return <b>mvIMPACT::acquire::DMR_CAMERA_DESCRIPTION_INVALID_PARAMETER</b> in such a situation.
	rrCameraUserAOINotSupported = rrUnprocessibleRequest | 6
};

//-----------------------------------------------------------------------------
/// \brief Defines valid RTCtrl Modes.
enum TRTCtrlModes
//-----------------------------------------------------------------------------
{
	/// \brief RTC switched off and editable.
	rtctrlModeStop,
	/// \brief RTC switched on and NOT editable.
	rtctrlModeRun,
	/// \brief RTC switched on and restart after changes.
	rtctrlModeRunRestart
};

//-----------------------------------------------------------------------------
/// \brief Defines valid RTProg OpCodes.
enum TRTProgOpCodes
//-----------------------------------------------------------------------------
{
	/// \brief Do nothing.
	rtctrlProgNop,
	/// \brief Set digital outputs.
	rtctrlProgSetDigout,
	/// \brief Wait for digital inputs.
	rtctrlProgWaitDigin,
	/// \brief Wait for n clocks.
	rtctrlProgWaitClocks,
	/// \brief Jump to location.
	rtctrlProgJumpLoc,
	/// \brief Set internal trigger signal to sensor controller.
	rtctrlProgTriggerSet,
	/// \brief Reset internal trigger signal to sensor controller.
	rtctrlProgTriggerReset,
	/// \brief Set internal expose signal to sensor controller.
	rtctrlProgExposeSet,
	/// \brief Reset internal expose signal to sensor controller.
	rtctrlProgExposeReset,
	/// \brief Reset internal sensor frame counter.
	rtctrlProgFrameNrReset,
	/// \brief Jump to location if a certain register contains zero.
	rtctrlProgJumpLocOnZero,
	/// \brief Jump to location if a certain register differs from zero.
	rtctrlProgJumpLocOnNotZero,
	/// \brief Set a registers value.
	rtctrlProgRegisterSet,
	/// \brief Add a constant value to a register.
	rtctrlProgRegisterAdd,
	/// \brief Substract a constant value from a register.
	rtctrlProgRegisterSub
};

//-----------------------------------------------------------------------------
/// \brief Defines valid scaler modes.
enum TScalerMode
//-----------------------------------------------------------------------------
{
	/// \brief The scaler is switched off (default).
	smOff,
	/// \brief The scaler is switched on.
	smOn
};

#ifndef IGNORE_MVGRABBER_SPECIFIC_DOCUMENTATION
	//-----------------------------------------------------------------------------
	/// \brief Analog grabbers generate its scan clock on different ways.
	enum TScanClock
	//-----------------------------------------------------------------------------
	{
		/// \brief The cameras clock signal is used.
		///
		/// If the property \a pixelClockOutput in the camera description is either set to
		///	<b>mvIMPACT::acquire::TCameraExternalSyncEdge::ceseFallingEdge</b> or
		/// <b>mvIMPACT::acquire::TCameraExternalSyncEdge::ceseRisingEdge</b>. 
		/// Otherwise <b>mvIMPACT::acquire::TScanClock::scAnalogue</b> is used for <b>mvTITAN-RGB</b>
		/// and <b>mvTITAN-G1</b> devices and <b>mvIMPACT::acquire::TScanClock::scDigital</b> for 
		/// <b>mvGAMMA-G</b> devices. Other devices currently do not support this feature.
		scAuto,
		/// \brief The scan clock is generated by genlocking on horizontal sync.(HD) signal.
		///
		/// <b>ADVANTAGES:</b><br>
		/// - very small jitter (typically around some 100 pico seconds) -> suitable for high pixel clock (>20Mhz)
		/// - for matching HD freq. values (with respect to the signal send by the camera) this will produce 
		/// results almost as good as when working with an external clock signal(less scan artifacts)
		///
		/// <b>DISADVANTAGES:</b><br>
		/// - slow reaction time -> not suitable for fast channel switching
		/// - not suitable for signals with a pixel clock below 12 MHz
		scAnalogue,
		/// \brief The scan clock is generated digitally.
		///
		/// <b>ADVANTAGE:</b><br>
		/// - locked after a single line, therefore this mode is very useful for fast channel switching
		///
		/// <b>DISADVANTAGE:</b><br>
		/// - bigger jitter as the analogue mode(<10ns), therefore not suitable for cameras with a pixel clock higher then about 20Mhz
		scDigital
	};

	//-----------------------------------------------------------------------------
	/// \brief Defines valid scan modes for standard cameras.
	enum TScanStandard
	//-----------------------------------------------------------------------------
	{ 
		/// \brief 720 x 576 Pixels for 50 Hz standard cameras
		///		720 x 480 Pixels for 60 Hz standard cameras
		ssITU601,
		/// \brief 768 x 576 Pixels for 50 Hz standard cameras
		///		640 x 480 Pixels for 60 Hz standard cameras
		ssSquare,
		// \brief The user can define scanrate and camera AOI
		ssUser
	};

	//-----------------------------------------------------------------------------
	/// \brief Defines valid tap sort modes.
	///
	/// As certain cameras deliver their data unsorted this data sometimes needs
	/// to be sorted either by hard or software.
	enum TTapSortMode
	//-----------------------------------------------------------------------------
	{
		/// \brief Default. Sort according to the camera description.
		tsmAuto = 0,
		/// \brief No sorting.
		tsmOff = 0x1,
	};
#endif // IGNORE_MVGRABBER_SPECIFIC_DOCUMENTATION

//-----------------------------------------------------------------------------
/// \brief Defines valid thread priorities.
enum TThreadPriority
//-----------------------------------------------------------------------------
{
	/// \brief Idle thread priority.
	tpIdle,
	/// \brief Lowest thread priority.
	tpLowest,
	/// \brief Below normal thread priority.
	tpBelowNormal,
	/// \brief Normal thread priority.
	tpNormal,
	/// \brief Above normal thread priority.
	tpAboveNormal,
	/// \brief Highest priority.
	tpHighest,
	/// \brief time critical thread priority.
	tpTimeCritical
};

//-----------------------------------------------------------------------------
/// \brief Defines a trigger moment for a digital signal.
///
/// This can e.g. be the moment a signal connected to a device changes it state
/// or reaches a certain state.
enum TTriggerMoment
//-----------------------------------------------------------------------------
{
	/// \brief A falling edge will trigger the event.
	tmOnFallingEdge = 0,
	/// \brief A rising edge will trigger the event.
	tmOnRisingEdge
};

//-----------------------------------------------------------------------------
/// \brief Defines valid flags for controlling the user access rights to the user
/// data that can be stored in the devices non-volatile memory.
enum TUserDataAccessRight
//-----------------------------------------------------------------------------
{
	/// \brief The user has read rights for this entry.
	udarRead = 0x1,
	/// \brief The user has principle write rights for this entry.
	///
	/// If <b>mvIMPACT::acquire::udarPassword</b> is not set for this entry or
	/// the corresponding password has been set correctly, the user can modify the
	/// corresponding entry.
	udarWrite = 0x2,
	/// \brief Just combines <b>mvIMPACT::acquire::udarRead</b> and <b>mvIMPACT::acquire::udarWrite</b>.
	udarRW = udarRead | udarWrite,
	/// \brief A password is needed to modify this entry.
	///
	/// Even if <b>mvIMPACT::acquire::udarWrite</b> is specified the user can only modify this entry
	/// if the correct password has been set.
	udarPassword = 0x4,
	/// \brief Combines all other flags.
	udarFull = udarRW | udarPassword
};

//-----------------------------------------------------------------------------
/// \brief Defined valid values for the behaviour of the user data when a device
/// has been disconnected and reconnected within a running process.
enum TUserDataReconnectBehaviour
//-----------------------------------------------------------------------------
{
	/// \brief Keep the data currently buffered in the properties describing the
	/// user data. 
	///
	/// When the user data has been modified on another machine this
	/// will result in a loss of that data once this buffered data is written back
	/// to the devices non-volatile memory.
	udrbKeepCachedData,
	/// \brief Updates the propties describing the user data with the fresh data as
	/// read from the devices non-volatile memory.
	///
	/// This might result in the loss of data that has been edited but <b>NOT</b> written
	/// to the devices non-volatile memory if this data differs from the current
	/// data stored in the devices non-volatile memory.
	udrbUpdateFromDeviceData
};

//-----------------------------------------------------------------------------
/// \brief Defines valid video standards that might be supported by a video capture device.
enum TVideoStandard
//-----------------------------------------------------------------------------
{
	/// \brief videosignal: grey, 50 fields per second, 625 lines
	vsCCIR,
	/// \brief videosignal: grey, 60 fields per second, 525 lines
	vsRS170,
	/// \brief videosignal: color, 50 fields per second, 625 lines
	vsPALBGH,
	/// \brief videosignal: color, 60 fields per second, 525 lines
	vsNTSCM
};

#ifndef IGNORE_MVVIRTUALDEVICE_SPECIFIC_DOCUMENTATION
	//-----------------------------------------------------------------------------
	/// \brief Defines valid image types used when capturing data from a certain directory.
	enum TVirtualDeviceImageType
	//-----------------------------------------------------------------------------
	{
		/// \brief Will capture all recognized image formats
		vditAll,
		/// \brief Will capture BMP files only.
		vditBMP
	};

	//-----------------------------------------------------------------------------
	/// \brief Defines valid test modes.
	enum TVirtualDeviceTestMode
	//-----------------------------------------------------------------------------
	{
		/// \brief Will generate a moving test pattern with pixel format <b>mvIMPACT::acquire::ibpfRGBx888Packed</b>.
		vdtmMovingRGBx888PackedImage,
		/// \brief Will generate a moving test pattern with pixel format <b>mvIMPACT::acquire::ibpfRGB888Packed</b>.
		vdtmMovingRGB888PackedImage,
		/// \brief Will generate a moving test pattern with pixel format <b>mvIMPACT::acquire::ibpfRGBx888Planar</b>.
		vdtmMovingRGBx888PlanarImage,
		/// \brief Will generate a moving test pattern with a mono pixel format 
		vdtmMovingMonoRamp,
		/// \brief Will generate a moving test pattern with pixel format <b>mvIMPACT::acquire::ibpfYUV422Packed</b>.
		vdtmMovingYUV422PackedRamp,
		/// \brief Will generate a moving test pattern with pixel format <b>mvIMPACT::acquire::ibpfYUV422Planar</b>.
		vdtmMovingYUV422PlanarRamp,
		/// \brief Will generate a moving test pattern with pixel format <b>mvIMPACT::acquire::ibpfRGB101010Packed</b>.
		vdtmMovingRGB101010PackedImage,
		/// \brief Will generate a moving test pattern with pixel format <b>mvIMPACT::acquire::ibpfRGB121212Packed</b>.
		vdtmMovingRGB121212PackedImage,
		/// \brief Will generate a moving test pattern with pixel format <b>mvIMPACT::acquire::ibpfRGB141414Packed</b>.
		vdtmMovingRGB141414PackedImage,
		/// \brief Will generate a moving test pattern with pixel format <b>mvIMPACT::acquire::ibpfRGB161616Packed</b>.
		vdtmMovingRGB161616PackedImage,
		/// \brief Will generate a moving bayer test pattern.
		vdtmMovingBayerDataRamp,
		/// \brief Will generate a still bayer test pattern that can be used for white balancing.
		vdtmBayerWhiteBalanceTestImage,
		/// \brief Will capture images from a user supplied directory.
		vdtmImageDirectory,
		/// \brief Will generate a still 8 bit bayer test pattern for leaky pixel calibration.
		vdtmLeakyPixelTestImageMono8Bayer,
		/// \brief Will generate a moving test pattern with pixel format <b>mvIMPACT::acquire::ibpfYUV422_UYVYPacked</b>.
		vdtmMovingYUV422_UYVYPackedRamp
	};
#endif // #ifndef IGNORE_MVVIRTUALDEVICE_SPECIFIC_DOCUMENTATION

//-----------------------------------------------------------------------------
/// \brief Defines valid white balance calibration modes.
enum TWhiteBalanceCalibrationMode
//-----------------------------------------------------------------------------
{
	/// \brief Do not perform calibration, current values will be used.
	wbcmOff = 0,
	/// \brief Use the next image to perform the white balance calibration.
	///
	/// This is defined for bayer color sensors only.
	wbcmNextFrame,
	/// \brief Do a continuous white balance calibration.
	wbcmContinuous
};

//-----------------------------------------------------------------------------
/// \brief Defines valid parameter sets selectable via the \a WhiteBalance property.
enum TWhiteBalanceParameter
//-----------------------------------------------------------------------------
{
	/// \brief A set of constant parameters optimised for scenes illuminated by tungsten light sources.
	wbpTungsten = 0,
	/// \brief A set of constant parameters optimised for scenes illuminated by halogen light sources.
	wbpHalogen,
	/// \brief A set of constant parameters optimised for scenes illuminated by fluorescent light sources.
	wbpFluorescent,
	/// \brief A set of constant parameters optimised for scenes illuminated by day light.
	wbpDayLight,
	/// \brief A set of constant parameters optimised for scenes illuminated by photo flash light sources.
	wbpPhotoFlash,
	/// \brief A set of constant parameters optimised for scenes illuminated by day light and perfect weather.
	wbpBlueSky,
	/// \brief A parameter set which can be modified by the user.
	wbpUser1,
	/// \brief A parameter set which can be modified by the user.
	wbpUser2,
	/// \brief A parameter set which can be modified by the user.
	wbpUser3,
	/// \brief A parameter set which can be modified by the user.
	wbpUser4
};

#if !defined(DOXYGEN_SHOULD_SKIP_THIS) && !defined(WRAP_ANY)
	typedef enum TAcquisitionField TAcquisitionField;
	typedef enum TAcquisitionMode TAcquisitionMode;
	typedef enum TAdvancedImageInfo TAdvancedImageInfo;
	typedef enum TAoiMode TAoiMode;
	typedef enum TAutoControlMode TAutoControlMode;
	typedef enum TAutoControlSpeed TAutoControlSpeed;
	typedef enum TAutoExposureControl TAutoExposureControl;
	typedef enum TAutoGainControl TAutoGainControl;
	typedef enum TAutoOffsetCalibration TAutoOffsetCalibration;
	typedef enum TBayerMosaicParity TBayerMosaicParity;
	typedef enum TBayerWhiteBalanceResult TBayerWhiteBalanceResult;
	typedef enum TBlueFOXDigitalInputThreshold TBlueFOXDigitalInputThreshold;
	typedef enum TBlueFOXFooterMode TBlueFOXFooterMode;
	typedef enum TBlueFOXKernelDriver TBlueFOXKernelDriver;
	typedef enum TBlueFOXOffsetAutoBlackSpeed TBlueFOXOffsetAutoBlackSpeed;
	typedef enum TBlueFOXSensorTiming TBlueFOXSensorTiming;
	typedef enum TBlueFOXTransferSize TBlueFOXTransferSize;
	typedef enum TBlueLYNXCameraDataClipMode TBlueLYNXCameraDataClipMode;
	typedef enum TBlueLYNXCameraFlashMode TBlueLYNXCameraFlashMode;
	typedef enum TBlueLYNXVideoOutMode TBlueLYNXVideoOutMode;
	typedef enum TBoolean TBoolean;
	typedef enum TCameraAoiMode TCameraAoiMode;
	typedef enum TCameraBinningMode TCameraBinningMode;
	typedef enum TCameraDataFormat TCameraDataFormat;
	typedef enum TCameraExposeMode TCameraExposeMode;
	typedef enum TCameraExternalSyncEdge TCameraExternalSyncEdge;
	typedef enum TCameraExternalSyncOutput TCameraExternalSyncOutput;
	typedef enum TCameraFlashMode TCameraFlashMode;
	typedef enum TCameraFlashType TCameraFlashType;
	typedef enum TCameraHDRMode TCameraHDRMode;
	typedef enum TCameraInterlacedType TCameraInterlacedType;
	typedef enum TCameraLinkDataValidMode TCameraLinkDataValidMode;
	typedef enum TCameraOutput TCameraOutput;
	typedef enum TCameraPixelClock TCameraPixelClock;
	typedef enum TCameraScanMode TCameraScanMode;
	typedef enum TCameraSerialPortBaudRate TCameraSerialPortBaudRate;
	typedef enum TCameraShutterMode TCameraShutterMode;
	typedef enum TCameraTapsXGeometry TCameraTapsXGeometry;
	typedef enum TCameraTapsYGeometry TCameraTapsYGeometry;
	typedef enum TCameraTestMode TCameraTestMode;
	typedef enum TCameraTriggerMode TCameraTriggerMode;
	typedef enum TCameraTriggerSource TCameraTriggerSource;
	typedef enum TClampMode TClampMode;
	typedef enum TColorProcessingMode TColorProcessingMode;
	typedef enum TContinuousWhiteBalanceMode TContinuousWhiteBalanceMode;
	typedef enum TDarkCurrentFilterMode TDarkCurrentFilterMode;
	typedef enum TDefectivePixelsFilterMode TDefectivePixelsFilterMode;
	typedef enum TDeviceCapability TDeviceCapability;
	typedef enum TDeviceClass TDeviceClass;
	typedef enum TDeviceDigitalOutputMode TDeviceDigitalOutputMode;
	typedef enum TDeviceEventMode TDeviceEventMode;
	typedef enum TDeviceEventType TDeviceEventType;
	typedef enum TDeviceImageTrigger TDeviceImageTrigger;
	typedef enum TDeviceInterfaceLayout TDeviceInterfaceLayout;
	typedef enum TDeviceLoadSettings TDeviceLoadSettings;
	typedef enum TDevicePowerMode TDevicePowerMode;
	typedef enum TDeviceScanRateMode TDeviceScanRateMode;
	typedef enum TDeviceSignalOutputStartEvent TDeviceSignalOutputStartEvent;
	typedef enum TDeviceState TDeviceState;
	typedef enum TDeviceSyncOutMode TDeviceSyncOutMode;
	typedef enum TDeviceTriggerInterface TDeviceTriggerInterface;
	typedef enum TDeviceTriggerMode TDeviceTriggerMode;
	typedef enum TDeviceTriggerOverlap TDeviceTriggerOverlap;
	typedef enum TDigIOState TDigIOState;
	typedef enum TDigitalOutputControlMode TDigitalOutputControlMode;
	typedef enum TDigitalSignal TDigitalSignal;
	typedef enum TDMR_ERROR TDMR_ERROR;
	typedef enum TFieldGateMode TFieldGateMode;
	typedef enum TFilterType TFilterType;
	typedef enum TFlatFieldFilterMode TFlatFieldFilterMode;
	typedef enum THWUpdateResult THWUpdateResult;
	typedef enum TImageBufferPixelFormat TImageBufferPixelFormat;
	typedef enum TImageDestinationPixelFormat TImageDestinationPixelFormat;
	typedef enum TImageProcessingFilter TImageProcessingFilter;
	typedef enum TImageRequestControlMode TImageRequestControlMode;
	typedef enum TImageResultConfiguration TImageResultConfiguration;
	typedef enum TInfoSensorColorMode TInfoSensorColorMode;
	typedef enum TInfoSensorColorPattern TInfoSensorColorPattern;
	typedef enum TInfoSensorType TInfoSensorType;
	typedef enum TInterlacedMode TInterlacedMode;
	typedef enum TLineCounter TLineCounter;
	typedef enum TLUTGammaMode TLUTGammaMode;
	typedef enum TLUTImplementation TLUTImplementation;
	typedef enum TLUTInterpolationMode TLUTInterpolationMode;
	typedef enum TLUTMapping TLUTMapping;
	typedef enum TLUTMode TLUTMode;
	typedef enum TMemoryManagerMode TMemoryManagerMode;
	typedef enum TMemoryManagerPoolMode TMemoryManagerPoolMode;
	typedef enum TMirrorMode TMirrorMode;
	typedef enum TNetworkProtocol TNetworkProtocol;
	typedef enum TOnBoardMemoryMode TOnBoardMemoryMode;
	typedef enum TPulseStartTrigger TPulseStartTrigger;
	typedef enum TRequestImageMemoryMode TRequestImageMemoryMode;
	typedef enum TRequestResult TRequestResult;
	typedef enum TRequestState TRequestState;
	typedef enum TRTCtrlModes TRTCtrlModes;
	typedef enum TRTProgOpCodes TRTProgOpCodes;
	typedef enum TScalerMode TScalerMode;
	typedef enum TScanClock TScanClock;
	typedef enum TScanStandard TScanStandard;
	typedef enum TTapSortMode TTapSortMode;
	typedef enum TThreadPriority TThreadPriority;
	typedef enum TTriggerMoment TTriggerMoment;
	typedef enum TUserDataAccessRight TUserDataAccessRight;
	typedef enum TUserDataReconnectBehaviour TUserDataReconnectBehaviour;
	typedef enum TVideoStandard TVideoStandard;
	typedef enum TVirtualDeviceImageType TVirtualDeviceImageType;
	typedef enum TVirtualDeviceTestMode TVirtualDeviceTestMode;
	typedef enum TWhiteBalanceCalibrationMode TWhiteBalanceCalibrationMode;
	typedef enum TWhiteBalanceParameter TWhiteBalanceParameter;
#endif // DOXYGEN_SHOULD_SKIP_THIS && WRAP_ANY

#if defined(WRAP_DOTNET) || defined(MVIMPACT_ACQUIRE_H_) || defined(DOXYGEN_CPP_DOCUMENTATION)
		} // namespace acquire
	} // namespace mvIMPACT
#endif // #if defined(WRAP_DOTNET) || defined(MVIMPACT_ACQUIRE_H_) || defined(DOXYGEN_CPP_DOCUMENTATION)

#ifdef __cplusplus
	}
#endif // __cplusplus

// restore Borland compiler switch 'force enums to the size of integer'
#if !defined(DOXYGEN_SHOULD_SKIP_THIS) && !defined(WRAP_ANY)
#	ifdef _WIN32
#		ifdef __BORLANDC__
#			pragma option pop
#		endif // __BORLANDC__
#	endif // _WIN32
#endif // !defined(DOXYGEN_SHOULD_SKIP_THIS) && !defined(WRAP_ANY)

#endif // mvDriverBaseEnumsH

