#ifndef __VIZUM_INTERNAL_HEADER__
#define __VIZUM_INTERNAL_HEADER__

/// @brief
/// 公司内部使用的函数。
#include "VZNL_Types.h"
#include "VZNL_Export.h"

/// @breif
/// 设置门限值
/// <param name = "hDevice">[in]设备句柄</param>
/// <param name = "nThres">[in]门限值</param>
/// @return 返回0则表示成功，否则都是失败的
VZNLAPI int VzNL_ConfigThres(VZNLHANDLE hDevice, int nThres[2]);
VZNLAPI int VzNL_GetDetectThres(VZNLHANDLE hDevice, int* pnThres1, int* pnThres2);

/// @brief
/// 设置眼睛ROI
VZNLAPI int VzNL_EnableEyeROI(VZNLHANDLE hDevice, int bEnable);
VZNLAPI int VzNL_IsEnableEyeROI(VZNLHANDLE hDevice, int* pbEnable);

/// @brief
/// 启用边缘图
VZNLAPI int VzNL_EnableEdgeImage(VZNLHANDLE hDevice, int bEnable);
VZNLAPI int VzNL_IsEnableEdgeImage(VZNLHANDLE hDevice, int* pbEnable);

/// @brief
/// 设置曝光门限
VZNLAPI int VzNL_SetExposeThres(VZNLHANDLE hDevice, EVzExposeThresType eType, unsigned int nThresValue);
VZNLAPI int VzNL_GetExposeThres(VZNLHANDLE hDevice, EVzExposeThresType* peType, unsigned int* pnThresValue);

VZNLAPI int VzNL_SetDeviceID(VZNLHANDLE hDevice, char ucDeviceID[16]);

/// @brief
/// 设置眼睛的MAC，IP和目标IP
VZNLAPI int VzNL_ConfigEyeNetWork(VZNLHANDLE hDevice, const unsigned char byEyeIP[4], const unsigned char byEyeMAC[6], const unsigned char byEyeCBIP[4]);
VZNLAPI int VzNL_GetConfigEyeNetWork(VZNLHANDLE hDevice, unsigned char byEyeIP[4], unsigned char byEyeMAC[6], unsigned char byEyeCBIP[4]);

/// @brief
/// 设置第三方网络信息
VZNLAPI int VzNL_ConfigThridNetWorkInfo(VZNLHANDLE hDevice, unsigned char byThridIP[4], unsigned int nThridPort, int bIsTransPic);
VZNLAPI int VzNL_GetConfigThridNetWorkInfo(VZNLHANDLE hDevice, unsigned char byThridIP[4], unsigned int* pnThridPort, int* pbIsTransPic);

/// @brief
/// 配置Wifi
VZNLAPI int VzNL_ConfigWifiInfo(VZNLHANDLE hDevice, const char szBSSID[32], const char szPassWd[32], const unsigned char szMAC[6], const char szCipher[32]);
VZNLAPI int VzNL_GetConfigWifiInfo(VZNLHANDLE hDevice, char szBSSID[32], char szPassWd[32], unsigned char szMAC[6], char szCipher[32]);

/// @brief
/// Rename Device Name
VZNLAPI int VzNL_RenameDeviceName(VZNLHANDLE hDevice, char szDeviceName[32]);

/// @brief
/// Reset Device
VZNLAPI int VzNL_ResetDevice(VZNLHANDLE hDevice);

/// @brief
/// Query Device
VZNLAPI void* VzNL_QueryHandle(VZNLHANDLE hDevice);

/// @brief
/// 获取核心数据获取类(主要用于给3399用作算法解密用)
VZNLAPI int VzNL_QueryDeviceData(VZNLHANDLE hDevice, void** ppUnknown);

/// @brief
/// 设置眼睛Gap
VZNLAPI int VzNL_SetDeviceGap(VZNLHANDLE hDevice, unsigned short nGap);

/// @brief
/// 设置一次Trigger的次数
VZNLAPI int VzNL_SetDeviceTriggerN(VZNLHANDLE hDevice, int nMin, int nMax);

/// @brief
/// 创建算法句柄
VZNLAPI int VzNL_QueryAIObject(VZNLHANDLE hDevice, const char* lpszDll, void** pAIInterface);
VZNLAPI int VzNL_QueryAIObjectEx(VZNLHANDLE hDevice, const char* lpszDll, void** pAIInterface, char szVersion[64]);

/// @brief
/// 修改算法核心
VZNLAPI void* VzNL_QueryAlgoCore(VZNLHANDLE hDevice, int nDetectType);

/// @brief
/// 获取接口
VZNLAPI int VzNL_QueryInterface(unsigned int nUnknownInterface, void** ppUnknownInterface);

/// @brief 3399相关参数
/// @{
/// @brief
/// 重置3399设备
VZNLAPI int VzNL_ResetEyeCBDevice(SVzNLEyeCBDeviceInfoEx*	psEyeCBDeviceInfo);

/// @brief
/// 设置3399设备Debug码
VZNLAPI int VzNL_SetEyeCBDebugCode(VZNLHANDLE hDevice, double nDebugCode);

/// @brief
/// 设置3399设备LogType
VZNLAPI int VzNL_SetEyeCBLogType(VZNLHANDLE hDevice, unsigned int nLogType);

/// @brief
/// 设置钢筋打标模式
VZNLAPI int VzNL_SetCounterDetectMode(VZNLHANDLE hDevice, EVzEyeCBDetectMode eDetectMode);

/// @}

/// @name 激光检测参数
/// @{
/// @brief
/// 设置采集模式
VZNLAPI int VzNL_SetLocalLaserMode(VZNLHANDLE hDevice, EVzLaserCaptureMode eCaptureMode);

/// @brief
/// 开启本地检测
VZNLAPI int VzNL_EnableLocalDetect(VZNLHANDLE hDevice, VzBool bEnable);

/// @brief
/// 设置缓存帧数
VZNLAPI int VzNL_SetCacheSize(VZNLHANDLE hDevice, unsigned int nCacheSize);
/// @}

/// @brief
/// 设置自定义数据
VZNLAPI int VzNL_WriteCustomData(VZNLHANDLE hDevice, unsigned char* pCustomData, unsigned int nDataLength);
VZNLAPI int VzNL_ReadCustomData(VZNLHANDLE hDevice, unsigned char* pCustomData, unsigned int* pnDataLength);

/// @brief
/// 启用增强检测（3399支持）
/// <pararm name = "hDevice">[in]设备</param>
/// <pararm name = "bEnable">[in]启用/禁用</param>
/// @return 返回0为正确，失败返回错误码
VZNLAPI int VzNL_EnableEnhancedDetection(VZNLHANDLE hDevice, VzBool bEnable);
VZNLAPI VzBool VzNL_IsEnableEnhancedDetection(VZNLHANDLE hDevice, int* pnErrorCode);

/// @brief
/// 启用弱极光线检测（3399支持）
/// <pararm name = "hDevice">[in]设备</param>
/// <pararm name = "bEnable">[in]启用/禁用</param>
/// @return 返回0为正确，失败返回错误码/200.3
VZNLAPI int VzNL_EnableDetectLowLevelLaser(VZNLHANDLE hDevice, VzBool bEnable);
VZNLAPI VzBool VzNL_IsEnableDetectLowLevelLaser(VZNLHANDLE hDevice, int* pnErrorCode);

/// @brief
/// 停止采图时自动切换为数据采集状态
/// <pararm name = "hDevice">[in]设备</param>
/// <pararm name = "bPicOrDataMode">[in]True为图像模式/False数据模式</param>
/// @return 返回0为正确，失败返回错误码
VZNLAPI int VzNL_EnableAutoSwitchMode(VZNLHANDLE hDevice, VzBool bEnable, EVzNLEyeDataWorkMode eStatus);

/// @brief
/// 停止采图时自动切换为数据采集状态
/// <pararm name = "hDevice">[in]设备</param>
/// <pararm name = "bPicOrDataMode">[in]True为图像模式/False数据模式</param>
/// @return 返回0为正确，失败返回错误码
VZNLAPI int VzNL_ResetRobotCalibParam(VZNLHANDLE hDevice);
VZNLAPI int VzNL_SetRobotCalibParam(VZNLHANDLE hDevice, double dMatrix[16]);
VZNLAPI int VzNL_GetRobotCalibParam(VZNLHANDLE hDevice, double dMatrix[16]);

/// @name 圆形检测
/// @brief
/// 设置误差
VZNLAPI int VzNL_SetCircleMaxRDeviation(VZNLHANDLE hDevice, int nMaxReviation);

/// @brief
/// 获取眼睛Handle
VZNLAPI void* VzNL_QueryEyeHandle(VZNLHANDLE hDevice);

/// @brief
/// 写3399第二个网卡IP
VZNLAPI int VzNL_ConfigEyeCBNetWorkAdapterIP(VZNLHANDLE hDevice, int nAdapter, unsigned char byIP[4]);
VZNLAPI int VzNL_GetEyeCBNetWorkAdapterIP(VZNLHANDLE hDevice, int nAdapter, unsigned char byIP[4]);

/// @brief
/// 设置自定义命令
VZNLAPI int VzNL_SetCustomCommand(VZNLHANDLE hDevice, unsigned short shAddress, unsigned short shCommand, unsigned int nSetValue);
VZNLAPI int VzNL_GetCustomCommand(VZNLHANDLE hDevice, unsigned short shAddress, unsigned short shCommand, unsigned int* pnReadData);

/// @brief
/// 启用/禁用命令心跳
VZNLAPI int VzNL_EnableHeartBeat(VZNLHANDLE hDevice, VzBool bStreamOrCommand, VzBool bEnable, unsigned int nTimeOut, unsigned int nCmdInterval);

/// @brief
/// 启用/禁用SDK枚举
VZNLAPI int VzNL_EnableSDKEveryNetSearch(VzBool bEnable);

/// @brief
/// 获取3399设置的帧率
VZNLAPI int VzNL_Get3399FrameRate(VZNLHANDLE hDevice, unsigned int* pnFrameRate);

/// @brief
/// 设置煤流目标个数
VZNLAPI int VzNL_SetGangueTargetCount(VZNLHANDLE hDevice, unsigned int nTargetCount);

/// @brief
/// 发送SPI指令
VZNLAPI int VzNL_SetSPICustomData(VZNLHANDLE hDevice, unsigned char* pData, unsigned int nLength);

/// @brief
/// 启用Trigger状态检测
VZNLAPI int VzNL_EnableCheckTriggerStatus(VZNLHANDLE hDevice, VzBool bEnable);

/// @brief
/// 启用Trigger状态检测
VZNLAPI int VzNL_EnableStreamListener(VZNLHANDLE hDevice, VzBool bEnable, unsigned int nTimeOut);

/// @brief
/// 启用摆动机构时是否设置动态ROI
/// <param name = "hDeivce">[in]设备句柄</param>
/// <param name = "bEnableMotor">[in]是否启用摆动机构</param>
/// <param name = "bLinkDynamicROI">[in]是否联动动态ROI</param>
VZNLAPI int VzNL_EnableSwingMotorEx(VZNLHANDLE hDevice, VzBool bEnableMotor, VzBool bLinkDynamicROI);

/// @brief
/// 切换图像/数据状态
/// <param name = "hDeivce">[in]设备句柄</param>
/// <param name = "eMode">[in]数据/图像数据</param>
/// @return 0为成功，非0为失败
VZNLAPI int VzNL_SwitchLaserEyeImageDataMode(VZNLHANDLE hDevice, EVzNLEyeDataWorkMode eMode);
VZNLAPI EVzNLEyeDataWorkMode VzNL_GetLaserEyeImageDataMode(VZNLHANDLE hDevice, int* pnErrorCode);

/// @brief 是否改变单次检测时的图像数据模式
/// <param name = "hDeivce">[in]设备句柄</param>
/// <param name = "bEnable">[in]VzTrue启用改变</param>
VZNLAPI void VzNL_EnableLaserEyeSwitchModeWhenDetect(VZNLHANDLE hDevice, VzBool bEnable);
VZNLAPI VzBool VzNL_IsEnableLaserEyeSwitchModeWhenDetect(VZNLHANDLE hDevice, int* pnErrorCode);

/// @brief 存储激光结果
VZNLAPI void VzNL_SaveLaserResult(VZNLHANDLE hDevice, const char* lpszFIle);

/// @brief 读取彩色相机标定数据
VZNLAPI int VzNL_ReadColorCalibInfo(VZNLHANDLE hDevice, unsigned char* byData, unsigned int nDataLength);

/// @brief 注册Dump回调
VZNLAPI void VzNL_RegisterDumpCB(VzNL_CrashCallBack pFunCB);

/// @brief 当在摆动机构相机时，自动切换ROI
VZNLAPI void VzNL_EnableAutoChangeSwingROI(VZNLHANDLE hDevice, VzBool bEnable);

/// @brief 写入多相机数据
/// <param name = "hDevice">[in]设备句柄</param>
/// <param name = "nDevIndex">[in]设备Index,主设备0, 从设备1~xxx</param>
/// <param name = "dConvertMatrix">[in]转换矩阵</param>
/// <param name = "dYRange">[in]Y过滤范围,默认-9999999~999999</param>
/// <param name = "nOrderIdx">[in]序号，用于数据排序</param>
VZNLAPI int VzNL_WriteMultiDevData(VZNLHANDLE hDevice, unsigned int nDevIndex, double dConvertMatrix[3][4], double dYRange[2]);
VZNLAPI int VzNL_ReadMultiDevData(VZNLHANDLE hDevice, unsigned int* pnDevIndex, double dConvertMatrix[3][4], double dYRange[2]);

/// @brief 写入/读取多相机数据序号（配置顺序后，设备将按照这个顺序进行数据展示)
/// <param name = "hDevice">[in]设备句柄</param>
/// <param name = "nOrderIdx">[in]设备顺序号</param>
VZNLAPI int VzNL_WriteMultiDevOrder(VZNLHANDLE hDevice, int nOrderIdx);
VZNLAPI int VzNL_ReadMultiDevOrder(VZNLHANDLE hDevice, int* pnOrderIdx);

/// @brief
/// DistVarth
VZNLAPI int VzNL_SetDistVarth(VZNLHANDLE hDevice, unsigned int nDistVarth);
VZNLAPI unsigned int VzNL_GetDistVarth(VZNLHANDLE hDevice, int* pnErrorCode);

/// @brief
/// 启用CalibBetterRgnPtNumTh
VZNLAPI int VzNL_SetCalibBetterRgnPtNumTh(VZNLHANDLE hDevice, unsigned int nRgnPtNumTh);
VZNLAPI unsigned int VzNL_GetCalibBetterRgnPtNumTh(VZNLHANDLE hDevice, int* pnErrorCode);

/// @brief
/// 设置最大线宽
VZNLAPI int VzNL_SetMaxLineWidth(VZNLHANDLE hDevice, unsigned int nLineWidth);
VZNLAPI unsigned int VzNL_GetMaxLineWidth(VZNLHANDLE hDevice, int* pnErrorCode);

/// @brief
/// 设置测试图
VZNLAPI int VzNL_SetTestPatten(VZNLHANDLE hDevice, unsigned int nTestPatten);

/// @brief 设置激光Y过滤值
VZNLAPI int VzNL_SetLaserFilterExceptYRange(VZNLHANDLE hDevice, double dYMin, double dYMax);

/// @brief 读/写 激光引用位置
VZNLAPI int VzNL_Read3DRef(VZNLHANDLE hDevice, SVzNL3DPoint* ps3DPoint);
VZNLAPI int VzNL_Write3DRef(VZNLHANDLE hDevice, SVzNL3DPoint* ps3DPoint);


/*
 * @brief 获取产品类型
 * @param hDevice [in] 设备信息
 * @return 产品类型。
 */
VZNLAPI EVzProjectType VzNL_GetProjectType(VZNLHANDLE hDevice);

/*
 * @brief 是否只显示结果？
 * @param hDevice [in] 设备信息
 */
VZNLAPI VzBool VzNL_IsOnlyResult(VZNLHANDLE hDevice, int* pnErrorCode);

/*
 * @brief 获取逆矩阵信息
 * @param hDevice [in] 设备信息
 * @param dInverseRT [in] 逆向矩阵(原点标定逆向矩阵)
 * @return 返回值为0则表明成功，其他返回值请查询错误信息。
 */ 
VZNLAPI int VzNL_QueryInverseRT(VZNLHANDLE hDevice, double dInverseR[4][4]);

/*
 * @brief 保存CircleMark文件
 * @param hDevice [in] 设备信息
 * @param lpszFile [in] 存储文件
 * @return 返回值为0则表明成功，其他返回值请查询错误信息。
 */
VZNLAPI int	VzNL_SaveCircleMarkFile(VZNLHANDLE hDevice, const char* lpszFile);

/**
 * @brief 保存激光线文件(智光眼专用)
 * @param hDevice [in] 设备Handle
 * @param bEnable [in] VzTrue启用/VzFalse禁用
 * @return 关闭成功返回0，否则为错误码
 */
VZNLAPI int VzNL_SaveLaserFile(VZNLHANDLE hDevice, const char* lpszFile);

/**
 * @brief 获取逆矩阵(智光眼专用)
 * @param hDevice [in] 设备Handle
 * @param bEnable [in] VzTrue启用/VzFalse禁用
 * @return 关闭成功返回0，否则为错误码
 */
VZNLAPI int VzNL_QueryLogisticsInverseRT(VZNLHANDLE hDevice, double dInverseMatrix[4][4]);

/**
 * @brief 设置仅传图像模式(智光眼专用)
 * @param hDevice [in] 设备Handle
 * @param bEnable [in] VzTrue启用/VzFalse禁用
 * @return 关闭成功返回0，否则为错误码
 */
VZNLAPI int VzNL_OnlyTransOriImage(VZNLHANDLE hDevice, VzBool bEnable);

/**
 * @brief 获取原始分辨率
 * @param hDevice [in] 设备Handle
 * @return 关闭成功返回0，否则为错误码
 */
VZNLAPI int VzNL_GetOriResolution(VZNLHANDLE hDevice, SVzVideoResolution* psVideoRes);

/**
 * @brief 设置中间Sensor图像格式
 * @param hDevice [in] 设备Handle
 * @param bIsGray [in] VzTrue设置为灰度Sensor， VzFalse为彩色
 * @return 关闭成功返回0，否则为错误码
 */
VZNLAPI int VzNL_SetCenterSensorImageType(VZNLHANDLE hDevice, VzBool bIsGray);
VZNLAPI VzBool VzNL_GetCenterSensorImageType(VZNLHANDLE hDevice, int* pnErrorCode);

/**
 * @brief 是否下载过Map
 * @param hDevice [in] 设备Handle
 * @param pnErrorCode [out] 错误码
 * @return VzTrue下载过Map
 */
VZNLAPI VzBool VzNL_IsDownloadMap(VZNLHANDLE hDevice, int* pnErrorCode);

/**
 * @brief 获取Sensor状态
 * @param hDevice [in] 设备Handle
 * @param bValidStatus [out] 0：左 1：右 2：中间Sensor VzTrue为存在 VzFalse为不存在
 * @return 关闭成功返回0，否则为错误码
 */
VZNLAPI int VzNL_GetSensorStatus(VZNLHANDLE hDevice, VzBool bValidStatus[3]);

/**
 * @brief 写入用户数据
 * @param hDevice [in] 设备Handle
 */
VZNLAPI int VzNL_WriteUserData(VZNLHANDLE hDevice, unsigned int nOffset, unsigned char* pData, unsigned int nDataLength);
VZNLAPI int VzNL_ReadUserData(VZNLHANDLE hDevice, unsigned int nOffset, unsigned char* pData, unsigned int nDataLength);

/**
 * @brief LL
 * @param hDevice [in] 设备Handle
 */
VZNLAPI int VzNL_SetSmoothingLL(VZNLHANDLE hDevice, unsigned int nWinSize);
VZNLAPI unsigned int VzNL_GetSmoothingLL(VZNLHANDLE hDevice, int* pnErrorCode);

/**
 * @brief LLG (当LL为1时, LLG最大只为1)
 * @param hDevice [in] 设备Handle
 */
VZNLAPI int VzNL_SetSmoothingDigiGain(VZNLHANDLE hDevice, unsigned int nDigiGain);
VZNLAPI unsigned int VzNL_GetSmoothingDigiGain(VZNLHANDLE hDevice, int* pnErrorCode);

/// @brief 给PetaLinux发送信息
VZNLAPI int VzNL_SendDataToPeta(VZNLHANDLE hDevice, unsigned char* pData, unsigned int nDataLength);

/// @brief 激活取消激活PetaLinux通道
VZNLAPI int VzNL_ActivePetaLinux(VZNLHANDLE hDevice, VzBool bActive);

/// @brief 启用/禁用 激光线输出
VZNLAPI int VzNL_EnableOutputLaserLine(VZNLHANDLE hDevice, VzBool bActive);
VZNLAPI VzBool VzNL_IsEnableOutputLaserLine(VZNLHANDLE hDevice, int* pnErrorCode);


/// @brief 启用/禁用 煤流数据
VZNLAPI int VzNL_EnableOutputCoalData(VZNLHANDLE hDevice, VzBool bEnable);
VZNLAPI VzBool VzNL_IsEnableOutputCoalData(VZNLHANDLE hDevice, int* pnErrorCode);

/// @brief
/// 写入煤流特有的命令
VZNLAPI int VzNL_SendCoalSpecialCommand(VZNLHANDLE hDevice, unsigned int eCoalCommand, unsigned char* pData, unsigned int nDataLength);
VZNLAPI int VzNL_GetCoalSpecialCommand(VZNLHANDLE hDevice, unsigned int eCoalCommand, unsigned char* ppData, unsigned int nDataLength);

/// @brief
/// 查看当前开流状态
VZNLAPI VzBool VzNL_QueryStreamStatus(VZNLHANDLE hDevice);
VZNLAPI EVzNLEyeDataWorkMode VzNL_QueryCurDataMode(VZNLHANDLE hDevice);

/// @brief
/// 发送任意数据到PS
VZNLAPI int VzNL_SendCustomDataToPS(VZNLHANDLE hDevice, unsigned char* pData, unsigned int nDataLength);

/// @brief
/// 激活PS通道
VZNLAPI int VzNL_ActivePSChannel(VZNLHANDLE hDevice, VzBool bEnable);

/// @brief
/// 设置在开流前后是否自己控制摆动模块位置
VZNLAPI int VzNL_EnableAutoRotateSwingToStopAngle(VZNLHANDLE hDevice, VzBool bEnable);
VZNLAPI VzBool VzNL_IsEnableAutoRotateSwingToStopAngle(VZNLHANDLE hDevice, int* pnErrorCode);

/// @brief 是否支持Bin
VZNLAPI VzBool VzNL_IsSupportBin(VZNLHANDLE hDevice);

/// @brief 启用/禁用 Bin模式
VZNLAPI VzBool VzNL_IsEnableBinMode(VZNLHANDLE hDevice, int* pnErrorCode);

/// @breif 设置当前位置为零位
VZNLAPI int VzNL_SetSwingZeroPos(VZNLHANDLE hDevice);

/// @breif 设置当前位置为左极限
VZNLAPI int VzNL_SetSwingLeftLimit(VZNLHANDLE hDevice);

/// @breif 设置当前位置为右极限
VZNLAPI int VzNL_SetSwingRightLimit(VZNLHANDLE hDevice);

/// @brief 重启摆动模块
VZNLAPI int VzNL_SetSpeedPI(VZNLHANDLE hDevice, unsigned char shSpeedP, unsigned char shSpeedI);
VZNLAPI int VzNL_GetSpeedPI(VZNLHANDLE hDevice, unsigned char* pshSpeedP, unsigned char* pshSpeedI);

/// @brief 重启摆动模块
VZNLAPI int VzNL_SetCurrentPI(VZNLHANDLE hDevice, unsigned char shSpeedP, unsigned char shSpeedI);
VZNLAPI int VzNL_GetCurrentPI(VZNLHANDLE hDevice, unsigned char* pshSpeedP, unsigned char* pshSpeedI);


/// @brief 自动配置PI
VZNLAPI int VzNL_EnableSwingAdjustPI(VZNLHANDLE hDevice, VzBool bEnable);

/// @brief 获取摆动模块状态
VZNLAPI int VzNL_QuerySwingStatus(VZNLHANDLE hDevice, int* pnErrorCode);

/// @brief 升级摆动模块
VZNLAPI int VZNL_UpdateSwing(VZNLHANDLE hDevice, const char* lpszFile);

/// @brief 重置摆动模块
VZNLAPI int VZNL_ResetSwing(VZNLHANDLE hDevice);

/// @brief 电机找零
VZNLAPI int VZNL_FindMotorZero(VZNLHANDLE hDevice);

/// @brief 电机自检
VZNLAPI int VZNL_MotorSelfCheck(VZNLHANDLE hDevice);

/// @brief 设置延迟的帧数 frame
VZNLAPI int VzNL_SetRGBDPostFrameNum(VZNLHANDLE hDevice, unsigned int nPostFrameNum);
VZNLAPI unsigned int VzNL_GetRGBDPostFrameNum(VZNLHANDLE hDevice, int* pnErrorCode);

/// @brief 设置微调距离mm
VZNLAPI int VzNL_SetRGBDFineTune(VZNLHANDLE hDevice, float fFineTune);
VZNLAPI float VzNL_GetRGBDFineTune(VZNLHANDLE hDevice, int* pnErrorCode);

/// @brief 设置双目标单目参数
VZNLAPI int VzNL_UseSingleCameraCalibParam(VZNLHANDLE hDevice, VzBool bUseCalibParam);
VZNLAPI VzBool VzNL_IsUseSingleCameraCalibParam(VZNLHANDLE hDevice, int* pnErrorCode);
VZNLAPI int VzNL_SetSingleCameraRefPlaneCalibParam(VZNLHANDLE hDevice, double dParam[5]);
VZNLAPI int VzNL_GetSingleCameraRefPlaneCalibParam(VZNLHANDLE hDevice, double dParam[5]);

/// @brief 设置单目标定参数
VZNLAPI int VzNL_EnableCompute3DSingleEye(VZNLHANDLE hDevice, VzBool bEnable);
VZNLAPI VzBool VzNL_IsEnableCompute3DSingleEye(VZNLHANDLE hDevice, int* pnErrorCode);
VZNLAPI int VzNL_SetCompute3DSEParam(VZNLHANDLE hDevice, float fParam[4]);
VZNLAPI int VzNL_GetCompute3DSEParam(VZNLHANDLE hDevice, float fParam[4]);

/// @brief 获取Debug数据的总数据量
VZNLAPI unsigned int VzNL_QueryDeviceDebugDataTotleSize(VZNLHANDLE hDevice);

/// @brief 保存Map数据等信息
/// <param name = "hDevice">[in]设备句柄</param>
/// <param name = "lpszSaveDir">[in]存储路径</param>
/// <param name = "dUpdateTime">[in]更新时间</param>
/// <param name = "pDebugSaveProgress">[in]数据回调</param>
VZNLAPI int VzNL_SaveDeviceDebugInfo(VZNLHANDLE hDevice, const char* lpszSaveDir, double dUpdateTime, void* pDebugSaveProgress);


/**
 * @brief 是否启用C模式图像传输
 * @param [in] hDevice 设备Handle
 * @param [in] bEnable 是否启用C模式图像
 * @return 当前已启用分层返回VzTrue,否则返回VzFalse
 */
VZNLAPI int VzNL_EnableCModeImage(VZNLHANDLE hDevice, VzBool bEnable);

/**
 * @brief 配置蓝光RGBD偏移距离(mm)
 * @param [in] hDevice 设备Handle
 * @param [in] fDistance 偏移距离(mm)
 * @return 成功返回0，失败返回错误码
 */
VZNLAPI int VzNL_SetRGBOffsetDistance(VZNLHANDLE hDevice, float fDistance);

/**
 * @brief 获取蓝光RGBD偏移距离(mm)
 * @param [in] hDevice 设备Handle
 * @param [in] nErrorCode 错误码
 * @return 蓝光RGBD偏移距离(mm)
 */
VZNLAPI float VzNL_GetRGBOffsetDistance(VZNLHANDLE hDevice, int* nErrorCode);

/**
 * @brief 启用/禁用算法增强
 * @param [in] hDevice 设备Handle
 * @param [in] bEnable 启用VzTrue / 禁用VzFalse
 * @return 成功返回0，失败返回错误码
 */
VZNLAPI int VzNL_EnableSupportSS(VZNLHANDLE hDevice, VzBool bEnable);

/**
 * @brief 是否启用算法增强
 * @param [in] hDevice 设备Handle
 * @param [in] pnErrorCode 错误码
 * @return 当前已启用分层返回VzTrue,否则返回VzFalse
 */
VZNLAPI VzBool VzNL_IsEnableSupportSS(VZNLHANDLE hDevice, int* pnErrorCode);

/**
 * @brief 启用/禁用单边反光增强
 * @param [in] hDevice 设备Handle
 * @param [in] bEnable 启用VzTrue / 禁用VzFalse
 * @return 成功返回0，失败返回错误码
 */
VZNLAPI int VzNL_EnableSupportSingleReflect(VZNLHANDLE hDevice, VzBool bEnable);

/**
 * @brief 是否启用了单边反光增强
 * @param [in] hDevice 设备Handle
 * @param [in] pnErrorCode 错误码
 * @return 当前已启用分层返回VzTrue,否则返回VzFalse
 */
VZNLAPI VzBool VzNL_IsEnableSupportSingleReflect(VZNLHANDLE hDevice, int* pnErrorCode);

/**
 * @brief 启用分层功能 (默认为VzTrue)
 * @param [in] hDevice 设备Handle
 * @param [in] bEnable 启用VzTrue / 禁用VzFalse
 * @return 成功返回0，失败返回错误码
 */
VZNLAPI int VzNL_EnableMultiMatch(VZNLHANDLE hDevice, VzBool bEnable);

/**
 * @brief 是否启用了分层功能
 * @param [in] hDevice 设备Handle
 * @param [in] pnErrorCode 错误码
 * @return 当前已启用分层返回VzTrue,否则返回VzFalse
 */
VZNLAPI VzBool VzNL_IsEnableMultiMatch(VZNLHANDLE hDevice, int* pnErrorCode);

/**
 * @brief 获取用户配置个数(共10个) 当前仅支持智光眼
 * @param [in] hDevice 设备Handle
 * @param [out]pnSupportUserProfileCount 不能为null, 获取支持的最大文件个数
 */
VZNLAPI int VzNL_QueryUserProfileCount(VZNLHANDLE hDevice, int* pnSupportUserProfileCount);

/**
 * @brief 获取单个配置文件最大的大小(512 K) 当前仅支持智光眼
 * @param [in] hDevice 设备Handle
 * @param [out]pnMaxLength 不能为null, 获取文件的最大数据长度
 */
VZNLAPI int VzNL_QueryUserProfileMaxLength(VZNLHANDLE hDevice, int* pnMaxLength);

/**
 * @brief 读取、写入用户配置(共10个) 当前仅支持智光眼
 * @param [in] hDevice 设备Handle
 * @param [in] nProfileIdx 文件索引
 * @param [in] pData 数据Buffer
 * @param [in] nReadLength 数据长度
 */
VZNLAPI int VzNL_ReadUserProfile(VZNLHANDLE hDevice, unsigned int nProfileIdx, unsigned char* pData, unsigned int nReadLength);
VZNLAPI int VzNL_WriteUserProfile(VZNLHANDLE hDevice, unsigned int nProfileIdx, unsigned char* pData, unsigned int nWriteLength);

/**
 * @brief 写入/读取用户文件列表 当前仅支持智光眼
 * @param [in] hDevice 设备Handle
 * @param [in] pData 数据Buffer
 * @param [in] nReadLength 数据长度
 */
VZNLAPI int VzNL_WriteUseProfileHeadBlock(VZNLHANDLE hDevice, unsigned char* pData, unsigned int nWriteLength);
VZNLAPI int VzNL_ReadUseProfileHeadBlock(VZNLHANDLE hDevice, unsigned char* pData, unsigned int nReadLength);

/**
 * @brief 设置摆动模块速度补偿系数
 * @param [in] hDevice 设备Handle
 * @param [in] fSpeedFactor 速度补偿系数
 */
VZNLAPI int VzNL_SetSwingSpeedFactor(VZNLHANDLE hDevice, float fSpeedFactor);

/**
 * @brief 测试SPI通信是否正常
 * @param [in] hDevice 设备Handle
 */
VZNLAPI int VzNL_CheckSwingSPIComm(VZNLHANDLE hDevice);

/**
 * @brief 保存默认参数配置，当前仅支持智光眼
 * @param hDevice 设备Handle
 */
VZNLAPI int VzNL_SaveDefaultSetting(VZNLHANDLE hDevice);

/**
 * @brief 读写用户默认区数据
 * @param [in] hDevice 设备Handle
 * @param [in] pData 数据Buffer
 * @param [in] nReadLength 数据长度
 */
VZNLAPI int VzNL_WriteDefaultData(VZNLHANDLE hDevice, unsigned char* pData, unsigned int nWriteLength);
VZNLAPI int VzNL_ReadDefaultData(VZNLHANDLE hDevice, unsigned char* pData, unsigned int nReadLength);

/**
 * @brief 读写运行区数据
 * @param [in] hDevice 设备Handle
 * @param [in] pData 数据Buffer
 * @param [in] nReadLength 数据长度
 */
VZNLAPI int VzNL_WriteRuntimeData(VZNLHANDLE hDevice, unsigned char* pData, unsigned int nWriteLength);
VZNLAPI int VzNL_ReadRuntimeData(VZNLHANDLE hDevice, unsigned char* pData, unsigned int nReadLength);

/**
 * @brief 切换使能和触发信号线
 */
VZNLAPI int VzNL_SwapTriggerSignal(VZNLHANDLE hDevice, VzBool bEnable);
VZNLAPI VzBool VzNL_IsSwapTriggerSignal(VZNLHANDLE hDevice, int* pnErrorCode);

/**
 * @brief 是否支持双相编码器
 */
VZNLAPI VzBool VzNL_IsSupportBiPhaseEncoder(VZNLHANDLE hDevice, int* pnErrorCode);

/**
 * @brief 是否支持光强数据
 */
VZNLAPI VzBool VzNL_IsSupportIntensityData(VZNLHANDLE hDevice, int* pnErrorCode);

/**
 * @brief 切换双向编码器/En 信号
 */
VZNLAPI int VzNL_SetEnInPointSignal(VZNLHANDLE hDevice, EVzEnLineInPoint bEnable);
VZNLAPI EVzEnLineInPoint VzNL_GetEnInPointSignal(VZNLHANDLE hDevice, int* pnErrorCode);

/**
 * @brief 修改选择左右目灰度源
 */
VZNLAPI int VzNL_SetGraySource(VZNLHANDLE hDevice, EVzGrayValueSource eSource);
VZNLAPI EVzGrayValueSource VzNL_GetGraySource(VZNLHANDLE hDevice, int* pnErrorCode);

/**
 * @brief 获取当前编码器状态
 */
VZNLAPI int VzNL_GetEncoderStatus(VZNLHANDLE hDevice, unsigned int nStatus[3]);

/**
 * @brief 重置当前编码器
 */
VZNLAPI int VzNL_ResetEncoder(VZNLHANDLE hDevice);

/**
 * @brief 获取当前编码器状态
 */
VZNLAPI int VzNL_SetRGBCalibCamInfo(VZNLHANDLE hDevice, float fCamInfo[4]);
VZNLAPI int VzNL_GetRGBCalibCamInfo(VZNLHANDLE hDevice, float fCamInfo[4]);

/**
 * @brief 获取当前编码器状态
 */
VZNLAPI int VzNL_SetRGBCalibRTMatrixData(VZNLHANDLE hDevice, float fRTMatrix[12]);
VZNLAPI int VzNL_GetRGBCalibRTMatrixData(VZNLHANDLE hDevice, float fRTMatrix[12]);


/// @brief 写入RGB 标定数据
VZNLAPI int VzNL_SetRGBASyncParamData(VZNLHANDLE hDevice, float fBaseDx, float fMidDx[2], float fMaxDx[2], unsigned int nDivFrame);
VZNLAPI int VzNL_GetRGBASyncParamData(VZNLHANDLE hDevice, float* pfBaseDx, float fMidDx[2], float fMaxDx[2], unsigned int* pnDivFrame);

/// @brief 计算RGB UV
VZNLAPI SVzNL2DPoint* VzNL_CalcRGBUV(VZNLHANDLE hDevice, SVzNL3DPointF* ptPoint, int nPointCount);

/// @brief 是否为异步RGBD相机
VZNLAPI VzBool VzNL_IsSupportAsyncRGB(VZNLHANDLE hDevice);

/**
 * @brief 获取智光眼/星光眼设备详细信息
 * @param [in] pEyeCBInfo
 * @param [out] pDeviceInfoEx
 * @return 返回0表示成功
 */
VZNLAPI int VzNL_QueryDeviceDetailDesc(const SVzNLEyeCBInfo* pEyeCBInfo, SVzNLEyeDeviceInfoEx* pDeviceInfoEx);

// @name Mark 相关
// @{
/**
 * @brief 启用/禁用 Mark跟踪
 * @param [in] bEnable 启用跟踪？
 * @return 返回0表示正确
 * @retval 0 表示成功
 * @retval 非0 表示失败,可以使用VzNL_GetErrorInfo获取
 */
VZNLAPI int VzNL_EnableTraceMark(VZNLHANDLE hDevice, VzBool bEnable);
VZNLAPI int VzNL_IsEnableTraceMark(VZNLHANDLE hDevice, VzBool* pbEnable);

/**
 * @brief 设置、获取 跟踪范围
 * @param [in] dDiameter 直径
 * @return 返回0表示正确
 * @retval 0 表示成功
 * @retval 非0 表示失败,可以使用VzNL_GetErrorInfo获取
 */
VZNLAPI int VzNL_SetMarkTraceDistance(VZNLHANDLE hDevice, float fDistance);
VZNLAPI int VzNL_GetMarkTraceDistance(VZNLHANDLE hDevice, float* pfDistance);

/**
 * @brief 设置、获取 跟踪范围
 * @param [in] dDiameter 直径
 * @return 返回0表示正确
 * @retval 0 表示成功
 * @retval 非0 表示失败,可以使用VzNL_GetErrorInfo获取
 */
VZNLAPI int VzNL_ResetMarkSequenceID(VZNLHANDLE hDevice, unsigned int* pnSequenceID, unsigned int nCount);
VZNLAPI int VzNL_GetMarkSequenceID(VZNLHANDLE hDevice, unsigned int* pnSequenceID, unsigned int* pnCount);

// @}

VZNLAPI int VzNL_EnableOutputTearData(VZNLHANDLE hDevice, VzBool bEnable);

/**
 * @brief 设置激光线采样间隔
 * @param [in] hDevice 设备句柄
 * @param [in] nInterval 采样间隔
 * @return 返回0表示正确
 * @retval 0 表示成功
 * @retval 非0 表示失败,可以使用VzNL_GetErrorInfo获取
 */
VZNLAPI int VzNL_SetOutputLaserInterval(VZNLHANDLE hDevice, unsigned int nInterval);
VZNLAPI int VzNL_GetOutputLaserInterval(VZNLHANDLE hDevice, unsigned int* pnInterval);

/**
 * @brief 是否只输出缺陷数据
 * @param [in] hDevice 设备句柄
 * @param [in] bEnable VzTrue表示只输出缺陷数据
 * @return 返回0表示正确
 * @retval 0 表示成功
 * @retval 非0 表示失败,可以使用VzNL_GetErrorInfo获取
 */
VZNLAPI int VzNL_EnableOnlyOutputTearResult(VZNLHANDLE hDevice, VzBool bEnable);
VZNLAPI VzBool VzNL_IsEnableOnlyOutputTearResult(VZNLHANDLE hDevice, int* pnErrorCode);

/**
 * @brief 配置检测目标类型
 * @param [in] ePresetProfile 目标类型配置
 * @return 返回0表示正确
 * @retval 0 表示成功
 * @retval 非0 表示失败,可以使用VzNL_GetErrorInfo获取
 */
VZNLAPI int VzNL_SetDetectObjectType(VZNLHANDLE hDevice, EVzLaserObjectDetectPresetProfile ePresetProfile);
VZNLAPI EVzLaserObjectDetectPresetProfile VzNL_GetDetectObjectType(VZNLHANDLE hDevice, int* pnErrorCode);

/**
 * @brief 是否禁用流输出
 */
VZNLAPI int VzNL_DisableStreamData(VZNLHANDLE hDevice, VzBool bEnable);
VZNLAPI VzBool VzNL_IsDisableStreamData(VZNLHANDLE hDevice, int* pnErrorCode);

/**
 * szy
 * @brief 启用3D数据计算模式  
 */
VZNLAPI int VzNL_EnableTrans3DRGBImage(VZNLHANDLE hDevice, VzBool bEnable);
VZNLAPI VzBool VzNL_IsEnableTrans3DRGBImage(VZNLHANDLE hDevice, int* pnErrorCode);

/**
 * @brief 网络一次发送数据大小
 */
VZNLAPI int VzNL_SetEthSendDataLength(VZNLHANDLE hDevice, unsigned int nDataLength);

/**
 * @brief 获取摆动模块记录的Debug数据，分别为发送命令的次数，接收命令的次数，命令错误的次数
 */
VZNLAPI int VzNL_GetSwingInterruptInfo(VZNLHANDLE hDevice, unsigned int nTime[3]);

/**
 * @brief 启用摆动模块Debug模式
 */
VZNLAPI int VzNL_EnableSwingDebugMode(VZNLHANDLE hDevice, VzBool bEnable);

/**
 * @brief 启用摆动模块Log
 */
VZNLAPI int VzNL_EnableSwingLog(VZNLHANDLE hDevice, VzBool bEnable);

/**
 * @brief 输出摆动模块的Log
 */
VZNLAPI void VzNL_PrintSwingLog(VZNLHANDLE hDevice);

/**
 * @brief 输出摆动模块的Log
 */
VZNLAPI int VzNL_GetSwingLogCount(VZNLHANDLE hDevice);

/**
 * @brief 输出摆动模块的Log
 */
VZNLAPI int VzNL_GetPSSwingLog(VZNLHANDLE hDevice, int nLogIdx, char szLog[256]);

/**
 * @brief 输出摆动模块Log
 */
VZNLAPI int VzNL_GetSwingDevLog(VZNLHANDLE hDevice, unsigned char* pTransData, unsigned int* pnDataLength);

/**
 * @brief 获取RTC状态 0正常 1损坏 2过期
 */
VZNLAPI int VzNL_GetRTCStatus(VZNLHANDLE hDevice, int* pnErrorCode);

/// @brief
/// 获取AutoReg个数
VZNLAPI int VzNL_GetAutoRegCount(VZNLHANDLE hDevice, int* pnErrorCode);

/// @brief
/// 获取AutoReg名称
VZNLAPI int VzNL_GetAutoRegName(VZNLHANDLE hDevice, int nAutoRegIdx, char szRegName[64]);

/// @brief
/// 获取AutoReg类型
/// @return 返回AutoReg类型，如果是1则表示为int 2则表示为float
VZNLAPI int VzNL_GetAutoRegType(VZNLHANDLE hDevice, int nAutoRegIdx, int* pnErrorCode);

/// @brief
/// 获取AutoReg值
VZNLAPI int VzNL_GetAutoRegVal(VZNLHANDLE hDevice, int nAutoRegIdx, unsigned char pData[4]);

/// @brief 
/// 设置AutoReg
VZNLAPI int VzNL_SetAutoRegVal(VZNLHANDLE hDevice, int nAutoRegIdx, const unsigned char* pData, unsigned int nDataLength);

/// @brief
/// 配置Debug存储标志
VZNLAPI int VzNL_EnterDebugMode(VZNLHANDLE hDevice, VzBool bEnterDebug);

VZNLAPI VzBool VzNL_IsEnterDebugMode(VZNLHANDLE hDevice, int* pnErrorCode);

/// @brief 配置/获取sensor镜头信息
VZNLAPI int VzNL_SetSensorLenType(VZNLHANDLE hDevice, EVzSensorLenType eLenType);
VZNLAPI EVzSensorLenType VzNL_GetSensorLenType(VZNLHANDLE hDevice, int* pnErrorCode);

//@brief
//设置/获取镜头舵机极性
VZNLAPI int VzNL_SetCameraServoPola(VZNLHANDLE hDevice, unsigned int nPola);
VZNLAPI int VzNL_GetCameraServoPola(VZNLHANDLE hDevice, unsigned int& nPola);

//@brief
//设置/获取镜头舵机各种状态下对应的脉冲值
VZNLAPI int VzNL_SetCameraServoStatusPlusWidth(VZNLHANDLE hDevice, EVzServoStatusType eServoStatusType, unsigned int nPlusWidth);
VZNLAPI int VzNL_GetCameraServoStatusPlusWidth(VZNLHANDLE hDevice, EVzServoStatusType eServoStatusType, unsigned int& nPlusWidth);

//@brief
//设置/获取镜头舵机各种状态下对应的脉冲周期
VZNLAPI int VzNL_SetCameraServoSpeedCycle(VZNLHANDLE hDevice, unsigned int nCycle);
VZNLAPI int VzNL_GetCameraServoSpeedCycle(VZNLHANDLE hDevice, unsigned int& nCycle);

//@brief
//设置/获取等待时间 (ms)
VZNLAPI int VzNL_SetCameraServoWaitTime(VZNLHANDLE hDevice, unsigned int nTime);
VZNLAPI int VzNL_GetCameraServoWaitTime(VZNLHANDLE hDevice, unsigned int& nTime);

//@brief
//设置/获取打开、关闭动作次数
VZNLAPI int VzNL_SetCameraServoMoveCount(VZNLHANDLE hDevice, unsigned int nCount);
VZNLAPI int VzNL_GetCameraServoMoveCount(VZNLHANDLE hDevice, unsigned int& nCount);

//设置舵机脉冲值
VZNLAPI int VzNL_SetCameraServoPlusWidth(VZNLHANDLE hDevice, unsigned int nPlusWidth);

//设置舵机开机后的默认脉冲值
VZNLAPI int VzNL_SetCameraServoDefaultPlusWidth(VZNLHANDLE hDevice, unsigned int nPlusWidth);

//获取舵机开机后的默认脉冲值
VZNLAPI int VzNL_GetCameraServoDefaultPlusWidth(VZNLHANDLE hDevice, unsigned int& nPlusWidth);

/// @brief 是否具有打开CalibTool的能力
VZNLAPI VzBool VzNL_HasCalibToolCap(VZNLHANDLE hDevice);

/// @brief 写入/读取Map系数表数据
VZNLAPI int VzNL_WriteSparseMapData(VZNLHANDLE hDevice, VzBool bCMode, VzBool bLeftOrRight, const unsigned char* pData, unsigned int nDataLength);
VZNLAPI int VzNL_ReadSparseMapData(VZNLHANDLE hDevice, VzBool bCMode, VzBool bLeftOrRight, unsigned char* pData, unsigned int nDataLength);

/// @brief 配置在计算ROI时，左右眼的偏移角度
VZNLAPI int VzNL_SetROIOffsetAngle(VZNLHANDLE hDevice,float fLeftOffsetAngle,float fRightOffsetAngle);
VZNLAPI int VzNL_GetROIOffsetAngle(VZNLHANDLE hDevice, float& fLeftOffsetAngle, float& fRightOffsetAngle);

/// @brief 获取左右目的ROI跟踪表的大小
VZNLAPI int VzNL_GetROITraceTableSize(VZNLHANDLE hDevice, unsigned int* pnSize);

/// @brief 获取左右目的ROI跟踪表
VZNLAPI int VzNL_GetROITraceTable(VZNLHANDLE hDevice, unsigned int* pnLeftOffset, unsigned int* pnRightOffset, unsigned int nSize);


/// @brief 设置算法参数
VZNLAPI int VzNL_SetAlgoParam(VZNLHANDLE hDevice, const char* pParamJson);
/// @brief 获取算法参数数值
VZNLAPI int VzNL_GetAlgoParam(VZNLHANDLE hDevice, const char* pParamJson, char* pValueJson, unsigned int& nSize);


/**
 * @brief 设置是否支持关闭激光器
 * @param [in] hDevice 设备句柄
 * @param [in] bSupport 是否支持
 * @return 成功返回0，否则为错误码。
 */
VZNLAPI int VzNL_SetIsSupportTurnOffLaserLight(VZNLHANDLE hDevice, VzBool bSupport);

/**
 * @brief 设置是否支持激光器亮度调节功能
 * @param [in] hDevice 设备句柄
 * @param [in] bSupport 是否支持
 * @return 成功返回0，否则为错误码。
 */
VZNLAPI int VzNL_SetIsSupportChangeLaserLightLevel(VZNLHANDLE hDevice, VzBool bSupport);

/**
 * @brief 设置rgb小模组图像方向翻转
 * @param [in] hDevice 设备句柄
 * @param [in] bRotate 是否旋转
 * @return 成功返回0，否则为错误码。
 */
VZNLAPI int VzNL_SetRgbImageRotate180(VZNLHANDLE hDevice, VzBool bRotate);

/**
 * @brief 是否rgb小模组图像方向翻转了
 * @param [in] hDevice 设备句柄
 * @param [in] pnErrorCode 错误信息，如果不需要可填NULL
 * @return VzTrue是旋转,VzTrue是没有
 */
VZNLAPI VzBool VzNL_IsRgbImageRotate180(VZNLHANDLE hDevice, int* pnErrorCode);


/**
 * @brief 检查网络速率
 * @param hDevice 当前设备句柄
 * @param [in] nSpeed 网速,索引0为本地网卡速率，索引1为相机网卡速率
 * @return 成功返回0，否则为错误码。
 */
VZNLAPI int VzNL_CheckNetworkSpeed(VZNLHANDLE hDevice, unsigned int nSpeed[2]);


/**
 * @brief 设置相机瞳距信息
 * @param hDevice 当前设备句柄
 * @param [in] nPupilDistance 瞳距
 * @return 成功返回0，否则为错误码。
 */
VZNLAPI int VzNL_SetPupilDistance(VZNLHANDLE hDevice, unsigned int nPupilDistance);

/**
 * @brief 设置/获取相机modbus波特率
 * @param hDevice 当前设备句柄
 * @param [in] nBaudRate 波特率
 * @return 成功返回0，否则为错误码。
 */
VZNLAPI int VzNL_SetModbusBaudRate(VZNLHANDLE hDevice, unsigned int nBaudRate);
VZNLAPI unsigned int VzNL_GetModbusBaudRate(VZNLHANDLE hDevice, int* pnErrorCode);

////////////////////////////////////////////////////////////////////////////////
/**
 * @brief 激光器在相机上安装？
 * @param hDevice [in] 设备Handle
 * @param bOnCamera [in] VzTrue在相机上/VzFalse不在相机上
 * @return 关闭成功返回0，否则为错误码
 */
VZNLAPI int VzNL_LaserEmitterOnCamera(VZNLHANDLE hDevice, VzBool bOnCamera);
VZNLAPI VzBool VzNL_HasLaserEmitterOnCamera(VZNLHANDLE hDevice, int* pnErrorCode);

/**
 * @brief 当前相机是否有触发信号进来？
 * @param hDevice [in] 设备Handle
 * @param pnErrorCode [out] 错误码
 * @return VzTrue有触发信号/VzFalse无触发信号
 */
VZNLAPI VzBool VzNL_HasTriggerSignalToCamera(VZNLHANDLE hDevice, int* pnErrorCode);

/**
 * @brief 获取当前相机连接的编码器值
 * @param hDevice [in] 设备Handle
 * @param pnErrorCode [out] 错误码
 * @return VzTrue有触发信号/VzFalse无触发信号
 */
VZNLAPI int VzNL_GetCameraTriggerEncoderData(VZNLHANDLE hDevice, SVzEncoderData* pEncoderData);

/**
 * @brief 相机是否做过面标定
 * @param hDevice 当前设备句柄
 * @param pnErrorCode 错误信息，如果不需要可填NULL
 * @return VzTrue 表示做过 VzFalse 表示没做过
 */
VZNLAPI VzBool VzNL_IsSupportStaticCalibParam(VZNLHANDLE hDevice, int* pnErrorCode);


/**
 * @brief 相机是否使用面标定
 * @param hDevice 当前设备句柄
 * @param pnErrorCode 错误信息，如果不需要可填NULL
 * @return VzTrue 表示做过 VzFalse 表示没做过
 */
VZNLAPI int VzNL_UseStaticCalibParam(VZNLHANDLE hDevice, VzBool bUseCalibParam);
VZNLAPI VzBool VzNL_IsUseStaticCalibParam(VZNLHANDLE hDevice, int* pnErrorCode);

/**
 * @brief 眼睛是否标定过
 * @param [in] hDevice			设备句柄
 * @param [in] pErrorCode		ErrorCode
 * @return 如果标定过返回VzTrue
 */
VZNLAPI VzBool VzNL_LaserIsCalibration(VZNLHANDLE hDevice, int* pErrorCode);

/**
* @brief 设置激光门限值(只支持EyeCB和星光眼)
* @param [in] hDevice 设备句柄
* @param [in] nLaserThres 激光门限值[Range:1~255]
* @return 返回0表示正确
* @retval 0 表示成功
* @retval 非0 表示失败,可以使用VzNL_GetErrorInfo获取
*/
VZNLAPI int VzNL_SetLaserThres(VZNLHANDLE hDevice, int nLaserThres);
VZNLAPI int VzNL_GetLaserThres(VZNLHANDLE hDevice, int* pnLaserThres);

/**
 * @brief 重置网络极光眼的配置信息
 * @param [in] pEyeCBInfo   设备信息
 * @param [in] byEyeIP      眼睛IP
 * @return 返回0表示成功
 */
VZNLAPI int VzNL_ConfigEthernetEyeConfigInfo(const SVzNLEyeCBInfo* pEyeCBInfo,
	unsigned char byEyeIP[4]);

/**
* @brief 重置网络配置信息
* @param [in] pEyeCBInfo   设备信息
* @param [in] byEyeIP      眼睛IP
* @param [in] byMask       子网掩码
* @param [in] byGateWay    网关
* @return 返回0表示成功
*/
VZNLAPI int VzNL_ConfigEthernetInfo(const SVzNLEyeCBInfo* pEyeCBInfo,
	unsigned char byEyeIP[4],
	unsigned char byMask[4],
	unsigned char byGateWay[4]);

/**
* @brief 重置网络配置信息
* @param [in] pEyeCBInfo   设备信息
* @param [in] eEyeIPType   眼睛IP 类型
* @param [in] byEyeIP      眼睛IP
* @param [in] byMask       子网掩码
* @param [in] byGateWay    网关
* @return 返回0表示成功
*/
VZNLAPI int VzNL_ConfigEthernetInfoEx(const SVzNLEyeCBInfo* pEyeCBInfo,
	EVzNLEthernetEyeIPType eEyeIPType,
	unsigned char byEyeIP[4],
	unsigned char byMask[4],
	unsigned char byGateWay[4]);

/**
 * @brief 设置IP类型
 * @param [in] pEyeCBInfo   设备信息
 * @param [in] eIPType      IP类型[keNLEthernetEyeIPType_StaticIP:静态IP keNLEthernetEyeIPType_DHCP:动态分配IP]
 * @return 返回0表示成功
 */
VZNLAPI int VzNL_ChangeEthernetIPType(const SVzNLEyeCBInfo* pEyeCBInfo,
	EVzNLEthernetEyeIPType eIPType);


/**
 * @brief 获取RGBD所在位置
 * @param hDevice 当前设备句柄
 * @param dCCMVal CCM值
 * @return 正确返回0， 失败返回其他值
 */
VZNLAPI int VzNL_GetRGBAsyncRect(VZNLHANDLE hDevice, SVzNLROIRect pROIRect[2]);


/**
 * @brief 获取RGB镜头的X方向视野大小(mm)
 * @param hDevice 当前设备句柄
 * @param nViewDx X方向视野大小(mm)
 * @return 正确返回0， 失败返回其他值
 */
VZNLAPI int VzNL_GetRGBViewXSize(VZNLHANDLE hDevice, unsigned int& nViewDx);

/////////////////////////////////////////////////////////////////////////////


/// @}

/// @name 多系统相关函数(gtx专用接口)
/// @{
/**
 * @brief 获取当前系统列表
 * @param hDevice 设备Handle
 * @param pnCount 输出系统的个数
 * @return 系统列表数组
 */
VZNLAPI SVzSystemProjectInfo* VzNL_GetSystemPrjArray(VZNLHANDLE hDevice, int* pnCount);

/**
 * @brief 设置当前系统索引
 * @param hDevice 设备Handle
 * @param nCurSel 要配置为第几个系统为运行时的系统
 * @return 返回0为正确，其他错误码请用GetErrorString。
 */
VZNLAPI int VzNL_SwitchSystemPrj(VZNLHANDLE hDevice, int nCurSel);

/**
 * @brief 获取当前系统索引
 * @param hDevice 设备Handle
 * @return 当前系统的索引
 */
VZNLAPI int VzNL_GetCurrentSystemPrj(VZNLHANDLE hDevice);

/**
 * @brief 查询运行时间(s)
 * @param hDevice 设备Handle
 * @param pnErrorCode 错误码
 * @return 返回运行时间
 */
VZNLAPI double VzNL_GetSystemRuntime(VZNLHANDLE hDevice, int* pnErrorCode);
/// @}


/**
 * @brief 设置激光标定。
 * @param [in] hDevice			设备句柄
 * @param [in] dStandardObjectHeight 设置标定高度
 * @param [in] pTopROI			顶部ROI数组指针
 * @param [in] nTopROICount		顶部ROI的数组个数
 * @param [in] pBottomROI		底部ROI数组指针
 * @param [in] nBottomROICount	底部ROI数组个数
 * @return 返回0为正确，失败返回错误码
 */
VZNLAPI int VzNL_SetLaserStandard(VZNLHANDLE hDevice, double dStandardObjectHeight,
	const SVzNLROIRect* pTopROI, const int nTopROICount,
	const SVzNLROIRect* pBottomROI, const int nBottomROICount);

/**
 * @brief 清除标定信息。
 * @param [in] hDevice			设备句柄
 * @return 返回0为正确，失败返回错误码
 */
VZNLAPI int VzNL_ClearLaserStandard(VZNLHANDLE hDevice);

/**
 * @brief 设置自动调节超时时间
 * @param hDevice 当前设备句柄
 * @param nTimeOut 设置自动调节超时时间
 * @return 正确返回0， 失败返回其他值
 */
VZNLAPI int VzNL_SetRGBAutoAdjustTimeOut(VZNLHANDLE hDevice, unsigned int nTimeOut);
VZNLAPI unsigned int VzNL_GetRGBAutoAdjustTimeOut(VZNLHANDLE hDevice, int* pnErrorCode);

/**
 * @brief 启用存储参数
 * @param [in] hDevice 设备句柄
 * @return 返回0表示正确
 * @retval 0 表示成功
 * @retval 非0 表示失败,可以使用VzNL_GetErrorInfo获取
 */
VZNLAPI int VzNL_EnableSaveSwingParam(VZNLHANDLE hDevice, VzBool bEnable);

/**
 * @brief 在栅格化是，点冲突时，保留z值小的点
 * @param [in] hDevice			设备句柄
 * @param [in] bEnable			VzTrue为保留z值小的点，VzFalse为保留z值大的点
 * @return 成功返回0，否则为其他错误码
 */
VZNLAPI int VzNL_SetKeepFrontPoint(VZNLHANDLE hDevice, VzBool bEnable);
VZNLAPI int VzNL_GetKeepFrontPoint(VZNLHANDLE hDevice, VzBool* bEnable);

/**
 * @brief 是否检查摆动模块角速度参数
 * @param [in] hDevice			设备句柄
 * @param [in] bEnable			VzTrue为保留z值小的点，VzFalse为保留z值大的点
 * @return 成功返回0，否则为其他错误码
 */
VZNLAPI int VzNL_EnableCheckSwingAngleSpeed(VZNLHANDLE hDevice, VzBool bEnable);
VZNLAPI int VzNL_IsEnableCheckSwingAngleSpeed(VZNLHANDLE hDevice, VzBool* bEnable);

/**
 * @brief 开启/关闭RGB图旋转功能
 * @param hDevice 当前设备句柄
 * @param [in] bEnable 是否启用
 * @return 成功返回0，否则为错误码。
 */
VZNLAPI int VzNL_EnableRotateRGBImage(VZNLHANDLE hDevice, VzBool bEnable);
VZNLAPI VzBool VzNL_IsEnableRotateRGBImage(VZNLHANDLE hDevice, int* pnErrorCode);

/**
 * @brief 是否支持动态口令
 * @param hDevice 当前设备句柄
 * @return 支持返回VzTrue
 */
VZNLAPI VzBool VzNL_IsSupportDynamicCode(VZNLHANDLE hDevice);

/**
 * @brief 检测动态口令
 * @param hDevice 当前设备句柄
 * @param [in] dynamicCode 动态口令
 * @return 成功返回0，否则为错误码。
 */
VZNLAPI int VzNL_CheckDynamicCode(VZNLHANDLE hDevice, unsigned char byDynamicCode[32]);

/**
 * @brief 是否支持仿真模式
 * @param hDevice 当前设备句柄
 * @return 支持返回VzTrue
 */
VZNLAPI VzBool VzNL_IsSupportEmulationMode(VZNLHANDLE hDevice);

/**
 * @brief 启用/关闭仿真模式
 * @param hDevice 当前设备句柄
 * @return 支持返回VzTrue
 */
VZNLAPI int VzNL_EnableEmulationMode(VZNLHANDLE hDevice,VzBool bEnable);
VZNLAPI VzBool VzNL_IsEnableEmulationMode(VZNLHANDLE hDevice, int* pnErrorCode);

/**
 * @brief 配置相机分辨率
 * @param hDevice 当前设备句柄
 * @param nWidthAndHeight 宽 + 高
 * @return 返回0为正确，失败返回错误码
 */
VZNLAPI int VzNL_ConfigEmulationResolution(VZNLHANDLE hDevice, unsigned int nWidthAndHeight[2]);
VZNLAPI int VzNL_GetEmulationResolution(VZNLHANDLE hDevice, unsigned int nWidthAndHeight[2]);

/**
* @brief 设置左右目图片和参数的路径
* @param hDevice			当前设备句柄
* @param [in] szDataPath    数据目录（2DData的父目录）
* @param [in] szParamPath   参数目录
* @param [in] pszImagePath  指定一帧的参数，全路径+文件名前缀,例如,D:\15-18-14\2DData\1
* @return 返回0为正确，失败返回错误码
*/
VZNLAPI int VzNL_ConfigEmulationParam(VZNLHANDLE hDevice, const char* pszDataPath, const char* pszParamPath, const char* pszImagePath);


/**
* @brief 推送指定帧的左右目图像和相关数据到相机中
* @param hDevice			 当前设备句柄
* @param [in] szImagePath    全路径+文件名前缀,例如,D:\15-18-14\2DData\1
* @return 返回0为正确，失败返回错误码
*/
VZNLAPI int VzNL_PushEmulationDetectImageData(VZNLHANDLE hDevice, const char* pszImagePath);

/**
 * @brief 单帧检测
 * @param [in] hDevice			设备句柄
 * @param [in] nPointInterval	点的间隔
 * @return 返回0为正确，失败返回错误码
 */
VZNLAPI int VzNL_EmulationDetectLaser(VZNLHANDLE hDevice, const char* pszImagePath);

/**
 * @brief 是否支持RGB图像旋转
 * @param hDevice 当前设备句柄
 * @return 支持返回VzTrue
 */
VZNLAPI VzBool VzNL_IsSupportRGBRotateType(VZNLHANDLE hDevice);

/**
 * @brief 配置RGB图像旋转
 * @param hDevice 当前设备句柄
 * @return 支持返回VzTrue
 */
VZNLAPI int VzNL_SetRGBRotateType(VZNLHANDLE hDevice, EVzImageRotateType eRotateType);
VZNLAPI EVzImageRotateType VzNL_GetRGBRotateType(VZNLHANDLE hDevice, int* pnErrorCode);

/**
 * @brief 保存当前舵机配置的配置类型
 * @param hDevice 当前设备句柄
 * @param [in] eConfigType 保存的配置类型
 * @return 成功返回0，否则为错误码。
 */
VZNLAPI int VzNL_SaveDustCoverConfigType(VZNLHANDLE hDevice, EVzDustCoverConfigType eConfigType);

/**
 * @brief 保存左目内参
 * @param hDevice 当前设备句柄
 * @param [in] dMatrix 左目内参矩阵 3*3 + 5*1
 * @return 成功返回0，否则为错误码。
 */
VZNLAPI int VzNL_SaveLeftEyeCalibData(VZNLHANDLE hDevice, double dMatrix[14]);

/**
 * @brief 保存左目到3D点云的转换矩阵
 * @param hDevice 当前设备句柄
 * @param [in] dStereo2Left 3D到左目的转换矩阵 4*4
 * @return 成功返回0，否则为错误码。
 */
VZNLAPI int VzNL_SaveStereo2LeftEyeMatrix(VZNLHANDLE hDevice, double dMatrix[16]);

/**
 * @brief 保存左目到3D点云的转换矩阵
 * @param hDevice 当前设备句柄
 * @param [in] dLeft2Stereo 左目到3D的转换矩阵 4*4
 * @return 成功返回0，否则为错误码。
 */
VZNLAPI int VzNL_SaveLeftEye2StereoMatrix(VZNLHANDLE hDevice, double dMatrix[16]);

/**
 * @brief 开启/关闭是否支持保存原始数据的功能
 * @param hDevice 当前设备句柄
 * @param bEnable VzTrue:开启，VzFalse:不开启
 * @return 支持返回VzTrue
 */
VZNLAPI int VzNL_EnableSaveOriData(VZNLHANDLE hDevice, VzBool bEnable);
VZNLAPI VzBool VzNL_IsEnableSaveOriData(VZNLHANDLE hDevice, int* pnErrorCode);

/**
 * @brief PL是否支持频闪功能
 * @param [in] hDevice 设备句柄
 * @param [in] pnErrorCode 错误码,为nullptr时不返回
 * @return 返回VzTrue表示支持，否则为不支持。
 */
VZNLAPI VzBool VzNL_IsSupportStrobeByPl(VZNLHANDLE hDevice, int* pnErrorCode);

/**
 * @brief 设置是否安装了频闪的硬件设备
 * @param [in] hDevice 设备句柄
 * @param [in] bInstall VzTrue:安装了，VzFalse:未安装
 * @return 成功返回0，否则为错误码。
 */
VZNLAPI int VzNL_SetInstallStrobeDevice(VZNLHANDLE hDevice, VzBool bInstall);

/**
 * @brief 是否安装了频闪的硬件设备
 * @param [in] hDevice 设备句柄
 * @param [in] pnErrorCode 错误码,为nullptr时不返回
 * @return 返回VzTrue表示安装了，否则未安装。
 */
VZNLAPI VzBool VzNL_IsInstallStrobeDevice(VZNLHANDLE hDevice, int* pnErrorCode);

/**
 * @brief PL是否支持PWM功率调节功能
 * @param [in] hDevice 设备句柄
 * @param [in] pnErrorCode 错误码,为nullptr时不返回
 * @return 返回VzTrue表示支持，否则为不支持。
 */
VZNLAPI VzBool VzNL_IsSupportPwmByPl(VZNLHANDLE hDevice, int* pnErrorCode);

/**
 * @brief 设置是否安装了PWM功率调节的硬件设备
 * @param [in] hDevice 设备句柄
 * @param [in] bInstall VzTrue:安装了，VzFalse:未安装
 * @return 成功返回0，否则为错误码。
 */
VZNLAPI int VzNL_SetInstallPwmDevice(VZNLHANDLE hDevice, VzBool bInstall);

/**
 * @brief 是否安装了PWM功率调节的硬件设备
 * @param [in] hDevice 设备句柄
 * @param [in] pnErrorCode 错误码,为nullptr时不返回
 * @return 返回VzTrue表示安装了，否则未安装。
 */
VZNLAPI VzBool VzNL_IsInstallPwmDevice(VZNLHANDLE hDevice, int* pnErrorCode);

/**
 * @brief PL是否支持补光灯功能
 * @param [in] hDevice 设备句柄
 * @param [in] pnErrorCode 错误码,为nullptr时不返回
 * @return 返回VzTrue表示支持，否则为不支持。
 */
VZNLAPI VzBool VzNL_IsSupportExtLightByPl(VZNLHANDLE hDevice, int* pnErrorCode);

/**
 * @brief 设置是否安装了补光灯的硬件设备
 * @param [in] hDevice 设备句柄
 * @param [in] bInstall VzTrue:安装了，VzFalse:未安装
 * @return 成功返回0，否则为错误码。
 */
VZNLAPI int VzNL_SetInstallExtLightDevice(VZNLHANDLE hDevice, VzBool bInstall);

/**
 * @brief 是否安装了补光灯的硬件设备
 * @param [in] hDevice 设备句柄
 * @param [in] pnErrorCode 错误码,为nullptr时不返回
 * @return 返回VzTrue表示安装了，否则未安装。
 */
VZNLAPI VzBool VzNL_IsInstallExtLightDevice(VZNLHANDLE hDevice, int* pnErrorCode);

/**
 * @brief 设置/获取点云Y轴过滤数据
 * @param [in] hDevice 设备句柄
 * @param [in] dYData Y轴过滤数据
 * @return 成功返回0，否则为错误码。
 */
VZNLAPI int VzNL_SetLaserFilterYData(VZNLHANDLE hDevice, double dYData[2]);
VZNLAPI int VzNL_GetLaserFilterYData(VZNLHANDLE hDevice, double dYData[2]);

/**
 * @brief 设置/获取点云Z轴过滤数据
 * @param [in] hDevice 设备句柄
 * @param [in] dYData Z轴过滤数据
 * @return 成功返回0，否则为错误码。
 */
VZNLAPI int VzNL_SetLaserFilterZData(VZNLHANDLE hDevice, double dZData[2]);
VZNLAPI int VzNL_GetLaserFilterZData(VZNLHANDLE hDevice, double dZData[2]);

/**
 * @brief 获取左右目激光对比度
 * @param [in] hDevice 设备句柄
 * @param [in] nRatio 左右目的激光对比度，0为左目的对比度，1为右目的对比度
 * @return 成功返回0，否则为错误码。
 */
VZNLAPI int VzNL_GetLaserContrastRatio(VZNLHANDLE hDevice, unsigned int nRatio[2]);

/**
 * @brief 设置/获取运动方向
 * @param [in] hDevice 设备句柄
 * @param [in] EVzAntiReflectCmpsDirType 运动方向类型
 * @return 成功返回0，否则为错误码。
 */
VZNLAPI int VzNL_SetAntiReflectCmpsDirType(VZNLHANDLE hDevice, EVzAntiReflectCmpsDirType eAntiReflectCmpsDirType);
VZNLAPI EVzAntiReflectCmpsDirType VzNL_GetAntiReflectCmpsDirType(VZNLHANDLE hDevice, int* pnErrorCode);

/**
 * @brief 设置/获取运动补偿
 * @param [in] hDevice 设备句柄
 * @param [in] nValue 运动补偿
 * @return 成功返回0，否则为错误码。
 */
VZNLAPI int VzNL_SetAntiReflectCmpsDot(VZNLHANDLE hDevice, unsigned int nValue);
VZNLAPI unsigned int VzNL_GetAntiReflectCmpsDot(VZNLHANDLE hDevice, int* pnErrorCode);

/**
 * @brief 设置是否支持推杆翻盖
 * @param [in] hDevice 设备句柄
 * @param [in] bInstall VzTrue:支持，VzFalse:不支持
 * @return 成功返回0，否则为错误码。
 */
VZNLAPI int VzNL_SetSupportLinearActuatorDevice(VZNLHANDLE hDevice, VzBool bSupport);


/**
 * @brief 是否支持推杆翻盖控制的功能
 * @param hDevice 当前设备句柄
 * @param pnErrorCode 错误信息，如果不需要可填NULL
 * @return VzTrue 表示支持 VzFalse 表示不支持
 */
VZNLAPI VzBool VzNL_IsSupportLinearActuatorCover(VZNLHANDLE hDevice, int* pnErrorCode);

/**
 * @brief 推杆电机找零
 * @param [in] hDevice 设备句柄
 * @return 成功返回0，否则为错误码。
 */
VZNLAPI int VzNL_LinearActuatorFindZero(VZNLHANDLE hDevice);

VZNLAPI int VzNL_LinearActuatorMFindZero(VZNLHANDLE hDevice);

/** @brief 开启/关闭推杆翻盖控制的功能
 *  @param hDevice		[in] 设备Handle
 *  @param bEnable		[in] 开启/关闭
 *  @return 正确返回0， 失败返回其他值
 */
VZNLAPI int VzNL_EnableLinearActuatorCover(VZNLHANDLE hDevice, VzBool bEnable);
VZNLAPI VzBool VzNL_IsEnableLinearActuatorCover(VZNLHANDLE hDevice, int* pnErrorCode);

/** @brief 推杆翻盖保存关闭点的位置
 *  @param hDevice		[in] 设备Handle
 *  @return 正确返回0， 失败返回其他值
 */
VZNLAPI int VzNL_LinearActuatorSaveClosePos(VZNLHANDLE hDevice);

/** @brief 配置左右目的图像类型
 *  @param hDevice		[in] 设备Handle
 *  @param eImageType	[in] 图像类型
 *  @return 正确返回0， 失败返回其他值
 */
VZNLAPI int VzNL_SetLRSensorImageType(VZNLHANDLE hDevice, EVzNLImageType eLeftImageType, EVzNLImageType eRightImageType);


/**
 * @brief 开启/关闭抗反光调试
 * @param [in] hDevice 设备句柄
 * @param [out] eAntiReflectGainType 抗反光增益类型
 * @return 成功返回0，否则为错误码。
 */
VZNLAPI int VzNL_EnableAntiReflectDebug(VZNLHANDLE hDevice, VzBool bEnable);
VZNLAPI VzBool VzNL_IsEnableAntiReflectDebug(VZNLHANDLE hDevice, int* pnErrorCode);

/**
 * @brief 设置、获取是否安装了舵机翻盖装置
 * @param [in] hDevice 设备句柄
 * @param [in] bInstall 是否安装
 * @return 成功返回0，否则为错误码。
 */
VZNLAPI int VzNL_InstallServoMotor(VZNLHANDLE hDevice, VzBool bInstall);
VZNLAPI VzBool VzNL_IsInstallServoMotor(VZNLHANDLE hDevice, int* pnErrorCode);

VZNLAPI int VzNL_WriteDebugRegister(VZNLHANDLE hDevice, unsigned int nAddress,unsigned int nValue);

/**
 * @brief 设置、获取自动开关盖设置
 * @param [in] hDevice 设备句柄
 * @param [out] eAntiReflectGainType 抗反光增益类型
 * @return 成功返回0，否则为错误码。
 */
VZNLAPI int VzNL_SetAutoCoverControlParam(VZNLHANDLE hDevice, SVzAutoCoverControlParam sAutoCoverControlParam);
VZNLAPI int VzNL_GetAutoCoverControlParam(VZNLHANDLE hDevice, SVzAutoCoverControlParam* psAutoCoverControlParam);

/**
 * @brief 设置最大工作范围
 * @param [in] hDevice			设备句柄
 * @param [in] dNearDistance	近距离
 * @param [in] dFarDistance		远距离
 * @return 返回0表示正确
 * @retval 0 表示成功
 * @retval 非0 表示失败,可以使用VzNL_GetErrorInfo获取
 */
VZNLAPI int VzNL_SetMaxWorkRange(VZNLHANDLE hDevice, double dNearDistance, double dFarDistance);
VZNLAPI int VzNL_GetMaxWorkRange(VZNLHANDLE hDevice, double* pdNearDistance, double* pdFarDistance);


/**
 * @brief 设置/获取双目图像bit位数
 * @param [in] hDevice 设备句柄
 * @param [in] nValue bit位数
 * @return 成功返回0，否则为错误码。
 */
VZNLAPI int VzNL_SetImageBitDepth(VZNLHANDLE hDevice, unsigned int nValue);
VZNLAPI unsigned int VzNL_GetImageBitDepth(VZNLHANDLE hDevice, int* pnErrorCode);

/**
 * @brief 设置/获取双目图像16位数据转8位数据对齐位置
 * @param [in] hDevice 设备句柄
 * @param [in] nValue 运动补偿
 * @return 成功返回0，否则为错误码。
 */
VZNLAPI int VzNL_SetImageConvertAlignPos(VZNLHANDLE hDevice, unsigned int nValue);
VZNLAPI unsigned int VzNL_GetImageConvertAlignPos(VZNLHANDLE hDevice, int* pnErrorCode);


/**
 * @brief 设置/获取翻盖打开圈数
 * @param [in] hDevice 设备句柄
 * @param [in] nValue 圈数
 * @return 成功返回0，否则为错误码。
 */
VZNLAPI int VzNL_SetOpenCoverRound(VZNLHANDLE hDevice, int nValue);
VZNLAPI int VzNL_GetOpenCoverRound(VZNLHANDLE hDevice, int* pnErrorCode);


/**
 * @brief 设置/获取翻盖关闭偏差
 * @param [in] hDevice 设备句柄
 * @param [in] nValue 偏差
 * @return 成功返回0，否则为错误码。
 */
VZNLAPI int VzNL_SetCloseCoverOffset(VZNLHANDLE hDevice, int nValue);
VZNLAPI int VzNL_GetCloseCoverOffset(VZNLHANDLE hDevice, int* pnErrorCode);


/**
 * @brief 设置/获取翻盖角度
 * @param [in] hDevice 设备句柄
 * @param [in] nAngle 角度 1-100
 * @return 成功返回0，否则为错误码。
 */
VZNLAPI int VzNL_SetDustOpenAngle(VZNLHANDLE hDevice, int nAngle);
VZNLAPI int VzNL_GetDustOpenAngle(VZNLHANDLE hDevice, int* pnErrorCode);

/**
* @brief 设置/获取回摆角速度
* @param [in] hDevice 设备句柄
* @param [in] nAngleSpeed 角速度
* @return 返回0表示正确
* @retval 0 表示成功
* @retval 非0 表示失败,可以使用VzNL_GetErrorInfo获取
*/
VZNLAPI int VzNL_SetSwingBackAngleSpeed(VZNLHANDLE hDevice, int nAngleSpeed);
VZNLAPI int VzNL_GetSwingBackAngleSpeed(VZNLHANDLE hDevice, int* pnAngleSpeed);

/**
 * @brief 设置摆动角度和当前角度阈值
 * @param [in] hDevice 设备句柄
 * @param [in] fAngle 角度阈值
 * @return 返回0表示正确
 * @retval 0 表示成功
 * @retval 非0 表示失败,可以使用VzNL_GetErrorInfo获取
 */
VZNLAPI int VzNL_SetRoateAngleThres(VZNLHANDLE hDevice, float fAngle);
VZNLAPI float VzNL_GetRoateAngleThres(VZNLHANDLE hDevice, int* pnErrorCode);


/**
 * @brief 设置/获取颜色转换映射表数据
 * @param [in] hDevice 设备句柄
 * @param [in] nData 映射表数据
 * @return 成功返回0，否则为错误码。
 */
VZNLAPI int VzNL_SetSensorColorMapData(VZNLHANDLE hDevice, unsigned char szData[4096]);
VZNLAPI int VzNL_GetSensorColorMapData(VZNLHANDLE hDevice, unsigned char szData[4096]);

/**
 * @brief 使能485接口
 * @param [in] hDevice 设备句柄
 * @param [in] bEnable 是否使能485接口
 * @return 成功返回0，否则为错误码。
 */
VZNLAPI int VzNL_Enable485Signal(VZNLHANDLE hDevice, VzBool bEnable);
VZNLAPI VzBool VzNL_IsEnable485Signal(VZNLHANDLE hDevice, int* pnErrorCode);


/**
 * @brief 选择RGB Sensor中某一种颜色通道作为数据输出
 * @param [in] hDevice 设备句柄
 * @param [in] nValue 数值
 * @return 成功返回0，否则为错误码。
 */
VZNLAPI int VzNL_SetRGBOutputChannel(VZNLHANDLE hDevice, EVzRGBOutputChannelType eType);
VZNLAPI EVzRGBOutputChannelType VzNL_GetRGBOutputChannel(VZNLHANDLE hDevice, int* pnErrorCode);

/**
 * @brief 设置左右目sensor类型
 * @param [in] hDevice 设备句柄
 * @param [in] nValue 数值
 * @return 成功返回0，否则为错误码。
 */
VZNLAPI int VzNL_SetLRSensorType(VZNLHANDLE hDevice, EVzLRSensorType eType);
VZNLAPI EVzLRSensorType VzNL_GetLRSensorType(VZNLHANDLE hDevice, int* pnErrorCode);

/**
 * @brief 设置双目彩色拍照RGB曝光
 * @param hDevice 当前设备句柄
 * @param nValue 
 * @return 正确返回0， 失败返回其他值
 */
VZNLAPI int VzNL_SetLRRGBExpose(VZNLHANDLE hDevice, unsigned int nValue);
VZNLAPI unsigned int VzNL_GetLRRGBExpose(VZNLHANDLE hDevice, int* pnErrorCode);

/**
 * @brief 保存左右目的拜耳图像
 * @param hDevice 当前设备句柄
 * @param szLeftFileName 左目图像的文件名
 * @param szRightFileName 右目图像的文件名
 * @return 正确返回0， 失败返回其他值
 */
VZNLAPI int VzNL_SaveLRBayerImage(VZNLHANDLE hDevice, const char* szLeftFileName, const char* szRightFileName);

/**
 * @brief 获取摆动机构编码器值
 * @param [in] hDevice 设备句柄
 * @param [in] pnErrorCode 错误码
 * @return 摆动机构编码器值。
 */
VZNLAPI unsigned int VzNL_GetSwingEncode(VZNLHANDLE hDevice, int* pnErrorCode);

/**
 * @brief PL是否支持Ch3功能
 * @param [in] hDevice 设备句柄
 * @param [in] pnErrorCode 错误码,为nullptr时不返回
 * @return 返回VzTrue表示支持，否则为不支持。
 */
VZNLAPI VzBool VzNL_IsSupportCh3ByPl(VZNLHANDLE hDevice, int* pnErrorCode);

/**
 * @brief 设置是否安装了Ch3的硬件设备
 * @param [in] hDevice 设备句柄
 * @param [in] bInstall VzTrue:安装了，VzFalse:未安装
 * @return 成功返回0，否则为错误码。
 */
VZNLAPI int VzNL_SetInstallCh3Device(VZNLHANDLE hDevice, VzBool bInstall);

/**
 * @brief 是否安装了Ch3的硬件设备
 * @param [in] hDevice 设备句柄
 * @param [in] pnErrorCode 错误码,为nullptr时不返回
 * @return 返回VzTrue表示安装了，否则未安装。
 */
VZNLAPI VzBool VzNL_IsInstallCh3Device(VZNLHANDLE hDevice, int* pnErrorCode);

/**
* @brief 设置支持RGB HDR功能
* @param [in] hDevice 设备句柄
* @param [in] pnErrorCode 错误码,为nullptr时不返回
* @return 返回VzTrue表示支持，否则为不支持。
*/
VZNLAPI int VzNL_SetIsSupportRGBHDR(VZNLHANDLE hDevice, VzBool bSupport);


/**
 * @brief 设置/获取静态扫描端点采图功能采集图像的曝光时间
 * @param [in] hDevice 设备句柄
 * @param [in] eExposeMode [keVzNLExposeMode_Fix=定值曝光 / keVzNLExposeMode_Auto=自动曝光]
 * @param [in] nExposeTime 高曝光时间[0~65535]
 * @return 返回错误码
 * @note: 目前智光眼/星光眼仅支持定值曝光
 */
VZNLAPI int VzNL_ConfigSideCaptureExpose(VZNLHANDLE hDevice, EVzNLExposeMode eExposeMode, unsigned int nExposeTime);
VZNLAPI int VzNL_GetSideCaptureExpose(VZNLHANDLE hDevice, EVzNLExposeMode* peExposeMode, unsigned int* pnExposeTime);

/**
 * @brief 是否支持静态扫描端点采图功能
 * @param [in] hDevice 设备句柄
 * @param [in] pnErrorCode 错误码,为nullptr时不返回
 * @return 返回VzTrue表示支持，否则不支持。
 */
VZNLAPI VzBool VzNL_IsSupportSideCapture(VZNLHANDLE hDevice, int* pnErrorCode);

/**
 * @brief 使能静态扫描端点采图功能
 * @param [in] hDevice 设备句柄
 * @param [in] bEnable 是否使能
 * @return 成功返回0，否则为错误码。
 */
VZNLAPI int VzNL_EnableSideCapture(VZNLHANDLE hDevice, VzBool bEnable);
VZNLAPI VzBool VzNL_IsEnableSideCapture(VZNLHANDLE hDevice, int* pnErrorCode);


/**
 * @brief 是否支持超低曝光
 * @param [in] hDevice 设备句柄
 * @param [in] pnErrorCode 错误码,为nullptr时不返回
 * @return 返回VzTrue表示支持，否则不支持。
 */
VZNLAPI VzBool VzNL_IsSupportLowExp(VZNLHANDLE hDevice, int* pnErrorCode);

/**
 * @brief 使能超低曝光
 * @param [in] hDevice 设备句柄
 * @param [in] bEnable 是否使能
 * @return 成功返回0，否则为错误码。
 */
VZNLAPI int VzNL_EnableLowExp(VZNLHANDLE hDevice, VzBool bEnable);
VZNLAPI VzBool VzNL_IsEnableLowExp(VZNLHANDLE hDevice, int* pnErrorCode);

/**
 * @brief 使能图像美化功能
 * @param [in] hDevice 设备句柄
 * @param [in] bEnable 是否使能
 * @return 成功返回0，否则为错误码。
 */
VZNLAPI int VzNL_EnableISPBeautify(VZNLHANDLE hDevice, VzBool bEnable);
VZNLAPI VzBool VzNL_IsEnableISPBeautify(VZNLHANDLE hDevice, int* pnErrorCode);

/**
 * @brief 使能图像白平衡
 * @param [in] hDevice 设备句柄
 * @param [in] bEnable 是否使能
 * @return 成功返回0，否则为错误码。
 */
VZNLAPI int VzNL_EnableISPAWB(VZNLHANDLE hDevice, VzBool bEnable);
VZNLAPI VzBool VzNL_IsEnableISPAWB(VZNLHANDLE hDevice, int* pnErrorCode);

/**
 * @brief 使能图像CCM
 * @param [in] hDevice 设备句柄
 * @param [in] bEnable 是否使能
 * @return 成功返回0，否则为错误码。
 */
VZNLAPI int VzNL_EnableISPCCM(VZNLHANDLE hDevice, VzBool bEnable);
VZNLAPI VzBool VzNL_IsEnableISPCCM(VZNLHANDLE hDevice, int* pnErrorCode);

VZNLAPI int VzNL_GetLaser2DFResult(VZNLHANDLE hDevice, SVzNL2DPositionF* p2DPoint, int* pnCount);

/**
 * @brief 是否支持相机特征描述数据
 * @param [in] hDevice 设备句柄
 * @param [in] pnErrorCode 错误码,为nullptr时不返回
 * @return 返回VzTrue表示支持，否则不支持。
 */
VZNLAPI VzBool VzNL_IsSupportCamFeatureData(VZNLHANDLE hDevice, int* pnErrorCode);

/**
 * @brief 设置/获取相机特征描述数据
 * @param [in] hDevice 设备句柄
 * @param [in] nData 相机特征描述数据
 * @return 成功返回0，否则为错误码。
 */
VZNLAPI int VzNL_SetCamFeatureData(VZNLHANDLE hDevice, SVzFeatureData sVzFeatureData);
VZNLAPI int VzNL_GetCamFeatureData(VZNLHANDLE hDevice, SVzFeatureData* psVzFeatureData);


/**
 * @brief 是否支持多帧差值的累加功能
 * @param [in] hDevice 设备句柄
 * @param [in] pnErrorCode 错误码,为nullptr时不返回
 * @return 返回VzTrue表示支持，否则不支持。
 */
VZNLAPI VzBool VzNL_IsSupportMulRate(VZNLHANDLE hDevice, int* pnErrorCode);

/**
 * @brief 设置/获取多帧差值的累加帧数
 * @param [in] hDevice 设备句柄
 * @param [in] nRate 帧数
 * @return 成功返回0，否则为错误码。
 */
VZNLAPI int VzNL_SetMulInterRate(VZNLHANDLE hDevice, unsigned int nRate);
VZNLAPI unsigned int VzNL_GetMulInterRate(VZNLHANDLE hDevice, int* pnErrorCode);

/**
 * @brief 设置/获取多少帧一次循环
 * @param [in] hDevice 设备句柄
 * @param [in] nCycle  循环次数
 * @return 成功返回0，否则为错误码。
 */
VZNLAPI int VzNL_SetMulRateCycle(VZNLHANDLE hDevice, unsigned int nCycle);
VZNLAPI unsigned int VzNL_GetMulRateCycle(VZNLHANDLE hDevice, int* pnErrorCode);


/**
 * @brief 设置/获取在hdr开启后确定输出多少帧的低曝光帧
 * @param [in] hDevice 设备句柄
 * @param [in] nNum  低曝光帧数量
 * @return 成功返回0，否则为错误码。
 */
VZNLAPI int VzNL_SetLowExpNum(VZNLHANDLE hDevice, unsigned int nNum);
VZNLAPI unsigned int VzNL_GetLowExpNum(VZNLHANDLE hDevice, int* pnErrorCode);

/**
 * @brief 设置/获取在hdr配置参数
 * @param [in] hDevice 设备句柄
 * @param [in] nCycle  循环次数
 * @param [in] nRate 帧数
 * @param [in] nNum  低曝光帧数量
 * @return 成功返回0，否则为错误码。
 */
VZNLAPI int VzNL_SetHDRConfig(VZNLHANDLE hDevice, unsigned int nCycle, unsigned int nRate,unsigned int nNum);
VZNLAPI int VzNL_GetHDRConfig(VZNLHANDLE hDevice, unsigned int* pnCycle, unsigned int* pnRate, unsigned int* pnNum);

/**
 * @brief 是否支持触发延时
 * @param [in] hDevice 设备句柄
 * @param [in] pnErrorCode 错误码,为nullptr时不返回
 * @return 返回VzTrue表示支持，否则不支持。
 */
VZNLAPI VzBool VzNL_IsSupportTrigDelay(VZNLHANDLE hDevice, int* pnErrorCode);

/**
 * @brief 设置/获取触发延时
 * @param [in] hDevice 设备句柄
 * @param [in] nDelay  延时
 * @return 成功返回0，否则为错误码。
 */
VZNLAPI int VzNL_SetTrigDelay(VZNLHANDLE hDevice, unsigned int nDelay);
VZNLAPI unsigned int VzNL_GetTrigDelay(VZNLHANDLE hDevice, int* pnErrorCode);


/**
 * @brief 获取自摆动机械零位
 * @param [in] hDevice 设备句柄
 * @param [in] pnErrorCode	错误码
 * @return 自摆动机械零位
 */
VZNLAPI int VzNL_QueryMotorZero(VZNLHANDLE hDevice, int* pnErrorCode);

/**
 * @brief 是否支持相机时间戳功能
 * @param [in] hDevice 设备句柄
 * @param [in] pnErrorCode 错误码,为nullptr时不返回
 * @return 返回VzTrue表示支持，否则不支持。
 */
VZNLAPI VzBool VzNL_IsSupportTimeStamp(VZNLHANDLE hDevice, int* pnErrorCode);

/**
* @brief 使能相机时间戳功能
* @param [in] hDevice 设备句柄
 * @param [in] bEnable 是否使能
 * @return 成功返回0，否则为错误码。
 */
VZNLAPI int VzNL_EnableTimeStamp(VZNLHANDLE hDevice, VzBool bEnable);
VZNLAPI VzBool VzNL_IsEnableTimeStamp(VZNLHANDLE hDevice, int* pnErrorCode);

/**
 * @brief 保存默认参数配置，当前仅支持智光眼
 * @param hDevice 设备Handle
 */
VZNLAPI int VzNL_SaveDefaultConfig(VZNLHANDLE hDevice, const void* pExtData, unsigned int nExtDataLength);

#endif