#include"xiApiPlusOcv.hpp"

//-------------------------------------------------------------------------------------------------------------------
// xiAPIplus parameters implementation file - created from gen_xiAPIplus_cpp_file.xslt
// XIMEA Application Programming Interface Object Oriented Approach
//-------------------------------------------------------------------------------------------------------------------


//#include <xiAPIplus/xiapiplus.h>

	//-------------------------------------------------------------------------------------------------------------------
	// xiApi public parameters
	


	//-------------------------------------------------------------------------------------------------------------------
	// ---- Parameter Group: Basic
	//-------------------------------------------------------------------------------------------------------------------

	 
	
	// Exposure time in microseconds (XI_PRM_EXPOSURE)
	float xiAPIplus_Camera::GetExposureTime()
	{
		float val=0;
		
		CheckCamHandle("GetExposureTime");
		
		XI_RETURN res=xiGetParamFloat(camera_handle, XI_PRM_EXPOSURE, &val);
		CheckResult(res,"GetExposureTime");
		return val;
	}

	float xiAPIplus_Camera::GetExposureTime_Maximum()
	{
		float val=0;
		
		CheckCamHandle("GetExposureTime" "_Maximum");
		
		XI_RETURN res=xiGetParamFloat(camera_handle, XI_PRM_EXPOSURE XI_PRM_INFO_MAX, &val);
		CheckResult(res,"GetExposureTime" "_Maximum");
		return val;
	}

	float xiAPIplus_Camera::GetExposureTime_Minimum()
	{
		float val=0;
		
		CheckCamHandle("GetExposureTime" "_Minimum");
		
		XI_RETURN res=xiGetParamFloat(camera_handle, XI_PRM_EXPOSURE XI_PRM_INFO_MIN, &val);
		CheckResult(res,"GetExposureTime" "_Minimum");
		return val;
	}

	float xiAPIplus_Camera::GetExposureTime_Increment()
	{
		float val=0;
		
		CheckCamHandle("GetExposureTime" "_Increment");
		
		XI_RETURN res=xiGetParamFloat(camera_handle, XI_PRM_EXPOSURE XI_PRM_INFO_INCREMENT, &val);
		CheckResult(res,"GetExposureTime" "_Increment");
		return val;
	}
	
	void xiAPIplus_Camera::SetExposureTime(float ExposureTime)
	{
		
		CheckCamHandle("SetExposureTime");
		
		XI_RETURN res=xiSetParamFloat(camera_handle, XI_PRM_EXPOSURE, ExposureTime);
		CheckResult(res,"SetExposureTime");
	}
	 
	
	// Selector for Exposure parameter (XI_PRM_EXPOSURE_TIME_SELECTOR)
	XI_EXPOSURE_TIME_SELECTOR_TYPE xiAPIplus_Camera::GetExposureTimeSelector()
	{
		int val=0;
		
		CheckCamHandle("GetExposureTimeSelector");
		
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_EXPOSURE_TIME_SELECTOR, &val);
		CheckResult(res,"GetExposureTimeSelector");
		return (XI_EXPOSURE_TIME_SELECTOR_TYPE)val;
	}
	
	XI_EXPOSURE_TIME_SELECTOR_TYPE xiAPIplus_Camera::GetExposureTimeSelector_Maximum()
	{
		int val=0;
		
		CheckCamHandle("GetExposureTimeSelector" "_Maximum");
		
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_EXPOSURE_TIME_SELECTOR XI_PRM_INFO_MAX, &val);
		CheckResult(res,"GetExposureTimeSelector" "_Maximum");
		return (XI_EXPOSURE_TIME_SELECTOR_TYPE)val;
	}
	
	XI_EXPOSURE_TIME_SELECTOR_TYPE xiAPIplus_Camera::GetExposureTimeSelector_Minimum()
	{
		int val=0;
		
		CheckCamHandle("GetExposureTimeSelector" "_Minimum");
		
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_EXPOSURE_TIME_SELECTOR XI_PRM_INFO_MIN, &val);
		CheckResult(res,"GetExposureTimeSelector" "_Minimum");
		return (XI_EXPOSURE_TIME_SELECTOR_TYPE)val;
	}
	
	int xiAPIplus_Camera::GetExposureTimeSelector_Increment()
	{
		int val=0;
		
		CheckCamHandle("GetExposureTimeSelector" "_Increment");
		
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_EXPOSURE_TIME_SELECTOR XI_PRM_INFO_INCREMENT, &val);
		CheckResult(res,"GetExposureTimeSelector" "_Increment");
		return val;
	}
	
	void xiAPIplus_Camera::SetExposureTimeSelector(XI_EXPOSURE_TIME_SELECTOR_TYPE ExposureTimeSelector)
	{
		
		CheckCamHandleInt("SetExposureTimeSelector",(int)ExposureTimeSelector);
		
		XI_RETURN res=xiSetParamInt(camera_handle, XI_PRM_EXPOSURE_TIME_SELECTOR, ExposureTimeSelector);
		CheckResult(res,"SetExposureTimeSelector");
	}
	 
	
	// Sets the number of times of exposure in one frame. (XI_PRM_EXPOSURE_BURST_COUNT)
	// integer type
	int xiAPIplus_Camera::GetExposureBurstCount()
	{
		CheckCamHandle("GetExposureBurstCount");
		int val=0;
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_EXPOSURE_BURST_COUNT, &val);
		CheckResult(res,"GetExposureBurstCount");
		return val;	
	}
	int xiAPIplus_Camera::GetExposureBurstCount_Maximum()
	{		
		CheckCamHandle("GetExposureBurstCount" "_Maximum");
		int val=0;
		CheckCamHandle("GetExposureBurstCount");
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_EXPOSURE_BURST_COUNT XI_PRM_INFO_MAX, &val);
		CheckResult(res,"GetExposureBurstCount" "_Maximum");
		return val;
	}
	
	int xiAPIplus_Camera::GetExposureBurstCount_Minimum()
	{
		CheckCamHandle("GetExposureBurstCount" "_Minimum");
		int val=0;
		CheckCamHandle("GetExposureBurstCount");
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_EXPOSURE_BURST_COUNT XI_PRM_INFO_MIN, &val);
		CheckResult(res,"GetExposureBurstCount" "_Minimum");
		return val;
	}

	int xiAPIplus_Camera::GetExposureBurstCount_Increment()
	{
		CheckCamHandle("GetExposureBurstCount" "_Increment");
		int val=0;
		CheckCamHandle("GetExposureBurstCount");
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_EXPOSURE_BURST_COUNT XI_PRM_INFO_INCREMENT, &val);
		CheckResult(res,"GetExposureBurstCount" "_Increment");
		return val;		
	}
	
	void xiAPIplus_Camera::SetExposureBurstCount(int ExposureBurstCount)
	{
		
		CheckCamHandleInt("SetExposureBurstCount",ExposureBurstCount);
		
		XI_RETURN res=xiSetParamInt(camera_handle, XI_PRM_EXPOSURE_BURST_COUNT, ExposureBurstCount);
		CheckResult(res,"SetExposureBurstCount");
	}
	 
	
	// Gain selector for parameter Gain allows to select different type of gains. (XI_PRM_GAIN_SELECTOR)
	XI_GAIN_SELECTOR_TYPE xiAPIplus_Camera::GetGainSelector()
	{
		int val=0;
		
		CheckCamHandle("GetGainSelector");
		
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_GAIN_SELECTOR, &val);
		CheckResult(res,"GetGainSelector");
		return (XI_GAIN_SELECTOR_TYPE)val;
	}
	
	XI_GAIN_SELECTOR_TYPE xiAPIplus_Camera::GetGainSelector_Maximum()
	{
		int val=0;
		
		CheckCamHandle("GetGainSelector" "_Maximum");
		
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_GAIN_SELECTOR XI_PRM_INFO_MAX, &val);
		CheckResult(res,"GetGainSelector" "_Maximum");
		return (XI_GAIN_SELECTOR_TYPE)val;
	}
	
	XI_GAIN_SELECTOR_TYPE xiAPIplus_Camera::GetGainSelector_Minimum()
	{
		int val=0;
		
		CheckCamHandle("GetGainSelector" "_Minimum");
		
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_GAIN_SELECTOR XI_PRM_INFO_MIN, &val);
		CheckResult(res,"GetGainSelector" "_Minimum");
		return (XI_GAIN_SELECTOR_TYPE)val;
	}
	
	int xiAPIplus_Camera::GetGainSelector_Increment()
	{
		int val=0;
		
		CheckCamHandle("GetGainSelector" "_Increment");
		
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_GAIN_SELECTOR XI_PRM_INFO_INCREMENT, &val);
		CheckResult(res,"GetGainSelector" "_Increment");
		return val;
	}
	
	void xiAPIplus_Camera::SetGainSelector(XI_GAIN_SELECTOR_TYPE GainSelector)
	{
		
		CheckCamHandleInt("SetGainSelector",(int)GainSelector);
		
		XI_RETURN res=xiSetParamInt(camera_handle, XI_PRM_GAIN_SELECTOR, GainSelector);
		CheckResult(res,"SetGainSelector");
	}
	 
	
	// Gain in dB (XI_PRM_GAIN)
	float xiAPIplus_Camera::GetGain()
	{
		float val=0;
		
		CheckCamHandle("GetGain");
		
		XI_RETURN res=xiGetParamFloat(camera_handle, XI_PRM_GAIN, &val);
		CheckResult(res,"GetGain");
		return val;
	}

	float xiAPIplus_Camera::GetGain_Maximum()
	{
		float val=0;
		
		CheckCamHandle("GetGain" "_Maximum");
		
		XI_RETURN res=xiGetParamFloat(camera_handle, XI_PRM_GAIN XI_PRM_INFO_MAX, &val);
		CheckResult(res,"GetGain" "_Maximum");
		return val;
	}

	float xiAPIplus_Camera::GetGain_Minimum()
	{
		float val=0;
		
		CheckCamHandle("GetGain" "_Minimum");
		
		XI_RETURN res=xiGetParamFloat(camera_handle, XI_PRM_GAIN XI_PRM_INFO_MIN, &val);
		CheckResult(res,"GetGain" "_Minimum");
		return val;
	}

	float xiAPIplus_Camera::GetGain_Increment()
	{
		float val=0;
		
		CheckCamHandle("GetGain" "_Increment");
		
		XI_RETURN res=xiGetParamFloat(camera_handle, XI_PRM_GAIN XI_PRM_INFO_INCREMENT, &val);
		CheckResult(res,"GetGain" "_Increment");
		return val;
	}
	
	void xiAPIplus_Camera::SetGain(float Gain)
	{
		
		CheckCamHandle("SetGain");
		
		XI_RETURN res=xiSetParamFloat(camera_handle, XI_PRM_GAIN, Gain);
		CheckResult(res,"SetGain");
	}
	 
	
	// Change image resolution by binning or skipping. (XI_PRM_DOWNSAMPLING)
	XI_DOWNSAMPLING_VALUE xiAPIplus_Camera::GetDownsampling()
	{
		int val=0;
		
		CheckCamHandle("GetDownsampling");
		
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_DOWNSAMPLING, &val);
		CheckResult(res,"GetDownsampling");
		return (XI_DOWNSAMPLING_VALUE)val;
	}
	
	XI_DOWNSAMPLING_VALUE xiAPIplus_Camera::GetDownsampling_Maximum()
	{
		int val=0;
		
		CheckCamHandle("GetDownsampling" "_Maximum");
		
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_DOWNSAMPLING XI_PRM_INFO_MAX, &val);
		CheckResult(res,"GetDownsampling" "_Maximum");
		return (XI_DOWNSAMPLING_VALUE)val;
	}
	
	XI_DOWNSAMPLING_VALUE xiAPIplus_Camera::GetDownsampling_Minimum()
	{
		int val=0;
		
		CheckCamHandle("GetDownsampling" "_Minimum");
		
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_DOWNSAMPLING XI_PRM_INFO_MIN, &val);
		CheckResult(res,"GetDownsampling" "_Minimum");
		return (XI_DOWNSAMPLING_VALUE)val;
	}
	
	int xiAPIplus_Camera::GetDownsampling_Increment()
	{
		int val=0;
		
		CheckCamHandle("GetDownsampling" "_Increment");
		
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_DOWNSAMPLING XI_PRM_INFO_INCREMENT, &val);
		CheckResult(res,"GetDownsampling" "_Increment");
		return val;
	}
	
	void xiAPIplus_Camera::SetDownsampling(XI_DOWNSAMPLING_VALUE Downsampling)
	{
		
		CheckCamHandleInt("SetDownsampling",(int)Downsampling);
		
		XI_RETURN res=xiSetParamInt(camera_handle, XI_PRM_DOWNSAMPLING, Downsampling);
		CheckResult(res,"SetDownsampling");
	}
	 
	
	// Change image downsampling type. (XI_PRM_DOWNSAMPLING_TYPE)
	XI_DOWNSAMPLING_TYPE xiAPIplus_Camera::GetDownsamplingType()
	{
		int val=0;
		
		CheckCamHandle("GetDownsamplingType");
		
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_DOWNSAMPLING_TYPE, &val);
		CheckResult(res,"GetDownsamplingType");
		return (XI_DOWNSAMPLING_TYPE)val;
	}
	
	XI_DOWNSAMPLING_TYPE xiAPIplus_Camera::GetDownsamplingType_Maximum()
	{
		int val=0;
		
		CheckCamHandle("GetDownsamplingType" "_Maximum");
		
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_DOWNSAMPLING_TYPE XI_PRM_INFO_MAX, &val);
		CheckResult(res,"GetDownsamplingType" "_Maximum");
		return (XI_DOWNSAMPLING_TYPE)val;
	}
	
	XI_DOWNSAMPLING_TYPE xiAPIplus_Camera::GetDownsamplingType_Minimum()
	{
		int val=0;
		
		CheckCamHandle("GetDownsamplingType" "_Minimum");
		
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_DOWNSAMPLING_TYPE XI_PRM_INFO_MIN, &val);
		CheckResult(res,"GetDownsamplingType" "_Minimum");
		return (XI_DOWNSAMPLING_TYPE)val;
	}
	
	int xiAPIplus_Camera::GetDownsamplingType_Increment()
	{
		int val=0;
		
		CheckCamHandle("GetDownsamplingType" "_Increment");
		
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_DOWNSAMPLING_TYPE XI_PRM_INFO_INCREMENT, &val);
		CheckResult(res,"GetDownsamplingType" "_Increment");
		return val;
	}
	
	void xiAPIplus_Camera::SetDownsamplingType(XI_DOWNSAMPLING_TYPE DownsamplingType)
	{
		
		CheckCamHandleInt("SetDownsamplingType",(int)DownsamplingType);
		
		XI_RETURN res=xiSetParamInt(camera_handle, XI_PRM_DOWNSAMPLING_TYPE, DownsamplingType);
		CheckResult(res,"SetDownsamplingType");
	}
	 
	
	// Selects which test pattern generator is controlled by the test pattern feature. (XI_PRM_TEST_PATTERN_GENERATOR_SELECTOR)
	XI_TEST_PATTERN_GENERATOR xiAPIplus_Camera::GetTestPatternGeneratorSelector()
	{
		int val=0;
		
		CheckCamHandle("GetTestPatternGeneratorSelector");
		
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_TEST_PATTERN_GENERATOR_SELECTOR, &val);
		CheckResult(res,"GetTestPatternGeneratorSelector");
		return (XI_TEST_PATTERN_GENERATOR)val;
	}
	
	XI_TEST_PATTERN_GENERATOR xiAPIplus_Camera::GetTestPatternGeneratorSelector_Maximum()
	{
		int val=0;
		
		CheckCamHandle("GetTestPatternGeneratorSelector" "_Maximum");
		
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_TEST_PATTERN_GENERATOR_SELECTOR XI_PRM_INFO_MAX, &val);
		CheckResult(res,"GetTestPatternGeneratorSelector" "_Maximum");
		return (XI_TEST_PATTERN_GENERATOR)val;
	}
	
	XI_TEST_PATTERN_GENERATOR xiAPIplus_Camera::GetTestPatternGeneratorSelector_Minimum()
	{
		int val=0;
		
		CheckCamHandle("GetTestPatternGeneratorSelector" "_Minimum");
		
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_TEST_PATTERN_GENERATOR_SELECTOR XI_PRM_INFO_MIN, &val);
		CheckResult(res,"GetTestPatternGeneratorSelector" "_Minimum");
		return (XI_TEST_PATTERN_GENERATOR)val;
	}
	
	int xiAPIplus_Camera::GetTestPatternGeneratorSelector_Increment()
	{
		int val=0;
		
		CheckCamHandle("GetTestPatternGeneratorSelector" "_Increment");
		
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_TEST_PATTERN_GENERATOR_SELECTOR XI_PRM_INFO_INCREMENT, &val);
		CheckResult(res,"GetTestPatternGeneratorSelector" "_Increment");
		return val;
	}
	
	void xiAPIplus_Camera::SetTestPatternGeneratorSelector(XI_TEST_PATTERN_GENERATOR TestPatternGeneratorSelector)
	{
		
		CheckCamHandleInt("SetTestPatternGeneratorSelector",(int)TestPatternGeneratorSelector);
		
		XI_RETURN res=xiSetParamInt(camera_handle, XI_PRM_TEST_PATTERN_GENERATOR_SELECTOR, TestPatternGeneratorSelector);
		CheckResult(res,"SetTestPatternGeneratorSelector");
	}
	 
	
	// Selects which test pattern type is generated by the selected generator. (XI_PRM_TEST_PATTERN)
	XI_TEST_PATTERN xiAPIplus_Camera::GetTestPattern()
	{
		int val=0;
		
		CheckCamHandle("GetTestPattern");
		
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_TEST_PATTERN, &val);
		CheckResult(res,"GetTestPattern");
		return (XI_TEST_PATTERN)val;
	}
	
	XI_TEST_PATTERN xiAPIplus_Camera::GetTestPattern_Maximum()
	{
		int val=0;
		
		CheckCamHandle("GetTestPattern" "_Maximum");
		
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_TEST_PATTERN XI_PRM_INFO_MAX, &val);
		CheckResult(res,"GetTestPattern" "_Maximum");
		return (XI_TEST_PATTERN)val;
	}
	
	XI_TEST_PATTERN xiAPIplus_Camera::GetTestPattern_Minimum()
	{
		int val=0;
		
		CheckCamHandle("GetTestPattern" "_Minimum");
		
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_TEST_PATTERN XI_PRM_INFO_MIN, &val);
		CheckResult(res,"GetTestPattern" "_Minimum");
		return (XI_TEST_PATTERN)val;
	}
	
	int xiAPIplus_Camera::GetTestPattern_Increment()
	{
		int val=0;
		
		CheckCamHandle("GetTestPattern" "_Increment");
		
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_TEST_PATTERN XI_PRM_INFO_INCREMENT, &val);
		CheckResult(res,"GetTestPattern" "_Increment");
		return val;
	}
	
	void xiAPIplus_Camera::SetTestPattern(XI_TEST_PATTERN TestPattern)
	{
		
		CheckCamHandleInt("SetTestPattern",(int)TestPattern);
		
		XI_RETURN res=xiSetParamInt(camera_handle, XI_PRM_TEST_PATTERN, TestPattern);
		CheckResult(res,"SetTestPattern");
	}
	 
	
	// Output data format. (XI_PRM_IMAGE_DATA_FORMAT)
	XI_IMG_FORMAT xiAPIplus_Camera::GetImageDataFormat()
	{
		int val=0;
		
		CheckCamHandle("GetImageDataFormat");
		
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_IMAGE_DATA_FORMAT, &val);
		CheckResult(res,"GetImageDataFormat");
		return (XI_IMG_FORMAT)val;
	}
	
	XI_IMG_FORMAT xiAPIplus_Camera::GetImageDataFormat_Maximum()
	{
		int val=0;
		
		CheckCamHandle("GetImageDataFormat" "_Maximum");
		
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_IMAGE_DATA_FORMAT XI_PRM_INFO_MAX, &val);
		CheckResult(res,"GetImageDataFormat" "_Maximum");
		return (XI_IMG_FORMAT)val;
	}
	
	XI_IMG_FORMAT xiAPIplus_Camera::GetImageDataFormat_Minimum()
	{
		int val=0;
		
		CheckCamHandle("GetImageDataFormat" "_Minimum");
		
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_IMAGE_DATA_FORMAT XI_PRM_INFO_MIN, &val);
		CheckResult(res,"GetImageDataFormat" "_Minimum");
		return (XI_IMG_FORMAT)val;
	}
	
	int xiAPIplus_Camera::GetImageDataFormat_Increment()
	{
		int val=0;
		
		CheckCamHandle("GetImageDataFormat" "_Increment");
		
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_IMAGE_DATA_FORMAT XI_PRM_INFO_INCREMENT, &val);
		CheckResult(res,"GetImageDataFormat" "_Increment");
		return val;
	}
	
	void xiAPIplus_Camera::SetImageDataFormat(XI_IMG_FORMAT ImageDataFormat)
	{
		
		CheckCamHandleInt("SetImageDataFormat",(int)ImageDataFormat);
		
		XI_RETURN res=xiSetParamInt(camera_handle, XI_PRM_IMAGE_DATA_FORMAT, ImageDataFormat);
		CheckResult(res,"SetImageDataFormat");
	}
	 
	
	// Signedness of image data. (XI_PRM_IMAGE_DATA_SIGN)
	XI_DATA_SM xiAPIplus_Camera::GetImageDataSign()
	{
		int val=0;
		
		CheckCamHandle("GetImageDataSign");
		
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_IMAGE_DATA_SIGN, &val);
		CheckResult(res,"GetImageDataSign");
		return (XI_DATA_SM)val;
	}
	
	XI_DATA_SM xiAPIplus_Camera::GetImageDataSign_Maximum()
	{
		int val=0;
		
		CheckCamHandle("GetImageDataSign" "_Maximum");
		
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_IMAGE_DATA_SIGN XI_PRM_INFO_MAX, &val);
		CheckResult(res,"GetImageDataSign" "_Maximum");
		return (XI_DATA_SM)val;
	}
	
	XI_DATA_SM xiAPIplus_Camera::GetImageDataSign_Minimum()
	{
		int val=0;
		
		CheckCamHandle("GetImageDataSign" "_Minimum");
		
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_IMAGE_DATA_SIGN XI_PRM_INFO_MIN, &val);
		CheckResult(res,"GetImageDataSign" "_Minimum");
		return (XI_DATA_SM)val;
	}
	
	int xiAPIplus_Camera::GetImageDataSign_Increment()
	{
		int val=0;
		
		CheckCamHandle("GetImageDataSign" "_Increment");
		
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_IMAGE_DATA_SIGN XI_PRM_INFO_INCREMENT, &val);
		CheckResult(res,"GetImageDataSign" "_Increment");
		return val;
	}
	 
	
	// Change sensor shutter type(CMOS sensor). (XI_PRM_SHUTTER_TYPE)
	XI_SHUTTER_TYPE xiAPIplus_Camera::GetShutterType()
	{
		int val=0;
		
		CheckCamHandle("GetShutterType");
		
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_SHUTTER_TYPE, &val);
		CheckResult(res,"GetShutterType");
		return (XI_SHUTTER_TYPE)val;
	}
	
	XI_SHUTTER_TYPE xiAPIplus_Camera::GetShutterType_Maximum()
	{
		int val=0;
		
		CheckCamHandle("GetShutterType" "_Maximum");
		
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_SHUTTER_TYPE XI_PRM_INFO_MAX, &val);
		CheckResult(res,"GetShutterType" "_Maximum");
		return (XI_SHUTTER_TYPE)val;
	}
	
	XI_SHUTTER_TYPE xiAPIplus_Camera::GetShutterType_Minimum()
	{
		int val=0;
		
		CheckCamHandle("GetShutterType" "_Minimum");
		
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_SHUTTER_TYPE XI_PRM_INFO_MIN, &val);
		CheckResult(res,"GetShutterType" "_Minimum");
		return (XI_SHUTTER_TYPE)val;
	}
	
	int xiAPIplus_Camera::GetShutterType_Increment()
	{
		int val=0;
		
		CheckCamHandle("GetShutterType" "_Increment");
		
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_SHUTTER_TYPE XI_PRM_INFO_INCREMENT, &val);
		CheckResult(res,"GetShutterType" "_Increment");
		return val;
	}
	
	void xiAPIplus_Camera::SetShutterType(XI_SHUTTER_TYPE ShutterType)
	{
		
		CheckCamHandleInt("SetShutterType",(int)ShutterType);
		
		XI_RETURN res=xiSetParamInt(camera_handle, XI_PRM_SHUTTER_TYPE, ShutterType);
		CheckResult(res,"SetShutterType");
	}
	 
	
	// Number of taps (XI_PRM_SENSOR_TAPS)
	XI_SENSOR_TAP_CNT xiAPIplus_Camera::GetSensorTaps()
	{
		int val=0;
		
		CheckCamHandle("GetSensorTaps");
		
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_SENSOR_TAPS, &val);
		CheckResult(res,"GetSensorTaps");
		return (XI_SENSOR_TAP_CNT)val;
	}
	
	XI_SENSOR_TAP_CNT xiAPIplus_Camera::GetSensorTaps_Maximum()
	{
		int val=0;
		
		CheckCamHandle("GetSensorTaps" "_Maximum");
		
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_SENSOR_TAPS XI_PRM_INFO_MAX, &val);
		CheckResult(res,"GetSensorTaps" "_Maximum");
		return (XI_SENSOR_TAP_CNT)val;
	}
	
	XI_SENSOR_TAP_CNT xiAPIplus_Camera::GetSensorTaps_Minimum()
	{
		int val=0;
		
		CheckCamHandle("GetSensorTaps" "_Minimum");
		
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_SENSOR_TAPS XI_PRM_INFO_MIN, &val);
		CheckResult(res,"GetSensorTaps" "_Minimum");
		return (XI_SENSOR_TAP_CNT)val;
	}
	
	int xiAPIplus_Camera::GetSensorTaps_Increment()
	{
		int val=0;
		
		CheckCamHandle("GetSensorTaps" "_Increment");
		
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_SENSOR_TAPS XI_PRM_INFO_INCREMENT, &val);
		CheckResult(res,"GetSensorTaps" "_Increment");
		return val;
	}
	
	void xiAPIplus_Camera::SetSensorTaps(XI_SENSOR_TAP_CNT SensorTaps)
	{
		
		CheckCamHandleInt("SetSensorTaps",(int)SensorTaps);
		
		XI_RETURN res=xiSetParamInt(camera_handle, XI_PRM_SENSOR_TAPS, SensorTaps);
		CheckResult(res,"SetSensorTaps");
	}
	 
	
	// Automatic exposure/gain (XI_PRM_AEAG)
	bool xiAPIplus_Camera::IsAutoExposureAutoGain()
	{
		int val=0;
		
		CheckCamHandle("IsAutoExposureAutoGain");
		
		xiGetParamInt(camera_handle, XI_PRM_AEAG, &val);
		return (val!=0);
	}
	
	void xiAPIplus_Camera::EnableAutoExposureAutoGain()
	{
		
		CheckCamHandle("IsAutoExposureAutoGain");
		
		XI_RETURN res=xiSetParamInt(camera_handle, XI_PRM_AEAG, XI_ON);
		CheckResult(res,"EnableAutoExposureAutoGain");
	}

	void xiAPIplus_Camera::DisableAutoExposureAutoGain()
	{
		
		CheckCamHandle("DisableAutoExposureAutoGain");
		
		XI_RETURN res=xiSetParamInt(camera_handle, XI_PRM_AEAG, XI_OFF);
		CheckResult(res,"DisableAutoExposureAutoGain");
	}	
	 
	
	// Automatic exposure/gain ROI offset X (XI_PRM_AEAG_ROI_OFFSET_X)
	// integer type
	int xiAPIplus_Camera::GetAutoExposureAutoGainROIoffsetX()
	{
		CheckCamHandle("GetAutoExposureAutoGainROIoffsetX");
		int val=0;
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_AEAG_ROI_OFFSET_X, &val);
		CheckResult(res,"GetAutoExposureAutoGainROIoffsetX");
		return val;	
	}
	int xiAPIplus_Camera::GetAutoExposureAutoGainROIoffsetX_Maximum()
	{		
		CheckCamHandle("GetAutoExposureAutoGainROIoffsetX" "_Maximum");
		int val=0;
		CheckCamHandle("GetAutoExposureAutoGainROIoffsetX");
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_AEAG_ROI_OFFSET_X XI_PRM_INFO_MAX, &val);
		CheckResult(res,"GetAutoExposureAutoGainROIoffsetX" "_Maximum");
		return val;
	}
	
	int xiAPIplus_Camera::GetAutoExposureAutoGainROIoffsetX_Minimum()
	{
		CheckCamHandle("GetAutoExposureAutoGainROIoffsetX" "_Minimum");
		int val=0;
		CheckCamHandle("GetAutoExposureAutoGainROIoffsetX");
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_AEAG_ROI_OFFSET_X XI_PRM_INFO_MIN, &val);
		CheckResult(res,"GetAutoExposureAutoGainROIoffsetX" "_Minimum");
		return val;
	}

	int xiAPIplus_Camera::GetAutoExposureAutoGainROIoffsetX_Increment()
	{
		CheckCamHandle("GetAutoExposureAutoGainROIoffsetX" "_Increment");
		int val=0;
		CheckCamHandle("GetAutoExposureAutoGainROIoffsetX");
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_AEAG_ROI_OFFSET_X XI_PRM_INFO_INCREMENT, &val);
		CheckResult(res,"GetAutoExposureAutoGainROIoffsetX" "_Increment");
		return val;		
	}
	
	void xiAPIplus_Camera::SetAutoExposureAutoGainROIoffsetX(int AutoExposureAutoGainROIoffsetX)
	{
		
		CheckCamHandleInt("SetAutoExposureAutoGainROIoffsetX",AutoExposureAutoGainROIoffsetX);
		
		XI_RETURN res=xiSetParamInt(camera_handle, XI_PRM_AEAG_ROI_OFFSET_X, AutoExposureAutoGainROIoffsetX);
		CheckResult(res,"SetAutoExposureAutoGainROIoffsetX");
	}
	 
	
	// Automatic exposure/gain ROI offset Y (XI_PRM_AEAG_ROI_OFFSET_Y)
	// integer type
	int xiAPIplus_Camera::GetAutoExposureAutoGainROIoffsetY()
	{
		CheckCamHandle("GetAutoExposureAutoGainROIoffsetY");
		int val=0;
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_AEAG_ROI_OFFSET_Y, &val);
		CheckResult(res,"GetAutoExposureAutoGainROIoffsetY");
		return val;	
	}
	int xiAPIplus_Camera::GetAutoExposureAutoGainROIoffsetY_Maximum()
	{		
		CheckCamHandle("GetAutoExposureAutoGainROIoffsetY" "_Maximum");
		int val=0;
		CheckCamHandle("GetAutoExposureAutoGainROIoffsetY");
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_AEAG_ROI_OFFSET_Y XI_PRM_INFO_MAX, &val);
		CheckResult(res,"GetAutoExposureAutoGainROIoffsetY" "_Maximum");
		return val;
	}
	
	int xiAPIplus_Camera::GetAutoExposureAutoGainROIoffsetY_Minimum()
	{
		CheckCamHandle("GetAutoExposureAutoGainROIoffsetY" "_Minimum");
		int val=0;
		CheckCamHandle("GetAutoExposureAutoGainROIoffsetY");
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_AEAG_ROI_OFFSET_Y XI_PRM_INFO_MIN, &val);
		CheckResult(res,"GetAutoExposureAutoGainROIoffsetY" "_Minimum");
		return val;
	}

	int xiAPIplus_Camera::GetAutoExposureAutoGainROIoffsetY_Increment()
	{
		CheckCamHandle("GetAutoExposureAutoGainROIoffsetY" "_Increment");
		int val=0;
		CheckCamHandle("GetAutoExposureAutoGainROIoffsetY");
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_AEAG_ROI_OFFSET_Y XI_PRM_INFO_INCREMENT, &val);
		CheckResult(res,"GetAutoExposureAutoGainROIoffsetY" "_Increment");
		return val;		
	}
	
	void xiAPIplus_Camera::SetAutoExposureAutoGainROIoffsetY(int AutoExposureAutoGainROIoffsetY)
	{
		
		CheckCamHandleInt("SetAutoExposureAutoGainROIoffsetY",AutoExposureAutoGainROIoffsetY);
		
		XI_RETURN res=xiSetParamInt(camera_handle, XI_PRM_AEAG_ROI_OFFSET_Y, AutoExposureAutoGainROIoffsetY);
		CheckResult(res,"SetAutoExposureAutoGainROIoffsetY");
	}
	 
	
	// Automatic exposure/gain ROI Width (XI_PRM_AEAG_ROI_WIDTH)
	// integer type
	int xiAPIplus_Camera::GetAutoExposureAutoGainROIWidth()
	{
		CheckCamHandle("GetAutoExposureAutoGainROIWidth");
		int val=0;
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_AEAG_ROI_WIDTH, &val);
		CheckResult(res,"GetAutoExposureAutoGainROIWidth");
		return val;	
	}
	int xiAPIplus_Camera::GetAutoExposureAutoGainROIWidth_Maximum()
	{		
		CheckCamHandle("GetAutoExposureAutoGainROIWidth" "_Maximum");
		int val=0;
		CheckCamHandle("GetAutoExposureAutoGainROIWidth");
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_AEAG_ROI_WIDTH XI_PRM_INFO_MAX, &val);
		CheckResult(res,"GetAutoExposureAutoGainROIWidth" "_Maximum");
		return val;
	}
	
	int xiAPIplus_Camera::GetAutoExposureAutoGainROIWidth_Minimum()
	{
		CheckCamHandle("GetAutoExposureAutoGainROIWidth" "_Minimum");
		int val=0;
		CheckCamHandle("GetAutoExposureAutoGainROIWidth");
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_AEAG_ROI_WIDTH XI_PRM_INFO_MIN, &val);
		CheckResult(res,"GetAutoExposureAutoGainROIWidth" "_Minimum");
		return val;
	}

	int xiAPIplus_Camera::GetAutoExposureAutoGainROIWidth_Increment()
	{
		CheckCamHandle("GetAutoExposureAutoGainROIWidth" "_Increment");
		int val=0;
		CheckCamHandle("GetAutoExposureAutoGainROIWidth");
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_AEAG_ROI_WIDTH XI_PRM_INFO_INCREMENT, &val);
		CheckResult(res,"GetAutoExposureAutoGainROIWidth" "_Increment");
		return val;		
	}
	
	void xiAPIplus_Camera::SetAutoExposureAutoGainROIWidth(int AutoExposureAutoGainROIWidth)
	{
		
		CheckCamHandleInt("SetAutoExposureAutoGainROIWidth",AutoExposureAutoGainROIWidth);
		
		XI_RETURN res=xiSetParamInt(camera_handle, XI_PRM_AEAG_ROI_WIDTH, AutoExposureAutoGainROIWidth);
		CheckResult(res,"SetAutoExposureAutoGainROIWidth");
	}
	 
	
	// Automatic exposure/gain ROI Height (XI_PRM_AEAG_ROI_HEIGHT)
	// integer type
	int xiAPIplus_Camera::GetAutoExposureAutoGainROIHeight()
	{
		CheckCamHandle("GetAutoExposureAutoGainROIHeight");
		int val=0;
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_AEAG_ROI_HEIGHT, &val);
		CheckResult(res,"GetAutoExposureAutoGainROIHeight");
		return val;	
	}
	int xiAPIplus_Camera::GetAutoExposureAutoGainROIHeight_Maximum()
	{		
		CheckCamHandle("GetAutoExposureAutoGainROIHeight" "_Maximum");
		int val=0;
		CheckCamHandle("GetAutoExposureAutoGainROIHeight");
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_AEAG_ROI_HEIGHT XI_PRM_INFO_MAX, &val);
		CheckResult(res,"GetAutoExposureAutoGainROIHeight" "_Maximum");
		return val;
	}
	
	int xiAPIplus_Camera::GetAutoExposureAutoGainROIHeight_Minimum()
	{
		CheckCamHandle("GetAutoExposureAutoGainROIHeight" "_Minimum");
		int val=0;
		CheckCamHandle("GetAutoExposureAutoGainROIHeight");
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_AEAG_ROI_HEIGHT XI_PRM_INFO_MIN, &val);
		CheckResult(res,"GetAutoExposureAutoGainROIHeight" "_Minimum");
		return val;
	}

	int xiAPIplus_Camera::GetAutoExposureAutoGainROIHeight_Increment()
	{
		CheckCamHandle("GetAutoExposureAutoGainROIHeight" "_Increment");
		int val=0;
		CheckCamHandle("GetAutoExposureAutoGainROIHeight");
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_AEAG_ROI_HEIGHT XI_PRM_INFO_INCREMENT, &val);
		CheckResult(res,"GetAutoExposureAutoGainROIHeight" "_Increment");
		return val;		
	}
	
	void xiAPIplus_Camera::SetAutoExposureAutoGainROIHeight(int AutoExposureAutoGainROIHeight)
	{
		
		CheckCamHandleInt("SetAutoExposureAutoGainROIHeight",AutoExposureAutoGainROIHeight);
		
		XI_RETURN res=xiSetParamInt(camera_handle, XI_PRM_AEAG_ROI_HEIGHT, AutoExposureAutoGainROIHeight);
		CheckResult(res,"SetAutoExposureAutoGainROIHeight");
	}
	 
	
	// Selector of list used by Sensor Defects Correction parameter (XI_PRM_SENS_DEFECTS_CORR_LIST_SELECTOR)
	XI_SENS_DEFFECTS_CORR_LIST_SELECTOR xiAPIplus_Camera::GetSensorDefectsCorrectionListSelector()
	{
		int val=0;
		
		CheckCamHandle("GetSensorDefectsCorrectionListSelector");
		
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_SENS_DEFECTS_CORR_LIST_SELECTOR, &val);
		CheckResult(res,"GetSensorDefectsCorrectionListSelector");
		return (XI_SENS_DEFFECTS_CORR_LIST_SELECTOR)val;
	}
	
	XI_SENS_DEFFECTS_CORR_LIST_SELECTOR xiAPIplus_Camera::GetSensorDefectsCorrectionListSelector_Maximum()
	{
		int val=0;
		
		CheckCamHandle("GetSensorDefectsCorrectionListSelector" "_Maximum");
		
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_SENS_DEFECTS_CORR_LIST_SELECTOR XI_PRM_INFO_MAX, &val);
		CheckResult(res,"GetSensorDefectsCorrectionListSelector" "_Maximum");
		return (XI_SENS_DEFFECTS_CORR_LIST_SELECTOR)val;
	}
	
	XI_SENS_DEFFECTS_CORR_LIST_SELECTOR xiAPIplus_Camera::GetSensorDefectsCorrectionListSelector_Minimum()
	{
		int val=0;
		
		CheckCamHandle("GetSensorDefectsCorrectionListSelector" "_Minimum");
		
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_SENS_DEFECTS_CORR_LIST_SELECTOR XI_PRM_INFO_MIN, &val);
		CheckResult(res,"GetSensorDefectsCorrectionListSelector" "_Minimum");
		return (XI_SENS_DEFFECTS_CORR_LIST_SELECTOR)val;
	}
	
	int xiAPIplus_Camera::GetSensorDefectsCorrectionListSelector_Increment()
	{
		int val=0;
		
		CheckCamHandle("GetSensorDefectsCorrectionListSelector" "_Increment");
		
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_SENS_DEFECTS_CORR_LIST_SELECTOR XI_PRM_INFO_INCREMENT, &val);
		CheckResult(res,"GetSensorDefectsCorrectionListSelector" "_Increment");
		return val;
	}
	
	void xiAPIplus_Camera::SetSensorDefectsCorrectionListSelector(XI_SENS_DEFFECTS_CORR_LIST_SELECTOR SensorDefectsCorrectionListSelector)
	{
		
		CheckCamHandleInt("SetSensorDefectsCorrectionListSelector",(int)SensorDefectsCorrectionListSelector);
		
		XI_RETURN res=xiSetParamInt(camera_handle, XI_PRM_SENS_DEFECTS_CORR_LIST_SELECTOR, SensorDefectsCorrectionListSelector);
		CheckResult(res,"SetSensorDefectsCorrectionListSelector");
	}
	 
	
	// Sets/Gets sensor defects list in special text format (XI_PRM_SENS_DEFECTS_CORR_LIST_CONTENT)
	void xiAPIplus_Camera::GetSensDefectsCorrListContent(char* buffer, int buffer_length)
	{
		
		XI_RETURN res=xiGetParamString(camera_handle, XI_PRM_SENS_DEFECTS_CORR_LIST_CONTENT, buffer, buffer_length);
		CheckResult(res,"GetSensDefectsCorrListContent");
	}
	
	void xiAPIplus_Camera::SetSensDefectsCorrListContent(char* new_value)
	{
		
		XI_RETURN res=xiSetParamString(camera_handle, XI_PRM_SENS_DEFECTS_CORR_LIST_CONTENT, new_value, (DWORD)strlen(new_value));
		CheckResult(res,"SetSensDefectsCorrListContent");
	}
	 
	
	// Correction of sensor defects (pixels, columns, rows) enable/disable (XI_PRM_SENS_DEFECTS_CORR)
	bool xiAPIplus_Camera::IsSensorDefectsCorrection()
	{
		int val=0;
		
		CheckCamHandle("IsSensorDefectsCorrection");
		
		xiGetParamInt(camera_handle, XI_PRM_SENS_DEFECTS_CORR, &val);
		return (val!=0);
	}
	
	void xiAPIplus_Camera::EnableSensorDefectsCorrection()
	{
		
		CheckCamHandle("IsSensorDefectsCorrection");
		
		XI_RETURN res=xiSetParamInt(camera_handle, XI_PRM_SENS_DEFECTS_CORR, XI_ON);
		CheckResult(res,"EnableSensorDefectsCorrection");
	}

	void xiAPIplus_Camera::DisableSensorDefectsCorrection()
	{
		
		CheckCamHandle("DisableSensorDefectsCorrection");
		
		XI_RETURN res=xiSetParamInt(camera_handle, XI_PRM_SENS_DEFECTS_CORR, XI_OFF);
		CheckResult(res,"DisableSensorDefectsCorrection");
	}	
	 
	
	// Automatic white balance (XI_PRM_AUTO_WB)
	bool xiAPIplus_Camera::IsWhiteBalanceAuto()
	{
		int val=0;
		
		CheckCamHandle("IsWhiteBalanceAuto");
		
		xiGetParamInt(camera_handle, XI_PRM_AUTO_WB, &val);
		return (val!=0);
	}
	
	void xiAPIplus_Camera::EnableWhiteBalanceAuto()
	{
		
		CheckCamHandle("IsWhiteBalanceAuto");
		
		XI_RETURN res=xiSetParamInt(camera_handle, XI_PRM_AUTO_WB, XI_ON);
		CheckResult(res,"EnableWhiteBalanceAuto");
	}

	void xiAPIplus_Camera::DisableWhiteBalanceAuto()
	{
		
		CheckCamHandle("DisableWhiteBalanceAuto");
		
		XI_RETURN res=xiSetParamInt(camera_handle, XI_PRM_AUTO_WB, XI_OFF);
		CheckResult(res,"DisableWhiteBalanceAuto");
	}	
	 
	
	// Calculates White Balance(xiGetImage function must be called) (XI_PRM_MANUAL_WB)
	void xiAPIplus_Camera::SetWhiteBalanceManualNow(int WhiteBalanceManualNow)
	{
		
		CheckCamHandleInt("SetWhiteBalanceManualNow",WhiteBalanceManualNow);
		
		XI_RETURN res=xiSetParamInt(camera_handle, XI_PRM_MANUAL_WB, WhiteBalanceManualNow);
		CheckResult(res,"SetWhiteBalanceManualNow");
	}
	 
	
	// White balance offset X (XI_PRM_WB_ROI_OFFSET_X)
	// integer type
	int xiAPIplus_Camera::GetWhiteBalanceROIoffsetX()
	{
		CheckCamHandle("GetWhiteBalanceROIoffsetX");
		int val=0;
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_WB_ROI_OFFSET_X, &val);
		CheckResult(res,"GetWhiteBalanceROIoffsetX");
		return val;	
	}
	int xiAPIplus_Camera::GetWhiteBalanceROIoffsetX_Maximum()
	{		
		CheckCamHandle("GetWhiteBalanceROIoffsetX" "_Maximum");
		int val=0;
		CheckCamHandle("GetWhiteBalanceROIoffsetX");
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_WB_ROI_OFFSET_X XI_PRM_INFO_MAX, &val);
		CheckResult(res,"GetWhiteBalanceROIoffsetX" "_Maximum");
		return val;
	}
	
	int xiAPIplus_Camera::GetWhiteBalanceROIoffsetX_Minimum()
	{
		CheckCamHandle("GetWhiteBalanceROIoffsetX" "_Minimum");
		int val=0;
		CheckCamHandle("GetWhiteBalanceROIoffsetX");
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_WB_ROI_OFFSET_X XI_PRM_INFO_MIN, &val);
		CheckResult(res,"GetWhiteBalanceROIoffsetX" "_Minimum");
		return val;
	}

	int xiAPIplus_Camera::GetWhiteBalanceROIoffsetX_Increment()
	{
		CheckCamHandle("GetWhiteBalanceROIoffsetX" "_Increment");
		int val=0;
		CheckCamHandle("GetWhiteBalanceROIoffsetX");
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_WB_ROI_OFFSET_X XI_PRM_INFO_INCREMENT, &val);
		CheckResult(res,"GetWhiteBalanceROIoffsetX" "_Increment");
		return val;		
	}
	
	void xiAPIplus_Camera::SetWhiteBalanceROIoffsetX(int WhiteBalanceROIoffsetX)
	{
		
		CheckCamHandleInt("SetWhiteBalanceROIoffsetX",WhiteBalanceROIoffsetX);
		
		XI_RETURN res=xiSetParamInt(camera_handle, XI_PRM_WB_ROI_OFFSET_X, WhiteBalanceROIoffsetX);
		CheckResult(res,"SetWhiteBalanceROIoffsetX");
	}
	 
	
	// White balance offset Y (XI_PRM_WB_ROI_OFFSET_Y)
	// integer type
	int xiAPIplus_Camera::GetWhiteBalanceROIoffsetY()
	{
		CheckCamHandle("GetWhiteBalanceROIoffsetY");
		int val=0;
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_WB_ROI_OFFSET_Y, &val);
		CheckResult(res,"GetWhiteBalanceROIoffsetY");
		return val;	
	}
	int xiAPIplus_Camera::GetWhiteBalanceROIoffsetY_Maximum()
	{		
		CheckCamHandle("GetWhiteBalanceROIoffsetY" "_Maximum");
		int val=0;
		CheckCamHandle("GetWhiteBalanceROIoffsetY");
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_WB_ROI_OFFSET_Y XI_PRM_INFO_MAX, &val);
		CheckResult(res,"GetWhiteBalanceROIoffsetY" "_Maximum");
		return val;
	}
	
	int xiAPIplus_Camera::GetWhiteBalanceROIoffsetY_Minimum()
	{
		CheckCamHandle("GetWhiteBalanceROIoffsetY" "_Minimum");
		int val=0;
		CheckCamHandle("GetWhiteBalanceROIoffsetY");
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_WB_ROI_OFFSET_Y XI_PRM_INFO_MIN, &val);
		CheckResult(res,"GetWhiteBalanceROIoffsetY" "_Minimum");
		return val;
	}

	int xiAPIplus_Camera::GetWhiteBalanceROIoffsetY_Increment()
	{
		CheckCamHandle("GetWhiteBalanceROIoffsetY" "_Increment");
		int val=0;
		CheckCamHandle("GetWhiteBalanceROIoffsetY");
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_WB_ROI_OFFSET_Y XI_PRM_INFO_INCREMENT, &val);
		CheckResult(res,"GetWhiteBalanceROIoffsetY" "_Increment");
		return val;		
	}
	
	void xiAPIplus_Camera::SetWhiteBalanceROIoffsetY(int WhiteBalanceROIoffsetY)
	{
		
		CheckCamHandleInt("SetWhiteBalanceROIoffsetY",WhiteBalanceROIoffsetY);
		
		XI_RETURN res=xiSetParamInt(camera_handle, XI_PRM_WB_ROI_OFFSET_Y, WhiteBalanceROIoffsetY);
		CheckResult(res,"SetWhiteBalanceROIoffsetY");
	}
	 
	
	// White balance width (XI_PRM_WB_ROI_WIDTH)
	// integer type
	int xiAPIplus_Camera::GetWhiteBalanceROIWidth()
	{
		CheckCamHandle("GetWhiteBalanceROIWidth");
		int val=0;
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_WB_ROI_WIDTH, &val);
		CheckResult(res,"GetWhiteBalanceROIWidth");
		return val;	
	}
	int xiAPIplus_Camera::GetWhiteBalanceROIWidth_Maximum()
	{		
		CheckCamHandle("GetWhiteBalanceROIWidth" "_Maximum");
		int val=0;
		CheckCamHandle("GetWhiteBalanceROIWidth");
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_WB_ROI_WIDTH XI_PRM_INFO_MAX, &val);
		CheckResult(res,"GetWhiteBalanceROIWidth" "_Maximum");
		return val;
	}
	
	int xiAPIplus_Camera::GetWhiteBalanceROIWidth_Minimum()
	{
		CheckCamHandle("GetWhiteBalanceROIWidth" "_Minimum");
		int val=0;
		CheckCamHandle("GetWhiteBalanceROIWidth");
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_WB_ROI_WIDTH XI_PRM_INFO_MIN, &val);
		CheckResult(res,"GetWhiteBalanceROIWidth" "_Minimum");
		return val;
	}

	int xiAPIplus_Camera::GetWhiteBalanceROIWidth_Increment()
	{
		CheckCamHandle("GetWhiteBalanceROIWidth" "_Increment");
		int val=0;
		CheckCamHandle("GetWhiteBalanceROIWidth");
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_WB_ROI_WIDTH XI_PRM_INFO_INCREMENT, &val);
		CheckResult(res,"GetWhiteBalanceROIWidth" "_Increment");
		return val;		
	}
	
	void xiAPIplus_Camera::SetWhiteBalanceROIWidth(int WhiteBalanceROIWidth)
	{
		
		CheckCamHandleInt("SetWhiteBalanceROIWidth",WhiteBalanceROIWidth);
		
		XI_RETURN res=xiSetParamInt(camera_handle, XI_PRM_WB_ROI_WIDTH, WhiteBalanceROIWidth);
		CheckResult(res,"SetWhiteBalanceROIWidth");
	}
	 
	
	// White balance height (XI_PRM_WB_ROI_HEIGHT)
	// integer type
	int xiAPIplus_Camera::GetWhiteBalanceROIHeight()
	{
		CheckCamHandle("GetWhiteBalanceROIHeight");
		int val=0;
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_WB_ROI_HEIGHT, &val);
		CheckResult(res,"GetWhiteBalanceROIHeight");
		return val;	
	}
	int xiAPIplus_Camera::GetWhiteBalanceROIHeight_Maximum()
	{		
		CheckCamHandle("GetWhiteBalanceROIHeight" "_Maximum");
		int val=0;
		CheckCamHandle("GetWhiteBalanceROIHeight");
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_WB_ROI_HEIGHT XI_PRM_INFO_MAX, &val);
		CheckResult(res,"GetWhiteBalanceROIHeight" "_Maximum");
		return val;
	}
	
	int xiAPIplus_Camera::GetWhiteBalanceROIHeight_Minimum()
	{
		CheckCamHandle("GetWhiteBalanceROIHeight" "_Minimum");
		int val=0;
		CheckCamHandle("GetWhiteBalanceROIHeight");
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_WB_ROI_HEIGHT XI_PRM_INFO_MIN, &val);
		CheckResult(res,"GetWhiteBalanceROIHeight" "_Minimum");
		return val;
	}

	int xiAPIplus_Camera::GetWhiteBalanceROIHeight_Increment()
	{
		CheckCamHandle("GetWhiteBalanceROIHeight" "_Increment");
		int val=0;
		CheckCamHandle("GetWhiteBalanceROIHeight");
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_WB_ROI_HEIGHT XI_PRM_INFO_INCREMENT, &val);
		CheckResult(res,"GetWhiteBalanceROIHeight" "_Increment");
		return val;		
	}
	
	void xiAPIplus_Camera::SetWhiteBalanceROIHeight(int WhiteBalanceROIHeight)
	{
		
		CheckCamHandleInt("SetWhiteBalanceROIHeight",WhiteBalanceROIHeight);
		
		XI_RETURN res=xiSetParamInt(camera_handle, XI_PRM_WB_ROI_HEIGHT, WhiteBalanceROIHeight);
		CheckResult(res,"SetWhiteBalanceROIHeight");
	}
	 
	
	// White balance red coefficient (XI_PRM_WB_KR)
	float xiAPIplus_Camera::GetWhiteBalanceRed()
	{
		float val=0;
		
		CheckCamHandle("GetWhiteBalanceRed");
		
		XI_RETURN res=xiGetParamFloat(camera_handle, XI_PRM_WB_KR, &val);
		CheckResult(res,"GetWhiteBalanceRed");
		return val;
	}

	float xiAPIplus_Camera::GetWhiteBalanceRed_Maximum()
	{
		float val=0;
		
		CheckCamHandle("GetWhiteBalanceRed" "_Maximum");
		
		XI_RETURN res=xiGetParamFloat(camera_handle, XI_PRM_WB_KR XI_PRM_INFO_MAX, &val);
		CheckResult(res,"GetWhiteBalanceRed" "_Maximum");
		return val;
	}

	float xiAPIplus_Camera::GetWhiteBalanceRed_Minimum()
	{
		float val=0;
		
		CheckCamHandle("GetWhiteBalanceRed" "_Minimum");
		
		XI_RETURN res=xiGetParamFloat(camera_handle, XI_PRM_WB_KR XI_PRM_INFO_MIN, &val);
		CheckResult(res,"GetWhiteBalanceRed" "_Minimum");
		return val;
	}

	float xiAPIplus_Camera::GetWhiteBalanceRed_Increment()
	{
		float val=0;
		
		CheckCamHandle("GetWhiteBalanceRed" "_Increment");
		
		XI_RETURN res=xiGetParamFloat(camera_handle, XI_PRM_WB_KR XI_PRM_INFO_INCREMENT, &val);
		CheckResult(res,"GetWhiteBalanceRed" "_Increment");
		return val;
	}
	
	void xiAPIplus_Camera::SetWhiteBalanceRed(float WhiteBalanceRed)
	{
		
		CheckCamHandle("SetWhiteBalanceRed");
		
		XI_RETURN res=xiSetParamFloat(camera_handle, XI_PRM_WB_KR, WhiteBalanceRed);
		CheckResult(res,"SetWhiteBalanceRed");
	}
	 
	
	// White balance green coefficient (XI_PRM_WB_KG)
	float xiAPIplus_Camera::GetWhiteBalanceGreen()
	{
		float val=0;
		
		CheckCamHandle("GetWhiteBalanceGreen");
		
		XI_RETURN res=xiGetParamFloat(camera_handle, XI_PRM_WB_KG, &val);
		CheckResult(res,"GetWhiteBalanceGreen");
		return val;
	}

	float xiAPIplus_Camera::GetWhiteBalanceGreen_Maximum()
	{
		float val=0;
		
		CheckCamHandle("GetWhiteBalanceGreen" "_Maximum");
		
		XI_RETURN res=xiGetParamFloat(camera_handle, XI_PRM_WB_KG XI_PRM_INFO_MAX, &val);
		CheckResult(res,"GetWhiteBalanceGreen" "_Maximum");
		return val;
	}

	float xiAPIplus_Camera::GetWhiteBalanceGreen_Minimum()
	{
		float val=0;
		
		CheckCamHandle("GetWhiteBalanceGreen" "_Minimum");
		
		XI_RETURN res=xiGetParamFloat(camera_handle, XI_PRM_WB_KG XI_PRM_INFO_MIN, &val);
		CheckResult(res,"GetWhiteBalanceGreen" "_Minimum");
		return val;
	}

	float xiAPIplus_Camera::GetWhiteBalanceGreen_Increment()
	{
		float val=0;
		
		CheckCamHandle("GetWhiteBalanceGreen" "_Increment");
		
		XI_RETURN res=xiGetParamFloat(camera_handle, XI_PRM_WB_KG XI_PRM_INFO_INCREMENT, &val);
		CheckResult(res,"GetWhiteBalanceGreen" "_Increment");
		return val;
	}
	
	void xiAPIplus_Camera::SetWhiteBalanceGreen(float WhiteBalanceGreen)
	{
		
		CheckCamHandle("SetWhiteBalanceGreen");
		
		XI_RETURN res=xiSetParamFloat(camera_handle, XI_PRM_WB_KG, WhiteBalanceGreen);
		CheckResult(res,"SetWhiteBalanceGreen");
	}
	 
	
	// White balance blue coefficient (XI_PRM_WB_KB)
	float xiAPIplus_Camera::GetWhiteBalanceBlue()
	{
		float val=0;
		
		CheckCamHandle("GetWhiteBalanceBlue");
		
		XI_RETURN res=xiGetParamFloat(camera_handle, XI_PRM_WB_KB, &val);
		CheckResult(res,"GetWhiteBalanceBlue");
		return val;
	}

	float xiAPIplus_Camera::GetWhiteBalanceBlue_Maximum()
	{
		float val=0;
		
		CheckCamHandle("GetWhiteBalanceBlue" "_Maximum");
		
		XI_RETURN res=xiGetParamFloat(camera_handle, XI_PRM_WB_KB XI_PRM_INFO_MAX, &val);
		CheckResult(res,"GetWhiteBalanceBlue" "_Maximum");
		return val;
	}

	float xiAPIplus_Camera::GetWhiteBalanceBlue_Minimum()
	{
		float val=0;
		
		CheckCamHandle("GetWhiteBalanceBlue" "_Minimum");
		
		XI_RETURN res=xiGetParamFloat(camera_handle, XI_PRM_WB_KB XI_PRM_INFO_MIN, &val);
		CheckResult(res,"GetWhiteBalanceBlue" "_Minimum");
		return val;
	}

	float xiAPIplus_Camera::GetWhiteBalanceBlue_Increment()
	{
		float val=0;
		
		CheckCamHandle("GetWhiteBalanceBlue" "_Increment");
		
		XI_RETURN res=xiGetParamFloat(camera_handle, XI_PRM_WB_KB XI_PRM_INFO_INCREMENT, &val);
		CheckResult(res,"GetWhiteBalanceBlue" "_Increment");
		return val;
	}
	
	void xiAPIplus_Camera::SetWhiteBalanceBlue(float WhiteBalanceBlue)
	{
		
		CheckCamHandle("SetWhiteBalanceBlue");
		
		XI_RETURN res=xiSetParamFloat(camera_handle, XI_PRM_WB_KB, WhiteBalanceBlue);
		CheckResult(res,"SetWhiteBalanceBlue");
	}
	 
	
	// Width of the Image provided by the device (in pixels). (XI_PRM_WIDTH)
	// integer type
	int xiAPIplus_Camera::GetWidth()
	{
		CheckCamHandle("GetWidth");
		int val=0;
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_WIDTH, &val);
		CheckResult(res,"GetWidth");
		return val;	
	}
	int xiAPIplus_Camera::GetWidth_Maximum()
	{		
		CheckCamHandle("GetWidth" "_Maximum");
		int val=0;
		CheckCamHandle("GetWidth");
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_WIDTH XI_PRM_INFO_MAX, &val);
		CheckResult(res,"GetWidth" "_Maximum");
		return val;
	}
	
	int xiAPIplus_Camera::GetWidth_Minimum()
	{
		CheckCamHandle("GetWidth" "_Minimum");
		int val=0;
		CheckCamHandle("GetWidth");
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_WIDTH XI_PRM_INFO_MIN, &val);
		CheckResult(res,"GetWidth" "_Minimum");
		return val;
	}

	int xiAPIplus_Camera::GetWidth_Increment()
	{
		CheckCamHandle("GetWidth" "_Increment");
		int val=0;
		CheckCamHandle("GetWidth");
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_WIDTH XI_PRM_INFO_INCREMENT, &val);
		CheckResult(res,"GetWidth" "_Increment");
		return val;		
	}
	
	void xiAPIplus_Camera::SetWidth(int Width)
	{
		
		CheckCamHandleInt("SetWidth",Width);
		
		XI_RETURN res=xiSetParamInt(camera_handle, XI_PRM_WIDTH, Width);
		CheckResult(res,"SetWidth");
	}
	 
	
	// Height of the Image provided by the device (in pixels). (XI_PRM_HEIGHT)
	// integer type
	int xiAPIplus_Camera::GetHeight()
	{
		CheckCamHandle("GetHeight");
		int val=0;
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_HEIGHT, &val);
		CheckResult(res,"GetHeight");
		return val;	
	}
	int xiAPIplus_Camera::GetHeight_Maximum()
	{		
		CheckCamHandle("GetHeight" "_Maximum");
		int val=0;
		CheckCamHandle("GetHeight");
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_HEIGHT XI_PRM_INFO_MAX, &val);
		CheckResult(res,"GetHeight" "_Maximum");
		return val;
	}
	
	int xiAPIplus_Camera::GetHeight_Minimum()
	{
		CheckCamHandle("GetHeight" "_Minimum");
		int val=0;
		CheckCamHandle("GetHeight");
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_HEIGHT XI_PRM_INFO_MIN, &val);
		CheckResult(res,"GetHeight" "_Minimum");
		return val;
	}

	int xiAPIplus_Camera::GetHeight_Increment()
	{
		CheckCamHandle("GetHeight" "_Increment");
		int val=0;
		CheckCamHandle("GetHeight");
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_HEIGHT XI_PRM_INFO_INCREMENT, &val);
		CheckResult(res,"GetHeight" "_Increment");
		return val;		
	}
	
	void xiAPIplus_Camera::SetHeight(int Height)
	{
		
		CheckCamHandleInt("SetHeight",Height);
		
		XI_RETURN res=xiSetParamInt(camera_handle, XI_PRM_HEIGHT, Height);
		CheckResult(res,"SetHeight");
	}
	 
	
	// Horizontal offset from the origin to the area of interest (in pixels). (XI_PRM_OFFSET_X)
	// integer type
	int xiAPIplus_Camera::GetOffsetX()
	{
		CheckCamHandle("GetOffsetX");
		int val=0;
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_OFFSET_X, &val);
		CheckResult(res,"GetOffsetX");
		return val;	
	}
	int xiAPIplus_Camera::GetOffsetX_Maximum()
	{		
		CheckCamHandle("GetOffsetX" "_Maximum");
		int val=0;
		CheckCamHandle("GetOffsetX");
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_OFFSET_X XI_PRM_INFO_MAX, &val);
		CheckResult(res,"GetOffsetX" "_Maximum");
		return val;
	}
	
	int xiAPIplus_Camera::GetOffsetX_Minimum()
	{
		CheckCamHandle("GetOffsetX" "_Minimum");
		int val=0;
		CheckCamHandle("GetOffsetX");
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_OFFSET_X XI_PRM_INFO_MIN, &val);
		CheckResult(res,"GetOffsetX" "_Minimum");
		return val;
	}

	int xiAPIplus_Camera::GetOffsetX_Increment()
	{
		CheckCamHandle("GetOffsetX" "_Increment");
		int val=0;
		CheckCamHandle("GetOffsetX");
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_OFFSET_X XI_PRM_INFO_INCREMENT, &val);
		CheckResult(res,"GetOffsetX" "_Increment");
		return val;		
	}
	
	void xiAPIplus_Camera::SetOffsetX(int OffsetX)
	{
		
		CheckCamHandleInt("SetOffsetX",OffsetX);
		
		XI_RETURN res=xiSetParamInt(camera_handle, XI_PRM_OFFSET_X, OffsetX);
		CheckResult(res,"SetOffsetX");
	}
	 
	
	// Vertical offset from the origin to the area of interest (in pixels). (XI_PRM_OFFSET_Y)
	// integer type
	int xiAPIplus_Camera::GetOffsetY()
	{
		CheckCamHandle("GetOffsetY");
		int val=0;
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_OFFSET_Y, &val);
		CheckResult(res,"GetOffsetY");
		return val;	
	}
	int xiAPIplus_Camera::GetOffsetY_Maximum()
	{		
		CheckCamHandle("GetOffsetY" "_Maximum");
		int val=0;
		CheckCamHandle("GetOffsetY");
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_OFFSET_Y XI_PRM_INFO_MAX, &val);
		CheckResult(res,"GetOffsetY" "_Maximum");
		return val;
	}
	
	int xiAPIplus_Camera::GetOffsetY_Minimum()
	{
		CheckCamHandle("GetOffsetY" "_Minimum");
		int val=0;
		CheckCamHandle("GetOffsetY");
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_OFFSET_Y XI_PRM_INFO_MIN, &val);
		CheckResult(res,"GetOffsetY" "_Minimum");
		return val;
	}

	int xiAPIplus_Camera::GetOffsetY_Increment()
	{
		CheckCamHandle("GetOffsetY" "_Increment");
		int val=0;
		CheckCamHandle("GetOffsetY");
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_OFFSET_Y XI_PRM_INFO_INCREMENT, &val);
		CheckResult(res,"GetOffsetY" "_Increment");
		return val;		
	}
	
	void xiAPIplus_Camera::SetOffsetY(int OffsetY)
	{
		
		CheckCamHandleInt("SetOffsetY",OffsetY);
		
		XI_RETURN res=xiSetParamInt(camera_handle, XI_PRM_OFFSET_Y, OffsetY);
		CheckResult(res,"SetOffsetY");
	}
	 
	
	// Selects Region in Multiple ROI which parameters are set by width, height, ... ,region mode (XI_PRM_REGION_SELECTOR)
	// integer type
	int xiAPIplus_Camera::GetRegionSelector()
	{
		CheckCamHandle("GetRegionSelector");
		int val=0;
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_REGION_SELECTOR, &val);
		CheckResult(res,"GetRegionSelector");
		return val;	
	}
	int xiAPIplus_Camera::GetRegionSelector_Maximum()
	{		
		CheckCamHandle("GetRegionSelector" "_Maximum");
		int val=0;
		CheckCamHandle("GetRegionSelector");
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_REGION_SELECTOR XI_PRM_INFO_MAX, &val);
		CheckResult(res,"GetRegionSelector" "_Maximum");
		return val;
	}
	
	int xiAPIplus_Camera::GetRegionSelector_Minimum()
	{
		CheckCamHandle("GetRegionSelector" "_Minimum");
		int val=0;
		CheckCamHandle("GetRegionSelector");
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_REGION_SELECTOR XI_PRM_INFO_MIN, &val);
		CheckResult(res,"GetRegionSelector" "_Minimum");
		return val;
	}

	int xiAPIplus_Camera::GetRegionSelector_Increment()
	{
		CheckCamHandle("GetRegionSelector" "_Increment");
		int val=0;
		CheckCamHandle("GetRegionSelector");
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_REGION_SELECTOR XI_PRM_INFO_INCREMENT, &val);
		CheckResult(res,"GetRegionSelector" "_Increment");
		return val;		
	}
	
	void xiAPIplus_Camera::SetRegionSelector(int RegionSelector)
	{
		
		CheckCamHandleInt("SetRegionSelector",RegionSelector);
		
		XI_RETURN res=xiSetParamInt(camera_handle, XI_PRM_REGION_SELECTOR, RegionSelector);
		CheckResult(res,"SetRegionSelector");
	}
	 
	
	// Activates/deactivates Region selected by Region Selector (XI_PRM_REGION_MODE)
	// integer type
	int xiAPIplus_Camera::GetRegionMode()
	{
		CheckCamHandle("GetRegionMode");
		int val=0;
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_REGION_MODE, &val);
		CheckResult(res,"GetRegionMode");
		return val;	
	}
	int xiAPIplus_Camera::GetRegionMode_Maximum()
	{		
		CheckCamHandle("GetRegionMode" "_Maximum");
		int val=0;
		CheckCamHandle("GetRegionMode");
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_REGION_MODE XI_PRM_INFO_MAX, &val);
		CheckResult(res,"GetRegionMode" "_Maximum");
		return val;
	}
	
	int xiAPIplus_Camera::GetRegionMode_Minimum()
	{
		CheckCamHandle("GetRegionMode" "_Minimum");
		int val=0;
		CheckCamHandle("GetRegionMode");
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_REGION_MODE XI_PRM_INFO_MIN, &val);
		CheckResult(res,"GetRegionMode" "_Minimum");
		return val;
	}

	int xiAPIplus_Camera::GetRegionMode_Increment()
	{
		CheckCamHandle("GetRegionMode" "_Increment");
		int val=0;
		CheckCamHandle("GetRegionMode");
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_REGION_MODE XI_PRM_INFO_INCREMENT, &val);
		CheckResult(res,"GetRegionMode" "_Increment");
		return val;		
	}
	
	void xiAPIplus_Camera::SetRegionMode(int RegionMode)
	{
		
		CheckCamHandleInt("SetRegionMode",RegionMode);
		
		XI_RETURN res=xiSetParamInt(camera_handle, XI_PRM_REGION_MODE, RegionMode);
		CheckResult(res,"SetRegionMode");
	}
	 
	
	// Horizontal flip enable (XI_PRM_HORIZONTAL_FLIP)
	bool xiAPIplus_Camera::IsHorizontalFlip()
	{
		int val=0;
		
		CheckCamHandle("IsHorizontalFlip");
		
		xiGetParamInt(camera_handle, XI_PRM_HORIZONTAL_FLIP, &val);
		return (val!=0);
	}
	
	void xiAPIplus_Camera::EnableHorizontalFlip()
	{
		
		CheckCamHandle("IsHorizontalFlip");
		
		XI_RETURN res=xiSetParamInt(camera_handle, XI_PRM_HORIZONTAL_FLIP, XI_ON);
		CheckResult(res,"EnableHorizontalFlip");
	}

	void xiAPIplus_Camera::DisableHorizontalFlip()
	{
		
		CheckCamHandle("DisableHorizontalFlip");
		
		XI_RETURN res=xiSetParamInt(camera_handle, XI_PRM_HORIZONTAL_FLIP, XI_OFF);
		CheckResult(res,"DisableHorizontalFlip");
	}	
	 
	
	// Vertical flip enable (XI_PRM_VERTICAL_FLIP)
	bool xiAPIplus_Camera::IsVerticalFlip()
	{
		int val=0;
		
		CheckCamHandle("IsVerticalFlip");
		
		xiGetParamInt(camera_handle, XI_PRM_VERTICAL_FLIP, &val);
		return (val!=0);
	}
	
	void xiAPIplus_Camera::EnableVerticalFlip()
	{
		
		CheckCamHandle("IsVerticalFlip");
		
		XI_RETURN res=xiSetParamInt(camera_handle, XI_PRM_VERTICAL_FLIP, XI_ON);
		CheckResult(res,"EnableVerticalFlip");
	}

	void xiAPIplus_Camera::DisableVerticalFlip()
	{
		
		CheckCamHandle("DisableVerticalFlip");
		
		XI_RETURN res=xiSetParamInt(camera_handle, XI_PRM_VERTICAL_FLIP, XI_OFF);
		CheckResult(res,"DisableVerticalFlip");
	}	
	 
	
	// Selector for Exposure parameter (XI_PRM_INTERLINE_EXPOSURE_MODE)
	XI_INTERLINE_EXPOSURE_MODE_TYPE xiAPIplus_Camera::GetInterlineExposureMode()
	{
		int val=0;
		
		CheckCamHandle("GetInterlineExposureMode");
		
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_INTERLINE_EXPOSURE_MODE, &val);
		CheckResult(res,"GetInterlineExposureMode");
		return (XI_INTERLINE_EXPOSURE_MODE_TYPE)val;
	}
	
	XI_INTERLINE_EXPOSURE_MODE_TYPE xiAPIplus_Camera::GetInterlineExposureMode_Maximum()
	{
		int val=0;
		
		CheckCamHandle("GetInterlineExposureMode" "_Maximum");
		
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_INTERLINE_EXPOSURE_MODE XI_PRM_INFO_MAX, &val);
		CheckResult(res,"GetInterlineExposureMode" "_Maximum");
		return (XI_INTERLINE_EXPOSURE_MODE_TYPE)val;
	}
	
	XI_INTERLINE_EXPOSURE_MODE_TYPE xiAPIplus_Camera::GetInterlineExposureMode_Minimum()
	{
		int val=0;
		
		CheckCamHandle("GetInterlineExposureMode" "_Minimum");
		
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_INTERLINE_EXPOSURE_MODE XI_PRM_INFO_MIN, &val);
		CheckResult(res,"GetInterlineExposureMode" "_Minimum");
		return (XI_INTERLINE_EXPOSURE_MODE_TYPE)val;
	}
	
	int xiAPIplus_Camera::GetInterlineExposureMode_Increment()
	{
		int val=0;
		
		CheckCamHandle("GetInterlineExposureMode" "_Increment");
		
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_INTERLINE_EXPOSURE_MODE XI_PRM_INFO_INCREMENT, &val);
		CheckResult(res,"GetInterlineExposureMode" "_Increment");
		return val;
	}
	
	void xiAPIplus_Camera::SetInterlineExposureMode(XI_INTERLINE_EXPOSURE_MODE_TYPE InterlineExposureMode)
	{
		
		CheckCamHandleInt("SetInterlineExposureMode",(int)InterlineExposureMode);
		
		XI_RETURN res=xiSetParamInt(camera_handle, XI_PRM_INTERLINE_EXPOSURE_MODE, InterlineExposureMode);
		CheckResult(res,"SetInterlineExposureMode");
	}
	 
	
	// Image flat field correction (XI_PRM_FFC)
	bool xiAPIplus_Camera::IsFlatFieldCorrection()
	{
		int val=0;
		
		CheckCamHandle("IsFlatFieldCorrection");
		
		xiGetParamInt(camera_handle, XI_PRM_FFC, &val);
		return (val!=0);
	}
	
	void xiAPIplus_Camera::EnableFlatFieldCorrection()
	{
		
		CheckCamHandle("IsFlatFieldCorrection");
		
		XI_RETURN res=xiSetParamInt(camera_handle, XI_PRM_FFC, XI_ON);
		CheckResult(res,"EnableFlatFieldCorrection");
	}

	void xiAPIplus_Camera::DisableFlatFieldCorrection()
	{
		
		CheckCamHandle("DisableFlatFieldCorrection");
		
		XI_RETURN res=xiSetParamInt(camera_handle, XI_PRM_FFC, XI_OFF);
		CheckResult(res,"DisableFlatFieldCorrection");
	}	
	 
	
	// Set name of file to be applied for FFC processor. (XI_PRM_FFC_FLAT_FIELD_FILE_NAME)
	void xiAPIplus_Camera::GetFFCFlatFieldFileName(char* buffer, int buffer_length)
	{
		
		XI_RETURN res=xiGetParamString(camera_handle, XI_PRM_FFC_FLAT_FIELD_FILE_NAME, buffer, buffer_length);
		CheckResult(res,"GetFFCFlatFieldFileName");
	}
	
	void xiAPIplus_Camera::SetFFCFlatFieldFileName(char* new_value)
	{
		
		XI_RETURN res=xiSetParamString(camera_handle, XI_PRM_FFC_FLAT_FIELD_FILE_NAME, new_value, (DWORD)strlen(new_value));
		CheckResult(res,"SetFFCFlatFieldFileName");
	}
	 
	
	// Set name of file to be applied for FFC processor. (XI_PRM_FFC_DARK_FIELD_FILE_NAME)
	void xiAPIplus_Camera::GetFFCDarkFieldFileName(char* buffer, int buffer_length)
	{
		
		XI_RETURN res=xiGetParamString(camera_handle, XI_PRM_FFC_DARK_FIELD_FILE_NAME, buffer, buffer_length);
		CheckResult(res,"GetFFCDarkFieldFileName");
	}
	
	void xiAPIplus_Camera::SetFFCDarkFieldFileName(char* new_value)
	{
		
		XI_RETURN res=xiSetParamString(camera_handle, XI_PRM_FFC_DARK_FIELD_FILE_NAME, new_value, (DWORD)strlen(new_value));
		CheckResult(res,"SetFFCDarkFieldFileName");
	}
	 
	
	// Sets ToF Readout Mode (XI_PRM_TOF_READOUT_MODE)
	XI_TOF_READOUT_MODE xiAPIplus_Camera::GetTofReadoutMode()
	{
		int val=0;
		
		CheckCamHandle("GetTofReadoutMode");
		
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_TOF_READOUT_MODE, &val);
		CheckResult(res,"GetTofReadoutMode");
		return (XI_TOF_READOUT_MODE)val;
	}
	
	XI_TOF_READOUT_MODE xiAPIplus_Camera::GetTofReadoutMode_Maximum()
	{
		int val=0;
		
		CheckCamHandle("GetTofReadoutMode" "_Maximum");
		
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_TOF_READOUT_MODE XI_PRM_INFO_MAX, &val);
		CheckResult(res,"GetTofReadoutMode" "_Maximum");
		return (XI_TOF_READOUT_MODE)val;
	}
	
	XI_TOF_READOUT_MODE xiAPIplus_Camera::GetTofReadoutMode_Minimum()
	{
		int val=0;
		
		CheckCamHandle("GetTofReadoutMode" "_Minimum");
		
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_TOF_READOUT_MODE XI_PRM_INFO_MIN, &val);
		CheckResult(res,"GetTofReadoutMode" "_Minimum");
		return (XI_TOF_READOUT_MODE)val;
	}
	
	int xiAPIplus_Camera::GetTofReadoutMode_Increment()
	{
		int val=0;
		
		CheckCamHandle("GetTofReadoutMode" "_Increment");
		
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_TOF_READOUT_MODE XI_PRM_INFO_INCREMENT, &val);
		CheckResult(res,"GetTofReadoutMode" "_Increment");
		return val;
	}
	
	void xiAPIplus_Camera::SetTofReadoutMode(XI_TOF_READOUT_MODE TofReadoutMode)
	{
		
		CheckCamHandleInt("SetTofReadoutMode",(int)TofReadoutMode);
		
		XI_RETURN res=xiSetParamInt(camera_handle, XI_PRM_TOF_READOUT_MODE, TofReadoutMode);
		CheckResult(res,"SetTofReadoutMode");
	}
	 
	
	// Sets ToF Modulation Frequency in MHz (XI_PRM_TOF_MODULATION_FREQUENCY)
	float xiAPIplus_Camera::GetTofModulationFrequency()
	{
		float val=0;
		
		CheckCamHandle("GetTofModulationFrequency");
		
		XI_RETURN res=xiGetParamFloat(camera_handle, XI_PRM_TOF_MODULATION_FREQUENCY, &val);
		CheckResult(res,"GetTofModulationFrequency");
		return val;
	}

	float xiAPIplus_Camera::GetTofModulationFrequency_Maximum()
	{
		float val=0;
		
		CheckCamHandle("GetTofModulationFrequency" "_Maximum");
		
		XI_RETURN res=xiGetParamFloat(camera_handle, XI_PRM_TOF_MODULATION_FREQUENCY XI_PRM_INFO_MAX, &val);
		CheckResult(res,"GetTofModulationFrequency" "_Maximum");
		return val;
	}

	float xiAPIplus_Camera::GetTofModulationFrequency_Minimum()
	{
		float val=0;
		
		CheckCamHandle("GetTofModulationFrequency" "_Minimum");
		
		XI_RETURN res=xiGetParamFloat(camera_handle, XI_PRM_TOF_MODULATION_FREQUENCY XI_PRM_INFO_MIN, &val);
		CheckResult(res,"GetTofModulationFrequency" "_Minimum");
		return val;
	}

	float xiAPIplus_Camera::GetTofModulationFrequency_Increment()
	{
		float val=0;
		
		CheckCamHandle("GetTofModulationFrequency" "_Increment");
		
		XI_RETURN res=xiGetParamFloat(camera_handle, XI_PRM_TOF_MODULATION_FREQUENCY XI_PRM_INFO_INCREMENT, &val);
		CheckResult(res,"GetTofModulationFrequency" "_Increment");
		return val;
	}
	
	void xiAPIplus_Camera::SetTofModulationFrequency(float TofModulationFrequency)
	{
		
		CheckCamHandle("SetTofModulationFrequency");
		
		XI_RETURN res=xiSetParamFloat(camera_handle, XI_PRM_TOF_MODULATION_FREQUENCY, TofModulationFrequency);
		CheckResult(res,"SetTofModulationFrequency");
	}
	 
	
	// is multiple ToF phases concatenated in buffer (XI_PRM_TOF_MULTIPLE_PHASES_IN_BUFFER)
	// integer type
	int xiAPIplus_Camera::GetTofMultiplePhasesInBuffer()
	{
		CheckCamHandle("GetTofMultiplePhasesInBuffer");
		int val=0;
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_TOF_MULTIPLE_PHASES_IN_BUFFER, &val);
		CheckResult(res,"GetTofMultiplePhasesInBuffer");
		return val;	
	}
	int xiAPIplus_Camera::GetTofMultiplePhasesInBuffer_Maximum()
	{		
		CheckCamHandle("GetTofMultiplePhasesInBuffer" "_Maximum");
		int val=0;
		CheckCamHandle("GetTofMultiplePhasesInBuffer");
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_TOF_MULTIPLE_PHASES_IN_BUFFER XI_PRM_INFO_MAX, &val);
		CheckResult(res,"GetTofMultiplePhasesInBuffer" "_Maximum");
		return val;
	}
	
	int xiAPIplus_Camera::GetTofMultiplePhasesInBuffer_Minimum()
	{
		CheckCamHandle("GetTofMultiplePhasesInBuffer" "_Minimum");
		int val=0;
		CheckCamHandle("GetTofMultiplePhasesInBuffer");
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_TOF_MULTIPLE_PHASES_IN_BUFFER XI_PRM_INFO_MIN, &val);
		CheckResult(res,"GetTofMultiplePhasesInBuffer" "_Minimum");
		return val;
	}

	int xiAPIplus_Camera::GetTofMultiplePhasesInBuffer_Increment()
	{
		CheckCamHandle("GetTofMultiplePhasesInBuffer" "_Increment");
		int val=0;
		CheckCamHandle("GetTofMultiplePhasesInBuffer");
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_TOF_MULTIPLE_PHASES_IN_BUFFER XI_PRM_INFO_INCREMENT, &val);
		CheckResult(res,"GetTofMultiplePhasesInBuffer" "_Increment");
		return val;		
	}
	 
	
	// Sets the number of tof phases. E.g. 4 for four phases. (XI_PRM_TOF_PHASES_COUNT)
	// integer type
	int xiAPIplus_Camera::GetTofPhasesCount()
	{
		CheckCamHandle("GetTofPhasesCount");
		int val=0;
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_TOF_PHASES_COUNT, &val);
		CheckResult(res,"GetTofPhasesCount");
		return val;	
	}
	int xiAPIplus_Camera::GetTofPhasesCount_Maximum()
	{		
		CheckCamHandle("GetTofPhasesCount" "_Maximum");
		int val=0;
		CheckCamHandle("GetTofPhasesCount");
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_TOF_PHASES_COUNT XI_PRM_INFO_MAX, &val);
		CheckResult(res,"GetTofPhasesCount" "_Maximum");
		return val;
	}
	
	int xiAPIplus_Camera::GetTofPhasesCount_Minimum()
	{
		CheckCamHandle("GetTofPhasesCount" "_Minimum");
		int val=0;
		CheckCamHandle("GetTofPhasesCount");
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_TOF_PHASES_COUNT XI_PRM_INFO_MIN, &val);
		CheckResult(res,"GetTofPhasesCount" "_Minimum");
		return val;
	}

	int xiAPIplus_Camera::GetTofPhasesCount_Increment()
	{
		CheckCamHandle("GetTofPhasesCount" "_Increment");
		int val=0;
		CheckCamHandle("GetTofPhasesCount");
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_TOF_PHASES_COUNT XI_PRM_INFO_INCREMENT, &val);
		CheckResult(res,"GetTofPhasesCount" "_Increment");
		return val;		
	}
	
	void xiAPIplus_Camera::SetTofPhasesCount(int TofPhasesCount)
	{
		
		CheckCamHandleInt("SetTofPhasesCount",TofPhasesCount);
		
		XI_RETURN res=xiSetParamInt(camera_handle, XI_PRM_TOF_PHASES_COUNT, TofPhasesCount);
		CheckResult(res,"SetTofPhasesCount");
	}
	 
	
	// Sets Illumination angle for selected ToF phase (XI_PRM_TOF_PHASE_ANGLE)
	float xiAPIplus_Camera::GetTofPhaseAngle()
	{
		float val=0;
		
		CheckCamHandle("GetTofPhaseAngle");
		
		XI_RETURN res=xiGetParamFloat(camera_handle, XI_PRM_TOF_PHASE_ANGLE, &val);
		CheckResult(res,"GetTofPhaseAngle");
		return val;
	}

	float xiAPIplus_Camera::GetTofPhaseAngle_Maximum()
	{
		float val=0;
		
		CheckCamHandle("GetTofPhaseAngle" "_Maximum");
		
		XI_RETURN res=xiGetParamFloat(camera_handle, XI_PRM_TOF_PHASE_ANGLE XI_PRM_INFO_MAX, &val);
		CheckResult(res,"GetTofPhaseAngle" "_Maximum");
		return val;
	}

	float xiAPIplus_Camera::GetTofPhaseAngle_Minimum()
	{
		float val=0;
		
		CheckCamHandle("GetTofPhaseAngle" "_Minimum");
		
		XI_RETURN res=xiGetParamFloat(camera_handle, XI_PRM_TOF_PHASE_ANGLE XI_PRM_INFO_MIN, &val);
		CheckResult(res,"GetTofPhaseAngle" "_Minimum");
		return val;
	}

	float xiAPIplus_Camera::GetTofPhaseAngle_Increment()
	{
		float val=0;
		
		CheckCamHandle("GetTofPhaseAngle" "_Increment");
		
		XI_RETURN res=xiGetParamFloat(camera_handle, XI_PRM_TOF_PHASE_ANGLE XI_PRM_INFO_INCREMENT, &val);
		CheckResult(res,"GetTofPhaseAngle" "_Increment");
		return val;
	}
	
	void xiAPIplus_Camera::SetTofPhaseAngle(float TofPhaseAngle)
	{
		
		CheckCamHandle("SetTofPhaseAngle");
		
		XI_RETURN res=xiSetParamFloat(camera_handle, XI_PRM_TOF_PHASE_ANGLE, TofPhaseAngle);
		CheckResult(res,"SetTofPhaseAngle");
	}
	 
	
	// Sets Exposure time for selected ToF phase in microseconds. (XI_PRM_TOF_PHASE_EXPOSURE_TIME)
	float xiAPIplus_Camera::GetTofPhaseExposureTime()
	{
		float val=0;
		
		CheckCamHandle("GetTofPhaseExposureTime");
		
		XI_RETURN res=xiGetParamFloat(camera_handle, XI_PRM_TOF_PHASE_EXPOSURE_TIME, &val);
		CheckResult(res,"GetTofPhaseExposureTime");
		return val;
	}

	float xiAPIplus_Camera::GetTofPhaseExposureTime_Maximum()
	{
		float val=0;
		
		CheckCamHandle("GetTofPhaseExposureTime" "_Maximum");
		
		XI_RETURN res=xiGetParamFloat(camera_handle, XI_PRM_TOF_PHASE_EXPOSURE_TIME XI_PRM_INFO_MAX, &val);
		CheckResult(res,"GetTofPhaseExposureTime" "_Maximum");
		return val;
	}

	float xiAPIplus_Camera::GetTofPhaseExposureTime_Minimum()
	{
		float val=0;
		
		CheckCamHandle("GetTofPhaseExposureTime" "_Minimum");
		
		XI_RETURN res=xiGetParamFloat(camera_handle, XI_PRM_TOF_PHASE_EXPOSURE_TIME XI_PRM_INFO_MIN, &val);
		CheckResult(res,"GetTofPhaseExposureTime" "_Minimum");
		return val;
	}

	float xiAPIplus_Camera::GetTofPhaseExposureTime_Increment()
	{
		float val=0;
		
		CheckCamHandle("GetTofPhaseExposureTime" "_Increment");
		
		XI_RETURN res=xiGetParamFloat(camera_handle, XI_PRM_TOF_PHASE_EXPOSURE_TIME XI_PRM_INFO_INCREMENT, &val);
		CheckResult(res,"GetTofPhaseExposureTime" "_Increment");
		return val;
	}
	
	void xiAPIplus_Camera::SetTofPhaseExposureTime(float TofPhaseExposureTime)
	{
		
		CheckCamHandle("SetTofPhaseExposureTime");
		
		XI_RETURN res=xiSetParamFloat(camera_handle, XI_PRM_TOF_PHASE_EXPOSURE_TIME, TofPhaseExposureTime);
		CheckResult(res,"SetTofPhaseExposureTime");
	}
	 
	
	// Selects tof phase (XI_PRM_TOF_PHASE_SELECTOR)
	// integer type
	int xiAPIplus_Camera::GetTofPhaseSelector()
	{
		CheckCamHandle("GetTofPhaseSelector");
		int val=0;
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_TOF_PHASE_SELECTOR, &val);
		CheckResult(res,"GetTofPhaseSelector");
		return val;	
	}
	int xiAPIplus_Camera::GetTofPhaseSelector_Maximum()
	{		
		CheckCamHandle("GetTofPhaseSelector" "_Maximum");
		int val=0;
		CheckCamHandle("GetTofPhaseSelector");
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_TOF_PHASE_SELECTOR XI_PRM_INFO_MAX, &val);
		CheckResult(res,"GetTofPhaseSelector" "_Maximum");
		return val;
	}
	
	int xiAPIplus_Camera::GetTofPhaseSelector_Minimum()
	{
		CheckCamHandle("GetTofPhaseSelector" "_Minimum");
		int val=0;
		CheckCamHandle("GetTofPhaseSelector");
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_TOF_PHASE_SELECTOR XI_PRM_INFO_MIN, &val);
		CheckResult(res,"GetTofPhaseSelector" "_Minimum");
		return val;
	}

	int xiAPIplus_Camera::GetTofPhaseSelector_Increment()
	{
		CheckCamHandle("GetTofPhaseSelector" "_Increment");
		int val=0;
		CheckCamHandle("GetTofPhaseSelector");
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_TOF_PHASE_SELECTOR XI_PRM_INFO_INCREMENT, &val);
		CheckResult(res,"GetTofPhaseSelector" "_Increment");
		return val;		
	}
	
	void xiAPIplus_Camera::SetTofPhaseSelector(int TofPhaseSelector)
	{
		
		CheckCamHandleInt("SetTofPhaseSelector",TofPhaseSelector);
		
		XI_RETURN res=xiSetParamInt(camera_handle, XI_PRM_TOF_PHASE_SELECTOR, TofPhaseSelector);
		CheckResult(res,"SetTofPhaseSelector");
	}
	

	//-------------------------------------------------------------------------------------------------------------------
	// ---- Parameter Group: Image Format
	//-------------------------------------------------------------------------------------------------------------------

	 
	
	// Binning engine selector. (XI_PRM_BINNING_SELECTOR)
	XI_BIN_SELECTOR xiAPIplus_Camera::GetBinningSelector()
	{
		int val=0;
		
		CheckCamHandle("GetBinningSelector");
		
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_BINNING_SELECTOR, &val);
		CheckResult(res,"GetBinningSelector");
		return (XI_BIN_SELECTOR)val;
	}
	
	XI_BIN_SELECTOR xiAPIplus_Camera::GetBinningSelector_Maximum()
	{
		int val=0;
		
		CheckCamHandle("GetBinningSelector" "_Maximum");
		
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_BINNING_SELECTOR XI_PRM_INFO_MAX, &val);
		CheckResult(res,"GetBinningSelector" "_Maximum");
		return (XI_BIN_SELECTOR)val;
	}
	
	XI_BIN_SELECTOR xiAPIplus_Camera::GetBinningSelector_Minimum()
	{
		int val=0;
		
		CheckCamHandle("GetBinningSelector" "_Minimum");
		
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_BINNING_SELECTOR XI_PRM_INFO_MIN, &val);
		CheckResult(res,"GetBinningSelector" "_Minimum");
		return (XI_BIN_SELECTOR)val;
	}
	
	int xiAPIplus_Camera::GetBinningSelector_Increment()
	{
		int val=0;
		
		CheckCamHandle("GetBinningSelector" "_Increment");
		
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_BINNING_SELECTOR XI_PRM_INFO_INCREMENT, &val);
		CheckResult(res,"GetBinningSelector" "_Increment");
		return val;
	}
	
	void xiAPIplus_Camera::SetBinningSelector(XI_BIN_SELECTOR BinningSelector)
	{
		
		CheckCamHandleInt("SetBinningSelector",(int)BinningSelector);
		
		XI_RETURN res=xiSetParamInt(camera_handle, XI_PRM_BINNING_SELECTOR, BinningSelector);
		CheckResult(res,"SetBinningSelector");
	}
	 
	
	// Sets the mode to use to combine vertical pixel together. (XI_PRM_BINNING_VERTICAL_MODE)
	XI_BIN_MODE xiAPIplus_Camera::GetBinningVerticalMode()
	{
		int val=0;
		
		CheckCamHandle("GetBinningVerticalMode");
		
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_BINNING_VERTICAL_MODE, &val);
		CheckResult(res,"GetBinningVerticalMode");
		return (XI_BIN_MODE)val;
	}
	
	XI_BIN_MODE xiAPIplus_Camera::GetBinningVerticalMode_Maximum()
	{
		int val=0;
		
		CheckCamHandle("GetBinningVerticalMode" "_Maximum");
		
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_BINNING_VERTICAL_MODE XI_PRM_INFO_MAX, &val);
		CheckResult(res,"GetBinningVerticalMode" "_Maximum");
		return (XI_BIN_MODE)val;
	}
	
	XI_BIN_MODE xiAPIplus_Camera::GetBinningVerticalMode_Minimum()
	{
		int val=0;
		
		CheckCamHandle("GetBinningVerticalMode" "_Minimum");
		
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_BINNING_VERTICAL_MODE XI_PRM_INFO_MIN, &val);
		CheckResult(res,"GetBinningVerticalMode" "_Minimum");
		return (XI_BIN_MODE)val;
	}
	
	int xiAPIplus_Camera::GetBinningVerticalMode_Increment()
	{
		int val=0;
		
		CheckCamHandle("GetBinningVerticalMode" "_Increment");
		
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_BINNING_VERTICAL_MODE XI_PRM_INFO_INCREMENT, &val);
		CheckResult(res,"GetBinningVerticalMode" "_Increment");
		return val;
	}
	
	void xiAPIplus_Camera::SetBinningVerticalMode(XI_BIN_MODE BinningVerticalMode)
	{
		
		CheckCamHandleInt("SetBinningVerticalMode",(int)BinningVerticalMode);
		
		XI_RETURN res=xiSetParamInt(camera_handle, XI_PRM_BINNING_VERTICAL_MODE, BinningVerticalMode);
		CheckResult(res,"SetBinningVerticalMode");
	}
	 
	
	// Vertical Binning - number of vertical photo-sensitive cells to combine together. (XI_PRM_BINNING_VERTICAL)
	// integer type
	int xiAPIplus_Camera::GetBinningVertical()
	{
		CheckCamHandle("GetBinningVertical");
		int val=0;
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_BINNING_VERTICAL, &val);
		CheckResult(res,"GetBinningVertical");
		return val;	
	}
	int xiAPIplus_Camera::GetBinningVertical_Maximum()
	{		
		CheckCamHandle("GetBinningVertical" "_Maximum");
		int val=0;
		CheckCamHandle("GetBinningVertical");
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_BINNING_VERTICAL XI_PRM_INFO_MAX, &val);
		CheckResult(res,"GetBinningVertical" "_Maximum");
		return val;
	}
	
	int xiAPIplus_Camera::GetBinningVertical_Minimum()
	{
		CheckCamHandle("GetBinningVertical" "_Minimum");
		int val=0;
		CheckCamHandle("GetBinningVertical");
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_BINNING_VERTICAL XI_PRM_INFO_MIN, &val);
		CheckResult(res,"GetBinningVertical" "_Minimum");
		return val;
	}

	int xiAPIplus_Camera::GetBinningVertical_Increment()
	{
		CheckCamHandle("GetBinningVertical" "_Increment");
		int val=0;
		CheckCamHandle("GetBinningVertical");
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_BINNING_VERTICAL XI_PRM_INFO_INCREMENT, &val);
		CheckResult(res,"GetBinningVertical" "_Increment");
		return val;		
	}
	
	void xiAPIplus_Camera::SetBinningVertical(int BinningVertical)
	{
		
		CheckCamHandleInt("SetBinningVertical",BinningVertical);
		
		XI_RETURN res=xiSetParamInt(camera_handle, XI_PRM_BINNING_VERTICAL, BinningVertical);
		CheckResult(res,"SetBinningVertical");
	}
	 
	
	// Vertical Binning Float - number of vertical photo-sensitive cells to combine together. (XI_PRM_BINNING_VERTICAL_FLOAT)
	float xiAPIplus_Camera::GetBinningVerticalFloat()
	{
		float val=0;
		
		CheckCamHandle("GetBinningVerticalFloat");
		
		XI_RETURN res=xiGetParamFloat(camera_handle, XI_PRM_BINNING_VERTICAL_FLOAT, &val);
		CheckResult(res,"GetBinningVerticalFloat");
		return val;
	}

	float xiAPIplus_Camera::GetBinningVerticalFloat_Maximum()
	{
		float val=0;
		
		CheckCamHandle("GetBinningVerticalFloat" "_Maximum");
		
		XI_RETURN res=xiGetParamFloat(camera_handle, XI_PRM_BINNING_VERTICAL_FLOAT XI_PRM_INFO_MAX, &val);
		CheckResult(res,"GetBinningVerticalFloat" "_Maximum");
		return val;
	}

	float xiAPIplus_Camera::GetBinningVerticalFloat_Minimum()
	{
		float val=0;
		
		CheckCamHandle("GetBinningVerticalFloat" "_Minimum");
		
		XI_RETURN res=xiGetParamFloat(camera_handle, XI_PRM_BINNING_VERTICAL_FLOAT XI_PRM_INFO_MIN, &val);
		CheckResult(res,"GetBinningVerticalFloat" "_Minimum");
		return val;
	}

	float xiAPIplus_Camera::GetBinningVerticalFloat_Increment()
	{
		float val=0;
		
		CheckCamHandle("GetBinningVerticalFloat" "_Increment");
		
		XI_RETURN res=xiGetParamFloat(camera_handle, XI_PRM_BINNING_VERTICAL_FLOAT XI_PRM_INFO_INCREMENT, &val);
		CheckResult(res,"GetBinningVerticalFloat" "_Increment");
		return val;
	}
	
	void xiAPIplus_Camera::SetBinningVerticalFloat(float BinningVerticalFloat)
	{
		
		CheckCamHandle("SetBinningVerticalFloat");
		
		XI_RETURN res=xiSetParamFloat(camera_handle, XI_PRM_BINNING_VERTICAL_FLOAT, BinningVerticalFloat);
		CheckResult(res,"SetBinningVerticalFloat");
	}
	 
	
	// Sets the mode to use to combine horizontal pixel together. (XI_PRM_BINNING_HORIZONTAL_MODE)
	XI_BIN_MODE xiAPIplus_Camera::GetBinningHorizontalMode()
	{
		int val=0;
		
		CheckCamHandle("GetBinningHorizontalMode");
		
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_BINNING_HORIZONTAL_MODE, &val);
		CheckResult(res,"GetBinningHorizontalMode");
		return (XI_BIN_MODE)val;
	}
	
	XI_BIN_MODE xiAPIplus_Camera::GetBinningHorizontalMode_Maximum()
	{
		int val=0;
		
		CheckCamHandle("GetBinningHorizontalMode" "_Maximum");
		
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_BINNING_HORIZONTAL_MODE XI_PRM_INFO_MAX, &val);
		CheckResult(res,"GetBinningHorizontalMode" "_Maximum");
		return (XI_BIN_MODE)val;
	}
	
	XI_BIN_MODE xiAPIplus_Camera::GetBinningHorizontalMode_Minimum()
	{
		int val=0;
		
		CheckCamHandle("GetBinningHorizontalMode" "_Minimum");
		
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_BINNING_HORIZONTAL_MODE XI_PRM_INFO_MIN, &val);
		CheckResult(res,"GetBinningHorizontalMode" "_Minimum");
		return (XI_BIN_MODE)val;
	}
	
	int xiAPIplus_Camera::GetBinningHorizontalMode_Increment()
	{
		int val=0;
		
		CheckCamHandle("GetBinningHorizontalMode" "_Increment");
		
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_BINNING_HORIZONTAL_MODE XI_PRM_INFO_INCREMENT, &val);
		CheckResult(res,"GetBinningHorizontalMode" "_Increment");
		return val;
	}
	
	void xiAPIplus_Camera::SetBinningHorizontalMode(XI_BIN_MODE BinningHorizontalMode)
	{
		
		CheckCamHandleInt("SetBinningHorizontalMode",(int)BinningHorizontalMode);
		
		XI_RETURN res=xiSetParamInt(camera_handle, XI_PRM_BINNING_HORIZONTAL_MODE, BinningHorizontalMode);
		CheckResult(res,"SetBinningHorizontalMode");
	}
	 
	
	// Horizontal Binning - number of horizontal photo-sensitive cells to combine together. (XI_PRM_BINNING_HORIZONTAL)
	// integer type
	int xiAPIplus_Camera::GetBinningHorizontal()
	{
		CheckCamHandle("GetBinningHorizontal");
		int val=0;
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_BINNING_HORIZONTAL, &val);
		CheckResult(res,"GetBinningHorizontal");
		return val;	
	}
	int xiAPIplus_Camera::GetBinningHorizontal_Maximum()
	{		
		CheckCamHandle("GetBinningHorizontal" "_Maximum");
		int val=0;
		CheckCamHandle("GetBinningHorizontal");
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_BINNING_HORIZONTAL XI_PRM_INFO_MAX, &val);
		CheckResult(res,"GetBinningHorizontal" "_Maximum");
		return val;
	}
	
	int xiAPIplus_Camera::GetBinningHorizontal_Minimum()
	{
		CheckCamHandle("GetBinningHorizontal" "_Minimum");
		int val=0;
		CheckCamHandle("GetBinningHorizontal");
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_BINNING_HORIZONTAL XI_PRM_INFO_MIN, &val);
		CheckResult(res,"GetBinningHorizontal" "_Minimum");
		return val;
	}

	int xiAPIplus_Camera::GetBinningHorizontal_Increment()
	{
		CheckCamHandle("GetBinningHorizontal" "_Increment");
		int val=0;
		CheckCamHandle("GetBinningHorizontal");
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_BINNING_HORIZONTAL XI_PRM_INFO_INCREMENT, &val);
		CheckResult(res,"GetBinningHorizontal" "_Increment");
		return val;		
	}
	
	void xiAPIplus_Camera::SetBinningHorizontal(int BinningHorizontal)
	{
		
		CheckCamHandleInt("SetBinningHorizontal",BinningHorizontal);
		
		XI_RETURN res=xiSetParamInt(camera_handle, XI_PRM_BINNING_HORIZONTAL, BinningHorizontal);
		CheckResult(res,"SetBinningHorizontal");
	}
	 
	
	// Horizontal Binning Float - number of horizontal photo-sensitive cells to combine together. (XI_PRM_BINNING_HORIZONTAL_FLOAT)
	float xiAPIplus_Camera::GetBinningHorizontalFloat()
	{
		float val=0;
		
		CheckCamHandle("GetBinningHorizontalFloat");
		
		XI_RETURN res=xiGetParamFloat(camera_handle, XI_PRM_BINNING_HORIZONTAL_FLOAT, &val);
		CheckResult(res,"GetBinningHorizontalFloat");
		return val;
	}

	float xiAPIplus_Camera::GetBinningHorizontalFloat_Maximum()
	{
		float val=0;
		
		CheckCamHandle("GetBinningHorizontalFloat" "_Maximum");
		
		XI_RETURN res=xiGetParamFloat(camera_handle, XI_PRM_BINNING_HORIZONTAL_FLOAT XI_PRM_INFO_MAX, &val);
		CheckResult(res,"GetBinningHorizontalFloat" "_Maximum");
		return val;
	}

	float xiAPIplus_Camera::GetBinningHorizontalFloat_Minimum()
	{
		float val=0;
		
		CheckCamHandle("GetBinningHorizontalFloat" "_Minimum");
		
		XI_RETURN res=xiGetParamFloat(camera_handle, XI_PRM_BINNING_HORIZONTAL_FLOAT XI_PRM_INFO_MIN, &val);
		CheckResult(res,"GetBinningHorizontalFloat" "_Minimum");
		return val;
	}

	float xiAPIplus_Camera::GetBinningHorizontalFloat_Increment()
	{
		float val=0;
		
		CheckCamHandle("GetBinningHorizontalFloat" "_Increment");
		
		XI_RETURN res=xiGetParamFloat(camera_handle, XI_PRM_BINNING_HORIZONTAL_FLOAT XI_PRM_INFO_INCREMENT, &val);
		CheckResult(res,"GetBinningHorizontalFloat" "_Increment");
		return val;
	}
	
	void xiAPIplus_Camera::SetBinningHorizontalFloat(float BinningHorizontalFloat)
	{
		
		CheckCamHandle("SetBinningHorizontalFloat");
		
		XI_RETURN res=xiSetParamFloat(camera_handle, XI_PRM_BINNING_HORIZONTAL_FLOAT, BinningHorizontalFloat);
		CheckResult(res,"SetBinningHorizontalFloat");
	}
	 
	
	// Binning horizontal pattern type. (XI_PRM_BINNING_HORIZONTAL_PATTERN)
	XI_BIN_PATTERN xiAPIplus_Camera::GetBinningHorizontalPattern()
	{
		int val=0;
		
		CheckCamHandle("GetBinningHorizontalPattern");
		
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_BINNING_HORIZONTAL_PATTERN, &val);
		CheckResult(res,"GetBinningHorizontalPattern");
		return (XI_BIN_PATTERN)val;
	}
	
	XI_BIN_PATTERN xiAPIplus_Camera::GetBinningHorizontalPattern_Maximum()
	{
		int val=0;
		
		CheckCamHandle("GetBinningHorizontalPattern" "_Maximum");
		
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_BINNING_HORIZONTAL_PATTERN XI_PRM_INFO_MAX, &val);
		CheckResult(res,"GetBinningHorizontalPattern" "_Maximum");
		return (XI_BIN_PATTERN)val;
	}
	
	XI_BIN_PATTERN xiAPIplus_Camera::GetBinningHorizontalPattern_Minimum()
	{
		int val=0;
		
		CheckCamHandle("GetBinningHorizontalPattern" "_Minimum");
		
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_BINNING_HORIZONTAL_PATTERN XI_PRM_INFO_MIN, &val);
		CheckResult(res,"GetBinningHorizontalPattern" "_Minimum");
		return (XI_BIN_PATTERN)val;
	}
	
	int xiAPIplus_Camera::GetBinningHorizontalPattern_Increment()
	{
		int val=0;
		
		CheckCamHandle("GetBinningHorizontalPattern" "_Increment");
		
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_BINNING_HORIZONTAL_PATTERN XI_PRM_INFO_INCREMENT, &val);
		CheckResult(res,"GetBinningHorizontalPattern" "_Increment");
		return val;
	}
	
	void xiAPIplus_Camera::SetBinningHorizontalPattern(XI_BIN_PATTERN BinningHorizontalPattern)
	{
		
		CheckCamHandleInt("SetBinningHorizontalPattern",(int)BinningHorizontalPattern);
		
		XI_RETURN res=xiSetParamInt(camera_handle, XI_PRM_BINNING_HORIZONTAL_PATTERN, BinningHorizontalPattern);
		CheckResult(res,"SetBinningHorizontalPattern");
	}
	 
	
	// Binning vertical pattern type. (XI_PRM_BINNING_VERTICAL_PATTERN)
	XI_BIN_PATTERN xiAPIplus_Camera::GetBinningVerticalPattern()
	{
		int val=0;
		
		CheckCamHandle("GetBinningVerticalPattern");
		
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_BINNING_VERTICAL_PATTERN, &val);
		CheckResult(res,"GetBinningVerticalPattern");
		return (XI_BIN_PATTERN)val;
	}
	
	XI_BIN_PATTERN xiAPIplus_Camera::GetBinningVerticalPattern_Maximum()
	{
		int val=0;
		
		CheckCamHandle("GetBinningVerticalPattern" "_Maximum");
		
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_BINNING_VERTICAL_PATTERN XI_PRM_INFO_MAX, &val);
		CheckResult(res,"GetBinningVerticalPattern" "_Maximum");
		return (XI_BIN_PATTERN)val;
	}
	
	XI_BIN_PATTERN xiAPIplus_Camera::GetBinningVerticalPattern_Minimum()
	{
		int val=0;
		
		CheckCamHandle("GetBinningVerticalPattern" "_Minimum");
		
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_BINNING_VERTICAL_PATTERN XI_PRM_INFO_MIN, &val);
		CheckResult(res,"GetBinningVerticalPattern" "_Minimum");
		return (XI_BIN_PATTERN)val;
	}
	
	int xiAPIplus_Camera::GetBinningVerticalPattern_Increment()
	{
		int val=0;
		
		CheckCamHandle("GetBinningVerticalPattern" "_Increment");
		
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_BINNING_VERTICAL_PATTERN XI_PRM_INFO_INCREMENT, &val);
		CheckResult(res,"GetBinningVerticalPattern" "_Increment");
		return val;
	}
	
	void xiAPIplus_Camera::SetBinningVerticalPattern(XI_BIN_PATTERN BinningVerticalPattern)
	{
		
		CheckCamHandleInt("SetBinningVerticalPattern",(int)BinningVerticalPattern);
		
		XI_RETURN res=xiSetParamInt(camera_handle, XI_PRM_BINNING_VERTICAL_PATTERN, BinningVerticalPattern);
		CheckResult(res,"SetBinningVerticalPattern");
	}
	 
	
	// Decimation engine selector. (XI_PRM_DECIMATION_SELECTOR)
	XI_DEC_SELECTOR xiAPIplus_Camera::GetDecimationSelector()
	{
		int val=0;
		
		CheckCamHandle("GetDecimationSelector");
		
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_DECIMATION_SELECTOR, &val);
		CheckResult(res,"GetDecimationSelector");
		return (XI_DEC_SELECTOR)val;
	}
	
	XI_DEC_SELECTOR xiAPIplus_Camera::GetDecimationSelector_Maximum()
	{
		int val=0;
		
		CheckCamHandle("GetDecimationSelector" "_Maximum");
		
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_DECIMATION_SELECTOR XI_PRM_INFO_MAX, &val);
		CheckResult(res,"GetDecimationSelector" "_Maximum");
		return (XI_DEC_SELECTOR)val;
	}
	
	XI_DEC_SELECTOR xiAPIplus_Camera::GetDecimationSelector_Minimum()
	{
		int val=0;
		
		CheckCamHandle("GetDecimationSelector" "_Minimum");
		
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_DECIMATION_SELECTOR XI_PRM_INFO_MIN, &val);
		CheckResult(res,"GetDecimationSelector" "_Minimum");
		return (XI_DEC_SELECTOR)val;
	}
	
	int xiAPIplus_Camera::GetDecimationSelector_Increment()
	{
		int val=0;
		
		CheckCamHandle("GetDecimationSelector" "_Increment");
		
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_DECIMATION_SELECTOR XI_PRM_INFO_INCREMENT, &val);
		CheckResult(res,"GetDecimationSelector" "_Increment");
		return val;
	}
	
	void xiAPIplus_Camera::SetDecimationSelector(XI_DEC_SELECTOR DecimationSelector)
	{
		
		CheckCamHandleInt("SetDecimationSelector",(int)DecimationSelector);
		
		XI_RETURN res=xiSetParamInt(camera_handle, XI_PRM_DECIMATION_SELECTOR, DecimationSelector);
		CheckResult(res,"SetDecimationSelector");
	}
	 
	
	// Vertical Decimation - vertical sub-sampling of the image - reduces the vertical resolution of the image by the specified vertical decimation factor. (XI_PRM_DECIMATION_VERTICAL)
	// integer type
	int xiAPIplus_Camera::GetDecimationVertical()
	{
		CheckCamHandle("GetDecimationVertical");
		int val=0;
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_DECIMATION_VERTICAL, &val);
		CheckResult(res,"GetDecimationVertical");
		return val;	
	}
	int xiAPIplus_Camera::GetDecimationVertical_Maximum()
	{		
		CheckCamHandle("GetDecimationVertical" "_Maximum");
		int val=0;
		CheckCamHandle("GetDecimationVertical");
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_DECIMATION_VERTICAL XI_PRM_INFO_MAX, &val);
		CheckResult(res,"GetDecimationVertical" "_Maximum");
		return val;
	}
	
	int xiAPIplus_Camera::GetDecimationVertical_Minimum()
	{
		CheckCamHandle("GetDecimationVertical" "_Minimum");
		int val=0;
		CheckCamHandle("GetDecimationVertical");
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_DECIMATION_VERTICAL XI_PRM_INFO_MIN, &val);
		CheckResult(res,"GetDecimationVertical" "_Minimum");
		return val;
	}

	int xiAPIplus_Camera::GetDecimationVertical_Increment()
	{
		CheckCamHandle("GetDecimationVertical" "_Increment");
		int val=0;
		CheckCamHandle("GetDecimationVertical");
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_DECIMATION_VERTICAL XI_PRM_INFO_INCREMENT, &val);
		CheckResult(res,"GetDecimationVertical" "_Increment");
		return val;		
	}
	
	void xiAPIplus_Camera::SetDecimationVertical(int DecimationVertical)
	{
		
		CheckCamHandleInt("SetDecimationVertical",DecimationVertical);
		
		XI_RETURN res=xiSetParamInt(camera_handle, XI_PRM_DECIMATION_VERTICAL, DecimationVertical);
		CheckResult(res,"SetDecimationVertical");
	}
	 
	
	// Horizontal Decimation - horizontal sub-sampling of the image - reduces the horizontal resolution of the image by the specified vertical decimation factor. (XI_PRM_DECIMATION_HORIZONTAL)
	// integer type
	int xiAPIplus_Camera::GetDecimationHorizontal()
	{
		CheckCamHandle("GetDecimationHorizontal");
		int val=0;
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_DECIMATION_HORIZONTAL, &val);
		CheckResult(res,"GetDecimationHorizontal");
		return val;	
	}
	int xiAPIplus_Camera::GetDecimationHorizontal_Maximum()
	{		
		CheckCamHandle("GetDecimationHorizontal" "_Maximum");
		int val=0;
		CheckCamHandle("GetDecimationHorizontal");
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_DECIMATION_HORIZONTAL XI_PRM_INFO_MAX, &val);
		CheckResult(res,"GetDecimationHorizontal" "_Maximum");
		return val;
	}
	
	int xiAPIplus_Camera::GetDecimationHorizontal_Minimum()
	{
		CheckCamHandle("GetDecimationHorizontal" "_Minimum");
		int val=0;
		CheckCamHandle("GetDecimationHorizontal");
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_DECIMATION_HORIZONTAL XI_PRM_INFO_MIN, &val);
		CheckResult(res,"GetDecimationHorizontal" "_Minimum");
		return val;
	}

	int xiAPIplus_Camera::GetDecimationHorizontal_Increment()
	{
		CheckCamHandle("GetDecimationHorizontal" "_Increment");
		int val=0;
		CheckCamHandle("GetDecimationHorizontal");
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_DECIMATION_HORIZONTAL XI_PRM_INFO_INCREMENT, &val);
		CheckResult(res,"GetDecimationHorizontal" "_Increment");
		return val;		
	}
	
	void xiAPIplus_Camera::SetDecimationHorizontal(int DecimationHorizontal)
	{
		
		CheckCamHandleInt("SetDecimationHorizontal",DecimationHorizontal);
		
		XI_RETURN res=xiSetParamInt(camera_handle, XI_PRM_DECIMATION_HORIZONTAL, DecimationHorizontal);
		CheckResult(res,"SetDecimationHorizontal");
	}
	 
	
	// Decimation horizontal pattern type. (XI_PRM_DECIMATION_HORIZONTAL_PATTERN)
	XI_DEC_PATTERN xiAPIplus_Camera::GetDecimationHorizontalPattern()
	{
		int val=0;
		
		CheckCamHandle("GetDecimationHorizontalPattern");
		
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_DECIMATION_HORIZONTAL_PATTERN, &val);
		CheckResult(res,"GetDecimationHorizontalPattern");
		return (XI_DEC_PATTERN)val;
	}
	
	XI_DEC_PATTERN xiAPIplus_Camera::GetDecimationHorizontalPattern_Maximum()
	{
		int val=0;
		
		CheckCamHandle("GetDecimationHorizontalPattern" "_Maximum");
		
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_DECIMATION_HORIZONTAL_PATTERN XI_PRM_INFO_MAX, &val);
		CheckResult(res,"GetDecimationHorizontalPattern" "_Maximum");
		return (XI_DEC_PATTERN)val;
	}
	
	XI_DEC_PATTERN xiAPIplus_Camera::GetDecimationHorizontalPattern_Minimum()
	{
		int val=0;
		
		CheckCamHandle("GetDecimationHorizontalPattern" "_Minimum");
		
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_DECIMATION_HORIZONTAL_PATTERN XI_PRM_INFO_MIN, &val);
		CheckResult(res,"GetDecimationHorizontalPattern" "_Minimum");
		return (XI_DEC_PATTERN)val;
	}
	
	int xiAPIplus_Camera::GetDecimationHorizontalPattern_Increment()
	{
		int val=0;
		
		CheckCamHandle("GetDecimationHorizontalPattern" "_Increment");
		
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_DECIMATION_HORIZONTAL_PATTERN XI_PRM_INFO_INCREMENT, &val);
		CheckResult(res,"GetDecimationHorizontalPattern" "_Increment");
		return val;
	}
	
	void xiAPIplus_Camera::SetDecimationHorizontalPattern(XI_DEC_PATTERN DecimationHorizontalPattern)
	{
		
		CheckCamHandleInt("SetDecimationHorizontalPattern",(int)DecimationHorizontalPattern);
		
		XI_RETURN res=xiSetParamInt(camera_handle, XI_PRM_DECIMATION_HORIZONTAL_PATTERN, DecimationHorizontalPattern);
		CheckResult(res,"SetDecimationHorizontalPattern");
	}
	 
	
	// Decimation vertical pattern type. (XI_PRM_DECIMATION_VERTICAL_PATTERN)
	XI_DEC_PATTERN xiAPIplus_Camera::GetDecimationVerticalPattern()
	{
		int val=0;
		
		CheckCamHandle("GetDecimationVerticalPattern");
		
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_DECIMATION_VERTICAL_PATTERN, &val);
		CheckResult(res,"GetDecimationVerticalPattern");
		return (XI_DEC_PATTERN)val;
	}
	
	XI_DEC_PATTERN xiAPIplus_Camera::GetDecimationVerticalPattern_Maximum()
	{
		int val=0;
		
		CheckCamHandle("GetDecimationVerticalPattern" "_Maximum");
		
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_DECIMATION_VERTICAL_PATTERN XI_PRM_INFO_MAX, &val);
		CheckResult(res,"GetDecimationVerticalPattern" "_Maximum");
		return (XI_DEC_PATTERN)val;
	}
	
	XI_DEC_PATTERN xiAPIplus_Camera::GetDecimationVerticalPattern_Minimum()
	{
		int val=0;
		
		CheckCamHandle("GetDecimationVerticalPattern" "_Minimum");
		
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_DECIMATION_VERTICAL_PATTERN XI_PRM_INFO_MIN, &val);
		CheckResult(res,"GetDecimationVerticalPattern" "_Minimum");
		return (XI_DEC_PATTERN)val;
	}
	
	int xiAPIplus_Camera::GetDecimationVerticalPattern_Increment()
	{
		int val=0;
		
		CheckCamHandle("GetDecimationVerticalPattern" "_Increment");
		
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_DECIMATION_VERTICAL_PATTERN XI_PRM_INFO_INCREMENT, &val);
		CheckResult(res,"GetDecimationVerticalPattern" "_Increment");
		return val;
	}
	
	void xiAPIplus_Camera::SetDecimationVerticalPattern(XI_DEC_PATTERN DecimationVerticalPattern)
	{
		
		CheckCamHandleInt("SetDecimationVerticalPattern",(int)DecimationVerticalPattern);
		
		XI_RETURN res=xiSetParamInt(camera_handle, XI_PRM_DECIMATION_VERTICAL_PATTERN, DecimationVerticalPattern);
		CheckResult(res,"SetDecimationVerticalPattern");
	}
	

	//-------------------------------------------------------------------------------------------------------------------
	// ---- Parameter Group: AE Setup
	//-------------------------------------------------------------------------------------------------------------------

	 
	
	// Exposure priority (0.8 - exposure 80%, gain 20%). (XI_PRM_EXP_PRIORITY)
	float xiAPIplus_Camera::GetAutoExposureAutoGainExposurePriority()
	{
		float val=0;
		
		CheckCamHandle("GetAutoExposureAutoGainExposurePriority");
		
		XI_RETURN res=xiGetParamFloat(camera_handle, XI_PRM_EXP_PRIORITY, &val);
		CheckResult(res,"GetAutoExposureAutoGainExposurePriority");
		return val;
	}

	float xiAPIplus_Camera::GetAutoExposureAutoGainExposurePriority_Maximum()
	{
		float val=0;
		
		CheckCamHandle("GetAutoExposureAutoGainExposurePriority" "_Maximum");
		
		XI_RETURN res=xiGetParamFloat(camera_handle, XI_PRM_EXP_PRIORITY XI_PRM_INFO_MAX, &val);
		CheckResult(res,"GetAutoExposureAutoGainExposurePriority" "_Maximum");
		return val;
	}

	float xiAPIplus_Camera::GetAutoExposureAutoGainExposurePriority_Minimum()
	{
		float val=0;
		
		CheckCamHandle("GetAutoExposureAutoGainExposurePriority" "_Minimum");
		
		XI_RETURN res=xiGetParamFloat(camera_handle, XI_PRM_EXP_PRIORITY XI_PRM_INFO_MIN, &val);
		CheckResult(res,"GetAutoExposureAutoGainExposurePriority" "_Minimum");
		return val;
	}

	float xiAPIplus_Camera::GetAutoExposureAutoGainExposurePriority_Increment()
	{
		float val=0;
		
		CheckCamHandle("GetAutoExposureAutoGainExposurePriority" "_Increment");
		
		XI_RETURN res=xiGetParamFloat(camera_handle, XI_PRM_EXP_PRIORITY XI_PRM_INFO_INCREMENT, &val);
		CheckResult(res,"GetAutoExposureAutoGainExposurePriority" "_Increment");
		return val;
	}
	
	void xiAPIplus_Camera::SetAutoExposureAutoGainExposurePriority(float AutoExposureAutoGainExposurePriority)
	{
		
		CheckCamHandle("SetAutoExposureAutoGainExposurePriority");
		
		XI_RETURN res=xiSetParamFloat(camera_handle, XI_PRM_EXP_PRIORITY, AutoExposureAutoGainExposurePriority);
		CheckResult(res,"SetAutoExposureAutoGainExposurePriority");
	}
	 
	
	// Maximum limit of gain in AEAG procedure (XI_PRM_AG_MAX_LIMIT)
	float xiAPIplus_Camera::GetAutoGainTopLimit()
	{
		float val=0;
		
		CheckCamHandle("GetAutoGainTopLimit");
		
		XI_RETURN res=xiGetParamFloat(camera_handle, XI_PRM_AG_MAX_LIMIT, &val);
		CheckResult(res,"GetAutoGainTopLimit");
		return val;
	}

	float xiAPIplus_Camera::GetAutoGainTopLimit_Maximum()
	{
		float val=0;
		
		CheckCamHandle("GetAutoGainTopLimit" "_Maximum");
		
		XI_RETURN res=xiGetParamFloat(camera_handle, XI_PRM_AG_MAX_LIMIT XI_PRM_INFO_MAX, &val);
		CheckResult(res,"GetAutoGainTopLimit" "_Maximum");
		return val;
	}

	float xiAPIplus_Camera::GetAutoGainTopLimit_Minimum()
	{
		float val=0;
		
		CheckCamHandle("GetAutoGainTopLimit" "_Minimum");
		
		XI_RETURN res=xiGetParamFloat(camera_handle, XI_PRM_AG_MAX_LIMIT XI_PRM_INFO_MIN, &val);
		CheckResult(res,"GetAutoGainTopLimit" "_Minimum");
		return val;
	}

	float xiAPIplus_Camera::GetAutoGainTopLimit_Increment()
	{
		float val=0;
		
		CheckCamHandle("GetAutoGainTopLimit" "_Increment");
		
		XI_RETURN res=xiGetParamFloat(camera_handle, XI_PRM_AG_MAX_LIMIT XI_PRM_INFO_INCREMENT, &val);
		CheckResult(res,"GetAutoGainTopLimit" "_Increment");
		return val;
	}
	
	void xiAPIplus_Camera::SetAutoGainTopLimit(float AutoGainTopLimit)
	{
		
		CheckCamHandle("SetAutoGainTopLimit");
		
		XI_RETURN res=xiSetParamFloat(camera_handle, XI_PRM_AG_MAX_LIMIT, AutoGainTopLimit);
		CheckResult(res,"SetAutoGainTopLimit");
	}
	 
	
	// Maximum time (us) used for exposure in AEAG procedure (XI_PRM_AE_MAX_LIMIT)
	// integer type
	int xiAPIplus_Camera::GetAutoExposureTopLimit()
	{
		CheckCamHandle("GetAutoExposureTopLimit");
		int val=0;
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_AE_MAX_LIMIT, &val);
		CheckResult(res,"GetAutoExposureTopLimit");
		return val;	
	}
	int xiAPIplus_Camera::GetAutoExposureTopLimit_Maximum()
	{		
		CheckCamHandle("GetAutoExposureTopLimit" "_Maximum");
		int val=0;
		CheckCamHandle("GetAutoExposureTopLimit");
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_AE_MAX_LIMIT XI_PRM_INFO_MAX, &val);
		CheckResult(res,"GetAutoExposureTopLimit" "_Maximum");
		return val;
	}
	
	int xiAPIplus_Camera::GetAutoExposureTopLimit_Minimum()
	{
		CheckCamHandle("GetAutoExposureTopLimit" "_Minimum");
		int val=0;
		CheckCamHandle("GetAutoExposureTopLimit");
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_AE_MAX_LIMIT XI_PRM_INFO_MIN, &val);
		CheckResult(res,"GetAutoExposureTopLimit" "_Minimum");
		return val;
	}

	int xiAPIplus_Camera::GetAutoExposureTopLimit_Increment()
	{
		CheckCamHandle("GetAutoExposureTopLimit" "_Increment");
		int val=0;
		CheckCamHandle("GetAutoExposureTopLimit");
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_AE_MAX_LIMIT XI_PRM_INFO_INCREMENT, &val);
		CheckResult(res,"GetAutoExposureTopLimit" "_Increment");
		return val;		
	}
	
	void xiAPIplus_Camera::SetAutoExposureTopLimit(int AutoExposureTopLimit)
	{
		
		CheckCamHandleInt("SetAutoExposureTopLimit",AutoExposureTopLimit);
		
		XI_RETURN res=xiSetParamInt(camera_handle, XI_PRM_AE_MAX_LIMIT, AutoExposureTopLimit);
		CheckResult(res,"SetAutoExposureTopLimit");
	}
	 
	
	// Average intensity of output signal AEAG should achieve(in %) (XI_PRM_AEAG_LEVEL)
	// integer type
	int xiAPIplus_Camera::GetAutoExposureAutoGainTargetLevel()
	{
		CheckCamHandle("GetAutoExposureAutoGainTargetLevel");
		int val=0;
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_AEAG_LEVEL, &val);
		CheckResult(res,"GetAutoExposureAutoGainTargetLevel");
		return val;	
	}
	int xiAPIplus_Camera::GetAutoExposureAutoGainTargetLevel_Maximum()
	{		
		CheckCamHandle("GetAutoExposureAutoGainTargetLevel" "_Maximum");
		int val=0;
		CheckCamHandle("GetAutoExposureAutoGainTargetLevel");
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_AEAG_LEVEL XI_PRM_INFO_MAX, &val);
		CheckResult(res,"GetAutoExposureAutoGainTargetLevel" "_Maximum");
		return val;
	}
	
	int xiAPIplus_Camera::GetAutoExposureAutoGainTargetLevel_Minimum()
	{
		CheckCamHandle("GetAutoExposureAutoGainTargetLevel" "_Minimum");
		int val=0;
		CheckCamHandle("GetAutoExposureAutoGainTargetLevel");
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_AEAG_LEVEL XI_PRM_INFO_MIN, &val);
		CheckResult(res,"GetAutoExposureAutoGainTargetLevel" "_Minimum");
		return val;
	}

	int xiAPIplus_Camera::GetAutoExposureAutoGainTargetLevel_Increment()
	{
		CheckCamHandle("GetAutoExposureAutoGainTargetLevel" "_Increment");
		int val=0;
		CheckCamHandle("GetAutoExposureAutoGainTargetLevel");
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_AEAG_LEVEL XI_PRM_INFO_INCREMENT, &val);
		CheckResult(res,"GetAutoExposureAutoGainTargetLevel" "_Increment");
		return val;		
	}
	
	void xiAPIplus_Camera::SetAutoExposureAutoGainTargetLevel(int AutoExposureAutoGainTargetLevel)
	{
		
		CheckCamHandleInt("SetAutoExposureAutoGainTargetLevel",AutoExposureAutoGainTargetLevel);
		
		XI_RETURN res=xiSetParamInt(camera_handle, XI_PRM_AEAG_LEVEL, AutoExposureAutoGainTargetLevel);
		CheckResult(res,"SetAutoExposureAutoGainTargetLevel");
	}
	 
	
	// Minimum number of frames to be skipped between AEAG compensation and AEAG re-evaluation (XI_PRM_AEAG_SKIP_FRAMES_COUNT)
	// integer type
	int xiAPIplus_Camera::GetAutoExposureAutoGainSkipFramesCount()
	{
		CheckCamHandle("GetAutoExposureAutoGainSkipFramesCount");
		int val=0;
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_AEAG_SKIP_FRAMES_COUNT, &val);
		CheckResult(res,"GetAutoExposureAutoGainSkipFramesCount");
		return val;	
	}
	int xiAPIplus_Camera::GetAutoExposureAutoGainSkipFramesCount_Maximum()
	{		
		CheckCamHandle("GetAutoExposureAutoGainSkipFramesCount" "_Maximum");
		int val=0;
		CheckCamHandle("GetAutoExposureAutoGainSkipFramesCount");
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_AEAG_SKIP_FRAMES_COUNT XI_PRM_INFO_MAX, &val);
		CheckResult(res,"GetAutoExposureAutoGainSkipFramesCount" "_Maximum");
		return val;
	}
	
	int xiAPIplus_Camera::GetAutoExposureAutoGainSkipFramesCount_Minimum()
	{
		CheckCamHandle("GetAutoExposureAutoGainSkipFramesCount" "_Minimum");
		int val=0;
		CheckCamHandle("GetAutoExposureAutoGainSkipFramesCount");
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_AEAG_SKIP_FRAMES_COUNT XI_PRM_INFO_MIN, &val);
		CheckResult(res,"GetAutoExposureAutoGainSkipFramesCount" "_Minimum");
		return val;
	}

	int xiAPIplus_Camera::GetAutoExposureAutoGainSkipFramesCount_Increment()
	{
		CheckCamHandle("GetAutoExposureAutoGainSkipFramesCount" "_Increment");
		int val=0;
		CheckCamHandle("GetAutoExposureAutoGainSkipFramesCount");
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_AEAG_SKIP_FRAMES_COUNT XI_PRM_INFO_INCREMENT, &val);
		CheckResult(res,"GetAutoExposureAutoGainSkipFramesCount" "_Increment");
		return val;		
	}
	
	void xiAPIplus_Camera::SetAutoExposureAutoGainSkipFramesCount(int AutoExposureAutoGainSkipFramesCount)
	{
		
		CheckCamHandleInt("SetAutoExposureAutoGainSkipFramesCount",AutoExposureAutoGainSkipFramesCount);
		
		XI_RETURN res=xiSetParamInt(camera_handle, XI_PRM_AEAG_SKIP_FRAMES_COUNT, AutoExposureAutoGainSkipFramesCount);
		CheckResult(res,"SetAutoExposureAutoGainSkipFramesCount");
	}
	

	//-------------------------------------------------------------------------------------------------------------------
	// ---- Parameter Group: Performance
	//-------------------------------------------------------------------------------------------------------------------

	 
	
	// Set/get bandwidth(data rate in Megabits) (XI_PRM_LIMIT_BANDWIDTH)
	// integer type
	int xiAPIplus_Camera::GetBandwidthLimit()
	{
		CheckCamHandle("GetBandwidthLimit");
		int val=0;
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_LIMIT_BANDWIDTH, &val);
		CheckResult(res,"GetBandwidthLimit");
		return val;	
	}
	int xiAPIplus_Camera::GetBandwidthLimit_Maximum()
	{		
		CheckCamHandle("GetBandwidthLimit" "_Maximum");
		int val=0;
		CheckCamHandle("GetBandwidthLimit");
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_LIMIT_BANDWIDTH XI_PRM_INFO_MAX, &val);
		CheckResult(res,"GetBandwidthLimit" "_Maximum");
		return val;
	}
	
	int xiAPIplus_Camera::GetBandwidthLimit_Minimum()
	{
		CheckCamHandle("GetBandwidthLimit" "_Minimum");
		int val=0;
		CheckCamHandle("GetBandwidthLimit");
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_LIMIT_BANDWIDTH XI_PRM_INFO_MIN, &val);
		CheckResult(res,"GetBandwidthLimit" "_Minimum");
		return val;
	}

	int xiAPIplus_Camera::GetBandwidthLimit_Increment()
	{
		CheckCamHandle("GetBandwidthLimit" "_Increment");
		int val=0;
		CheckCamHandle("GetBandwidthLimit");
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_LIMIT_BANDWIDTH XI_PRM_INFO_INCREMENT, &val);
		CheckResult(res,"GetBandwidthLimit" "_Increment");
		return val;		
	}
	
	void xiAPIplus_Camera::SetBandwidthLimit(int BandwidthLimit)
	{
		
		CheckCamHandleInt("SetBandwidthLimit",BandwidthLimit);
		
		XI_RETURN res=xiSetParamInt(camera_handle, XI_PRM_LIMIT_BANDWIDTH, BandwidthLimit);
		CheckResult(res,"SetBandwidthLimit");
	}
	 
	
	// Bandwidth limit enabled (XI_PRM_LIMIT_BANDWIDTH_MODE)
	XI_SWITCH xiAPIplus_Camera::GetBandwidthLimitMode()
	{
		int val=0;
		
		CheckCamHandle("GetBandwidthLimitMode");
		
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_LIMIT_BANDWIDTH_MODE, &val);
		CheckResult(res,"GetBandwidthLimitMode");
		return (XI_SWITCH)val;
	}
	
	XI_SWITCH xiAPIplus_Camera::GetBandwidthLimitMode_Maximum()
	{
		int val=0;
		
		CheckCamHandle("GetBandwidthLimitMode" "_Maximum");
		
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_LIMIT_BANDWIDTH_MODE XI_PRM_INFO_MAX, &val);
		CheckResult(res,"GetBandwidthLimitMode" "_Maximum");
		return (XI_SWITCH)val;
	}
	
	XI_SWITCH xiAPIplus_Camera::GetBandwidthLimitMode_Minimum()
	{
		int val=0;
		
		CheckCamHandle("GetBandwidthLimitMode" "_Minimum");
		
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_LIMIT_BANDWIDTH_MODE XI_PRM_INFO_MIN, &val);
		CheckResult(res,"GetBandwidthLimitMode" "_Minimum");
		return (XI_SWITCH)val;
	}
	
	int xiAPIplus_Camera::GetBandwidthLimitMode_Increment()
	{
		int val=0;
		
		CheckCamHandle("GetBandwidthLimitMode" "_Increment");
		
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_LIMIT_BANDWIDTH_MODE XI_PRM_INFO_INCREMENT, &val);
		CheckResult(res,"GetBandwidthLimitMode" "_Increment");
		return val;
	}
	
	void xiAPIplus_Camera::SetBandwidthLimitMode(XI_SWITCH BandwidthLimitMode)
	{
		
		CheckCamHandleInt("SetBandwidthLimitMode",(int)BandwidthLimitMode);
		
		XI_RETURN res=xiSetParamInt(camera_handle, XI_PRM_LIMIT_BANDWIDTH_MODE, BandwidthLimitMode);
		CheckResult(res,"SetBandwidthLimitMode");
	}
	 
	
	// Sensor output data bit depth. (XI_PRM_SENSOR_DATA_BIT_DEPTH)
	XI_BIT_DEPTH xiAPIplus_Camera::GetSensorDataBitDepth()
	{
		int val=0;
		
		CheckCamHandle("GetSensorDataBitDepth");
		
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_SENSOR_DATA_BIT_DEPTH, &val);
		CheckResult(res,"GetSensorDataBitDepth");
		return (XI_BIT_DEPTH)val;
	}
	
	XI_BIT_DEPTH xiAPIplus_Camera::GetSensorDataBitDepth_Maximum()
	{
		int val=0;
		
		CheckCamHandle("GetSensorDataBitDepth" "_Maximum");
		
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_SENSOR_DATA_BIT_DEPTH XI_PRM_INFO_MAX, &val);
		CheckResult(res,"GetSensorDataBitDepth" "_Maximum");
		return (XI_BIT_DEPTH)val;
	}
	
	XI_BIT_DEPTH xiAPIplus_Camera::GetSensorDataBitDepth_Minimum()
	{
		int val=0;
		
		CheckCamHandle("GetSensorDataBitDepth" "_Minimum");
		
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_SENSOR_DATA_BIT_DEPTH XI_PRM_INFO_MIN, &val);
		CheckResult(res,"GetSensorDataBitDepth" "_Minimum");
		return (XI_BIT_DEPTH)val;
	}
	
	int xiAPIplus_Camera::GetSensorDataBitDepth_Increment()
	{
		int val=0;
		
		CheckCamHandle("GetSensorDataBitDepth" "_Increment");
		
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_SENSOR_DATA_BIT_DEPTH XI_PRM_INFO_INCREMENT, &val);
		CheckResult(res,"GetSensorDataBitDepth" "_Increment");
		return val;
	}
	
	void xiAPIplus_Camera::SetSensorDataBitDepth(XI_BIT_DEPTH SensorDataBitDepth)
	{
		
		CheckCamHandleInt("SetSensorDataBitDepth",(int)SensorDataBitDepth);
		
		XI_RETURN res=xiSetParamInt(camera_handle, XI_PRM_SENSOR_DATA_BIT_DEPTH, SensorDataBitDepth);
		CheckResult(res,"SetSensorDataBitDepth");
	}
	 
	
	// Device output data bit depth. (XI_PRM_OUTPUT_DATA_BIT_DEPTH)
	XI_BIT_DEPTH xiAPIplus_Camera::GetDeviceOutputDataBitDepth()
	{
		int val=0;
		
		CheckCamHandle("GetDeviceOutputDataBitDepth");
		
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_OUTPUT_DATA_BIT_DEPTH, &val);
		CheckResult(res,"GetDeviceOutputDataBitDepth");
		return (XI_BIT_DEPTH)val;
	}
	
	XI_BIT_DEPTH xiAPIplus_Camera::GetDeviceOutputDataBitDepth_Maximum()
	{
		int val=0;
		
		CheckCamHandle("GetDeviceOutputDataBitDepth" "_Maximum");
		
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_OUTPUT_DATA_BIT_DEPTH XI_PRM_INFO_MAX, &val);
		CheckResult(res,"GetDeviceOutputDataBitDepth" "_Maximum");
		return (XI_BIT_DEPTH)val;
	}
	
	XI_BIT_DEPTH xiAPIplus_Camera::GetDeviceOutputDataBitDepth_Minimum()
	{
		int val=0;
		
		CheckCamHandle("GetDeviceOutputDataBitDepth" "_Minimum");
		
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_OUTPUT_DATA_BIT_DEPTH XI_PRM_INFO_MIN, &val);
		CheckResult(res,"GetDeviceOutputDataBitDepth" "_Minimum");
		return (XI_BIT_DEPTH)val;
	}
	
	int xiAPIplus_Camera::GetDeviceOutputDataBitDepth_Increment()
	{
		int val=0;
		
		CheckCamHandle("GetDeviceOutputDataBitDepth" "_Increment");
		
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_OUTPUT_DATA_BIT_DEPTH XI_PRM_INFO_INCREMENT, &val);
		CheckResult(res,"GetDeviceOutputDataBitDepth" "_Increment");
		return val;
	}
	
	void xiAPIplus_Camera::SetDeviceOutputDataBitDepth(XI_BIT_DEPTH DeviceOutputDataBitDepth)
	{
		
		CheckCamHandleInt("SetDeviceOutputDataBitDepth",(int)DeviceOutputDataBitDepth);
		
		XI_RETURN res=xiSetParamInt(camera_handle, XI_PRM_OUTPUT_DATA_BIT_DEPTH, DeviceOutputDataBitDepth);
		CheckResult(res,"SetDeviceOutputDataBitDepth");
	}
	 
	
	// bit depth of data returned by function xiGetImage (XI_PRM_IMAGE_DATA_BIT_DEPTH)
	XI_BIT_DEPTH xiAPIplus_Camera::GetImageDataBitDepth()
	{
		int val=0;
		
		CheckCamHandle("GetImageDataBitDepth");
		
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_IMAGE_DATA_BIT_DEPTH, &val);
		CheckResult(res,"GetImageDataBitDepth");
		return (XI_BIT_DEPTH)val;
	}
	
	XI_BIT_DEPTH xiAPIplus_Camera::GetImageDataBitDepth_Maximum()
	{
		int val=0;
		
		CheckCamHandle("GetImageDataBitDepth" "_Maximum");
		
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_IMAGE_DATA_BIT_DEPTH XI_PRM_INFO_MAX, &val);
		CheckResult(res,"GetImageDataBitDepth" "_Maximum");
		return (XI_BIT_DEPTH)val;
	}
	
	XI_BIT_DEPTH xiAPIplus_Camera::GetImageDataBitDepth_Minimum()
	{
		int val=0;
		
		CheckCamHandle("GetImageDataBitDepth" "_Minimum");
		
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_IMAGE_DATA_BIT_DEPTH XI_PRM_INFO_MIN, &val);
		CheckResult(res,"GetImageDataBitDepth" "_Minimum");
		return (XI_BIT_DEPTH)val;
	}
	
	int xiAPIplus_Camera::GetImageDataBitDepth_Increment()
	{
		int val=0;
		
		CheckCamHandle("GetImageDataBitDepth" "_Increment");
		
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_IMAGE_DATA_BIT_DEPTH XI_PRM_INFO_INCREMENT, &val);
		CheckResult(res,"GetImageDataBitDepth" "_Increment");
		return val;
	}
	
	void xiAPIplus_Camera::SetImageDataBitDepth(XI_BIT_DEPTH ImageDataBitDepth)
	{
		
		CheckCamHandleInt("SetImageDataBitDepth",(int)ImageDataBitDepth);
		
		XI_RETURN res=xiSetParamInt(camera_handle, XI_PRM_IMAGE_DATA_BIT_DEPTH, ImageDataBitDepth);
		CheckResult(res,"SetImageDataBitDepth");
	}
	 
	
	// Device output data packing (or grouping) enabled. Packing could be enabled if output_data_bit_depth > 8 and packing capability is available. (XI_PRM_OUTPUT_DATA_PACKING)
	bool xiAPIplus_Camera::IsDeviceOutputDataPacking()
	{
		int val=0;
		
		CheckCamHandle("IsDeviceOutputDataPacking");
		
		xiGetParamInt(camera_handle, XI_PRM_OUTPUT_DATA_PACKING, &val);
		return (val!=0);
	}
	
	void xiAPIplus_Camera::EnableDeviceOutputDataPacking()
	{
		
		CheckCamHandle("IsDeviceOutputDataPacking");
		
		XI_RETURN res=xiSetParamInt(camera_handle, XI_PRM_OUTPUT_DATA_PACKING, XI_ON);
		CheckResult(res,"EnableDeviceOutputDataPacking");
	}

	void xiAPIplus_Camera::DisableDeviceOutputDataPacking()
	{
		
		CheckCamHandle("DisableDeviceOutputDataPacking");
		
		XI_RETURN res=xiSetParamInt(camera_handle, XI_PRM_OUTPUT_DATA_PACKING, XI_OFF);
		CheckResult(res,"DisableDeviceOutputDataPacking");
	}	
	 
	
	// Data packing type. Some cameras supports only specific packing type. (XI_PRM_OUTPUT_DATA_PACKING_TYPE)
	XI_OUTPUT_DATA_PACKING_TYPE xiAPIplus_Camera::GetDeviceOutputDataPackingType()
	{
		int val=0;
		
		CheckCamHandle("GetDeviceOutputDataPackingType");
		
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_OUTPUT_DATA_PACKING_TYPE, &val);
		CheckResult(res,"GetDeviceOutputDataPackingType");
		return (XI_OUTPUT_DATA_PACKING_TYPE)val;
	}
	
	XI_OUTPUT_DATA_PACKING_TYPE xiAPIplus_Camera::GetDeviceOutputDataPackingType_Maximum()
	{
		int val=0;
		
		CheckCamHandle("GetDeviceOutputDataPackingType" "_Maximum");
		
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_OUTPUT_DATA_PACKING_TYPE XI_PRM_INFO_MAX, &val);
		CheckResult(res,"GetDeviceOutputDataPackingType" "_Maximum");
		return (XI_OUTPUT_DATA_PACKING_TYPE)val;
	}
	
	XI_OUTPUT_DATA_PACKING_TYPE xiAPIplus_Camera::GetDeviceOutputDataPackingType_Minimum()
	{
		int val=0;
		
		CheckCamHandle("GetDeviceOutputDataPackingType" "_Minimum");
		
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_OUTPUT_DATA_PACKING_TYPE XI_PRM_INFO_MIN, &val);
		CheckResult(res,"GetDeviceOutputDataPackingType" "_Minimum");
		return (XI_OUTPUT_DATA_PACKING_TYPE)val;
	}
	
	int xiAPIplus_Camera::GetDeviceOutputDataPackingType_Increment()
	{
		int val=0;
		
		CheckCamHandle("GetDeviceOutputDataPackingType" "_Increment");
		
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_OUTPUT_DATA_PACKING_TYPE XI_PRM_INFO_INCREMENT, &val);
		CheckResult(res,"GetDeviceOutputDataPackingType" "_Increment");
		return val;
	}
	
	void xiAPIplus_Camera::SetDeviceOutputDataPackingType(XI_OUTPUT_DATA_PACKING_TYPE DeviceOutputDataPackingType)
	{
		
		CheckCamHandleInt("SetDeviceOutputDataPackingType",(int)DeviceOutputDataPackingType);
		
		XI_RETURN res=xiSetParamInt(camera_handle, XI_PRM_OUTPUT_DATA_PACKING_TYPE, DeviceOutputDataPackingType);
		CheckResult(res,"SetDeviceOutputDataPackingType");
	}
	

	//-------------------------------------------------------------------------------------------------------------------
	// ---- Parameter Group: Temperature
	//-------------------------------------------------------------------------------------------------------------------

	 
	
	// Returns 1 for cameras that support cooling. (XI_PRM_IS_COOLED)
	bool xiAPIplus_Camera::IsCooled()
	{
		int val=0;
		
		CheckCamHandle("IsCooled");
		
		xiGetParamInt(camera_handle, XI_PRM_IS_COOLED, &val);
		return (val!=0);
	}
	 
	
	// Temperature control mode. (XI_PRM_COOLING)
	XI_TEMP_CTRL_MODE_SELECTOR xiAPIplus_Camera::GetCooling()
	{
		int val=0;
		
		CheckCamHandle("GetCooling");
		
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_COOLING, &val);
		CheckResult(res,"GetCooling");
		return (XI_TEMP_CTRL_MODE_SELECTOR)val;
	}
	
	XI_TEMP_CTRL_MODE_SELECTOR xiAPIplus_Camera::GetCooling_Maximum()
	{
		int val=0;
		
		CheckCamHandle("GetCooling" "_Maximum");
		
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_COOLING XI_PRM_INFO_MAX, &val);
		CheckResult(res,"GetCooling" "_Maximum");
		return (XI_TEMP_CTRL_MODE_SELECTOR)val;
	}
	
	XI_TEMP_CTRL_MODE_SELECTOR xiAPIplus_Camera::GetCooling_Minimum()
	{
		int val=0;
		
		CheckCamHandle("GetCooling" "_Minimum");
		
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_COOLING XI_PRM_INFO_MIN, &val);
		CheckResult(res,"GetCooling" "_Minimum");
		return (XI_TEMP_CTRL_MODE_SELECTOR)val;
	}
	
	int xiAPIplus_Camera::GetCooling_Increment()
	{
		int val=0;
		
		CheckCamHandle("GetCooling" "_Increment");
		
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_COOLING XI_PRM_INFO_INCREMENT, &val);
		CheckResult(res,"GetCooling" "_Increment");
		return val;
	}
	
	void xiAPIplus_Camera::SetCooling(XI_TEMP_CTRL_MODE_SELECTOR Cooling)
	{
		
		CheckCamHandleInt("SetCooling",(int)Cooling);
		
		XI_RETURN res=xiSetParamInt(camera_handle, XI_PRM_COOLING, Cooling);
		CheckResult(res,"SetCooling");
	}
	 
	
	// Set sensor target temperature for cooling. (XI_PRM_TARGET_TEMP)
	float xiAPIplus_Camera::GetTargetTemperature()
	{
		float val=0;
		
		CheckCamHandle("GetTargetTemperature");
		
		XI_RETURN res=xiGetParamFloat(camera_handle, XI_PRM_TARGET_TEMP, &val);
		CheckResult(res,"GetTargetTemperature");
		return val;
	}

	float xiAPIplus_Camera::GetTargetTemperature_Maximum()
	{
		float val=0;
		
		CheckCamHandle("GetTargetTemperature" "_Maximum");
		
		XI_RETURN res=xiGetParamFloat(camera_handle, XI_PRM_TARGET_TEMP XI_PRM_INFO_MAX, &val);
		CheckResult(res,"GetTargetTemperature" "_Maximum");
		return val;
	}

	float xiAPIplus_Camera::GetTargetTemperature_Minimum()
	{
		float val=0;
		
		CheckCamHandle("GetTargetTemperature" "_Minimum");
		
		XI_RETURN res=xiGetParamFloat(camera_handle, XI_PRM_TARGET_TEMP XI_PRM_INFO_MIN, &val);
		CheckResult(res,"GetTargetTemperature" "_Minimum");
		return val;
	}

	float xiAPIplus_Camera::GetTargetTemperature_Increment()
	{
		float val=0;
		
		CheckCamHandle("GetTargetTemperature" "_Increment");
		
		XI_RETURN res=xiGetParamFloat(camera_handle, XI_PRM_TARGET_TEMP XI_PRM_INFO_INCREMENT, &val);
		CheckResult(res,"GetTargetTemperature" "_Increment");
		return val;
	}
	
	void xiAPIplus_Camera::SetTargetTemperature(float TargetTemperature)
	{
		
		CheckCamHandle("SetTargetTemperature");
		
		XI_RETURN res=xiSetParamFloat(camera_handle, XI_PRM_TARGET_TEMP, TargetTemperature);
		CheckResult(res,"SetTargetTemperature");
	}
	 
	
	// Selector of mechanical point where thermometer is located. (XI_PRM_TEMP_SELECTOR)
	XI_TEMP_SELECTOR xiAPIplus_Camera::GetTemperatureSelector()
	{
		int val=0;
		
		CheckCamHandle("GetTemperatureSelector");
		
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_TEMP_SELECTOR, &val);
		CheckResult(res,"GetTemperatureSelector");
		return (XI_TEMP_SELECTOR)val;
	}
	
	XI_TEMP_SELECTOR xiAPIplus_Camera::GetTemperatureSelector_Maximum()
	{
		int val=0;
		
		CheckCamHandle("GetTemperatureSelector" "_Maximum");
		
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_TEMP_SELECTOR XI_PRM_INFO_MAX, &val);
		CheckResult(res,"GetTemperatureSelector" "_Maximum");
		return (XI_TEMP_SELECTOR)val;
	}
	
	XI_TEMP_SELECTOR xiAPIplus_Camera::GetTemperatureSelector_Minimum()
	{
		int val=0;
		
		CheckCamHandle("GetTemperatureSelector" "_Minimum");
		
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_TEMP_SELECTOR XI_PRM_INFO_MIN, &val);
		CheckResult(res,"GetTemperatureSelector" "_Minimum");
		return (XI_TEMP_SELECTOR)val;
	}
	
	int xiAPIplus_Camera::GetTemperatureSelector_Increment()
	{
		int val=0;
		
		CheckCamHandle("GetTemperatureSelector" "_Increment");
		
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_TEMP_SELECTOR XI_PRM_INFO_INCREMENT, &val);
		CheckResult(res,"GetTemperatureSelector" "_Increment");
		return val;
	}
	
	void xiAPIplus_Camera::SetTemperatureSelector(XI_TEMP_SELECTOR TemperatureSelector)
	{
		
		CheckCamHandleInt("SetTemperatureSelector",(int)TemperatureSelector);
		
		XI_RETURN res=xiSetParamInt(camera_handle, XI_PRM_TEMP_SELECTOR, TemperatureSelector);
		CheckResult(res,"SetTemperatureSelector");
	}
	 
	
	// Camera temperature (selected by XI_PRM_TEMP_SELECTOR) (XI_PRM_TEMP)
	float xiAPIplus_Camera::GetTemperature()
	{
		float val=0;
		
		CheckCamHandle("GetTemperature");
		
		XI_RETURN res=xiGetParamFloat(camera_handle, XI_PRM_TEMP, &val);
		CheckResult(res,"GetTemperature");
		return val;
	}

	float xiAPIplus_Camera::GetTemperature_Maximum()
	{
		float val=0;
		
		CheckCamHandle("GetTemperature" "_Maximum");
		
		XI_RETURN res=xiGetParamFloat(camera_handle, XI_PRM_TEMP XI_PRM_INFO_MAX, &val);
		CheckResult(res,"GetTemperature" "_Maximum");
		return val;
	}

	float xiAPIplus_Camera::GetTemperature_Minimum()
	{
		float val=0;
		
		CheckCamHandle("GetTemperature" "_Minimum");
		
		XI_RETURN res=xiGetParamFloat(camera_handle, XI_PRM_TEMP XI_PRM_INFO_MIN, &val);
		CheckResult(res,"GetTemperature" "_Minimum");
		return val;
	}

	float xiAPIplus_Camera::GetTemperature_Increment()
	{
		float val=0;
		
		CheckCamHandle("GetTemperature" "_Increment");
		
		XI_RETURN res=xiGetParamFloat(camera_handle, XI_PRM_TEMP XI_PRM_INFO_INCREMENT, &val);
		CheckResult(res,"GetTemperature" "_Increment");
		return val;
	}
	 
	
	// Temperature control mode. (XI_PRM_TEMP_CONTROL_MODE)
	XI_TEMP_CTRL_MODE_SELECTOR xiAPIplus_Camera::GetTemperatureControlMode()
	{
		int val=0;
		
		CheckCamHandle("GetTemperatureControlMode");
		
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_TEMP_CONTROL_MODE, &val);
		CheckResult(res,"GetTemperatureControlMode");
		return (XI_TEMP_CTRL_MODE_SELECTOR)val;
	}
	
	XI_TEMP_CTRL_MODE_SELECTOR xiAPIplus_Camera::GetTemperatureControlMode_Maximum()
	{
		int val=0;
		
		CheckCamHandle("GetTemperatureControlMode" "_Maximum");
		
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_TEMP_CONTROL_MODE XI_PRM_INFO_MAX, &val);
		CheckResult(res,"GetTemperatureControlMode" "_Maximum");
		return (XI_TEMP_CTRL_MODE_SELECTOR)val;
	}
	
	XI_TEMP_CTRL_MODE_SELECTOR xiAPIplus_Camera::GetTemperatureControlMode_Minimum()
	{
		int val=0;
		
		CheckCamHandle("GetTemperatureControlMode" "_Minimum");
		
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_TEMP_CONTROL_MODE XI_PRM_INFO_MIN, &val);
		CheckResult(res,"GetTemperatureControlMode" "_Minimum");
		return (XI_TEMP_CTRL_MODE_SELECTOR)val;
	}
	
	int xiAPIplus_Camera::GetTemperatureControlMode_Increment()
	{
		int val=0;
		
		CheckCamHandle("GetTemperatureControlMode" "_Increment");
		
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_TEMP_CONTROL_MODE XI_PRM_INFO_INCREMENT, &val);
		CheckResult(res,"GetTemperatureControlMode" "_Increment");
		return val;
	}
	
	void xiAPIplus_Camera::SetTemperatureControlMode(XI_TEMP_CTRL_MODE_SELECTOR TemperatureControlMode)
	{
		
		CheckCamHandleInt("SetTemperatureControlMode",(int)TemperatureControlMode);
		
		XI_RETURN res=xiSetParamInt(camera_handle, XI_PRM_TEMP_CONTROL_MODE, TemperatureControlMode);
		CheckResult(res,"SetTemperatureControlMode");
	}
	 
	
	// Camera sensor temperature (XI_PRM_CHIP_TEMP)
	float xiAPIplus_Camera::GetTemperatureSensor()
	{
		float val=0;
		
		CheckCamHandle("GetTemperatureSensor");
		
		XI_RETURN res=xiGetParamFloat(camera_handle, XI_PRM_CHIP_TEMP, &val);
		CheckResult(res,"GetTemperatureSensor");
		return val;
	}

	float xiAPIplus_Camera::GetTemperatureSensor_Maximum()
	{
		float val=0;
		
		CheckCamHandle("GetTemperatureSensor" "_Maximum");
		
		XI_RETURN res=xiGetParamFloat(camera_handle, XI_PRM_CHIP_TEMP XI_PRM_INFO_MAX, &val);
		CheckResult(res,"GetTemperatureSensor" "_Maximum");
		return val;
	}

	float xiAPIplus_Camera::GetTemperatureSensor_Minimum()
	{
		float val=0;
		
		CheckCamHandle("GetTemperatureSensor" "_Minimum");
		
		XI_RETURN res=xiGetParamFloat(camera_handle, XI_PRM_CHIP_TEMP XI_PRM_INFO_MIN, &val);
		CheckResult(res,"GetTemperatureSensor" "_Minimum");
		return val;
	}

	float xiAPIplus_Camera::GetTemperatureSensor_Increment()
	{
		float val=0;
		
		CheckCamHandle("GetTemperatureSensor" "_Increment");
		
		XI_RETURN res=xiGetParamFloat(camera_handle, XI_PRM_CHIP_TEMP XI_PRM_INFO_INCREMENT, &val);
		CheckResult(res,"GetTemperatureSensor" "_Increment");
		return val;
	}
	 
	
	// Camera housing temperature (XI_PRM_HOUS_TEMP)
	float xiAPIplus_Camera::GetTemperatureHousing()
	{
		float val=0;
		
		CheckCamHandle("GetTemperatureHousing");
		
		XI_RETURN res=xiGetParamFloat(camera_handle, XI_PRM_HOUS_TEMP, &val);
		CheckResult(res,"GetTemperatureHousing");
		return val;
	}

	float xiAPIplus_Camera::GetTemperatureHousing_Maximum()
	{
		float val=0;
		
		CheckCamHandle("GetTemperatureHousing" "_Maximum");
		
		XI_RETURN res=xiGetParamFloat(camera_handle, XI_PRM_HOUS_TEMP XI_PRM_INFO_MAX, &val);
		CheckResult(res,"GetTemperatureHousing" "_Maximum");
		return val;
	}

	float xiAPIplus_Camera::GetTemperatureHousing_Minimum()
	{
		float val=0;
		
		CheckCamHandle("GetTemperatureHousing" "_Minimum");
		
		XI_RETURN res=xiGetParamFloat(camera_handle, XI_PRM_HOUS_TEMP XI_PRM_INFO_MIN, &val);
		CheckResult(res,"GetTemperatureHousing" "_Minimum");
		return val;
	}

	float xiAPIplus_Camera::GetTemperatureHousing_Increment()
	{
		float val=0;
		
		CheckCamHandle("GetTemperatureHousing" "_Increment");
		
		XI_RETURN res=xiGetParamFloat(camera_handle, XI_PRM_HOUS_TEMP XI_PRM_INFO_INCREMENT, &val);
		CheckResult(res,"GetTemperatureHousing" "_Increment");
		return val;
	}
	 
	
	// Camera housing back side temperature (XI_PRM_HOUS_BACK_SIDE_TEMP)
	float xiAPIplus_Camera::GetTemperatureHousingBackSide()
	{
		float val=0;
		
		CheckCamHandle("GetTemperatureHousingBackSide");
		
		XI_RETURN res=xiGetParamFloat(camera_handle, XI_PRM_HOUS_BACK_SIDE_TEMP, &val);
		CheckResult(res,"GetTemperatureHousingBackSide");
		return val;
	}

	float xiAPIplus_Camera::GetTemperatureHousingBackSide_Maximum()
	{
		float val=0;
		
		CheckCamHandle("GetTemperatureHousingBackSide" "_Maximum");
		
		XI_RETURN res=xiGetParamFloat(camera_handle, XI_PRM_HOUS_BACK_SIDE_TEMP XI_PRM_INFO_MAX, &val);
		CheckResult(res,"GetTemperatureHousingBackSide" "_Maximum");
		return val;
	}

	float xiAPIplus_Camera::GetTemperatureHousingBackSide_Minimum()
	{
		float val=0;
		
		CheckCamHandle("GetTemperatureHousingBackSide" "_Minimum");
		
		XI_RETURN res=xiGetParamFloat(camera_handle, XI_PRM_HOUS_BACK_SIDE_TEMP XI_PRM_INFO_MIN, &val);
		CheckResult(res,"GetTemperatureHousingBackSide" "_Minimum");
		return val;
	}

	float xiAPIplus_Camera::GetTemperatureHousingBackSide_Increment()
	{
		float val=0;
		
		CheckCamHandle("GetTemperatureHousingBackSide" "_Increment");
		
		XI_RETURN res=xiGetParamFloat(camera_handle, XI_PRM_HOUS_BACK_SIDE_TEMP XI_PRM_INFO_INCREMENT, &val);
		CheckResult(res,"GetTemperatureHousingBackSide" "_Increment");
		return val;
	}
	 
	
	// Camera sensor board temperature (XI_PRM_SENSOR_BOARD_TEMP)
	float xiAPIplus_Camera::GetTemperatureSensorBoard()
	{
		float val=0;
		
		CheckCamHandle("GetTemperatureSensorBoard");
		
		XI_RETURN res=xiGetParamFloat(camera_handle, XI_PRM_SENSOR_BOARD_TEMP, &val);
		CheckResult(res,"GetTemperatureSensorBoard");
		return val;
	}

	float xiAPIplus_Camera::GetTemperatureSensorBoard_Maximum()
	{
		float val=0;
		
		CheckCamHandle("GetTemperatureSensorBoard" "_Maximum");
		
		XI_RETURN res=xiGetParamFloat(camera_handle, XI_PRM_SENSOR_BOARD_TEMP XI_PRM_INFO_MAX, &val);
		CheckResult(res,"GetTemperatureSensorBoard" "_Maximum");
		return val;
	}

	float xiAPIplus_Camera::GetTemperatureSensorBoard_Minimum()
	{
		float val=0;
		
		CheckCamHandle("GetTemperatureSensorBoard" "_Minimum");
		
		XI_RETURN res=xiGetParamFloat(camera_handle, XI_PRM_SENSOR_BOARD_TEMP XI_PRM_INFO_MIN, &val);
		CheckResult(res,"GetTemperatureSensorBoard" "_Minimum");
		return val;
	}

	float xiAPIplus_Camera::GetTemperatureSensorBoard_Increment()
	{
		float val=0;
		
		CheckCamHandle("GetTemperatureSensorBoard" "_Increment");
		
		XI_RETURN res=xiGetParamFloat(camera_handle, XI_PRM_SENSOR_BOARD_TEMP XI_PRM_INFO_INCREMENT, &val);
		CheckResult(res,"GetTemperatureSensorBoard" "_Increment");
		return val;
	}
	 
	
	// Temperature element selector (TEC(Peltier), Fan). (XI_PRM_TEMP_ELEMENT_SEL)
	XI_TEMP_ELEMENT_SELECTOR xiAPIplus_Camera::GetTemperatureElementSelector()
	{
		int val=0;
		
		CheckCamHandle("GetTemperatureElementSelector");
		
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_TEMP_ELEMENT_SEL, &val);
		CheckResult(res,"GetTemperatureElementSelector");
		return (XI_TEMP_ELEMENT_SELECTOR)val;
	}
	
	XI_TEMP_ELEMENT_SELECTOR xiAPIplus_Camera::GetTemperatureElementSelector_Maximum()
	{
		int val=0;
		
		CheckCamHandle("GetTemperatureElementSelector" "_Maximum");
		
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_TEMP_ELEMENT_SEL XI_PRM_INFO_MAX, &val);
		CheckResult(res,"GetTemperatureElementSelector" "_Maximum");
		return (XI_TEMP_ELEMENT_SELECTOR)val;
	}
	
	XI_TEMP_ELEMENT_SELECTOR xiAPIplus_Camera::GetTemperatureElementSelector_Minimum()
	{
		int val=0;
		
		CheckCamHandle("GetTemperatureElementSelector" "_Minimum");
		
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_TEMP_ELEMENT_SEL XI_PRM_INFO_MIN, &val);
		CheckResult(res,"GetTemperatureElementSelector" "_Minimum");
		return (XI_TEMP_ELEMENT_SELECTOR)val;
	}
	
	int xiAPIplus_Camera::GetTemperatureElementSelector_Increment()
	{
		int val=0;
		
		CheckCamHandle("GetTemperatureElementSelector" "_Increment");
		
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_TEMP_ELEMENT_SEL XI_PRM_INFO_INCREMENT, &val);
		CheckResult(res,"GetTemperatureElementSelector" "_Increment");
		return val;
	}
	
	void xiAPIplus_Camera::SetTemperatureElementSelector(XI_TEMP_ELEMENT_SELECTOR TemperatureElementSelector)
	{
		
		CheckCamHandleInt("SetTemperatureElementSelector",(int)TemperatureElementSelector);
		
		XI_RETURN res=xiSetParamInt(camera_handle, XI_PRM_TEMP_ELEMENT_SEL, TemperatureElementSelector);
		CheckResult(res,"SetTemperatureElementSelector");
	}
	 
	
	// Temperature element value in percents of full control range (XI_PRM_TEMP_ELEMENT_VALUE)
	float xiAPIplus_Camera::GetTemperatureElementValue()
	{
		float val=0;
		
		CheckCamHandle("GetTemperatureElementValue");
		
		XI_RETURN res=xiGetParamFloat(camera_handle, XI_PRM_TEMP_ELEMENT_VALUE, &val);
		CheckResult(res,"GetTemperatureElementValue");
		return val;
	}

	float xiAPIplus_Camera::GetTemperatureElementValue_Maximum()
	{
		float val=0;
		
		CheckCamHandle("GetTemperatureElementValue" "_Maximum");
		
		XI_RETURN res=xiGetParamFloat(camera_handle, XI_PRM_TEMP_ELEMENT_VALUE XI_PRM_INFO_MAX, &val);
		CheckResult(res,"GetTemperatureElementValue" "_Maximum");
		return val;
	}

	float xiAPIplus_Camera::GetTemperatureElementValue_Minimum()
	{
		float val=0;
		
		CheckCamHandle("GetTemperatureElementValue" "_Minimum");
		
		XI_RETURN res=xiGetParamFloat(camera_handle, XI_PRM_TEMP_ELEMENT_VALUE XI_PRM_INFO_MIN, &val);
		CheckResult(res,"GetTemperatureElementValue" "_Minimum");
		return val;
	}

	float xiAPIplus_Camera::GetTemperatureElementValue_Increment()
	{
		float val=0;
		
		CheckCamHandle("GetTemperatureElementValue" "_Increment");
		
		XI_RETURN res=xiGetParamFloat(camera_handle, XI_PRM_TEMP_ELEMENT_VALUE XI_PRM_INFO_INCREMENT, &val);
		CheckResult(res,"GetTemperatureElementValue" "_Increment");
		return val;
	}
	
	void xiAPIplus_Camera::SetTemperatureElementValue(float TemperatureElementValue)
	{
		
		CheckCamHandle("SetTemperatureElementValue");
		
		XI_RETURN res=xiSetParamFloat(camera_handle, XI_PRM_TEMP_ELEMENT_VALUE, TemperatureElementValue);
		CheckResult(res,"SetTemperatureElementValue");
	}
	

	//-------------------------------------------------------------------------------------------------------------------
	// ---- Parameter Group: Color Correction
	//-------------------------------------------------------------------------------------------------------------------

	 
	
	// Mode of color management system. (XI_PRM_CMS)
	XI_CMS_MODE xiAPIplus_Camera::GetColorManagementMode()
	{
		int val=0;
		
		CheckCamHandle("GetColorManagementMode");
		
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_CMS, &val);
		CheckResult(res,"GetColorManagementMode");
		return (XI_CMS_MODE)val;
	}
	
	XI_CMS_MODE xiAPIplus_Camera::GetColorManagementMode_Maximum()
	{
		int val=0;
		
		CheckCamHandle("GetColorManagementMode" "_Maximum");
		
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_CMS XI_PRM_INFO_MAX, &val);
		CheckResult(res,"GetColorManagementMode" "_Maximum");
		return (XI_CMS_MODE)val;
	}
	
	XI_CMS_MODE xiAPIplus_Camera::GetColorManagementMode_Minimum()
	{
		int val=0;
		
		CheckCamHandle("GetColorManagementMode" "_Minimum");
		
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_CMS XI_PRM_INFO_MIN, &val);
		CheckResult(res,"GetColorManagementMode" "_Minimum");
		return (XI_CMS_MODE)val;
	}
	
	int xiAPIplus_Camera::GetColorManagementMode_Increment()
	{
		int val=0;
		
		CheckCamHandle("GetColorManagementMode" "_Increment");
		
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_CMS XI_PRM_INFO_INCREMENT, &val);
		CheckResult(res,"GetColorManagementMode" "_Increment");
		return val;
	}
	
	void xiAPIplus_Camera::SetColorManagementMode(XI_CMS_MODE ColorManagementMode)
	{
		
		CheckCamHandleInt("SetColorManagementMode",(int)ColorManagementMode);
		
		XI_RETURN res=xiSetParamInt(camera_handle, XI_PRM_CMS, ColorManagementMode);
		CheckResult(res,"SetColorManagementMode");
	}
	 
	
	// Intent of color management system. (XI_PRM_CMS_INTENT)
	XI_CMS_INTENT xiAPIplus_Camera::GetColorManagementIntent()
	{
		int val=0;
		
		CheckCamHandle("GetColorManagementIntent");
		
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_CMS_INTENT, &val);
		CheckResult(res,"GetColorManagementIntent");
		return (XI_CMS_INTENT)val;
	}
	
	XI_CMS_INTENT xiAPIplus_Camera::GetColorManagementIntent_Maximum()
	{
		int val=0;
		
		CheckCamHandle("GetColorManagementIntent" "_Maximum");
		
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_CMS_INTENT XI_PRM_INFO_MAX, &val);
		CheckResult(res,"GetColorManagementIntent" "_Maximum");
		return (XI_CMS_INTENT)val;
	}
	
	XI_CMS_INTENT xiAPIplus_Camera::GetColorManagementIntent_Minimum()
	{
		int val=0;
		
		CheckCamHandle("GetColorManagementIntent" "_Minimum");
		
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_CMS_INTENT XI_PRM_INFO_MIN, &val);
		CheckResult(res,"GetColorManagementIntent" "_Minimum");
		return (XI_CMS_INTENT)val;
	}
	
	int xiAPIplus_Camera::GetColorManagementIntent_Increment()
	{
		int val=0;
		
		CheckCamHandle("GetColorManagementIntent" "_Increment");
		
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_CMS_INTENT XI_PRM_INFO_INCREMENT, &val);
		CheckResult(res,"GetColorManagementIntent" "_Increment");
		return val;
	}
	
	void xiAPIplus_Camera::SetColorManagementIntent(XI_CMS_INTENT ColorManagementIntent)
	{
		
		CheckCamHandleInt("SetColorManagementIntent",(int)ColorManagementIntent);
		
		XI_RETURN res=xiSetParamInt(camera_handle, XI_PRM_CMS_INTENT, ColorManagementIntent);
		CheckResult(res,"SetColorManagementIntent");
	}
	 
	
	// Enable applying of CMS profiles to xiGetImage (see XI_PRM_INPUT_CMS_PROFILE, XI_PRM_OUTPUT_CMS_PROFILE). (XI_PRM_APPLY_CMS)
	bool xiAPIplus_Camera::IsColorManagementApply()
	{
		int val=0;
		
		CheckCamHandle("IsColorManagementApply");
		
		xiGetParamInt(camera_handle, XI_PRM_APPLY_CMS, &val);
		return (val!=0);
	}
	
	void xiAPIplus_Camera::EnableColorManagementApply()
	{
		
		CheckCamHandle("IsColorManagementApply");
		
		XI_RETURN res=xiSetParamInt(camera_handle, XI_PRM_APPLY_CMS, XI_ON);
		CheckResult(res,"EnableColorManagementApply");
	}

	void xiAPIplus_Camera::DisableColorManagementApply()
	{
		
		CheckCamHandle("DisableColorManagementApply");
		
		XI_RETURN res=xiSetParamInt(camera_handle, XI_PRM_APPLY_CMS, XI_OFF);
		CheckResult(res,"DisableColorManagementApply");
	}	
	 
	
	// Filename for input cms profile (e.g. input.icc) (XI_PRM_INPUT_CMS_PROFILE)
	void xiAPIplus_Camera::GetColorManagementInputProfile(char* buffer, int buffer_length)
	{
		
		CheckCamHandle("GetColorManagementInputProfile");
		
		XI_RETURN res=xiGetParamString(camera_handle, XI_PRM_INPUT_CMS_PROFILE, buffer, buffer_length);
		CheckResult(res,"GetColorManagementInputProfile");
	}
	
	void xiAPIplus_Camera::SetColorManagementInputProfile(char* new_value)
	{
		
		CheckCamHandle("SetColorManagementInputProfile");
		
		XI_RETURN res=xiSetParamString(camera_handle, XI_PRM_INPUT_CMS_PROFILE, new_value, (DWORD)strlen(new_value));
		CheckResult(res,"SetColorManagementInputProfile");
	}
	 
	
	// Filename for output cms profile (e.g. input.icc) (XI_PRM_OUTPUT_CMS_PROFILE)
	void xiAPIplus_Camera::GetColorManagementOutputProfile(char* buffer, int buffer_length)
	{
		
		CheckCamHandle("GetColorManagementOutputProfile");
		
		XI_RETURN res=xiGetParamString(camera_handle, XI_PRM_OUTPUT_CMS_PROFILE, buffer, buffer_length);
		CheckResult(res,"GetColorManagementOutputProfile");
	}
	
	void xiAPIplus_Camera::SetColorManagementOutputProfile(char* new_value)
	{
		
		CheckCamHandle("SetColorManagementOutputProfile");
		
		XI_RETURN res=xiSetParamString(camera_handle, XI_PRM_OUTPUT_CMS_PROFILE, new_value, (DWORD)strlen(new_value));
		CheckResult(res,"SetColorManagementOutputProfile");
	}
	 
	
	// Returns 1 for color cameras. (XI_PRM_IMAGE_IS_COLOR)
	bool xiAPIplus_Camera::IsSensorColor()
	{
		int val=0;
		
		CheckCamHandle("IsSensorColor");
		
		xiGetParamInt(camera_handle, XI_PRM_IMAGE_IS_COLOR, &val);
		return (val!=0);
	}
	 
	
	// Returns color filter array type of RAW data. (XI_PRM_COLOR_FILTER_ARRAY)
	XI_COLOR_FILTER_ARRAY xiAPIplus_Camera::GetSensorColorFilterArray()
	{
		int val=0;
		
		CheckCamHandle("GetSensorColorFilterArray");
		
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_COLOR_FILTER_ARRAY, &val);
		CheckResult(res,"GetSensorColorFilterArray");
		return (XI_COLOR_FILTER_ARRAY)val;
	}
	
	XI_COLOR_FILTER_ARRAY xiAPIplus_Camera::GetSensorColorFilterArray_Maximum()
	{
		int val=0;
		
		CheckCamHandle("GetSensorColorFilterArray" "_Maximum");
		
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_COLOR_FILTER_ARRAY XI_PRM_INFO_MAX, &val);
		CheckResult(res,"GetSensorColorFilterArray" "_Maximum");
		return (XI_COLOR_FILTER_ARRAY)val;
	}
	
	XI_COLOR_FILTER_ARRAY xiAPIplus_Camera::GetSensorColorFilterArray_Minimum()
	{
		int val=0;
		
		CheckCamHandle("GetSensorColorFilterArray" "_Minimum");
		
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_COLOR_FILTER_ARRAY XI_PRM_INFO_MIN, &val);
		CheckResult(res,"GetSensorColorFilterArray" "_Minimum");
		return (XI_COLOR_FILTER_ARRAY)val;
	}
	
	int xiAPIplus_Camera::GetSensorColorFilterArray_Increment()
	{
		int val=0;
		
		CheckCamHandle("GetSensorColorFilterArray" "_Increment");
		
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_COLOR_FILTER_ARRAY XI_PRM_INFO_INCREMENT, &val);
		CheckResult(res,"GetSensorColorFilterArray" "_Increment");
		return val;
	}
	 
	
	// Luminosity gamma (XI_PRM_GAMMAY)
	float xiAPIplus_Camera::GetGammaLuminosity()
	{
		float val=0;
		
		CheckCamHandle("GetGammaLuminosity");
		
		XI_RETURN res=xiGetParamFloat(camera_handle, XI_PRM_GAMMAY, &val);
		CheckResult(res,"GetGammaLuminosity");
		return val;
	}

	float xiAPIplus_Camera::GetGammaLuminosity_Maximum()
	{
		float val=0;
		
		CheckCamHandle("GetGammaLuminosity" "_Maximum");
		
		XI_RETURN res=xiGetParamFloat(camera_handle, XI_PRM_GAMMAY XI_PRM_INFO_MAX, &val);
		CheckResult(res,"GetGammaLuminosity" "_Maximum");
		return val;
	}

	float xiAPIplus_Camera::GetGammaLuminosity_Minimum()
	{
		float val=0;
		
		CheckCamHandle("GetGammaLuminosity" "_Minimum");
		
		XI_RETURN res=xiGetParamFloat(camera_handle, XI_PRM_GAMMAY XI_PRM_INFO_MIN, &val);
		CheckResult(res,"GetGammaLuminosity" "_Minimum");
		return val;
	}

	float xiAPIplus_Camera::GetGammaLuminosity_Increment()
	{
		float val=0;
		
		CheckCamHandle("GetGammaLuminosity" "_Increment");
		
		XI_RETURN res=xiGetParamFloat(camera_handle, XI_PRM_GAMMAY XI_PRM_INFO_INCREMENT, &val);
		CheckResult(res,"GetGammaLuminosity" "_Increment");
		return val;
	}
	
	void xiAPIplus_Camera::SetGammaLuminosity(float GammaLuminosity)
	{
		
		CheckCamHandle("SetGammaLuminosity");
		
		XI_RETURN res=xiSetParamFloat(camera_handle, XI_PRM_GAMMAY, GammaLuminosity);
		CheckResult(res,"SetGammaLuminosity");
	}
	 
	
	// Chromaticity gamma (XI_PRM_GAMMAC)
	float xiAPIplus_Camera::GetGammaChromaticity()
	{
		float val=0;
		
		CheckCamHandle("GetGammaChromaticity");
		
		XI_RETURN res=xiGetParamFloat(camera_handle, XI_PRM_GAMMAC, &val);
		CheckResult(res,"GetGammaChromaticity");
		return val;
	}

	float xiAPIplus_Camera::GetGammaChromaticity_Maximum()
	{
		float val=0;
		
		CheckCamHandle("GetGammaChromaticity" "_Maximum");
		
		XI_RETURN res=xiGetParamFloat(camera_handle, XI_PRM_GAMMAC XI_PRM_INFO_MAX, &val);
		CheckResult(res,"GetGammaChromaticity" "_Maximum");
		return val;
	}

	float xiAPIplus_Camera::GetGammaChromaticity_Minimum()
	{
		float val=0;
		
		CheckCamHandle("GetGammaChromaticity" "_Minimum");
		
		XI_RETURN res=xiGetParamFloat(camera_handle, XI_PRM_GAMMAC XI_PRM_INFO_MIN, &val);
		CheckResult(res,"GetGammaChromaticity" "_Minimum");
		return val;
	}

	float xiAPIplus_Camera::GetGammaChromaticity_Increment()
	{
		float val=0;
		
		CheckCamHandle("GetGammaChromaticity" "_Increment");
		
		XI_RETURN res=xiGetParamFloat(camera_handle, XI_PRM_GAMMAC XI_PRM_INFO_INCREMENT, &val);
		CheckResult(res,"GetGammaChromaticity" "_Increment");
		return val;
	}
	
	void xiAPIplus_Camera::SetGammaChromaticity(float GammaChromaticity)
	{
		
		CheckCamHandle("SetGammaChromaticity");
		
		XI_RETURN res=xiSetParamFloat(camera_handle, XI_PRM_GAMMAC, GammaChromaticity);
		CheckResult(res,"SetGammaChromaticity");
	}
	 
	
	// Sharpness strength (XI_PRM_SHARPNESS)
	float xiAPIplus_Camera::GetSharpness()
	{
		float val=0;
		
		CheckCamHandle("GetSharpness");
		
		XI_RETURN res=xiGetParamFloat(camera_handle, XI_PRM_SHARPNESS, &val);
		CheckResult(res,"GetSharpness");
		return val;
	}

	float xiAPIplus_Camera::GetSharpness_Maximum()
	{
		float val=0;
		
		CheckCamHandle("GetSharpness" "_Maximum");
		
		XI_RETURN res=xiGetParamFloat(camera_handle, XI_PRM_SHARPNESS XI_PRM_INFO_MAX, &val);
		CheckResult(res,"GetSharpness" "_Maximum");
		return val;
	}

	float xiAPIplus_Camera::GetSharpness_Minimum()
	{
		float val=0;
		
		CheckCamHandle("GetSharpness" "_Minimum");
		
		XI_RETURN res=xiGetParamFloat(camera_handle, XI_PRM_SHARPNESS XI_PRM_INFO_MIN, &val);
		CheckResult(res,"GetSharpness" "_Minimum");
		return val;
	}

	float xiAPIplus_Camera::GetSharpness_Increment()
	{
		float val=0;
		
		CheckCamHandle("GetSharpness" "_Increment");
		
		XI_RETURN res=xiGetParamFloat(camera_handle, XI_PRM_SHARPNESS XI_PRM_INFO_INCREMENT, &val);
		CheckResult(res,"GetSharpness" "_Increment");
		return val;
	}
	
	void xiAPIplus_Camera::SetSharpness(float Sharpness)
	{
		
		CheckCamHandle("SetSharpness");
		
		XI_RETURN res=xiSetParamFloat(camera_handle, XI_PRM_SHARPNESS, Sharpness);
		CheckResult(res,"SetSharpness");
	}
	 
	
	// Color Correction Matrix element [0][0] (XI_PRM_CC_MATRIX_00)
	float xiAPIplus_Camera::GetColorCorrectionMatrix00()
	{
		float val=0;
		
		CheckCamHandle("GetColorCorrectionMatrix00");
		
		XI_RETURN res=xiGetParamFloat(camera_handle, XI_PRM_CC_MATRIX_00, &val);
		CheckResult(res,"GetColorCorrectionMatrix00");
		return val;
	}

	float xiAPIplus_Camera::GetColorCorrectionMatrix00_Maximum()
	{
		float val=0;
		
		CheckCamHandle("GetColorCorrectionMatrix00" "_Maximum");
		
		XI_RETURN res=xiGetParamFloat(camera_handle, XI_PRM_CC_MATRIX_00 XI_PRM_INFO_MAX, &val);
		CheckResult(res,"GetColorCorrectionMatrix00" "_Maximum");
		return val;
	}

	float xiAPIplus_Camera::GetColorCorrectionMatrix00_Minimum()
	{
		float val=0;
		
		CheckCamHandle("GetColorCorrectionMatrix00" "_Minimum");
		
		XI_RETURN res=xiGetParamFloat(camera_handle, XI_PRM_CC_MATRIX_00 XI_PRM_INFO_MIN, &val);
		CheckResult(res,"GetColorCorrectionMatrix00" "_Minimum");
		return val;
	}

	float xiAPIplus_Camera::GetColorCorrectionMatrix00_Increment()
	{
		float val=0;
		
		CheckCamHandle("GetColorCorrectionMatrix00" "_Increment");
		
		XI_RETURN res=xiGetParamFloat(camera_handle, XI_PRM_CC_MATRIX_00 XI_PRM_INFO_INCREMENT, &val);
		CheckResult(res,"GetColorCorrectionMatrix00" "_Increment");
		return val;
	}
	
	void xiAPIplus_Camera::SetColorCorrectionMatrix00(float ColorCorrectionMatrix00)
	{
		
		CheckCamHandle("SetColorCorrectionMatrix00");
		
		XI_RETURN res=xiSetParamFloat(camera_handle, XI_PRM_CC_MATRIX_00, ColorCorrectionMatrix00);
		CheckResult(res,"SetColorCorrectionMatrix00");
	}
	 
	
	// Color Correction Matrix element [0][1] (XI_PRM_CC_MATRIX_01)
	float xiAPIplus_Camera::GetColorCorrectionMatrix01()
	{
		float val=0;
		
		CheckCamHandle("GetColorCorrectionMatrix01");
		
		XI_RETURN res=xiGetParamFloat(camera_handle, XI_PRM_CC_MATRIX_01, &val);
		CheckResult(res,"GetColorCorrectionMatrix01");
		return val;
	}

	float xiAPIplus_Camera::GetColorCorrectionMatrix01_Maximum()
	{
		float val=0;
		
		CheckCamHandle("GetColorCorrectionMatrix01" "_Maximum");
		
		XI_RETURN res=xiGetParamFloat(camera_handle, XI_PRM_CC_MATRIX_01 XI_PRM_INFO_MAX, &val);
		CheckResult(res,"GetColorCorrectionMatrix01" "_Maximum");
		return val;
	}

	float xiAPIplus_Camera::GetColorCorrectionMatrix01_Minimum()
	{
		float val=0;
		
		CheckCamHandle("GetColorCorrectionMatrix01" "_Minimum");
		
		XI_RETURN res=xiGetParamFloat(camera_handle, XI_PRM_CC_MATRIX_01 XI_PRM_INFO_MIN, &val);
		CheckResult(res,"GetColorCorrectionMatrix01" "_Minimum");
		return val;
	}

	float xiAPIplus_Camera::GetColorCorrectionMatrix01_Increment()
	{
		float val=0;
		
		CheckCamHandle("GetColorCorrectionMatrix01" "_Increment");
		
		XI_RETURN res=xiGetParamFloat(camera_handle, XI_PRM_CC_MATRIX_01 XI_PRM_INFO_INCREMENT, &val);
		CheckResult(res,"GetColorCorrectionMatrix01" "_Increment");
		return val;
	}
	
	void xiAPIplus_Camera::SetColorCorrectionMatrix01(float ColorCorrectionMatrix01)
	{
		
		CheckCamHandle("SetColorCorrectionMatrix01");
		
		XI_RETURN res=xiSetParamFloat(camera_handle, XI_PRM_CC_MATRIX_01, ColorCorrectionMatrix01);
		CheckResult(res,"SetColorCorrectionMatrix01");
	}
	 
	
	// Color Correction Matrix element [0][2] (XI_PRM_CC_MATRIX_02)
	float xiAPIplus_Camera::GetColorCorrectionMatrix02()
	{
		float val=0;
		
		CheckCamHandle("GetColorCorrectionMatrix02");
		
		XI_RETURN res=xiGetParamFloat(camera_handle, XI_PRM_CC_MATRIX_02, &val);
		CheckResult(res,"GetColorCorrectionMatrix02");
		return val;
	}

	float xiAPIplus_Camera::GetColorCorrectionMatrix02_Maximum()
	{
		float val=0;
		
		CheckCamHandle("GetColorCorrectionMatrix02" "_Maximum");
		
		XI_RETURN res=xiGetParamFloat(camera_handle, XI_PRM_CC_MATRIX_02 XI_PRM_INFO_MAX, &val);
		CheckResult(res,"GetColorCorrectionMatrix02" "_Maximum");
		return val;
	}

	float xiAPIplus_Camera::GetColorCorrectionMatrix02_Minimum()
	{
		float val=0;
		
		CheckCamHandle("GetColorCorrectionMatrix02" "_Minimum");
		
		XI_RETURN res=xiGetParamFloat(camera_handle, XI_PRM_CC_MATRIX_02 XI_PRM_INFO_MIN, &val);
		CheckResult(res,"GetColorCorrectionMatrix02" "_Minimum");
		return val;
	}

	float xiAPIplus_Camera::GetColorCorrectionMatrix02_Increment()
	{
		float val=0;
		
		CheckCamHandle("GetColorCorrectionMatrix02" "_Increment");
		
		XI_RETURN res=xiGetParamFloat(camera_handle, XI_PRM_CC_MATRIX_02 XI_PRM_INFO_INCREMENT, &val);
		CheckResult(res,"GetColorCorrectionMatrix02" "_Increment");
		return val;
	}
	
	void xiAPIplus_Camera::SetColorCorrectionMatrix02(float ColorCorrectionMatrix02)
	{
		
		CheckCamHandle("SetColorCorrectionMatrix02");
		
		XI_RETURN res=xiSetParamFloat(camera_handle, XI_PRM_CC_MATRIX_02, ColorCorrectionMatrix02);
		CheckResult(res,"SetColorCorrectionMatrix02");
	}
	 
	
	// Color Correction Matrix element [0][3] (XI_PRM_CC_MATRIX_03)
	float xiAPIplus_Camera::GetColorCorrectionMatrix03()
	{
		float val=0;
		
		CheckCamHandle("GetColorCorrectionMatrix03");
		
		XI_RETURN res=xiGetParamFloat(camera_handle, XI_PRM_CC_MATRIX_03, &val);
		CheckResult(res,"GetColorCorrectionMatrix03");
		return val;
	}

	float xiAPIplus_Camera::GetColorCorrectionMatrix03_Maximum()
	{
		float val=0;
		
		CheckCamHandle("GetColorCorrectionMatrix03" "_Maximum");
		
		XI_RETURN res=xiGetParamFloat(camera_handle, XI_PRM_CC_MATRIX_03 XI_PRM_INFO_MAX, &val);
		CheckResult(res,"GetColorCorrectionMatrix03" "_Maximum");
		return val;
	}

	float xiAPIplus_Camera::GetColorCorrectionMatrix03_Minimum()
	{
		float val=0;
		
		CheckCamHandle("GetColorCorrectionMatrix03" "_Minimum");
		
		XI_RETURN res=xiGetParamFloat(camera_handle, XI_PRM_CC_MATRIX_03 XI_PRM_INFO_MIN, &val);
		CheckResult(res,"GetColorCorrectionMatrix03" "_Minimum");
		return val;
	}

	float xiAPIplus_Camera::GetColorCorrectionMatrix03_Increment()
	{
		float val=0;
		
		CheckCamHandle("GetColorCorrectionMatrix03" "_Increment");
		
		XI_RETURN res=xiGetParamFloat(camera_handle, XI_PRM_CC_MATRIX_03 XI_PRM_INFO_INCREMENT, &val);
		CheckResult(res,"GetColorCorrectionMatrix03" "_Increment");
		return val;
	}
	
	void xiAPIplus_Camera::SetColorCorrectionMatrix03(float ColorCorrectionMatrix03)
	{
		
		CheckCamHandle("SetColorCorrectionMatrix03");
		
		XI_RETURN res=xiSetParamFloat(camera_handle, XI_PRM_CC_MATRIX_03, ColorCorrectionMatrix03);
		CheckResult(res,"SetColorCorrectionMatrix03");
	}
	 
	
	// Color Correction Matrix element [1][0] (XI_PRM_CC_MATRIX_10)
	float xiAPIplus_Camera::GetColorCorrectionMatrix10()
	{
		float val=0;
		
		CheckCamHandle("GetColorCorrectionMatrix10");
		
		XI_RETURN res=xiGetParamFloat(camera_handle, XI_PRM_CC_MATRIX_10, &val);
		CheckResult(res,"GetColorCorrectionMatrix10");
		return val;
	}

	float xiAPIplus_Camera::GetColorCorrectionMatrix10_Maximum()
	{
		float val=0;
		
		CheckCamHandle("GetColorCorrectionMatrix10" "_Maximum");
		
		XI_RETURN res=xiGetParamFloat(camera_handle, XI_PRM_CC_MATRIX_10 XI_PRM_INFO_MAX, &val);
		CheckResult(res,"GetColorCorrectionMatrix10" "_Maximum");
		return val;
	}

	float xiAPIplus_Camera::GetColorCorrectionMatrix10_Minimum()
	{
		float val=0;
		
		CheckCamHandle("GetColorCorrectionMatrix10" "_Minimum");
		
		XI_RETURN res=xiGetParamFloat(camera_handle, XI_PRM_CC_MATRIX_10 XI_PRM_INFO_MIN, &val);
		CheckResult(res,"GetColorCorrectionMatrix10" "_Minimum");
		return val;
	}

	float xiAPIplus_Camera::GetColorCorrectionMatrix10_Increment()
	{
		float val=0;
		
		CheckCamHandle("GetColorCorrectionMatrix10" "_Increment");
		
		XI_RETURN res=xiGetParamFloat(camera_handle, XI_PRM_CC_MATRIX_10 XI_PRM_INFO_INCREMENT, &val);
		CheckResult(res,"GetColorCorrectionMatrix10" "_Increment");
		return val;
	}
	
	void xiAPIplus_Camera::SetColorCorrectionMatrix10(float ColorCorrectionMatrix10)
	{
		
		CheckCamHandle("SetColorCorrectionMatrix10");
		
		XI_RETURN res=xiSetParamFloat(camera_handle, XI_PRM_CC_MATRIX_10, ColorCorrectionMatrix10);
		CheckResult(res,"SetColorCorrectionMatrix10");
	}
	 
	
	// Color Correction Matrix element [1][1] (XI_PRM_CC_MATRIX_11)
	float xiAPIplus_Camera::GetColorCorrectionMatrix11()
	{
		float val=0;
		
		CheckCamHandle("GetColorCorrectionMatrix11");
		
		XI_RETURN res=xiGetParamFloat(camera_handle, XI_PRM_CC_MATRIX_11, &val);
		CheckResult(res,"GetColorCorrectionMatrix11");
		return val;
	}

	float xiAPIplus_Camera::GetColorCorrectionMatrix11_Maximum()
	{
		float val=0;
		
		CheckCamHandle("GetColorCorrectionMatrix11" "_Maximum");
		
		XI_RETURN res=xiGetParamFloat(camera_handle, XI_PRM_CC_MATRIX_11 XI_PRM_INFO_MAX, &val);
		CheckResult(res,"GetColorCorrectionMatrix11" "_Maximum");
		return val;
	}

	float xiAPIplus_Camera::GetColorCorrectionMatrix11_Minimum()
	{
		float val=0;
		
		CheckCamHandle("GetColorCorrectionMatrix11" "_Minimum");
		
		XI_RETURN res=xiGetParamFloat(camera_handle, XI_PRM_CC_MATRIX_11 XI_PRM_INFO_MIN, &val);
		CheckResult(res,"GetColorCorrectionMatrix11" "_Minimum");
		return val;
	}

	float xiAPIplus_Camera::GetColorCorrectionMatrix11_Increment()
	{
		float val=0;
		
		CheckCamHandle("GetColorCorrectionMatrix11" "_Increment");
		
		XI_RETURN res=xiGetParamFloat(camera_handle, XI_PRM_CC_MATRIX_11 XI_PRM_INFO_INCREMENT, &val);
		CheckResult(res,"GetColorCorrectionMatrix11" "_Increment");
		return val;
	}
	
	void xiAPIplus_Camera::SetColorCorrectionMatrix11(float ColorCorrectionMatrix11)
	{
		
		CheckCamHandle("SetColorCorrectionMatrix11");
		
		XI_RETURN res=xiSetParamFloat(camera_handle, XI_PRM_CC_MATRIX_11, ColorCorrectionMatrix11);
		CheckResult(res,"SetColorCorrectionMatrix11");
	}
	 
	
	// Color Correction Matrix element [1][2] (XI_PRM_CC_MATRIX_12)
	float xiAPIplus_Camera::GetColorCorrectionMatrix12()
	{
		float val=0;
		
		CheckCamHandle("GetColorCorrectionMatrix12");
		
		XI_RETURN res=xiGetParamFloat(camera_handle, XI_PRM_CC_MATRIX_12, &val);
		CheckResult(res,"GetColorCorrectionMatrix12");
		return val;
	}

	float xiAPIplus_Camera::GetColorCorrectionMatrix12_Maximum()
	{
		float val=0;
		
		CheckCamHandle("GetColorCorrectionMatrix12" "_Maximum");
		
		XI_RETURN res=xiGetParamFloat(camera_handle, XI_PRM_CC_MATRIX_12 XI_PRM_INFO_MAX, &val);
		CheckResult(res,"GetColorCorrectionMatrix12" "_Maximum");
		return val;
	}

	float xiAPIplus_Camera::GetColorCorrectionMatrix12_Minimum()
	{
		float val=0;
		
		CheckCamHandle("GetColorCorrectionMatrix12" "_Minimum");
		
		XI_RETURN res=xiGetParamFloat(camera_handle, XI_PRM_CC_MATRIX_12 XI_PRM_INFO_MIN, &val);
		CheckResult(res,"GetColorCorrectionMatrix12" "_Minimum");
		return val;
	}

	float xiAPIplus_Camera::GetColorCorrectionMatrix12_Increment()
	{
		float val=0;
		
		CheckCamHandle("GetColorCorrectionMatrix12" "_Increment");
		
		XI_RETURN res=xiGetParamFloat(camera_handle, XI_PRM_CC_MATRIX_12 XI_PRM_INFO_INCREMENT, &val);
		CheckResult(res,"GetColorCorrectionMatrix12" "_Increment");
		return val;
	}
	
	void xiAPIplus_Camera::SetColorCorrectionMatrix12(float ColorCorrectionMatrix12)
	{
		
		CheckCamHandle("SetColorCorrectionMatrix12");
		
		XI_RETURN res=xiSetParamFloat(camera_handle, XI_PRM_CC_MATRIX_12, ColorCorrectionMatrix12);
		CheckResult(res,"SetColorCorrectionMatrix12");
	}
	 
	
	// Color Correction Matrix element [1][3] (XI_PRM_CC_MATRIX_13)
	float xiAPIplus_Camera::GetColorCorrectionMatrix13()
	{
		float val=0;
		
		CheckCamHandle("GetColorCorrectionMatrix13");
		
		XI_RETURN res=xiGetParamFloat(camera_handle, XI_PRM_CC_MATRIX_13, &val);
		CheckResult(res,"GetColorCorrectionMatrix13");
		return val;
	}

	float xiAPIplus_Camera::GetColorCorrectionMatrix13_Maximum()
	{
		float val=0;
		
		CheckCamHandle("GetColorCorrectionMatrix13" "_Maximum");
		
		XI_RETURN res=xiGetParamFloat(camera_handle, XI_PRM_CC_MATRIX_13 XI_PRM_INFO_MAX, &val);
		CheckResult(res,"GetColorCorrectionMatrix13" "_Maximum");
		return val;
	}

	float xiAPIplus_Camera::GetColorCorrectionMatrix13_Minimum()
	{
		float val=0;
		
		CheckCamHandle("GetColorCorrectionMatrix13" "_Minimum");
		
		XI_RETURN res=xiGetParamFloat(camera_handle, XI_PRM_CC_MATRIX_13 XI_PRM_INFO_MIN, &val);
		CheckResult(res,"GetColorCorrectionMatrix13" "_Minimum");
		return val;
	}

	float xiAPIplus_Camera::GetColorCorrectionMatrix13_Increment()
	{
		float val=0;
		
		CheckCamHandle("GetColorCorrectionMatrix13" "_Increment");
		
		XI_RETURN res=xiGetParamFloat(camera_handle, XI_PRM_CC_MATRIX_13 XI_PRM_INFO_INCREMENT, &val);
		CheckResult(res,"GetColorCorrectionMatrix13" "_Increment");
		return val;
	}
	
	void xiAPIplus_Camera::SetColorCorrectionMatrix13(float ColorCorrectionMatrix13)
	{
		
		CheckCamHandle("SetColorCorrectionMatrix13");
		
		XI_RETURN res=xiSetParamFloat(camera_handle, XI_PRM_CC_MATRIX_13, ColorCorrectionMatrix13);
		CheckResult(res,"SetColorCorrectionMatrix13");
	}
	 
	
	// Color Correction Matrix element [2][0] (XI_PRM_CC_MATRIX_20)
	float xiAPIplus_Camera::GetColorCorrectionMatrix20()
	{
		float val=0;
		
		CheckCamHandle("GetColorCorrectionMatrix20");
		
		XI_RETURN res=xiGetParamFloat(camera_handle, XI_PRM_CC_MATRIX_20, &val);
		CheckResult(res,"GetColorCorrectionMatrix20");
		return val;
	}

	float xiAPIplus_Camera::GetColorCorrectionMatrix20_Maximum()
	{
		float val=0;
		
		CheckCamHandle("GetColorCorrectionMatrix20" "_Maximum");
		
		XI_RETURN res=xiGetParamFloat(camera_handle, XI_PRM_CC_MATRIX_20 XI_PRM_INFO_MAX, &val);
		CheckResult(res,"GetColorCorrectionMatrix20" "_Maximum");
		return val;
	}

	float xiAPIplus_Camera::GetColorCorrectionMatrix20_Minimum()
	{
		float val=0;
		
		CheckCamHandle("GetColorCorrectionMatrix20" "_Minimum");
		
		XI_RETURN res=xiGetParamFloat(camera_handle, XI_PRM_CC_MATRIX_20 XI_PRM_INFO_MIN, &val);
		CheckResult(res,"GetColorCorrectionMatrix20" "_Minimum");
		return val;
	}

	float xiAPIplus_Camera::GetColorCorrectionMatrix20_Increment()
	{
		float val=0;
		
		CheckCamHandle("GetColorCorrectionMatrix20" "_Increment");
		
		XI_RETURN res=xiGetParamFloat(camera_handle, XI_PRM_CC_MATRIX_20 XI_PRM_INFO_INCREMENT, &val);
		CheckResult(res,"GetColorCorrectionMatrix20" "_Increment");
		return val;
	}
	
	void xiAPIplus_Camera::SetColorCorrectionMatrix20(float ColorCorrectionMatrix20)
	{
		
		CheckCamHandle("SetColorCorrectionMatrix20");
		
		XI_RETURN res=xiSetParamFloat(camera_handle, XI_PRM_CC_MATRIX_20, ColorCorrectionMatrix20);
		CheckResult(res,"SetColorCorrectionMatrix20");
	}
	 
	
	// Color Correction Matrix element [2][1] (XI_PRM_CC_MATRIX_21)
	float xiAPIplus_Camera::GetColorCorrectionMatrix21()
	{
		float val=0;
		
		CheckCamHandle("GetColorCorrectionMatrix21");
		
		XI_RETURN res=xiGetParamFloat(camera_handle, XI_PRM_CC_MATRIX_21, &val);
		CheckResult(res,"GetColorCorrectionMatrix21");
		return val;
	}

	float xiAPIplus_Camera::GetColorCorrectionMatrix21_Maximum()
	{
		float val=0;
		
		CheckCamHandle("GetColorCorrectionMatrix21" "_Maximum");
		
		XI_RETURN res=xiGetParamFloat(camera_handle, XI_PRM_CC_MATRIX_21 XI_PRM_INFO_MAX, &val);
		CheckResult(res,"GetColorCorrectionMatrix21" "_Maximum");
		return val;
	}

	float xiAPIplus_Camera::GetColorCorrectionMatrix21_Minimum()
	{
		float val=0;
		
		CheckCamHandle("GetColorCorrectionMatrix21" "_Minimum");
		
		XI_RETURN res=xiGetParamFloat(camera_handle, XI_PRM_CC_MATRIX_21 XI_PRM_INFO_MIN, &val);
		CheckResult(res,"GetColorCorrectionMatrix21" "_Minimum");
		return val;
	}

	float xiAPIplus_Camera::GetColorCorrectionMatrix21_Increment()
	{
		float val=0;
		
		CheckCamHandle("GetColorCorrectionMatrix21" "_Increment");
		
		XI_RETURN res=xiGetParamFloat(camera_handle, XI_PRM_CC_MATRIX_21 XI_PRM_INFO_INCREMENT, &val);
		CheckResult(res,"GetColorCorrectionMatrix21" "_Increment");
		return val;
	}
	
	void xiAPIplus_Camera::SetColorCorrectionMatrix21(float ColorCorrectionMatrix21)
	{
		
		CheckCamHandle("SetColorCorrectionMatrix21");
		
		XI_RETURN res=xiSetParamFloat(camera_handle, XI_PRM_CC_MATRIX_21, ColorCorrectionMatrix21);
		CheckResult(res,"SetColorCorrectionMatrix21");
	}
	 
	
	// Color Correction Matrix element [2][2] (XI_PRM_CC_MATRIX_22)
	float xiAPIplus_Camera::GetColorCorrectionMatrix22()
	{
		float val=0;
		
		CheckCamHandle("GetColorCorrectionMatrix22");
		
		XI_RETURN res=xiGetParamFloat(camera_handle, XI_PRM_CC_MATRIX_22, &val);
		CheckResult(res,"GetColorCorrectionMatrix22");
		return val;
	}

	float xiAPIplus_Camera::GetColorCorrectionMatrix22_Maximum()
	{
		float val=0;
		
		CheckCamHandle("GetColorCorrectionMatrix22" "_Maximum");
		
		XI_RETURN res=xiGetParamFloat(camera_handle, XI_PRM_CC_MATRIX_22 XI_PRM_INFO_MAX, &val);
		CheckResult(res,"GetColorCorrectionMatrix22" "_Maximum");
		return val;
	}

	float xiAPIplus_Camera::GetColorCorrectionMatrix22_Minimum()
	{
		float val=0;
		
		CheckCamHandle("GetColorCorrectionMatrix22" "_Minimum");
		
		XI_RETURN res=xiGetParamFloat(camera_handle, XI_PRM_CC_MATRIX_22 XI_PRM_INFO_MIN, &val);
		CheckResult(res,"GetColorCorrectionMatrix22" "_Minimum");
		return val;
	}

	float xiAPIplus_Camera::GetColorCorrectionMatrix22_Increment()
	{
		float val=0;
		
		CheckCamHandle("GetColorCorrectionMatrix22" "_Increment");
		
		XI_RETURN res=xiGetParamFloat(camera_handle, XI_PRM_CC_MATRIX_22 XI_PRM_INFO_INCREMENT, &val);
		CheckResult(res,"GetColorCorrectionMatrix22" "_Increment");
		return val;
	}
	
	void xiAPIplus_Camera::SetColorCorrectionMatrix22(float ColorCorrectionMatrix22)
	{
		
		CheckCamHandle("SetColorCorrectionMatrix22");
		
		XI_RETURN res=xiSetParamFloat(camera_handle, XI_PRM_CC_MATRIX_22, ColorCorrectionMatrix22);
		CheckResult(res,"SetColorCorrectionMatrix22");
	}
	 
	
	// Color Correction Matrix element [2][3] (XI_PRM_CC_MATRIX_23)
	float xiAPIplus_Camera::GetColorCorrectionMatrix23()
	{
		float val=0;
		
		CheckCamHandle("GetColorCorrectionMatrix23");
		
		XI_RETURN res=xiGetParamFloat(camera_handle, XI_PRM_CC_MATRIX_23, &val);
		CheckResult(res,"GetColorCorrectionMatrix23");
		return val;
	}

	float xiAPIplus_Camera::GetColorCorrectionMatrix23_Maximum()
	{
		float val=0;
		
		CheckCamHandle("GetColorCorrectionMatrix23" "_Maximum");
		
		XI_RETURN res=xiGetParamFloat(camera_handle, XI_PRM_CC_MATRIX_23 XI_PRM_INFO_MAX, &val);
		CheckResult(res,"GetColorCorrectionMatrix23" "_Maximum");
		return val;
	}

	float xiAPIplus_Camera::GetColorCorrectionMatrix23_Minimum()
	{
		float val=0;
		
		CheckCamHandle("GetColorCorrectionMatrix23" "_Minimum");
		
		XI_RETURN res=xiGetParamFloat(camera_handle, XI_PRM_CC_MATRIX_23 XI_PRM_INFO_MIN, &val);
		CheckResult(res,"GetColorCorrectionMatrix23" "_Minimum");
		return val;
	}

	float xiAPIplus_Camera::GetColorCorrectionMatrix23_Increment()
	{
		float val=0;
		
		CheckCamHandle("GetColorCorrectionMatrix23" "_Increment");
		
		XI_RETURN res=xiGetParamFloat(camera_handle, XI_PRM_CC_MATRIX_23 XI_PRM_INFO_INCREMENT, &val);
		CheckResult(res,"GetColorCorrectionMatrix23" "_Increment");
		return val;
	}
	
	void xiAPIplus_Camera::SetColorCorrectionMatrix23(float ColorCorrectionMatrix23)
	{
		
		CheckCamHandle("SetColorCorrectionMatrix23");
		
		XI_RETURN res=xiSetParamFloat(camera_handle, XI_PRM_CC_MATRIX_23, ColorCorrectionMatrix23);
		CheckResult(res,"SetColorCorrectionMatrix23");
	}
	 
	
	// Color Correction Matrix element [3][0] (XI_PRM_CC_MATRIX_30)
	float xiAPIplus_Camera::GetColorCorrectionMatrix30()
	{
		float val=0;
		
		CheckCamHandle("GetColorCorrectionMatrix30");
		
		XI_RETURN res=xiGetParamFloat(camera_handle, XI_PRM_CC_MATRIX_30, &val);
		CheckResult(res,"GetColorCorrectionMatrix30");
		return val;
	}

	float xiAPIplus_Camera::GetColorCorrectionMatrix30_Maximum()
	{
		float val=0;
		
		CheckCamHandle("GetColorCorrectionMatrix30" "_Maximum");
		
		XI_RETURN res=xiGetParamFloat(camera_handle, XI_PRM_CC_MATRIX_30 XI_PRM_INFO_MAX, &val);
		CheckResult(res,"GetColorCorrectionMatrix30" "_Maximum");
		return val;
	}

	float xiAPIplus_Camera::GetColorCorrectionMatrix30_Minimum()
	{
		float val=0;
		
		CheckCamHandle("GetColorCorrectionMatrix30" "_Minimum");
		
		XI_RETURN res=xiGetParamFloat(camera_handle, XI_PRM_CC_MATRIX_30 XI_PRM_INFO_MIN, &val);
		CheckResult(res,"GetColorCorrectionMatrix30" "_Minimum");
		return val;
	}

	float xiAPIplus_Camera::GetColorCorrectionMatrix30_Increment()
	{
		float val=0;
		
		CheckCamHandle("GetColorCorrectionMatrix30" "_Increment");
		
		XI_RETURN res=xiGetParamFloat(camera_handle, XI_PRM_CC_MATRIX_30 XI_PRM_INFO_INCREMENT, &val);
		CheckResult(res,"GetColorCorrectionMatrix30" "_Increment");
		return val;
	}
	
	void xiAPIplus_Camera::SetColorCorrectionMatrix30(float ColorCorrectionMatrix30)
	{
		
		CheckCamHandle("SetColorCorrectionMatrix30");
		
		XI_RETURN res=xiSetParamFloat(camera_handle, XI_PRM_CC_MATRIX_30, ColorCorrectionMatrix30);
		CheckResult(res,"SetColorCorrectionMatrix30");
	}
	 
	
	// Color Correction Matrix element [3][1] (XI_PRM_CC_MATRIX_31)
	float xiAPIplus_Camera::GetColorCorrectionMatrix31()
	{
		float val=0;
		
		CheckCamHandle("GetColorCorrectionMatrix31");
		
		XI_RETURN res=xiGetParamFloat(camera_handle, XI_PRM_CC_MATRIX_31, &val);
		CheckResult(res,"GetColorCorrectionMatrix31");
		return val;
	}

	float xiAPIplus_Camera::GetColorCorrectionMatrix31_Maximum()
	{
		float val=0;
		
		CheckCamHandle("GetColorCorrectionMatrix31" "_Maximum");
		
		XI_RETURN res=xiGetParamFloat(camera_handle, XI_PRM_CC_MATRIX_31 XI_PRM_INFO_MAX, &val);
		CheckResult(res,"GetColorCorrectionMatrix31" "_Maximum");
		return val;
	}

	float xiAPIplus_Camera::GetColorCorrectionMatrix31_Minimum()
	{
		float val=0;
		
		CheckCamHandle("GetColorCorrectionMatrix31" "_Minimum");
		
		XI_RETURN res=xiGetParamFloat(camera_handle, XI_PRM_CC_MATRIX_31 XI_PRM_INFO_MIN, &val);
		CheckResult(res,"GetColorCorrectionMatrix31" "_Minimum");
		return val;
	}

	float xiAPIplus_Camera::GetColorCorrectionMatrix31_Increment()
	{
		float val=0;
		
		CheckCamHandle("GetColorCorrectionMatrix31" "_Increment");
		
		XI_RETURN res=xiGetParamFloat(camera_handle, XI_PRM_CC_MATRIX_31 XI_PRM_INFO_INCREMENT, &val);
		CheckResult(res,"GetColorCorrectionMatrix31" "_Increment");
		return val;
	}
	
	void xiAPIplus_Camera::SetColorCorrectionMatrix31(float ColorCorrectionMatrix31)
	{
		
		CheckCamHandle("SetColorCorrectionMatrix31");
		
		XI_RETURN res=xiSetParamFloat(camera_handle, XI_PRM_CC_MATRIX_31, ColorCorrectionMatrix31);
		CheckResult(res,"SetColorCorrectionMatrix31");
	}
	 
	
	// Color Correction Matrix element [3][2] (XI_PRM_CC_MATRIX_32)
	float xiAPIplus_Camera::GetColorCorrectionMatrix32()
	{
		float val=0;
		
		CheckCamHandle("GetColorCorrectionMatrix32");
		
		XI_RETURN res=xiGetParamFloat(camera_handle, XI_PRM_CC_MATRIX_32, &val);
		CheckResult(res,"GetColorCorrectionMatrix32");
		return val;
	}

	float xiAPIplus_Camera::GetColorCorrectionMatrix32_Maximum()
	{
		float val=0;
		
		CheckCamHandle("GetColorCorrectionMatrix32" "_Maximum");
		
		XI_RETURN res=xiGetParamFloat(camera_handle, XI_PRM_CC_MATRIX_32 XI_PRM_INFO_MAX, &val);
		CheckResult(res,"GetColorCorrectionMatrix32" "_Maximum");
		return val;
	}

	float xiAPIplus_Camera::GetColorCorrectionMatrix32_Minimum()
	{
		float val=0;
		
		CheckCamHandle("GetColorCorrectionMatrix32" "_Minimum");
		
		XI_RETURN res=xiGetParamFloat(camera_handle, XI_PRM_CC_MATRIX_32 XI_PRM_INFO_MIN, &val);
		CheckResult(res,"GetColorCorrectionMatrix32" "_Minimum");
		return val;
	}

	float xiAPIplus_Camera::GetColorCorrectionMatrix32_Increment()
	{
		float val=0;
		
		CheckCamHandle("GetColorCorrectionMatrix32" "_Increment");
		
		XI_RETURN res=xiGetParamFloat(camera_handle, XI_PRM_CC_MATRIX_32 XI_PRM_INFO_INCREMENT, &val);
		CheckResult(res,"GetColorCorrectionMatrix32" "_Increment");
		return val;
	}
	
	void xiAPIplus_Camera::SetColorCorrectionMatrix32(float ColorCorrectionMatrix32)
	{
		
		CheckCamHandle("SetColorCorrectionMatrix32");
		
		XI_RETURN res=xiSetParamFloat(camera_handle, XI_PRM_CC_MATRIX_32, ColorCorrectionMatrix32);
		CheckResult(res,"SetColorCorrectionMatrix32");
	}
	 
	
	// Color Correction Matrix element [3][3] (XI_PRM_CC_MATRIX_33)
	float xiAPIplus_Camera::GetColorCorrectionMatrix33()
	{
		float val=0;
		
		CheckCamHandle("GetColorCorrectionMatrix33");
		
		XI_RETURN res=xiGetParamFloat(camera_handle, XI_PRM_CC_MATRIX_33, &val);
		CheckResult(res,"GetColorCorrectionMatrix33");
		return val;
	}

	float xiAPIplus_Camera::GetColorCorrectionMatrix33_Maximum()
	{
		float val=0;
		
		CheckCamHandle("GetColorCorrectionMatrix33" "_Maximum");
		
		XI_RETURN res=xiGetParamFloat(camera_handle, XI_PRM_CC_MATRIX_33 XI_PRM_INFO_MAX, &val);
		CheckResult(res,"GetColorCorrectionMatrix33" "_Maximum");
		return val;
	}

	float xiAPIplus_Camera::GetColorCorrectionMatrix33_Minimum()
	{
		float val=0;
		
		CheckCamHandle("GetColorCorrectionMatrix33" "_Minimum");
		
		XI_RETURN res=xiGetParamFloat(camera_handle, XI_PRM_CC_MATRIX_33 XI_PRM_INFO_MIN, &val);
		CheckResult(res,"GetColorCorrectionMatrix33" "_Minimum");
		return val;
	}

	float xiAPIplus_Camera::GetColorCorrectionMatrix33_Increment()
	{
		float val=0;
		
		CheckCamHandle("GetColorCorrectionMatrix33" "_Increment");
		
		XI_RETURN res=xiGetParamFloat(camera_handle, XI_PRM_CC_MATRIX_33 XI_PRM_INFO_INCREMENT, &val);
		CheckResult(res,"GetColorCorrectionMatrix33" "_Increment");
		return val;
	}
	
	void xiAPIplus_Camera::SetColorCorrectionMatrix33(float ColorCorrectionMatrix33)
	{
		
		CheckCamHandle("SetColorCorrectionMatrix33");
		
		XI_RETURN res=xiSetParamFloat(camera_handle, XI_PRM_CC_MATRIX_33, ColorCorrectionMatrix33);
		CheckResult(res,"SetColorCorrectionMatrix33");
	}
	 
	
	// Set default Color Correction Matrix (XI_PRM_DEFAULT_CC_MATRIX)
	void xiAPIplus_Camera::SetColorCorrectionMatrixDefault(int ColorCorrectionMatrixDefault)
	{
		
		CheckCamHandleInt("SetColorCorrectionMatrixDefault",ColorCorrectionMatrixDefault);
		
		XI_RETURN res=xiSetParamInt(camera_handle, XI_PRM_DEFAULT_CC_MATRIX, ColorCorrectionMatrixDefault);
		CheckResult(res,"SetColorCorrectionMatrixDefault");
	}
	 
	
	// Normalize color correction matrix (XI_PRM_CC_MATRIX_NORM)
	bool xiAPIplus_Camera::IsColorCorrectionMatrixNorm()
	{
		int val=0;
		
		CheckCamHandle("IsColorCorrectionMatrixNorm");
		
		xiGetParamInt(camera_handle, XI_PRM_CC_MATRIX_NORM, &val);
		return (val!=0);
	}
	
	void xiAPIplus_Camera::EnableColorCorrectionMatrixNorm()
	{
		
		CheckCamHandle("IsColorCorrectionMatrixNorm");
		
		XI_RETURN res=xiSetParamInt(camera_handle, XI_PRM_CC_MATRIX_NORM, XI_ON);
		CheckResult(res,"EnableColorCorrectionMatrixNorm");
	}

	void xiAPIplus_Camera::DisableColorCorrectionMatrixNorm()
	{
		
		CheckCamHandle("DisableColorCorrectionMatrixNorm");
		
		XI_RETURN res=xiSetParamInt(camera_handle, XI_PRM_CC_MATRIX_NORM, XI_OFF);
		CheckResult(res,"DisableColorCorrectionMatrixNorm");
	}	
	

	//-------------------------------------------------------------------------------------------------------------------
	// ---- Parameter Group: Device IO
	//-------------------------------------------------------------------------------------------------------------------

	 
	
	// Defines source of trigger. (XI_PRM_TRG_SOURCE)
	XI_TRG_SOURCE xiAPIplus_Camera::GetTriggerSource()
	{
		int val=0;
		
		CheckCamHandle("GetTriggerSource");
		
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_TRG_SOURCE, &val);
		CheckResult(res,"GetTriggerSource");
		return (XI_TRG_SOURCE)val;
	}
	
	XI_TRG_SOURCE xiAPIplus_Camera::GetTriggerSource_Maximum()
	{
		int val=0;
		
		CheckCamHandle("GetTriggerSource" "_Maximum");
		
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_TRG_SOURCE XI_PRM_INFO_MAX, &val);
		CheckResult(res,"GetTriggerSource" "_Maximum");
		return (XI_TRG_SOURCE)val;
	}
	
	XI_TRG_SOURCE xiAPIplus_Camera::GetTriggerSource_Minimum()
	{
		int val=0;
		
		CheckCamHandle("GetTriggerSource" "_Minimum");
		
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_TRG_SOURCE XI_PRM_INFO_MIN, &val);
		CheckResult(res,"GetTriggerSource" "_Minimum");
		return (XI_TRG_SOURCE)val;
	}
	
	int xiAPIplus_Camera::GetTriggerSource_Increment()
	{
		int val=0;
		
		CheckCamHandle("GetTriggerSource" "_Increment");
		
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_TRG_SOURCE XI_PRM_INFO_INCREMENT, &val);
		CheckResult(res,"GetTriggerSource" "_Increment");
		return val;
	}
	
	void xiAPIplus_Camera::SetTriggerSource(XI_TRG_SOURCE TriggerSource)
	{
		
		CheckCamHandleInt("SetTriggerSource",(int)TriggerSource);
		
		XI_RETURN res=xiSetParamInt(camera_handle, XI_PRM_TRG_SOURCE, TriggerSource);
		CheckResult(res,"SetTriggerSource");
	}
	 
	
	// Generates an internal trigger. XI_PRM_TRG_SOURCE must be set to TRG_SOFTWARE. (XI_PRM_TRG_SOFTWARE)
	void xiAPIplus_Camera::SetTriggerSoftware(int TriggerSoftware)
	{
		
		CheckCamHandleInt("SetTriggerSoftware",TriggerSoftware);
		
		XI_RETURN res=xiSetParamInt(camera_handle, XI_PRM_TRG_SOFTWARE, TriggerSoftware);
		CheckResult(res,"SetTriggerSoftware");
	}
	 
	
	// Selects the type of trigger. (XI_PRM_TRG_SELECTOR)
	XI_TRG_SELECTOR xiAPIplus_Camera::GetTriggerSelector()
	{
		int val=0;
		
		CheckCamHandle("GetTriggerSelector");
		
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_TRG_SELECTOR, &val);
		CheckResult(res,"GetTriggerSelector");
		return (XI_TRG_SELECTOR)val;
	}
	
	XI_TRG_SELECTOR xiAPIplus_Camera::GetTriggerSelector_Maximum()
	{
		int val=0;
		
		CheckCamHandle("GetTriggerSelector" "_Maximum");
		
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_TRG_SELECTOR XI_PRM_INFO_MAX, &val);
		CheckResult(res,"GetTriggerSelector" "_Maximum");
		return (XI_TRG_SELECTOR)val;
	}
	
	XI_TRG_SELECTOR xiAPIplus_Camera::GetTriggerSelector_Minimum()
	{
		int val=0;
		
		CheckCamHandle("GetTriggerSelector" "_Minimum");
		
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_TRG_SELECTOR XI_PRM_INFO_MIN, &val);
		CheckResult(res,"GetTriggerSelector" "_Minimum");
		return (XI_TRG_SELECTOR)val;
	}
	
	int xiAPIplus_Camera::GetTriggerSelector_Increment()
	{
		int val=0;
		
		CheckCamHandle("GetTriggerSelector" "_Increment");
		
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_TRG_SELECTOR XI_PRM_INFO_INCREMENT, &val);
		CheckResult(res,"GetTriggerSelector" "_Increment");
		return val;
	}
	
	void xiAPIplus_Camera::SetTriggerSelector(XI_TRG_SELECTOR TriggerSelector)
	{
		
		CheckCamHandleInt("SetTriggerSelector",(int)TriggerSelector);
		
		XI_RETURN res=xiSetParamInt(camera_handle, XI_PRM_TRG_SELECTOR, TriggerSelector);
		CheckResult(res,"SetTriggerSelector");
	}
	 
	
	// The mode of Trigger Overlap. This influences of trigger acception/rejection policy (XI_PRM_TRG_OVERLAP)
	XI_TRG_OVERLAP xiAPIplus_Camera::GetTriggerOverlap()
	{
		int val=0;
		
		CheckCamHandle("GetTriggerOverlap");
		
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_TRG_OVERLAP, &val);
		CheckResult(res,"GetTriggerOverlap");
		return (XI_TRG_OVERLAP)val;
	}
	
	XI_TRG_OVERLAP xiAPIplus_Camera::GetTriggerOverlap_Maximum()
	{
		int val=0;
		
		CheckCamHandle("GetTriggerOverlap" "_Maximum");
		
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_TRG_OVERLAP XI_PRM_INFO_MAX, &val);
		CheckResult(res,"GetTriggerOverlap" "_Maximum");
		return (XI_TRG_OVERLAP)val;
	}
	
	XI_TRG_OVERLAP xiAPIplus_Camera::GetTriggerOverlap_Minimum()
	{
		int val=0;
		
		CheckCamHandle("GetTriggerOverlap" "_Minimum");
		
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_TRG_OVERLAP XI_PRM_INFO_MIN, &val);
		CheckResult(res,"GetTriggerOverlap" "_Minimum");
		return (XI_TRG_OVERLAP)val;
	}
	
	int xiAPIplus_Camera::GetTriggerOverlap_Increment()
	{
		int val=0;
		
		CheckCamHandle("GetTriggerOverlap" "_Increment");
		
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_TRG_OVERLAP XI_PRM_INFO_INCREMENT, &val);
		CheckResult(res,"GetTriggerOverlap" "_Increment");
		return val;
	}
	
	void xiAPIplus_Camera::SetTriggerOverlap(XI_TRG_OVERLAP TriggerOverlap)
	{
		
		CheckCamHandleInt("SetTriggerOverlap",(int)TriggerOverlap);
		
		XI_RETURN res=xiSetParamInt(camera_handle, XI_PRM_TRG_OVERLAP, TriggerOverlap);
		CheckResult(res,"SetTriggerOverlap");
	}
	 
	
	// Sets number of frames acquired by burst. This burst is used only if trigger is set to FrameBurstStart (XI_PRM_ACQ_FRAME_BURST_COUNT)
	// integer type
	int xiAPIplus_Camera::GetAcquisitionFrameBurstCount()
	{
		CheckCamHandle("GetAcquisitionFrameBurstCount");
		int val=0;
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_ACQ_FRAME_BURST_COUNT, &val);
		CheckResult(res,"GetAcquisitionFrameBurstCount");
		return val;	
	}
	int xiAPIplus_Camera::GetAcquisitionFrameBurstCount_Maximum()
	{		
		CheckCamHandle("GetAcquisitionFrameBurstCount" "_Maximum");
		int val=0;
		CheckCamHandle("GetAcquisitionFrameBurstCount");
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_ACQ_FRAME_BURST_COUNT XI_PRM_INFO_MAX, &val);
		CheckResult(res,"GetAcquisitionFrameBurstCount" "_Maximum");
		return val;
	}
	
	int xiAPIplus_Camera::GetAcquisitionFrameBurstCount_Minimum()
	{
		CheckCamHandle("GetAcquisitionFrameBurstCount" "_Minimum");
		int val=0;
		CheckCamHandle("GetAcquisitionFrameBurstCount");
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_ACQ_FRAME_BURST_COUNT XI_PRM_INFO_MIN, &val);
		CheckResult(res,"GetAcquisitionFrameBurstCount" "_Minimum");
		return val;
	}

	int xiAPIplus_Camera::GetAcquisitionFrameBurstCount_Increment()
	{
		CheckCamHandle("GetAcquisitionFrameBurstCount" "_Increment");
		int val=0;
		CheckCamHandle("GetAcquisitionFrameBurstCount");
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_ACQ_FRAME_BURST_COUNT XI_PRM_INFO_INCREMENT, &val);
		CheckResult(res,"GetAcquisitionFrameBurstCount" "_Increment");
		return val;		
	}
	
	void xiAPIplus_Camera::SetAcquisitionFrameBurstCount(int AcquisitionFrameBurstCount)
	{
		
		CheckCamHandleInt("SetAcquisitionFrameBurstCount",AcquisitionFrameBurstCount);
		
		XI_RETURN res=xiSetParamInt(camera_handle, XI_PRM_ACQ_FRAME_BURST_COUNT, AcquisitionFrameBurstCount);
		CheckResult(res,"SetAcquisitionFrameBurstCount");
	}
	 
	
	// Current value of the device timestamp counter (XI_PRM_TIMESTAMP)
	// integer type
	uint64_t xiAPIplus_Camera::GetTimestamp()
	{
		CheckCamHandle("GetTimestamp");
		uint64_t val=0;
		DWORD size = sizeof(val);
		XI_PRM_TYPE type = xiTypeInteger64;		
		XI_RETURN res=xiGetParam(camera_handle, XI_PRM_TIMESTAMP, &val, &size, &type);
		CheckResult(res,"GetTimestamp");
		return val;	
	}
	uint64_t xiAPIplus_Camera::GetTimestamp_Maximum()
	{		
		CheckCamHandle("GetTimestamp" "_Maximum");
		uint64_t val=0;
		DWORD size = sizeof(val);
		XI_PRM_TYPE type = xiTypeInteger64;
		XI_RETURN res=xiGetParam(camera_handle, XI_PRM_TIMESTAMP XI_PRM_INFO_MAX, &val, &size, &type);
		CheckResult(res,"GetTimestamp" "_Maximum");
		return val;
	}
	
	uint64_t xiAPIplus_Camera::GetTimestamp_Minimum()
	{
		CheckCamHandle("GetTimestamp" "_Minimum");
		uint64_t val=0;
		DWORD size = sizeof(val);
		XI_PRM_TYPE type = xiTypeInteger64;
		XI_RETURN res=xiGetParam(camera_handle, XI_PRM_TIMESTAMP XI_PRM_INFO_MIN, &val, &size, &type);
		CheckResult(res,"GetTimestamp" "_Minimum");
		return val;
	}

	uint64_t xiAPIplus_Camera::GetTimestamp_Increment()
	{
		CheckCamHandle("GetTimestamp" "_Increment");
		uint64_t val=0;
		DWORD size = sizeof(val);
		XI_PRM_TYPE type = xiTypeInteger64;
		XI_RETURN res=xiGetParam(camera_handle, XI_PRM_TIMESTAMP XI_PRM_INFO_INCREMENT, &val, &size, &type);
		CheckResult(res,"GetTimestamp" "_Increment");
		return val;		
	}
	

	//-------------------------------------------------------------------------------------------------------------------
	// ---- Parameter Group: GPIO Setup
	//-------------------------------------------------------------------------------------------------------------------

	 
	
	// Selects GPI (XI_PRM_GPI_SELECTOR)
	XI_GPI_SELECTOR xiAPIplus_Camera::GetGPISelector()
	{
		int val=0;
		
		CheckCamHandle("GetGPISelector");
		
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_GPI_SELECTOR, &val);
		CheckResult(res,"GetGPISelector");
		return (XI_GPI_SELECTOR)val;
	}
	
	XI_GPI_SELECTOR xiAPIplus_Camera::GetGPISelector_Maximum()
	{
		int val=0;
		
		CheckCamHandle("GetGPISelector" "_Maximum");
		
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_GPI_SELECTOR XI_PRM_INFO_MAX, &val);
		CheckResult(res,"GetGPISelector" "_Maximum");
		return (XI_GPI_SELECTOR)val;
	}
	
	XI_GPI_SELECTOR xiAPIplus_Camera::GetGPISelector_Minimum()
	{
		int val=0;
		
		CheckCamHandle("GetGPISelector" "_Minimum");
		
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_GPI_SELECTOR XI_PRM_INFO_MIN, &val);
		CheckResult(res,"GetGPISelector" "_Minimum");
		return (XI_GPI_SELECTOR)val;
	}
	
	int xiAPIplus_Camera::GetGPISelector_Increment()
	{
		int val=0;
		
		CheckCamHandle("GetGPISelector" "_Increment");
		
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_GPI_SELECTOR XI_PRM_INFO_INCREMENT, &val);
		CheckResult(res,"GetGPISelector" "_Increment");
		return val;
	}
	
	void xiAPIplus_Camera::SetGPISelector(XI_GPI_SELECTOR GPISelector)
	{
		
		CheckCamHandleInt("SetGPISelector",(int)GPISelector);
		
		XI_RETURN res=xiSetParamInt(camera_handle, XI_PRM_GPI_SELECTOR, GPISelector);
		CheckResult(res,"SetGPISelector");
	}
	 
	
	// Defines GPI functionality (XI_PRM_GPI_MODE)
	XI_GPI_MODE xiAPIplus_Camera::GetGPIMode()
	{
		int val=0;
		
		CheckCamHandle("GetGPIMode");
		
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_GPI_MODE, &val);
		CheckResult(res,"GetGPIMode");
		return (XI_GPI_MODE)val;
	}
	
	XI_GPI_MODE xiAPIplus_Camera::GetGPIMode_Maximum()
	{
		int val=0;
		
		CheckCamHandle("GetGPIMode" "_Maximum");
		
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_GPI_MODE XI_PRM_INFO_MAX, &val);
		CheckResult(res,"GetGPIMode" "_Maximum");
		return (XI_GPI_MODE)val;
	}
	
	XI_GPI_MODE xiAPIplus_Camera::GetGPIMode_Minimum()
	{
		int val=0;
		
		CheckCamHandle("GetGPIMode" "_Minimum");
		
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_GPI_MODE XI_PRM_INFO_MIN, &val);
		CheckResult(res,"GetGPIMode" "_Minimum");
		return (XI_GPI_MODE)val;
	}
	
	int xiAPIplus_Camera::GetGPIMode_Increment()
	{
		int val=0;
		
		CheckCamHandle("GetGPIMode" "_Increment");
		
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_GPI_MODE XI_PRM_INFO_INCREMENT, &val);
		CheckResult(res,"GetGPIMode" "_Increment");
		return val;
	}
	
	void xiAPIplus_Camera::SetGPIMode(XI_GPI_MODE GPIMode)
	{
		
		CheckCamHandleInt("SetGPIMode",(int)GPIMode);
		
		XI_RETURN res=xiSetParamInt(camera_handle, XI_PRM_GPI_MODE, GPIMode);
		CheckResult(res,"SetGPIMode");
	}
	 
	
	// GPI level (XI_PRM_GPI_LEVEL)
	// integer type
	int xiAPIplus_Camera::GetGPILevel()
	{
		CheckCamHandle("GetGPILevel");
		int val=0;
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_GPI_LEVEL, &val);
		CheckResult(res,"GetGPILevel");
		return val;	
	}
	int xiAPIplus_Camera::GetGPILevel_Maximum()
	{		
		CheckCamHandle("GetGPILevel" "_Maximum");
		int val=0;
		CheckCamHandle("GetGPILevel");
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_GPI_LEVEL XI_PRM_INFO_MAX, &val);
		CheckResult(res,"GetGPILevel" "_Maximum");
		return val;
	}
	
	int xiAPIplus_Camera::GetGPILevel_Minimum()
	{
		CheckCamHandle("GetGPILevel" "_Minimum");
		int val=0;
		CheckCamHandle("GetGPILevel");
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_GPI_LEVEL XI_PRM_INFO_MIN, &val);
		CheckResult(res,"GetGPILevel" "_Minimum");
		return val;
	}

	int xiAPIplus_Camera::GetGPILevel_Increment()
	{
		CheckCamHandle("GetGPILevel" "_Increment");
		int val=0;
		CheckCamHandle("GetGPILevel");
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_GPI_LEVEL XI_PRM_INFO_INCREMENT, &val);
		CheckResult(res,"GetGPILevel" "_Increment");
		return val;		
	}
	 
	
	// GPI Level at image exposure start (XI_PRM_GPI_LEVEL_AT_IMAGE_EXP_START)
	// integer type
	int xiAPIplus_Camera::GetGPILevelAtImageExpStart()
	{
		CheckCamHandle("GetGPILevelAtImageExpStart");
		int val=0;
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_GPI_LEVEL_AT_IMAGE_EXP_START, &val);
		CheckResult(res,"GetGPILevelAtImageExpStart");
		return val;	
	}
	int xiAPIplus_Camera::GetGPILevelAtImageExpStart_Maximum()
	{		
		CheckCamHandle("GetGPILevelAtImageExpStart" "_Maximum");
		int val=0;
		CheckCamHandle("GetGPILevelAtImageExpStart");
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_GPI_LEVEL_AT_IMAGE_EXP_START XI_PRM_INFO_MAX, &val);
		CheckResult(res,"GetGPILevelAtImageExpStart" "_Maximum");
		return val;
	}
	
	int xiAPIplus_Camera::GetGPILevelAtImageExpStart_Minimum()
	{
		CheckCamHandle("GetGPILevelAtImageExpStart" "_Minimum");
		int val=0;
		CheckCamHandle("GetGPILevelAtImageExpStart");
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_GPI_LEVEL_AT_IMAGE_EXP_START XI_PRM_INFO_MIN, &val);
		CheckResult(res,"GetGPILevelAtImageExpStart" "_Minimum");
		return val;
	}

	int xiAPIplus_Camera::GetGPILevelAtImageExpStart_Increment()
	{
		CheckCamHandle("GetGPILevelAtImageExpStart" "_Increment");
		int val=0;
		CheckCamHandle("GetGPILevelAtImageExpStart");
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_GPI_LEVEL_AT_IMAGE_EXP_START XI_PRM_INFO_INCREMENT, &val);
		CheckResult(res,"GetGPILevelAtImageExpStart" "_Increment");
		return val;		
	}
	 
	
	// GPI Level at image exposure end (XI_PRM_GPI_LEVEL_AT_IMAGE_EXP_END)
	// integer type
	int xiAPIplus_Camera::GetGPILevelAtImageExpEnd()
	{
		CheckCamHandle("GetGPILevelAtImageExpEnd");
		int val=0;
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_GPI_LEVEL_AT_IMAGE_EXP_END, &val);
		CheckResult(res,"GetGPILevelAtImageExpEnd");
		return val;	
	}
	int xiAPIplus_Camera::GetGPILevelAtImageExpEnd_Maximum()
	{		
		CheckCamHandle("GetGPILevelAtImageExpEnd" "_Maximum");
		int val=0;
		CheckCamHandle("GetGPILevelAtImageExpEnd");
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_GPI_LEVEL_AT_IMAGE_EXP_END XI_PRM_INFO_MAX, &val);
		CheckResult(res,"GetGPILevelAtImageExpEnd" "_Maximum");
		return val;
	}
	
	int xiAPIplus_Camera::GetGPILevelAtImageExpEnd_Minimum()
	{
		CheckCamHandle("GetGPILevelAtImageExpEnd" "_Minimum");
		int val=0;
		CheckCamHandle("GetGPILevelAtImageExpEnd");
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_GPI_LEVEL_AT_IMAGE_EXP_END XI_PRM_INFO_MIN, &val);
		CheckResult(res,"GetGPILevelAtImageExpEnd" "_Minimum");
		return val;
	}

	int xiAPIplus_Camera::GetGPILevelAtImageExpEnd_Increment()
	{
		CheckCamHandle("GetGPILevelAtImageExpEnd" "_Increment");
		int val=0;
		CheckCamHandle("GetGPILevelAtImageExpEnd");
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_GPI_LEVEL_AT_IMAGE_EXP_END XI_PRM_INFO_INCREMENT, &val);
		CheckResult(res,"GetGPILevelAtImageExpEnd" "_Increment");
		return val;		
	}
	 
	
	// GPI Level at image readout end (XI_PRM_GPI_LEVEL_AT_IMAGE_READOUT_END)
	// integer type
	int xiAPIplus_Camera::GetGPILevelAtImageReadoutEnd()
	{
		CheckCamHandle("GetGPILevelAtImageReadoutEnd");
		int val=0;
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_GPI_LEVEL_AT_IMAGE_READOUT_END, &val);
		CheckResult(res,"GetGPILevelAtImageReadoutEnd");
		return val;	
	}
	int xiAPIplus_Camera::GetGPILevelAtImageReadoutEnd_Maximum()
	{		
		CheckCamHandle("GetGPILevelAtImageReadoutEnd" "_Maximum");
		int val=0;
		CheckCamHandle("GetGPILevelAtImageReadoutEnd");
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_GPI_LEVEL_AT_IMAGE_READOUT_END XI_PRM_INFO_MAX, &val);
		CheckResult(res,"GetGPILevelAtImageReadoutEnd" "_Maximum");
		return val;
	}
	
	int xiAPIplus_Camera::GetGPILevelAtImageReadoutEnd_Minimum()
	{
		CheckCamHandle("GetGPILevelAtImageReadoutEnd" "_Minimum");
		int val=0;
		CheckCamHandle("GetGPILevelAtImageReadoutEnd");
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_GPI_LEVEL_AT_IMAGE_READOUT_END XI_PRM_INFO_MIN, &val);
		CheckResult(res,"GetGPILevelAtImageReadoutEnd" "_Minimum");
		return val;
	}

	int xiAPIplus_Camera::GetGPILevelAtImageReadoutEnd_Increment()
	{
		CheckCamHandle("GetGPILevelAtImageReadoutEnd" "_Increment");
		int val=0;
		CheckCamHandle("GetGPILevelAtImageReadoutEnd");
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_GPI_LEVEL_AT_IMAGE_READOUT_END XI_PRM_INFO_INCREMENT, &val);
		CheckResult(res,"GetGPILevelAtImageReadoutEnd" "_Increment");
		return val;		
	}
	 
	
	// Selects GPO (XI_PRM_GPO_SELECTOR)
	XI_GPO_SELECTOR xiAPIplus_Camera::GetGPOSelector()
	{
		int val=0;
		
		CheckCamHandle("GetGPOSelector");
		
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_GPO_SELECTOR, &val);
		CheckResult(res,"GetGPOSelector");
		return (XI_GPO_SELECTOR)val;
	}
	
	XI_GPO_SELECTOR xiAPIplus_Camera::GetGPOSelector_Maximum()
	{
		int val=0;
		
		CheckCamHandle("GetGPOSelector" "_Maximum");
		
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_GPO_SELECTOR XI_PRM_INFO_MAX, &val);
		CheckResult(res,"GetGPOSelector" "_Maximum");
		return (XI_GPO_SELECTOR)val;
	}
	
	XI_GPO_SELECTOR xiAPIplus_Camera::GetGPOSelector_Minimum()
	{
		int val=0;
		
		CheckCamHandle("GetGPOSelector" "_Minimum");
		
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_GPO_SELECTOR XI_PRM_INFO_MIN, &val);
		CheckResult(res,"GetGPOSelector" "_Minimum");
		return (XI_GPO_SELECTOR)val;
	}
	
	int xiAPIplus_Camera::GetGPOSelector_Increment()
	{
		int val=0;
		
		CheckCamHandle("GetGPOSelector" "_Increment");
		
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_GPO_SELECTOR XI_PRM_INFO_INCREMENT, &val);
		CheckResult(res,"GetGPOSelector" "_Increment");
		return val;
	}
	
	void xiAPIplus_Camera::SetGPOSelector(XI_GPO_SELECTOR GPOSelector)
	{
		
		CheckCamHandleInt("SetGPOSelector",(int)GPOSelector);
		
		XI_RETURN res=xiSetParamInt(camera_handle, XI_PRM_GPO_SELECTOR, GPOSelector);
		CheckResult(res,"SetGPOSelector");
	}
	 
	
	// Defines GPO functionality (XI_PRM_GPO_MODE)
	XI_GPO_MODE xiAPIplus_Camera::GetGPOMode()
	{
		int val=0;
		
		CheckCamHandle("GetGPOMode");
		
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_GPO_MODE, &val);
		CheckResult(res,"GetGPOMode");
		return (XI_GPO_MODE)val;
	}
	
	XI_GPO_MODE xiAPIplus_Camera::GetGPOMode_Maximum()
	{
		int val=0;
		
		CheckCamHandle("GetGPOMode" "_Maximum");
		
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_GPO_MODE XI_PRM_INFO_MAX, &val);
		CheckResult(res,"GetGPOMode" "_Maximum");
		return (XI_GPO_MODE)val;
	}
	
	XI_GPO_MODE xiAPIplus_Camera::GetGPOMode_Minimum()
	{
		int val=0;
		
		CheckCamHandle("GetGPOMode" "_Minimum");
		
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_GPO_MODE XI_PRM_INFO_MIN, &val);
		CheckResult(res,"GetGPOMode" "_Minimum");
		return (XI_GPO_MODE)val;
	}
	
	int xiAPIplus_Camera::GetGPOMode_Increment()
	{
		int val=0;
		
		CheckCamHandle("GetGPOMode" "_Increment");
		
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_GPO_MODE XI_PRM_INFO_INCREMENT, &val);
		CheckResult(res,"GetGPOMode" "_Increment");
		return val;
	}
	
	void xiAPIplus_Camera::SetGPOMode(XI_GPO_MODE GPOMode)
	{
		
		CheckCamHandleInt("SetGPOMode",(int)GPOMode);
		
		XI_RETURN res=xiSetParamInt(camera_handle, XI_PRM_GPO_MODE, GPOMode);
		CheckResult(res,"SetGPOMode");
	}
	 
	
	// Defines metadata sampling mode (XI_PRM_METADATA_SAMPLING_MODE)
	XI_METADATA_SAMPLING_MODE xiAPIplus_Camera::GetMetadataSamplingMode()
	{
		int val=0;
		
		CheckCamHandle("GetMetadataSamplingMode");
		
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_METADATA_SAMPLING_MODE, &val);
		CheckResult(res,"GetMetadataSamplingMode");
		return (XI_METADATA_SAMPLING_MODE)val;
	}
	
	XI_METADATA_SAMPLING_MODE xiAPIplus_Camera::GetMetadataSamplingMode_Maximum()
	{
		int val=0;
		
		CheckCamHandle("GetMetadataSamplingMode" "_Maximum");
		
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_METADATA_SAMPLING_MODE XI_PRM_INFO_MAX, &val);
		CheckResult(res,"GetMetadataSamplingMode" "_Maximum");
		return (XI_METADATA_SAMPLING_MODE)val;
	}
	
	XI_METADATA_SAMPLING_MODE xiAPIplus_Camera::GetMetadataSamplingMode_Minimum()
	{
		int val=0;
		
		CheckCamHandle("GetMetadataSamplingMode" "_Minimum");
		
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_METADATA_SAMPLING_MODE XI_PRM_INFO_MIN, &val);
		CheckResult(res,"GetMetadataSamplingMode" "_Minimum");
		return (XI_METADATA_SAMPLING_MODE)val;
	}
	
	int xiAPIplus_Camera::GetMetadataSamplingMode_Increment()
	{
		int val=0;
		
		CheckCamHandle("GetMetadataSamplingMode" "_Increment");
		
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_METADATA_SAMPLING_MODE XI_PRM_INFO_INCREMENT, &val);
		CheckResult(res,"GetMetadataSamplingMode" "_Increment");
		return val;
	}
	
	void xiAPIplus_Camera::SetMetadataSamplingMode(XI_METADATA_SAMPLING_MODE MetadataSamplingMode)
	{
		
		CheckCamHandleInt("SetMetadataSamplingMode",(int)MetadataSamplingMode);
		
		XI_RETURN res=xiSetParamInt(camera_handle, XI_PRM_METADATA_SAMPLING_MODE, MetadataSamplingMode);
		CheckResult(res,"SetMetadataSamplingMode");
	}
	 
	
	// Selects LED (XI_PRM_LED_SELECTOR)
	XI_LED_SELECTOR xiAPIplus_Camera::GetLEDSelector()
	{
		int val=0;
		
		CheckCamHandle("GetLEDSelector");
		
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_LED_SELECTOR, &val);
		CheckResult(res,"GetLEDSelector");
		return (XI_LED_SELECTOR)val;
	}
	
	XI_LED_SELECTOR xiAPIplus_Camera::GetLEDSelector_Maximum()
	{
		int val=0;
		
		CheckCamHandle("GetLEDSelector" "_Maximum");
		
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_LED_SELECTOR XI_PRM_INFO_MAX, &val);
		CheckResult(res,"GetLEDSelector" "_Maximum");
		return (XI_LED_SELECTOR)val;
	}
	
	XI_LED_SELECTOR xiAPIplus_Camera::GetLEDSelector_Minimum()
	{
		int val=0;
		
		CheckCamHandle("GetLEDSelector" "_Minimum");
		
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_LED_SELECTOR XI_PRM_INFO_MIN, &val);
		CheckResult(res,"GetLEDSelector" "_Minimum");
		return (XI_LED_SELECTOR)val;
	}
	
	int xiAPIplus_Camera::GetLEDSelector_Increment()
	{
		int val=0;
		
		CheckCamHandle("GetLEDSelector" "_Increment");
		
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_LED_SELECTOR XI_PRM_INFO_INCREMENT, &val);
		CheckResult(res,"GetLEDSelector" "_Increment");
		return val;
	}
	
	void xiAPIplus_Camera::SetLEDSelector(XI_LED_SELECTOR LEDSelector)
	{
		
		CheckCamHandleInt("SetLEDSelector",(int)LEDSelector);
		
		XI_RETURN res=xiSetParamInt(camera_handle, XI_PRM_LED_SELECTOR, LEDSelector);
		CheckResult(res,"SetLEDSelector");
	}
	 
	
	// Defines LED functionality (XI_PRM_LED_MODE)
	XI_LED_MODE xiAPIplus_Camera::GetLEDMode()
	{
		int val=0;
		
		CheckCamHandle("GetLEDMode");
		
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_LED_MODE, &val);
		CheckResult(res,"GetLEDMode");
		return (XI_LED_MODE)val;
	}
	
	XI_LED_MODE xiAPIplus_Camera::GetLEDMode_Maximum()
	{
		int val=0;
		
		CheckCamHandle("GetLEDMode" "_Maximum");
		
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_LED_MODE XI_PRM_INFO_MAX, &val);
		CheckResult(res,"GetLEDMode" "_Maximum");
		return (XI_LED_MODE)val;
	}
	
	XI_LED_MODE xiAPIplus_Camera::GetLEDMode_Minimum()
	{
		int val=0;
		
		CheckCamHandle("GetLEDMode" "_Minimum");
		
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_LED_MODE XI_PRM_INFO_MIN, &val);
		CheckResult(res,"GetLEDMode" "_Minimum");
		return (XI_LED_MODE)val;
	}
	
	int xiAPIplus_Camera::GetLEDMode_Increment()
	{
		int val=0;
		
		CheckCamHandle("GetLEDMode" "_Increment");
		
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_LED_MODE XI_PRM_INFO_INCREMENT, &val);
		CheckResult(res,"GetLEDMode" "_Increment");
		return val;
	}
	
	void xiAPIplus_Camera::SetLEDMode(XI_LED_MODE LEDMode)
	{
		
		CheckCamHandleInt("SetLEDMode",(int)LEDMode);
		
		XI_RETURN res=xiSetParamInt(camera_handle, XI_PRM_LED_MODE, LEDMode);
		CheckResult(res,"SetLEDMode");
	}
	 
	
	// Enable/Disable debounce to selected GPI (XI_PRM_DEBOUNCE_EN)
	bool xiAPIplus_Camera::IsGPIDebounce()
	{
		int val=0;
		
		CheckCamHandle("IsGPIDebounce");
		
		xiGetParamInt(camera_handle, XI_PRM_DEBOUNCE_EN, &val);
		return (val!=0);
	}
	
	void xiAPIplus_Camera::EnableGPIDebounce()
	{
		
		CheckCamHandle("IsGPIDebounce");
		
		XI_RETURN res=xiSetParamInt(camera_handle, XI_PRM_DEBOUNCE_EN, XI_ON);
		CheckResult(res,"EnableGPIDebounce");
	}

	void xiAPIplus_Camera::DisableGPIDebounce()
	{
		
		CheckCamHandle("DisableGPIDebounce");
		
		XI_RETURN res=xiSetParamInt(camera_handle, XI_PRM_DEBOUNCE_EN, XI_OFF);
		CheckResult(res,"DisableGPIDebounce");
	}	
	

	//-------------------------------------------------------------------------------------------------------------------
	// ---- Parameter Group: Debounce Setup
	//-------------------------------------------------------------------------------------------------------------------

	 
	
	// Debounce time (x * 10us) (XI_PRM_DEBOUNCE_T0)
	// integer type
	int xiAPIplus_Camera::GetGPIDebounceFallingEdge()
	{
		CheckCamHandle("GetGPIDebounceFallingEdge");
		int val=0;
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_DEBOUNCE_T0, &val);
		CheckResult(res,"GetGPIDebounceFallingEdge");
		return val;	
	}
	int xiAPIplus_Camera::GetGPIDebounceFallingEdge_Maximum()
	{		
		CheckCamHandle("GetGPIDebounceFallingEdge" "_Maximum");
		int val=0;
		CheckCamHandle("GetGPIDebounceFallingEdge");
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_DEBOUNCE_T0 XI_PRM_INFO_MAX, &val);
		CheckResult(res,"GetGPIDebounceFallingEdge" "_Maximum");
		return val;
	}
	
	int xiAPIplus_Camera::GetGPIDebounceFallingEdge_Minimum()
	{
		CheckCamHandle("GetGPIDebounceFallingEdge" "_Minimum");
		int val=0;
		CheckCamHandle("GetGPIDebounceFallingEdge");
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_DEBOUNCE_T0 XI_PRM_INFO_MIN, &val);
		CheckResult(res,"GetGPIDebounceFallingEdge" "_Minimum");
		return val;
	}

	int xiAPIplus_Camera::GetGPIDebounceFallingEdge_Increment()
	{
		CheckCamHandle("GetGPIDebounceFallingEdge" "_Increment");
		int val=0;
		CheckCamHandle("GetGPIDebounceFallingEdge");
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_DEBOUNCE_T0 XI_PRM_INFO_INCREMENT, &val);
		CheckResult(res,"GetGPIDebounceFallingEdge" "_Increment");
		return val;		
	}
	
	void xiAPIplus_Camera::SetGPIDebounceFallingEdge(int GPIDebounceFallingEdge)
	{
		
		CheckCamHandleInt("SetGPIDebounceFallingEdge",GPIDebounceFallingEdge);
		
		XI_RETURN res=xiSetParamInt(camera_handle, XI_PRM_DEBOUNCE_T0, GPIDebounceFallingEdge);
		CheckResult(res,"SetGPIDebounceFallingEdge");
	}
	 
	
	// Debounce time (x * 10us) (XI_PRM_DEBOUNCE_T1)
	// integer type
	int xiAPIplus_Camera::GetGPIDebounceRisingEdge()
	{
		CheckCamHandle("GetGPIDebounceRisingEdge");
		int val=0;
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_DEBOUNCE_T1, &val);
		CheckResult(res,"GetGPIDebounceRisingEdge");
		return val;	
	}
	int xiAPIplus_Camera::GetGPIDebounceRisingEdge_Maximum()
	{		
		CheckCamHandle("GetGPIDebounceRisingEdge" "_Maximum");
		int val=0;
		CheckCamHandle("GetGPIDebounceRisingEdge");
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_DEBOUNCE_T1 XI_PRM_INFO_MAX, &val);
		CheckResult(res,"GetGPIDebounceRisingEdge" "_Maximum");
		return val;
	}
	
	int xiAPIplus_Camera::GetGPIDebounceRisingEdge_Minimum()
	{
		CheckCamHandle("GetGPIDebounceRisingEdge" "_Minimum");
		int val=0;
		CheckCamHandle("GetGPIDebounceRisingEdge");
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_DEBOUNCE_T1 XI_PRM_INFO_MIN, &val);
		CheckResult(res,"GetGPIDebounceRisingEdge" "_Minimum");
		return val;
	}

	int xiAPIplus_Camera::GetGPIDebounceRisingEdge_Increment()
	{
		CheckCamHandle("GetGPIDebounceRisingEdge" "_Increment");
		int val=0;
		CheckCamHandle("GetGPIDebounceRisingEdge");
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_DEBOUNCE_T1 XI_PRM_INFO_INCREMENT, &val);
		CheckResult(res,"GetGPIDebounceRisingEdge" "_Increment");
		return val;		
	}
	
	void xiAPIplus_Camera::SetGPIDebounceRisingEdge(int GPIDebounceRisingEdge)
	{
		
		CheckCamHandleInt("SetGPIDebounceRisingEdge",GPIDebounceRisingEdge);
		
		XI_RETURN res=xiSetParamInt(camera_handle, XI_PRM_DEBOUNCE_T1, GPIDebounceRisingEdge);
		CheckResult(res,"SetGPIDebounceRisingEdge");
	}
	 
	
	// Debounce polarity (pol = 1 t0 - falling edge, t1 - rising edge) (XI_PRM_DEBOUNCE_POL)
	// integer type
	int xiAPIplus_Camera::GetGPIDebouncePolarity()
	{
		CheckCamHandle("GetGPIDebouncePolarity");
		int val=0;
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_DEBOUNCE_POL, &val);
		CheckResult(res,"GetGPIDebouncePolarity");
		return val;	
	}
	int xiAPIplus_Camera::GetGPIDebouncePolarity_Maximum()
	{		
		CheckCamHandle("GetGPIDebouncePolarity" "_Maximum");
		int val=0;
		CheckCamHandle("GetGPIDebouncePolarity");
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_DEBOUNCE_POL XI_PRM_INFO_MAX, &val);
		CheckResult(res,"GetGPIDebouncePolarity" "_Maximum");
		return val;
	}
	
	int xiAPIplus_Camera::GetGPIDebouncePolarity_Minimum()
	{
		CheckCamHandle("GetGPIDebouncePolarity" "_Minimum");
		int val=0;
		CheckCamHandle("GetGPIDebouncePolarity");
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_DEBOUNCE_POL XI_PRM_INFO_MIN, &val);
		CheckResult(res,"GetGPIDebouncePolarity" "_Minimum");
		return val;
	}

	int xiAPIplus_Camera::GetGPIDebouncePolarity_Increment()
	{
		CheckCamHandle("GetGPIDebouncePolarity" "_Increment");
		int val=0;
		CheckCamHandle("GetGPIDebouncePolarity");
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_DEBOUNCE_POL XI_PRM_INFO_INCREMENT, &val);
		CheckResult(res,"GetGPIDebouncePolarity" "_Increment");
		return val;		
	}
	
	void xiAPIplus_Camera::SetGPIDebouncePolarity(int GPIDebouncePolarity)
	{
		
		CheckCamHandleInt("SetGPIDebouncePolarity",GPIDebouncePolarity);
		
		XI_RETURN res=xiSetParamInt(camera_handle, XI_PRM_DEBOUNCE_POL, GPIDebouncePolarity);
		CheckResult(res,"SetGPIDebouncePolarity");
	}
	

	//-------------------------------------------------------------------------------------------------------------------
	// ---- Parameter Group: Lens Control
	//-------------------------------------------------------------------------------------------------------------------

	 
	
	// Status of lens control interface. This shall be set to XI_ON before any Lens operations. (XI_PRM_LENS_MODE)
	bool xiAPIplus_Camera::IsLensMode()
	{
		int val=0;
		
		CheckCamHandle("IsLensMode");
		
		xiGetParamInt(camera_handle, XI_PRM_LENS_MODE, &val);
		return (val!=0);
	}
	
	void xiAPIplus_Camera::EnableLensMode()
	{
		
		CheckCamHandle("IsLensMode");
		
		XI_RETURN res=xiSetParamInt(camera_handle, XI_PRM_LENS_MODE, XI_ON);
		CheckResult(res,"EnableLensMode");
	}

	void xiAPIplus_Camera::DisableLensMode()
	{
		
		CheckCamHandle("DisableLensMode");
		
		XI_RETURN res=xiSetParamInt(camera_handle, XI_PRM_LENS_MODE, XI_OFF);
		CheckResult(res,"DisableLensMode");
	}	
	 
	
	// Current lens aperture value in stops. Examples: 2.8, 4, 5.6, 8, 11 (XI_PRM_LENS_APERTURE_VALUE)
	float xiAPIplus_Camera::GetLensApertureValue()
	{
		float val=0;
		
		CheckCamHandle("GetLensApertureValue");
		
		XI_RETURN res=xiGetParamFloat(camera_handle, XI_PRM_LENS_APERTURE_VALUE, &val);
		CheckResult(res,"GetLensApertureValue");
		return val;
	}

	float xiAPIplus_Camera::GetLensApertureValue_Maximum()
	{
		float val=0;
		
		CheckCamHandle("GetLensApertureValue" "_Maximum");
		
		XI_RETURN res=xiGetParamFloat(camera_handle, XI_PRM_LENS_APERTURE_VALUE XI_PRM_INFO_MAX, &val);
		CheckResult(res,"GetLensApertureValue" "_Maximum");
		return val;
	}

	float xiAPIplus_Camera::GetLensApertureValue_Minimum()
	{
		float val=0;
		
		CheckCamHandle("GetLensApertureValue" "_Minimum");
		
		XI_RETURN res=xiGetParamFloat(camera_handle, XI_PRM_LENS_APERTURE_VALUE XI_PRM_INFO_MIN, &val);
		CheckResult(res,"GetLensApertureValue" "_Minimum");
		return val;
	}

	float xiAPIplus_Camera::GetLensApertureValue_Increment()
	{
		float val=0;
		
		CheckCamHandle("GetLensApertureValue" "_Increment");
		
		XI_RETURN res=xiGetParamFloat(camera_handle, XI_PRM_LENS_APERTURE_VALUE XI_PRM_INFO_INCREMENT, &val);
		CheckResult(res,"GetLensApertureValue" "_Increment");
		return val;
	}
	
	void xiAPIplus_Camera::SetLensApertureValue(float LensApertureValue)
	{
		
		CheckCamHandle("SetLensApertureValue");
		
		XI_RETURN res=xiSetParamFloat(camera_handle, XI_PRM_LENS_APERTURE_VALUE, LensApertureValue);
		CheckResult(res,"SetLensApertureValue");
	}
	 
	
	// Current aperture index as reported by lens. (XI_PRM_LENS_APERTURE_INDEX)
	// integer type
	int xiAPIplus_Camera::GetLensApertureIndex()
	{
		CheckCamHandle("GetLensApertureIndex");
		int val=0;
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_LENS_APERTURE_INDEX, &val);
		CheckResult(res,"GetLensApertureIndex");
		return val;	
	}
	int xiAPIplus_Camera::GetLensApertureIndex_Maximum()
	{		
		CheckCamHandle("GetLensApertureIndex" "_Maximum");
		int val=0;
		CheckCamHandle("GetLensApertureIndex");
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_LENS_APERTURE_INDEX XI_PRM_INFO_MAX, &val);
		CheckResult(res,"GetLensApertureIndex" "_Maximum");
		return val;
	}
	
	int xiAPIplus_Camera::GetLensApertureIndex_Minimum()
	{
		CheckCamHandle("GetLensApertureIndex" "_Minimum");
		int val=0;
		CheckCamHandle("GetLensApertureIndex");
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_LENS_APERTURE_INDEX XI_PRM_INFO_MIN, &val);
		CheckResult(res,"GetLensApertureIndex" "_Minimum");
		return val;
	}

	int xiAPIplus_Camera::GetLensApertureIndex_Increment()
	{
		CheckCamHandle("GetLensApertureIndex" "_Increment");
		int val=0;
		CheckCamHandle("GetLensApertureIndex");
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_LENS_APERTURE_INDEX XI_PRM_INFO_INCREMENT, &val);
		CheckResult(res,"GetLensApertureIndex" "_Increment");
		return val;		
	}
	
	void xiAPIplus_Camera::SetLensApertureIndex(int LensApertureIndex)
	{
		
		CheckCamHandleInt("SetLensApertureIndex",LensApertureIndex);
		
		XI_RETURN res=xiSetParamInt(camera_handle, XI_PRM_LENS_APERTURE_INDEX, LensApertureIndex);
		CheckResult(res,"SetLensApertureIndex");
	}
	 
	
	// Lens current focus movement value to be used by XI_PRM_LENS_FOCUS_MOVE in motor steps. (XI_PRM_LENS_FOCUS_MOVEMENT_VALUE)
	// integer type
	int xiAPIplus_Camera::GetLensFocusMovementValue()
	{
		CheckCamHandle("GetLensFocusMovementValue");
		int val=0;
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_LENS_FOCUS_MOVEMENT_VALUE, &val);
		CheckResult(res,"GetLensFocusMovementValue");
		return val;	
	}
	int xiAPIplus_Camera::GetLensFocusMovementValue_Maximum()
	{		
		CheckCamHandle("GetLensFocusMovementValue" "_Maximum");
		int val=0;
		CheckCamHandle("GetLensFocusMovementValue");
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_LENS_FOCUS_MOVEMENT_VALUE XI_PRM_INFO_MAX, &val);
		CheckResult(res,"GetLensFocusMovementValue" "_Maximum");
		return val;
	}
	
	int xiAPIplus_Camera::GetLensFocusMovementValue_Minimum()
	{
		CheckCamHandle("GetLensFocusMovementValue" "_Minimum");
		int val=0;
		CheckCamHandle("GetLensFocusMovementValue");
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_LENS_FOCUS_MOVEMENT_VALUE XI_PRM_INFO_MIN, &val);
		CheckResult(res,"GetLensFocusMovementValue" "_Minimum");
		return val;
	}

	int xiAPIplus_Camera::GetLensFocusMovementValue_Increment()
	{
		CheckCamHandle("GetLensFocusMovementValue" "_Increment");
		int val=0;
		CheckCamHandle("GetLensFocusMovementValue");
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_LENS_FOCUS_MOVEMENT_VALUE XI_PRM_INFO_INCREMENT, &val);
		CheckResult(res,"GetLensFocusMovementValue" "_Increment");
		return val;		
	}
	
	void xiAPIplus_Camera::SetLensFocusMovementValue(int LensFocusMovementValue)
	{
		
		CheckCamHandleInt("SetLensFocusMovementValue",LensFocusMovementValue);
		
		XI_RETURN res=xiSetParamInt(camera_handle, XI_PRM_LENS_FOCUS_MOVEMENT_VALUE, LensFocusMovementValue);
		CheckResult(res,"SetLensFocusMovementValue");
	}
	 
	
	// Moves lens focus motor by steps set in XI_PRM_LENS_FOCUS_MOVEMENT_VALUE. (XI_PRM_LENS_FOCUS_MOVE)
	void xiAPIplus_Camera::SetLensFocusMove(int LensFocusMove)
	{
		
		CheckCamHandleInt("SetLensFocusMove",LensFocusMove);
		
		XI_RETURN res=xiSetParamInt(camera_handle, XI_PRM_LENS_FOCUS_MOVE, LensFocusMove);
		CheckResult(res,"SetLensFocusMove");
	}
	 
	
	// Lens focal distance in mm. (XI_PRM_LENS_FOCAL_LENGTH)
	float xiAPIplus_Camera::GetLensFocalLength()
	{
		float val=0;
		
		CheckCamHandle("GetLensFocalLength");
		
		XI_RETURN res=xiGetParamFloat(camera_handle, XI_PRM_LENS_FOCAL_LENGTH, &val);
		CheckResult(res,"GetLensFocalLength");
		return val;
	}

	float xiAPIplus_Camera::GetLensFocalLength_Maximum()
	{
		float val=0;
		
		CheckCamHandle("GetLensFocalLength" "_Maximum");
		
		XI_RETURN res=xiGetParamFloat(camera_handle, XI_PRM_LENS_FOCAL_LENGTH XI_PRM_INFO_MAX, &val);
		CheckResult(res,"GetLensFocalLength" "_Maximum");
		return val;
	}

	float xiAPIplus_Camera::GetLensFocalLength_Minimum()
	{
		float val=0;
		
		CheckCamHandle("GetLensFocalLength" "_Minimum");
		
		XI_RETURN res=xiGetParamFloat(camera_handle, XI_PRM_LENS_FOCAL_LENGTH XI_PRM_INFO_MIN, &val);
		CheckResult(res,"GetLensFocalLength" "_Minimum");
		return val;
	}

	float xiAPIplus_Camera::GetLensFocalLength_Increment()
	{
		float val=0;
		
		CheckCamHandle("GetLensFocalLength" "_Increment");
		
		XI_RETURN res=xiGetParamFloat(camera_handle, XI_PRM_LENS_FOCAL_LENGTH XI_PRM_INFO_INCREMENT, &val);
		CheckResult(res,"GetLensFocalLength" "_Increment");
		return val;
	}
	 
	
	// Selects the current feature which is accessible by XI_PRM_LENS_FEATURE. (XI_PRM_LENS_FEATURE_SELECTOR)
	XI_LENS_FEATURE xiAPIplus_Camera::GetLensFeatureSelector()
	{
		int val=0;
		
		CheckCamHandle("GetLensFeatureSelector");
		
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_LENS_FEATURE_SELECTOR, &val);
		CheckResult(res,"GetLensFeatureSelector");
		return (XI_LENS_FEATURE)val;
	}
	
	XI_LENS_FEATURE xiAPIplus_Camera::GetLensFeatureSelector_Maximum()
	{
		int val=0;
		
		CheckCamHandle("GetLensFeatureSelector" "_Maximum");
		
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_LENS_FEATURE_SELECTOR XI_PRM_INFO_MAX, &val);
		CheckResult(res,"GetLensFeatureSelector" "_Maximum");
		return (XI_LENS_FEATURE)val;
	}
	
	XI_LENS_FEATURE xiAPIplus_Camera::GetLensFeatureSelector_Minimum()
	{
		int val=0;
		
		CheckCamHandle("GetLensFeatureSelector" "_Minimum");
		
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_LENS_FEATURE_SELECTOR XI_PRM_INFO_MIN, &val);
		CheckResult(res,"GetLensFeatureSelector" "_Minimum");
		return (XI_LENS_FEATURE)val;
	}
	
	int xiAPIplus_Camera::GetLensFeatureSelector_Increment()
	{
		int val=0;
		
		CheckCamHandle("GetLensFeatureSelector" "_Increment");
		
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_LENS_FEATURE_SELECTOR XI_PRM_INFO_INCREMENT, &val);
		CheckResult(res,"GetLensFeatureSelector" "_Increment");
		return val;
	}
	
	void xiAPIplus_Camera::SetLensFeatureSelector(XI_LENS_FEATURE LensFeatureSelector)
	{
		
		CheckCamHandleInt("SetLensFeatureSelector",(int)LensFeatureSelector);
		
		XI_RETURN res=xiSetParamInt(camera_handle, XI_PRM_LENS_FEATURE_SELECTOR, LensFeatureSelector);
		CheckResult(res,"SetLensFeatureSelector");
	}
	 
	
	// Allows access to lens feature value currently selected by XI_PRM_LENS_FEATURE_SELECTOR. (XI_PRM_LENS_FEATURE)
	float xiAPIplus_Camera::GetLensFeature()
	{
		float val=0;
		
		CheckCamHandle("GetLensFeature");
		
		XI_RETURN res=xiGetParamFloat(camera_handle, XI_PRM_LENS_FEATURE, &val);
		CheckResult(res,"GetLensFeature");
		return val;
	}

	float xiAPIplus_Camera::GetLensFeature_Maximum()
	{
		float val=0;
		
		CheckCamHandle("GetLensFeature" "_Maximum");
		
		XI_RETURN res=xiGetParamFloat(camera_handle, XI_PRM_LENS_FEATURE XI_PRM_INFO_MAX, &val);
		CheckResult(res,"GetLensFeature" "_Maximum");
		return val;
	}

	float xiAPIplus_Camera::GetLensFeature_Minimum()
	{
		float val=0;
		
		CheckCamHandle("GetLensFeature" "_Minimum");
		
		XI_RETURN res=xiGetParamFloat(camera_handle, XI_PRM_LENS_FEATURE XI_PRM_INFO_MIN, &val);
		CheckResult(res,"GetLensFeature" "_Minimum");
		return val;
	}

	float xiAPIplus_Camera::GetLensFeature_Increment()
	{
		float val=0;
		
		CheckCamHandle("GetLensFeature" "_Increment");
		
		XI_RETURN res=xiGetParamFloat(camera_handle, XI_PRM_LENS_FEATURE XI_PRM_INFO_INCREMENT, &val);
		CheckResult(res,"GetLensFeature" "_Increment");
		return val;
	}
	
	void xiAPIplus_Camera::SetLensFeature(float LensFeature)
	{
		
		CheckCamHandle("SetLensFeature");
		
		XI_RETURN res=xiSetParamFloat(camera_handle, XI_PRM_LENS_FEATURE, LensFeature);
		CheckResult(res,"SetLensFeature");
	}
	

	//-------------------------------------------------------------------------------------------------------------------
	// ---- Parameter Group: Device info parameters
	//-------------------------------------------------------------------------------------------------------------------

	 
	
	// Return device name (XI_PRM_DEVICE_NAME)
	void xiAPIplus_Camera::GetCameraName(char* buffer, int buffer_length)
	{
		
		CheckCamHandle("GetCameraName");
		
		XI_RETURN res=xiGetParamString(camera_handle, XI_PRM_DEVICE_NAME, buffer, buffer_length);
		CheckResult(res,"GetCameraName");
	}
	 
	
	// Return device type (XI_PRM_DEVICE_TYPE)
	void xiAPIplus_Camera::GetCameraType(char* buffer, int buffer_length)
	{
		
		CheckCamHandle("GetCameraType");
		
		XI_RETURN res=xiGetParamString(camera_handle, XI_PRM_DEVICE_TYPE, buffer, buffer_length);
		CheckResult(res,"GetCameraType");
	}
	 
	
	// Return device model id (XI_PRM_DEVICE_MODEL_ID)
	// integer type
	int xiAPIplus_Camera::GetModelId()
	{
		CheckCamHandle("GetModelId");
		int val=0;
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_DEVICE_MODEL_ID, &val);
		CheckResult(res,"GetModelId");
		return val;	
	}
	int xiAPIplus_Camera::GetModelId_Maximum()
	{		
		CheckCamHandle("GetModelId" "_Maximum");
		int val=0;
		CheckCamHandle("GetModelId");
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_DEVICE_MODEL_ID XI_PRM_INFO_MAX, &val);
		CheckResult(res,"GetModelId" "_Maximum");
		return val;
	}
	
	int xiAPIplus_Camera::GetModelId_Minimum()
	{
		CheckCamHandle("GetModelId" "_Minimum");
		int val=0;
		CheckCamHandle("GetModelId");
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_DEVICE_MODEL_ID XI_PRM_INFO_MIN, &val);
		CheckResult(res,"GetModelId" "_Minimum");
		return val;
	}

	int xiAPIplus_Camera::GetModelId_Increment()
	{
		CheckCamHandle("GetModelId" "_Increment");
		int val=0;
		CheckCamHandle("GetModelId");
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_DEVICE_MODEL_ID XI_PRM_INFO_INCREMENT, &val);
		CheckResult(res,"GetModelId" "_Increment");
		return val;		
	}
	 
	
	// Return device sensor model id (XI_PRM_SENSOR_MODEL_ID)
	// integer type
	int xiAPIplus_Camera::GetSensorId()
	{
		CheckCamHandle("GetSensorId");
		int val=0;
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_SENSOR_MODEL_ID, &val);
		CheckResult(res,"GetSensorId");
		return val;	
	}
	int xiAPIplus_Camera::GetSensorId_Maximum()
	{		
		CheckCamHandle("GetSensorId" "_Maximum");
		int val=0;
		CheckCamHandle("GetSensorId");
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_SENSOR_MODEL_ID XI_PRM_INFO_MAX, &val);
		CheckResult(res,"GetSensorId" "_Maximum");
		return val;
	}
	
	int xiAPIplus_Camera::GetSensorId_Minimum()
	{
		CheckCamHandle("GetSensorId" "_Minimum");
		int val=0;
		CheckCamHandle("GetSensorId");
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_SENSOR_MODEL_ID XI_PRM_INFO_MIN, &val);
		CheckResult(res,"GetSensorId" "_Minimum");
		return val;
	}

	int xiAPIplus_Camera::GetSensorId_Increment()
	{
		CheckCamHandle("GetSensorId" "_Increment");
		int val=0;
		CheckCamHandle("GetSensorId");
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_SENSOR_MODEL_ID XI_PRM_INFO_INCREMENT, &val);
		CheckResult(res,"GetSensorId" "_Increment");
		return val;		
	}
	 
	
	// Return device serial number (XI_PRM_DEVICE_SN)
	void xiAPIplus_Camera::GetSerialNumber(char* buffer, int buffer_length)
	{
		
		CheckCamHandle("GetSerialNumber");
		
		XI_RETURN res=xiGetParamString(camera_handle, XI_PRM_DEVICE_SN, buffer, buffer_length);
		CheckResult(res,"GetSerialNumber");
	}
	 
	
	// Return sensor serial number (XI_PRM_DEVICE_SENS_SN)
	void xiAPIplus_Camera::GetSensorSerialNumber(char* buffer, int buffer_length)
	{
		
		CheckCamHandle("GetSensorSerialNumber");
		
		XI_RETURN res=xiGetParamString(camera_handle, XI_PRM_DEVICE_SENS_SN, buffer, buffer_length);
		CheckResult(res,"GetSensorSerialNumber");
	}
	 
	
	// Return device system instance path. (XI_PRM_DEVICE_INSTANCE_PATH)
	void xiAPIplus_Camera::GetDevicePath(char* buffer, int buffer_length)
	{
		
		CheckCamHandle("GetDevicePath");
		
		XI_RETURN res=xiGetParamString(camera_handle, XI_PRM_DEVICE_INSTANCE_PATH, buffer, buffer_length);
		CheckResult(res,"GetDevicePath");
	}
	 
	
	// Represents the location of the device in the device tree. (XI_PRM_DEVICE_LOCATION_PATH)
	void xiAPIplus_Camera::GetDeviceLocPath(char* buffer, int buffer_length)
	{
		
		CheckCamHandle("GetDeviceLocPath");
		
		XI_RETURN res=xiGetParamString(camera_handle, XI_PRM_DEVICE_LOCATION_PATH, buffer, buffer_length);
		CheckResult(res,"GetDeviceLocPath");
	}
	 
	
	// Return custom ID of camera. (XI_PRM_DEVICE_USER_ID)
	void xiAPIplus_Camera::GetUserId(char* buffer, int buffer_length)
	{
		
		CheckCamHandle("GetUserId");
		
		XI_RETURN res=xiGetParamString(camera_handle, XI_PRM_DEVICE_USER_ID, buffer, buffer_length);
		CheckResult(res,"GetUserId");
	}
	 
	
	// Return device capability description XML. (XI_PRM_DEVICE_MANIFEST)
	void xiAPIplus_Camera::GetDeviceManifest(char* buffer, int buffer_length)
	{
		
		CheckCamHandle("GetDeviceManifest");
		
		XI_RETURN res=xiGetParamString(camera_handle, XI_PRM_DEVICE_MANIFEST, buffer, buffer_length);
		CheckResult(res,"GetDeviceManifest");
	}
	 
	
	// User image data at image header to track parameters synchronization. (XI_PRM_IMAGE_USER_DATA)
	// integer type
	int xiAPIplus_Camera::GetImageUserData()
	{
		CheckCamHandle("GetImageUserData");
		int val=0;
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_IMAGE_USER_DATA, &val);
		CheckResult(res,"GetImageUserData");
		return val;	
	}
	int xiAPIplus_Camera::GetImageUserData_Maximum()
	{		
		CheckCamHandle("GetImageUserData" "_Maximum");
		int val=0;
		CheckCamHandle("GetImageUserData");
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_IMAGE_USER_DATA XI_PRM_INFO_MAX, &val);
		CheckResult(res,"GetImageUserData" "_Maximum");
		return val;
	}
	
	int xiAPIplus_Camera::GetImageUserData_Minimum()
	{
		CheckCamHandle("GetImageUserData" "_Minimum");
		int val=0;
		CheckCamHandle("GetImageUserData");
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_IMAGE_USER_DATA XI_PRM_INFO_MIN, &val);
		CheckResult(res,"GetImageUserData" "_Minimum");
		return val;
	}

	int xiAPIplus_Camera::GetImageUserData_Increment()
	{
		CheckCamHandle("GetImageUserData" "_Increment");
		int val=0;
		CheckCamHandle("GetImageUserData");
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_IMAGE_USER_DATA XI_PRM_INFO_INCREMENT, &val);
		CheckResult(res,"GetImageUserData" "_Increment");
		return val;		
	}
	
	void xiAPIplus_Camera::SetImageUserData(int ImageUserData)
	{
		
		CheckCamHandleInt("SetImageUserData",ImageUserData);
		
		XI_RETURN res=xiSetParamInt(camera_handle, XI_PRM_IMAGE_USER_DATA, ImageUserData);
		CheckResult(res,"SetImageUserData");
	}
	

	//-------------------------------------------------------------------------------------------------------------------
	// ---- Parameter Group: Device acquisition settings
	//-------------------------------------------------------------------------------------------------------------------

	 
	
	// The alpha channel of RGB32 output image format. (XI_PRM_IMAGE_DATA_FORMAT_RGB32_ALPHA)
	// integer type
	int xiAPIplus_Camera::GetImageDataFormatRGB32Alpha()
	{
		CheckCamHandle("GetImageDataFormatRGB32Alpha");
		int val=0;
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_IMAGE_DATA_FORMAT_RGB32_ALPHA, &val);
		CheckResult(res,"GetImageDataFormatRGB32Alpha");
		return val;	
	}
	int xiAPIplus_Camera::GetImageDataFormatRGB32Alpha_Maximum()
	{		
		CheckCamHandle("GetImageDataFormatRGB32Alpha" "_Maximum");
		int val=0;
		CheckCamHandle("GetImageDataFormatRGB32Alpha");
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_IMAGE_DATA_FORMAT_RGB32_ALPHA XI_PRM_INFO_MAX, &val);
		CheckResult(res,"GetImageDataFormatRGB32Alpha" "_Maximum");
		return val;
	}
	
	int xiAPIplus_Camera::GetImageDataFormatRGB32Alpha_Minimum()
	{
		CheckCamHandle("GetImageDataFormatRGB32Alpha" "_Minimum");
		int val=0;
		CheckCamHandle("GetImageDataFormatRGB32Alpha");
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_IMAGE_DATA_FORMAT_RGB32_ALPHA XI_PRM_INFO_MIN, &val);
		CheckResult(res,"GetImageDataFormatRGB32Alpha" "_Minimum");
		return val;
	}

	int xiAPIplus_Camera::GetImageDataFormatRGB32Alpha_Increment()
	{
		CheckCamHandle("GetImageDataFormatRGB32Alpha" "_Increment");
		int val=0;
		CheckCamHandle("GetImageDataFormatRGB32Alpha");
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_IMAGE_DATA_FORMAT_RGB32_ALPHA XI_PRM_INFO_INCREMENT, &val);
		CheckResult(res,"GetImageDataFormatRGB32Alpha" "_Increment");
		return val;		
	}
	
	void xiAPIplus_Camera::SetImageDataFormatRGB32Alpha(int ImageDataFormatRGB32Alpha)
	{
		
		CheckCamHandleInt("SetImageDataFormatRGB32Alpha",ImageDataFormatRGB32Alpha);
		
		XI_RETURN res=xiSetParamInt(camera_handle, XI_PRM_IMAGE_DATA_FORMAT_RGB32_ALPHA, ImageDataFormatRGB32Alpha);
		CheckResult(res,"SetImageDataFormatRGB32Alpha");
	}
	 
	
	// Buffer size in bytes sufficient for output image returned by xiGetImage (XI_PRM_IMAGE_PAYLOAD_SIZE)
	// integer type
	int xiAPIplus_Camera::GetImagePayloadSize()
	{
		CheckCamHandle("GetImagePayloadSize");
		int val=0;
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_IMAGE_PAYLOAD_SIZE, &val);
		CheckResult(res,"GetImagePayloadSize");
		return val;	
	}
	int xiAPIplus_Camera::GetImagePayloadSize_Maximum()
	{		
		CheckCamHandle("GetImagePayloadSize" "_Maximum");
		int val=0;
		CheckCamHandle("GetImagePayloadSize");
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_IMAGE_PAYLOAD_SIZE XI_PRM_INFO_MAX, &val);
		CheckResult(res,"GetImagePayloadSize" "_Maximum");
		return val;
	}
	
	int xiAPIplus_Camera::GetImagePayloadSize_Minimum()
	{
		CheckCamHandle("GetImagePayloadSize" "_Minimum");
		int val=0;
		CheckCamHandle("GetImagePayloadSize");
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_IMAGE_PAYLOAD_SIZE XI_PRM_INFO_MIN, &val);
		CheckResult(res,"GetImagePayloadSize" "_Minimum");
		return val;
	}

	int xiAPIplus_Camera::GetImagePayloadSize_Increment()
	{
		CheckCamHandle("GetImagePayloadSize" "_Increment");
		int val=0;
		CheckCamHandle("GetImagePayloadSize");
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_IMAGE_PAYLOAD_SIZE XI_PRM_INFO_INCREMENT, &val);
		CheckResult(res,"GetImagePayloadSize" "_Increment");
		return val;		
	}
	 
	
	// Current format of pixels on transport layer. (XI_PRM_TRANSPORT_PIXEL_FORMAT)
	XI_GenTL_Image_Format_e xiAPIplus_Camera::GetTransportPixelFormat()
	{
		int val=0;
		
		CheckCamHandle("GetTransportPixelFormat");
		
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_TRANSPORT_PIXEL_FORMAT, &val);
		CheckResult(res,"GetTransportPixelFormat");
		return (XI_GenTL_Image_Format_e)val;
	}
	
	XI_GenTL_Image_Format_e xiAPIplus_Camera::GetTransportPixelFormat_Maximum()
	{
		int val=0;
		
		CheckCamHandle("GetTransportPixelFormat" "_Maximum");
		
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_TRANSPORT_PIXEL_FORMAT XI_PRM_INFO_MAX, &val);
		CheckResult(res,"GetTransportPixelFormat" "_Maximum");
		return (XI_GenTL_Image_Format_e)val;
	}
	
	XI_GenTL_Image_Format_e xiAPIplus_Camera::GetTransportPixelFormat_Minimum()
	{
		int val=0;
		
		CheckCamHandle("GetTransportPixelFormat" "_Minimum");
		
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_TRANSPORT_PIXEL_FORMAT XI_PRM_INFO_MIN, &val);
		CheckResult(res,"GetTransportPixelFormat" "_Minimum");
		return (XI_GenTL_Image_Format_e)val;
	}
	
	int xiAPIplus_Camera::GetTransportPixelFormat_Increment()
	{
		int val=0;
		
		CheckCamHandle("GetTransportPixelFormat" "_Increment");
		
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_TRANSPORT_PIXEL_FORMAT XI_PRM_INFO_INCREMENT, &val);
		CheckResult(res,"GetTransportPixelFormat" "_Increment");
		return val;
	}
	
	void xiAPIplus_Camera::SetTransportPixelFormat(XI_GenTL_Image_Format_e TransportPixelFormat)
	{
		
		CheckCamHandleInt("SetTransportPixelFormat",(int)TransportPixelFormat);
		
		XI_RETURN res=xiSetParamInt(camera_handle, XI_PRM_TRANSPORT_PIXEL_FORMAT, TransportPixelFormat);
		CheckResult(res,"SetTransportPixelFormat");
	}
	 
	
	// Target selector for data - CPU RAM or GPU RAM (XI_PRM_TRANSPORT_DATA_TARGET)
	XI_TRANSPORT_DATA_TARGET_MODE xiAPIplus_Camera::GetTransportDataTarget()
	{
		int val=0;
		
		CheckCamHandle("GetTransportDataTarget");
		
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_TRANSPORT_DATA_TARGET, &val);
		CheckResult(res,"GetTransportDataTarget");
		return (XI_TRANSPORT_DATA_TARGET_MODE)val;
	}
	
	XI_TRANSPORT_DATA_TARGET_MODE xiAPIplus_Camera::GetTransportDataTarget_Maximum()
	{
		int val=0;
		
		CheckCamHandle("GetTransportDataTarget" "_Maximum");
		
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_TRANSPORT_DATA_TARGET XI_PRM_INFO_MAX, &val);
		CheckResult(res,"GetTransportDataTarget" "_Maximum");
		return (XI_TRANSPORT_DATA_TARGET_MODE)val;
	}
	
	XI_TRANSPORT_DATA_TARGET_MODE xiAPIplus_Camera::GetTransportDataTarget_Minimum()
	{
		int val=0;
		
		CheckCamHandle("GetTransportDataTarget" "_Minimum");
		
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_TRANSPORT_DATA_TARGET XI_PRM_INFO_MIN, &val);
		CheckResult(res,"GetTransportDataTarget" "_Minimum");
		return (XI_TRANSPORT_DATA_TARGET_MODE)val;
	}
	
	int xiAPIplus_Camera::GetTransportDataTarget_Increment()
	{
		int val=0;
		
		CheckCamHandle("GetTransportDataTarget" "_Increment");
		
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_TRANSPORT_DATA_TARGET XI_PRM_INFO_INCREMENT, &val);
		CheckResult(res,"GetTransportDataTarget" "_Increment");
		return val;
	}
	
	void xiAPIplus_Camera::SetTransportDataTarget(XI_TRANSPORT_DATA_TARGET_MODE TransportDataTarget)
	{
		
		CheckCamHandleInt("SetTransportDataTarget",(int)TransportDataTarget);
		
		XI_RETURN res=xiSetParamInt(camera_handle, XI_PRM_TRANSPORT_DATA_TARGET, TransportDataTarget);
		CheckResult(res,"SetTransportDataTarget");
	}
	 
	
	// Sensor clock frequency in Hz. (XI_PRM_SENSOR_CLOCK_FREQ_HZ)
	float xiAPIplus_Camera::GetSensorClockFrequencyHz()
	{
		float val=0;
		
		CheckCamHandle("GetSensorClockFrequencyHz");
		
		XI_RETURN res=xiGetParamFloat(camera_handle, XI_PRM_SENSOR_CLOCK_FREQ_HZ, &val);
		CheckResult(res,"GetSensorClockFrequencyHz");
		return val;
	}

	float xiAPIplus_Camera::GetSensorClockFrequencyHz_Maximum()
	{
		float val=0;
		
		CheckCamHandle("GetSensorClockFrequencyHz" "_Maximum");
		
		XI_RETURN res=xiGetParamFloat(camera_handle, XI_PRM_SENSOR_CLOCK_FREQ_HZ XI_PRM_INFO_MAX, &val);
		CheckResult(res,"GetSensorClockFrequencyHz" "_Maximum");
		return val;
	}

	float xiAPIplus_Camera::GetSensorClockFrequencyHz_Minimum()
	{
		float val=0;
		
		CheckCamHandle("GetSensorClockFrequencyHz" "_Minimum");
		
		XI_RETURN res=xiGetParamFloat(camera_handle, XI_PRM_SENSOR_CLOCK_FREQ_HZ XI_PRM_INFO_MIN, &val);
		CheckResult(res,"GetSensorClockFrequencyHz" "_Minimum");
		return val;
	}

	float xiAPIplus_Camera::GetSensorClockFrequencyHz_Increment()
	{
		float val=0;
		
		CheckCamHandle("GetSensorClockFrequencyHz" "_Increment");
		
		XI_RETURN res=xiGetParamFloat(camera_handle, XI_PRM_SENSOR_CLOCK_FREQ_HZ XI_PRM_INFO_INCREMENT, &val);
		CheckResult(res,"GetSensorClockFrequencyHz" "_Increment");
		return val;
	}
	
	void xiAPIplus_Camera::SetSensorClockFrequencyHz(float SensorClockFrequencyHz)
	{
		
		CheckCamHandle("SetSensorClockFrequencyHz");
		
		XI_RETURN res=xiSetParamFloat(camera_handle, XI_PRM_SENSOR_CLOCK_FREQ_HZ, SensorClockFrequencyHz);
		CheckResult(res,"SetSensorClockFrequencyHz");
	}
	 
	
	// Sensor clock frequency index. Sensor with selected frequencies have possibility to set the frequency only by this index. (XI_PRM_SENSOR_CLOCK_FREQ_INDEX)
	// integer type
	int xiAPIplus_Camera::GetSensorClockFrequencyIndex()
	{
		CheckCamHandle("GetSensorClockFrequencyIndex");
		int val=0;
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_SENSOR_CLOCK_FREQ_INDEX, &val);
		CheckResult(res,"GetSensorClockFrequencyIndex");
		return val;	
	}
	int xiAPIplus_Camera::GetSensorClockFrequencyIndex_Maximum()
	{		
		CheckCamHandle("GetSensorClockFrequencyIndex" "_Maximum");
		int val=0;
		CheckCamHandle("GetSensorClockFrequencyIndex");
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_SENSOR_CLOCK_FREQ_INDEX XI_PRM_INFO_MAX, &val);
		CheckResult(res,"GetSensorClockFrequencyIndex" "_Maximum");
		return val;
	}
	
	int xiAPIplus_Camera::GetSensorClockFrequencyIndex_Minimum()
	{
		CheckCamHandle("GetSensorClockFrequencyIndex" "_Minimum");
		int val=0;
		CheckCamHandle("GetSensorClockFrequencyIndex");
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_SENSOR_CLOCK_FREQ_INDEX XI_PRM_INFO_MIN, &val);
		CheckResult(res,"GetSensorClockFrequencyIndex" "_Minimum");
		return val;
	}

	int xiAPIplus_Camera::GetSensorClockFrequencyIndex_Increment()
	{
		CheckCamHandle("GetSensorClockFrequencyIndex" "_Increment");
		int val=0;
		CheckCamHandle("GetSensorClockFrequencyIndex");
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_SENSOR_CLOCK_FREQ_INDEX XI_PRM_INFO_INCREMENT, &val);
		CheckResult(res,"GetSensorClockFrequencyIndex" "_Increment");
		return val;		
	}
	
	void xiAPIplus_Camera::SetSensorClockFrequencyIndex(int SensorClockFrequencyIndex)
	{
		
		CheckCamHandleInt("SetSensorClockFrequencyIndex",SensorClockFrequencyIndex);
		
		XI_RETURN res=xiSetParamInt(camera_handle, XI_PRM_SENSOR_CLOCK_FREQ_INDEX, SensorClockFrequencyIndex);
		CheckResult(res,"SetSensorClockFrequencyIndex");
	}
	 
	
	// Number of output channels from sensor used for data transfer. (XI_PRM_SENSOR_OUTPUT_CHANNEL_COUNT)
	XI_SENSOR_OUTPUT_CHANNEL_COUNT xiAPIplus_Camera::GetSensorOutputChannelCount()
	{
		int val=0;
		
		CheckCamHandle("GetSensorOutputChannelCount");
		
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_SENSOR_OUTPUT_CHANNEL_COUNT, &val);
		CheckResult(res,"GetSensorOutputChannelCount");
		return (XI_SENSOR_OUTPUT_CHANNEL_COUNT)val;
	}
	
	XI_SENSOR_OUTPUT_CHANNEL_COUNT xiAPIplus_Camera::GetSensorOutputChannelCount_Maximum()
	{
		int val=0;
		
		CheckCamHandle("GetSensorOutputChannelCount" "_Maximum");
		
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_SENSOR_OUTPUT_CHANNEL_COUNT XI_PRM_INFO_MAX, &val);
		CheckResult(res,"GetSensorOutputChannelCount" "_Maximum");
		return (XI_SENSOR_OUTPUT_CHANNEL_COUNT)val;
	}
	
	XI_SENSOR_OUTPUT_CHANNEL_COUNT xiAPIplus_Camera::GetSensorOutputChannelCount_Minimum()
	{
		int val=0;
		
		CheckCamHandle("GetSensorOutputChannelCount" "_Minimum");
		
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_SENSOR_OUTPUT_CHANNEL_COUNT XI_PRM_INFO_MIN, &val);
		CheckResult(res,"GetSensorOutputChannelCount" "_Minimum");
		return (XI_SENSOR_OUTPUT_CHANNEL_COUNT)val;
	}
	
	int xiAPIplus_Camera::GetSensorOutputChannelCount_Increment()
	{
		int val=0;
		
		CheckCamHandle("GetSensorOutputChannelCount" "_Increment");
		
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_SENSOR_OUTPUT_CHANNEL_COUNT XI_PRM_INFO_INCREMENT, &val);
		CheckResult(res,"GetSensorOutputChannelCount" "_Increment");
		return val;
	}
	
	void xiAPIplus_Camera::SetSensorOutputChannelCount(XI_SENSOR_OUTPUT_CHANNEL_COUNT SensorOutputChannelCount)
	{
		
		CheckCamHandleInt("SetSensorOutputChannelCount",(int)SensorOutputChannelCount);
		
		XI_RETURN res=xiSetParamInt(camera_handle, XI_PRM_SENSOR_OUTPUT_CHANNEL_COUNT, SensorOutputChannelCount);
		CheckResult(res,"SetSensorOutputChannelCount");
	}
	 
	
	// Define framerate in Hz (XI_PRM_FRAMERATE)
	float xiAPIplus_Camera::GetFrameRate()
	{
		float val=0;
		
		CheckCamHandle("GetFrameRate");
		
		XI_RETURN res=xiGetParamFloat(camera_handle, XI_PRM_FRAMERATE, &val);
		CheckResult(res,"GetFrameRate");
		return val;
	}

	float xiAPIplus_Camera::GetFrameRate_Maximum()
	{
		float val=0;
		
		CheckCamHandle("GetFrameRate" "_Maximum");
		
		XI_RETURN res=xiGetParamFloat(camera_handle, XI_PRM_FRAMERATE XI_PRM_INFO_MAX, &val);
		CheckResult(res,"GetFrameRate" "_Maximum");
		return val;
	}

	float xiAPIplus_Camera::GetFrameRate_Minimum()
	{
		float val=0;
		
		CheckCamHandle("GetFrameRate" "_Minimum");
		
		XI_RETURN res=xiGetParamFloat(camera_handle, XI_PRM_FRAMERATE XI_PRM_INFO_MIN, &val);
		CheckResult(res,"GetFrameRate" "_Minimum");
		return val;
	}

	float xiAPIplus_Camera::GetFrameRate_Increment()
	{
		float val=0;
		
		CheckCamHandle("GetFrameRate" "_Increment");
		
		XI_RETURN res=xiGetParamFloat(camera_handle, XI_PRM_FRAMERATE XI_PRM_INFO_INCREMENT, &val);
		CheckResult(res,"GetFrameRate" "_Increment");
		return val;
	}
	
	void xiAPIplus_Camera::SetFrameRate(float FrameRate)
	{
		
		CheckCamHandle("SetFrameRate");
		
		XI_RETURN res=xiSetParamFloat(camera_handle, XI_PRM_FRAMERATE, FrameRate);
		CheckResult(res,"SetFrameRate");
	}
	 
	
	// Select counter (XI_PRM_COUNTER_SELECTOR)
	XI_COUNTER_SELECTOR xiAPIplus_Camera::GetCounterSelector()
	{
		int val=0;
		
		CheckCamHandle("GetCounterSelector");
		
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_COUNTER_SELECTOR, &val);
		CheckResult(res,"GetCounterSelector");
		return (XI_COUNTER_SELECTOR)val;
	}
	
	XI_COUNTER_SELECTOR xiAPIplus_Camera::GetCounterSelector_Maximum()
	{
		int val=0;
		
		CheckCamHandle("GetCounterSelector" "_Maximum");
		
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_COUNTER_SELECTOR XI_PRM_INFO_MAX, &val);
		CheckResult(res,"GetCounterSelector" "_Maximum");
		return (XI_COUNTER_SELECTOR)val;
	}
	
	XI_COUNTER_SELECTOR xiAPIplus_Camera::GetCounterSelector_Minimum()
	{
		int val=0;
		
		CheckCamHandle("GetCounterSelector" "_Minimum");
		
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_COUNTER_SELECTOR XI_PRM_INFO_MIN, &val);
		CheckResult(res,"GetCounterSelector" "_Minimum");
		return (XI_COUNTER_SELECTOR)val;
	}
	
	int xiAPIplus_Camera::GetCounterSelector_Increment()
	{
		int val=0;
		
		CheckCamHandle("GetCounterSelector" "_Increment");
		
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_COUNTER_SELECTOR XI_PRM_INFO_INCREMENT, &val);
		CheckResult(res,"GetCounterSelector" "_Increment");
		return val;
	}
	
	void xiAPIplus_Camera::SetCounterSelector(XI_COUNTER_SELECTOR CounterSelector)
	{
		
		CheckCamHandleInt("SetCounterSelector",(int)CounterSelector);
		
		XI_RETURN res=xiSetParamInt(camera_handle, XI_PRM_COUNTER_SELECTOR, CounterSelector);
		CheckResult(res,"SetCounterSelector");
	}
	 
	
	// Counter status (XI_PRM_COUNTER_VALUE)
	// integer type
	int xiAPIplus_Camera::GetCounterValue()
	{
		CheckCamHandle("GetCounterValue");
		int val=0;
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_COUNTER_VALUE, &val);
		CheckResult(res,"GetCounterValue");
		return val;	
	}
	int xiAPIplus_Camera::GetCounterValue_Maximum()
	{		
		CheckCamHandle("GetCounterValue" "_Maximum");
		int val=0;
		CheckCamHandle("GetCounterValue");
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_COUNTER_VALUE XI_PRM_INFO_MAX, &val);
		CheckResult(res,"GetCounterValue" "_Maximum");
		return val;
	}
	
	int xiAPIplus_Camera::GetCounterValue_Minimum()
	{
		CheckCamHandle("GetCounterValue" "_Minimum");
		int val=0;
		CheckCamHandle("GetCounterValue");
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_COUNTER_VALUE XI_PRM_INFO_MIN, &val);
		CheckResult(res,"GetCounterValue" "_Minimum");
		return val;
	}

	int xiAPIplus_Camera::GetCounterValue_Increment()
	{
		CheckCamHandle("GetCounterValue" "_Increment");
		int val=0;
		CheckCamHandle("GetCounterValue");
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_COUNTER_VALUE XI_PRM_INFO_INCREMENT, &val);
		CheckResult(res,"GetCounterValue" "_Increment");
		return val;		
	}
	 
	
	// Type of sensor frames timing. (XI_PRM_ACQ_TIMING_MODE)
	XI_ACQ_TIMING_MODE xiAPIplus_Camera::GetAcquisitionTimingMode()
	{
		int val=0;
		
		CheckCamHandle("GetAcquisitionTimingMode");
		
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_ACQ_TIMING_MODE, &val);
		CheckResult(res,"GetAcquisitionTimingMode");
		return (XI_ACQ_TIMING_MODE)val;
	}
	
	XI_ACQ_TIMING_MODE xiAPIplus_Camera::GetAcquisitionTimingMode_Maximum()
	{
		int val=0;
		
		CheckCamHandle("GetAcquisitionTimingMode" "_Maximum");
		
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_ACQ_TIMING_MODE XI_PRM_INFO_MAX, &val);
		CheckResult(res,"GetAcquisitionTimingMode" "_Maximum");
		return (XI_ACQ_TIMING_MODE)val;
	}
	
	XI_ACQ_TIMING_MODE xiAPIplus_Camera::GetAcquisitionTimingMode_Minimum()
	{
		int val=0;
		
		CheckCamHandle("GetAcquisitionTimingMode" "_Minimum");
		
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_ACQ_TIMING_MODE XI_PRM_INFO_MIN, &val);
		CheckResult(res,"GetAcquisitionTimingMode" "_Minimum");
		return (XI_ACQ_TIMING_MODE)val;
	}
	
	int xiAPIplus_Camera::GetAcquisitionTimingMode_Increment()
	{
		int val=0;
		
		CheckCamHandle("GetAcquisitionTimingMode" "_Increment");
		
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_ACQ_TIMING_MODE XI_PRM_INFO_INCREMENT, &val);
		CheckResult(res,"GetAcquisitionTimingMode" "_Increment");
		return val;
	}
	
	void xiAPIplus_Camera::SetAcquisitionTimingMode(XI_ACQ_TIMING_MODE AcquisitionTimingMode)
	{
		
		CheckCamHandleInt("SetAcquisitionTimingMode",(int)AcquisitionTimingMode);
		
		XI_RETURN res=xiSetParamInt(camera_handle, XI_PRM_ACQ_TIMING_MODE, AcquisitionTimingMode);
		CheckResult(res,"SetAcquisitionTimingMode");
	}
	 
	
	// Measure available interface bandwidth (in Megabits) (XI_PRM_AVAILABLE_BANDWIDTH)
	// integer type
	int xiAPIplus_Camera::GetBandwidthAvailable()
	{
		CheckCamHandle("GetBandwidthAvailable");
		int val=0;
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_AVAILABLE_BANDWIDTH, &val);
		CheckResult(res,"GetBandwidthAvailable");
		return val;	
	}
	int xiAPIplus_Camera::GetBandwidthAvailable_Maximum()
	{		
		CheckCamHandle("GetBandwidthAvailable" "_Maximum");
		int val=0;
		CheckCamHandle("GetBandwidthAvailable");
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_AVAILABLE_BANDWIDTH XI_PRM_INFO_MAX, &val);
		CheckResult(res,"GetBandwidthAvailable" "_Maximum");
		return val;
	}
	
	int xiAPIplus_Camera::GetBandwidthAvailable_Minimum()
	{
		CheckCamHandle("GetBandwidthAvailable" "_Minimum");
		int val=0;
		CheckCamHandle("GetBandwidthAvailable");
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_AVAILABLE_BANDWIDTH XI_PRM_INFO_MIN, &val);
		CheckResult(res,"GetBandwidthAvailable" "_Minimum");
		return val;
	}

	int xiAPIplus_Camera::GetBandwidthAvailable_Increment()
	{
		CheckCamHandle("GetBandwidthAvailable" "_Increment");
		int val=0;
		CheckCamHandle("GetBandwidthAvailable");
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_AVAILABLE_BANDWIDTH XI_PRM_INFO_INCREMENT, &val);
		CheckResult(res,"GetBandwidthAvailable" "_Increment");
		return val;		
	}
	 
	
	// Data move policy (XI_PRM_BUFFER_POLICY)
	XI_BP xiAPIplus_Camera::GetBufferPolicy()
	{
		int val=0;
		
		CheckCamHandle("GetBufferPolicy");
		
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_BUFFER_POLICY, &val);
		CheckResult(res,"GetBufferPolicy");
		return (XI_BP)val;
	}
	
	XI_BP xiAPIplus_Camera::GetBufferPolicy_Maximum()
	{
		int val=0;
		
		CheckCamHandle("GetBufferPolicy" "_Maximum");
		
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_BUFFER_POLICY XI_PRM_INFO_MAX, &val);
		CheckResult(res,"GetBufferPolicy" "_Maximum");
		return (XI_BP)val;
	}
	
	XI_BP xiAPIplus_Camera::GetBufferPolicy_Minimum()
	{
		int val=0;
		
		CheckCamHandle("GetBufferPolicy" "_Minimum");
		
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_BUFFER_POLICY XI_PRM_INFO_MIN, &val);
		CheckResult(res,"GetBufferPolicy" "_Minimum");
		return (XI_BP)val;
	}
	
	int xiAPIplus_Camera::GetBufferPolicy_Increment()
	{
		int val=0;
		
		CheckCamHandle("GetBufferPolicy" "_Increment");
		
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_BUFFER_POLICY XI_PRM_INFO_INCREMENT, &val);
		CheckResult(res,"GetBufferPolicy" "_Increment");
		return val;
	}
	
	void xiAPIplus_Camera::SetBufferPolicy(XI_BP BufferPolicy)
	{
		
		CheckCamHandleInt("SetBufferPolicy",(int)BufferPolicy);
		
		XI_RETURN res=xiSetParamInt(camera_handle, XI_PRM_BUFFER_POLICY, BufferPolicy);
		CheckResult(res,"SetBufferPolicy");
	}
	 
	
	// Activates LUT. (XI_PRM_LUT_EN)
	bool xiAPIplus_Camera::IsLookUpTable()
	{
		int val=0;
		
		CheckCamHandle("IsLookUpTable");
		
		xiGetParamInt(camera_handle, XI_PRM_LUT_EN, &val);
		return (val!=0);
	}
	
	void xiAPIplus_Camera::EnableLookUpTable()
	{
		
		CheckCamHandle("IsLookUpTable");
		
		XI_RETURN res=xiSetParamInt(camera_handle, XI_PRM_LUT_EN, XI_ON);
		CheckResult(res,"EnableLookUpTable");
	}

	void xiAPIplus_Camera::DisableLookUpTable()
	{
		
		CheckCamHandle("DisableLookUpTable");
		
		XI_RETURN res=xiSetParamInt(camera_handle, XI_PRM_LUT_EN, XI_OFF);
		CheckResult(res,"DisableLookUpTable");
	}	
	 
	
	// Control the index (offset) of the coefficient to access in the LUT. (XI_PRM_LUT_INDEX)
	// integer type
	int xiAPIplus_Camera::GetLookUpTableIndex()
	{
		CheckCamHandle("GetLookUpTableIndex");
		int val=0;
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_LUT_INDEX, &val);
		CheckResult(res,"GetLookUpTableIndex");
		return val;	
	}
	int xiAPIplus_Camera::GetLookUpTableIndex_Maximum()
	{		
		CheckCamHandle("GetLookUpTableIndex" "_Maximum");
		int val=0;
		CheckCamHandle("GetLookUpTableIndex");
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_LUT_INDEX XI_PRM_INFO_MAX, &val);
		CheckResult(res,"GetLookUpTableIndex" "_Maximum");
		return val;
	}
	
	int xiAPIplus_Camera::GetLookUpTableIndex_Minimum()
	{
		CheckCamHandle("GetLookUpTableIndex" "_Minimum");
		int val=0;
		CheckCamHandle("GetLookUpTableIndex");
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_LUT_INDEX XI_PRM_INFO_MIN, &val);
		CheckResult(res,"GetLookUpTableIndex" "_Minimum");
		return val;
	}

	int xiAPIplus_Camera::GetLookUpTableIndex_Increment()
	{
		CheckCamHandle("GetLookUpTableIndex" "_Increment");
		int val=0;
		CheckCamHandle("GetLookUpTableIndex");
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_LUT_INDEX XI_PRM_INFO_INCREMENT, &val);
		CheckResult(res,"GetLookUpTableIndex" "_Increment");
		return val;		
	}
	
	void xiAPIplus_Camera::SetLookUpTableIndex(int LookUpTableIndex)
	{
		
		CheckCamHandleInt("SetLookUpTableIndex",LookUpTableIndex);
		
		XI_RETURN res=xiSetParamInt(camera_handle, XI_PRM_LUT_INDEX, LookUpTableIndex);
		CheckResult(res,"SetLookUpTableIndex");
	}
	 
	
	// Value at entry LUTIndex of the LUT (XI_PRM_LUT_VALUE)
	// integer type
	int xiAPIplus_Camera::GetLookUpTableValue()
	{
		CheckCamHandle("GetLookUpTableValue");
		int val=0;
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_LUT_VALUE, &val);
		CheckResult(res,"GetLookUpTableValue");
		return val;	
	}
	int xiAPIplus_Camera::GetLookUpTableValue_Maximum()
	{		
		CheckCamHandle("GetLookUpTableValue" "_Maximum");
		int val=0;
		CheckCamHandle("GetLookUpTableValue");
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_LUT_VALUE XI_PRM_INFO_MAX, &val);
		CheckResult(res,"GetLookUpTableValue" "_Maximum");
		return val;
	}
	
	int xiAPIplus_Camera::GetLookUpTableValue_Minimum()
	{
		CheckCamHandle("GetLookUpTableValue" "_Minimum");
		int val=0;
		CheckCamHandle("GetLookUpTableValue");
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_LUT_VALUE XI_PRM_INFO_MIN, &val);
		CheckResult(res,"GetLookUpTableValue" "_Minimum");
		return val;
	}

	int xiAPIplus_Camera::GetLookUpTableValue_Increment()
	{
		CheckCamHandle("GetLookUpTableValue" "_Increment");
		int val=0;
		CheckCamHandle("GetLookUpTableValue");
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_LUT_VALUE XI_PRM_INFO_INCREMENT, &val);
		CheckResult(res,"GetLookUpTableValue" "_Increment");
		return val;		
	}
	
	void xiAPIplus_Camera::SetLookUpTableValue(int LookUpTableValue)
	{
		
		CheckCamHandleInt("SetLookUpTableValue",LookUpTableValue);
		
		XI_RETURN res=xiSetParamInt(camera_handle, XI_PRM_LUT_VALUE, LookUpTableValue);
		CheckResult(res,"SetLookUpTableValue");
	}
	 
	
	// Specifies the delay in microseconds (us) to apply after the trigger reception before activating it. (XI_PRM_TRG_DELAY)
	// integer type
	int xiAPIplus_Camera::GetTriggerDelay()
	{
		CheckCamHandle("GetTriggerDelay");
		int val=0;
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_TRG_DELAY, &val);
		CheckResult(res,"GetTriggerDelay");
		return val;	
	}
	int xiAPIplus_Camera::GetTriggerDelay_Maximum()
	{		
		CheckCamHandle("GetTriggerDelay" "_Maximum");
		int val=0;
		CheckCamHandle("GetTriggerDelay");
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_TRG_DELAY XI_PRM_INFO_MAX, &val);
		CheckResult(res,"GetTriggerDelay" "_Maximum");
		return val;
	}
	
	int xiAPIplus_Camera::GetTriggerDelay_Minimum()
	{
		CheckCamHandle("GetTriggerDelay" "_Minimum");
		int val=0;
		CheckCamHandle("GetTriggerDelay");
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_TRG_DELAY XI_PRM_INFO_MIN, &val);
		CheckResult(res,"GetTriggerDelay" "_Minimum");
		return val;
	}

	int xiAPIplus_Camera::GetTriggerDelay_Increment()
	{
		CheckCamHandle("GetTriggerDelay" "_Increment");
		int val=0;
		CheckCamHandle("GetTriggerDelay");
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_TRG_DELAY XI_PRM_INFO_INCREMENT, &val);
		CheckResult(res,"GetTriggerDelay" "_Increment");
		return val;		
	}
	
	void xiAPIplus_Camera::SetTriggerDelay(int TriggerDelay)
	{
		
		CheckCamHandleInt("SetTriggerDelay",TriggerDelay);
		
		XI_RETURN res=xiSetParamInt(camera_handle, XI_PRM_TRG_DELAY, TriggerDelay);
		CheckResult(res,"SetTriggerDelay");
	}
	 
	
	// Defines how TimeStamp reset engine will be armed (XI_PRM_TS_RST_MODE)
	XI_TS_RST_MODE xiAPIplus_Camera::GetTimestampResetMode()
	{
		int val=0;
		
		CheckCamHandle("GetTimestampResetMode");
		
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_TS_RST_MODE, &val);
		CheckResult(res,"GetTimestampResetMode");
		return (XI_TS_RST_MODE)val;
	}
	
	XI_TS_RST_MODE xiAPIplus_Camera::GetTimestampResetMode_Maximum()
	{
		int val=0;
		
		CheckCamHandle("GetTimestampResetMode" "_Maximum");
		
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_TS_RST_MODE XI_PRM_INFO_MAX, &val);
		CheckResult(res,"GetTimestampResetMode" "_Maximum");
		return (XI_TS_RST_MODE)val;
	}
	
	XI_TS_RST_MODE xiAPIplus_Camera::GetTimestampResetMode_Minimum()
	{
		int val=0;
		
		CheckCamHandle("GetTimestampResetMode" "_Minimum");
		
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_TS_RST_MODE XI_PRM_INFO_MIN, &val);
		CheckResult(res,"GetTimestampResetMode" "_Minimum");
		return (XI_TS_RST_MODE)val;
	}
	
	int xiAPIplus_Camera::GetTimestampResetMode_Increment()
	{
		int val=0;
		
		CheckCamHandle("GetTimestampResetMode" "_Increment");
		
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_TS_RST_MODE XI_PRM_INFO_INCREMENT, &val);
		CheckResult(res,"GetTimestampResetMode" "_Increment");
		return val;
	}
	
	void xiAPIplus_Camera::SetTimestampResetMode(XI_TS_RST_MODE TimestampResetMode)
	{
		
		CheckCamHandleInt("SetTimestampResetMode",(int)TimestampResetMode);
		
		XI_RETURN res=xiSetParamInt(camera_handle, XI_PRM_TS_RST_MODE, TimestampResetMode);
		CheckResult(res,"SetTimestampResetMode");
	}
	 
	
	// Defines which source will be used for timestamp reset. Writing this parameter will trigger settings of engine (arming) (XI_PRM_TS_RST_SOURCE)
	XI_TS_RST_SOURCE xiAPIplus_Camera::GetTimestampResetSource()
	{
		int val=0;
		
		CheckCamHandle("GetTimestampResetSource");
		
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_TS_RST_SOURCE, &val);
		CheckResult(res,"GetTimestampResetSource");
		return (XI_TS_RST_SOURCE)val;
	}
	
	XI_TS_RST_SOURCE xiAPIplus_Camera::GetTimestampResetSource_Maximum()
	{
		int val=0;
		
		CheckCamHandle("GetTimestampResetSource" "_Maximum");
		
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_TS_RST_SOURCE XI_PRM_INFO_MAX, &val);
		CheckResult(res,"GetTimestampResetSource" "_Maximum");
		return (XI_TS_RST_SOURCE)val;
	}
	
	XI_TS_RST_SOURCE xiAPIplus_Camera::GetTimestampResetSource_Minimum()
	{
		int val=0;
		
		CheckCamHandle("GetTimestampResetSource" "_Minimum");
		
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_TS_RST_SOURCE XI_PRM_INFO_MIN, &val);
		CheckResult(res,"GetTimestampResetSource" "_Minimum");
		return (XI_TS_RST_SOURCE)val;
	}
	
	int xiAPIplus_Camera::GetTimestampResetSource_Increment()
	{
		int val=0;
		
		CheckCamHandle("GetTimestampResetSource" "_Increment");
		
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_TS_RST_SOURCE XI_PRM_INFO_INCREMENT, &val);
		CheckResult(res,"GetTimestampResetSource" "_Increment");
		return val;
	}
	
	void xiAPIplus_Camera::SetTimestampResetSource(XI_TS_RST_SOURCE TimestampResetSource)
	{
		
		CheckCamHandleInt("SetTimestampResetSource",(int)TimestampResetSource);
		
		XI_RETURN res=xiSetParamInt(camera_handle, XI_PRM_TS_RST_SOURCE, TimestampResetSource);
		CheckResult(res,"SetTimestampResetSource");
	}
	

	//-------------------------------------------------------------------------------------------------------------------
	// ---- Parameter Group: Extended Device parameters
	//-------------------------------------------------------------------------------------------------------------------

	 
	
	// Returns 1 if camera connected and works properly. (XI_PRM_IS_DEVICE_EXIST)
	bool xiAPIplus_Camera::IsExist()
	{
		int val=0;
		
		CheckCamHandle("IsExist");
		
		xiGetParamInt(camera_handle, XI_PRM_IS_DEVICE_EXIST, &val);
		return (val!=0);
	}
	 
	
	// Acquisition buffer size in buffer_size_unit. Default bytes. (XI_PRM_ACQ_BUFFER_SIZE)
	// integer type
	int xiAPIplus_Camera::GetAcquisitionBufferSizeBytes()
	{
		CheckCamHandle("GetAcquisitionBufferSizeBytes");
		int val=0;
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_ACQ_BUFFER_SIZE, &val);
		CheckResult(res,"GetAcquisitionBufferSizeBytes");
		return val;	
	}
	int xiAPIplus_Camera::GetAcquisitionBufferSizeBytes_Maximum()
	{		
		CheckCamHandle("GetAcquisitionBufferSizeBytes" "_Maximum");
		int val=0;
		CheckCamHandle("GetAcquisitionBufferSizeBytes");
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_ACQ_BUFFER_SIZE XI_PRM_INFO_MAX, &val);
		CheckResult(res,"GetAcquisitionBufferSizeBytes" "_Maximum");
		return val;
	}
	
	int xiAPIplus_Camera::GetAcquisitionBufferSizeBytes_Minimum()
	{
		CheckCamHandle("GetAcquisitionBufferSizeBytes" "_Minimum");
		int val=0;
		CheckCamHandle("GetAcquisitionBufferSizeBytes");
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_ACQ_BUFFER_SIZE XI_PRM_INFO_MIN, &val);
		CheckResult(res,"GetAcquisitionBufferSizeBytes" "_Minimum");
		return val;
	}

	int xiAPIplus_Camera::GetAcquisitionBufferSizeBytes_Increment()
	{
		CheckCamHandle("GetAcquisitionBufferSizeBytes" "_Increment");
		int val=0;
		CheckCamHandle("GetAcquisitionBufferSizeBytes");
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_ACQ_BUFFER_SIZE XI_PRM_INFO_INCREMENT, &val);
		CheckResult(res,"GetAcquisitionBufferSizeBytes" "_Increment");
		return val;		
	}
	
	void xiAPIplus_Camera::SetAcquisitionBufferSizeBytes(int AcquisitionBufferSizeBytes)
	{
		
		CheckCamHandleInt("SetAcquisitionBufferSizeBytes",AcquisitionBufferSizeBytes);
		
		XI_RETURN res=xiSetParamInt(camera_handle, XI_PRM_ACQ_BUFFER_SIZE, AcquisitionBufferSizeBytes);
		CheckResult(res,"SetAcquisitionBufferSizeBytes");
	}
	 
	
	// Acquisition buffer size unit in bytes. Default 1. E.g. Value 1024 means that buffer_size is in KiBytes (XI_PRM_ACQ_BUFFER_SIZE_UNIT)
	// integer type
	int xiAPIplus_Camera::GetAcquisitionBufferSizeBytesUnit()
	{
		CheckCamHandle("GetAcquisitionBufferSizeBytesUnit");
		int val=0;
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_ACQ_BUFFER_SIZE_UNIT, &val);
		CheckResult(res,"GetAcquisitionBufferSizeBytesUnit");
		return val;	
	}
	int xiAPIplus_Camera::GetAcquisitionBufferSizeBytesUnit_Maximum()
	{		
		CheckCamHandle("GetAcquisitionBufferSizeBytesUnit" "_Maximum");
		int val=0;
		CheckCamHandle("GetAcquisitionBufferSizeBytesUnit");
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_ACQ_BUFFER_SIZE_UNIT XI_PRM_INFO_MAX, &val);
		CheckResult(res,"GetAcquisitionBufferSizeBytesUnit" "_Maximum");
		return val;
	}
	
	int xiAPIplus_Camera::GetAcquisitionBufferSizeBytesUnit_Minimum()
	{
		CheckCamHandle("GetAcquisitionBufferSizeBytesUnit" "_Minimum");
		int val=0;
		CheckCamHandle("GetAcquisitionBufferSizeBytesUnit");
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_ACQ_BUFFER_SIZE_UNIT XI_PRM_INFO_MIN, &val);
		CheckResult(res,"GetAcquisitionBufferSizeBytesUnit" "_Minimum");
		return val;
	}

	int xiAPIplus_Camera::GetAcquisitionBufferSizeBytesUnit_Increment()
	{
		CheckCamHandle("GetAcquisitionBufferSizeBytesUnit" "_Increment");
		int val=0;
		CheckCamHandle("GetAcquisitionBufferSizeBytesUnit");
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_ACQ_BUFFER_SIZE_UNIT XI_PRM_INFO_INCREMENT, &val);
		CheckResult(res,"GetAcquisitionBufferSizeBytesUnit" "_Increment");
		return val;		
	}
	
	void xiAPIplus_Camera::SetAcquisitionBufferSizeBytesUnit(int AcquisitionBufferSizeBytesUnit)
	{
		
		CheckCamHandleInt("SetAcquisitionBufferSizeBytesUnit",AcquisitionBufferSizeBytesUnit);
		
		XI_RETURN res=xiSetParamInt(camera_handle, XI_PRM_ACQ_BUFFER_SIZE_UNIT, AcquisitionBufferSizeBytesUnit);
		CheckResult(res,"SetAcquisitionBufferSizeBytesUnit");
	}
	 
	
	// Acquisition transport buffer size in bytes (XI_PRM_ACQ_TRANSPORT_BUFFER_SIZE)
	// integer type
	int xiAPIplus_Camera::GetAcquisitionTransportBufferSizeBytes()
	{
		CheckCamHandle("GetAcquisitionTransportBufferSizeBytes");
		int val=0;
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_ACQ_TRANSPORT_BUFFER_SIZE, &val);
		CheckResult(res,"GetAcquisitionTransportBufferSizeBytes");
		return val;	
	}
	int xiAPIplus_Camera::GetAcquisitionTransportBufferSizeBytes_Maximum()
	{		
		CheckCamHandle("GetAcquisitionTransportBufferSizeBytes" "_Maximum");
		int val=0;
		CheckCamHandle("GetAcquisitionTransportBufferSizeBytes");
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_ACQ_TRANSPORT_BUFFER_SIZE XI_PRM_INFO_MAX, &val);
		CheckResult(res,"GetAcquisitionTransportBufferSizeBytes" "_Maximum");
		return val;
	}
	
	int xiAPIplus_Camera::GetAcquisitionTransportBufferSizeBytes_Minimum()
	{
		CheckCamHandle("GetAcquisitionTransportBufferSizeBytes" "_Minimum");
		int val=0;
		CheckCamHandle("GetAcquisitionTransportBufferSizeBytes");
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_ACQ_TRANSPORT_BUFFER_SIZE XI_PRM_INFO_MIN, &val);
		CheckResult(res,"GetAcquisitionTransportBufferSizeBytes" "_Minimum");
		return val;
	}

	int xiAPIplus_Camera::GetAcquisitionTransportBufferSizeBytes_Increment()
	{
		CheckCamHandle("GetAcquisitionTransportBufferSizeBytes" "_Increment");
		int val=0;
		CheckCamHandle("GetAcquisitionTransportBufferSizeBytes");
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_ACQ_TRANSPORT_BUFFER_SIZE XI_PRM_INFO_INCREMENT, &val);
		CheckResult(res,"GetAcquisitionTransportBufferSizeBytes" "_Increment");
		return val;		
	}
	
	void xiAPIplus_Camera::SetAcquisitionTransportBufferSizeBytes(int AcquisitionTransportBufferSizeBytes)
	{
		
		CheckCamHandleInt("SetAcquisitionTransportBufferSizeBytes",AcquisitionTransportBufferSizeBytes);
		
		XI_RETURN res=xiSetParamInt(camera_handle, XI_PRM_ACQ_TRANSPORT_BUFFER_SIZE, AcquisitionTransportBufferSizeBytes);
		CheckResult(res,"SetAcquisitionTransportBufferSizeBytes");
	}
	 
	
	// Acquisition transport packet size in bytes (XI_PRM_ACQ_TRANSPORT_PACKET_SIZE)
	// integer type
	int xiAPIplus_Camera::GetAcquisitionTransportPacketSizeBytes()
	{
		CheckCamHandle("GetAcquisitionTransportPacketSizeBytes");
		int val=0;
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_ACQ_TRANSPORT_PACKET_SIZE, &val);
		CheckResult(res,"GetAcquisitionTransportPacketSizeBytes");
		return val;	
	}
	int xiAPIplus_Camera::GetAcquisitionTransportPacketSizeBytes_Maximum()
	{		
		CheckCamHandle("GetAcquisitionTransportPacketSizeBytes" "_Maximum");
		int val=0;
		CheckCamHandle("GetAcquisitionTransportPacketSizeBytes");
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_ACQ_TRANSPORT_PACKET_SIZE XI_PRM_INFO_MAX, &val);
		CheckResult(res,"GetAcquisitionTransportPacketSizeBytes" "_Maximum");
		return val;
	}
	
	int xiAPIplus_Camera::GetAcquisitionTransportPacketSizeBytes_Minimum()
	{
		CheckCamHandle("GetAcquisitionTransportPacketSizeBytes" "_Minimum");
		int val=0;
		CheckCamHandle("GetAcquisitionTransportPacketSizeBytes");
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_ACQ_TRANSPORT_PACKET_SIZE XI_PRM_INFO_MIN, &val);
		CheckResult(res,"GetAcquisitionTransportPacketSizeBytes" "_Minimum");
		return val;
	}

	int xiAPIplus_Camera::GetAcquisitionTransportPacketSizeBytes_Increment()
	{
		CheckCamHandle("GetAcquisitionTransportPacketSizeBytes" "_Increment");
		int val=0;
		CheckCamHandle("GetAcquisitionTransportPacketSizeBytes");
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_ACQ_TRANSPORT_PACKET_SIZE XI_PRM_INFO_INCREMENT, &val);
		CheckResult(res,"GetAcquisitionTransportPacketSizeBytes" "_Increment");
		return val;		
	}
	
	void xiAPIplus_Camera::SetAcquisitionTransportPacketSizeBytes(int AcquisitionTransportPacketSizeBytes)
	{
		
		CheckCamHandleInt("SetAcquisitionTransportPacketSizeBytes",AcquisitionTransportPacketSizeBytes);
		
		XI_RETURN res=xiSetParamInt(camera_handle, XI_PRM_ACQ_TRANSPORT_PACKET_SIZE, AcquisitionTransportPacketSizeBytes);
		CheckResult(res,"SetAcquisitionTransportPacketSizeBytes");
	}
	 
	
	// Queue of field/frame buffers (XI_PRM_BUFFERS_QUEUE_SIZE)
	// integer type
	int xiAPIplus_Camera::GetAcquisitionQueueImagesCount()
	{
		CheckCamHandle("GetAcquisitionQueueImagesCount");
		int val=0;
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_BUFFERS_QUEUE_SIZE, &val);
		CheckResult(res,"GetAcquisitionQueueImagesCount");
		return val;	
	}
	int xiAPIplus_Camera::GetAcquisitionQueueImagesCount_Maximum()
	{		
		CheckCamHandle("GetAcquisitionQueueImagesCount" "_Maximum");
		int val=0;
		CheckCamHandle("GetAcquisitionQueueImagesCount");
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_BUFFERS_QUEUE_SIZE XI_PRM_INFO_MAX, &val);
		CheckResult(res,"GetAcquisitionQueueImagesCount" "_Maximum");
		return val;
	}
	
	int xiAPIplus_Camera::GetAcquisitionQueueImagesCount_Minimum()
	{
		CheckCamHandle("GetAcquisitionQueueImagesCount" "_Minimum");
		int val=0;
		CheckCamHandle("GetAcquisitionQueueImagesCount");
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_BUFFERS_QUEUE_SIZE XI_PRM_INFO_MIN, &val);
		CheckResult(res,"GetAcquisitionQueueImagesCount" "_Minimum");
		return val;
	}

	int xiAPIplus_Camera::GetAcquisitionQueueImagesCount_Increment()
	{
		CheckCamHandle("GetAcquisitionQueueImagesCount" "_Increment");
		int val=0;
		CheckCamHandle("GetAcquisitionQueueImagesCount");
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_BUFFERS_QUEUE_SIZE XI_PRM_INFO_INCREMENT, &val);
		CheckResult(res,"GetAcquisitionQueueImagesCount" "_Increment");
		return val;		
	}
	
	void xiAPIplus_Camera::SetAcquisitionQueueImagesCount(int AcquisitionQueueImagesCount)
	{
		
		CheckCamHandleInt("SetAcquisitionQueueImagesCount",AcquisitionQueueImagesCount);
		
		XI_RETURN res=xiSetParamInt(camera_handle, XI_PRM_BUFFERS_QUEUE_SIZE, AcquisitionQueueImagesCount);
		CheckResult(res,"SetAcquisitionQueueImagesCount");
	}
	 
	
	// Total number of buffers to be committed to transport layer. Increasing can enhance transport capacity. E.g. on USB (XI_PRM_ACQ_TRANSPORT_BUFFER_COMMIT)
	// integer type
	int xiAPIplus_Camera::GetAcquisitionTransportBufferCommit()
	{
		CheckCamHandle("GetAcquisitionTransportBufferCommit");
		int val=0;
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_ACQ_TRANSPORT_BUFFER_COMMIT, &val);
		CheckResult(res,"GetAcquisitionTransportBufferCommit");
		return val;	
	}
	int xiAPIplus_Camera::GetAcquisitionTransportBufferCommit_Maximum()
	{		
		CheckCamHandle("GetAcquisitionTransportBufferCommit" "_Maximum");
		int val=0;
		CheckCamHandle("GetAcquisitionTransportBufferCommit");
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_ACQ_TRANSPORT_BUFFER_COMMIT XI_PRM_INFO_MAX, &val);
		CheckResult(res,"GetAcquisitionTransportBufferCommit" "_Maximum");
		return val;
	}
	
	int xiAPIplus_Camera::GetAcquisitionTransportBufferCommit_Minimum()
	{
		CheckCamHandle("GetAcquisitionTransportBufferCommit" "_Minimum");
		int val=0;
		CheckCamHandle("GetAcquisitionTransportBufferCommit");
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_ACQ_TRANSPORT_BUFFER_COMMIT XI_PRM_INFO_MIN, &val);
		CheckResult(res,"GetAcquisitionTransportBufferCommit" "_Minimum");
		return val;
	}

	int xiAPIplus_Camera::GetAcquisitionTransportBufferCommit_Increment()
	{
		CheckCamHandle("GetAcquisitionTransportBufferCommit" "_Increment");
		int val=0;
		CheckCamHandle("GetAcquisitionTransportBufferCommit");
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_ACQ_TRANSPORT_BUFFER_COMMIT XI_PRM_INFO_INCREMENT, &val);
		CheckResult(res,"GetAcquisitionTransportBufferCommit" "_Increment");
		return val;		
	}
	
	void xiAPIplus_Camera::SetAcquisitionTransportBufferCommit(int AcquisitionTransportBufferCommit)
	{
		
		CheckCamHandleInt("SetAcquisitionTransportBufferCommit",AcquisitionTransportBufferCommit);
		
		XI_RETURN res=xiSetParamInt(camera_handle, XI_PRM_ACQ_TRANSPORT_BUFFER_COMMIT, AcquisitionTransportBufferCommit);
		CheckResult(res,"SetAcquisitionTransportBufferCommit");
	}
	 
	
	// GetImage returns most recent frame (XI_PRM_RECENT_FRAME)
	bool xiAPIplus_Camera::IsSelectRecentImage()
	{
		int val=0;
		
		CheckCamHandle("IsSelectRecentImage");
		
		xiGetParamInt(camera_handle, XI_PRM_RECENT_FRAME, &val);
		return (val!=0);
	}
	
	void xiAPIplus_Camera::EnableSelectRecentImage()
	{
		
		CheckCamHandle("IsSelectRecentImage");
		
		XI_RETURN res=xiSetParamInt(camera_handle, XI_PRM_RECENT_FRAME, XI_ON);
		CheckResult(res,"EnableSelectRecentImage");
	}

	void xiAPIplus_Camera::DisableSelectRecentImage()
	{
		
		CheckCamHandle("DisableSelectRecentImage");
		
		XI_RETURN res=xiSetParamInt(camera_handle, XI_PRM_RECENT_FRAME, XI_OFF);
		CheckResult(res,"DisableSelectRecentImage");
	}	
	 
	
	// Resets the camera to default state. (XI_PRM_DEVICE_RESET)
	void xiAPIplus_Camera::SetDeviceReset(int DeviceReset)
	{
		
		CheckCamHandleInt("SetDeviceReset",DeviceReset);
		
		XI_RETURN res=xiSetParamInt(camera_handle, XI_PRM_DEVICE_RESET, DeviceReset);
		CheckResult(res,"SetDeviceReset");
	}
	 
	
	// Enable/disable the Concatenated Images in One Buffer feature (XI_PRM_CONCAT_IMG_MODE)
	bool xiAPIplus_Camera::IsConcatenatedImagesMode()
	{
		int val=0;
		
		CheckCamHandle("IsConcatenatedImagesMode");
		
		xiGetParamInt(camera_handle, XI_PRM_CONCAT_IMG_MODE, &val);
		return (val!=0);
	}
	
	void xiAPIplus_Camera::EnableConcatenatedImagesMode()
	{
		
		CheckCamHandle("IsConcatenatedImagesMode");
		
		XI_RETURN res=xiSetParamInt(camera_handle, XI_PRM_CONCAT_IMG_MODE, XI_ON);
		CheckResult(res,"EnableConcatenatedImagesMode");
	}

	void xiAPIplus_Camera::DisableConcatenatedImagesMode()
	{
		
		CheckCamHandle("DisableConcatenatedImagesMode");
		
		XI_RETURN res=xiSetParamInt(camera_handle, XI_PRM_CONCAT_IMG_MODE, XI_OFF);
		CheckResult(res,"DisableConcatenatedImagesMode");
	}	
	 
	
	// Number of Concatenated Images in One Buffer (XI_PRM_CONCAT_IMG_COUNT)
	// integer type
	int xiAPIplus_Camera::GetConcatenatedImagesCount()
	{
		CheckCamHandle("GetConcatenatedImagesCount");
		int val=0;
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_CONCAT_IMG_COUNT, &val);
		CheckResult(res,"GetConcatenatedImagesCount");
		return val;	
	}
	int xiAPIplus_Camera::GetConcatenatedImagesCount_Maximum()
	{		
		CheckCamHandle("GetConcatenatedImagesCount" "_Maximum");
		int val=0;
		CheckCamHandle("GetConcatenatedImagesCount");
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_CONCAT_IMG_COUNT XI_PRM_INFO_MAX, &val);
		CheckResult(res,"GetConcatenatedImagesCount" "_Maximum");
		return val;
	}
	
	int xiAPIplus_Camera::GetConcatenatedImagesCount_Minimum()
	{
		CheckCamHandle("GetConcatenatedImagesCount" "_Minimum");
		int val=0;
		CheckCamHandle("GetConcatenatedImagesCount");
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_CONCAT_IMG_COUNT XI_PRM_INFO_MIN, &val);
		CheckResult(res,"GetConcatenatedImagesCount" "_Minimum");
		return val;
	}

	int xiAPIplus_Camera::GetConcatenatedImagesCount_Increment()
	{
		CheckCamHandle("GetConcatenatedImagesCount" "_Increment");
		int val=0;
		CheckCamHandle("GetConcatenatedImagesCount");
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_CONCAT_IMG_COUNT XI_PRM_INFO_INCREMENT, &val);
		CheckResult(res,"GetConcatenatedImagesCount" "_Increment");
		return val;		
	}
	
	void xiAPIplus_Camera::SetConcatenatedImagesCount(int ConcatenatedImagesCount)
	{
		
		CheckCamHandleInt("SetConcatenatedImagesCount",ConcatenatedImagesCount);
		
		XI_RETURN res=xiSetParamInt(camera_handle, XI_PRM_CONCAT_IMG_COUNT, ConcatenatedImagesCount);
		CheckResult(res,"SetConcatenatedImagesCount");
	}
	 
	
	// Offset between images data in transport buffer when feature Concatenated Images in One Buffer is enabled (XI_PRM_CONCAT_IMG_TRANSPORT_IMG_OFFSET)
	// integer type
	int xiAPIplus_Camera::GetConcatenatedImagesTransportImgOffset()
	{
		CheckCamHandle("GetConcatenatedImagesTransportImgOffset");
		int val=0;
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_CONCAT_IMG_TRANSPORT_IMG_OFFSET, &val);
		CheckResult(res,"GetConcatenatedImagesTransportImgOffset");
		return val;	
	}
	int xiAPIplus_Camera::GetConcatenatedImagesTransportImgOffset_Maximum()
	{		
		CheckCamHandle("GetConcatenatedImagesTransportImgOffset" "_Maximum");
		int val=0;
		CheckCamHandle("GetConcatenatedImagesTransportImgOffset");
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_CONCAT_IMG_TRANSPORT_IMG_OFFSET XI_PRM_INFO_MAX, &val);
		CheckResult(res,"GetConcatenatedImagesTransportImgOffset" "_Maximum");
		return val;
	}
	
	int xiAPIplus_Camera::GetConcatenatedImagesTransportImgOffset_Minimum()
	{
		CheckCamHandle("GetConcatenatedImagesTransportImgOffset" "_Minimum");
		int val=0;
		CheckCamHandle("GetConcatenatedImagesTransportImgOffset");
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_CONCAT_IMG_TRANSPORT_IMG_OFFSET XI_PRM_INFO_MIN, &val);
		CheckResult(res,"GetConcatenatedImagesTransportImgOffset" "_Minimum");
		return val;
	}

	int xiAPIplus_Camera::GetConcatenatedImagesTransportImgOffset_Increment()
	{
		CheckCamHandle("GetConcatenatedImagesTransportImgOffset" "_Increment");
		int val=0;
		CheckCamHandle("GetConcatenatedImagesTransportImgOffset");
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_CONCAT_IMG_TRANSPORT_IMG_OFFSET XI_PRM_INFO_INCREMENT, &val);
		CheckResult(res,"GetConcatenatedImagesTransportImgOffset" "_Increment");
		return val;		
	}
	 
	
	// Select Probe (XI_PRM_PROBE_SELECTOR)
	XI_PROBE_SELECTOR xiAPIplus_Camera::GetProbeSelector()
	{
		int val=0;
		
		CheckCamHandle("GetProbeSelector");
		
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_PROBE_SELECTOR, &val);
		CheckResult(res,"GetProbeSelector");
		return (XI_PROBE_SELECTOR)val;
	}
	
	XI_PROBE_SELECTOR xiAPIplus_Camera::GetProbeSelector_Maximum()
	{
		int val=0;
		
		CheckCamHandle("GetProbeSelector" "_Maximum");
		
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_PROBE_SELECTOR XI_PRM_INFO_MAX, &val);
		CheckResult(res,"GetProbeSelector" "_Maximum");
		return (XI_PROBE_SELECTOR)val;
	}
	
	XI_PROBE_SELECTOR xiAPIplus_Camera::GetProbeSelector_Minimum()
	{
		int val=0;
		
		CheckCamHandle("GetProbeSelector" "_Minimum");
		
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_PROBE_SELECTOR XI_PRM_INFO_MIN, &val);
		CheckResult(res,"GetProbeSelector" "_Minimum");
		return (XI_PROBE_SELECTOR)val;
	}
	
	int xiAPIplus_Camera::GetProbeSelector_Increment()
	{
		int val=0;
		
		CheckCamHandle("GetProbeSelector" "_Increment");
		
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_PROBE_SELECTOR XI_PRM_INFO_INCREMENT, &val);
		CheckResult(res,"GetProbeSelector" "_Increment");
		return val;
	}
	
	void xiAPIplus_Camera::SetProbeSelector(XI_PROBE_SELECTOR ProbeSelector)
	{
		
		CheckCamHandleInt("SetProbeSelector",(int)ProbeSelector);
		
		XI_RETURN res=xiSetParamInt(camera_handle, XI_PRM_PROBE_SELECTOR, ProbeSelector);
		CheckResult(res,"SetProbeSelector");
	}
	 
	
	// Returns Value of the selected Probe (XI_PRM_PROBE_VALUE)
	float xiAPIplus_Camera::GetProbeValue()
	{
		float val=0;
		
		CheckCamHandle("GetProbeValue");
		
		XI_RETURN res=xiGetParamFloat(camera_handle, XI_PRM_PROBE_VALUE, &val);
		CheckResult(res,"GetProbeValue");
		return val;
	}

	float xiAPIplus_Camera::GetProbeValue_Maximum()
	{
		float val=0;
		
		CheckCamHandle("GetProbeValue" "_Maximum");
		
		XI_RETURN res=xiGetParamFloat(camera_handle, XI_PRM_PROBE_VALUE XI_PRM_INFO_MAX, &val);
		CheckResult(res,"GetProbeValue" "_Maximum");
		return val;
	}

	float xiAPIplus_Camera::GetProbeValue_Minimum()
	{
		float val=0;
		
		CheckCamHandle("GetProbeValue" "_Minimum");
		
		XI_RETURN res=xiGetParamFloat(camera_handle, XI_PRM_PROBE_VALUE XI_PRM_INFO_MIN, &val);
		CheckResult(res,"GetProbeValue" "_Minimum");
		return val;
	}

	float xiAPIplus_Camera::GetProbeValue_Increment()
	{
		float val=0;
		
		CheckCamHandle("GetProbeValue" "_Increment");
		
		XI_RETURN res=xiGetParamFloat(camera_handle, XI_PRM_PROBE_VALUE XI_PRM_INFO_INCREMENT, &val);
		CheckResult(res,"GetProbeValue" "_Increment");
		return val;
	}
	

	//-------------------------------------------------------------------------------------------------------------------
	// ---- Parameter Group: Sensor Defects Correction
	//-------------------------------------------------------------------------------------------------------------------

	 
	
	// Correction of column FPN (XI_PRM_COLUMN_FPN_CORRECTION)
	XI_SWITCH xiAPIplus_Camera::GetColumnFpnCorrection()
	{
		int val=0;
		
		CheckCamHandle("GetColumnFpnCorrection");
		
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_COLUMN_FPN_CORRECTION, &val);
		CheckResult(res,"GetColumnFpnCorrection");
		return (XI_SWITCH)val;
	}
	
	XI_SWITCH xiAPIplus_Camera::GetColumnFpnCorrection_Maximum()
	{
		int val=0;
		
		CheckCamHandle("GetColumnFpnCorrection" "_Maximum");
		
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_COLUMN_FPN_CORRECTION XI_PRM_INFO_MAX, &val);
		CheckResult(res,"GetColumnFpnCorrection" "_Maximum");
		return (XI_SWITCH)val;
	}
	
	XI_SWITCH xiAPIplus_Camera::GetColumnFpnCorrection_Minimum()
	{
		int val=0;
		
		CheckCamHandle("GetColumnFpnCorrection" "_Minimum");
		
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_COLUMN_FPN_CORRECTION XI_PRM_INFO_MIN, &val);
		CheckResult(res,"GetColumnFpnCorrection" "_Minimum");
		return (XI_SWITCH)val;
	}
	
	int xiAPIplus_Camera::GetColumnFpnCorrection_Increment()
	{
		int val=0;
		
		CheckCamHandle("GetColumnFpnCorrection" "_Increment");
		
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_COLUMN_FPN_CORRECTION XI_PRM_INFO_INCREMENT, &val);
		CheckResult(res,"GetColumnFpnCorrection" "_Increment");
		return val;
	}
	
	void xiAPIplus_Camera::SetColumnFpnCorrection(XI_SWITCH ColumnFpnCorrection)
	{
		
		CheckCamHandleInt("SetColumnFpnCorrection",(int)ColumnFpnCorrection);
		
		XI_RETURN res=xiSetParamInt(camera_handle, XI_PRM_COLUMN_FPN_CORRECTION, ColumnFpnCorrection);
		CheckResult(res,"SetColumnFpnCorrection");
	}
	 
	
	// Correction of row FPN (XI_PRM_ROW_FPN_CORRECTION)
	XI_SWITCH xiAPIplus_Camera::GetRowFpnCorrection()
	{
		int val=0;
		
		CheckCamHandle("GetRowFpnCorrection");
		
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_ROW_FPN_CORRECTION, &val);
		CheckResult(res,"GetRowFpnCorrection");
		return (XI_SWITCH)val;
	}
	
	XI_SWITCH xiAPIplus_Camera::GetRowFpnCorrection_Maximum()
	{
		int val=0;
		
		CheckCamHandle("GetRowFpnCorrection" "_Maximum");
		
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_ROW_FPN_CORRECTION XI_PRM_INFO_MAX, &val);
		CheckResult(res,"GetRowFpnCorrection" "_Maximum");
		return (XI_SWITCH)val;
	}
	
	XI_SWITCH xiAPIplus_Camera::GetRowFpnCorrection_Minimum()
	{
		int val=0;
		
		CheckCamHandle("GetRowFpnCorrection" "_Minimum");
		
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_ROW_FPN_CORRECTION XI_PRM_INFO_MIN, &val);
		CheckResult(res,"GetRowFpnCorrection" "_Minimum");
		return (XI_SWITCH)val;
	}
	
	int xiAPIplus_Camera::GetRowFpnCorrection_Increment()
	{
		int val=0;
		
		CheckCamHandle("GetRowFpnCorrection" "_Increment");
		
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_ROW_FPN_CORRECTION XI_PRM_INFO_INCREMENT, &val);
		CheckResult(res,"GetRowFpnCorrection" "_Increment");
		return val;
	}
	
	void xiAPIplus_Camera::SetRowFpnCorrection(XI_SWITCH RowFpnCorrection)
	{
		
		CheckCamHandleInt("SetRowFpnCorrection",(int)RowFpnCorrection);
		
		XI_RETURN res=xiSetParamInt(camera_handle, XI_PRM_ROW_FPN_CORRECTION, RowFpnCorrection);
		CheckResult(res,"SetRowFpnCorrection");
	}
	 
	
	// Correction of column black offset (XI_PRM_COLUMN_BLACK_OFFSET_CORRECTION)
	XI_SWITCH xiAPIplus_Camera::GetColumnBlackOffsetCorrection()
	{
		int val=0;
		
		CheckCamHandle("GetColumnBlackOffsetCorrection");
		
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_COLUMN_BLACK_OFFSET_CORRECTION, &val);
		CheckResult(res,"GetColumnBlackOffsetCorrection");
		return (XI_SWITCH)val;
	}
	
	XI_SWITCH xiAPIplus_Camera::GetColumnBlackOffsetCorrection_Maximum()
	{
		int val=0;
		
		CheckCamHandle("GetColumnBlackOffsetCorrection" "_Maximum");
		
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_COLUMN_BLACK_OFFSET_CORRECTION XI_PRM_INFO_MAX, &val);
		CheckResult(res,"GetColumnBlackOffsetCorrection" "_Maximum");
		return (XI_SWITCH)val;
	}
	
	XI_SWITCH xiAPIplus_Camera::GetColumnBlackOffsetCorrection_Minimum()
	{
		int val=0;
		
		CheckCamHandle("GetColumnBlackOffsetCorrection" "_Minimum");
		
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_COLUMN_BLACK_OFFSET_CORRECTION XI_PRM_INFO_MIN, &val);
		CheckResult(res,"GetColumnBlackOffsetCorrection" "_Minimum");
		return (XI_SWITCH)val;
	}
	
	int xiAPIplus_Camera::GetColumnBlackOffsetCorrection_Increment()
	{
		int val=0;
		
		CheckCamHandle("GetColumnBlackOffsetCorrection" "_Increment");
		
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_COLUMN_BLACK_OFFSET_CORRECTION XI_PRM_INFO_INCREMENT, &val);
		CheckResult(res,"GetColumnBlackOffsetCorrection" "_Increment");
		return val;
	}
	
	void xiAPIplus_Camera::SetColumnBlackOffsetCorrection(XI_SWITCH ColumnBlackOffsetCorrection)
	{
		
		CheckCamHandleInt("SetColumnBlackOffsetCorrection",(int)ColumnBlackOffsetCorrection);
		
		XI_RETURN res=xiSetParamInt(camera_handle, XI_PRM_COLUMN_BLACK_OFFSET_CORRECTION, ColumnBlackOffsetCorrection);
		CheckResult(res,"SetColumnBlackOffsetCorrection");
	}
	 
	
	// Correction of row black offset (XI_PRM_ROW_BLACK_OFFSET_CORRECTION)
	XI_SWITCH xiAPIplus_Camera::GetRowBlackOffsetCorrection()
	{
		int val=0;
		
		CheckCamHandle("GetRowBlackOffsetCorrection");
		
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_ROW_BLACK_OFFSET_CORRECTION, &val);
		CheckResult(res,"GetRowBlackOffsetCorrection");
		return (XI_SWITCH)val;
	}
	
	XI_SWITCH xiAPIplus_Camera::GetRowBlackOffsetCorrection_Maximum()
	{
		int val=0;
		
		CheckCamHandle("GetRowBlackOffsetCorrection" "_Maximum");
		
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_ROW_BLACK_OFFSET_CORRECTION XI_PRM_INFO_MAX, &val);
		CheckResult(res,"GetRowBlackOffsetCorrection" "_Maximum");
		return (XI_SWITCH)val;
	}
	
	XI_SWITCH xiAPIplus_Camera::GetRowBlackOffsetCorrection_Minimum()
	{
		int val=0;
		
		CheckCamHandle("GetRowBlackOffsetCorrection" "_Minimum");
		
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_ROW_BLACK_OFFSET_CORRECTION XI_PRM_INFO_MIN, &val);
		CheckResult(res,"GetRowBlackOffsetCorrection" "_Minimum");
		return (XI_SWITCH)val;
	}
	
	int xiAPIplus_Camera::GetRowBlackOffsetCorrection_Increment()
	{
		int val=0;
		
		CheckCamHandle("GetRowBlackOffsetCorrection" "_Increment");
		
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_ROW_BLACK_OFFSET_CORRECTION XI_PRM_INFO_INCREMENT, &val);
		CheckResult(res,"GetRowBlackOffsetCorrection" "_Increment");
		return val;
	}
	
	void xiAPIplus_Camera::SetRowBlackOffsetCorrection(XI_SWITCH RowBlackOffsetCorrection)
	{
		
		CheckCamHandleInt("SetRowBlackOffsetCorrection",(int)RowBlackOffsetCorrection);
		
		XI_RETURN res=xiSetParamInt(camera_handle, XI_PRM_ROW_BLACK_OFFSET_CORRECTION, RowBlackOffsetCorrection);
		CheckResult(res,"SetRowBlackOffsetCorrection");
	}
	

	//-------------------------------------------------------------------------------------------------------------------
	// ---- Parameter Group: Sensor features
	//-------------------------------------------------------------------------------------------------------------------

	 
	
	// Current sensor mode. Allows to select sensor mode by one integer. Setting of this parameter affects: image dimensions and downsampling. (XI_PRM_SENSOR_MODE)
	XI_SENSOR_MODE xiAPIplus_Camera::GetSensorMode()
	{
		int val=0;
		
		CheckCamHandle("GetSensorMode");
		
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_SENSOR_MODE, &val);
		CheckResult(res,"GetSensorMode");
		return (XI_SENSOR_MODE)val;
	}
	
	XI_SENSOR_MODE xiAPIplus_Camera::GetSensorMode_Maximum()
	{
		int val=0;
		
		CheckCamHandle("GetSensorMode" "_Maximum");
		
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_SENSOR_MODE XI_PRM_INFO_MAX, &val);
		CheckResult(res,"GetSensorMode" "_Maximum");
		return (XI_SENSOR_MODE)val;
	}
	
	XI_SENSOR_MODE xiAPIplus_Camera::GetSensorMode_Minimum()
	{
		int val=0;
		
		CheckCamHandle("GetSensorMode" "_Minimum");
		
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_SENSOR_MODE XI_PRM_INFO_MIN, &val);
		CheckResult(res,"GetSensorMode" "_Minimum");
		return (XI_SENSOR_MODE)val;
	}
	
	int xiAPIplus_Camera::GetSensorMode_Increment()
	{
		int val=0;
		
		CheckCamHandle("GetSensorMode" "_Increment");
		
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_SENSOR_MODE XI_PRM_INFO_INCREMENT, &val);
		CheckResult(res,"GetSensorMode" "_Increment");
		return val;
	}
	
	void xiAPIplus_Camera::SetSensorMode(XI_SENSOR_MODE SensorMode)
	{
		
		CheckCamHandleInt("SetSensorMode",(int)SensorMode);
		
		XI_RETURN res=xiSetParamInt(camera_handle, XI_PRM_SENSOR_MODE, SensorMode);
		CheckResult(res,"SetSensorMode");
	}
	 
	
	// Enable High Dynamic Range feature. (XI_PRM_HDR)
	bool xiAPIplus_Camera::IsHDR()
	{
		int val=0;
		
		CheckCamHandle("IsHDR");
		
		xiGetParamInt(camera_handle, XI_PRM_HDR, &val);
		return (val!=0);
	}
	
	void xiAPIplus_Camera::EnableHDR()
	{
		
		CheckCamHandle("IsHDR");
		
		XI_RETURN res=xiSetParamInt(camera_handle, XI_PRM_HDR, XI_ON);
		CheckResult(res,"EnableHDR");
	}

	void xiAPIplus_Camera::DisableHDR()
	{
		
		CheckCamHandle("DisableHDR");
		
		XI_RETURN res=xiSetParamInt(camera_handle, XI_PRM_HDR, XI_OFF);
		CheckResult(res,"DisableHDR");
	}	
	 
	
	// The number of kneepoints in the PWLR. (XI_PRM_HDR_KNEEPOINT_COUNT)
	// integer type
	int xiAPIplus_Camera::GetHDR_KNEEPOINT_COUNT()
	{
		CheckCamHandle("GetHDR_KNEEPOINT_COUNT");
		int val=0;
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_HDR_KNEEPOINT_COUNT, &val);
		CheckResult(res,"GetHDR_KNEEPOINT_COUNT");
		return val;	
	}
	int xiAPIplus_Camera::GetHDR_KNEEPOINT_COUNT_Maximum()
	{		
		CheckCamHandle("GetHDR_KNEEPOINT_COUNT" "_Maximum");
		int val=0;
		CheckCamHandle("GetHDR_KNEEPOINT_COUNT");
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_HDR_KNEEPOINT_COUNT XI_PRM_INFO_MAX, &val);
		CheckResult(res,"GetHDR_KNEEPOINT_COUNT" "_Maximum");
		return val;
	}
	
	int xiAPIplus_Camera::GetHDR_KNEEPOINT_COUNT_Minimum()
	{
		CheckCamHandle("GetHDR_KNEEPOINT_COUNT" "_Minimum");
		int val=0;
		CheckCamHandle("GetHDR_KNEEPOINT_COUNT");
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_HDR_KNEEPOINT_COUNT XI_PRM_INFO_MIN, &val);
		CheckResult(res,"GetHDR_KNEEPOINT_COUNT" "_Minimum");
		return val;
	}

	int xiAPIplus_Camera::GetHDR_KNEEPOINT_COUNT_Increment()
	{
		CheckCamHandle("GetHDR_KNEEPOINT_COUNT" "_Increment");
		int val=0;
		CheckCamHandle("GetHDR_KNEEPOINT_COUNT");
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_HDR_KNEEPOINT_COUNT XI_PRM_INFO_INCREMENT, &val);
		CheckResult(res,"GetHDR_KNEEPOINT_COUNT" "_Increment");
		return val;		
	}
	
	void xiAPIplus_Camera::SetHDR_KNEEPOINT_COUNT(int HDR_KNEEPOINT_COUNT)
	{
		
		CheckCamHandleInt("SetHDR_KNEEPOINT_COUNT",HDR_KNEEPOINT_COUNT);
		
		XI_RETURN res=xiSetParamInt(camera_handle, XI_PRM_HDR_KNEEPOINT_COUNT, HDR_KNEEPOINT_COUNT);
		CheckResult(res,"SetHDR_KNEEPOINT_COUNT");
	}
	 
	
	// position of first kneepoint(in % of XI_PRM_EXPOSURE) (XI_PRM_HDR_T1)
	// integer type
	int xiAPIplus_Camera::GetHDRTimeSlope1()
	{
		CheckCamHandle("GetHDRTimeSlope1");
		int val=0;
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_HDR_T1, &val);
		CheckResult(res,"GetHDRTimeSlope1");
		return val;	
	}
	int xiAPIplus_Camera::GetHDRTimeSlope1_Maximum()
	{		
		CheckCamHandle("GetHDRTimeSlope1" "_Maximum");
		int val=0;
		CheckCamHandle("GetHDRTimeSlope1");
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_HDR_T1 XI_PRM_INFO_MAX, &val);
		CheckResult(res,"GetHDRTimeSlope1" "_Maximum");
		return val;
	}
	
	int xiAPIplus_Camera::GetHDRTimeSlope1_Minimum()
	{
		CheckCamHandle("GetHDRTimeSlope1" "_Minimum");
		int val=0;
		CheckCamHandle("GetHDRTimeSlope1");
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_HDR_T1 XI_PRM_INFO_MIN, &val);
		CheckResult(res,"GetHDRTimeSlope1" "_Minimum");
		return val;
	}

	int xiAPIplus_Camera::GetHDRTimeSlope1_Increment()
	{
		CheckCamHandle("GetHDRTimeSlope1" "_Increment");
		int val=0;
		CheckCamHandle("GetHDRTimeSlope1");
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_HDR_T1 XI_PRM_INFO_INCREMENT, &val);
		CheckResult(res,"GetHDRTimeSlope1" "_Increment");
		return val;		
	}
	
	void xiAPIplus_Camera::SetHDRTimeSlope1(int HDRTimeSlope1)
	{
		
		CheckCamHandleInt("SetHDRTimeSlope1",HDRTimeSlope1);
		
		XI_RETURN res=xiSetParamInt(camera_handle, XI_PRM_HDR_T1, HDRTimeSlope1);
		CheckResult(res,"SetHDRTimeSlope1");
	}
	 
	
	// position of second kneepoint (in % of XI_PRM_EXPOSURE) (XI_PRM_HDR_T2)
	// integer type
	int xiAPIplus_Camera::GetHDRTimeSlope2()
	{
		CheckCamHandle("GetHDRTimeSlope2");
		int val=0;
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_HDR_T2, &val);
		CheckResult(res,"GetHDRTimeSlope2");
		return val;	
	}
	int xiAPIplus_Camera::GetHDRTimeSlope2_Maximum()
	{		
		CheckCamHandle("GetHDRTimeSlope2" "_Maximum");
		int val=0;
		CheckCamHandle("GetHDRTimeSlope2");
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_HDR_T2 XI_PRM_INFO_MAX, &val);
		CheckResult(res,"GetHDRTimeSlope2" "_Maximum");
		return val;
	}
	
	int xiAPIplus_Camera::GetHDRTimeSlope2_Minimum()
	{
		CheckCamHandle("GetHDRTimeSlope2" "_Minimum");
		int val=0;
		CheckCamHandle("GetHDRTimeSlope2");
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_HDR_T2 XI_PRM_INFO_MIN, &val);
		CheckResult(res,"GetHDRTimeSlope2" "_Minimum");
		return val;
	}

	int xiAPIplus_Camera::GetHDRTimeSlope2_Increment()
	{
		CheckCamHandle("GetHDRTimeSlope2" "_Increment");
		int val=0;
		CheckCamHandle("GetHDRTimeSlope2");
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_HDR_T2 XI_PRM_INFO_INCREMENT, &val);
		CheckResult(res,"GetHDRTimeSlope2" "_Increment");
		return val;		
	}
	
	void xiAPIplus_Camera::SetHDRTimeSlope2(int HDRTimeSlope2)
	{
		
		CheckCamHandleInt("SetHDRTimeSlope2",HDRTimeSlope2);
		
		XI_RETURN res=xiSetParamInt(camera_handle, XI_PRM_HDR_T2, HDRTimeSlope2);
		CheckResult(res,"SetHDRTimeSlope2");
	}
	 
	
	// value of first kneepoint (% of sensor saturation) (XI_PRM_KNEEPOINT1)
	// integer type
	int xiAPIplus_Camera::GetHDRKnee1Percent()
	{
		CheckCamHandle("GetHDRKnee1Percent");
		int val=0;
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_KNEEPOINT1, &val);
		CheckResult(res,"GetHDRKnee1Percent");
		return val;	
	}
	int xiAPIplus_Camera::GetHDRKnee1Percent_Maximum()
	{		
		CheckCamHandle("GetHDRKnee1Percent" "_Maximum");
		int val=0;
		CheckCamHandle("GetHDRKnee1Percent");
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_KNEEPOINT1 XI_PRM_INFO_MAX, &val);
		CheckResult(res,"GetHDRKnee1Percent" "_Maximum");
		return val;
	}
	
	int xiAPIplus_Camera::GetHDRKnee1Percent_Minimum()
	{
		CheckCamHandle("GetHDRKnee1Percent" "_Minimum");
		int val=0;
		CheckCamHandle("GetHDRKnee1Percent");
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_KNEEPOINT1 XI_PRM_INFO_MIN, &val);
		CheckResult(res,"GetHDRKnee1Percent" "_Minimum");
		return val;
	}

	int xiAPIplus_Camera::GetHDRKnee1Percent_Increment()
	{
		CheckCamHandle("GetHDRKnee1Percent" "_Increment");
		int val=0;
		CheckCamHandle("GetHDRKnee1Percent");
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_KNEEPOINT1 XI_PRM_INFO_INCREMENT, &val);
		CheckResult(res,"GetHDRKnee1Percent" "_Increment");
		return val;		
	}
	
	void xiAPIplus_Camera::SetHDRKnee1Percent(int HDRKnee1Percent)
	{
		
		CheckCamHandleInt("SetHDRKnee1Percent",HDRKnee1Percent);
		
		XI_RETURN res=xiSetParamInt(camera_handle, XI_PRM_KNEEPOINT1, HDRKnee1Percent);
		CheckResult(res,"SetHDRKnee1Percent");
	}
	 
	
	// value of second kneepoint (% of sensor saturation) (XI_PRM_KNEEPOINT2)
	// integer type
	int xiAPIplus_Camera::GetHDRKnee2Percent()
	{
		CheckCamHandle("GetHDRKnee2Percent");
		int val=0;
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_KNEEPOINT2, &val);
		CheckResult(res,"GetHDRKnee2Percent");
		return val;	
	}
	int xiAPIplus_Camera::GetHDRKnee2Percent_Maximum()
	{		
		CheckCamHandle("GetHDRKnee2Percent" "_Maximum");
		int val=0;
		CheckCamHandle("GetHDRKnee2Percent");
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_KNEEPOINT2 XI_PRM_INFO_MAX, &val);
		CheckResult(res,"GetHDRKnee2Percent" "_Maximum");
		return val;
	}
	
	int xiAPIplus_Camera::GetHDRKnee2Percent_Minimum()
	{
		CheckCamHandle("GetHDRKnee2Percent" "_Minimum");
		int val=0;
		CheckCamHandle("GetHDRKnee2Percent");
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_KNEEPOINT2 XI_PRM_INFO_MIN, &val);
		CheckResult(res,"GetHDRKnee2Percent" "_Minimum");
		return val;
	}

	int xiAPIplus_Camera::GetHDRKnee2Percent_Increment()
	{
		CheckCamHandle("GetHDRKnee2Percent" "_Increment");
		int val=0;
		CheckCamHandle("GetHDRKnee2Percent");
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_KNEEPOINT2 XI_PRM_INFO_INCREMENT, &val);
		CheckResult(res,"GetHDRKnee2Percent" "_Increment");
		return val;		
	}
	
	void xiAPIplus_Camera::SetHDRKnee2Percent(int HDRKnee2Percent)
	{
		
		CheckCamHandleInt("SetHDRKnee2Percent",HDRKnee2Percent);
		
		XI_RETURN res=xiSetParamInt(camera_handle, XI_PRM_KNEEPOINT2, HDRKnee2Percent);
		CheckResult(res,"SetHDRKnee2Percent");
	}
	 
	
	// Last image black level counts (same as in XI_IMG). Setting can be used only for Offline Processing. (XI_PRM_IMAGE_BLACK_LEVEL)
	// integer type
	int xiAPIplus_Camera::GetImageBlackLevel()
	{
		CheckCamHandle("GetImageBlackLevel");
		int val=0;
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_IMAGE_BLACK_LEVEL, &val);
		CheckResult(res,"GetImageBlackLevel");
		return val;	
	}
	int xiAPIplus_Camera::GetImageBlackLevel_Maximum()
	{		
		CheckCamHandle("GetImageBlackLevel" "_Maximum");
		int val=0;
		CheckCamHandle("GetImageBlackLevel");
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_IMAGE_BLACK_LEVEL XI_PRM_INFO_MAX, &val);
		CheckResult(res,"GetImageBlackLevel" "_Maximum");
		return val;
	}
	
	int xiAPIplus_Camera::GetImageBlackLevel_Minimum()
	{
		CheckCamHandle("GetImageBlackLevel" "_Minimum");
		int val=0;
		CheckCamHandle("GetImageBlackLevel");
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_IMAGE_BLACK_LEVEL XI_PRM_INFO_MIN, &val);
		CheckResult(res,"GetImageBlackLevel" "_Minimum");
		return val;
	}

	int xiAPIplus_Camera::GetImageBlackLevel_Increment()
	{
		CheckCamHandle("GetImageBlackLevel" "_Increment");
		int val=0;
		CheckCamHandle("GetImageBlackLevel");
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_IMAGE_BLACK_LEVEL XI_PRM_INFO_INCREMENT, &val);
		CheckResult(res,"GetImageBlackLevel" "_Increment");
		return val;		
	}
	 
	
	// Defines image area of sensor as output. (XI_PRM_IMAGE_AREA)
	XI_IMAGE_AREA_SELECTOR xiAPIplus_Camera::GetImageArea()
	{
		int val=0;
		
		CheckCamHandle("GetImageArea");
		
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_IMAGE_AREA, &val);
		CheckResult(res,"GetImageArea");
		return (XI_IMAGE_AREA_SELECTOR)val;
	}
	
	XI_IMAGE_AREA_SELECTOR xiAPIplus_Camera::GetImageArea_Maximum()
	{
		int val=0;
		
		CheckCamHandle("GetImageArea" "_Maximum");
		
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_IMAGE_AREA XI_PRM_INFO_MAX, &val);
		CheckResult(res,"GetImageArea" "_Maximum");
		return (XI_IMAGE_AREA_SELECTOR)val;
	}
	
	XI_IMAGE_AREA_SELECTOR xiAPIplus_Camera::GetImageArea_Minimum()
	{
		int val=0;
		
		CheckCamHandle("GetImageArea" "_Minimum");
		
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_IMAGE_AREA XI_PRM_INFO_MIN, &val);
		CheckResult(res,"GetImageArea" "_Minimum");
		return (XI_IMAGE_AREA_SELECTOR)val;
	}
	
	int xiAPIplus_Camera::GetImageArea_Increment()
	{
		int val=0;
		
		CheckCamHandle("GetImageArea" "_Increment");
		
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_IMAGE_AREA XI_PRM_INFO_INCREMENT, &val);
		CheckResult(res,"GetImageArea" "_Increment");
		return val;
	}
	
	void xiAPIplus_Camera::SetImageArea(XI_IMAGE_AREA_SELECTOR ImageArea)
	{
		
		CheckCamHandleInt("SetImageArea",(int)ImageArea);
		
		XI_RETURN res=xiSetParamInt(camera_handle, XI_PRM_IMAGE_AREA, ImageArea);
		CheckResult(res,"SetImageArea");
	}
	 
	
	// Sets DualADC Mode (XI_PRM_DUAL_ADC_MODE)
	XI_DUAL_ADC_MODE xiAPIplus_Camera::GetDualADCMode()
	{
		int val=0;
		
		CheckCamHandle("GetDualADCMode");
		
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_DUAL_ADC_MODE, &val);
		CheckResult(res,"GetDualADCMode");
		return (XI_DUAL_ADC_MODE)val;
	}
	
	XI_DUAL_ADC_MODE xiAPIplus_Camera::GetDualADCMode_Maximum()
	{
		int val=0;
		
		CheckCamHandle("GetDualADCMode" "_Maximum");
		
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_DUAL_ADC_MODE XI_PRM_INFO_MAX, &val);
		CheckResult(res,"GetDualADCMode" "_Maximum");
		return (XI_DUAL_ADC_MODE)val;
	}
	
	XI_DUAL_ADC_MODE xiAPIplus_Camera::GetDualADCMode_Minimum()
	{
		int val=0;
		
		CheckCamHandle("GetDualADCMode" "_Minimum");
		
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_DUAL_ADC_MODE XI_PRM_INFO_MIN, &val);
		CheckResult(res,"GetDualADCMode" "_Minimum");
		return (XI_DUAL_ADC_MODE)val;
	}
	
	int xiAPIplus_Camera::GetDualADCMode_Increment()
	{
		int val=0;
		
		CheckCamHandle("GetDualADCMode" "_Increment");
		
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_DUAL_ADC_MODE XI_PRM_INFO_INCREMENT, &val);
		CheckResult(res,"GetDualADCMode" "_Increment");
		return val;
	}
	
	void xiAPIplus_Camera::SetDualADCMode(XI_DUAL_ADC_MODE DualADCMode)
	{
		
		CheckCamHandleInt("SetDualADCMode",(int)DualADCMode);
		
		XI_RETURN res=xiSetParamInt(camera_handle, XI_PRM_DUAL_ADC_MODE, DualADCMode);
		CheckResult(res,"SetDualADCMode");
	}
	 
	
	// Sets DualADC Gain Ratio in dB (XI_PRM_DUAL_ADC_GAIN_RATIO)
	float xiAPIplus_Camera::GetDualADCGainRatio()
	{
		float val=0;
		
		CheckCamHandle("GetDualADCGainRatio");
		
		XI_RETURN res=xiGetParamFloat(camera_handle, XI_PRM_DUAL_ADC_GAIN_RATIO, &val);
		CheckResult(res,"GetDualADCGainRatio");
		return val;
	}

	float xiAPIplus_Camera::GetDualADCGainRatio_Maximum()
	{
		float val=0;
		
		CheckCamHandle("GetDualADCGainRatio" "_Maximum");
		
		XI_RETURN res=xiGetParamFloat(camera_handle, XI_PRM_DUAL_ADC_GAIN_RATIO XI_PRM_INFO_MAX, &val);
		CheckResult(res,"GetDualADCGainRatio" "_Maximum");
		return val;
	}

	float xiAPIplus_Camera::GetDualADCGainRatio_Minimum()
	{
		float val=0;
		
		CheckCamHandle("GetDualADCGainRatio" "_Minimum");
		
		XI_RETURN res=xiGetParamFloat(camera_handle, XI_PRM_DUAL_ADC_GAIN_RATIO XI_PRM_INFO_MIN, &val);
		CheckResult(res,"GetDualADCGainRatio" "_Minimum");
		return val;
	}

	float xiAPIplus_Camera::GetDualADCGainRatio_Increment()
	{
		float val=0;
		
		CheckCamHandle("GetDualADCGainRatio" "_Increment");
		
		XI_RETURN res=xiGetParamFloat(camera_handle, XI_PRM_DUAL_ADC_GAIN_RATIO XI_PRM_INFO_INCREMENT, &val);
		CheckResult(res,"GetDualADCGainRatio" "_Increment");
		return val;
	}
	
	void xiAPIplus_Camera::SetDualADCGainRatio(float DualADCGainRatio)
	{
		
		CheckCamHandle("SetDualADCGainRatio");
		
		XI_RETURN res=xiSetParamFloat(camera_handle, XI_PRM_DUAL_ADC_GAIN_RATIO, DualADCGainRatio);
		CheckResult(res,"SetDualADCGainRatio");
	}
	 
	
	// Sets DualADC Threshold value (XI_PRM_DUAL_ADC_THRESHOLD)
	// integer type
	int xiAPIplus_Camera::GetDualADCThreshold()
	{
		CheckCamHandle("GetDualADCThreshold");
		int val=0;
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_DUAL_ADC_THRESHOLD, &val);
		CheckResult(res,"GetDualADCThreshold");
		return val;	
	}
	int xiAPIplus_Camera::GetDualADCThreshold_Maximum()
	{		
		CheckCamHandle("GetDualADCThreshold" "_Maximum");
		int val=0;
		CheckCamHandle("GetDualADCThreshold");
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_DUAL_ADC_THRESHOLD XI_PRM_INFO_MAX, &val);
		CheckResult(res,"GetDualADCThreshold" "_Maximum");
		return val;
	}
	
	int xiAPIplus_Camera::GetDualADCThreshold_Minimum()
	{
		CheckCamHandle("GetDualADCThreshold" "_Minimum");
		int val=0;
		CheckCamHandle("GetDualADCThreshold");
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_DUAL_ADC_THRESHOLD XI_PRM_INFO_MIN, &val);
		CheckResult(res,"GetDualADCThreshold" "_Minimum");
		return val;
	}

	int xiAPIplus_Camera::GetDualADCThreshold_Increment()
	{
		CheckCamHandle("GetDualADCThreshold" "_Increment");
		int val=0;
		CheckCamHandle("GetDualADCThreshold");
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_DUAL_ADC_THRESHOLD XI_PRM_INFO_INCREMENT, &val);
		CheckResult(res,"GetDualADCThreshold" "_Increment");
		return val;		
	}
	
	void xiAPIplus_Camera::SetDualADCThreshold(int DualADCThreshold)
	{
		
		CheckCamHandleInt("SetDualADCThreshold",DualADCThreshold);
		
		XI_RETURN res=xiSetParamInt(camera_handle, XI_PRM_DUAL_ADC_THRESHOLD, DualADCThreshold);
		CheckResult(res,"SetDualADCThreshold");
	}
	 
	
	// Sets Compression Region Selector (XI_PRM_COMPRESSION_REGION_SELECTOR)
	// integer type
	int xiAPIplus_Camera::GetCompressionRegionSelector()
	{
		CheckCamHandle("GetCompressionRegionSelector");
		int val=0;
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_COMPRESSION_REGION_SELECTOR, &val);
		CheckResult(res,"GetCompressionRegionSelector");
		return val;	
	}
	int xiAPIplus_Camera::GetCompressionRegionSelector_Maximum()
	{		
		CheckCamHandle("GetCompressionRegionSelector" "_Maximum");
		int val=0;
		CheckCamHandle("GetCompressionRegionSelector");
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_COMPRESSION_REGION_SELECTOR XI_PRM_INFO_MAX, &val);
		CheckResult(res,"GetCompressionRegionSelector" "_Maximum");
		return val;
	}
	
	int xiAPIplus_Camera::GetCompressionRegionSelector_Minimum()
	{
		CheckCamHandle("GetCompressionRegionSelector" "_Minimum");
		int val=0;
		CheckCamHandle("GetCompressionRegionSelector");
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_COMPRESSION_REGION_SELECTOR XI_PRM_INFO_MIN, &val);
		CheckResult(res,"GetCompressionRegionSelector" "_Minimum");
		return val;
	}

	int xiAPIplus_Camera::GetCompressionRegionSelector_Increment()
	{
		CheckCamHandle("GetCompressionRegionSelector" "_Increment");
		int val=0;
		CheckCamHandle("GetCompressionRegionSelector");
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_COMPRESSION_REGION_SELECTOR XI_PRM_INFO_INCREMENT, &val);
		CheckResult(res,"GetCompressionRegionSelector" "_Increment");
		return val;		
	}
	
	void xiAPIplus_Camera::SetCompressionRegionSelector(int CompressionRegionSelector)
	{
		
		CheckCamHandleInt("SetCompressionRegionSelector",CompressionRegionSelector);
		
		XI_RETURN res=xiSetParamInt(camera_handle, XI_PRM_COMPRESSION_REGION_SELECTOR, CompressionRegionSelector);
		CheckResult(res,"SetCompressionRegionSelector");
	}
	 
	
	// Sets Compression Region Start (XI_PRM_COMPRESSION_REGION_START)
	float xiAPIplus_Camera::GetCompressionRegionStart()
	{
		float val=0;
		
		CheckCamHandle("GetCompressionRegionStart");
		
		XI_RETURN res=xiGetParamFloat(camera_handle, XI_PRM_COMPRESSION_REGION_START, &val);
		CheckResult(res,"GetCompressionRegionStart");
		return val;
	}

	float xiAPIplus_Camera::GetCompressionRegionStart_Maximum()
	{
		float val=0;
		
		CheckCamHandle("GetCompressionRegionStart" "_Maximum");
		
		XI_RETURN res=xiGetParamFloat(camera_handle, XI_PRM_COMPRESSION_REGION_START XI_PRM_INFO_MAX, &val);
		CheckResult(res,"GetCompressionRegionStart" "_Maximum");
		return val;
	}

	float xiAPIplus_Camera::GetCompressionRegionStart_Minimum()
	{
		float val=0;
		
		CheckCamHandle("GetCompressionRegionStart" "_Minimum");
		
		XI_RETURN res=xiGetParamFloat(camera_handle, XI_PRM_COMPRESSION_REGION_START XI_PRM_INFO_MIN, &val);
		CheckResult(res,"GetCompressionRegionStart" "_Minimum");
		return val;
	}

	float xiAPIplus_Camera::GetCompressionRegionStart_Increment()
	{
		float val=0;
		
		CheckCamHandle("GetCompressionRegionStart" "_Increment");
		
		XI_RETURN res=xiGetParamFloat(camera_handle, XI_PRM_COMPRESSION_REGION_START XI_PRM_INFO_INCREMENT, &val);
		CheckResult(res,"GetCompressionRegionStart" "_Increment");
		return val;
	}
	
	void xiAPIplus_Camera::SetCompressionRegionStart(float CompressionRegionStart)
	{
		
		CheckCamHandle("SetCompressionRegionStart");
		
		XI_RETURN res=xiSetParamFloat(camera_handle, XI_PRM_COMPRESSION_REGION_START, CompressionRegionStart);
		CheckResult(res,"SetCompressionRegionStart");
	}
	 
	
	// Sets Compression Region Gain (XI_PRM_COMPRESSION_REGION_GAIN)
	float xiAPIplus_Camera::GetCompressionRegionGain()
	{
		float val=0;
		
		CheckCamHandle("GetCompressionRegionGain");
		
		XI_RETURN res=xiGetParamFloat(camera_handle, XI_PRM_COMPRESSION_REGION_GAIN, &val);
		CheckResult(res,"GetCompressionRegionGain");
		return val;
	}

	float xiAPIplus_Camera::GetCompressionRegionGain_Maximum()
	{
		float val=0;
		
		CheckCamHandle("GetCompressionRegionGain" "_Maximum");
		
		XI_RETURN res=xiGetParamFloat(camera_handle, XI_PRM_COMPRESSION_REGION_GAIN XI_PRM_INFO_MAX, &val);
		CheckResult(res,"GetCompressionRegionGain" "_Maximum");
		return val;
	}

	float xiAPIplus_Camera::GetCompressionRegionGain_Minimum()
	{
		float val=0;
		
		CheckCamHandle("GetCompressionRegionGain" "_Minimum");
		
		XI_RETURN res=xiGetParamFloat(camera_handle, XI_PRM_COMPRESSION_REGION_GAIN XI_PRM_INFO_MIN, &val);
		CheckResult(res,"GetCompressionRegionGain" "_Minimum");
		return val;
	}

	float xiAPIplus_Camera::GetCompressionRegionGain_Increment()
	{
		float val=0;
		
		CheckCamHandle("GetCompressionRegionGain" "_Increment");
		
		XI_RETURN res=xiGetParamFloat(camera_handle, XI_PRM_COMPRESSION_REGION_GAIN XI_PRM_INFO_INCREMENT, &val);
		CheckResult(res,"GetCompressionRegionGain" "_Increment");
		return val;
	}
	
	void xiAPIplus_Camera::SetCompressionRegionGain(float CompressionRegionGain)
	{
		
		CheckCamHandle("SetCompressionRegionGain");
		
		XI_RETURN res=xiSetParamFloat(camera_handle, XI_PRM_COMPRESSION_REGION_GAIN, CompressionRegionGain);
		CheckResult(res,"SetCompressionRegionGain");
	}
	

	//-------------------------------------------------------------------------------------------------------------------
	// ---- Parameter Group: Version info
	//-------------------------------------------------------------------------------------------------------------------

	 
	
	// Selects module/unit, which version we get. (XI_PRM_VERSION_SELECTOR)
	XI_VERSION xiAPIplus_Camera::GetVersionSelector()
	{
		int val=0;
		
		CheckCamHandle("GetVersionSelector");
		
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_VERSION_SELECTOR, &val);
		CheckResult(res,"GetVersionSelector");
		return (XI_VERSION)val;
	}
	
	XI_VERSION xiAPIplus_Camera::GetVersionSelector_Maximum()
	{
		int val=0;
		
		CheckCamHandle("GetVersionSelector" "_Maximum");
		
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_VERSION_SELECTOR XI_PRM_INFO_MAX, &val);
		CheckResult(res,"GetVersionSelector" "_Maximum");
		return (XI_VERSION)val;
	}
	
	XI_VERSION xiAPIplus_Camera::GetVersionSelector_Minimum()
	{
		int val=0;
		
		CheckCamHandle("GetVersionSelector" "_Minimum");
		
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_VERSION_SELECTOR XI_PRM_INFO_MIN, &val);
		CheckResult(res,"GetVersionSelector" "_Minimum");
		return (XI_VERSION)val;
	}
	
	int xiAPIplus_Camera::GetVersionSelector_Increment()
	{
		int val=0;
		
		CheckCamHandle("GetVersionSelector" "_Increment");
		
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_VERSION_SELECTOR XI_PRM_INFO_INCREMENT, &val);
		CheckResult(res,"GetVersionSelector" "_Increment");
		return val;
	}
	
	void xiAPIplus_Camera::SetVersionSelector(XI_VERSION VersionSelector)
	{
		
		CheckCamHandleInt("SetVersionSelector",(int)VersionSelector);
		
		XI_RETURN res=xiSetParamInt(camera_handle, XI_PRM_VERSION_SELECTOR, VersionSelector);
		CheckResult(res,"SetVersionSelector");
	}
	 
	
	// Returns version of selected module/unit(XI_PRM_VERSION_SELECTOR). (XI_PRM_VERSION)
	void xiAPIplus_Camera::GetVersion(char* buffer, int buffer_length)
	{
		
		CheckCamHandle("GetVersion");
		
		XI_RETURN res=xiGetParamString(camera_handle, XI_PRM_VERSION, buffer, buffer_length);
		CheckResult(res,"GetVersion");
	}
	 
	
	// Returns version of API. (XI_PRM_API_VERSION)
	void xiAPIplus_Camera::GetVersionAPI(char* buffer, int buffer_length)
	{
		
		CheckCamHandle("GetVersionAPI");
		
		XI_RETURN res=xiGetParamString(camera_handle, XI_PRM_API_VERSION, buffer, buffer_length);
		CheckResult(res,"GetVersionAPI");
	}
	 
	
	// Returns version of current device driver. (XI_PRM_DRV_VERSION)
	void xiAPIplus_Camera::GetVersionDriver(char* buffer, int buffer_length)
	{
		
		CheckCamHandle("GetVersionDriver");
		
		XI_RETURN res=xiGetParamString(camera_handle, XI_PRM_DRV_VERSION, buffer, buffer_length);
		CheckResult(res,"GetVersionDriver");
	}
	 
	
	// Returns version of MCU1 firmware. (XI_PRM_MCU1_VERSION)
	void xiAPIplus_Camera::GetVersionMCU1(char* buffer, int buffer_length)
	{
		
		CheckCamHandle("GetVersionMCU1");
		
		XI_RETURN res=xiGetParamString(camera_handle, XI_PRM_MCU1_VERSION, buffer, buffer_length);
		CheckResult(res,"GetVersionMCU1");
	}
	 
	
	// Returns version of MCU2 firmware. (XI_PRM_MCU2_VERSION)
	void xiAPIplus_Camera::GetVersionMCU2(char* buffer, int buffer_length)
	{
		
		CheckCamHandle("GetVersionMCU2");
		
		XI_RETURN res=xiGetParamString(camera_handle, XI_PRM_MCU2_VERSION, buffer, buffer_length);
		CheckResult(res,"GetVersionMCU2");
	}
	 
	
	// Returns version of MCU3 firmware. (XI_PRM_MCU3_VERSION)
	void xiAPIplus_Camera::GetVersionMCU3(char* buffer, int buffer_length)
	{
		
		CheckCamHandle("GetVersionMCU3");
		
		XI_RETURN res=xiGetParamString(camera_handle, XI_PRM_MCU3_VERSION, buffer, buffer_length);
		CheckResult(res,"GetVersionMCU3");
	}
	 
	
	// Returns version of FPGA firmware currently running. (XI_PRM_FPGA1_VERSION)
	void xiAPIplus_Camera::GetVersionFPGA1(char* buffer, int buffer_length)
	{
		
		CheckCamHandle("GetVersionFPGA1");
		
		XI_RETURN res=xiGetParamString(camera_handle, XI_PRM_FPGA1_VERSION, buffer, buffer_length);
		CheckResult(res,"GetVersionFPGA1");
	}
	 
	
	// Returns version of XML manifest. (XI_PRM_XMLMAN_VERSION)
	void xiAPIplus_Camera::GetVersionXMLMAN(char* buffer, int buffer_length)
	{
		
		CheckCamHandle("GetVersionXMLMAN");
		
		XI_RETURN res=xiGetParamString(camera_handle, XI_PRM_XMLMAN_VERSION, buffer, buffer_length);
		CheckResult(res,"GetVersionXMLMAN");
	}
	 
	
	// Returns hardware revision number. (XI_PRM_HW_REVISION)
	void xiAPIplus_Camera::GetHWRevision(char* buffer, int buffer_length)
	{
		
		CheckCamHandle("GetHWRevision");
		
		XI_RETURN res=xiGetParamString(camera_handle, XI_PRM_HW_REVISION, buffer, buffer_length);
		CheckResult(res,"GetHWRevision");
	}
	 
	
	// Returns version of factory set. (XI_PRM_FACTORY_SET_VERSION)
	void xiAPIplus_Camera::GetVersionFactSet(char* buffer, int buffer_length)
	{
		
		CheckCamHandle("GetVersionFactSet");
		
		XI_RETURN res=xiGetParamString(camera_handle, XI_PRM_FACTORY_SET_VERSION, buffer, buffer_length);
		CheckResult(res,"GetVersionFactSet");
	}
	

	//-------------------------------------------------------------------------------------------------------------------
	// ---- Parameter Group: API features
	//-------------------------------------------------------------------------------------------------------------------

	 
	
	// Set debug level (XI_PRM_DEBUG_LEVEL)
	XI_DEBUG_LEVEL xiAPIplus_Camera::GetDebugLevel()
	{
		int val=0;
		
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_DEBUG_LEVEL, &val);
		CheckResult(res,"GetDebugLevel");
		return (XI_DEBUG_LEVEL)val;
	}
	
	XI_DEBUG_LEVEL xiAPIplus_Camera::GetDebugLevel_Maximum()
	{
		int val=0;
		
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_DEBUG_LEVEL XI_PRM_INFO_MAX, &val);
		CheckResult(res,"GetDebugLevel" "_Maximum");
		return (XI_DEBUG_LEVEL)val;
	}
	
	XI_DEBUG_LEVEL xiAPIplus_Camera::GetDebugLevel_Minimum()
	{
		int val=0;
		
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_DEBUG_LEVEL XI_PRM_INFO_MIN, &val);
		CheckResult(res,"GetDebugLevel" "_Minimum");
		return (XI_DEBUG_LEVEL)val;
	}
	
	int xiAPIplus_Camera::GetDebugLevel_Increment()
	{
		int val=0;
		
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_DEBUG_LEVEL XI_PRM_INFO_INCREMENT, &val);
		CheckResult(res,"GetDebugLevel" "_Increment");
		return val;
	}
	
	void xiAPIplus_Camera::SetDebugLevel(XI_DEBUG_LEVEL DebugLevel)
	{
		
		XI_RETURN res=xiSetParamInt(camera_handle, XI_PRM_DEBUG_LEVEL, DebugLevel);
		CheckResult(res,"SetDebugLevel");
	}
	 
	
	// Automatic bandwidth calculation, (XI_PRM_AUTO_BANDWIDTH_CALCULATION)
	bool xiAPIplus_Camera::IsAutoBandwidthCalculation()
	{
		int val=0;
		
		xiGetParamInt(camera_handle, XI_PRM_AUTO_BANDWIDTH_CALCULATION, &val);
		return (val!=0);
	}
	
	void xiAPIplus_Camera::EnableAutoBandwidthCalculation()
	{
		
		XI_RETURN res=xiSetParamInt(camera_handle, XI_PRM_AUTO_BANDWIDTH_CALCULATION, XI_ON);
		CheckResult(res,"EnableAutoBandwidthCalculation");
	}

	void xiAPIplus_Camera::DisableAutoBandwidthCalculation()
	{
		
		XI_RETURN res=xiSetParamInt(camera_handle, XI_PRM_AUTO_BANDWIDTH_CALCULATION, XI_OFF);
		CheckResult(res,"DisableAutoBandwidthCalculation");
	}	
	 
	
	// Enables (2015/FAPI) processing chain for MQ MU cameras. If disabled - legacy processing 2006 is used. (XI_PRM_NEW_PROCESS_CHAIN_ENABLE)
	bool xiAPIplus_Camera::IsNewProcessChainEnable()
	{
		int val=0;
		
		xiGetParamInt(camera_handle, XI_PRM_NEW_PROCESS_CHAIN_ENABLE, &val);
		return (val!=0);
	}
	
	void xiAPIplus_Camera::EnableNewProcessChainEnable()
	{
		
		XI_RETURN res=xiSetParamInt(camera_handle, XI_PRM_NEW_PROCESS_CHAIN_ENABLE, XI_ON);
		CheckResult(res,"EnableNewProcessChainEnable");
	}

	void xiAPIplus_Camera::DisableNewProcessChainEnable()
	{
		
		XI_RETURN res=xiSetParamInt(camera_handle, XI_PRM_NEW_PROCESS_CHAIN_ENABLE, XI_OFF);
		CheckResult(res,"DisableNewProcessChainEnable");
	}	
	 
	
	// Number of threads per image processor (XI_PRM_PROC_NUM_THREADS)
	// integer type
	int xiAPIplus_Camera::GetProcessorNumberThreads()
	{
		
		int val=0;
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_PROC_NUM_THREADS, &val);
		CheckResult(res,"GetProcessorNumberThreads");
		return val;	
	}
	int xiAPIplus_Camera::GetProcessorNumberThreads_Maximum()
	{		
		
		int val=0;
		
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_PROC_NUM_THREADS XI_PRM_INFO_MAX, &val);
		CheckResult(res,"GetProcessorNumberThreads" "_Maximum");
		return val;
	}
	
	int xiAPIplus_Camera::GetProcessorNumberThreads_Minimum()
	{
		
		int val=0;
		
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_PROC_NUM_THREADS XI_PRM_INFO_MIN, &val);
		CheckResult(res,"GetProcessorNumberThreads" "_Minimum");
		return val;
	}

	int xiAPIplus_Camera::GetProcessorNumberThreads_Increment()
	{
		
		int val=0;
		
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_PROC_NUM_THREADS XI_PRM_INFO_INCREMENT, &val);
		CheckResult(res,"GetProcessorNumberThreads" "_Increment");
		return val;		
	}
	
	void xiAPIplus_Camera::SetProcessorNumberThreads(int ProcessorNumberThreads)
	{
		
		XI_RETURN res=xiSetParamInt(camera_handle, XI_PRM_PROC_NUM_THREADS, ProcessorNumberThreads);
		CheckResult(res,"SetProcessorNumberThreads");
	}
	

	//-------------------------------------------------------------------------------------------------------------------
	// ---- Parameter Group: Camera FFS
	//-------------------------------------------------------------------------------------------------------------------

	 
	
	// Read file from camera flash filesystem. (XI_PRM_READ_FILE_FFS)
	void xiAPIplus_Camera::GetReadFileFFS(char* buffer, int buffer_length)
	{
		
		XI_RETURN res=xiGetParamString(camera_handle, XI_PRM_READ_FILE_FFS, buffer, buffer_length);
		CheckResult(res,"GetReadFileFFS");
	}
	 
	
	// Write file to camera flash filesystem. (XI_PRM_WRITE_FILE_FFS)
	void xiAPIplus_Camera::GetWriteFileFFS(char* buffer, int buffer_length)
	{
		
		XI_RETURN res=xiGetParamString(camera_handle, XI_PRM_WRITE_FILE_FFS, buffer, buffer_length);
		CheckResult(res,"GetWriteFileFFS");
	}
	
	void xiAPIplus_Camera::SetWriteFileFFS(char* new_value)
	{
		
		XI_RETURN res=xiSetParamString(camera_handle, XI_PRM_WRITE_FILE_FFS, new_value, (DWORD)strlen(new_value));
		CheckResult(res,"SetWriteFileFFS");
	}
	 
	
	// Set name of file to be written/read from camera FFS. (XI_PRM_FFS_FILE_NAME)
	void xiAPIplus_Camera::GetFFSFileName(char* buffer, int buffer_length)
	{
		
		XI_RETURN res=xiGetParamString(camera_handle, XI_PRM_FFS_FILE_NAME, buffer, buffer_length);
		CheckResult(res,"GetFFSFileName");
	}
	
	void xiAPIplus_Camera::SetFFSFileName(char* new_value)
	{
		
		XI_RETURN res=xiSetParamString(camera_handle, XI_PRM_FFS_FILE_NAME, new_value, (DWORD)strlen(new_value));
		CheckResult(res,"SetFFSFileName");
	}
	 
	
	// File number. (XI_PRM_FFS_FILE_ID)
	// integer type
	int xiAPIplus_Camera::GetFFSFileId()
	{
		
		int val=0;
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_FFS_FILE_ID, &val);
		CheckResult(res,"GetFFSFileId");
		return val;	
	}
	int xiAPIplus_Camera::GetFFSFileId_Maximum()
	{		
		
		int val=0;
		
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_FFS_FILE_ID XI_PRM_INFO_MAX, &val);
		CheckResult(res,"GetFFSFileId" "_Maximum");
		return val;
	}
	
	int xiAPIplus_Camera::GetFFSFileId_Minimum()
	{
		
		int val=0;
		
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_FFS_FILE_ID XI_PRM_INFO_MIN, &val);
		CheckResult(res,"GetFFSFileId" "_Minimum");
		return val;
	}

	int xiAPIplus_Camera::GetFFSFileId_Increment()
	{
		
		int val=0;
		
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_FFS_FILE_ID XI_PRM_INFO_INCREMENT, &val);
		CheckResult(res,"GetFFSFileId" "_Increment");
		return val;		
	}
	 
	
	// Size of file. (XI_PRM_FFS_FILE_SIZE)
	// integer type
	int xiAPIplus_Camera::GetFFSFileSize()
	{
		
		int val=0;
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_FFS_FILE_SIZE, &val);
		CheckResult(res,"GetFFSFileSize");
		return val;	
	}
	int xiAPIplus_Camera::GetFFSFileSize_Maximum()
	{		
		
		int val=0;
		
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_FFS_FILE_SIZE XI_PRM_INFO_MAX, &val);
		CheckResult(res,"GetFFSFileSize" "_Maximum");
		return val;
	}
	
	int xiAPIplus_Camera::GetFFSFileSize_Minimum()
	{
		
		int val=0;
		
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_FFS_FILE_SIZE XI_PRM_INFO_MIN, &val);
		CheckResult(res,"GetFFSFileSize" "_Minimum");
		return val;
	}

	int xiAPIplus_Camera::GetFFSFileSize_Increment()
	{
		
		int val=0;
		
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_FFS_FILE_SIZE XI_PRM_INFO_INCREMENT, &val);
		CheckResult(res,"GetFFSFileSize" "_Increment");
		return val;		
	}
	 
	
	// Size of free camera FFS. (XI_PRM_FREE_FFS_SIZE)
	// integer type
	uint64_t xiAPIplus_Camera::GetFreeFFSSize()
	{
		
		uint64_t val=0;
		DWORD size = sizeof(val);
		XI_PRM_TYPE type = xiTypeInteger64;		
		XI_RETURN res=xiGetParam(camera_handle, XI_PRM_FREE_FFS_SIZE, &val, &size, &type);
		CheckResult(res,"GetFreeFFSSize");
		return val;	
	}
	uint64_t xiAPIplus_Camera::GetFreeFFSSize_Maximum()
	{		
		
		uint64_t val=0;
		DWORD size = sizeof(val);
		XI_PRM_TYPE type = xiTypeInteger64;
		XI_RETURN res=xiGetParam(camera_handle, XI_PRM_FREE_FFS_SIZE XI_PRM_INFO_MAX, &val, &size, &type);
		CheckResult(res,"GetFreeFFSSize" "_Maximum");
		return val;
	}
	
	uint64_t xiAPIplus_Camera::GetFreeFFSSize_Minimum()
	{
		
		uint64_t val=0;
		DWORD size = sizeof(val);
		XI_PRM_TYPE type = xiTypeInteger64;
		XI_RETURN res=xiGetParam(camera_handle, XI_PRM_FREE_FFS_SIZE XI_PRM_INFO_MIN, &val, &size, &type);
		CheckResult(res,"GetFreeFFSSize" "_Minimum");
		return val;
	}

	uint64_t xiAPIplus_Camera::GetFreeFFSSize_Increment()
	{
		
		uint64_t val=0;
		DWORD size = sizeof(val);
		XI_PRM_TYPE type = xiTypeInteger64;
		XI_RETURN res=xiGetParam(camera_handle, XI_PRM_FREE_FFS_SIZE XI_PRM_INFO_INCREMENT, &val, &size, &type);
		CheckResult(res,"GetFreeFFSSize" "_Increment");
		return val;		
	}
	 
	
	// Size of used camera FFS. (XI_PRM_USED_FFS_SIZE)
	// integer type
	uint64_t xiAPIplus_Camera::GetUsedFFSSize()
	{
		
		uint64_t val=0;
		DWORD size = sizeof(val);
		XI_PRM_TYPE type = xiTypeInteger64;		
		XI_RETURN res=xiGetParam(camera_handle, XI_PRM_USED_FFS_SIZE, &val, &size, &type);
		CheckResult(res,"GetUsedFFSSize");
		return val;	
	}
	uint64_t xiAPIplus_Camera::GetUsedFFSSize_Maximum()
	{		
		
		uint64_t val=0;
		DWORD size = sizeof(val);
		XI_PRM_TYPE type = xiTypeInteger64;
		XI_RETURN res=xiGetParam(camera_handle, XI_PRM_USED_FFS_SIZE XI_PRM_INFO_MAX, &val, &size, &type);
		CheckResult(res,"GetUsedFFSSize" "_Maximum");
		return val;
	}
	
	uint64_t xiAPIplus_Camera::GetUsedFFSSize_Minimum()
	{
		
		uint64_t val=0;
		DWORD size = sizeof(val);
		XI_PRM_TYPE type = xiTypeInteger64;
		XI_RETURN res=xiGetParam(camera_handle, XI_PRM_USED_FFS_SIZE XI_PRM_INFO_MIN, &val, &size, &type);
		CheckResult(res,"GetUsedFFSSize" "_Minimum");
		return val;
	}

	uint64_t xiAPIplus_Camera::GetUsedFFSSize_Increment()
	{
		
		uint64_t val=0;
		DWORD size = sizeof(val);
		XI_PRM_TYPE type = xiTypeInteger64;
		XI_RETURN res=xiGetParam(camera_handle, XI_PRM_USED_FFS_SIZE XI_PRM_INFO_INCREMENT, &val, &size, &type);
		CheckResult(res,"GetUsedFFSSize" "_Increment");
		return val;		
	}
	 
	
	// Setting of key enables file operations on some cameras. (XI_PRM_FFS_ACCESS_KEY)
	// integer type
	int xiAPIplus_Camera::GetFFSAccessKey()
	{
		CheckCamHandle("GetFFSAccessKey");
		int val=0;
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_FFS_ACCESS_KEY, &val);
		CheckResult(res,"GetFFSAccessKey");
		return val;	
	}
	int xiAPIplus_Camera::GetFFSAccessKey_Maximum()
	{		
		CheckCamHandle("GetFFSAccessKey" "_Maximum");
		int val=0;
		CheckCamHandle("GetFFSAccessKey");
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_FFS_ACCESS_KEY XI_PRM_INFO_MAX, &val);
		CheckResult(res,"GetFFSAccessKey" "_Maximum");
		return val;
	}
	
	int xiAPIplus_Camera::GetFFSAccessKey_Minimum()
	{
		CheckCamHandle("GetFFSAccessKey" "_Minimum");
		int val=0;
		CheckCamHandle("GetFFSAccessKey");
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_FFS_ACCESS_KEY XI_PRM_INFO_MIN, &val);
		CheckResult(res,"GetFFSAccessKey" "_Minimum");
		return val;
	}

	int xiAPIplus_Camera::GetFFSAccessKey_Increment()
	{
		CheckCamHandle("GetFFSAccessKey" "_Increment");
		int val=0;
		CheckCamHandle("GetFFSAccessKey");
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_FFS_ACCESS_KEY XI_PRM_INFO_INCREMENT, &val);
		CheckResult(res,"GetFFSAccessKey" "_Increment");
		return val;		
	}
	
	void xiAPIplus_Camera::SetFFSAccessKey(int FFSAccessKey)
	{
		
		CheckCamHandleInt("SetFFSAccessKey",FFSAccessKey);
		
		XI_RETURN res=xiSetParamInt(camera_handle, XI_PRM_FFS_ACCESS_KEY, FFSAccessKey);
		CheckResult(res,"SetFFSAccessKey");
	}
	

	//-------------------------------------------------------------------------------------------------------------------
	// ---- Parameter Group: APIContextControl
	//-------------------------------------------------------------------------------------------------------------------

	 
	
	// List of current parameters settings context - parameters with values. Used for offline processing. (XI_PRM_API_CONTEXT_LIST)
	void xiAPIplus_Camera::GetApiContextList(char* buffer, int buffer_length)
	{
		
		XI_RETURN res=xiGetParamString(camera_handle, XI_PRM_API_CONTEXT_LIST, buffer, buffer_length);
		CheckResult(res,"GetApiContextList");
	}
	
	void xiAPIplus_Camera::SetApiContextList(char* new_value)
	{
		
		XI_RETURN res=xiSetParamString(camera_handle, XI_PRM_API_CONTEXT_LIST, new_value, (DWORD)strlen(new_value));
		CheckResult(res,"SetApiContextList");
	}
	

	//-------------------------------------------------------------------------------------------------------------------
	// ---- Parameter Group: Sensor Control
	//-------------------------------------------------------------------------------------------------------------------

	 
	
	// Selects the current feature which is accessible by XI_PRM_SENSOR_FEATURE_VALUE. (XI_PRM_SENSOR_FEATURE_SELECTOR)
	XI_SENSOR_FEATURE_SELECTOR xiAPIplus_Camera::GetSensorFeatureSelector()
	{
		int val=0;
		
		CheckCamHandle("GetSensorFeatureSelector");
		
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_SENSOR_FEATURE_SELECTOR, &val);
		CheckResult(res,"GetSensorFeatureSelector");
		return (XI_SENSOR_FEATURE_SELECTOR)val;
	}
	
	XI_SENSOR_FEATURE_SELECTOR xiAPIplus_Camera::GetSensorFeatureSelector_Maximum()
	{
		int val=0;
		
		CheckCamHandle("GetSensorFeatureSelector" "_Maximum");
		
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_SENSOR_FEATURE_SELECTOR XI_PRM_INFO_MAX, &val);
		CheckResult(res,"GetSensorFeatureSelector" "_Maximum");
		return (XI_SENSOR_FEATURE_SELECTOR)val;
	}
	
	XI_SENSOR_FEATURE_SELECTOR xiAPIplus_Camera::GetSensorFeatureSelector_Minimum()
	{
		int val=0;
		
		CheckCamHandle("GetSensorFeatureSelector" "_Minimum");
		
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_SENSOR_FEATURE_SELECTOR XI_PRM_INFO_MIN, &val);
		CheckResult(res,"GetSensorFeatureSelector" "_Minimum");
		return (XI_SENSOR_FEATURE_SELECTOR)val;
	}
	
	int xiAPIplus_Camera::GetSensorFeatureSelector_Increment()
	{
		int val=0;
		
		CheckCamHandle("GetSensorFeatureSelector" "_Increment");
		
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_SENSOR_FEATURE_SELECTOR XI_PRM_INFO_INCREMENT, &val);
		CheckResult(res,"GetSensorFeatureSelector" "_Increment");
		return val;
	}
	
	void xiAPIplus_Camera::SetSensorFeatureSelector(XI_SENSOR_FEATURE_SELECTOR SensorFeatureSelector)
	{
		
		CheckCamHandleInt("SetSensorFeatureSelector",(int)SensorFeatureSelector);
		
		XI_RETURN res=xiSetParamInt(camera_handle, XI_PRM_SENSOR_FEATURE_SELECTOR, SensorFeatureSelector);
		CheckResult(res,"SetSensorFeatureSelector");
	}
	 
	
	// Allows access to sensor feature value currently selected by XI_PRM_SENSOR_FEATURE_SELECTOR. (XI_PRM_SENSOR_FEATURE_VALUE)
	// integer type
	int xiAPIplus_Camera::GetSensorFeatureValue()
	{
		CheckCamHandle("GetSensorFeatureValue");
		int val=0;
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_SENSOR_FEATURE_VALUE, &val);
		CheckResult(res,"GetSensorFeatureValue");
		return val;	
	}
	int xiAPIplus_Camera::GetSensorFeatureValue_Maximum()
	{		
		CheckCamHandle("GetSensorFeatureValue" "_Maximum");
		int val=0;
		CheckCamHandle("GetSensorFeatureValue");
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_SENSOR_FEATURE_VALUE XI_PRM_INFO_MAX, &val);
		CheckResult(res,"GetSensorFeatureValue" "_Maximum");
		return val;
	}
	
	int xiAPIplus_Camera::GetSensorFeatureValue_Minimum()
	{
		CheckCamHandle("GetSensorFeatureValue" "_Minimum");
		int val=0;
		CheckCamHandle("GetSensorFeatureValue");
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_SENSOR_FEATURE_VALUE XI_PRM_INFO_MIN, &val);
		CheckResult(res,"GetSensorFeatureValue" "_Minimum");
		return val;
	}

	int xiAPIplus_Camera::GetSensorFeatureValue_Increment()
	{
		CheckCamHandle("GetSensorFeatureValue" "_Increment");
		int val=0;
		CheckCamHandle("GetSensorFeatureValue");
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_SENSOR_FEATURE_VALUE XI_PRM_INFO_INCREMENT, &val);
		CheckResult(res,"GetSensorFeatureValue" "_Increment");
		return val;		
	}
	
	void xiAPIplus_Camera::SetSensorFeatureValue(int SensorFeatureValue)
	{
		
		CheckCamHandleInt("SetSensorFeatureValue",SensorFeatureValue);
		
		XI_RETURN res=xiSetParamInt(camera_handle, XI_PRM_SENSOR_FEATURE_VALUE, SensorFeatureValue);
		CheckResult(res,"SetSensorFeatureValue");
	}
	

	//-------------------------------------------------------------------------------------------------------------------
	// ---- Parameter Group: Extended Features
	//-------------------------------------------------------------------------------------------------------------------

	 
	
	// Selects the internal acquisition signal to read using XI_PRM_ACQUISITION_STATUS. (XI_PRM_ACQUISITION_STATUS_SELECTOR)
	XI_ACQUISITION_STATUS_SELECTOR xiAPIplus_Camera::GetAcquisitionStatusSelector()
	{
		int val=0;
		
		CheckCamHandle("GetAcquisitionStatusSelector");
		
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_ACQUISITION_STATUS_SELECTOR, &val);
		CheckResult(res,"GetAcquisitionStatusSelector");
		return (XI_ACQUISITION_STATUS_SELECTOR)val;
	}
	
	XI_ACQUISITION_STATUS_SELECTOR xiAPIplus_Camera::GetAcquisitionStatusSelector_Maximum()
	{
		int val=0;
		
		CheckCamHandle("GetAcquisitionStatusSelector" "_Maximum");
		
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_ACQUISITION_STATUS_SELECTOR XI_PRM_INFO_MAX, &val);
		CheckResult(res,"GetAcquisitionStatusSelector" "_Maximum");
		return (XI_ACQUISITION_STATUS_SELECTOR)val;
	}
	
	XI_ACQUISITION_STATUS_SELECTOR xiAPIplus_Camera::GetAcquisitionStatusSelector_Minimum()
	{
		int val=0;
		
		CheckCamHandle("GetAcquisitionStatusSelector" "_Minimum");
		
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_ACQUISITION_STATUS_SELECTOR XI_PRM_INFO_MIN, &val);
		CheckResult(res,"GetAcquisitionStatusSelector" "_Minimum");
		return (XI_ACQUISITION_STATUS_SELECTOR)val;
	}
	
	int xiAPIplus_Camera::GetAcquisitionStatusSelector_Increment()
	{
		int val=0;
		
		CheckCamHandle("GetAcquisitionStatusSelector" "_Increment");
		
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_ACQUISITION_STATUS_SELECTOR XI_PRM_INFO_INCREMENT, &val);
		CheckResult(res,"GetAcquisitionStatusSelector" "_Increment");
		return val;
	}
	
	void xiAPIplus_Camera::SetAcquisitionStatusSelector(XI_ACQUISITION_STATUS_SELECTOR AcquisitionStatusSelector)
	{
		
		CheckCamHandleInt("SetAcquisitionStatusSelector",(int)AcquisitionStatusSelector);
		
		XI_RETURN res=xiSetParamInt(camera_handle, XI_PRM_ACQUISITION_STATUS_SELECTOR, AcquisitionStatusSelector);
		CheckResult(res,"SetAcquisitionStatusSelector");
	}
	 
	
	// Acquisition status(True/False) (XI_PRM_ACQUISITION_STATUS)
	XI_SWITCH xiAPIplus_Camera::GetAcquisitionStatus()
	{
		int val=0;
		
		CheckCamHandle("GetAcquisitionStatus");
		
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_ACQUISITION_STATUS, &val);
		CheckResult(res,"GetAcquisitionStatus");
		return (XI_SWITCH)val;
	}
	
	XI_SWITCH xiAPIplus_Camera::GetAcquisitionStatus_Maximum()
	{
		int val=0;
		
		CheckCamHandle("GetAcquisitionStatus" "_Maximum");
		
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_ACQUISITION_STATUS XI_PRM_INFO_MAX, &val);
		CheckResult(res,"GetAcquisitionStatus" "_Maximum");
		return (XI_SWITCH)val;
	}
	
	XI_SWITCH xiAPIplus_Camera::GetAcquisitionStatus_Minimum()
	{
		int val=0;
		
		CheckCamHandle("GetAcquisitionStatus" "_Minimum");
		
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_ACQUISITION_STATUS XI_PRM_INFO_MIN, &val);
		CheckResult(res,"GetAcquisitionStatus" "_Minimum");
		return (XI_SWITCH)val;
	}
	
	int xiAPIplus_Camera::GetAcquisitionStatus_Increment()
	{
		int val=0;
		
		CheckCamHandle("GetAcquisitionStatus" "_Increment");
		
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_ACQUISITION_STATUS XI_PRM_INFO_INCREMENT, &val);
		CheckResult(res,"GetAcquisitionStatus" "_Increment");
		return val;
	}
	 
	
	// Data Pipe Unit Selector. (XI_PRM_DP_UNIT_SELECTOR)
	XI_DP_UNIT_SELECTOR xiAPIplus_Camera::GetDataPipeUnitSelector()
	{
		int val=0;
		
		CheckCamHandle("GetDataPipeUnitSelector");
		
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_DP_UNIT_SELECTOR, &val);
		CheckResult(res,"GetDataPipeUnitSelector");
		return (XI_DP_UNIT_SELECTOR)val;
	}
	
	XI_DP_UNIT_SELECTOR xiAPIplus_Camera::GetDataPipeUnitSelector_Maximum()
	{
		int val=0;
		
		CheckCamHandle("GetDataPipeUnitSelector" "_Maximum");
		
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_DP_UNIT_SELECTOR XI_PRM_INFO_MAX, &val);
		CheckResult(res,"GetDataPipeUnitSelector" "_Maximum");
		return (XI_DP_UNIT_SELECTOR)val;
	}
	
	XI_DP_UNIT_SELECTOR xiAPIplus_Camera::GetDataPipeUnitSelector_Minimum()
	{
		int val=0;
		
		CheckCamHandle("GetDataPipeUnitSelector" "_Minimum");
		
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_DP_UNIT_SELECTOR XI_PRM_INFO_MIN, &val);
		CheckResult(res,"GetDataPipeUnitSelector" "_Minimum");
		return (XI_DP_UNIT_SELECTOR)val;
	}
	
	int xiAPIplus_Camera::GetDataPipeUnitSelector_Increment()
	{
		int val=0;
		
		CheckCamHandle("GetDataPipeUnitSelector" "_Increment");
		
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_DP_UNIT_SELECTOR XI_PRM_INFO_INCREMENT, &val);
		CheckResult(res,"GetDataPipeUnitSelector" "_Increment");
		return val;
	}
	
	void xiAPIplus_Camera::SetDataPipeUnitSelector(XI_DP_UNIT_SELECTOR DataPipeUnitSelector)
	{
		
		CheckCamHandleInt("SetDataPipeUnitSelector",(int)DataPipeUnitSelector);
		
		XI_RETURN res=xiSetParamInt(camera_handle, XI_PRM_DP_UNIT_SELECTOR, DataPipeUnitSelector);
		CheckResult(res,"SetDataPipeUnitSelector");
	}
	 
	
	// Data Pipe Processor Selector. (XI_PRM_DP_PROC_SELECTOR)
	XI_DP_PROC_SELECTOR xiAPIplus_Camera::GetDataPipeProcSelector()
	{
		int val=0;
		
		CheckCamHandle("GetDataPipeProcSelector");
		
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_DP_PROC_SELECTOR, &val);
		CheckResult(res,"GetDataPipeProcSelector");
		return (XI_DP_PROC_SELECTOR)val;
	}
	
	XI_DP_PROC_SELECTOR xiAPIplus_Camera::GetDataPipeProcSelector_Maximum()
	{
		int val=0;
		
		CheckCamHandle("GetDataPipeProcSelector" "_Maximum");
		
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_DP_PROC_SELECTOR XI_PRM_INFO_MAX, &val);
		CheckResult(res,"GetDataPipeProcSelector" "_Maximum");
		return (XI_DP_PROC_SELECTOR)val;
	}
	
	XI_DP_PROC_SELECTOR xiAPIplus_Camera::GetDataPipeProcSelector_Minimum()
	{
		int val=0;
		
		CheckCamHandle("GetDataPipeProcSelector" "_Minimum");
		
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_DP_PROC_SELECTOR XI_PRM_INFO_MIN, &val);
		CheckResult(res,"GetDataPipeProcSelector" "_Minimum");
		return (XI_DP_PROC_SELECTOR)val;
	}
	
	int xiAPIplus_Camera::GetDataPipeProcSelector_Increment()
	{
		int val=0;
		
		CheckCamHandle("GetDataPipeProcSelector" "_Increment");
		
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_DP_PROC_SELECTOR XI_PRM_INFO_INCREMENT, &val);
		CheckResult(res,"GetDataPipeProcSelector" "_Increment");
		return val;
	}
	
	void xiAPIplus_Camera::SetDataPipeProcSelector(XI_DP_PROC_SELECTOR DataPipeProcSelector)
	{
		
		CheckCamHandleInt("SetDataPipeProcSelector",(int)DataPipeProcSelector);
		
		XI_RETURN res=xiSetParamInt(camera_handle, XI_PRM_DP_PROC_SELECTOR, DataPipeProcSelector);
		CheckResult(res,"SetDataPipeProcSelector");
	}
	 
	
	// Data Pipe Processor parameter Selector. (XI_PRM_DP_PARAM_SELECTOR)
	XI_DP_PARAM_SELECTOR xiAPIplus_Camera::GetDataPipeParamSelector()
	{
		int val=0;
		
		CheckCamHandle("GetDataPipeParamSelector");
		
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_DP_PARAM_SELECTOR, &val);
		CheckResult(res,"GetDataPipeParamSelector");
		return (XI_DP_PARAM_SELECTOR)val;
	}
	
	XI_DP_PARAM_SELECTOR xiAPIplus_Camera::GetDataPipeParamSelector_Maximum()
	{
		int val=0;
		
		CheckCamHandle("GetDataPipeParamSelector" "_Maximum");
		
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_DP_PARAM_SELECTOR XI_PRM_INFO_MAX, &val);
		CheckResult(res,"GetDataPipeParamSelector" "_Maximum");
		return (XI_DP_PARAM_SELECTOR)val;
	}
	
	XI_DP_PARAM_SELECTOR xiAPIplus_Camera::GetDataPipeParamSelector_Minimum()
	{
		int val=0;
		
		CheckCamHandle("GetDataPipeParamSelector" "_Minimum");
		
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_DP_PARAM_SELECTOR XI_PRM_INFO_MIN, &val);
		CheckResult(res,"GetDataPipeParamSelector" "_Minimum");
		return (XI_DP_PARAM_SELECTOR)val;
	}
	
	int xiAPIplus_Camera::GetDataPipeParamSelector_Increment()
	{
		int val=0;
		
		CheckCamHandle("GetDataPipeParamSelector" "_Increment");
		
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_DP_PARAM_SELECTOR XI_PRM_INFO_INCREMENT, &val);
		CheckResult(res,"GetDataPipeParamSelector" "_Increment");
		return val;
	}
	
	void xiAPIplus_Camera::SetDataPipeParamSelector(XI_DP_PARAM_SELECTOR DataPipeParamSelector)
	{
		
		CheckCamHandleInt("SetDataPipeParamSelector",(int)DataPipeParamSelector);
		
		XI_RETURN res=xiSetParamInt(camera_handle, XI_PRM_DP_PARAM_SELECTOR, DataPipeParamSelector);
		CheckResult(res,"SetDataPipeParamSelector");
	}
	 
	
	// Data Pipe processor parameter value (XI_PRM_DP_PARAM_VALUE)
	float xiAPIplus_Camera::GetDataPipeParamValue()
	{
		float val=0;
		
		CheckCamHandle("GetDataPipeParamValue");
		
		XI_RETURN res=xiGetParamFloat(camera_handle, XI_PRM_DP_PARAM_VALUE, &val);
		CheckResult(res,"GetDataPipeParamValue");
		return val;
	}

	float xiAPIplus_Camera::GetDataPipeParamValue_Maximum()
	{
		float val=0;
		
		CheckCamHandle("GetDataPipeParamValue" "_Maximum");
		
		XI_RETURN res=xiGetParamFloat(camera_handle, XI_PRM_DP_PARAM_VALUE XI_PRM_INFO_MAX, &val);
		CheckResult(res,"GetDataPipeParamValue" "_Maximum");
		return val;
	}

	float xiAPIplus_Camera::GetDataPipeParamValue_Minimum()
	{
		float val=0;
		
		CheckCamHandle("GetDataPipeParamValue" "_Minimum");
		
		XI_RETURN res=xiGetParamFloat(camera_handle, XI_PRM_DP_PARAM_VALUE XI_PRM_INFO_MIN, &val);
		CheckResult(res,"GetDataPipeParamValue" "_Minimum");
		return val;
	}

	float xiAPIplus_Camera::GetDataPipeParamValue_Increment()
	{
		float val=0;
		
		CheckCamHandle("GetDataPipeParamValue" "_Increment");
		
		XI_RETURN res=xiGetParamFloat(camera_handle, XI_PRM_DP_PARAM_VALUE XI_PRM_INFO_INCREMENT, &val);
		CheckResult(res,"GetDataPipeParamValue" "_Increment");
		return val;
	}
	
	void xiAPIplus_Camera::SetDataPipeParamValue(float DataPipeParamValue)
	{
		
		CheckCamHandle("SetDataPipeParamValue");
		
		XI_RETURN res=xiSetParamFloat(camera_handle, XI_PRM_DP_PARAM_VALUE, DataPipeParamValue);
		CheckResult(res,"SetDataPipeParamValue");
	}
	 
	
	// Enable or disable low level streaming via GenTL. (XI_PRM_GENTL_DATASTREAM_ENABLED)
	bool xiAPIplus_Camera::IsGenTLStreamEn()
	{
		int val=0;
		
		xiGetParamInt(camera_handle, XI_PRM_GENTL_DATASTREAM_ENABLED, &val);
		return (val!=0);
	}
	
	void xiAPIplus_Camera::EnableGenTLStreamEn()
	{
		
		XI_RETURN res=xiSetParamInt(camera_handle, XI_PRM_GENTL_DATASTREAM_ENABLED, XI_ON);
		CheckResult(res,"EnableGenTLStreamEn");
	}

	void xiAPIplus_Camera::DisableGenTLStreamEn()
	{
		
		XI_RETURN res=xiSetParamInt(camera_handle, XI_PRM_GENTL_DATASTREAM_ENABLED, XI_OFF);
		CheckResult(res,"DisableGenTLStreamEn");
	}	
	 
	
	// Get GenTL stream context pointer for low level streaming (XI_PRM_GENTL_DATASTREAM_CONTEXT)
	void xiAPIplus_Camera::GetGenTLStreamContext(char* buffer, int buffer_length)
	{
		
		XI_RETURN res=xiGetParamString(camera_handle, XI_PRM_GENTL_DATASTREAM_CONTEXT, buffer, buffer_length);
		CheckResult(res,"GetGenTLStreamContext");
	}
	

	//-------------------------------------------------------------------------------------------------------------------
	// ---- Parameter Group: User Set Control
	//-------------------------------------------------------------------------------------------------------------------

	 
	
	// Selects the feature User Set to load, save or configure. (XI_PRM_USER_SET_SELECTOR)
	XI_USER_SET_SELECTOR xiAPIplus_Camera::GetUserSetSelector()
	{
		int val=0;
		
		CheckCamHandle("GetUserSetSelector");
		
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_USER_SET_SELECTOR, &val);
		CheckResult(res,"GetUserSetSelector");
		return (XI_USER_SET_SELECTOR)val;
	}
	
	XI_USER_SET_SELECTOR xiAPIplus_Camera::GetUserSetSelector_Maximum()
	{
		int val=0;
		
		CheckCamHandle("GetUserSetSelector" "_Maximum");
		
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_USER_SET_SELECTOR XI_PRM_INFO_MAX, &val);
		CheckResult(res,"GetUserSetSelector" "_Maximum");
		return (XI_USER_SET_SELECTOR)val;
	}
	
	XI_USER_SET_SELECTOR xiAPIplus_Camera::GetUserSetSelector_Minimum()
	{
		int val=0;
		
		CheckCamHandle("GetUserSetSelector" "_Minimum");
		
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_USER_SET_SELECTOR XI_PRM_INFO_MIN, &val);
		CheckResult(res,"GetUserSetSelector" "_Minimum");
		return (XI_USER_SET_SELECTOR)val;
	}
	
	int xiAPIplus_Camera::GetUserSetSelector_Increment()
	{
		int val=0;
		
		CheckCamHandle("GetUserSetSelector" "_Increment");
		
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_USER_SET_SELECTOR XI_PRM_INFO_INCREMENT, &val);
		CheckResult(res,"GetUserSetSelector" "_Increment");
		return val;
	}
	
	void xiAPIplus_Camera::SetUserSetSelector(XI_USER_SET_SELECTOR UserSetSelector)
	{
		
		CheckCamHandleInt("SetUserSetSelector",(int)UserSetSelector);
		
		XI_RETURN res=xiSetParamInt(camera_handle, XI_PRM_USER_SET_SELECTOR, UserSetSelector);
		CheckResult(res,"SetUserSetSelector");
	}
	 
	
	// Loads the User Set specified by User Set Selector to the device and makes it active. (XI_PRM_USER_SET_LOAD)
	void xiAPIplus_Camera::SetUserSetLoad(int UserSetLoad)
	{
		
		CheckCamHandleInt("SetUserSetLoad",UserSetLoad);
		
		XI_RETURN res=xiSetParamInt(camera_handle, XI_PRM_USER_SET_LOAD, UserSetLoad);
		CheckResult(res,"SetUserSetLoad");
	}
	 
	
	// Selects the feature User Set to load and make active by default when the device is reset. Change might affect default mode in other applications, e.g. CamTool. (XI_PRM_USER_SET_DEFAULT)
	XI_USER_SET_SELECTOR xiAPIplus_Camera::GetUserSetDefault()
	{
		int val=0;
		
		CheckCamHandle("GetUserSetDefault");
		
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_USER_SET_DEFAULT, &val);
		CheckResult(res,"GetUserSetDefault");
		return (XI_USER_SET_SELECTOR)val;
	}
	
	XI_USER_SET_SELECTOR xiAPIplus_Camera::GetUserSetDefault_Maximum()
	{
		int val=0;
		
		CheckCamHandle("GetUserSetDefault" "_Maximum");
		
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_USER_SET_DEFAULT XI_PRM_INFO_MAX, &val);
		CheckResult(res,"GetUserSetDefault" "_Maximum");
		return (XI_USER_SET_SELECTOR)val;
	}
	
	XI_USER_SET_SELECTOR xiAPIplus_Camera::GetUserSetDefault_Minimum()
	{
		int val=0;
		
		CheckCamHandle("GetUserSetDefault" "_Minimum");
		
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_USER_SET_DEFAULT XI_PRM_INFO_MIN, &val);
		CheckResult(res,"GetUserSetDefault" "_Minimum");
		return (XI_USER_SET_SELECTOR)val;
	}
	
	int xiAPIplus_Camera::GetUserSetDefault_Increment()
	{
		int val=0;
		
		CheckCamHandle("GetUserSetDefault" "_Increment");
		
		XI_RETURN res=xiGetParamInt(camera_handle, XI_PRM_USER_SET_DEFAULT XI_PRM_INFO_INCREMENT, &val);
		CheckResult(res,"GetUserSetDefault" "_Increment");
		return val;
	}
	
	void xiAPIplus_Camera::SetUserSetDefault(XI_USER_SET_SELECTOR UserSetDefault)
	{
		
		CheckCamHandleInt("SetUserSetDefault",(int)UserSetDefault);
		
		XI_RETURN res=xiSetParamInt(camera_handle, XI_PRM_USER_SET_DEFAULT, UserSetDefault);
		CheckResult(res,"SetUserSetDefault");
	}
	


//-------------------------------------------------------------------------------------------------------------------
// Error codes xiApi
struct xiapi_errorcode_t
{
	XI_RETURN code;
	const char*     descr;
};

xiapi_errorcode_t xiAPIplus_errorcodes_list[]=
{
	XI_OK                             ,  "Function call succeeded",
		XI_INVALID_HANDLE                 ,  "Invalid handle",
		XI_READREG                        ,  "Register read error",
		XI_WRITEREG                       ,  "Register write error",
		XI_FREE_RESOURCES                 ,  "Freeing resources error",
		XI_FREE_CHANNEL                   ,  "Freeing channel error",
		XI_FREE_BANDWIDTH                 ,  "Freeing bandwith error",
		XI_READBLK                        ,  "Read block error",
		XI_WRITEBLK                       ,  "Write block error",
		XI_NO_IMAGE                       ,  "No image",
		XI_TIMEOUT                        ,  "Timeout",
		XI_INVALID_ARG                    ,  "Invalid arguments supplied",
		XI_NOT_SUPPORTED                  ,  "Not supported",
		XI_ISOCH_ATTACH_BUFFERS           ,  "Attach buffers error",
		XI_GET_OVERLAPPED_RESULT          ,  "Overlapped result",
		XI_MEMORY_ALLOCATION              ,  "Memory allocation error",
		XI_DLLCONTEXTISNULL               ,  "DLL context is NULL",
		XI_DLLCONTEXTISNONZERO            ,  "DLL context is non zero",
		XI_DLLCONTEXTEXIST                ,  "DLL context exists",
		XI_TOOMANYDEVICES                 ,  "Too many devices connected",
		XI_ERRORCAMCONTEXT                ,  "Camera context error",
		XI_UNKNOWN_HARDWARE               ,  "Unknown hardware",
		XI_INVALID_TM_FILE                ,  "Invalid TM file",
		XI_INVALID_TM_TAG                 ,  "Invalid TM tag",
		XI_INCOMPLETE_TM                  ,  "Incomplete TM",
		XI_BUS_RESET_FAILED               ,  "Bus reset error",
		XI_NOT_IMPLEMENTED                ,  "Not implemented",
		XI_SHADING_TOOBRIGHT              ,  "Shading is too bright",
		XI_SHADING_TOODARK                ,  "Shading is too dark",
		XI_TOO_LOW_GAIN                   ,  "Gain is too low",
		XI_INVALID_BPL                    ,  "Invalid sensor defect correction list",
		XI_BPL_REALLOC                    ,  "Error while sensor defect correction list reallocation",
		XI_INVALID_PIXEL_LIST             ,  "Invalid pixel list",
		XI_INVALID_FFS                    ,  "Invalid Flash File System",
		XI_INVALID_PROFILE                ,  "Invalid profile",
		XI_INVALID_CALIBRATION            ,  "Invalid calibration",
		XI_INVALID_BUFFER                 ,  "Invalid buffer",
		XI_INVALID_DATA                   ,  "Invalid data",
		XI_TGBUSY                         ,  "Timing generator is busy",
		XI_IO_WRONG                       ,  "Wrong operation open/write/read/close",
		XI_ACQUISITION_ALREADY_UP         ,  "Acquisition already started",
		XI_OLD_DRIVER_VERSION             ,  "Old version of device driver installed to the system.",
		XI_GET_LAST_ERROR                 ,  "To get error code please call GetLastError function.",
		XI_CANT_PROCESS                   ,  "Data cannot be processed",
		XI_ACQUISITION_STOPED             ,  "Acquisition is stopped. It needs to be started to perform operation.",
		XI_ACQUISITION_STOPED_WERR        ,  "Acquisition has been stopped with an error.",
		XI_INVALID_INPUT_ICC_PROFILE      ,  "Input ICC profile missing or corrupted",
		XI_INVALID_OUTPUT_ICC_PROFILE     ,  "Output ICC profile missing or corrupted",
		XI_DEVICE_NOT_READY               ,  "Device not ready to operate",
		XI_SHADING_TOOCONTRAST            ,  "Shading is too contrast",
		XI_ALREADY_INITIALIZED            ,  "Module already initialized",
		XI_NOT_ENOUGH_PRIVILEGES          ,  "Application does not have enough privileges (one or more app)",
		XI_NOT_COMPATIBLE_DRIVER          ,  "Installed driver is not compatible with current software",
		XI_TM_INVALID_RESOURCE            ,  "TM file was not loaded successfully from resources",
		XI_DEVICE_HAS_BEEN_RESETED        ,  "Device has been reset, abnormal initial state",
		XI_NO_DEVICES_FOUND               ,  "No Devices Found",
		XI_RESOURCE_OR_FUNCTION_LOCKED    ,  "Resource (device) or function locked by mutex",
		XI_BUFFER_SIZE_TOO_SMALL          ,  "Buffer provided by user is too small",
		XI_COULDNT_INIT_PROCESSOR         ,  "Could not initialize processor.",
		XI_NOT_INITIALIZED                ,  "The object/module/procedure/process being referred to has not been started.",
		XI_RESOURCE_NOT_FOUND             ,  "Resource not found(could be processor, file, item...).",
		XI_UNKNOWN_PARAM                  ,  "Unknown parameter",
		XI_WRONG_PARAM_VALUE              ,  "Wrong parameter value",
		XI_WRONG_PARAM_TYPE               ,  "Wrong parameter type",
		XI_WRONG_PARAM_SIZE               ,  "Wrong parameter size",
		XI_BUFFER_TOO_SMALL               ,  "Input buffer is too small",
		XI_NOT_SUPPORTED_PARAM            ,  "Parameter is not supported",
		XI_NOT_SUPPORTED_PARAM_INFO       ,  "Parameter info not supported",
		XI_NOT_SUPPORTED_DATA_FORMAT      ,  "Data format is not supported",
		XI_READ_ONLY_PARAM                ,  "Read only parameter",
		XI_BANDWIDTH_NOT_SUPPORTED        ,  "This camera does not support currently available bandwidth",
		XI_INVALID_FFS_FILE_NAME          ,  "FFS file selector is invalid or NULL",
		XI_FFS_FILE_NOT_FOUND             ,  "FFS file not found",
		XI_PARAM_NOT_SETTABLE             ,  "Parameter value cannot be set (might be out of range or invalid).",
		XI_SAFE_POLICY_NOT_SUPPORTED      ,  "Safe buffer policy is not supported. E.g. when transport target is set to GPU (GPUDirect).",
		XI_GPUDIRECT_NOT_AVAILABLE        ,  "GPUDirect is not available. E.g. platform isn't supported or CUDA toolkit isn't installed.",
		XI_INCORRECT_SENS_ID_CHECK        ,  "Incorrect sensor board unique identifier checksum.",
		XI_INCORRECT_FPGA_TYPE            ,  "Incorrect or unknown FPGA firmware type used for camera.",
		XI_PARAM_CONDITIONALLY_NOT_AVAILABLE,  "Parameter is not available in current context. Available only if another feature is turned on.",
		XI_ERR_FRAME_BUFFER_RAM_INIT      ,  "Frame buffer RAM initialization error.",
		XI_NOT_SUPPORTED_WHILE_ACQUISITION ,  "Parameter is not supported while acquisition is running.",
		XI_PROC_OTHER_ERROR               ,  "Processing error - other",
		XI_PROC_PROCESSING_ERROR          ,  "Error while image processing.",
		XI_PROC_INPUT_FORMAT_UNSUPPORTED  ,  "Input format is not supported for processing.",
		XI_PROC_OUTPUT_FORMAT_UNSUPPORTED ,  "Output format is not supported for processing.",
		XI_OUT_OF_RANGE                   ,  "Parameter value is out of range",
		XIPR_OK                           ,  "Result OK",
		XIPR_INVALID_ARG                  ,  "Invalid argument detected (out of range)",
		XIPR_NOT_IMPLEMENTED              ,  "Implementation is not yet done",
		XIPR_NOT_SUPPORTED                ,  "This value is not supported",
		XIPR_UNKNOWN_PARAM                ,  "Using of unknown parameter",
		XIPR_INPUT_BUFFER_NOT_ALLOCATED   ,  "Input buffer is not allocated",
		XIPR_OUTPUT_BUFFER_NOT_ALLOCATED  ,  "Output buffer is not allocated",
		XIPR_OUTPUT_BUFFER_MEMORY_ALLOCATION_ERROR,  "Output buffer allocation error",
		XIPR_NO_PROCESSORS_AVAILABLE      ,  "There are no processors in chain",
		XIPR_INVALID_REQUIREMENTS         ,  "Some requirement is not met",
		XIPR_NO_MORE_SPACE_IN_PROCESSORS_CHAIN,  "Processors chain is full",
		XIPR_PROCESSOR_NOT_INITIALIZED    ,  "Processor is not initialized yet",
		XIPR_PROCESSING_ERROR             ,  "Processor generates error",
		XIPR_UNKNOWN_DATA_FORMAT          ,  "Unknown data format",
		XIPR_UNKNOWN_CFA_PATTERN          ,  "Unknown color filter array pattern type",
		XIPR_UNKNOWN_LOAD_LIBRARY         ,  "Couldn't load library",
		XIPR_UNKNOWN_LOAD_LIBRARY_FUNC    ,  "Couldn't load function",
		XIPR_UNKNOWN_OPEN_PROCESS         ,  "Couldn't open process",
		XIPR_UNKNOWN_BPL_STRING           ,  "Couldn't open process",
		XIPR_UNSUPPORTED_INPUT_FORMAT     ,  "Unsupported input format",
		XIPR_UNSUPPORTED_OUTPUT_FORMAT    ,  "Unsupported output format",
		XIPR_IMAGE_INTENSITY_OUT_OF_RANGE ,  "Image intensity is our of range",
		XIPR_TIMEOUT_WAITING_FOR_EVENT    ,  "Timeout waiting for event",
		XIPR_PROCESSOR_EXECUTION_DISABLED ,  "Processor execution disabled",
		XIPR_DEFECT_ALREADY_IN_LIST       ,  "Defect already in list",
		XIPR_ERROR_OPEN_FILE              ,  "Couldn't open input file",
		XIPR_ERROR_MEMORY_ALLOCATE        ,  "Couldn't allocate memory",
		XIPR_ERROR_READ_OPERATION         ,  "Couldn't read",
		XIPR_ERROR_WRITE_OPERATION        ,  "Couldn't write",
		XIPR_READ_ONLY_OPERATION          ,  "Operation is read only",
		XIPR_FFC_INCORRECT_DATA_FORMAT    ,  "Input data not compatible with current FFC processor settings",
		XIPR_IMAGE_CANT_PROCESSED_DUETO_WIDTH_ALIGNMENT,  "Image can't be processed due to image width alignment is not supported by Image Processor.",
		
};




xiAPIplus_Enumerators::xiAPIplus_Enumerators()
{
	Init();
}

void xiAPIplus_Enumerators::Init()
{

	// Downsampling value enumerator.
	XI_DOWNSAMPLING_VALUE_ITEMS.push_back({"XI_DWN_1x1",                             1, "1 sensor pixel = 1 image pixel"});
	XI_DOWNSAMPLING_VALUE_ITEMS.push_back({"XI_DWN_2x2",                             2, "2x2 sensor pixels = 1 image pixel"});
	XI_DOWNSAMPLING_VALUE_ITEMS.push_back({"XI_DWN_3x3",                             3, "Downsampling 3x3."});
	XI_DOWNSAMPLING_VALUE_ITEMS.push_back({"XI_DWN_4x4",                             4, "4x4 sensor pixels = 1 image pixel"});
	XI_DOWNSAMPLING_VALUE_ITEMS.push_back({"XI_DWN_5x5",                             5, "Downsampling 5x5."});
	XI_DOWNSAMPLING_VALUE_ITEMS.push_back({"XI_DWN_6x6",                             6, "Downsampling 6x6."});
	XI_DOWNSAMPLING_VALUE_ITEMS.push_back({"XI_DWN_7x7",                             7, "Downsampling 7x7."});
	XI_DOWNSAMPLING_VALUE_ITEMS.push_back({"XI_DWN_8x8",                             8, "Downsampling 8x8."});
	XI_DOWNSAMPLING_VALUE_ITEMS.push_back({"XI_DWN_9x9",                             9, "Downsampling 9x9."});
	XI_DOWNSAMPLING_VALUE_ITEMS.push_back({"XI_DWN_10x10",                           10, "Downsampling 10x10."});
	XI_DOWNSAMPLING_VALUE_ITEMS.push_back({"XI_DWN_16x16",                           16, "Downsampling 16x16."});

	// Test Pattern Generator
	XI_TEST_PATTERN_GENERATOR_ITEMS.push_back({"XI_TESTPAT_GEN_SENSOR",                  0, "Sensor test pattern generator"});
	XI_TEST_PATTERN_GENERATOR_ITEMS.push_back({"XI_TESTPAT_GEN_FPGA",                    1, " FPGA Test Pattern Generator"});
	XI_TEST_PATTERN_GENERATOR_ITEMS.push_back({"XI_TESTPAT_GEN_MCU",                     2, " MCU Test Pattern Generator"});

	// Module/Unit version selector
	XI_VERSION_ITEMS.push_back({"XI_VER_API",                             0, "version of API"});
	XI_VERSION_ITEMS.push_back({"XI_VER_DRV",                             1, "version of device driver"});
	XI_VERSION_ITEMS.push_back({"XI_VER_MCU1",                            2, "version of MCU1 firmware."});
	XI_VERSION_ITEMS.push_back({"XI_VER_MCU2",                            3, "version of MCU2 firmware."});
	XI_VERSION_ITEMS.push_back({"XI_VER_MCU3",                            4, "version of MCU3 firmware."});
	XI_VERSION_ITEMS.push_back({"XI_VER_FPGA1",                           5, "version of FPGA1 firmware."});
	XI_VERSION_ITEMS.push_back({"XI_VER_XMLMAN",                          6, "version of XML manifest."});
	XI_VERSION_ITEMS.push_back({"XI_VER_HW_REV",                          7, "version of hardware revision."});
	XI_VERSION_ITEMS.push_back({"XI_VER_FACTORY_SET",                     8, "version of factory set."});

	// Test Pattern Type
	XI_TEST_PATTERN_ITEMS.push_back({"XI_TESTPAT_OFF",                         0, " Testpattern turned off."});
	XI_TEST_PATTERN_ITEMS.push_back({"XI_TESTPAT_BLACK",                       1, " Image is filled with darkest possible image."});
	XI_TEST_PATTERN_ITEMS.push_back({"XI_TESTPAT_WHITE",                       2, " Image is filled with brightest possible image."});
	XI_TEST_PATTERN_ITEMS.push_back({"XI_TESTPAT_GREY_HORIZ_RAMP",             3, " Image is filled horizontally with an image that goes from the darkest possible value to the brightest."});
	XI_TEST_PATTERN_ITEMS.push_back({"XI_TESTPAT_GREY_VERT_RAMP",              4, " Image is filled vertically with an image that goes from the darkest possible value to the brightest."});
	XI_TEST_PATTERN_ITEMS.push_back({"XI_TESTPAT_GREY_HORIZ_RAMP_MOVING",      5, " Image is filled horizontally with an image that goes from the darkest possible value to the brightest and moves from left to right."});
	XI_TEST_PATTERN_ITEMS.push_back({"XI_TESTPAT_GREY_VERT_RAMP_MOVING",       6, " Image is filled vertically with an image that goes from the darkest possible value to the brightest and moves from left to right."});
	XI_TEST_PATTERN_ITEMS.push_back({"XI_TESTPAT_HORIZ_LINE_MOVING",           7, " A moving horizontal line is superimposed on the live image."});
	XI_TEST_PATTERN_ITEMS.push_back({"XI_TESTPAT_VERT_LINE_MOVING",            8, " A moving vertical line is superimposed on the live image."});
	XI_TEST_PATTERN_ITEMS.push_back({"XI_TESTPAT_COLOR_BAR",                   9, " Image is filled with stripes of color including White, Black, Red, Green, Blue, Cyan, Magenta and Yellow."});
	XI_TEST_PATTERN_ITEMS.push_back({"XI_TESTPAT_FRAME_COUNTER",               10, " A frame counter is superimposed on the live image."});
	XI_TEST_PATTERN_ITEMS.push_back({"XI_TESTPAT_DEVICE_SPEC_COUNTER",         11, " 128bit counter."});

	// Decimation Pattern Format
	XI_DEC_PATTERN_ITEMS.push_back({"XI_DEC_MONO",                            1, "adjacent pixels are decimated"});
	XI_DEC_PATTERN_ITEMS.push_back({"XI_DEC_BAYER",                           2, "	Bayer pattern is preserved during pixel decimation"});

	// Binning Pattern Format
	XI_BIN_PATTERN_ITEMS.push_back({"XI_BIN_MONO",                            1, "adjacent pixels are combined"});
	XI_BIN_PATTERN_ITEMS.push_back({"XI_BIN_BAYER",                           2, "Bayer pattern is preserved during pixel combining"});

	// Binning Engine Selector
	XI_BIN_SELECTOR_ITEMS.push_back({"XI_BIN_SELECT_SENSOR",                   0, "parameters for image sensor binning are selected"});
	XI_BIN_SELECTOR_ITEMS.push_back({"XI_BIN_SELECT_DEVICE_FPGA",              1, "parameters for device (camera) FPGA decimation are selected"});
	XI_BIN_SELECTOR_ITEMS.push_back({"XI_BIN_SELECT_HOST_CPU",                 2, "parameters for Host CPU binning are selected"});

	// Selects binning mode; to be used with
	XI_BIN_MODE_ITEMS.push_back({"XI_BIN_MODE_SUM",                        0, "The response from the combined pixels will be added, resulting in increased sensitivity."});
	XI_BIN_MODE_ITEMS.push_back({"XI_BIN_MODE_AVERAGE",                    1, "The response from the combined pixels will be averaged, resulting in increased signal/noise ratio."});

	// Decimation Engine Selector
	XI_DEC_SELECTOR_ITEMS.push_back({"XI_DEC_SELECT_SENSOR",                   0, "parameters for image sensor decimation are selected"});
	XI_DEC_SELECTOR_ITEMS.push_back({"XI_DEC_SELECT_DEVICE_FPGA",              1, "parameters for device (camera) FPGA decimation are selected"});
	XI_DEC_SELECTOR_ITEMS.push_back({"XI_DEC_SELECT_HOST_CPU",                 2, "parameters for Host CPU decimation are selected"});

	// Sensor tap count enumerator.
	XI_SENSOR_TAP_CNT_ITEMS.push_back({"XI_TAP_CNT_1",                           1, "1 sensor tap selected."});
	XI_SENSOR_TAP_CNT_ITEMS.push_back({"XI_TAP_CNT_2",                           2, "2 sensor taps selected."});
	XI_SENSOR_TAP_CNT_ITEMS.push_back({"XI_TAP_CNT_4",                           4, "4 sensor taps selected."});

	// Bit depth enumerator.
	XI_BIT_DEPTH_ITEMS.push_back({"XI_BPP_8",                               8, "8 bit per pixel"});
	XI_BIT_DEPTH_ITEMS.push_back({"XI_BPP_9",                               9, "9 bit per pixel"});
	XI_BIT_DEPTH_ITEMS.push_back({"XI_BPP_10",                              10, "10 bit per pixel"});
	XI_BIT_DEPTH_ITEMS.push_back({"XI_BPP_11",                              11, "11 bit per pixel"});
	XI_BIT_DEPTH_ITEMS.push_back({"XI_BPP_12",                              12, "12 bit per pixel"});
	XI_BIT_DEPTH_ITEMS.push_back({"XI_BPP_13",                              13, "13 bit per pixel"});
	XI_BIT_DEPTH_ITEMS.push_back({"XI_BPP_14",                              14, "14 bit per pixel"});
	XI_BIT_DEPTH_ITEMS.push_back({"XI_BPP_15",                              15, "15 bit per pixel"});
	XI_BIT_DEPTH_ITEMS.push_back({"XI_BPP_16",                              16, "16 bit per pixel"});
	XI_BIT_DEPTH_ITEMS.push_back({"XI_BPP_24",                              24, "24 bit per pixel"});
	XI_BIT_DEPTH_ITEMS.push_back({"XI_BPP_32",                              32, "32 bit per pixel"});

	// Debug level enumerator.
	XI_DEBUG_LEVEL_ITEMS.push_back({"XI_DL_DETAIL",                           0, "(see Note1)"});
	XI_DEBUG_LEVEL_ITEMS.push_back({"XI_DL_TRACE",                            1, "Prints errors, warnings and important informations"});
	XI_DEBUG_LEVEL_ITEMS.push_back({"XI_DL_WARNING",                          2, "Prints all errors and warnings"});
	XI_DEBUG_LEVEL_ITEMS.push_back({"XI_DL_ERROR",                            3, "Prints all errors"});
	XI_DEBUG_LEVEL_ITEMS.push_back({"XI_DL_FATAL",                            4, "Prints only important errors"});
	XI_DEBUG_LEVEL_ITEMS.push_back({"XI_DL_DISABLED",                         100, "Prints no messages"});

	// Image output format enumerator.
	XI_IMG_FORMAT_ITEMS.push_back({"XI_MONO8",                               0, "8 bits per pixel. 	[Intensity] (see Note5,Note6)"});
	XI_IMG_FORMAT_ITEMS.push_back({"XI_MONO16",                              1, "16 bits per pixel. [Intensity LSB] [Intensity MSB] (see Note5,Note6)"});
	XI_IMG_FORMAT_ITEMS.push_back({"XI_RGB24",                               2, "RGB data format. [Blue][Green][Red] (see Note5)"});
	XI_IMG_FORMAT_ITEMS.push_back({"XI_RGB32",                               3, "RGBA data format. 	[Blue][Green][Red][0] (see Note5)"});
	XI_IMG_FORMAT_ITEMS.push_back({"XI_RGB_PLANAR",                          4, "RGB planar data format. [Red][Red]...[Green][Green]...[Blue][Blue]... (see Note5)"});
	XI_IMG_FORMAT_ITEMS.push_back({"XI_RAW8",                                5, "8 bits per pixel raw data from sensor. 	[pixel byte] raw data from transport (camera output)"});
	XI_IMG_FORMAT_ITEMS.push_back({"XI_RAW16",                               6, "16 bits per pixel raw data from sensor. 	[pixel byte low] [pixel byte high] 16 bits (depacked) raw data"});
	XI_IMG_FORMAT_ITEMS.push_back({"XI_FRM_TRANSPORT_DATA",                  7, "Data from transport layer (e.g. packed). Depends on data on the transport layer (see Note7)"});
	XI_IMG_FORMAT_ITEMS.push_back({"XI_RGB48",                               8, "RGB data format. [Blue low byte][Blue high byte][Green low][Green high][Red low][Red high] (see Note5)"});
	XI_IMG_FORMAT_ITEMS.push_back({"XI_RGB64",                               9, "RGBA data format. [Blue low byte][Blue high byte][Green low][Green high][Red low][Red high][0][0] (Note5)"});
	XI_IMG_FORMAT_ITEMS.push_back({"XI_RGB16_PLANAR",                        10, "RGB16 planar data format"});
	XI_IMG_FORMAT_ITEMS.push_back({"XI_RAW8X2",                              11, "8 bits per pixel raw data from sensor(2 components in a row). [ch1 pixel byte] [ch2 pixel byte] 8 bits raw data from 2 channels (e.g. high gain and low gain channels of sCMOS cameras)"});
	XI_IMG_FORMAT_ITEMS.push_back({"XI_RAW8X4",                              12, "8 bits per pixel raw data from sensor(4 components in a row). 	[ch1 pixel byte [ch2 pixel byte] [ch3 pixel byte] [ch4 pixel byte] 8 bits raw data from 4 channels (e.g. sCMOS cameras)"});
	XI_IMG_FORMAT_ITEMS.push_back({"XI_RAW16X2",                             13, "16 bits per pixel raw data from sensor(2 components in a row). 	[ch1 pixel byte low] [ch1 pixel byte high] [ch2 pixel byte low] [ch2 pixel byte high] 16 bits (depacked) raw data from 2 channels (e.g. high gain and low gain channels of sCMOS cameras)"});
	XI_IMG_FORMAT_ITEMS.push_back({"XI_RAW16X4",                             14, "16 bits per pixel raw data from sensor(4 components in a row). 	[ch1 pixel byte low] [ch1 pixel byte high] [ch2 pixel byte low] [ch2 pixel byte high] [ch3 pixel byte low] [ch3 pixel byte high] [ch4 pixel byte low] [ch4 pixel byte high] 16 bits (depacked) raw data from 4 channels (e.g. sCMOS cameras)"});
	XI_IMG_FORMAT_ITEMS.push_back({"XI_RAW32",                               15, "32 bits per pixel raw data from sensor in integer format (LSB first). 4 bytes (LSB first) pixel (depacked) raw data"});
	XI_IMG_FORMAT_ITEMS.push_back({"XI_RAW32FLOAT",                          16, "32 bits per pixel raw data from sensor in single-precision floating point format. 4 bytes per pixel (depacked) raw data"});
	XI_IMG_FORMAT_ITEMS.push_back({"XI_RAW8X3",                              17, "8 bits per pixel raw data from sensor(3 components in a row). 	[ch1 pixel byte] [ch2 pixel byte] [ch3 pixel byte] raw data from 3 channels (e.g. ToF cameras)"});
	XI_IMG_FORMAT_ITEMS.push_back({"XI_RAW16X3",                             18, "16 bits per pixel raw data from sensor(3 components in a row). [ch1 pixel byte low] [ch1 pixel byte high] [ch2 pixel byte low] [ch2 pixel byte high] [ch3 pixel byte low] [ch3 pixel byte high] 16 bits (depacked) raw data from 3 channels (e.g. ToF cameras)"});

	// Bayer color matrix enumerator.
	XI_COLOR_FILTER_ARRAY_ITEMS.push_back({"XI_CFA_NONE",                            0, "Result pixels have no filters applied in this format"});
	XI_COLOR_FILTER_ARRAY_ITEMS.push_back({"XI_CFA_BAYER_RGGB",                      1, "Regular RGGB"});
	XI_COLOR_FILTER_ARRAY_ITEMS.push_back({"XI_CFA_CMYG",                            2, "AK Sony sens"});
	XI_COLOR_FILTER_ARRAY_ITEMS.push_back({"XI_CFA_RGR",                             3, "2R+G readout"});
	XI_COLOR_FILTER_ARRAY_ITEMS.push_back({"XI_CFA_BAYER_BGGR",                      4, "BGGR readout"});
	XI_COLOR_FILTER_ARRAY_ITEMS.push_back({"XI_CFA_BAYER_GRBG",                      5, "GRBG readout"});
	XI_COLOR_FILTER_ARRAY_ITEMS.push_back({"XI_CFA_BAYER_GBRG",                      6, "GBRG readout"});
	XI_COLOR_FILTER_ARRAY_ITEMS.push_back({"XI_CFA_POLAR_A_BAYER_BGGR",              7, "BGGR polarized 4x4 macropixel"});
	XI_COLOR_FILTER_ARRAY_ITEMS.push_back({"XI_CFA_POLAR_A",                         8, "Polarized 2x2 macropixel"});
	XI_COLOR_FILTER_ARRAY_ITEMS.push_back({"XI_CFA_TOF_ANB",                         9, "ToF A and B"});
	XI_COLOR_FILTER_ARRAY_ITEMS.push_back({"XI_CFA_TOF_AMB",                         10, "ToF A minus B"});
	XI_COLOR_FILTER_ARRAY_ITEMS.push_back({"XI_CFA_TOF_APB",                         11, "ToF A plus B"});
	XI_COLOR_FILTER_ARRAY_ITEMS.push_back({"XI_CFA_TOF_A",                           12, "ToF A only"});
	XI_COLOR_FILTER_ARRAY_ITEMS.push_back({"XI_CFA_TOF_B",                           13, "ToF B only"});
	XI_COLOR_FILTER_ARRAY_ITEMS.push_back({"XI_CFA_TOF_X1X2X3",                      14, "ToF X1,X2,X3"});

	// Image sequence type.
	XI_IMAGE_SEQUENCE_TYPE_ITEMS.push_back({"XI_IMAGE_SEQUENCE_TYPE_DISABLED",        0, "No image sequence."});
	XI_IMAGE_SEQUENCE_TYPE_ITEMS.push_back({"XI_IMAGE_SEQUENCE_TYPE_EXPOSURES",       1, "Image sequence off different exposures. E.g. for HDR."});

	// structure containing information about buffer policy(can be safe, data will be copied to user/app buffer or unsafe, user will get internally allocated buffer without data copy).
	XI_BP_ITEMS.push_back({"XI_BP_UNSAFE",                           0, "User gets pointer to internally allocated circle buffer and data may be overwritten by device."});
	XI_BP_ITEMS.push_back({"XI_BP_SAFE",                             1, "Data from device will be copied to user allocated buffer or xiApi allocated memory."});

	// structure containing information about trigger source
	XI_TRG_SOURCE_ITEMS.push_back({"XI_TRG_OFF",                             0, "Capture of next image is automatically started after previous."});
	XI_TRG_SOURCE_ITEMS.push_back({"XI_TRG_EDGE_RISING",                     1, "Capture is started on rising edge of selected input."});
	XI_TRG_SOURCE_ITEMS.push_back({"XI_TRG_EDGE_FALLING",                    2, "Capture is started on falling edge of selected input"});
	XI_TRG_SOURCE_ITEMS.push_back({"XI_TRG_SOFTWARE",                        3, "Capture is started with software trigger."});
	XI_TRG_SOURCE_ITEMS.push_back({"XI_TRG_LEVEL_HIGH",                      4, "Specifies that the trigger is considered valid as long as the level of the source signal is high."});
	XI_TRG_SOURCE_ITEMS.push_back({"XI_TRG_LEVEL_LOW",                       5, "Specifies that the trigger is considered valid as long as the level of the source signal is low."});

	// structure containing information about trigger functionality
	XI_TRG_SELECTOR_ITEMS.push_back({"XI_TRG_SEL_FRAME_START",                 0, "Trigger starts the capture of one frame"});
	XI_TRG_SELECTOR_ITEMS.push_back({"XI_TRG_SEL_EXPOSURE_ACTIVE",             1, "Trigger controls the start and length of the exposure."});
	XI_TRG_SELECTOR_ITEMS.push_back({"XI_TRG_SEL_FRAME_BURST_START",           2, "Trigger starts the capture of the bursts of frames in an acquisition."});
	XI_TRG_SELECTOR_ITEMS.push_back({"XI_TRG_SEL_FRAME_BURST_ACTIVE",          3, "Trigger controls the duration of the capture of the bursts of frames in an acquisition."});
	XI_TRG_SELECTOR_ITEMS.push_back({"XI_TRG_SEL_MULTIPLE_EXPOSURES",          4, "Trigger which when first trigger starts exposure and consequent pulses are gating exposure(active HI)"});
	XI_TRG_SELECTOR_ITEMS.push_back({"XI_TRG_SEL_EXPOSURE_START",              5, "Trigger controls the start of the exposure of one Frame."});
	XI_TRG_SELECTOR_ITEMS.push_back({"XI_TRG_SEL_MULTI_SLOPE_PHASE_CHANGE",    6, "Trigger controls the multi slope phase in one Frame (phase0 -> phase1) or (phase1 -> phase2)."});
	XI_TRG_SELECTOR_ITEMS.push_back({"XI_TRG_SEL_ACQUISITION_START",           7, "Selects a trigger that starts the Acquisition."});

	// Trigger overlap modes
	XI_TRG_OVERLAP_ITEMS.push_back({"XI_TRG_OVERLAP_OFF",                     0, "No trigger overlap is permitted."});
	XI_TRG_OVERLAP_ITEMS.push_back({"XI_TRG_OVERLAP_READ_OUT",                1, "Trigger is accepted immediately after the exposure period. (see Note1)"});
	XI_TRG_OVERLAP_ITEMS.push_back({"XI_TRG_OVERLAP_PREV_FRAME",              2, "Trigger is accepted (latched) at any time during the capture of the previous frame."});

	// structure containing information about acquisition timing modes
	XI_ACQ_TIMING_MODE_ITEMS.push_back({"XI_ACQ_TIMING_MODE_FREE_RUN",            0, "camera acquires images at a maximum possible framerate"});
	XI_ACQ_TIMING_MODE_ITEMS.push_back({"XI_ACQ_TIMING_MODE_FRAME_RATE",          1, "Selects a mode when sensor frame acquisition frequency is set to parameter FRAMERATE"});
	XI_ACQ_TIMING_MODE_ITEMS.push_back({"XI_ACQ_TIMING_MODE_FRAME_RATE_LIMIT",    2, "Selects a mode when sensor frame acquisition frequency is limited by parameter FRAMERATE"});

	// Enumerator for data target modes
	XI_TRANSPORT_DATA_TARGET_MODE_ITEMS.push_back({"XI_TRANSPORT_DATA_TARGET_CPU_RAM",       0, "normal CPU memory buffer is used for image data"});
	XI_TRANSPORT_DATA_TARGET_MODE_ITEMS.push_back({"XI_TRANSPORT_DATA_TARGET_GPU_RAM",       1, "data is delivered straight to GPU memory using GPUDirect technology"});
	XI_TRANSPORT_DATA_TARGET_MODE_ITEMS.push_back({"XI_TRANSPORT_DATA_TARGET_UNIFIED",       2, "CUDA managed memory is used for image data."});
	XI_TRANSPORT_DATA_TARGET_MODE_ITEMS.push_back({"XI_TRANSPORT_DATA_TARGET_ZEROCOPY",      3, "CUDA zerocopy memory is used for image data."});

	// Enumeration for XI_PRM_GPI_SELECTOR for CB cameras.
	XI_GPI_SEL_CB_ITEMS.push_back({"XI_GPI_SEL_CB_IN1",                      1, "Input1 - Pin3 (Opto Isolated)."});
	XI_GPI_SEL_CB_ITEMS.push_back({"XI_GPI_SEL_CB_IN2",                      2, "Input2 - Pin4 (Opto Isolated)."});
	XI_GPI_SEL_CB_ITEMS.push_back({"XI_GPI_SEL_CB_INOUT1",                   3, "Input/Output1 - Pin6"});
	XI_GPI_SEL_CB_ITEMS.push_back({"XI_GPI_SEL_CB_INOUT2",                   4, "Input/Output2 - Pin7"});
	XI_GPI_SEL_CB_ITEMS.push_back({"XI_GPI_SEL_CB_INOUT3",                   5, "Input/Output3 - Pin11"});
	XI_GPI_SEL_CB_ITEMS.push_back({"XI_GPI_SEL_CB_INOUT4",                   6, "Input/Output4 - Pin12"});

	// Enumeration for XI_PRM_GPO_SELECTOR for CB cameras.
	XI_GPO_SEL_CB_ITEMS.push_back({"XI_GPO_SEL_CB_OUT1",                     1, "Output1 - Pin8 (Opto Isolated)."});
	XI_GPO_SEL_CB_ITEMS.push_back({"XI_GPO_SEL_CB_OUT2",                     2, "Output2 - Pin9 (Opto Isolated)."});
	XI_GPO_SEL_CB_ITEMS.push_back({"XI_GPO_SEL_CB_INOUT1",                   3, "Input/Output1 - Pin6"});
	XI_GPO_SEL_CB_ITEMS.push_back({"XI_GPO_SEL_CB_INOUT2",                   4, "Input/Output2 - Pin7"});
	XI_GPO_SEL_CB_ITEMS.push_back({"XI_GPO_SEL_CB_INOUT3",                   5, "Input/Output3 - Pin11"});
	XI_GPO_SEL_CB_ITEMS.push_back({"XI_GPO_SEL_CB_INOUT4",                   6, "Input/Output4 - Pin12"});

	// structure containing information about GPI functionality
	XI_GPI_MODE_ITEMS.push_back({"XI_GPI_OFF",                             0, "Input is not used for triggering, but can be used to get parameter GPI_LEVEL. This can be used to switch I/O line on some cameras to input mode."});
	XI_GPI_MODE_ITEMS.push_back({"XI_GPI_TRIGGER",                         1, "Input can be used for triggering."});
	XI_GPI_MODE_ITEMS.push_back({"XI_GPI_EXT_EVENT",                       2, "External signal input (not implemented)"});

	// Enumerator for GPI port selection.
	XI_GPI_SELECTOR_ITEMS.push_back({"XI_GPI_PORT1",                           1, "GPI port 1"});
	XI_GPI_SELECTOR_ITEMS.push_back({"XI_GPI_PORT2",                           2, "GPI port 2"});
	XI_GPI_SELECTOR_ITEMS.push_back({"XI_GPI_PORT3",                           3, "GPI port 3"});
	XI_GPI_SELECTOR_ITEMS.push_back({"XI_GPI_PORT4",                           4, "GPI port 4"});
	XI_GPI_SELECTOR_ITEMS.push_back({"XI_GPI_PORT5",                           5, "GPI port 5"});
	XI_GPI_SELECTOR_ITEMS.push_back({"XI_GPI_PORT6",                           6, "GPI port 6"});
	XI_GPI_SELECTOR_ITEMS.push_back({"XI_GPI_PORT7",                           7, "GPI port 7"});
	XI_GPI_SELECTOR_ITEMS.push_back({"XI_GPI_PORT8",                           8, "GPI port 8"});
	XI_GPI_SELECTOR_ITEMS.push_back({"XI_GPI_PORT9",                           9, "GPI port 9"});
	XI_GPI_SELECTOR_ITEMS.push_back({"XI_GPI_PORT10",                          10, "GPI port 10"});
	XI_GPI_SELECTOR_ITEMS.push_back({"XI_GPI_PORT11",                          11, "GPI port 11"});
	XI_GPI_SELECTOR_ITEMS.push_back({"XI_GPI_PORT12",                          12, "GPI port 12"});

	// structure containing information about GPO functionality
	XI_GPO_MODE_ITEMS.push_back({"XI_GPO_OFF",                             0, "Output is off (zero voltage or switched_off)"});
	XI_GPO_MODE_ITEMS.push_back({"XI_GPO_ON",                              1, "Output is on (voltage or switched_on)"});
	XI_GPO_MODE_ITEMS.push_back({"XI_GPO_FRAME_ACTIVE",                    2, "Output is on while frame exposure,read,transfer."});
	XI_GPO_MODE_ITEMS.push_back({"XI_GPO_FRAME_ACTIVE_NEG",                3, "Output is off while frame exposure,read,transfer."});
	XI_GPO_MODE_ITEMS.push_back({"XI_GPO_EXPOSURE_ACTIVE",                 4, "Output is on while frame exposure"});
	XI_GPO_MODE_ITEMS.push_back({"XI_GPO_EXPOSURE_ACTIVE_NEG",             5, "Output is off while frame exposure"});
	XI_GPO_MODE_ITEMS.push_back({"XI_GPO_FRAME_TRIGGER_WAIT",              6, "Output is on while camera is ready for trigger"});
	XI_GPO_MODE_ITEMS.push_back({"XI_GPO_FRAME_TRIGGER_WAIT_NEG",          7, "Output is off while camera is ready for trigger."});
	XI_GPO_MODE_ITEMS.push_back({"XI_GPO_EXPOSURE_PULSE",                  8, "Output is on short pulse at the beginning of frame exposure."});
	XI_GPO_MODE_ITEMS.push_back({"XI_GPO_EXPOSURE_PULSE_NEG",              9, "Output is off short pulse at the beginning of frame exposure."});
	XI_GPO_MODE_ITEMS.push_back({"XI_GPO_BUSY",                            10, "Output is on when camera has received trigger until end of transfer"});
	XI_GPO_MODE_ITEMS.push_back({"XI_GPO_BUSY_NEG",                        11, "Output is off when camera has received trigger until end of transfer"});
	XI_GPO_MODE_ITEMS.push_back({"XI_GPO_HIGH_IMPEDANCE",                  12, "Associated pin is in high impedance (tri-stated) and can be driven externally. E.g. for triggering or reading status by GPI_LEVEL."});
	XI_GPO_MODE_ITEMS.push_back({"XI_GPO_FRAME_BUFFER_OVERFLOW",           13, "Frame buffer overflow status."});
	XI_GPO_MODE_ITEMS.push_back({"XI_GPO_EXPOSURE_ACTIVE_FIRST_ROW",       14, "Output is on while the first row exposure."});
	XI_GPO_MODE_ITEMS.push_back({"XI_GPO_EXPOSURE_ACTIVE_FIRST_ROW_NEG",   15, "Output is off while the first row exposure."});
	XI_GPO_MODE_ITEMS.push_back({"XI_GPO_EXPOSURE_ACTIVE_ALL_ROWS",        16, "Output is on while all rows exposure together."});
	XI_GPO_MODE_ITEMS.push_back({"XI_GPO_EXPOSURE_ACTIVE_ALL_ROWS_NEG",    17, "Output is off while all rows exposure together."});
	XI_GPO_MODE_ITEMS.push_back({"XI_GPO_TXD",                             18, "Output is connected to TXD of UART module"});

	// Enumerator for GPO port selection.
	XI_GPO_SELECTOR_ITEMS.push_back({"XI_GPO_PORT1",                           1, "GPO port 1"});
	XI_GPO_SELECTOR_ITEMS.push_back({"XI_GPO_PORT2",                           2, "GPO port 2"});
	XI_GPO_SELECTOR_ITEMS.push_back({"XI_GPO_PORT3",                           3, "GPO port 3"});
	XI_GPO_SELECTOR_ITEMS.push_back({"XI_GPO_PORT4",                           4, "GPO port 4"});
	XI_GPO_SELECTOR_ITEMS.push_back({"XI_GPO_PORT5",                           5, "GPO port 5"});
	XI_GPO_SELECTOR_ITEMS.push_back({"XI_GPO_PORT6",                           6, "GPO port 6"});
	XI_GPO_SELECTOR_ITEMS.push_back({"XI_GPO_PORT7",                           7, "GPO port 7"});
	XI_GPO_SELECTOR_ITEMS.push_back({"XI_GPO_PORT8",                           8, "GPO port 8"});
	XI_GPO_SELECTOR_ITEMS.push_back({"XI_GPO_PORT9",                           9, "GPO port 9"});
	XI_GPO_SELECTOR_ITEMS.push_back({"XI_GPO_PORT10",                          10, "GPO port 10"});
	XI_GPO_SELECTOR_ITEMS.push_back({"XI_GPO_PORT11",                          11, "GPO port 11"});
	XI_GPO_SELECTOR_ITEMS.push_back({"XI_GPO_PORT12",                          12, "GPO port 12"});

	// Metadata sampling mode selector
	XI_METADATA_SAMPLING_MODE_ITEMS.push_back({"XI_METADATA_SAMPLING_OFF",               0, "Metadata sampling turned off"});
	XI_METADATA_SAMPLING_MODE_ITEMS.push_back({"XI_METADATA_SAMPLING_POINT_EXPOSURE_START",1, "Selects the sampling point to exposure start"});
	XI_METADATA_SAMPLING_MODE_ITEMS.push_back({"XI_METADATA_SAMPLING_POINT_EXPOSURE_END",2, "Selects the sampling point to exposure end"});
	XI_METADATA_SAMPLING_MODE_ITEMS.push_back({"XI_METADATA_SAMPLING_POINT_EXPOSURE_START_END",3, "Selects the sampling point to exposure start and end"});
	XI_METADATA_SAMPLING_MODE_ITEMS.push_back({"XI_METADATA_SAMPLING_POINT_READOUT_END", 4, "Selects the sampling point to readout end"});

	// structure containing information about LED functionality
	XI_LED_MODE_ITEMS.push_back({"XI_LED_HEARTBEAT",                       0, "Set led to blink (1 Hz) if link is OK."});
	XI_LED_MODE_ITEMS.push_back({"XI_LED_TRIGGER_ACTIVE",                  1, "Set led to blink if trigger detected."});
	XI_LED_MODE_ITEMS.push_back({"XI_LED_EXT_EVENT_ACTIVE",                2, "Set led to blink if external signal detected."});
	XI_LED_MODE_ITEMS.push_back({"XI_LED_LINK",                            3, "Set led to blink if link is OK."});
	XI_LED_MODE_ITEMS.push_back({"XI_LED_ACQUISITION",                     4, "Set led to blink if data streaming"});
	XI_LED_MODE_ITEMS.push_back({"XI_LED_EXPOSURE_ACTIVE",                 5, "Set led to blink if sensor integration time."});
	XI_LED_MODE_ITEMS.push_back({"XI_LED_FRAME_ACTIVE",                    6, "Set led to blink if device busy/not busy."});
	XI_LED_MODE_ITEMS.push_back({"XI_LED_OFF",                             7, "Set led to off."});
	XI_LED_MODE_ITEMS.push_back({"XI_LED_ON",                              8, "Set led to on."});
	XI_LED_MODE_ITEMS.push_back({"XI_LED_BLINK",                           9, "Blinking (1Hz)."});

	// Enumerator for LED selection.
	XI_LED_SELECTOR_ITEMS.push_back({"XI_LED_SEL1",                            1, "LED 1"});
	XI_LED_SELECTOR_ITEMS.push_back({"XI_LED_SEL2",                            2, "LED 2"});
	XI_LED_SELECTOR_ITEMS.push_back({"XI_LED_SEL3",                            3, "LED 3"});
	XI_LED_SELECTOR_ITEMS.push_back({"XI_LED_SEL4",                            4, "LED 4"});
	XI_LED_SELECTOR_ITEMS.push_back({"XI_LED_SEL5",                            5, "LED 5"});

	// structure contains frames counter
	XI_COUNTER_SELECTOR_ITEMS.push_back({"XI_CNT_SEL_TRANSPORT_SKIPPED_FRAMES",    0, "Number of skipped frames on transport layer (e.g. when image gets lost while transmission). Occur when capacity of transport channel does not allow to transfer all data."});
	XI_COUNTER_SELECTOR_ITEMS.push_back({"XI_CNT_SEL_API_SKIPPED_FRAMES",          1, "Number of skipped frames on API layer. Occur when application does not process the images as quick as they are received from the camera."});
	XI_COUNTER_SELECTOR_ITEMS.push_back({"XI_CNT_SEL_TRANSPORT_TRANSFERRED_FRAMES",2, "Number of delivered buffers since last acquisition start."});
	XI_COUNTER_SELECTOR_ITEMS.push_back({"XI_CNT_SEL_FRAME_MISSED_TRIGGER_DUETO_OVERLAP",3, "Number of missed triggers overlapped with exposure or read-out stage of previous frame – see XI_PRM_TRG_OVERLAP. (see Note1)"});
	XI_COUNTER_SELECTOR_ITEMS.push_back({"XI_CNT_SEL_FRAME_MISSED_TRIGGER_DUETO_FRAME_BUFFER_OVR",4, "Number of missed triggers due to frame buffer full. (see Note1)"});
	XI_COUNTER_SELECTOR_ITEMS.push_back({"XI_CNT_SEL_FRAME_BUFFER_OVERFLOW",       5, "Internal camera frame buffer memory (RAM) full events counter. It can be incremented multiple times per one frame. (see Note1)"});
	XI_COUNTER_SELECTOR_ITEMS.push_back({"XI_CNT_SEL_TRANSPORT_QUEUE_UNDERRUN",    6, "Incremented when camera starts to transfer new image, however no target buffer is queued in the transport queue. Connected to GenTL.STREAM_INFO_NUM_UNDERRUN. (see Note1)"});
	XI_COUNTER_SELECTOR_ITEMS.push_back({"XI_CNT_SEL_ACQUISITION_AUTO_RESTARTED_ON_FAILURE",7, "Acquisition can be restarted, due to failures on bus"});

	// structure containing information about timestamp reset arming
	XI_TS_RST_MODE_ITEMS.push_back({"XI_TS_RST_ARM_ONCE",                     0, "Engine is disabled after TimeStamp has been reset after selected event."});
	XI_TS_RST_MODE_ITEMS.push_back({"XI_TS_RST_ARM_PERSIST",                  1, "Engine is armed permanently so each selected event will trigger TimeStamp reset. "});

	// structure containing information about possible timestamp reset sources
	XI_TS_RST_SOURCE_ITEMS.push_back({"XI_TS_RST_OFF",                          0, "No source selected TimeStamp reset is not armed."});
	XI_TS_RST_SOURCE_ITEMS.push_back({"XI_TS_RST_SRC_GPI_1",                    1, "GPI1 rising edge is active (signal after de-bounce module)"});
	XI_TS_RST_SOURCE_ITEMS.push_back({"XI_TS_RST_SRC_GPI_2",                    2, "GPI2 rising edge is active"});
	XI_TS_RST_SOURCE_ITEMS.push_back({"XI_TS_RST_SRC_GPI_3",                    3, "GPI3 rising edge is active"});
	XI_TS_RST_SOURCE_ITEMS.push_back({"XI_TS_RST_SRC_GPI_4",                    4, "GPI4 rising edge is active"});
	XI_TS_RST_SOURCE_ITEMS.push_back({"XI_TS_RST_SRC_GPI_1_INV",                5, "GPI1 falling edge is active"});
	XI_TS_RST_SOURCE_ITEMS.push_back({"XI_TS_RST_SRC_GPI_2_INV",                6, "GPI2 falling edge is active"});
	XI_TS_RST_SOURCE_ITEMS.push_back({"XI_TS_RST_SRC_GPI_3_INV",                7, "GPI3 falling edge is active"});
	XI_TS_RST_SOURCE_ITEMS.push_back({"XI_TS_RST_SRC_GPI_4_INV",                8, "GPI4 falling edge is active"});
	XI_TS_RST_SOURCE_ITEMS.push_back({"XI_TS_RST_SRC_GPO_1",                    9, "TimeStamp reset source selected GPO1"});
	XI_TS_RST_SOURCE_ITEMS.push_back({"XI_TS_RST_SRC_GPO_2",                    10, "TimeStamp reset source selected GPO2"});
	XI_TS_RST_SOURCE_ITEMS.push_back({"XI_TS_RST_SRC_GPO_3",                    11, "TimeStamp reset source selected GPO3"});
	XI_TS_RST_SOURCE_ITEMS.push_back({"XI_TS_RST_SRC_GPO_4",                    12, "TimeStamp reset source selected GPO4"});
	XI_TS_RST_SOURCE_ITEMS.push_back({"XI_TS_RST_SRC_GPO_1_INV",                13, "TimeStamp reset source selected GPO1 inverted"});
	XI_TS_RST_SOURCE_ITEMS.push_back({"XI_TS_RST_SRC_GPO_2_INV",                14, "TimeStamp reset source selected GPO2 inverted"});
	XI_TS_RST_SOURCE_ITEMS.push_back({"XI_TS_RST_SRC_GPO_3_INV",                15, "TimeStamp reset source selected GPO3 inverted"});
	XI_TS_RST_SOURCE_ITEMS.push_back({"XI_TS_RST_SRC_GPO_4_INV",                16, "TimeStamp reset source selected GPO4 inverted"});
	XI_TS_RST_SOURCE_ITEMS.push_back({"XI_TS_RST_SRC_TRIGGER",                  17, "TRIGGER to sensor rising edge is active"});
	XI_TS_RST_SOURCE_ITEMS.push_back({"XI_TS_RST_SRC_TRIGGER_INV",              18, "TRIGGER to sensor rising edge is active"});
	XI_TS_RST_SOURCE_ITEMS.push_back({"XI_TS_RST_SRC_SW",                       19, "TRIGGER to sensor rising edge is active. TimeStamp is reset by software take effect imminently."});
	XI_TS_RST_SOURCE_ITEMS.push_back({"XI_TS_RST_SRC_EXPACTIVE",                20, "Exposure Active signal rising edge "});
	XI_TS_RST_SOURCE_ITEMS.push_back({"XI_TS_RST_SRC_EXPACTIVE_INV",            21, "Exposure Active signal falling edge "});
	XI_TS_RST_SOURCE_ITEMS.push_back({"XI_TS_RST_SRC_FVAL",                     22, "Frame valid signal rising edge (internal signal in camera)"});
	XI_TS_RST_SOURCE_ITEMS.push_back({"XI_TS_RST_SRC_FVAL_INV",                 23, "Frame valid signal falling edge (internal signal in camera)"});
	XI_TS_RST_SOURCE_ITEMS.push_back({"XI_TS_RST_SRC_GPI_5",                    24, "GPI5 rising edge is active"});
	XI_TS_RST_SOURCE_ITEMS.push_back({"XI_TS_RST_SRC_GPI_6",                    25, "GPI6 rising edge is active"});
	XI_TS_RST_SOURCE_ITEMS.push_back({"XI_TS_RST_SRC_GPI_5_INV",                26, "GPI5 falling edge is active"});
	XI_TS_RST_SOURCE_ITEMS.push_back({"XI_TS_RST_SRC_GPI_6_INV",                27, "GPI6 falling edge is active"});
	XI_TS_RST_SOURCE_ITEMS.push_back({"XI_TS_RST_SRC_GPI_7",                    28, "TimeStamp reset source selected GPI7 (after de bounce)"});
	XI_TS_RST_SOURCE_ITEMS.push_back({"XI_TS_RST_SRC_GPI_8",                    29, "TimeStamp reset source selected GPI8 (after de bounce)"});
	XI_TS_RST_SOURCE_ITEMS.push_back({"XI_TS_RST_SRC_GPI_9",                    30, "TimeStamp reset source selected GPI9 (after de bounce)"});
	XI_TS_RST_SOURCE_ITEMS.push_back({"XI_TS_RST_SRC_GPI_10",                   31, "TimeStamp reset source selected GPI10 (after de bounce)"});
	XI_TS_RST_SOURCE_ITEMS.push_back({"XI_TS_RST_SRC_GPI_11",                   32, "TimeStamp reset source selected GPI11 (after de bounce)"});
	XI_TS_RST_SOURCE_ITEMS.push_back({"XI_TS_RST_SRC_GPI_7_INV",                33, "TimeStamp reset source selected GPI7 inverted (after de bounce)"});
	XI_TS_RST_SOURCE_ITEMS.push_back({"XI_TS_RST_SRC_GPI_8_INV",                34, "TimeStamp reset source selected GPI8 inverted (after de bounce)"});
	XI_TS_RST_SOURCE_ITEMS.push_back({"XI_TS_RST_SRC_GPI_9_INV",                35, "TimeStamp reset source selected GPI9 inverted (after de bounce)"});
	XI_TS_RST_SOURCE_ITEMS.push_back({"XI_TS_RST_SRC_GPI_10_INV",               36, "TimeStamp reset source selected GPI10 inverted (after de bounce)"});
	XI_TS_RST_SOURCE_ITEMS.push_back({"XI_TS_RST_SRC_GPI_11_INV",               37, "TimeStamp reset source selected GPI11 inverted (after de bounce)"});

	// structure containing information about parameters type
	XI_PRM_TYPE_ITEMS.push_back({"xiTypeInteger",                          0, "integer parameter type"});
	XI_PRM_TYPE_ITEMS.push_back({"xiTypeFloat",                            1, "float parameter type"});
	XI_PRM_TYPE_ITEMS.push_back({"xiTypeString",                           2, "string parameter type"});
	XI_PRM_TYPE_ITEMS.push_back({"xiTypeEnum",                             3, "enumerator parameter type"});
	XI_PRM_TYPE_ITEMS.push_back({"xiTypeBoolean",                          4, "boolean parameter type"});
	XI_PRM_TYPE_ITEMS.push_back({"xiTypeCommand",                          5, "command parameter type"});
	XI_PRM_TYPE_ITEMS.push_back({"xiTypeInteger64",                        6, "64bit integer parameter type"});

	// Turn parameter On/Off
	XI_SWITCH_ITEMS.push_back({"XI_OFF",                                 0, "Turn parameter off"});
	XI_SWITCH_ITEMS.push_back({"XI_ON",                                  1, "Turn parameter on"});

	// Temperature selector
	XI_TEMP_SELECTOR_ITEMS.push_back({"XI_TEMP_IMAGE_SENSOR_DIE_RAW",           0, "Image sensor die (non-calibrated)"});
	XI_TEMP_SELECTOR_ITEMS.push_back({"XI_TEMP_IMAGE_SENSOR_DIE",               1, "Image sensor die (calibrated)"});
	XI_TEMP_SELECTOR_ITEMS.push_back({"XI_TEMP_SENSOR_BOARD",                   2, "Image sensor PCB"});
	XI_TEMP_SELECTOR_ITEMS.push_back({"XI_TEMP_INTERFACE_BOARD",                3, "Data interface PCB"});
	XI_TEMP_SELECTOR_ITEMS.push_back({"XI_TEMP_FRONT_HOUSING",                  4, "Front part of camera housing"});
	XI_TEMP_SELECTOR_ITEMS.push_back({"XI_TEMP_REAR_HOUSING",                   5, "Rear part of camera housing"});
	XI_TEMP_SELECTOR_ITEMS.push_back({"XI_TEMP_TEC1_COLD",                      6, "TEC1 cold side temperature"});
	XI_TEMP_SELECTOR_ITEMS.push_back({"XI_TEMP_TEC1_HOT",                       7, "TEC1 hot side temperature"});
	XI_TEMP_SELECTOR_ITEMS.push_back({"XI_TEMP_VCSEL_BOARD_A",                  8, "VCSEL board temperature "});

	// Temperature selector
	XI_TEMP_CTRL_MODE_SELECTOR_ITEMS.push_back({"XI_TEMP_CTRL_MODE_OFF",                  0, "Controlling of elements (TEC/Peltier, Fans) is turned off"});
	XI_TEMP_CTRL_MODE_SELECTOR_ITEMS.push_back({"XI_TEMP_CTRL_MODE_AUTO",                 1, "Controlling of elements is performed automatically by API or camera in order to reach parameter TARGET_TEMP."});
	XI_TEMP_CTRL_MODE_SELECTOR_ITEMS.push_back({"XI_TEMP_CTRL_MODE_MANUAL",               2, "Controlling of elements is done manually by application."});

	// Temperature element selector
	XI_TEMP_ELEMENT_SELECTOR_ITEMS.push_back({"XI_TEMP_ELEM_TEC1",                      11, "TEC1 = TEC/Peltier that is closest to the image sensor"});
	XI_TEMP_ELEMENT_SELECTOR_ITEMS.push_back({"XI_TEMP_ELEM_TEC2",                      12, "TEC2 = TEC/Peltier location depends on camera model"});
	XI_TEMP_ELEMENT_SELECTOR_ITEMS.push_back({"XI_TEMP_ELEM_FAN1",                      31, "Temperature element fan current or rotation (FAN1 = Fan)"});
	XI_TEMP_ELEMENT_SELECTOR_ITEMS.push_back({"XI_TEMP_ELEM_FAN1_THRS_TEMP",            32, "Temperature element fan start rotation threshold temperature"});

	// Data packing(grouping) types.
	XI_OUTPUT_DATA_PACKING_TYPE_ITEMS.push_back({"XI_DATA_PACK_XI_GROUPING",               0, "Data grouping (10g160, 12g192, 14g224)."});
	XI_OUTPUT_DATA_PACKING_TYPE_ITEMS.push_back({"XI_DATA_PACK_PFNC_LSB_PACKING",          1, "Data packing (10p, 12p)"});

	// Downsampling types
	XI_DOWNSAMPLING_TYPE_ITEMS.push_back({"XI_BINNING",                             0, "pixels are interpolated - better image"});
	XI_DOWNSAMPLING_TYPE_ITEMS.push_back({"XI_SKIPPING",                            1, "pixels are skipped - higher frame rate"});

	// Exposure time selector
	XI_EXPOSURE_TIME_SELECTOR_TYPE_ITEMS.push_back({"XI_EXPOSURE_TIME_SELECTOR_COMMON",       0, "Selects the common Exposure Time"});
	XI_EXPOSURE_TIME_SELECTOR_TYPE_ITEMS.push_back({"XI_EXPOSURE_TIME_SELECTOR_GROUP1",       1, "Selects the common Exposure Time for pixel group 1 (for InterlineExposureMode)"});
	XI_EXPOSURE_TIME_SELECTOR_TYPE_ITEMS.push_back({"XI_EXPOSURE_TIME_SELECTOR_GROUP2",       2, "Selects the common Exposure Time for pixel group 2 (for InterlineExposureMode)"});
	XI_EXPOSURE_TIME_SELECTOR_TYPE_ITEMS.push_back({"XI_EXPOSURE_TIME_SELECTOR_DUAL_TRG_EXP_ZONE_1",3, "Selects the Exposure Time for Zone 1 (for Dual Trigger Exposure feature)"});
	XI_EXPOSURE_TIME_SELECTOR_TYPE_ITEMS.push_back({"XI_EXPOSURE_TIME_SELECTOR_DUAL_TRG_EXP_ZONE_2",4, "Selects the Exposure Time for Zone 2 (for Dual Trigger Exposure feature)"});

	// Interline exposure mode
	XI_INTERLINE_EXPOSURE_MODE_TYPE_ITEMS.push_back({"XI_INTERLINE_EXPOSURE_MODE_OFF",         0, "Disabled"});
	XI_INTERLINE_EXPOSURE_MODE_TYPE_ITEMS.push_back({"XI_INTERLINE_EXPOSURE_MODE_ON",          1, "Enabled"});

	// Gain selector
	XI_GAIN_SELECTOR_TYPE_ITEMS.push_back({"XI_GAIN_SELECTOR_ALL",                   0, "Gain selector selects all channels. Implementation of gain type depends on camera."});
	XI_GAIN_SELECTOR_TYPE_ITEMS.push_back({"XI_GAIN_SELECTOR_ANALOG_ALL",            1, "Gain selector selects all analog channels. This is available only on some cameras."});
	XI_GAIN_SELECTOR_TYPE_ITEMS.push_back({"XI_GAIN_SELECTOR_DIGITAL_ALL",           2, "Gain selector selects all digital channels. This is available only on some cameras."});
	XI_GAIN_SELECTOR_TYPE_ITEMS.push_back({"XI_GAIN_SELECTOR_ANALOG_TAP1",           3, "Gain selector selects tap 1. This is available only on some cameras."});
	XI_GAIN_SELECTOR_TYPE_ITEMS.push_back({"XI_GAIN_SELECTOR_ANALOG_TAP2",           4, "Gain selector selects tap 2. This is available only on some cameras."});
	XI_GAIN_SELECTOR_TYPE_ITEMS.push_back({"XI_GAIN_SELECTOR_ANALOG_TAP3",           5, "Gain selector selects tap 3. This is available only on some cameras."});
	XI_GAIN_SELECTOR_TYPE_ITEMS.push_back({"XI_GAIN_SELECTOR_ANALOG_TAP4",           6, "Gain selector selects tap 4. This is available only on some cameras."});
	XI_GAIN_SELECTOR_TYPE_ITEMS.push_back({"XI_GAIN_SELECTOR_ANALOG_N",              7, "First of two channels of programmable gain control (PGC) function - Gain setting of R, B pixels (North column analog gain). This is available only on some cameras."});
	XI_GAIN_SELECTOR_TYPE_ITEMS.push_back({"XI_GAIN_SELECTOR_ANALOG_S",              8, "Second of two channels of programmable gain control (PGC) function - Gain setting of Gr, Gb pixels (South column analog gain). This is available only on some cameras."});

	// Shutter mode types
	XI_SHUTTER_TYPE_ITEMS.push_back({"XI_SHUTTER_GLOBAL",                      0, "Sensor Global Shutter(CMOS sensor)"});
	XI_SHUTTER_TYPE_ITEMS.push_back({"XI_SHUTTER_ROLLING",                     1, "Sensor Electronic Rolling Shutter(CMOS sensor)"});
	XI_SHUTTER_TYPE_ITEMS.push_back({"XI_SHUTTER_GLOBAL_RESET_RELEASE",        2, "Sensor Global Reset Release Shutter(CMOS sensor)"});

	// structure containing information about CMS functionality
	XI_CMS_MODE_ITEMS.push_back({"XI_CMS_DIS",                             0, "disables color management"});
	XI_CMS_MODE_ITEMS.push_back({"XI_CMS_EN",                              1, "enables color management (high CPU usage)"});
	XI_CMS_MODE_ITEMS.push_back({"XI_CMS_EN_FAST",                         2, "enables fast color management (high RAM usage)"});

	// structure containing information about ICC Intents
	XI_CMS_INTENT_ITEMS.push_back({"XI_CMS_INTENT_PERCEPTUAL",               0, "CMS intent perceptual"});
	XI_CMS_INTENT_ITEMS.push_back({"XI_CMS_INTENT_RELATIVE_COLORIMETRIC",    1, "CMS intent relative colorimetry"});
	XI_CMS_INTENT_ITEMS.push_back({"XI_CMS_INTENT_SATURATION",               2, "CMS intent saturation"});
	XI_CMS_INTENT_ITEMS.push_back({"XI_CMS_INTENT_ABSOLUTE_COLORIMETRIC",    3, "CMS intent absolute colorimetry"});

	// structure containing information about options for selection of camera before opening
	XI_OPEN_BY_ITEMS.push_back({"XI_OPEN_BY_INST_PATH",                   0, "Open camera by its hardware path"});
	XI_OPEN_BY_ITEMS.push_back({"XI_OPEN_BY_SN",                          1, "Open camera by its serial number"});
	XI_OPEN_BY_ITEMS.push_back({"XI_OPEN_BY_USER_ID",                     2, "open camera by its custom user ID"});
	XI_OPEN_BY_ITEMS.push_back({"XI_OPEN_BY_LOC_PATH",                    3, "Open camera by its hardware location path"});

	// Lens feature selector selects which feature will be accessed.
	XI_LENS_FEATURE_ITEMS.push_back({"XI_LENS_FEATURE_MOTORIZED_FOCUS_SWITCH", 1, "Status of lens motorized focus switch"});
	XI_LENS_FEATURE_ITEMS.push_back({"XI_LENS_FEATURE_MOTORIZED_FOCUS_BOUNDED",2, "On read = 1 if motorized focus is on one of limits."});
	XI_LENS_FEATURE_ITEMS.push_back({"XI_LENS_FEATURE_MOTORIZED_FOCUS_CALIBRATION",3, "(planned feature) On read = 1 if motorized focus is calibrated. Write 1 to start calibration."});
	XI_LENS_FEATURE_ITEMS.push_back({"XI_LENS_FEATURE_IMAGE_STABILIZATION_ENABLED",4, "On read = 1 if image stabilization is enabled. Write 1 to enable image stabilization."});
	XI_LENS_FEATURE_ITEMS.push_back({"XI_LENS_FEATURE_IMAGE_STABILIZATION_SWITCH_STATUS",5, "On read = 1 if image stabilization switch is in position On."});
	XI_LENS_FEATURE_ITEMS.push_back({"XI_LENS_FEATURE_IMAGE_ZOOM_SUPPORTED",   6, "On read = 1 if lens supports zoom = are not prime."});

	// Sensor feature selector selects which feature will be accessed.
	XI_SENSOR_FEATURE_SELECTOR_ITEMS.push_back({"XI_SENSOR_FEATURE_ZEROROT_ENABLE",       0, "Sensor Zero ROT enable for ONSEMI PYTHON family. For camera model:MQ013xG-ON (on/off)"});
	XI_SENSOR_FEATURE_SELECTOR_ITEMS.push_back({"XI_SENSOR_FEATURE_BLACK_LEVEL_CLAMP",    1, "Black level offset clamping (value). for Camera model:MD"});
	XI_SENSOR_FEATURE_SELECTOR_ITEMS.push_back({"XI_SENSOR_FEATURE_MD_FPGA_DIGITAL_GAIN_DISABLE",2, "Disable digital component of gain for MD family (1=disabled/0=enabled)"});
	XI_SENSOR_FEATURE_SELECTOR_ITEMS.push_back({"XI_SENSOR_FEATURE_ACQUISITION_RUNNING",  3, "Sensor acquisition is running status (0/1). Could be stopped by setting of 0. For camera model:CB,MC,MX,MT"});
	XI_SENSOR_FEATURE_SELECTOR_ITEMS.push_back({"XI_SENSOR_FEATURE_TIMING_MODE",          4, "Sensor timing mode (value depends on sensor)"});
	XI_SENSOR_FEATURE_SELECTOR_ITEMS.push_back({"XI_SENSOR_FEATURE_PARALLEL_ADC",         5, " Enables the parallel ADC readout mode, where all exposed pixels undergo dual sampling, leading to reduced readout noise at the cost of increased readout time "});
	XI_SENSOR_FEATURE_SELECTOR_ITEMS.push_back({"XI_SENSOR_FEATURE_BLACK_LEVEL_OFFSET_RAW",6, "Sensor specific register raw black level offset (value)"});
	XI_SENSOR_FEATURE_SELECTOR_ITEMS.push_back({"XI_SENSOR_FEATURE_SHORT_INTERVAL_SHUTTER",7, "Sensor short Interval Shutter (on/off)"});
	XI_SENSOR_FEATURE_SELECTOR_ITEMS.push_back({"XI_SENSOR_FEATURE_AUTO_LOW_POWER_MODE_AUTO",8, "Sensor low power mode (on/off)"});
	XI_SENSOR_FEATURE_SELECTOR_ITEMS.push_back({"XI_SENSOR_FEATURE_HIGH_CONVERSION_GAIN", 9, "Enables high conversion gain feature which applies additional gain to the signal at the pixel level. This leads to a reduction in read noise and a boost in sensitivity and signal-to-noise ratio, particularly in low-light situations. Consequently, the camera exhibits superior performance in dark environments, capturing images with minimal noise and enhanced detail."});
	XI_SENSOR_FEATURE_SELECTOR_ITEMS.push_back({"XI_SENSOR_FEATURE_DUAL_TRG_EXP_ZONE_DIVIDER_POSITION",10, "Sensor Dual Trigger Exposure Zone Divider Position"});
	XI_SENSOR_FEATURE_SELECTOR_ITEMS.push_back({"XI_SENSOR_FEATURE_TOF_VCSEL_CTRL_VOLTAGE_MV",11, "ToF VCSEL Control Voltage in mV"});
	XI_SENSOR_FEATURE_SELECTOR_ITEMS.push_back({"XI_SENSOR_FEATURE_MULTIPLE_ADC",         12, "Multiple ADC"});
	XI_SENSOR_FEATURE_SELECTOR_ITEMS.push_back({"XI_SENSOR_FEATURE_FAST_TRIGGER_MODE_ENABLE",13, "Enables a sensor trigger mode that starts exposure immediately at the beginning of the trigger signal. When fast trigger mode is disabled, the camera operates in a trigger mode that allows exposure and readout to overlap, resulting in a higher FPS. For camera model: MU051xG. (on/off)"});

	// Camera sensor mode enumerator.
	XI_SENSOR_MODE_ITEMS.push_back({"XI_SENS_MD0",                            0, "Sensor mode number 0"});
	XI_SENSOR_MODE_ITEMS.push_back({"XI_SENS_MD1",                            1, "Sensor mode number 1"});
	XI_SENSOR_MODE_ITEMS.push_back({"XI_SENS_MD2",                            2, "Sensor mode number 2"});
	XI_SENSOR_MODE_ITEMS.push_back({"XI_SENS_MD3",                            3, "Sensor mode number 3"});
	XI_SENSOR_MODE_ITEMS.push_back({"XI_SENS_MD4",                            4, "Sensor mode number 4"});
	XI_SENSOR_MODE_ITEMS.push_back({"XI_SENS_MD5",                            5, "Sensor mode number 5"});
	XI_SENSOR_MODE_ITEMS.push_back({"XI_SENS_MD6",                            6, "Sensor mode number 6"});
	XI_SENSOR_MODE_ITEMS.push_back({"XI_SENS_MD7",                            7, "Sensor mode number 7"});
	XI_SENSOR_MODE_ITEMS.push_back({"XI_SENS_MD8",                            8, "Sensor mode number 8"});
	XI_SENSOR_MODE_ITEMS.push_back({"XI_SENS_MD9",                            9, "Sensor mode number 9"});
	XI_SENSOR_MODE_ITEMS.push_back({"XI_SENS_MD10",                           10, "Sensor mode number 10"});
	XI_SENSOR_MODE_ITEMS.push_back({"XI_SENS_MD11",                           11, "Sensor mode number 11"});
	XI_SENSOR_MODE_ITEMS.push_back({"XI_SENS_MD12",                           12, "Sensor mode number 12"});
	XI_SENSOR_MODE_ITEMS.push_back({"XI_SENS_MD13",                           13, "Sensor mode number 13"});
	XI_SENSOR_MODE_ITEMS.push_back({"XI_SENS_MD14",                           14, "Sensor mode number 14"});
	XI_SENSOR_MODE_ITEMS.push_back({"XI_SENS_MD15",                           15, "Sensor mode number 15"});

	// Defines image sensor area as output.
	XI_IMAGE_AREA_SELECTOR_ITEMS.push_back({"XI_IMAGE_AREA_ACTIVE",                   0, "All light sensitive pixels suggested by image vendor."});
	XI_IMAGE_AREA_SELECTOR_ITEMS.push_back({"XI_IMAGE_AREA_ACTIVE_AND_MASKED",        1, "All Active pixels plus masked pixels surrounding the Active area."});

	// Camera channel count enumerator.
	XI_SENSOR_OUTPUT_CHANNEL_COUNT_ITEMS.push_back({"XI_CHANN_CNT2",                          2, "2 sensor readout channels."});
	XI_SENSOR_OUTPUT_CHANNEL_COUNT_ITEMS.push_back({"XI_CHANN_CNT4",                          4, "4 sensor readout channels."});
	XI_SENSOR_OUTPUT_CHANNEL_COUNT_ITEMS.push_back({"XI_CHANN_CNT8",                          8, "8 sensor readout channels."});
	XI_SENSOR_OUTPUT_CHANNEL_COUNT_ITEMS.push_back({"XI_CHANN_CNT16",                         16, "16 sensor readout channels."});
	XI_SENSOR_OUTPUT_CHANNEL_COUNT_ITEMS.push_back({"XI_CHANN_CNT24",                         24, "24 sensor readout channels."});
	XI_SENSOR_OUTPUT_CHANNEL_COUNT_ITEMS.push_back({"XI_CHANN_CNT32",                         32, "32 sensor readout channels."});
	XI_SENSOR_OUTPUT_CHANNEL_COUNT_ITEMS.push_back({"XI_CHANN_CNT48",                         48, "48 sensor readout channels."});

	// Sensor defects correction list selector
	XI_SENS_DEFFECTS_CORR_LIST_SELECTOR_ITEMS.push_back({"XI_SENS_DEFFECTS_CORR_LIST_SEL_FACTORY", 0, "Factory defect correction list"});
	XI_SENS_DEFFECTS_CORR_LIST_SELECTOR_ITEMS.push_back({"XI_SENS_DEFFECTS_CORR_LIST_SEL_USER0",   1, "User defect correction list"});
	XI_SENS_DEFFECTS_CORR_LIST_SELECTOR_ITEMS.push_back({"XI_SENS_DEFFECTS_CORR_LIST_SEL_IN_CAMERA",2, "Device specific defect correction list"});

	// Acquisition status Selector
	XI_ACQUISITION_STATUS_SELECTOR_ITEMS.push_back({"XI_ACQUISITION_STATUS_ACQ_ACTIVE",       0, " Device is currently doing an acquisition of one or many frames."});

	// Select unit where data-pipe is configured
	XI_DP_UNIT_SELECTOR_ITEMS.push_back({"XI_DP_UNIT_SENSOR",                      0, "Selects device image sensor"});
	XI_DP_UNIT_SELECTOR_ITEMS.push_back({"XI_DP_UNIT_FPGA",                        1, "Selects device image FPGA"});

	// Select unit processor
	XI_DP_PROC_SELECTOR_ITEMS.push_back({"XI_DP_PROC_NONE",                        0, "Default empty processor"});
	XI_DP_PROC_SELECTOR_ITEMS.push_back({"XI_DP_PROC_CHANNEL_MUXER",               1, "Channel Muxer (selected processor combines multiple input channels)"});
	XI_DP_PROC_SELECTOR_ITEMS.push_back({"XI_DP_PROC_PIXEL_SEQUENCER",             2, "Selects pixel data output sequence"});
	XI_DP_PROC_SELECTOR_ITEMS.push_back({"XI_DP_PROC_CHANNEL_1",                   3, "Selects sensor output channel 1"});
	XI_DP_PROC_SELECTOR_ITEMS.push_back({"XI_DP_PROC_CHANNEL_2",                   4, "Selects sensor output channel 2"});
	XI_DP_PROC_SELECTOR_ITEMS.push_back({"XI_DP_PROC_FRAME_BUFFER",                5, "Selects frame buffer memory"});

	// Select processor parameter
	XI_DP_PARAM_SELECTOR_ITEMS.push_back({"XI_DP_PARAM_NONE",                       0, "Empty parameter"});
	XI_DP_PARAM_SELECTOR_ITEMS.push_back({"XI_DP_PARAM_CHMUX_CHANNEL_SELECTOR",     1, "Defines output of Channel Muxer processor"});
	XI_DP_PARAM_SELECTOR_ITEMS.push_back({"XI_DP_PARAM_CHMUX_ALPHA",                2, "Channel merger coefficient Alpha"});
	XI_DP_PARAM_SELECTOR_ITEMS.push_back({"XI_DP_PARAM_CHMUX_BETA",                 3, "Channel merger coefficient Beta"});
	XI_DP_PARAM_SELECTOR_ITEMS.push_back({"XI_DP_PARAM_PIXSEQ_SELECTOR",            4, "PixSeq Selector"});
	XI_DP_PARAM_SELECTOR_ITEMS.push_back({"XI_DP_PARAM_CHANNEL_TIMING",             5, "Selected channel timing"});
	XI_DP_PARAM_SELECTOR_ITEMS.push_back({"XI_DP_PARAM_FRAMEBUF_MODE",              6, "Frame Buffer Mode"});
	XI_DP_PARAM_SELECTOR_ITEMS.push_back({"XI_DP_PARAM_FRAMEBUF_SIZE",              7, "Frame Buffer Size Bytes"});

	// Select processor parameter value
	XI_DP_PARAM_VALUE_ITEMS.push_back({"XI_DP_PARAM_VALUE_CHMUX_CHANNEL_1",      0, "Selected source channel 1"});
	XI_DP_PARAM_VALUE_ITEMS.push_back({"XI_DP_PARAM_VALUE_CHMUX_CHANNEL_2",      1, "Selected source channel 2"});
	XI_DP_PARAM_VALUE_ITEMS.push_back({"XI_DP_PARAM_VALUE_CHMUX_CHANNEL_1_2",    2, "Selected source channel 1 and 2"});
	XI_DP_PARAM_VALUE_ITEMS.push_back({"XI_DP_PARAM_VALUE_CHMUX_MERGED",         3, "Merged data of two channels"});
	XI_DP_PARAM_VALUE_ITEMS.push_back({"XI_DP_PARAM_VALUE_CHMUX_CMS_S",          4, "Correlated Multiple Sampling(summing)"});
	XI_DP_PARAM_VALUE_ITEMS.push_back({"XI_DP_PARAM_VALUE_PIXSEQ_ONE_VALUE",     5, "Output is one value per pixel"});
	XI_DP_PARAM_VALUE_ITEMS.push_back({"XI_DP_PARAM_VALUE_PIXSEQ_TWO_VALUES",    6, "Output are two values per pixel"});
	XI_DP_PARAM_VALUE_ITEMS.push_back({"XI_DP_PARAM_VALUE_CHTIM_HG",             7, "High Gain channel timing"});
	XI_DP_PARAM_VALUE_ITEMS.push_back({"XI_DP_PARAM_VALUE_CHTIM_LG",             8, "Low Gain channel timing"});
	XI_DP_PARAM_VALUE_ITEMS.push_back({"XI_DP_PARAM_VALUE_FRAMEBUF_MODE_DISABLED",9, "Frame buffer is disabled"});
	XI_DP_PARAM_VALUE_ITEMS.push_back({"XI_DP_PARAM_VALUE_FRAMEBUF_MODE_ENABLED",10, "Frame buffer is on"});
	XI_DP_PARAM_VALUE_ITEMS.push_back({"XI_DP_PARAM_VALUE_PIXSEQ_FOUR_VALUES",   11, "Output are four values per pixel"});
	XI_DP_PARAM_VALUE_ITEMS.push_back({"XI_DP_PARAM_VALUE_CHMUX_CMS_A",          12, "Correlated Multiple Sampling(averaging)"});

	// User Set selector options.
	XI_USER_SET_SELECTOR_ITEMS.push_back({"XI_US_12_STD_L",                         10, "12bit per channel STD Low Gain mode preset."});
	XI_USER_SET_SELECTOR_ITEMS.push_back({"XI_US_12_STD_H",                         11, "12bit per channel STD High Gain mode preset."});
	XI_USER_SET_SELECTOR_ITEMS.push_back({"XI_US_14_STD_L",                         12, "14bit per channel STD Low Gain mode preset."});
	XI_USER_SET_SELECTOR_ITEMS.push_back({"XI_US_NONE",                             999, "No preset selected."});
	XI_USER_SET_SELECTOR_ITEMS.push_back({"XI_US_14_STD_H",                         13, "14bit per channel STD High Gain mode preset."});
	XI_USER_SET_SELECTOR_ITEMS.push_back({"XI_US_2_12_CMS_S_L",                     14, "12bit per channel, 2 samples,  CMS(summing) Low Gain mode preset."});
	XI_USER_SET_SELECTOR_ITEMS.push_back({"XI_US_2_12_CMS_S_H",                     15, "12bit per channel, 2 samples,  CMS(summing) High Gain mode preset."});
	XI_USER_SET_SELECTOR_ITEMS.push_back({"XI_US_2_14_CMS_S_L",                     16, "14bit per channel, 2 samples,  CMS(summing) Low Gain mode preset."});
	XI_USER_SET_SELECTOR_ITEMS.push_back({"XI_US_2_14_CMS_S_H",                     17, "14bit per channel, 2 samples,  CMS(summing) High Gain mode preset."});
	XI_USER_SET_SELECTOR_ITEMS.push_back({"XI_US_4_12_CMS_S_L",                     18, "12bit per channel, 4 samples,  CMS(summing) Low Gain mode preset."});
	XI_USER_SET_SELECTOR_ITEMS.push_back({"XI_US_4_12_CMS_S_H",                     19, "12bit per channel, 4 samples,  CMS(summing) High Gain mode preset."});
	XI_USER_SET_SELECTOR_ITEMS.push_back({"XI_US_4_14_CMS_S_L",                     20, "14bit per channel, 4 samples,  CMS(summing) Low Gain mode preset."});
	XI_USER_SET_SELECTOR_ITEMS.push_back({"XI_US_4_14_CMS_S_H",                     21, "14bit per channel, 4 samples,  CMS(summing) High Gain mode preset."});
	XI_USER_SET_SELECTOR_ITEMS.push_back({"XI_US_2_12_HDR_HL",                      22, "12bit per channel, 2 samples,  HDR High Low Gain mode preset."});
	XI_USER_SET_SELECTOR_ITEMS.push_back({"XI_US_2_12_HDR_L",                       23, "12bit per channel, 2 samples,  HDR Low Gain mode preset."});
	XI_USER_SET_SELECTOR_ITEMS.push_back({"XI_US_2_12_HDR_H",                       24, "12bit per channel, 2 samples,  HDR High Gain mode preset."});
	XI_USER_SET_SELECTOR_ITEMS.push_back({"XI_US_4_12_CMS_HDR_HL",                  25, "12bit per channel, 4 samples,  CMS + HDR High Low Gain mode preset."});
	XI_USER_SET_SELECTOR_ITEMS.push_back({"XI_US_2_14_HDR_L",                       26, "14bit per channel, 2 samples,  HDR Low Gain mode preset."});
	XI_USER_SET_SELECTOR_ITEMS.push_back({"XI_US_2_14_HDR_H",                       27, "14bit per channel, 2 samples,  HDR High Gain mode preset."});
	XI_USER_SET_SELECTOR_ITEMS.push_back({"XI_US_2_12_CMS_A_L",                     28, "12bit per channel, 2 samples,  CMS(averaging) Low Gain mode preset."});
	XI_USER_SET_SELECTOR_ITEMS.push_back({"XI_US_2_12_CMS_A_H",                     29, "12bit per channel, 2 samples,  CMS(averaging) High Gain mode preset."});
	XI_USER_SET_SELECTOR_ITEMS.push_back({"XI_US_TOF_DEFAULT",                      30, ""});
	XI_USER_SET_SELECTOR_ITEMS.push_back({"XI_US_TOF_LONG_RANGE",                   31, ""});
	XI_USER_SET_SELECTOR_ITEMS.push_back({"XI_US_TOF_SINGLE_READOUT",               32, ""});
	XI_USER_SET_SELECTOR_ITEMS.push_back({"XI_US_TOF_DEFAULT_EXT_CDS",              33, ""});
	XI_USER_SET_SELECTOR_ITEMS.push_back({"XI_US_TOF_LONG_RANGE_EXT_CDS",           34, ""});
	XI_USER_SET_SELECTOR_ITEMS.push_back({"XI_US_TOF_SINGLE_READOUT_EXT_CDS",       35, ""});

	// Mode of DualADC feature
	XI_DUAL_ADC_MODE_ITEMS.push_back({"XI_DUAL_ADC_MODE_OFF",                   0, "Disable DualADC feature"});
	XI_DUAL_ADC_MODE_ITEMS.push_back({"XI_DUAL_ADC_MODE_COMBINED",              1, "Set Combined mode"});
	XI_DUAL_ADC_MODE_ITEMS.push_back({"XI_DUAL_ADC_MODE_NON_COMBINED",          2, "Set NonCombined mode"});

	// Probe Selector
	XI_PROBE_SELECTOR_ITEMS.push_back({"XI_PROBE_SELECTOR_CURRENT_MAINBOARD_VCC_IN",0, "Current probe on Main Board at VCC_IN power supply"});
	XI_PROBE_SELECTOR_ITEMS.push_back({"XI_PROBE_SELECTOR_VOLTAGE_MAINBOARD_VCC_IN",1, "Voltage probe on Main Board at VCC_IN power supply"});
	XI_PROBE_SELECTOR_ITEMS.push_back({"XI_PROBE_SELECTOR_CURRENT_MAINBOARD_VCC_ADJ2",2, "Current probe on Main Board at VCC_ADJ2 power supply"});
	XI_PROBE_SELECTOR_ITEMS.push_back({"XI_PROBE_SELECTOR_VOLTAGE_MAINBOARD_VCC_ADJ2",3, "Voltage probe on Main Board at VCC_ADJ2 power supply"});
	XI_PROBE_SELECTOR_ITEMS.push_back({"XI_PROBE_SELECTOR_CURRENT_MAINBOARD_VCC_ADJ1",4, "Current probe on Main Board at VCC_ADJ1 power supply"});
	XI_PROBE_SELECTOR_ITEMS.push_back({"XI_PROBE_SELECTOR_VOLTAGE_MAINBOARD_VCC_ADJ1",5, "Voltage probe on Main Board at VCC_ADJ1 power supply"});
	XI_PROBE_SELECTOR_ITEMS.push_back({"XI_PROBE_SELECTOR_CURRENT_MAINBOARD_VCC_PLT",6, "Current probe on Main Board at VCC_PLT power supply"});
	XI_PROBE_SELECTOR_ITEMS.push_back({"XI_PROBE_SELECTOR_VOLTAGE_MAINBOARD_VCC_PLT",7, "Voltage probe on Main Board at VCC_PLT power supply"});
	XI_PROBE_SELECTOR_ITEMS.push_back({"XI_PROBE_SELECTOR_VOLTAGE_SENSORBOARD_VCC_ADJ1",8, "Voltage probe on Sensor Board at VCC_ADJ1"});
	XI_PROBE_SELECTOR_ITEMS.push_back({"XI_PROBE_SELECTOR_VOLTAGE_SENSORBOARD_VCC_ADJ2",9, "Voltage probe on Sensor Board at VCC_ADJ2"});
	XI_PROBE_SELECTOR_ITEMS.push_back({"XI_PROBE_SELECTOR_VOLTAGE_SENSORBOARD_VCC_5V0",10, "Voltage probe on Sensor Board at VCC_5V0"});
	XI_PROBE_SELECTOR_ITEMS.push_back({"XI_PROBE_SELECTOR_VOLTAGE_SENSORBOARD_VCC_3V3",11, "Voltage probe on Sensor Board at VCC_3V3"});
	XI_PROBE_SELECTOR_ITEMS.push_back({"XI_PROBE_SELECTOR_VOLTAGE_DATA_CON_INPUT",12, "Voltage probe on device input, if device is bus powered"});
	XI_PROBE_SELECTOR_ITEMS.push_back({"XI_PROBE_SELECTOR_VOLTAGE_PELTIER1",     13, "Voltage probe on peltier #1"});
	XI_PROBE_SELECTOR_ITEMS.push_back({"XI_PROBE_SELECTOR_CURRENT_PELTIER1",     14, "Current probe on peltier #1"});
	XI_PROBE_SELECTOR_ITEMS.push_back({"XI_PROBE_SELECTOR_VOLTAGE_PELTIER2",     15, "Voltage probe on peltier #2"});
	XI_PROBE_SELECTOR_ITEMS.push_back({"XI_PROBE_SELECTOR_CURRENT_PELTIER2",     16, "Current probe on peltier #2"});
	XI_PROBE_SELECTOR_ITEMS.push_back({"XI_PROBE_SELECTOR_VOLTAGE_MAINBOARD_VCC_5V0",17, "Voltage probe on Main Board at VCC_5V0 power supply "});
	XI_PROBE_SELECTOR_ITEMS.push_back({"XI_PROBE_SELECTOR_CURRENT_MAINBOARD_VCC_5V0",18, "Current probe on Main Board at VCC_5V0 power supply"});

	// ToF Readout Mode feature
	XI_TOF_READOUT_MODE_ITEMS.push_back({"XI_TOF_READOUT_MODE_A_ONLY",             0, "A Only readout mode"});
	XI_TOF_READOUT_MODE_ITEMS.push_back({"XI_TOF_READOUT_MODE_B_ONLY",             1, "B Only readout mode"});
	XI_TOF_READOUT_MODE_ITEMS.push_back({"XI_TOF_READOUT_MODE_A_MINUS_B",          2, "A Minus B readout mode"});
	XI_TOF_READOUT_MODE_ITEMS.push_back({"XI_TOF_READOUT_MODE_A_PLUS_B",           3, "A Plus B readout mode"});
	XI_TOF_READOUT_MODE_ITEMS.push_back({"XI_TOF_READOUT_MODE_A_AND_B",            4, "A And B readout mode"});

	// Image data signedness
	XI_DATA_SM_ITEMS.push_back({"XI_DATA_SM_UNSIGNED",                    0, "Unsigned if it can only represent non-negative numbers (zero or positive numbers)."});
	XI_DATA_SM_ITEMS.push_back({"XI_DATA_SM_SIGNED_2C",                   1, "Signed if it can represent both positive and negative numbers (two's complement)."});
	XI_DATA_SM_ITEMS.push_back({"XI_DATA_SM_SIGNED_FLOATING",             2, "Signed floating point data type."});


	XI_RET_ITEMS.push_back({"XI_OK",                              0, " Function call succeeded"});
	XI_RET_ITEMS.push_back({"XI_INVALID_HANDLE",                  1, " Invalid handle"});
	XI_RET_ITEMS.push_back({"XI_READREG",                         2, " Register read error"});
	XI_RET_ITEMS.push_back({"XI_WRITEREG",                        3, " Register write error"});
	XI_RET_ITEMS.push_back({"XI_FREE_RESOURCES",                  4, " Freeing resources error"});
	XI_RET_ITEMS.push_back({"XI_FREE_CHANNEL",                    5, " Freeing channel error"});
	XI_RET_ITEMS.push_back({"XI_FREE_BANDWIDTH",                  6, " Freeing bandwith error"});
	XI_RET_ITEMS.push_back({"XI_READBLK",                         7, " Read block error"});
	XI_RET_ITEMS.push_back({"XI_WRITEBLK",                        8, " Write block error"});
	XI_RET_ITEMS.push_back({"XI_NO_IMAGE",                        9, " No image"});
	XI_RET_ITEMS.push_back({"XI_TIMEOUT",                        10, " Timeout"});
	XI_RET_ITEMS.push_back({"XI_INVALID_ARG",                    11, " Invalid arguments supplied"});
	XI_RET_ITEMS.push_back({"XI_NOT_SUPPORTED",                  12, " Not supported"});
	XI_RET_ITEMS.push_back({"XI_ISOCH_ATTACH_BUFFERS",           13, " Attach buffers error"});
	XI_RET_ITEMS.push_back({"XI_GET_OVERLAPPED_RESULT",          14, " Overlapped result"});
	XI_RET_ITEMS.push_back({"XI_MEMORY_ALLOCATION",              15, " Memory allocation error"});
	XI_RET_ITEMS.push_back({"XI_DLLCONTEXTISNULL",               16, " DLL context is NULL"});
	XI_RET_ITEMS.push_back({"XI_DLLCONTEXTISNONZERO",            17, " DLL context is non zero"});
	XI_RET_ITEMS.push_back({"XI_DLLCONTEXTEXIST",                18, " DLL context exists"});
	XI_RET_ITEMS.push_back({"XI_TOOMANYDEVICES",                 19, " Too many devices connected"});
	XI_RET_ITEMS.push_back({"XI_ERRORCAMCONTEXT",                20, " Camera context error"});
	XI_RET_ITEMS.push_back({"XI_UNKNOWN_HARDWARE",               21, " Unknown hardware"});
	XI_RET_ITEMS.push_back({"XI_INVALID_TM_FILE",                22, " Invalid TM file"});
	XI_RET_ITEMS.push_back({"XI_INVALID_TM_TAG",                 23, " Invalid TM tag"});
	XI_RET_ITEMS.push_back({"XI_INCOMPLETE_TM",                  24, " Incomplete TM"});
	XI_RET_ITEMS.push_back({"XI_BUS_RESET_FAILED",               25, " Bus reset error"});
	XI_RET_ITEMS.push_back({"XI_NOT_IMPLEMENTED",                26, " Not implemented"});
	XI_RET_ITEMS.push_back({"XI_SHADING_TOOBRIGHT",              27, " Shading is too bright"});
	XI_RET_ITEMS.push_back({"XI_SHADING_TOODARK",                28, " Shading is too dark"});
	XI_RET_ITEMS.push_back({"XI_TOO_LOW_GAIN",                   29, " Gain is too low"});
	XI_RET_ITEMS.push_back({"XI_INVALID_BPL",                    30, " Invalid sensor defect correction list"});
	XI_RET_ITEMS.push_back({"XI_BPL_REALLOC",                    31, " Error while sensor defect correction list reallocation"});
	XI_RET_ITEMS.push_back({"XI_INVALID_PIXEL_LIST",             32, " Invalid pixel list"});
	XI_RET_ITEMS.push_back({"XI_INVALID_FFS",                    33, " Invalid Flash File System"});
	XI_RET_ITEMS.push_back({"XI_INVALID_PROFILE",                34, " Invalid profile"});
	XI_RET_ITEMS.push_back({"XI_INVALID_CALIBRATION",            35, " Invalid calibration"});
	XI_RET_ITEMS.push_back({"XI_INVALID_BUFFER",                 36, " Invalid buffer"});
	XI_RET_ITEMS.push_back({"XI_INVALID_DATA",                   38, " Invalid data"});
	XI_RET_ITEMS.push_back({"XI_TGBUSY",                         39, " Timing generator is busy"});
	XI_RET_ITEMS.push_back({"XI_IO_WRONG",                       40, " Wrong operation open/write/read/close"});
	XI_RET_ITEMS.push_back({"XI_ACQUISITION_ALREADY_UP",         41, " Acquisition already started"});
	XI_RET_ITEMS.push_back({"XI_OLD_DRIVER_VERSION",             42, " Old version of device driver installed to the system."});
	XI_RET_ITEMS.push_back({"XI_GET_LAST_ERROR",                 43, " To get error code please call GetLastError function."});
	XI_RET_ITEMS.push_back({"XI_CANT_PROCESS",                   44, " Data cannot be processed"});
	XI_RET_ITEMS.push_back({"XI_ACQUISITION_STOPED",             45, " Acquisition is stopped. It needs to be started to perform operation."});
	XI_RET_ITEMS.push_back({"XI_ACQUISITION_STOPED_WERR",        46, " Acquisition has been stopped with an error."});
	XI_RET_ITEMS.push_back({"XI_INVALID_INPUT_ICC_PROFILE",      47, " Input ICC profile missing or corrupted"});
	XI_RET_ITEMS.push_back({"XI_INVALID_OUTPUT_ICC_PROFILE",     48, " Output ICC profile missing or corrupted"});
	XI_RET_ITEMS.push_back({"XI_DEVICE_NOT_READY",               49, " Device not ready to operate"});
	XI_RET_ITEMS.push_back({"XI_SHADING_TOOCONTRAST",            50, " Shading is too contrast"});
	XI_RET_ITEMS.push_back({"XI_ALREADY_INITIALIZED",            51, " Module already initialized"});
	XI_RET_ITEMS.push_back({"XI_NOT_ENOUGH_PRIVILEGES",          52, " Application does not have enough privileges (one or more app)"});
	XI_RET_ITEMS.push_back({"XI_NOT_COMPATIBLE_DRIVER",          53, " Installed driver is not compatible with current software"});
	XI_RET_ITEMS.push_back({"XI_TM_INVALID_RESOURCE",            54, " TM file was not loaded successfully from resources"});
	XI_RET_ITEMS.push_back({"XI_DEVICE_HAS_BEEN_RESETED",        55, " Device has been reset, abnormal initial state"});
	XI_RET_ITEMS.push_back({"XI_NO_DEVICES_FOUND",               56, " No Devices Found"});
	XI_RET_ITEMS.push_back({"XI_RESOURCE_OR_FUNCTION_LOCKED",    57, " Resource (device) or function locked by mutex"});
	XI_RET_ITEMS.push_back({"XI_BUFFER_SIZE_TOO_SMALL",          58, " Buffer provided by user is too small"});
	XI_RET_ITEMS.push_back({"XI_COULDNT_INIT_PROCESSOR",         59, " Could not initialize processor."});
	XI_RET_ITEMS.push_back({"XI_NOT_INITIALIZED",                60, " The object/module/procedure/process being referred to has not been started."});
	XI_RET_ITEMS.push_back({"XI_RESOURCE_NOT_FOUND",             61, " Resource not found(could be processor, file, item...)."});
	XI_RET_ITEMS.push_back({"XI_UNKNOWN_PARAM",                  100, " Unknown parameter"});
	XI_RET_ITEMS.push_back({"XI_WRONG_PARAM_VALUE",              101, " Wrong parameter value"});
	XI_RET_ITEMS.push_back({"XI_WRONG_PARAM_TYPE",               103, " Wrong parameter type"});
	XI_RET_ITEMS.push_back({"XI_WRONG_PARAM_SIZE",               104, " Wrong parameter size"});
	XI_RET_ITEMS.push_back({"XI_BUFFER_TOO_SMALL",               105, " Input buffer is too small"});
	XI_RET_ITEMS.push_back({"XI_NOT_SUPPORTED_PARAM",            106, " Parameter is not supported"});
	XI_RET_ITEMS.push_back({"XI_NOT_SUPPORTED_PARAM_INFO",       107, " Parameter info not supported"});
	XI_RET_ITEMS.push_back({"XI_NOT_SUPPORTED_DATA_FORMAT",      108, " Data format is not supported"});
	XI_RET_ITEMS.push_back({"XI_READ_ONLY_PARAM",                109, " Read only parameter"});
	XI_RET_ITEMS.push_back({"XI_BANDWIDTH_NOT_SUPPORTED",        111, " This camera does not support currently available bandwidth"});
	XI_RET_ITEMS.push_back({"XI_INVALID_FFS_FILE_NAME",          112, " FFS file selector is invalid or NULL"});
	XI_RET_ITEMS.push_back({"XI_FFS_FILE_NOT_FOUND",             113, " FFS file not found"});
	XI_RET_ITEMS.push_back({"XI_PARAM_NOT_SETTABLE",             114, " Parameter value cannot be set (might be out of range or invalid)."});
	XI_RET_ITEMS.push_back({"XI_SAFE_POLICY_NOT_SUPPORTED",      115, " Safe buffer policy is not supported. E.g. when transport target is set to GPU (GPUDirect)."});
	XI_RET_ITEMS.push_back({"XI_GPUDIRECT_NOT_AVAILABLE",        116, " GPUDirect is not available. E.g. platform isn't supported or CUDA toolkit isn't installed."});
	XI_RET_ITEMS.push_back({"XI_INCORRECT_SENS_ID_CHECK",        117, " Incorrect sensor board unique identifier checksum."});
	XI_RET_ITEMS.push_back({"XI_INCORRECT_FPGA_TYPE",            118, " Incorrect or unknown FPGA firmware type used for camera."});
	XI_RET_ITEMS.push_back({"XI_PARAM_CONDITIONALLY_NOT_AVAILABLE",119, " Parameter is not available in current context. Available only if another feature is turned on."});
	XI_RET_ITEMS.push_back({"XI_ERR_FRAME_BUFFER_RAM_INIT",      120, " Frame buffer RAM initialization error."});
	XI_RET_ITEMS.push_back({"XI_NOT_SUPPORTED_WHILE_ACQUISITION ",121, " Parameter is not supported while acquisition is running."});
	XI_RET_ITEMS.push_back({"XI_PROC_OTHER_ERROR",               201, " Processing error - other"});
	XI_RET_ITEMS.push_back({"XI_PROC_PROCESSING_ERROR",          202, " Error while image processing."});
	XI_RET_ITEMS.push_back({"XI_PROC_INPUT_FORMAT_UNSUPPORTED",  203, " Input format is not supported for processing."});
	XI_RET_ITEMS.push_back({"XI_PROC_OUTPUT_FORMAT_UNSUPPORTED", 204, " Output format is not supported for processing."});
	XI_RET_ITEMS.push_back({"XI_OUT_OF_RANGE",                   205, " Parameter value is out of range"});
	XI_RET_ITEMS.push_back({"XIPR_OK",                              0, " Result OK"});
	XI_RET_ITEMS.push_back({"XIPR_INVALID_ARG",                  1001, " Invalid argument detected (out of range)"});
	XI_RET_ITEMS.push_back({"XIPR_NOT_IMPLEMENTED",              1002, " Implementation is not yet done"});
	XI_RET_ITEMS.push_back({"XIPR_NOT_SUPPORTED",                1003, " This value is not supported"});
	XI_RET_ITEMS.push_back({"XIPR_UNKNOWN_PARAM",                1004, " Using of unknown parameter"});
	XI_RET_ITEMS.push_back({"XIPR_INPUT_BUFFER_NOT_ALLOCATED",   1005, " Input buffer is not allocated"});
	XI_RET_ITEMS.push_back({"XIPR_OUTPUT_BUFFER_NOT_ALLOCATED",  1006, " Output buffer is not allocated"});
	XI_RET_ITEMS.push_back({"XIPR_OUTPUT_BUFFER_MEMORY_ALLOCATION_ERROR",1007, " Output buffer allocation error"});
	XI_RET_ITEMS.push_back({"XIPR_NO_PROCESSORS_AVAILABLE",      1008, " There are no processors in chain"});
	XI_RET_ITEMS.push_back({"XIPR_INVALID_REQUIREMENTS",         1009, " Some requirement is not met"});
	XI_RET_ITEMS.push_back({"XIPR_NO_MORE_SPACE_IN_PROCESSORS_CHAIN",1010, " Processors chain is full"});
	XI_RET_ITEMS.push_back({"XIPR_PROCESSOR_NOT_INITIALIZED",    1011, " Processor is not initialized yet"});
	XI_RET_ITEMS.push_back({"XIPR_PROCESSING_ERROR",             1012, " Processor generates error"});
	XI_RET_ITEMS.push_back({"XIPR_UNKNOWN_DATA_FORMAT",          1013, " Unknown data format"});
	XI_RET_ITEMS.push_back({"XIPR_UNKNOWN_CFA_PATTERN",          1014, " Unknown color filter array pattern type"});
	XI_RET_ITEMS.push_back({"XIPR_UNKNOWN_LOAD_LIBRARY",         1020, " Couldn't load library"});
	XI_RET_ITEMS.push_back({"XIPR_UNKNOWN_LOAD_LIBRARY_FUNC",    1021, " Couldn't load function"});
	XI_RET_ITEMS.push_back({"XIPR_UNKNOWN_OPEN_PROCESS",         1022, " Couldn't open process"});
	XI_RET_ITEMS.push_back({"XIPR_UNKNOWN_BPL_STRING",           1023, " Couldn't open process"});
	XI_RET_ITEMS.push_back({"XIPR_UNSUPPORTED_INPUT_FORMAT",     1024, " Unsupported input format"});
	XI_RET_ITEMS.push_back({"XIPR_UNSUPPORTED_OUTPUT_FORMAT",    1025, " Unsupported output format"});
	XI_RET_ITEMS.push_back({"XIPR_IMAGE_INTENSITY_OUT_OF_RANGE", 1026, " Image intensity is our of range"});
	XI_RET_ITEMS.push_back({"XIPR_TIMEOUT_WAITING_FOR_EVENT",    1027, " Timeout waiting for event"});
	XI_RET_ITEMS.push_back({"XIPR_PROCESSOR_EXECUTION_DISABLED", 1028, " Processor execution disabled"});
	XI_RET_ITEMS.push_back({"XIPR_DEFECT_ALREADY_IN_LIST",       1029, " Defect already in list"});
	XI_RET_ITEMS.push_back({"XIPR_ERROR_OPEN_FILE",              1030, " Couldn't open input file"});
	XI_RET_ITEMS.push_back({"XIPR_ERROR_MEMORY_ALLOCATE",        1031, " Couldn't allocate memory"});
	XI_RET_ITEMS.push_back({"XIPR_ERROR_READ_OPERATION",         1032, " Couldn't read"});
	XI_RET_ITEMS.push_back({"XIPR_ERROR_WRITE_OPERATION",        1033, " Couldn't write"});
	XI_RET_ITEMS.push_back({"XIPR_READ_ONLY_OPERATION",          1034, " Operation is read only"});
	XI_RET_ITEMS.push_back({"XIPR_FFC_INCORRECT_DATA_FORMAT",    1035, " Input data not compatible with current FFC processor settings"});
	XI_RET_ITEMS.push_back({"XIPR_IMAGE_CANT_PROCESSED_DUETO_WIDTH_ALIGNMENT",1036, " Image can't be processed due to image width alignment is not supported by Image Processor."});
		
}


xiAPIplus_Enumerators::param_item_t::param_item_t()
{
	name = NULL;
	value = 0;
	description = NULL;
}

xiAPIplus_Enumerators::param_item_t::param_item_t(const char * in_name, int in_value, const char * in_description)
{
	name = in_name;
	value = in_value;
	description = in_description;
}

xiAPIplus_Enumerators::param_item_t * xiAPIplus_Enumerators::FindItem(std::vector<param_item_t> * param_vector, int item_val)
{
	for (unsigned int i=0;i<param_vector->size();i++)
	{
		if ((*param_vector)[i].value==item_val)
		{			
			return &((*param_vector)[i]);
		}
	}
	return NULL;
}
//-------------------------------------------------------------------------------------------------------------------
// xiAPIplus implementation file
// XIMEA Application Programming Interface Object Oriented Approach
//-------------------------------------------------------------------------------------------------------------------

//#include <os_common_header.h>
//#include <stdio.h>
//#include <cstring>
//#include <xiAPIplus/xiapiplus.h>

#ifdef WIN32
// disable warning C4996: 'sprintf': This function or variable may be unsafe - use _CRT_SECURE_NO_WARNINGS
#pragma warning(disable:4996)
#endif

// forward declarations

void ReportException(XI_RETURN res, const char* location);

// -----------------------------------------------
// parameters handlers implementation
// -----------------------------------------------

//#include "xiAPIplus_parameters.cpp"

// -----------------------------------------------
// xiAPIplus
// -----------------------------------------------

unsigned long xiAPIplus::GetNumberOfConnectedCameras()
{
	DWORD count=0;
	XI_RETURN res=xiGetNumberDevices(&count);
	if (res) ReportException(res,"GetNumberOfConnectedCameras");
	return count;
}

// exception handling
void ReportException(XI_RETURN res, const char* location)
{
	// generate exception
	char descr[200]="(missing_error_description)";
	int total_errors=sizeof(xiAPIplus_errorcodes_list)/sizeof(xiapi_errorcode_t);
	// find description
	for(int i=0;i<total_errors;i++)
	{
		if (xiAPIplus_errorcodes_list[i].code == res)
		{
			// found
			const char* d=xiAPIplus_errorcodes_list[i].descr;
			if (sizeof(descr) > strlen(d) + sizeof("%s (xiAPIplus_Camera::%s)") + strlen(location))
			{
				sprintf(descr,"%s (xiAPIplus_Camera::%s)",xiAPIplus_errorcodes_list[i].descr,location);
			}
			else
			{
				strcpy(descr,"(descr_too_long)");
			}
			break;
		}
	}
	throw xiAPIplus_Exception(res, descr);
}

void xiAPIplus_Camera::CheckResult(XI_RETURN res, const char* location)
{
	xiAPIPlusDP((DBFOUT "%d\n",res));
	if (res != XI_OK)
	{
		ReportException(res, location);
	}
}

void xiAPIplus_Camera::CheckResultParam(XI_RETURN res, const char* location, const char* param)
{
	xiAPIPlusDP((DBFOUT "%d\n",res));
	if (res != XI_OK)
	{
		char buff[MAX_PATH] = "";
		sprintf(buff, "%s - %s", location, param);
		ReportException(res, buff);
	}
}

void xiAPIplus_Exception::GetDescription(char* name, size_t name_max_size)
{
	if (!name) return;
	if (!description) return;
	if (name_max_size<sizeof(description)) return;
	strncpy(name,description,name_max_size);
}

void xiAPIplus_Exception::PrintError()
{
	char descr[200]="";
	GetDescription(descr,sizeof(descr)-1);
	printf("xiAPIplus-Error %d:%s\n",GetErrorNumber(),descr);
}

unsigned long xiAPIplus_Camera::GetNumberOfConnectedCameras()
{
	xiAPIplus api;
	return api.GetNumberOfConnectedCameras();
}

// -----------------------------------------------
// class xiAPIplus - Image
// -----------------------------------------------

xiAPIplus_Image::xiAPIplus_Image()
{
	memset(&image,0,sizeof(image));
	image.size = sizeof(image);
	is_copy = false;
}

// -----------------------------------------------
// class xiAPIplus - Camera
// -----------------------------------------------

xiAPIplus_Camera::xiAPIplus_Camera()
{
	camera_handle=NULL;
	image_timeout_ms=2000;
	acquisition_active=false;
	is_debug_enabled=false;
}

xiAPIplus_Camera::~xiAPIplus_Camera()
{
	Close();
}

void xiAPIplus_Camera::OpenFirst()
{
	OpenByID(0);
}

void xiAPIplus_Camera::OpenByID(const unsigned long id)
{
	xiAPIPlusDP((DBFIN "%s\n","OpenByID"));
	XI_RETURN res=xiOpenDevice(id, &camera_handle);
	CheckResult(res,"OpenByID");

	if(!camera_handle) res = XI_INVALID_HANDLE;
	CheckResult(res,"OpenByID");
}
void xiAPIplus_Camera::OpenBySN(const char* serial_number)
{
	if (!serial_number)  ReportException(XI_WRONG_PARAM_VALUE, "xiAPIplus_Camera::OpenBySN()");

	xiAPIPlusDP((DBFIN "%s\n", "OpenBySN"));
	XI_RETURN res = xiOpenDeviceBy(XI_OPEN_BY_SN, serial_number, &camera_handle);
	CheckResult(res, "OpenBySN");

	if (!camera_handle) res = XI_INVALID_HANDLE;
	CheckResult(res, "OpenBySN");
}

void xiAPIplus_Camera::OpenByPath(const char* device_path)
{
	if(!device_path)  ReportException(XI_WRONG_PARAM_VALUE, "xiAPIplus_Camera::OpenByPath()");

	xiAPIPlusDP((DBFIN "%s\n","OpenByPath"));
	XI_RETURN res=xiOpenDeviceBy(XI_OPEN_BY_INST_PATH, device_path, &camera_handle);
	CheckResult(res,"OpenByPath");

	if(!camera_handle) res = XI_INVALID_HANDLE;
	CheckResult(res,"OpenByPath");
}

void xiAPIplus_Camera::OpenByUserID(const char* user_id)
{
	if(!user_id)  ReportException(XI_WRONG_PARAM_VALUE, "xiAPIplus_Camera::OpenByUserID()");

	xiAPIPlusDP((DBFIN "%s\n","OpenByUserID"));
	XI_RETURN res=xiOpenDeviceBy(XI_OPEN_BY_USER_ID, user_id, &camera_handle);
	CheckResult(res,"OpenByUserID");

	if(!camera_handle) res = XI_INVALID_HANDLE;
	CheckResult(res,"OpenByUserID");
}

void xiAPIplus_Camera::OpenByLocation(const char* location)
{
	if(!location)  ReportException(XI_WRONG_PARAM_VALUE, "xiAPIplus_Camera::OpenByLocation()");

	xiAPIPlusDP((DBFIN "%s\n","OpenByUserID"));
	XI_RETURN res=xiOpenDeviceBy(XI_OPEN_BY_LOC_PATH, location, &camera_handle);
	CheckResult(res,"OpenByLocation");

	if(!camera_handle) res = XI_INVALID_HANDLE;
	CheckResult(res,"OpenByLocation");
}

// ---------------------------------------------------------------------
// camera close

void xiAPIplus_Camera::Close()
{
	xiAPIPlusDP((DBFIN "%s\n","Close"));
	if (camera_handle)
	{
		XI_RETURN res=xiCloseDevice(camera_handle);
		CheckResult(res,"Close");
	}
	camera_handle=NULL;
}

// ---------------------------------------------------------------------
// acquisition
void xiAPIplus_Camera::StartAcquisition()
{
	CheckCamHandle("StartAcquisition");
	XI_RETURN res=xiStartAcquisition(camera_handle);
	CheckResult(res,"StartAcquisition");
	acquisition_active=true;
}

void xiAPIplus_Camera::StopAcquisition()
{
	CheckCamHandle("StopAcquisition");
	XI_RETURN res=xiStopAcquisition(camera_handle);
	CheckResult(res,"StopAcquisition");
	acquisition_active=false;
}

bool xiAPIplus_Camera::IsAcquisitionActive()
{
	return acquisition_active;
}

// ---------------------------------------------------------------------
// get next image
// receiving next image from xiAPI
// if (app_image is defined) storing result to app_image
// else storing result to last_image, also returing pointer to it

xiAPIplus_Image* xiAPIplus_Camera::GetNextImage(xiAPIplus_Image* app_image)
{
	CheckCamHandle("GetNextImage");
	xiAPIplus_Image* image=&last_image;
	if (app_image)
		image = app_image;

	XI_RETURN res = XI_OK;
	res = xiGetImage(camera_handle, image_timeout_ms, image->GetXI_IMG());
	CheckResult(res,"GetNextImage");
	return image;
}

// ---------------------------------------------------------------------
// get last received image
// returns last received image (by function GetNextImage)

xiAPIplus_Image* xiAPIplus_Camera::GetLastImage()
{
	return &last_image;
}

// ---------------------------------------------------------------------
// set next image timeout in milliseconds

void xiAPIplus_Camera::SetNextImageTimeout_ms(int timeout_ms)
{
	image_timeout_ms=timeout_ms;
}

// ---------------------------------------------------------------------
// get next image timeout in milliseconds

int xiAPIplus_Camera::GetNextImageTimeout_ms()
{
	return image_timeout_ms;
}

// ---------------------------------------------------------------------
// return xiAPI parameter by name

void xiAPIplus_Camera::GetXIAPIParamString(char* xiapi_param_name, char* value, int value_max_size)
{
	CheckCamHandle("GetXIAPIParamStr");
	XI_RETURN res=xiGetParamString(camera_handle, xiapi_param_name, value, value_max_size);
	CheckResultParam(res,"GetXIAPIParamStr", xiapi_param_name);
}

void xiAPIplus_Camera::SetXIAPIParamString(char* xiapi_param_name, char* value, unsigned int value_max_size)
{
	CheckCamHandle("SetXIAPIParamStr");
	XI_RETURN res=xiSetParamString(camera_handle, xiapi_param_name, value, value_max_size);
	CheckResultParam(res,"SetXIAPIParamStr", xiapi_param_name);
}

void xiAPIplus_Camera::GetXIAPIParamInt(char* xiapi_param_name, int* value)
{
	CheckCamHandle("GetXIAPIParamInt");
	XI_RETURN res=xiGetParamInt(camera_handle, xiapi_param_name, value);
	CheckResultParam(res,"GetXIAPIParamInt", xiapi_param_name);
}
void xiAPIplus_Camera::SetXIAPIParamInt(char* xiapi_param_name, int value)
{
	CheckCamHandle("SetXIAPIParamInt");
	XI_RETURN res=xiSetParamInt(camera_handle, xiapi_param_name, value);
	CheckResultParam(res,"SetXIAPIParamInt", xiapi_param_name);
}

void xiAPIplus_Camera::GetXIAPIParamFloat(char* xiapi_param_name, float* value)
{
	CheckCamHandle("GetXIAPIParamFloat");
	XI_RETURN res=xiGetParamFloat(camera_handle, xiapi_param_name, value);
	CheckResultParam(res,"GetXIAPIParamFloat", xiapi_param_name);
}

void xiAPIplus_Camera::SetXIAPIParamFloat(char* xiapi_param_name, float value)
{
	CheckCamHandle("SetXIAPIParamFloat");
	XI_RETURN res=xiSetParamFloat(camera_handle, xiapi_param_name, value);
	CheckResultParam(res,"SetXIAPIParamFloat", xiapi_param_name);
}

void xiAPIplus_Camera::SetXIAPIParam(char* xiapi_param_name, void* value, size_t value_size, XI_PRM_TYPE type)
{
	CheckCamHandle("SetXIAPIParam");
	XI_RETURN res=xiSetParam(camera_handle, xiapi_param_name, value, (DWORD)value_size,type);
	CheckResultParam(res,"SetXIAPIParam", xiapi_param_name);
}

void xiAPIplus_Camera::GetXIAPIParam(char* xiapi_param_name, void* value, size_t * value_size, XI_PRM_TYPE * type)
{
	CheckCamHandle("GetXIAPIParam");
	XI_RETURN res=xiGetParam(camera_handle, xiapi_param_name, value, (DWORD*)value_size,type);
	CheckResultParam(res,"GetXIAPIParam", xiapi_param_name);
}

// ---------------------------------------------------------------------
// Image Destructor

xiAPIplus_Image::~xiAPIplus_Image()
{
	if (IsCopy())
	{
		// desctruct copy
		XI_IMG* image=GetXI_IMG();
		if (image->bp && GetPixelsArraySize())
		{
			if(image->bp)
				free(image->bp);
		}
	}
}

// ---------------------------------------------------------------------
// get bytes per pixel

int xiAPIplus_Image::GetBytesPerPixel()
{
	int bpp=1;
	switch (image.frm)
	{
	case XI_MONO8:
	case XI_RAW8:
	case XI_RAW8X2:
	case XI_RAW8X3:
	case XI_RAW8X4:
	case XI_RGB_PLANAR:
		bpp=1;
		break;
	case XI_MONO16:
	case XI_RAW16:
	case XI_RAW16X2:
	case XI_RAW16X3:
	case XI_RAW16X4:
	case XI_RGB16_PLANAR:
		bpp=2;
		break;
	case XI_RGB24:
		bpp=3;
		break;
	case XI_RAW32:
	case XI_RGB32:
	case XI_RAW32FLOAT:
		bpp=4;
		break;
	case XI_RGB48:
		bpp = 6;
		break;
	case XI_RGB64:
		bpp = 8;
		break;
	default:
		ReportException(XI_NOT_SUPPORTED_DATA_FORMAT, "GetBytesPerPixel");
		break;
	}
	return bpp;
}

// ---------------------------------------------------------------------

int xiAPIplus_Image::GetBitCount()
{
	int vals=1;
	switch (image.frm)
	{
	case XI_MONO8:
	case XI_RAW8:
	case XI_RAW8X2:
	case XI_RAW8X3:
	case XI_RAW8X4:
	case XI_RGB_PLANAR:	vals = 8; break;
	case XI_MONO16:
	case XI_RAW16:
	case XI_RAW16X2:
	case XI_RAW16X3:
	case XI_RAW16X4:
	case XI_RGB16_PLANAR: vals = 16; break;
	case XI_RGB24:		vals = 24; break;
	case XI_RAW32:
	case XI_RGB32:
	case XI_RAW32FLOAT:	vals = 32; break;
	case XI_RGB48:		vals = 48; break;
	case XI_RGB64:		vals = 64; break;
	default:
		ReportException(XI_NOT_SUPPORTED_DATA_FORMAT, "GetBitCount");
		break;
	}
	return vals;
}

// ---------------------------------------------------------------------
// Image Clone
// make new copy of existing image
// this copy should be deleted by caller after finishing of use

void xiAPIplus_Image::CopyTo(xiAPIplus_Image* image_copy)
{
	XI_IMG* orig=GetXI_IMG();
	XI_IMG* clone=image_copy->GetXI_IMG();
	// copy structure
	memcpy(clone,orig,sizeof(XI_IMG));
	// copy image data
	clone->bp = malloc(GetPixelsArraySize());
	if (!clone->bp)
	{
		ReportException(XI_MEMORY_ALLOCATION, "CopyTo");
	}else memcpy(clone->bp, orig->bp, GetPixelsArraySize());
}

// ---------------------------------------------------------------------
// return core xiAPI image

XI_IMG* xiAPIplus_Image::GetXI_IMG()
{
	return &image;
}

// ---------------------------------------------------------------------

int xiAPIplus_Image::GetPadding_X()
{
	switch(image.frm)
	{
	case XI_RAW16:
	case XI_MONO16:
		return image.padding_x/2;
	default:
		return image.padding_x;
	}
}

// ---------------------------------------------------------------------

xiAPIplus_ImageProcessing::xiAPIplus_ImageProcessing()
{
	processing_handle_ = NULL;
	XI_RETURN res=xiProcOpen(&processing_handle_);
	CheckResult(res,"xiProcOpen");
}

// ---------------------------------------------------------------------

xiAPIplus_ImageProcessing::~xiAPIplus_ImageProcessing()
{
	XI_RETURN res=xiProcClose(processing_handle_);
	CheckResult(res,"xiProcClose");
}

// ---------------------------------------------------------------------

void xiAPIplus_ImageProcessing::CheckResult(XI_RETURN res, const char* location)
{
	if (res != XI_OK)
	{
		ReportException(res, location);
	}
}

// -------------------------------------------------------------------

void xiAPIplus_ImageProcessing::SetParam(const char* prm, void* val, DWORD size, XI_PRM_TYPE type)
{
	XI_RETURN res=xiProcSetParam(processing_handle_,prm,val,size,type);
	CheckResult(res,"xiProcSetParam");
}

// ---------------------------------------------------------------------

void xiAPIplus_ImageProcessing::PushImage(unsigned char* first_pixel)
{
	XI_RETURN res=xiProcPushImage(processing_handle_,first_pixel);
	CheckResult(res,"xiProcPushImage");
}

// ---------------------------------------------------------------------

void xiAPIplus_ImageProcessing::PullImage()
{
	XI_RETURN res=xiProcPullImage(processing_handle_,0, last_image_.GetXI_IMG());
	CheckResult(res,"xiPullImage");
}

// ---------------------------------------------------------------------

void xiAPIplus_ImageProcessing::GetImage(xiAPIplus_Image* ret_image)
{
	last_image_.CopyTo(ret_image);
}

// ---------------------------------------------------------------------
//#include "XiSampleOpencv.hpp"




/**********************************************************************************/
/**
* Initialize the xiAPIplusCameraOcv class.
*/
xiAPIplusCameraOcv::xiAPIplusCameraOcv(){
	cv_mat_image_ = cv::Mat(0,1,CV_8UC1);
	next_image_ = NULL;
	counter_=0;
	index_=0;
}

/**********************************************************************************/
/**
* Class destructor. Free allocated memory, release images
*/
xiAPIplusCameraOcv::~xiAPIplusCameraOcv(){
	printf("Closing xiAPIplus_Ocv camera\n");
	cv_mat_image_.release();
}

/**********************************************************************************/
/**
* Reads an image from the camera using XiAPI, stores the image in OpenCV Mat format.
* @return OpenCV Mat image. 
*/
cv::Mat xiAPIplusCameraOcv::GetNextImageOcvMat(){
	next_image_ = GetNextImage(NULL);
	return ConvertOcvMat(next_image_);
}

/**********************************************************************************/
/**
* Converts a XiAPI image (xiAPIplus_Image*) to OpenCV  .
* @param input_image[in] Input xiAPIplus_Image* to be converted.
* @return converted OpenCV Mat. 
*/
cv::Mat	xiAPIplusCameraOcv::ConvertOcvMat(xiAPIplus_Image *  input_image){
	counter_++;
	next_image_ = input_image;
	// update cvImage after format has changed
	resetCvImage_();
	// allocate frame buffer copy pixel data
	cv_mat_image_.data = (uchar*)input_image->GetPixels();

	if (cv_mat_image_.empty()) printf("Error: converting XI_IMG to Mat\n");
	return cv_mat_image_;
}

/**********************************************************************************/
/**
* Resets the Opencv image if properties of XI_IMG have changed. Resets the cv_mat_image_.
*/
void xiAPIplusCameraOcv::resetCvImage_()
{
	bool do_reset = false;

	// first check basic image resolution
	switch (next_image_->GetDataFormat())
	{
		case XI_MONO8:
		{
			if (((int)(next_image_->GetWidth() + next_image_->GetPadding_X()) != cv_mat_image_.cols) || ((int)next_image_->GetHeight() != cv_mat_image_.rows))
				do_reset = true;
		}
		break;
		case XI_RGB_PLANAR:
		case XI_RGB16_PLANAR:
		{
			if (((int)next_image_->GetWidth() != cv_mat_image_.cols) || (((int)next_image_->GetHeight() * 3) != cv_mat_image_.rows))
				do_reset = true;
		}
		break;
		case XI_RAW8X2:
		case XI_RAW16X2:
		{
			if ((((int)next_image_->GetWidth() *2) != cv_mat_image_.cols) || ((int)next_image_->GetHeight() != cv_mat_image_.rows))
				do_reset = true;
		}
		break;
		case XI_RAW8X3:
		case XI_RAW16X3:
		{
			if ((((int)next_image_->GetWidth() *3) != cv_mat_image_.cols) || ((int)next_image_->GetHeight() != cv_mat_image_.rows))
				do_reset = true;
		}
		break;
		case XI_RAW8X4:
		case XI_RAW16X4:
		{
			if ((((int)next_image_->GetWidth() *4) != cv_mat_image_.cols) || ((int)next_image_->GetHeight() != cv_mat_image_.rows))
				do_reset = true;
		}
		break;
		default:
		{
			if (((int)next_image_->GetWidth() != cv_mat_image_.cols) || ((int)next_image_->GetHeight() != cv_mat_image_.rows))
				do_reset = true;
		}
	}

	// afterwards check image format
	switch( next_image_->GetDataFormat())
	{
		case XI_MONO8		:
		case XI_RAW8        :
		case XI_RAW8X2		:
		case XI_RAW8X3		:
		case XI_RAW8X4		:
		case XI_RGB_PLANAR	:
		{
			if (cv_mat_image_.type() != CV_8UC1)
				do_reset = true;
		}
		break;
		case XI_MONO16			:
		case XI_RAW16			:
		case XI_RAW16X2			:
		case XI_RAW16X3			:
		case XI_RAW16X4			:
		case XI_RGB16_PLANAR	:
		{
			if (cv_mat_image_.type() != CV_16UC1)
				do_reset = true;
		}
		break;
		case XI_RGB24       :
		{ 
			if (cv_mat_image_.type() != CV_8UC3)
				do_reset = true;
		}
		break;
		case XI_RGB32       :
		{
			if (cv_mat_image_.type() != CV_8UC4)
				do_reset = true;
		}
		break;
		case XI_RGB48		:
		{
			if (cv_mat_image_.type() != CV_16UC3)
				do_reset = true;
		}
		break;
		case XI_RGB64		:
		{
			if (cv_mat_image_.type() != CV_16UC4)
				do_reset = true;
		}
		break;
		case XI_RAW32FLOAT	:
		{
			if (cv_mat_image_.type() != CV_32FC1)
				do_reset = true;
		}
		break;
		default:
			ReportException(XI_NOT_SUPPORTED_DATA_FORMAT, "xiAPIplusCameraOcv::resetCvImage");
			return;
	}


	if(do_reset)
	{		
		if (!cv_mat_image_.empty()) cv_mat_image_.release();
		cv_mat_image_ = NULL;

		switch( next_image_->GetDataFormat())
		{
			case XI_MONO8		: cv_mat_image_.create(next_image_->GetHeight(), next_image_->GetWidth() + next_image_->GetPadding_X(), CV_8UC1); printf("Doing reset to mono\n"); break;
			case XI_RAW8		: cv_mat_image_.create(next_image_->GetHeight(), next_image_->GetWidth(), CV_8UC1); printf("Doing reset to RAW\n"); break;
			case XI_RAW8X2		: cv_mat_image_.create(next_image_->GetHeight(), (next_image_->GetWidth()) * 2, CV_8UC1); printf("Doing reset to RAW\n"); break;
			case XI_RAW8X3		: cv_mat_image_.create(next_image_->GetHeight(), (next_image_->GetWidth()) * 3, CV_8UC1); printf("Doing reset to RAW\n"); break;
			case XI_RAW8X4		: cv_mat_image_.create(next_image_->GetHeight(), (next_image_->GetWidth()) * 4, CV_8UC1); printf("Doing reset to RAW\n"); break;
			case XI_MONO16		:
			case XI_RAW16		: cv_mat_image_.create(next_image_->GetHeight(), next_image_->GetWidth(), CV_16UC1); printf("Doing reset to mono/RAW\n"); break;
			case XI_RAW16X2		: cv_mat_image_.create(next_image_->GetHeight(), (next_image_->GetWidth()) * 2, CV_16UC1); printf("Doing reset to RAW\n"); break;
			case XI_RAW16X3		: cv_mat_image_.create(next_image_->GetHeight(), (next_image_->GetWidth()) * 3, CV_16UC1); printf("Doing reset to RAW\n"); break;
			case XI_RAW16X4		: cv_mat_image_.create(next_image_->GetHeight(), (next_image_->GetWidth()) * 4, CV_16UC1); printf("Doing reset to RAW\n"); break;
			case XI_RAW32FLOAT	: cv_mat_image_.create(next_image_->GetHeight(), next_image_->GetWidth(), CV_32FC1); printf("Doing reset to RAW\n"); break;
			case XI_RGB24		: cv_mat_image_.create(next_image_->GetHeight(), next_image_->GetWidth(), CV_8UC3);	printf("Doing reset to RGB\n"); break;
			case XI_RGB_PLANAR	: cv_mat_image_.create(next_image_->GetHeight() * 3, next_image_->GetWidth(), CV_8UC1);	printf("Doing reset to RGB PLANAR\n"); break;
			case XI_RGB32		: cv_mat_image_.create(next_image_->GetHeight(), next_image_->GetWidth(), CV_8UC4);	printf("Doing reset to RGB\n"); break;
			case XI_RGB48		: cv_mat_image_.create(next_image_->GetHeight(), next_image_->GetWidth(), CV_16UC3);	printf("Doing reset to RGB\n"); break;
			case XI_RGB16_PLANAR: cv_mat_image_.create(next_image_->GetHeight() * 3, next_image_->GetWidth(), CV_16UC1);	printf("Doing reset to RGB PLANAR\n"); break;
			case XI_RGB64		: cv_mat_image_.create(next_image_->GetHeight(), next_image_->GetWidth(), CV_16UC4);	printf("Doing reset to RGB\n"); break;
			default :
				ReportException(XI_NOT_SUPPORTED_DATA_FORMAT, "xiAPIplusCameraOcv::resetCvImage");
				return;
		}
	}
	return;
}