#ifndef __PHOSKEY_SS_H__
#define __PHOSKEY_SS_H__

#include <stdint.h>
#include <functional>

#if _WIN32
#ifdef CPPDLL_EXPORTS
#define CPP_EXPORTS __declspec(dllexport)
#else
#define CPP_EXPORTS __declspec(dllimport)
#endif


#define CPP_STDCALL __stdcall

#else

#ifdef CPPDLL_EXPORTS
    #define CPP_EXPORTS __attribute__ ((visibility ("default")))
#endif

#define CPP_EXPORTS
#define CPP_STDCALL

#endif


struct _GLX8_2_Data
{
	int lDeviceId;
	int Head;
};


typedef _GLX8_2_Data* GLX8_2_Data;

struct GLX8_2_ETHERNET_CONFIG
{
	unsigned char abyIpAddress[4];
};


struct GLX8_2_STR_CALLBACK_INFO
{
	int xPoints;                //x方向数据数量
	int BatchPoints;            //批处理数量
	int BatchTimes;             //批处理次数

	double xPixth;              //x方向点间距
	int startEncoder;           //批处理开始编码器值
	int HeadNumber;             //相机头数量
	int returnStatus;           //0:正常批处理
	int EXTROI_EN;             // 0=正常批处理，1=yroi行数会与设置的批处理数量不一致
};


struct GLX8_2_ModelInfo{
	char Model[16];          // 型号
	int PointSetCount;        // 设置的批处理数量
	int ProfileDataWidth;     // 数据宽度
	double xPixth;            // x方向点间距 mm
	double yPixth;			  // 时间轴间距 mm， -1 为没有设置，需要自行设置
	char HeaderSerial[32];   // 传感器头序列号
	char CtrlSerial[32];     // 控制器序列号
	unsigned int  CurrentEncoder;	  // 当前编码器的值
	int CurrentBatchTimes;           // 当前批处理次数
	char dllVersion[16];     // dll库的版本号

	double zRangmin;    // z最小量程mm
	double zRangmax;    // z最大量程mm

	double xRangmin;    // x最小量程mm
	double xRangmax;    // x最大量程mm

    double res_z;       //高度分辨率
};

/// <summary>
/// 扩展函数的配置
/// </summary>
struct GLX8_2_EXTEND
{
	bool ext_en; // 扩展函数使能
	int x_binning; // 0 = off, 1 = 2048 , 2 = 1024, 3 = 512, 4 = 256
	int x_roi_start; 
	int x_roi_end;
	int y_roi_start;
	int y_roi_end;
	int32_t z_tmpl[4096]; // z轴像素补偿的数组，单位0.01
	int z_tmpl_len;  // 轴像素补偿的数组生效的长度

	int NORMAL_WIDTH = 22;

    float gray_gamma;

    uint64_t features_flag;

    struct {
        int thres1, thres2, r, r_open;
        bool is_open;
        bool is_connected;
        int area_thres;
    }filter_grad_param;

    int32_t x_offset_563tif;
    int32_t roi_y1, roi_y2;
    double z_offset_563tif;
    int32_t light_offset_upper;
    int32_t thr_width_l, thr_width_h, thr_wh_ratio;
    int32_t filter_grad_object;
    int32_t profile_output_width;

    int32_t run_mode;

    struct {
        bool cloud_align;
        int32_t b_x_offset;
        double b_z_offset;
        int32_t single_valid_output;
        double height_delta_thres;
        int32_t dual_valid_output_in_delta, dual_valid_output_beyond_delta;
    }dual_merge_param;

    uint32_t callback_timeout;
    int32_t timeout_callback_amount;
};

enum class GLX8_2_Rc
{
	Ok = 0,  // 正常返回
	SocketErr = 1001,  //通信异常
	SystemErr = 3090,  // 系统错误
	SystemCaliErr = 3091,     // 系统错误
	ErrHaveOpenDeviceYet = 4091, //设备已经打开
	ErrOpenDevice = 4096, // 打开设备失败
	ErrNoDevice = 4097,  // 设备不存在
	ErrSend = 4098,      //发送失败
	ErrReceive = 4099,   // 接收失败
	ErrTimeout = 4100,   // 超时
	ErrNomemory = 4101,  // 内存错误
	ErrParameter = 4102, // 参数错误
	ErrRecvFmt = 4103, // 接收格式错误
	ErrHispeedNoDevice = 4105,
	ErrHispeedOpenYet = 4106,
	ErrHispeedRecvYet = 4107,
	ErrBufferShort = 4108, // 缓存太小
	ErrDisallowedSettings = 5001, // 不允许的设置
	ErrNullData = 5002, // 批处理数据为空
	ErrBatchTop = 5003, // 错误的开始行数
	ErrVersion = 5100,  // 固件版本与sdk版本不匹配
	ERRCodeerSpeed = 6001, // 编码器过快
	ErrBatch = 0x8081, // 不允许批处理
	ErrRequest = -1  // 错误的请求
};

enum GLX8_2_EXTEND_FEATURE {
    extend_feature_x_binning = 1,                   //x binning
    extend_feature_x_roi = 2,                       //x roi
    extend_feature_z_offset = 4,                    //z高度补偿
    extend_feature_light_correction = 8,            //亮度补正
    extend_feature_filter_grad = 16,                //高度过滤
    extend_feature_theta_base_zero = 32,            //倾斜基准归零
};

#define GLX8_2_ERROR_ROLL_DATA_OVERFLOW            (-985)                  // 无终止循环批处理出现溢出异常等.
#define GLX8_2_ERROR_ROLL_BUSY                     (-984)                  // 无终止循环批处理读数据忙.

struct GLX8_2_OUTLINE16BIT
{
	double zpitch;
	int res;
};

/**
* GLX8_2_HighSpeedDataCallBack 高速回调函数
** notify
0x00000004 批处理开始
0x00000008 超时错误
0x00000010 其他错误（停止 IO 信号输入等）
0x00010000 正常结束
0x80000000 批处理重新开始
其他 未定义

** buffer 深度数据 0.01um单位
* (uint32_t)(size / sizeof(uint32_t));   //轮廓宽度 4096
** count 批处理行数
** user 用户自定义回传参数
*/
typedef void (*GLX8_2_HighSpeedDataCallBack)(const int32_t* buffer, uint32_t size, uint32_t count, uint32_t notify, uint32_t user);

/**
** GLX8_2_BatchOneTimeCallBack 批处理一次回调一次函数
* info 批处理数据
*/
typedef void (*GLX8_2_BatchOneTimeCallBack)(const GLX8_2_STR_CALLBACK_INFO* info, const GLX8_2_Data DataObj);

/// <summary>
/// 初始化dll
/// </summary>
/// <returns></returns>
extern "C" CPP_EXPORTS int CPP_STDCALL GLX8_2_Initialize();

/// <summary>
/// 搜索在线设备
/// </summary>
/// <param name="count">搜索到的在线设备数量</param>
/// <param name="timeout">搜索超时时间</param>
/// <returns>GLX8_2_ETHERNET_CONFIG</returns>
extern "C" CPP_EXPORTS GLX8_2_ETHERNET_CONFIG* CPP_STDCALL GLX8_2_SearchOnline(int* count, int timeout);

/// <summary>
/// 通信连接
/// </summary>
/// <param name="lDeviceId">设备ID号,范围为 0 - 256</param>
/// <param name="pEthernetConfig">通信设定</param>
/// <returns>GLX8_2_Rc</returns>
extern "C" CPP_EXPORTS int CPP_STDCALL GLX8_2_EthernetOpen(int lDeviceId, GLX8_2_ETHERNET_CONFIG * pEthernetConfig);

/// <summary>
/// 断开与相机的连接
/// </summary>
/// <param name="lDeviceId">设备ID号,范围为 0 - 256</param>
/// <returns>GLX8_2_Rc</returns>
extern "C" CPP_EXPORTS int CPP_STDCALL GLX8_2_CommClose(int lDeviceId);

/// <summary>
/// 切换程序设定
/// </summary>
/// <param name="lDeviceId">设备ID号,范围为 0 - 256</param>
/// <param name="pEthernetConfig">程序设定编号</param>
/// <returns>GLX8_2_Rc</returns>
extern "C" CPP_EXPORTS int CPP_STDCALL GLX8_2_SwitchProgram(int lDeviceId, int No);

/// <summary>
/// 软件批处理开始
/// </summary>
/// <param name="lDeviceId"></param>
/// <param name="Timeout"></param>
/// <returns>GLX8_2_Rc</returns>
extern "C" CPP_EXPORTS int CPP_STDCALL GLX8_2_StartMeasure(int lDeviceId, int Timeout);

/// <summary>
/// 开始批处理,硬件IO触发开始批处理，具体查看硬件手册
/// </summary>
/// <param name="lDeviceId">设备ID号，范围为0 - 256</param>     
/// <param name="Timeout">非循环获取时,超时时间(单位ms)</param>       
/// <param name="restart">预留，设为0</param>       
/// <returns><0：成功; 小于0：失败/returns>                  
extern "C" CPP_EXPORTS int CPP_STDCALL GLX8_2_StartIOTriggerMeasure(int lDeviceId, int Timeout, int restart);

/// <summary>
/// 批处理结束
/// </summary>
/// <param name="lDeviceId">设备ID号，范围为0 - 256</param>
/// <returns>GLX8_2_Rc</returns>
extern "C" CPP_EXPORTS int CPP_STDCALL GLX8_2_StopMeasure(int lDeviceId);


/// <summary>
/// 获取当前一条轮廓,需要关闭批处理测量
/// </summary>
/// <param name="lDeviceId"></param>
/// <param name="pProfileData">返回轮廓的指针.</param>
/// <param name="pEncoder">返回编码器的指针.</param>
/// <returns>GLX8_2_Rc</returns>
extern "C" CPP_EXPORTS int CPP_STDCALL GLX8_2_GetSingleProfile(unsigned int lDeviceId, int* pProfileData, unsigned int* pEncoder);

/// <summary>
/// 阻塞方式获取数据.
/// </summary>
/// <param name="lDeviceId"></param>
/// <param name="DataObj"></param>
/// <returns></returns>
extern "C" CPP_EXPORTS int CPP_STDCALL GLX8_2_ReceiveData(int lDeviceId, GLX8_2_Data DataObj);


/// <summary>
/// 获取当前编码器的值
/// </summary>
/// <param name="lDeviceId">设备ID号，范围为0 - 256</param>
/// <param name="DataObj"></param>
/// <returns>当前编码器的值 , 小于 0错误 </returns>
extern "C" CPP_EXPORTS int CPP_STDCALL GLX8_2_GetCurrentEncoder(int lDeviceId, unsigned int* value);

/// <summary>
/// 获取当前批处理设定行数
/// </summary>
/// <param name="lDeviceId">设备ID号，范围为0 - 256</param>
/// <param name="DataObj">预留,默认 NULL</param>
/// <returns></returns>
extern "C" CPP_EXPORTS int CPP_STDCALL GLX8_2_ProfilePointSetCount(int lDeviceId, GLX8_2_Data DataObj);

/// <summary>
/// 非阻塞获取批处理实际获取行数
/// </summary>
/// <param name="lDeviceId">设备ID号，范围为0 - 256</param>
/// <param name="DataObj">预留,默认 NULL</param>
/// <returns></returns>
extern "C" CPP_EXPORTS int CPP_STDCALL GLX8_2_ProfilePointCount(int lDeviceId, GLX8_2_Data DataObj);

/// <summary>
/// 非阻塞获取轮廓数据
/// </summary>
/// <param name="lDeviceId">设备ID号，范围为0 - 256</param>
/// <param name="DataObj">预留,默认 NULL</param>
/// <param name="profile">数据指针</param>
/// <param name="count">获取的最大长度</param>
/// <returns></returns>
extern "C" CPP_EXPORTS int CPP_STDCALL GLX8_2_GetProfileContiuneData(int lDeviceId, GLX8_2_Data DataObj, int* profile, unsigned int count);

/// <summary>
/// 非阻塞获取亮度数据
/// </summary>
/// <param name="lDeviceId">设备ID号，范围为0 - 256</param>
/// <param name="DataObj">预留,默认 NULL</param>
/// <param name="profile">数据指针</param>
/// <param name="count">获取的最大长度</param>
/// <returns></returns>
extern "C" CPP_EXPORTS int CPP_STDCALL GLX8_2_GetIntensityContiuneData(int lDeviceId, GLX8_2_Data DataObj, unsigned char* intensity, unsigned int count);

/// <summary>
/// 非阻塞获取编码器数值
/// </summary>
/// <param name="lDeviceId">设备ID号，范围为0 - 256</param>
/// <param name="DataObj">预留,默认 NULL</param>
/// <param name="profile">数据指针</param>
/// <param name="count">获取的最大长度</param>
/// <returns></returns>
extern "C" CPP_EXPORTS int CPP_STDCALL GLX8_2_GetEncoderContiune(int lDeviceId, GLX8_2_Data DataObj, unsigned int* encoder, unsigned int count);

/// <summary>
/// 获取数据宽度
/// </summary>
/// <param name="lDeviceId">设备ID号，范围为0 - 256</param>
/// <param name="DataObj">预留，设置为NULL</param>
/// <returns>返回宽度像素</returns>
extern "C" CPP_EXPORTS int CPP_STDCALL GLX8_2_ProfileDataWidth(int lDeviceId, GLX8_2_Data DataObj);


/// <summary>
/// 获取数据x方向间距
/// </summary>
/// <param name="lDeviceId">设备ID号，范围为0 - 256</param>
/// <param name="DataObj">预留，设置为NULL</param>
/// <returns>返回数据x方向间距(mm)</returns>
extern "C" CPP_EXPORTS double CPP_STDCALL GLX8_2_ProfileData_XPitch(int lDeviceId, GLX8_2_Data DataObj);
extern "C" CPP_EXPORTS double CPP_STDCALL GLX8_2_ProfileData_YPitch(int lDeviceId, GLX8_2_Data DataObj);
/// <summary>
/// 阻塞获取编码器值
/// </summary>
/// <param name="lDeviceId">设备ID号，范围为0 - 256</param>
/// <param name="DataObj">预留，设置为NULL</param>
/// <param name="Encoder">返回数据指针</param>
/// <returns>GLX8_2_Rc</returns>
extern "C" CPP_EXPORTS int CPP_STDCALL GLX8_2_GetEncoder(int lDeviceId, GLX8_2_Data DataObj, uint32_t * Encoder);

/// <summary>
/// 阻塞获取当前批处理次数
/// </summary>
/// <param name="lDeviceId"></param>
/// <param name="DataObj"></param>
/// <returns></returns>
extern "C" CPP_EXPORTS uint32_t CPP_STDCALL GLX8_2_GetBatchTimes(int lDeviceId, GLX8_2_Data DataObj);
/// <summary>
/// 阻塞获取轮廓数据
/// </summary>
/// <param name="lDeviceId">设备ID号，范围为0 - 256</param>
/// <param name="DataObj">预留，设置为NULL</param>
/// <param name="Profile">返回数据指针</param>
/// <returns>GLX8_2_Rc</returns>
extern "C" CPP_EXPORTS int CPP_STDCALL GLX8_2_GetProfileData(int lDeviceId, GLX8_2_Data DataObj, int32_t * Profile);

/// <summary>
/// 阻塞获取亮度数据
/// </summary>
/// <param name="lDeviceId">设备ID号，范围为0 - 256</param>
/// <param name="DataObj">预留，设置为NULL</param>
/// <param name="Intensity">返回数据指针</param>
/// <returns>GLX8_2_Rc</returns>
extern "C" CPP_EXPORTS int CPP_STDCALL GLX8_2_GetIntensityData(int lDeviceId, GLX8_2_Data DataObj, uint8_t * Intensity);

/// <summary>
/// 阻塞获取每行的时间
/// </summary>
/// <param name="lDeviceId"></param>
/// <param name="DataObj"></param>
/// <param name="Intensity"></param>
/// <returns></returns>
extern "C" CPP_EXPORTS int CPP_STDCALL GLX8_2_GetTimestamps(int lDeviceId, GLX8_2_Data DataObj, uint64_t * timestamp);


/// <summary>
/// 开启无终止循环获取数据
/// </summary>
/// <param name="lDeviceId"></param>
/// <returns></returns>
extern "C" CPP_EXPORTS int CPP_STDCALL GLX8_2_StartBatchRollData(int lDeviceId);
extern "C" CPP_EXPORTS int CPP_STDCALL GLX8_2_StartIOBatchRollData(int lDeviceId);


/// <summary>
/// 无终止循环获取数据
/// </summary>
/// <param name="lDeviceId">设备ID号，范围为0 - 256</param>
/// <param name="DataObj">预留,设置为NULL</param>
/// <param name="Profile">返回轮廓数据指针</param>
/// <param name="Intensity">返回亮度数据指针</param>
/// <param name="Encoder">返回编码器数据指针</param>
/// <param name="FrameId">返回帧编号数据指针</param>
/// <param name="FrameLoss">返回批处理过快掉帧数量数据指针</param>
/// <param name="GetCnt">获取数据长度</param>
/// <returns></returns>
extern "C" CPP_EXPORTS int CPP_STDCALL GLX8_2_GetBatchRollData(int lDeviceId, const GLX8_2_Data DataObj,
										int* Profile, unsigned char* Intensity, unsigned int* Encoder, long long* FrameId, unsigned int* FrameLoss,
										unsigned int GetCnt);


/// <summary>
/// 无终止循环设定行数
/// </summary>
/// <param name="lDeviceId">设备ID号</param>
/// <param name="DataObj">预留,设置为NULL</param>
/// <param name="points">0:无终止循环  >=15000:设定行数  其他无效</param>
/// <returns></returns>
extern "C" CPP_EXPORTS int CPP_STDCALL GLX8_2_SetBatchRollProfilePoint(int lDeviceId, const GLX8_2_Data DataObj, unsigned int points);



/// <summary>
/// 设置x轴间距
/// </summary>
/// <param name="lDeviceId"></param>
/// <param name="dwXpitch">单位0.01um</param>
/// <returns></returns>
extern "C" CPP_EXPORTS int CPP_STDCALL GLX8_2_SetXpitch(int lDeviceId, uint32_t dwXpitch);

/// <summary>
/// 获取x轴间距
/// </summary>
/// <param name="lDeviceId"></param>
/// <param name="pdwXpitch">单位0.01um</param>
/// <returns></returns>
extern "C" CPP_EXPORTS int CPP_STDCALL GLX8_2_GetXpitch(int lDeviceId, uint32_t * pdwXpitch);

/// <summary>
/// 初始化以太网高速数据通信
/// </summary>
/// <param name="lDeviceId">设备ID号，范围为0 - 256</param>
/// <param name="pEthernetConfig">通信设定</param>
/// <param name="wHighSpeedPortNo">通信端口设定</param>
/// <param name="pCallBack">高速通信中数据接收的回调函数</param>
/// <param name="dwProfileCnt">默认 0</param>
/// <param name="user">回调时带回的参数</param>
/// <returns>GLX8_2_Rc</returns>
extern "C" CPP_EXPORTS int CPP_STDCALL GLX8_2_HighSpeedDataEthernetCommunicationInitalize(int lDeviceId, GLX8_2_ETHERNET_CONFIG * pEthernetConfig, int wHighSpeedPortNo, GLX8_2_HighSpeedDataCallBack pCallBack, uint32_t dwProfileCnt, uint32_t user);

/// <summary>
/// 获取版本号
/// </summary>
/// <returns>版本号</returns>
extern "C" CPP_EXPORTS char* CPP_STDCALL GLX8_2_GetVersion();
/// <summary>
/// 获取相机型号
/// </summary>
/// <param name="lDeviceId">设备ID号，范围为0 - 256</param>
/// <returns>相机型号</returns>
extern "C" CPP_EXPORTS char* CPP_STDCALL GLX8_2_GetModels(int lDeviceId);

/// <summary>
/// 获取相机头序列号
/// </summary>
/// <param name="lDeviceId">设备ID号，范围为0 - 256</param>
/// <param name="Head">默认0</param>
/// <returns>相机头序列号</returns>
extern "C" CPP_EXPORTS char* CPP_STDCALL GLX8_2_GetHeaderSerial(int lDeviceId, int Head);
//extern "C" CPP_EXPORTS int GLX8_2_SwitchProgram(int lDeviceId, int No);

/// <summary>
/// 设置配置（查看文档）
/// </summary>
/// <param name="lDeviceId">设备ID号，范围为0 - 256</param>
/// <param name="Depth">设置的值的级别</param>
/// <param name="Type">设置类型</param>
/// <param name="Category">设置种类</param>
/// <param name="Item">设置项目</param>
/// <param name="Target"></param>
/// <param name="pData">设置数据</param>
/// <param name="DataSize">设置数据长度</param>
/// <returns>GLX8_2_Rc</returns>
extern "C" CPP_EXPORTS int CPP_STDCALL GLX8_2_SetSetting(uint32_t lDeviceId, int Depth, int Type, int Category, int Item, int* Target, char* pData, int DataSize);
extern "C" CPP_EXPORTS int CPP_STDCALL GLX8_2_GetSetting(uint32_t lDeviceId, int Type, int Category, int Item, int* Target, char* pData, int DataSize);

/// <summary>
/// x轴开始像素到结束像素
/// </summary>
/// <param name="lDeviceId"></param>
/// <param name="start"></param>
/// <param name="end">0，表示到结束</param>
/// <returns>GLX8_2_Rc</returns>
extern "C" CPP_EXPORTS int CPP_STDCALL GLX8_2_SET_X_ROI(int lDeviceId, int start, int end);

/// <summary>
/// x轴开始像素到结束像素
/// </summary>
/// <param name="lDeviceId"></param>
/// <param name="start"></param>
/// <param name="end">0，表示到结束</param>
/// <returns>GLX8_2_Rc</returns>
extern "C" CPP_EXPORTS int CPP_STDCALL GLX8_2_GET_X_ROI(int lDeviceId, int* start, int* end);

/// <summary>
/// 设置回调函数,建议获取数据后另外开启线程进行处理（获取数据模式:批处理一次回调一次）
/// </summary>
/// <param name="lDeviceId">设备ID号，范围为0 - 256</param>
/// <param name="CallFunc">回调函数</param>
/// <returns>GLX8_2_Rc</returns>
extern "C" CPP_EXPORTS int CPP_STDCALL GLX8_2_SetBatchOneTimeDataHandler(int lDeviceId, GLX8_2_BatchOneTimeCallBack CallFunc);

extern "C" CPP_EXPORTS int CPP_STDCALL GLX8_2_SetBatchOneTimeDataHandler_V2(int lDeviceId, std::function<void(const GLX8_2_STR_CALLBACK_INFO* info, const GLX8_2_Data DataObj)> fc);

/// <summary>
/// 开始批处理（获取数据模式:批处理一次回调一次）
/// </summary>
/// <param name="lDeviceId">设备ID号,范围为0-256.</param>
/// <param name="ImmediateBatch">0:立即开始批处理  非0:等待外部开始批处理.</param>
/// <returns>GLX8_2_Rc</returns>
extern "C" CPP_EXPORTS int CPP_STDCALL GLX8_2_StartMeasureWithCallback(int lDeviceId, int ImmediateBatch);

/// <summary>
/// 批处理软件触发开始（获取数据模式:批处理一次回调一次）
/// </summary>
/// <param name="lDeviceId">设备ID号,范围为0-256.</param>
/// <returns>GLX8_2_Rc</returns>
extern "C" CPP_EXPORTS int CPP_STDCALL GLX8_2_TriggerOneBatch(int lDeviceId);

extern "C" CPP_EXPORTS uint16_t* CPP_STDCALL GLX8_2_GetBatchProfilePoint16(GLX8_2_Data DataIndex, int Head, double* res);

/// <summary>
/// 批处理轮廓获取（获取数据模式:批处理一次回调一次）
/// </summary>
/// <param name="DataIndex">参数数据传递</param>
/// <param name="Head">默认0</param>
/// <returns></returns>
extern "C" CPP_EXPORTS int32_t * CPP_STDCALL GLX8_2_GetBatchProfilePoint(GLX8_2_Data DataIndex, int Head);

/// <summary>
/// 批处理亮度获取（获取数据模式:批处理一次回调一次）
/// </summary>
/// <param name="DataIndex">参数数据传递</param>
/// <param name="Head">默认0</param>
/// <returns></returns>
extern "C" CPP_EXPORTS uint8_t * CPP_STDCALL GLX8_2_GetBatchIntensityPoint(GLX8_2_Data DataIndex, int Head);

/// <summary>
/// 批处理编码器获取（获取数据模式:批处理一次回调一次）
/// </summary>
/// <param name="DataIndex">参数数据传递</param>
/// <param name="Head">默认0</param>
/// <returns></returns>
extern "C" CPP_EXPORTS uint32_t * CPP_STDCALL GLX8_2_GetBatchEncoderPoint(GLX8_2_Data DataIndex, int Head);

/// <summary>
/// 批处理时间戳 单位us（获取数据模式:批处理一次回调一次）
/// </summary>
/// <param name="lDeviceId"></param>
/// <param name="infos"></param>
/// <returns></returns>
extern "C" CPP_EXPORTS uint64_t* CPP_STDCALL GLX8_2_GetBatchTimestamps(GLX8_2_Data DataIndex, int Head);

/// <summary>
/// 获取传感器的型号以及测量相关的数据
/// </summary>
/// <param name="lDeviceId"></param>
/// <param name="infos"></param>
/// <returns>GLX8_2_Rc</returns>
extern "C" CPP_EXPORTS int CPP_STDCALL GLX8_2_GetModelInfos(int lDeviceId, GLX8_2_ModelInfo* infos);


/// <summary>
/// 顺序获取批处理数据
/// </summary>
/// <param name="lDeviceId"></param>
/// <param name="batchdata">批处理数据</param>
/// <param name="grays">亮度数据</param>
/// <param name="encoderpoint">编码器数据</param>
/// <returns></returns>
extern "C" CPP_EXPORTS int CPP_STDCALL GLX8_2_ReceiveDataAuto(int lDeviceId, GLX8_2_STR_CALLBACK_INFO * info, int32_t * batchdata, uint8_t * grays, uint32_t * encoderpoint);

// 触发
extern "C" CPP_EXPORTS int CPP_STDCALL GLX8_Trigger(int lDeviceId);

// 获取扩展函数配置



/// <summary>
/// 获取扩展函数配置
/// </summary>
/// <param name="lDeviceId"></param>
/// <param name="en"></param>
/// <returns></returns>
extern "C" CPP_EXPORTS GLX8_2_EXTEND* CPP_STDCALL GLX8_2_GET_EXTEND_CNF(int lDeviceId);

//




/// <summary>
/// 设置扩展函数是否开启
/// </summary>
/// <param name="lDeviceId"></param>
/// <param name="binning"></param>
/// <returns></returns>
extern "C" CPP_EXPORTS int CPP_STDCALL GLX8_2_SET_EXTEND_EN(int lDeviceId, int en);


/// <summary>
/// x binning
/// </summary>
/// <param name="lDeviceId"></param>
/// <param name="binning">0，4096，1=2048，2=1024，3=512，4=256</param>
/// <returns>GLX8_2_Rc</returns>
extern "C" CPP_EXPORTS int CPP_STDCALL GLX8_2_SET_EXTEND_X_Binning(int lDeviceId, int binning);



extern "C" CPP_EXPORTS int CPP_STDCALL GLX8_2_SET_EXTEND_Y_ROI(int lDeviceId, int start, int end);


//z轴高度偏移,像素补偿,单位0.01
extern "C" CPP_EXPORTS int CPP_STDCALL GLX8_2_SET_EXTEND_Z_OFFSET(int lDeviceId, int32_t* offset, int len);
// z轴高度偏移,像素补偿,单位毫米
extern "C" CPP_EXPORTS int CPP_STDCALL GLX8_2_SET_EXTEND_Z_OFFSET_Double(int lDeviceId, double * offset, int len);

extern "C" CPP_EXPORTS int CPP_STDCALL GLX8_2_SET_EXTEND_LIGHT_CORRECTION(int lDeviceId, float value);

extern "C" CPP_EXPORTS GLX8_2_OUTLINE16BIT CPP_STDCALL GLX8_2_EXTEND_Outline16bit(int lDeviceId, int32_t* outline,int len, uint16_t* out_16bit);

extern "C" CPP_EXPORTS int CPP_STDCALL GLX8_2_GET_EXTEND_FEATURE_EN(int lDeviceId, uint64_t feature, bool* enabled);

/// <summary>
/// 设置指定的扩展特性是否开启
/// </summary>
/// <param name="lDeviceId"></param>
/// <param name="feature">见GLX8_2_EXTEND_FEATURE定义</param>
/// <param name="enabled">true表示启用该扩展特性， false表示不启用</param>
extern "C" CPP_EXPORTS int CPP_STDCALL GLX8_2_SET_EXTEND_FEATURE_EN(int lDeviceId, uint64_t feature, bool enabled);

/// <summary>
/// 设置高度过滤
/// </summary>
/// <param name="lDeviceId"></param>
/// <param name="thres1">高度差低阈值(单位: 0.01um)，默认值20000</param>
/// <param name="thres2">高度差高阈值(单位: 0.01um)，默认值100000</param>
/// <param name="r">滤波窗口尺寸, 默认值15，一定是奇数，参考数值[3 /5 /7,,,]</param>
/// <param name="is_open">是否进行开运算</param>
/// <param name="r_open">开运算窗口尺寸, 默认值9，一定是奇数，参考数值[3 /5 /7,,,]</param>
extern "C" CPP_EXPORTS int CPP_STDCALL GLX8_2_SET_EXTEND_FILTER_GRAD(int lDeviceId, int thres1, int thres2, int r, bool is_open, int r_open, bool is_connected, int area_thres, int object);

extern "C" CPP_EXPORTS int CPP_STDCALL GLX8_2_GET_EXTEND_563TIF_X_OFFSET(int lDeviceId, int32_t* offset);
extern "C" CPP_EXPORTS int CPP_STDCALL GLX8_2_SET_EXTEND_563TIF_X_OFFSET(int lDeviceId, int32_t offset);
extern "C" CPP_EXPORTS int CPP_STDCALL GLX8_2_GET_EXTEND_563TIF_Z_OFFSET(int lDeviceId, double* offset);
extern "C" CPP_EXPORTS int CPP_STDCALL GLX8_2_SET_EXTEND_563TIF_Z_OFFSET(int lDeviceId, double offset);
extern "C" CPP_EXPORTS int CPP_STDCALL GLX8_2_GET_EXTEND_563TIF_LIGHT_OFFSET_UPPER(int lDeviceId, int32_t* offset);
extern "C" CPP_EXPORTS int CPP_STDCALL GLX8_2_SET_EXTEND_563TIF_LIGHT_OFFSET_UPPER(int lDeviceId, int32_t offset);
extern "C" CPP_EXPORTS int CPP_STDCALL GLX8_2_GET_EXTEND_PROFILE_OUTPUT_WIDTH(int lDeviceId, int32_t* width);
extern "C" CPP_EXPORTS int CPP_STDCALL GLX8_2_SET_EXTEND_PROFILE_OUTPUT_WIDTH(int lDeviceId, int32_t width);
extern "C" CPP_EXPORTS int CPP_STDCALL GLX8_2_GET_EXTEND_THR_W_H(int lDeviceId, int32_t* thr_w_l, int32_t* thr_w_h, int32_t* thr_wh_ratio);
extern "C" CPP_EXPORTS int CPP_STDCALL GLX8_2_SET_EXTEND_THR_W_H(int lDeviceId, int32_t thr_w_l, int32_t thr_w_h, int32_t thr_wh_ratio);
extern "C" CPP_EXPORTS int CPP_STDCALL GLX8_2_GET_EXTEND_RUN_MODE(int lDeviceId, int32_t* run_mode);
extern "C" CPP_EXPORTS int CPP_STDCALL GLX8_2_SET_EXTEND_RUN_MODE(int lDeviceId, int32_t run_mode);
extern "C" CPP_EXPORTS int CPP_STDCALL GLX8_2_SET_EXTEND_DUAL_MERGE(int lDeviceId, bool cloud_align, int b_x_offset, double b_z_offset, int single_valid_output, double height_delta_thres, int dual_valid_output_in_delta, int dual_valid_output_beyond_delta);
#endif // __PHOSKEY_SS_H__