using System;
using System.Collections.Generic;
using System.Linq;
using System.Runtime.InteropServices;
using System.Text;
using System.Threading.Tasks;

namespace LB_SmartVisionCameraSDK.PHM6000
{
    /// <summary>
    /// 设置图像大小，用于逐行添加显示数据
    /// </summary>
    /// <param name="pHandle">二维显示控件的句柄</param>
    /// <param name="nWidth">宽度</param>
    /// <param name="nHeight">高度</param>
    [UnmanagedFunctionPointer(CallingConvention.StdCall)]
    public delegate void SetImageSize_t(IntPtr pHandle, int nWidth, int nHeight);
    /// <summary>
    /// 清除数据，在显示新的图象前调用
    /// </summary>
    /// <param name="pHandle">二维显示控件的句柄</param>
    [UnmanagedFunctionPointer(CallingConvention.StdCall)]
    public delegate void ClearAllPoints_t(IntPtr pHandle);
    /// <summary>
    /// 刷新显示窗口，此控件在传入数据时并不更新显示，直到调用此函数。
    /// </summary>
    /// <param name="pHandle">二维显示控件的句柄</param>
    [UnmanagedFunctionPointer(CallingConvention.StdCall)]
    public delegate void RefreshPilot2D_t(IntPtr pHandle);
    /// <summary>
    /// 添加强度数据
    /// </summary>
    /// <param name="pHandle">二维显示控件的句柄</param>
    /// <param name="points">兰宝线扫描传感器输出的数据指针, LBPointZA* points</param>
    /// <param name="nCount">指定上述数据的指针里的点的数量</param>
    /// <returns>函数调用成功返回1，失败返回-1</returns>
    [UnmanagedFunctionPointer(CallingConvention.StdCall)]
    public delegate int AddIntensityData_t(IntPtr pHandle, IntPtr points, int nCount);
    /// <summary>
    /// 添加深度数据，此函数具有颜色渲染功能
    /// </summary>
    /// <param name="pHandle">二维显示控件的句柄</param>
    /// <param name="points">兰宝线扫描传感器输出的数据指针, LBPointZA* points</param>
    /// <param name="nCount">指定上述数据的指针里的点的数量</param>
    /// <param name="nMinDepth">指定深度中的最小值，用于颜色渲染</param>
    /// <param name="nMaxDepth">指定深度中的最大值，用于颜色渲染</param>
    /// <returns>函数调用成功返回1，失败返回-1</returns>
    [UnmanagedFunctionPointer(CallingConvention.StdCall)]
    public delegate int AddDepthData_t(IntPtr pHandle, IntPtr points, int nCount, short nMinDepth, short nMaxDepth);
    /// <summary>
    /// 添加质心数据
    /// </summary>
    /// <param name="pHandle">二维显示控件的句柄</param>
    /// <param name="points">兰宝线扫描传感器输出的数据指针LBPointZA*</param>
    /// <param name="nCount">指定上述数据的指针里的点的数量</param>
    /// <param name="fMinDistance">兰宝线扫描传感器检测的最小距离（从说明书获得，取值225.0）</param>
    /// <param name="fMaxDistance">兰宝线扫描传感器检测的最大距离（从说明书获得，取值473.0）</param>
    /// <param name="fStdDistance">兰宝线扫描传感器检测的标准距离（从说明书获得，取值325.0）</param>
    /// <returns>函数调用成功返回1，失败返回-1</returns>
    /// <returns></returns>
    [UnmanagedFunctionPointer(CallingConvention.StdCall)]
    public delegate int AddBarycentreDataZA_t(IntPtr pHandle, IntPtr points, int nCount, float fMinDistance, float fMaxDistance, float fStdDistance);

    /// <summary>
    /// 清除点云实例增加数据点内部数据点
    /// </summary>
    /// <param name="pInstance">PCL显示实例句柄</param>
    /// <returns>失败返回0，成功返回1。</returns>
    [UnmanagedFunctionPointer(CallingConvention.StdCall)]
    public delegate int ClearPCLPoints_t(IntPtr pInstance);
    /// <summary>
    /// 向点云实例增加数据点，失败返回-1，否则返回当前点云中点的个数（不小于0）。
    /// </summary>
    /// <param name="pInstance">PCL显示实例句柄</param>
    /// <param name="points">包含深度(Z)和强度(A)信息的点数据</param>
    /// <param name="nCount">点的数量</param>
    /// <param name="fStepX">x分辨率</param>
    /// <param name="fStepY">y分辨率</param>
    /// <param name="nDownSample">降采样倍数</param>
    /// <returns>失败返回-1，否则返回当前点云中点的个数（不小于0）。</returns>
    [UnmanagedFunctionPointer(CallingConvention.StdCall)]
    public delegate int AddZAPoints_t(IntPtr pInstance, IntPtr points, int nCount, float fStepX, float fStepY, int nDownSample);
    /// <summary>
    /// 渲染点云窗口，无返回
    /// </summary>
    /// <param name="pInstance">PCL显示实例句柄</param>
    /// <param name="nWidth">窗口宽度</param>
    /// <param name="nHeight">窗口高度</param>
    [UnmanagedFunctionPointer(CallingConvention.StdCall)]
    public delegate void RenderPCLWindow_t(IntPtr pInstance, int nWidth, int nHeight);
    /// <summary>
    /// 更新PCL点云数据显示的颜色
    /// </summary>
    /// <param name="pInstance">PCL显示实例句柄</param>
    /// <param name="szColoring">W,B,r,g,b,x,y,z 对应于白黑红绿蓝和xyz三轴</param>
    /// <returns>失败返回0，成功返回1。</returns>
    [UnmanagedFunctionPointer(CallingConvention.StdCall, CharSet = CharSet.Ansi)]
    public delegate int UpdatePCLPointColors_t(IntPtr pInstance, string szColoring);
    /// <summary>
    /// 显示正方体坐标系，无返回
    /// </summary>
    /// <param name="pInstance">PCL显示实例句柄</param>
    /// <param name="bInit">是否初始化</param>
    [UnmanagedFunctionPointer(CallingConvention.StdCall)]
    public delegate void ShowCubeAxes_t(IntPtr pInstance, int bInit);
    /// <summary>
    /// 显示颜色表
    /// </summary>
    /// <param name="pInstance">PCL显示实例句柄</param>
    /// <param name="x">显示位置，数值是与窗口宽度的比值</param>
    /// <param name="y">显示位置，数值是与窗口高度的比值</param>
    /// <param name="xWide">水平宽度，数值是与窗口宽度的比值</param>
    /// <param name="yWide">垂直宽度，数值是与窗口高度的比值</param>
    [UnmanagedFunctionPointer(CallingConvention.StdCall)]
    public delegate void ShowLookUpTable_t(IntPtr pInstance, double x, double y, double xWide, double yWide);
    /// <summary>
    /// 获取PCL点云数据的范围
    /// </summary>
    /// <param name="pInstance">PCL显示实例句柄</param>
    /// <param name="pMin">返回最小值</param>
    /// <param name="pMax">返回最大值</param>
    /// <returns>失败返回0，成功返回1。</returns>
    [UnmanagedFunctionPointer(CallingConvention.StdCall)]
    public delegate int GetPointCloudBound_t(IntPtr pInstance, ref double pMin, ref double pMax);
    /// <summary>
    /// 设置颜色表范围，无返回值
    /// </summary>
    /// <param name="pInstance">PCL显示实例句柄</param>
    /// <param name="fMin">最小值</param>
    /// <param name="fMax">最大值</param>
    [UnmanagedFunctionPointer(CallingConvention.StdCall)]
    public delegate void SetLookUpTableRange_t(IntPtr pInstance, double fMin, double fMax);

    /// <summary>
    /// 定义下面的结构是为了向相机接口动态库传递Pilot2D.dll中的同名函数指针
    /// </summary>
    [StructLayout(LayoutKind.Sequential)]
    public struct PILOT2D_FUNC
    {
        /// <summary>
        /// 设置图像大小，用于逐行添加显示数据
        /// </summary>
        [MarshalAs(UnmanagedType.FunctionPtr)]
        public SetImageSize_t SetImageSize;
        /// <summary>
        /// 清除数据，在显示新的图象前调用
        /// </summary>
        [MarshalAs(UnmanagedType.FunctionPtr)]
        public ClearAllPoints_t ClearAllPoints;
        /// <summary>
        /// 刷新显示窗口，此控件在传入数据时并不更新显示，直到调用此函数。
        /// </summary>
        [MarshalAs(UnmanagedType.FunctionPtr)]
        public RefreshPilot2D_t RefreshPilot2D;
        /// <summary>
        /// 添加强度数据
        /// </summary>
        [MarshalAs(UnmanagedType.FunctionPtr)]
        public AddIntensityData_t AddIntensityData;
        /// <summary>
        /// 添加深度数据，此函数具有颜色渲染功能
        /// </summary>
        [MarshalAs(UnmanagedType.FunctionPtr)]
        public AddDepthData_t AddDepthData;
        /// <summary>
        /// 添加质心数据
        /// </summary>
        [MarshalAs(UnmanagedType.FunctionPtr)]
        public AddBarycentreDataZA_t AddBarycentreDataZA;
    }
    /// <summary>
    /// 对应于PointCloud3D.dll中的同名函数的形式，具体函数功能参见PointCloud3D.dll的调用说明
    /// </summary>
    [StructLayout(LayoutKind.Sequential)]
    public struct VTK3D_FUNC
    {
        /// <summary>
        /// 清除点云实例增加数据点内部数据点
        /// </summary>
        [MarshalAs(UnmanagedType.FunctionPtr)]
        public ClearPCLPoints_t ClearPCLPoints;
        /// <summary>
        /// 向点云实例增加数据点，失败返回-1，否则返回当前点云中点的个数（不小于0）。
        /// </summary>
        [MarshalAs(UnmanagedType.FunctionPtr)]
        public AddZAPoints_t AddZAPoints;
        /// <summary>
        /// 渲染点云窗口，无返回
        /// </summary>
        [MarshalAs(UnmanagedType.FunctionPtr)]
        public RenderPCLWindow_t RenderPCLWindow;
        /// <summary>
        /// 更新PCL点云数据显示的颜色
        /// </summary>
        [MarshalAs(UnmanagedType.FunctionPtr)]
        public UpdatePCLPointColors_t UpdatePCLPointColors;
        /// <summary>
        /// 显示正方体坐标系，无返回
        /// </summary>
        [MarshalAs(UnmanagedType.FunctionPtr)]
        public ShowCubeAxes_t ShowCubeAxes;
        /// <summary>
        /// 显示颜色表
        /// </summary>
        [MarshalAs(UnmanagedType.FunctionPtr)]
        public ShowLookUpTable_t ShowLookUpTable;
        /// <summary>
        /// 获取PCL点云数据的范围
        /// </summary>
        [MarshalAs(UnmanagedType.FunctionPtr)]
        public GetPointCloudBound_t GetPointCloudBound;
        /// <summary>
        /// 设置颜色表范围，无返回值
        /// </summary>
        [MarshalAs(UnmanagedType.FunctionPtr)]
        public SetLookUpTableRange_t SetLookUpTableRange;
    }

    //typedef void (__stdcall* ShowDebugInfoCallback) (char* szMessage, int nLength);
    /// <summary>
    /// 显示调试信息的回调函数格式，无返回值
    /// </summary>
    /// <param name="szMessage">消息字符串</param>
    /// <param name="nLength">字符串长度</param>
    [UnmanagedFunctionPointer(CallingConvention.StdCall)]
    public delegate void ShowDebugInfoCallback(string szMessage, int nLength);

    //typedef void (__stdcall* StartMotorCallback) (int direction, int move_steps, double move_speed);
    /// <summary>
    /// 启动电机,此回调函数由编写电机驱动者按此格式提供调用。
    /// </summary>
    /// <param name="direction">运动方向</param>
    /// <param name="move_steps">移动步数</param>
    /// <param name="move_speed">移动速度</param>
    [UnmanagedFunctionPointer(CallingConvention.StdCall)]
    public delegate void StartMotorCallback(int direction, int move_steps, double move_speed);

    //typedef void (__stdcall* StopMotorCallback) ();
    /// <summary>
    /// 停止电机,此回调函数由编写电机驱动者按此格式提供调用。
    /// </summary>
    [UnmanagedFunctionPointer(CallingConvention.StdCall)]
    public delegate void StopMotorCallback();

    //typedef void (__stdcall* AcquisitionCallbackZA) (void* pInstance, void* buffer, int points);
    /// <summary>
    /// 采集数据的回调函数
    /// </summary>
    /// <param name="pInstance">回调函数提供者的句柄</param>
    /// <param name="buffer">LBPointZA格式的数据缓冲区指针</param>
    /// <param name="points">数据中包含点的数量</param>
    [UnmanagedFunctionPointer(CallingConvention.StdCall)]
    public delegate void AcquisitionCallbackZA(IntPtr pInstance, IntPtr buffer, int points);

    //typedef void (__stdcall* AcquisitionCompletedCallback) (void* pInstance, int nOption);
    /// <summary>
    /// 采集结束的回调函数，可供用户在采集结束后做些处理
    /// </summary>
    /// <param name="pInstance">回调函数提供者的句柄</param>
    /// <param name="nOption">为0时表示一批数据结束，为1时表时全部采集完成</param>
    [UnmanagedFunctionPointer(CallingConvention.StdCall)]
    public delegate void AcquisitionCompletedCallback(IntPtr pInstance, int nOption);

    /// <summary>
    /// 相机连接成功回调函数，
    /// </summary>
    /// <param name="strSN">相机序列号</param>
    [UnmanagedFunctionPointer(CallingConvention.StdCall)]
    public delegate void AcquisitionConnectCompletedCallback(string strSN);

    /// <summary>
    /// 相机接口类
    /// </summary>
    public class PHM6000Profiler
    {
        //PHM6000_API(void*) CreateCameraEntry();
        /// <summary>
        /// 创建照相机接口，
        /// </summary>
        /// <returns>返回相机句柄</returns>
        [DllImport("PHM6000API", CallingConvention = CallingConvention.StdCall, EntryPoint = "CreateCameraEntry")]
        public static extern IntPtr CreateCameraEntry();

        //PHM6000_API(void) DestroyCameraEntry(void* pHandle);
        /// <summary>
        /// 销毁照相机接口
        /// </summary>
        /// <param name="pHandle">相机接口句柄</param>
        [DllImport("PHM6000API", CallingConvention = CallingConvention.StdCall, EntryPoint = "DestroyCameraEntry")]
        public static extern void DestroyCameraEntry(IntPtr pHandle);

        //PHM6000_API(int) DiscoverCameras(void* pHandle);
        /// <summary>
        /// 查找照相机
        /// </summary>
        /// <param name="pHandle">相机接口句柄</param>
        /// <returns>查找失败返回-1，否则返回相机个数。</returns>
        [DllImport("PHM6000API", CallingConvention = CallingConvention.StdCall, EntryPoint = "DiscoverCameras")]
        public static extern int DiscoverCameras(IntPtr pHandle);

        //PHM6000_API(int) GetCameraInfo(void* pHandle, int nIndex, LBCameraInfo* pCameraInfo);
        /// <summary>
        /// 获取照相机信息
        /// </summary>
        /// <param name="pHandle">相机接口句柄</param>
        /// <param name="nIndex">相机序号</param>
        /// <param name="pCameraInfo">相机信息结构指针, LBCameraInfo* pCameraInfo</param>
        /// <returns>获取失败返回-1，否则返回0。</returns>
        [DllImport("PHM6000API", CallingConvention = CallingConvention.StdCall, EntryPoint = "GetCameraInfo")]
        public static extern int GetCameraInfo(IntPtr pHandle, int nIndex, IntPtr pCameraInfo);

        //PHM6000_API(int) GetCameraInformation(void* pHandle, int nIndex, char* szModuleType, char* szSerialNumber);
        /// <summary>
        /// 获取照相机信息（方便C#调用增加的）
        /// </summary>
        /// <param name="pHandle">相机接口句柄</param>
        /// <param name="nIndex">相机序号</param>
        /// <param name="szModuleType">模块名, char* szModuleType</param>
        /// <param name="szSerialNumber">序列号, char* szSerialNumber</param>
        /// <returns>获取失败返回-1，否则返回0。</returns>
        //[DllImport("PHM6000API", CallingConvention = CallingConvention.StdCall, EntryPoint = "GetCameraInformation")]
        //public static extern int GetCameraInformation(IntPtr pHandle, int nIndex, IntPtr szModuleType, IntPtr szSerialNumber);
        //PHM6000_API(int) GetCameraInformation(void* pHandle, int nIndex, char* szModuleType, char* szSerialNumber);
        /// <summary>
        /// 获取照相机信息
        /// </summary>
        /// <param name="pHandle">开的接口</param>
        /// <param name="nlndex">第几个</param>
        /// <param name="szModuleType">型号</param>
        /// <param name="szSerialNumber">序列号</param>
        /// <returns></returns>
        [DllImport("PHM6000API", CallingConvention = CallingConvention.StdCall, EntryPoint = "GetCameraInformation")]
        public static extern int GetCameraInformation(IntPtr pHandle, int nlndex, byte[] szModuleType, byte[] szSerialNumber);


        //PHM6000_API(int) GetCameraAddress(void* pHandle, int nIndex, char* szAddress, int* nPort);
        /// <summary>
        /// 获取照相机IP信息
        /// </summary>
        /// <param name="pHandle">相机接口句柄</param>
        /// <param name="nIndex">相机序号</param>
        /// <param name="szAddress">IP地址字符串, char* szAddress</param>
        /// <param name="nPort">端口号, int* nPort</param>
        /// <returns>获取失败返回-1，否则返回0。</returns>
        //[DllImport("PHM6000API", CallingConvention = CallingConvention.StdCall, EntryPoint = "GetCameraAddress")]
        //public static extern int GetCameraAddress(IntPtr pHandle, int nIndex, IntPtr szAddress, IntPtr nPort);
        //PHM6000_API(int) GetCameraAddress(void* pHandle, int nIndex, char* szAddress, int* nPort);
        /// <summary>
        /// 得到连接的IP
        /// </summary>
        /// <param name="pHandle">开的接口</param>
        /// <param name="nlndex">第几个</param>
        /// <param name="szAddress">返回的地址</param>
        /// <param name="nPort">返回的端口</param>
        /// <returns>连接失败返回-1，否则返回0</returns>
        [DllImport("PHM6000API", CallingConvention = CallingConvention.StdCall, EntryPoint = "GetCameraAddress")]
        public static extern int GetCameraAddress(IntPtr pHandle, int nlndex, byte[] szAddress, ref int nPort);

        //PHM6000_API(int) ConnectToCamera(void* pHandle, char* szIpAddress, int nPort);
        /// <summary>
        /// 连接照相机
        /// </summary>
        /// <param name="pHandle">相机接口句柄</param>
        /// <param name="szAddress">IP地址字符串</param>
        /// <param name="nPort">端口号</param>
        /// <returns>连接失败返回-1，否则返回0。</returns>
        [DllImport("PHM6000API", CallingConvention = CallingConvention.StdCall, EntryPoint = "GetCameraAddress")]
        public static extern int GetCameraAddress(IntPtr pHandle, string szAddress, int nPort);

        //PHM6000_API(int) ConnectToCamera(void* pHandle, char* szIpAddress, int nPort);
        /// <summary>
        /// 连接照相机
        /// </summary>
        /// <param name="pHandle">相机接口句柄</param>
        /// <param name="szAddress">IP地址字符串</param>
        /// <param name="nPort">端口号</param>
        /// <returns>连接失败返回-1，否则返回0。</returns>
        [DllImport("PHM6000API", CallingConvention = CallingConvention.StdCall, EntryPoint = "ConnectToCamera")]
        public static extern int ConnectToCamera(IntPtr pHandle, IntPtr szAddress, int nPort);

        //PHM6000_API(int) ConnectToCamera(void* pHandle, char* szIpAddress, int nPort);
        /// <summary>
        /// 连接照相机
        /// </summary>
        /// <param name="pHandle">相机接口句柄</param>
        /// <param name="szAddress">IP地址字符串</param>
        /// <param name="nPort">端口号</param>
        /// <returns>连接失败返回-1，否则返回0。</returns>
        [DllImport("PHM6000API", CallingConvention = CallingConvention.StdCall, EntryPoint = "ConnectToCamera")]
        public static extern int ConnectToCamera(IntPtr pHandle, byte[] szAddress, int nPort);

        //PHM6000_API(int) DisconnectFromCamera(void* pHandle, char* szIpAddress);
        /// <summary>
        /// 断开照相机
        /// </summary>
        /// <param name="pHandle">相机接口句柄</param>
        /// <param name="szIpAddress">指定要断开的相机的IP地址</param>
        /// <returns>断开失败返回-1，否则返回0。</returns>
        [DllImport("PHM6000API", CallingConvention = CallingConvention.StdCall, EntryPoint = "DisconnectFromCamera")]
        public static extern int DisconnectFromCamera(IntPtr pHandle, string szIpAddress);

        //PHM6000_API(int) SetAcquisitionCallbackZA(void* pHandle, AcquisitionCallbackZA callbackZA, void* pInstance);
        /// <summary>
        /// 设置紧凑的采集回调函数
        /// </summary>
        /// <param name="pHandle">相机接口句柄</param>
        /// <param name="callbackZA">回调函数, AcquisitionCallbackZA callbackZA</param>
        /// <param name="pInstance">回调函数提供者的句柄</param>
        /// <returns>设置失败返回-1，否则返回0。</returns>
        [DllImport("PHM6000API", CallingConvention = CallingConvention.StdCall, EntryPoint = "SetAcquisitionCallbackZA")]
        public static extern int SetAcquisitionCallbackZA(IntPtr pHandle, AcquisitionCallbackZA callbackZA, IntPtr pInstance);

        //PHM6000_API(int) SetAcquisitionCallbackZA(void* pHandle, AcquisitionCallbackZA callbackZA, void* pInstance);
        /// <summary>
        /// 设置紧凑的采集回调函数
        /// </summary>
        /// <param name="pHandle">相机接口句柄</param>
        /// <param name="callbackZA">回调函数, AcquisitionCallbackZA callbackZA</param>
        /// <param name="pInstance">回调函数提供者的句柄</param>
        /// <returns>设置失败返回-1，否则返回0。</returns>
        [DllImport("PHM6000API", CallingConvention = CallingConvention.StdCall, EntryPoint = "SetAcquisitionCallbackZA")]
        public static extern int SetAcquisitionCallbackZA(IntPtr pHandle, IntPtr callbackZA, IntPtr pInstance);

        //PHM6000_API(int) SetMotorCallbackFunction(void* pHandle, StartMotorCallback startFunction, StopMotorCallback stopFunction);
        /// <summary>
        /// 设置马达回调函数，没有这两个回调函数就不调用此函数来设置回调功能。
        /// </summary>
        /// <param name="pHandle">相机接口句柄</param>
        /// <param name="startFunction">马达启动回调函数</param>
        /// <param name="stopFunction">马达停止回调函数</param>
        /// <returns>设置失败返回-1，否则返回0。</returns>
        [DllImport("PHM6000API", CallingConvention = CallingConvention.StdCall, EntryPoint = "SetMotorCallbackFunction")]
        public static extern int SetMotorCallbackFunction(IntPtr pHandle, StartMotorCallback startFunction, StopMotorCallback stopFunction);

        //PHM6000_API(int) SetAcquisitionMode(void* pHandle, int bScanMode, int bContinuedMode);
        /// <summary>
        /// 设置采集模式
        /// </summary>
        /// <param name="pHandle">相机接口句柄</param>
        /// <param name="bScanMode">为1时是扫描模式，为0时是轮廓模式</param>
        /// <param name="bContinuedMode">为1时是连接模式，为0时是单次模式</param>
        /// <returns>设置失败返回-1，否则返回0。</returns>
        [DllImport("PHM6000API", CallingConvention = CallingConvention.StdCall, EntryPoint = "SetAcquisitionMode")]
        public static extern int SetAcquisitionMode(IntPtr pHandle, int bScanMode, int bContinuedMode);

        //PHM6000_API(int) StartAcquisition(void* pHandle, int motor_direction, int move_steps, double move_speed);
        /// <summary>
        /// 启动采集
        /// </summary>
        /// <param name="pHandle">相机接口句柄</param>
        /// <param name="motor_direction">马达的运动方向，如果没有马达回调函数，置零即可。</param>
        /// <param name="move_steps">马达移动步数，如果没有马达回调函数，置零即可。</param>
        /// <param name="move_speed">马达移动速度，如果没有马达回调函数，置零即可。</param>
        /// <returns>启动失败返回-1，否则返回0。</returns>
        [DllImport("PHM6000API", CallingConvention = CallingConvention.StdCall, EntryPoint = "StartAcquisition")]
        public static extern int StartAcquisition(IntPtr pHandle, int motor_direction, int move_steps, double move_speed);

        //PHM6000_API(int) StopAcquisition(void* pHandle);
        /// <summary>
        /// 停止采集
        /// </summary>
        /// <param name="pHandle">相机接口句柄</param>
        /// <returns>停止失败返回-1，否则返回0。</returns>
        [DllImport("PHM6000API", CallingConvention = CallingConvention.StdCall, EntryPoint = "StopAcquisition")]
        public static extern int StopAcquisition(IntPtr pHandle);

        //PHM6000_API(int) GetRawImage(void* pHandle, LBPointBGRA** image, int* w, int* h);
        /// <summary>
        /// 获取原始图像数据，暂不支持
        /// </summary>
        /// <param name="pHandle">相机接口句柄</param>
        /// <param name="image">图像数据指针, LBPointBGRA** image</param>
        /// <param name="w">图像宽度, int* w</param>
        /// <param name="h">图像高度, int* h</param>
        /// <returns>获取失败返回-1，否则返回0。</returns>
        [DllImport("PHM6000API", CallingConvention = CallingConvention.StdCall, EntryPoint = "GetRawImage")]
        public static extern int GetRawImage(IntPtr pHandle, out IntPtr image, out int w, out int h);

        //PHM6000_API(int) GetParameterGroupCount(void* pHandle);
        /// <summary>
        /// 获取参数组的个数
        /// </summary>
        /// <param name="pHandle">相机接口句柄</param>
        /// <returns>获取失败返回-1，否则返回参数组的数量。</returns>
        [DllImport("PHM6000API", CallingConvention = CallingConvention.StdCall, EntryPoint = "GetParameterGroupCount")]
        public static extern int GetParameterGroupCount(IntPtr pHandle);

        //PHM6000_API(int) GetParameterGroupName(void* pHandle, int group_index, char* groupName);
        /// <summary>
        /// 获取全部参数组的名称
        /// </summary>
        /// <param name="pHandle">相机接口句柄</param>
        /// <param name="group_index">组序号</param>
        /// <param name="groupName">组名称，UTF-8格式的字符</param>
        /// <returns>获取失败返回-1，否则返回名称的长度。</returns>
        [DllImport("PHM6000API", CallingConvention = CallingConvention.StdCall, EntryPoint = "GetParameterGroupName")]
        public static extern int GetParameterGroupName(IntPtr pHandle, int group_index, byte[] groupName);

        //PHM6000_API(int) GetCurrentParameterGroup(void* pHandle, char* groupName);
        /// <summary>
        /// 获取当前参数组的名称
        /// </summary>
        /// <param name="pHandle">相机接口句柄</param>
        /// <param name="groupName">参数名称，UTF-8格式的字符</param>
        /// <returns>获取失败返回-1，否则返回名称的长度。</returns>
        [DllImport("PHM6000API", CallingConvention = CallingConvention.StdCall, EntryPoint = "GetCurrentParameterGroup")]
        public static extern int GetCurrentParameterGroup(IntPtr pHandle, byte[] groupName);

        //PHM6000_API(int) SelectParameterGroup(void* pHandle, const char* groupName);
        /// <summary>
        /// 选择参数组
        /// </summary>
        /// <param name="pHandle">相机接口句柄</param>
        /// <param name="groupName">参数组名称</param>
        /// <returns>获取失败返回-1，否则返回0。</returns>
        [DllImport("PHM6000API", CallingConvention = CallingConvention.StdCall, EntryPoint = "SelectParameterGroup")]
        public static extern int SelectParameterGroup(IntPtr pHandle, byte[] groupName);

        //PHM6000_API(int) AddParameterGroup(void* pHandle, const char* groupName);
        /// <summary>
        /// 添加参数组
        /// </summary>
        /// <param name="pHandle">相机接口句柄</param>
        /// <param name="groupName">参数组名称</param>
        /// <returns>获取失败返回-1，否则返回0。</returns>
        [DllImport("PHM6000API", CallingConvention = CallingConvention.StdCall, EntryPoint = "AddParameterGroup")]
        public static extern int AddParameterGroup(IntPtr pHandle, byte[] groupName);

        //PHM6000_API(int) DeleteParameterGroup(void* pHandle, const char* groupName);
        /// <summary>
        /// 删除参数组
        /// </summary>
        /// <param name="pHandle">相机接口句柄</param>
        /// <param name="groupName">参数组名称</param>
        /// <returns>获取失败返回-1，否则返回0。</returns>
        [DllImport("PHM6000API", CallingConvention = CallingConvention.StdCall, EntryPoint = "DeleteParameterGroup")]
        public static extern int DeleteParameterGroup(IntPtr pHandle, byte[] groupName);

        //PHM6000_API(int) RenameParameterGroup(void* pHandle, const char* newName);
        /// <summary>
        /// 重命名参数组
        /// </summary>
        /// <param name="pHandle">相机接口句柄</param>
        /// <param name="newName">新参数组名称</param>
        /// <returns>获取失败返回-1，否则返回0。</returns>
        [DllImport("PHM6000API", CallingConvention = CallingConvention.StdCall, EntryPoint = "RenameParameterGroup")]
        public static extern int RenameParameterGroup(IntPtr pHandle, byte[] newName);

        //PHM6000_API(int) LoadParameters(void* pHandle, char* szJSONFileName);
        /// <summary>
        /// 加载相机参数
        /// </summary>
        /// <param name="pHandle">相机接口句柄</param>
        /// <param name="szJSONFileName">json格式文件名</param>
        /// <returns>加载失败返回-1，否则返回0。</returns>
        [DllImport("PHM6000API", CallingConvention = CallingConvention.StdCall, EntryPoint = "LoadParameters")]
        public static extern int LoadParameters(IntPtr pHandle, byte[] szJSONFileName);

        //PHM6000_API(int) SaveParameters(void* pHandle, char* szJSONFileName);
        /// <summary>
        /// 保存相机参数
        /// </summary>
        /// <param name="pHandle">相机接口句柄</param>
        /// <param name="szJSONFileName">json格式文件名</param>
        /// <returns>保存失败返回-1，否则返回0。</returns>
        [DllImport("PHM6000API", CallingConvention = CallingConvention.StdCall, EntryPoint = "SaveParameters")]
        public static extern int SaveParameters(IntPtr pHandle, byte[] szJSONFileName);

        //PHM6000_API(int) GetProfilerParameter(void* pHandle, int nNameId, int* intValue, double* floatValue, int* enumValue);
        /// <summary>
        /// 获取线扫相机参数，每次读取一种参数，参数在相应类型处返回，其它类型位置忽略
        /// </summary>
        /// <param name="pHandle">相机接口句柄</param>
        /// <param name="nNameId">参数名的枚举值</param>
        /// <param name="intvalue">整型值指针</param>
        /// <param name="floatValue">双精度型指针</param>
        /// <param name="enumValue">枚举型指针</param>
        /// <returns>获取失败返回-1，否则返回0。</returns>
        [DllImport("PHM6000API", CallingConvention = CallingConvention.StdCall, EntryPoint = "GetProfilerParameter")]
        public static extern int GetProfilerParameter(IntPtr pHandle, int nNameId, ref int intvalue, ref double floatValue, ref int enumValue);

        //PHM6000_API(int) GetProfilerParameter(void* pHandle, int nNameId, int* intValue, double* floatValue, int* enumValue);
        /// <summary>
        /// 获取线扫相机参数，每次读取一种参数，参数在相应类型处返回，其它类型位置忽略
        /// </summary>
        /// <param name="pHandle">相机接口句柄</param>
        /// <param name="nNameId">参数名的枚举值</param>
        /// <param name="intvalue">整型值指针</param>
        /// <param name="floatValue">双精度型指针</param>
        /// <param name="enumValue">枚举型指针</param>
        /// <returns>获取失败返回-1，否则返回0。</returns>
        [DllImport("PHM6000API", CallingConvention = CallingConvention.StdCall, EntryPoint = "GetProfilerParameter")]
        public static extern int GetProfilerParameter(IntPtr pHandle, int nNameId, ref int intvalue, IntPtr floatValue, ref int enumValue);

        //PHM6000_API(int) SetProfilerParameter(void* pHandle, int nNameId, int intValue, double floatValue, int enumValue);
        /// <summary>
        /// 设置线扫相机参数，每次设置一种参数，参数在相应类型处输入，其它类型位置置零
        /// </summary>
        /// <param name="pHandle">相机接口句柄</param>
        /// <param name="nNameId">参数名的枚举值</param>
        /// <param name="intvalue">整型值</param>
        /// <param name="floatValue">双精度型值</param>
        /// <param name="enumValue">枚举型值</param>
        /// <returns>设置失败返回-1，否则返回0。</returns>
        [DllImport("PHM6000API", CallingConvention = CallingConvention.StdCall, EntryPoint = "SetProfilerParameter")]
        public static extern int SetProfilerParameter(IntPtr pHandle, int nNameId, int intvalue, double floatValue, int enumValue);

        //PHM6000_API(int) GetParameterNameCount(void* pHandle);
        /// <summary>
        /// 获取参数名的个数
        /// </summary>
        /// <param name="pHandle">相机接口句柄</param>
        /// <returns>获取失败返回-1，否则返回参数名的数量。</returns>
        [DllImport("PHM6000API", CallingConvention = CallingConvention.StdCall, EntryPoint = "GetParameterNameCount")]
        public static extern int GetParameterNameCount(IntPtr pHandle);

        //PHM6000_API(int) GetParameterName(void* pHandle, int param_index, char* paramName);
        /// <summary>
        /// 获取全部参数的名称
        /// </summary>
        /// <param name="pHandle">相机接口句柄</param>
        /// <param name="param_index">参数名序号</param>
        /// <param name="paramName">参数名称，UTF-8格式的字符</param>
        /// <returns>获取失败返回-1，否则返回名称的长度。</returns>
        [DllImport("PHM6000API", CallingConvention = CallingConvention.StdCall, EntryPoint = "GetParameterName")]
        public static extern int GetParameterName(IntPtr pHandle, int param_index, byte[] paramName);

        //PHM6000_API(int) ResetAllParametersToDefault(void* pHandle);
        /// <summary>
        /// 将全部参数的值复位成默认值
        /// </summary>
        /// <param name="pHandle">相机接口句柄</param>
        /// <returns>获取失败返回-1，否则返回0。</returns>
        [DllImport("PHM6000API", CallingConvention = CallingConvention.StdCall, EntryPoint = "ResetAllParametersToDefault")]
        public static extern int ResetAllParametersToDefault(IntPtr pHandle);

        //PHM6000_API(int) SaveAllParametersToDevice(void* pHandle);
        /// <summary>
        /// 将全部参数的值保存到设置
        /// </summary>
        /// <param name="pHandle">相机接口句柄</param>
        /// <returns>获取失败返回-1，否则返回0。</returns>
        [DllImport("PHM6000API", CallingConvention = CallingConvention.StdCall, EntryPoint = "SaveAllParametersToDevice")]
        public static extern int SaveAllParametersToDevice(IntPtr pHandle);

        //PHM6000_API(int) SetOutputGPIO(void* pHandle, GPIOLine LineIndex, int Level);
        /// <summary>
        /// 设置GPIO输出
        /// </summary>
        /// <param name="pHandle">相机接口句柄</param>
        /// <param name="LineIndex">引脚序号</param>
        /// <param name="Level">输出电平，1输出高电平</param>
        /// <returns>获取失败返回-1，否则返回0。</returns>
        [DllImport("PHM6000API", CallingConvention = CallingConvention.StdCall, EntryPoint = "SetOutputGPIO")]
        public static extern int SetOutputGPIO(IntPtr pHandle, GPIOLine LineIndex, int Level);

        //PHM6000_API(int) RegisterShowDebugInfoCallback(void* pHandle, ShowDebugInfoCallback callback);
        /// <summary>
        /// 注册调试信息回调函数，用于调试
        /// </summary>
        /// <param name="pHandle">相机接口句柄</param>
        /// <param name="callback">调试用回调函数指针</param>
        /// <returns>获取失败返回-1，否则返回0。</returns>
        [DllImport("PHM6000API", CallingConvention = CallingConvention.StdCall, EntryPoint = "RegisterShowDebugInfoCallback")]
        public static extern int RegisterShowDebugInfoCallback(IntPtr pHandle, ShowDebugInfoCallback callback);

        //PHM6000_API(int) RegisterAcquisitionCompletedCallback(void* pHandle, AcquisitionCompletedCallback callback, void* pInstance);
        /// <summary>
        /// 注册采集完成回调函数
        /// </summary>
        /// <param name="pHandle">相机接口句柄</param>
        /// <param name="callback">采集完成回调函数指针</param>
        /// <param name="pInstance">调用者的句柄</param>
        /// <returns>获取失败返回-1，否则返回0。</returns>
        [DllImport("PHM6000API", CallingConvention = CallingConvention.StdCall, EntryPoint = "RegisterAcquisitionCompletedCallback")]
        public static extern int RegisterAcquisitionCompletedCallback(IntPtr pHandle, AcquisitionCompletedCallback callback, IntPtr pInstance);

        //PHM6000_API(int) LoadDataFromFile(void* pHandle, const char* szFileName);
        /// <summary>
        /// 从文件加载数据（后缀名：*.lb3d）
        /// </summary>
        /// <param name="pHandle">相机接口句柄</param>
        /// <param name="szFileName">文件名</param>
        /// <returns>获取失败返回-1，否则返回0。</returns>
        [DllImport("PHM6000API", CallingConvention = CallingConvention.StdCall, EntryPoint = "LoadDataFromFile")]
        public static extern int LoadDataFromFile(IntPtr pHandle, byte[] szFileName);

        //PHM6000_API(int) SaveDataToFile(void* pHandle, const char* szFileName);
        /// <summary>
        /// 向文件保存数据（后缀名：*.lb3d）
        /// </summary>
        /// <param name="pHandle">相机接口句柄</param>
        /// <param name="szFileName">文件名</param>
        /// <returns>获取失败返回-1，否则返回0。</returns>
        [DllImport("PHM6000API", CallingConvention = CallingConvention.StdCall, EntryPoint = "SaveDataToFile")]
        public static extern int SaveDataToFile(IntPtr pHandle, byte[] szFileName);

        //PHM6000_API(void) SetShowHandles(void* pHandle, void* pIntensityHandle, void* pDepthHandle, void* pRawHandle, void* pVTK3dHandle, void* pChartHandle = nullptr);
        /// <summary>
        /// 设置显示控件的句柄,无返回值
        /// </summary>
        /// <param name="pHandle">相机接口句柄</param>
        /// <param name="pIntensityHandle">强度控件句柄</param>
        /// <param name="pDepthHandle">深度控件句柄</param>
        /// <param name="pRawHandle">原图控件句柄</param>
        /// <param name="pVTK3dHandle">三维显示控件句柄</param>
        /// <param name="pChartHandle">图表显控件句柄</param>
        [DllImport("PHM6000API", CallingConvention = CallingConvention.StdCall, EntryPoint = "SetShowHandles")]
        public static extern void SetShowHandles(IntPtr pHandle, IntPtr pIntensityHandle, IntPtr pDepthHandle, IntPtr pRawHandle, IntPtr pVTK3dHandle, IntPtr pChartHandle = new IntPtr());

        //PHM6000_API(void) SetPilot2dFunc(void* pHandle, PILOT2D_FUNC func);
        /// <summary>
        /// 设置二维显示控件所需的功能函数结构体,无返回值
        /// </summary>
        /// <param name="pHandle">相机接口句柄</param>
        /// <param name="func">二维显示控件所需的功能函数结构体</param>
        [DllImport("PHM6000API", CallingConvention = CallingConvention.StdCall, EntryPoint = "SetPilot2dFunc")]
        public static extern void SetPilot2dFunc(IntPtr pHandle, PILOT2D_FUNC func);

        //PHM6000_API(void) SetVTK3dFunc(void* pHandle, VTK3D_FUNC func);
        /// <summary>
        /// 设置三维显示控件所需的功能函数结构体,无返回值
        /// </summary>
        /// <param name="pHandle">相机接口句柄</param>
        /// <param name="func">三维显示控件所需的功能函数结构体</param>
        [DllImport("PHM6000API", CallingConvention = CallingConvention.StdCall, EntryPoint = "SetVTK3dFunc")]
        public static extern void SetVTK3dFunc(IntPtr pHandle, VTK3D_FUNC func);

        //PHM6000_API(unsigned char*) GetIntensityData(void* pHandle, int& nWidth, int& nHeight);
        /// <summary>
        /// 获取强度数据
        /// </summary>
        /// <param name="pHandle">相机接口句柄</param>
        /// <param name="nWidth">回传强度数据的宽度</param>
        /// <param name="nHeight">回传强度数据的高度</param>
        /// <returns>返回强度数据的指针，返回值为NULL时表示调用失败，(unsigned char*)</returns>
        [DllImport("PHM6000API", CallingConvention = CallingConvention.StdCall, EntryPoint = "GetIntensityData")]
        public static extern IntPtr GetIntensityData(IntPtr pHandle, ref int nWidth, ref int nHeight);

        //PHM6000_API(float*) GetDepthData(void* pHandle, int& nWidth, int& nHeight, float* fMinValue = NULL, float* fMaxValue = NULL);
        /// <summary>
        /// 获取深度数据
        /// </summary>
        /// <param name="pHandle">相机接口句柄</param>
        /// <param name="nWidth">回传深度数据的宽度</param>
        /// <param name="nHeight">回传深度数据的高度</param>
        /// <param name="fMinValue">用于回传深度的最小值, float* fMinValue = NULL</param>
        /// <param name="fMaxValue">用于回传深度的最大值, float* fMaxValue = NULL</param>
        /// <returns>返回深度数据的指针，返回值为NULL时表示调用失败,(float*) </returns>
        [DllImport("PHM6000API", CallingConvention = CallingConvention.StdCall, EntryPoint = "GetDepthData")]
        public static extern IntPtr GetDepthData(IntPtr pHandle, ref int nWidth, ref int nHeight, IntPtr fMinValue = new IntPtr(), IntPtr fMaxValue = new IntPtr());

        //PHM6000_API(float*) GetDepthDataInRectangle(void* pHandle, int nLeft, int nTop, int& nWidth, int& nHeight);
        /// <summary>
        /// 获取矩形兴趣区内的深度数据
        /// </summary>
        /// <param name="pHandle">相机接口句柄</param>
        /// <param name="nLeft">矩形左上角的x坐标</param>
        /// <param name="nTop">矩形左上角的y坐标</param>
        /// <param name="nWidth">矩形兴趣区的宽度</param>
        /// <param name="nHeight">矩形兴趣区的高度</param>
        /// <returns>返回深度数据的指针，返回值为NULL时表示调用失败，(float*)</returns>
        [DllImport("PHM6000API", CallingConvention = CallingConvention.StdCall, EntryPoint = "GetDepthDataInRectangle")]
        public static extern IntPtr GetDepthDataInRectangle(IntPtr pHandle, int nLeft, int nTop, ref int nWidth, ref int nHeight);

        //PHM6000_API(float*) GetDepthDataInCircle(void* pHandle, int& nWidth, int& nHeight, int nXPos, int nYPos, int nRadius);
        /// <summary>
        /// 获取圆形兴趣区内的深度数据
        /// </summary>
        /// <param name="pHandle">相机接口句柄</param>
        /// <param name="nWidth">回传深度数据的宽度</param>
        /// <param name="nHeight">回传深度数据的高度</param>
        /// <param name="nXPos">圆形中心的x坐标</param>
        /// <param name="nYPos">圆形中心的y坐标</param>
        /// <param name="nRadius">圆形的半径</param>
        /// <returns>返回深度数据的指针，返回值为NULL时表示调用失败,(float*)</returns>
        [DllImport("PHM6000API", CallingConvention = CallingConvention.StdCall, EntryPoint = "GetDepthDataInCircle")]
        public static extern IntPtr GetDepthDataInCircle(IntPtr pHandle, ref int nWidth, ref int nHeight, int nXPos, int nYPos, int nRadius);

        //PHM6000_API(float*) GetDepthDataInAnnulus(void* pHandle, int& nWidth, int& nHeight, int nXPos, int nYPos, int nRadius, float fRadiusRatio);
        /// <summary>
        /// 获取环形兴趣区内的深度数据
        /// </summary>
        /// <param name="pHandle">相机接口句柄</param>
        /// <param name="nWidth">回传深度数据的宽度</param>
        /// <param name="nHeight">回传深度数据的高度</param>
        /// <param name="nXPos">环形中心的x坐标</param>
        /// <param name="nYPos">环形中心的y坐标</param>
        /// <param name="nRadius">环形的半径</param>
        /// <param name="fRadiusRatio">环形的内外半径比，大于1时内外颠倒</param>
        /// <returns>返回深度数据的指针，返回值为NULL时表示调用失败,(float*) </returns>
        [DllImport("PHM6000API", CallingConvention = CallingConvention.StdCall, EntryPoint = "GetDepthDataInAnnulus")]
        public static extern IntPtr GetDepthDataInAnnulus(IntPtr pHandle, ref int nWidth, ref int nHeight, int nXPos, int nYPos, int nRadius, float fRadiusRatio);

        //PHM6000_API(float*) GetDepthDataInPolygon(void* pHandle, int& nWidth, int& nHeight, void* points, int nCount);
        /// <summary>
        /// 获取多边形兴趣区内的深度数据
        /// </summary>
        /// <param name="pHandle">相机接口句柄</param>
        /// <param name="nWidth">回传深度数据的宽度</param>
        /// <param name="nHeight">回传深度数据的高度</param>
        /// <param name="points">多边形顶点坐标数组的指针</param>
        /// <param name="nCount">多边形顶点的数量</param>
        /// <returns>返回深度数据的指针，返回值为NULL时表示调用失败，(float*) </returns>
        [DllImport("PHM6000API", CallingConvention = CallingConvention.StdCall, EntryPoint = "GetDepthDataInPolygon")]
        public static extern IntPtr GetDepthDataInPolygon(IntPtr pHandle, ref int nWidth, ref int nHeight, IntPtr points, int nCount);

        //PHM6000_API(int) InsertionSort(void* pHandle, float* pData, int nWidth, int nHeight);
        /// <summary>
        /// 从大到小排序函数并具有无效深度的过滤功能
        /// </summary>
        /// <param name="pHandle">相机接口句柄</param>
        /// <param name="pData">从兴趣区获得的深度数据指针, float* pData</param>
        /// <param name="nWidth">从兴趣区获得的深度数据的宽度</param>
        /// <param name="nHeight">从兴趣区获得的深度数据的高度</param>
        /// <returns>返回剔除无效数据后的深度数据个数，返回值为-1时表示调用失败</returns>
        [DllImport("PHM6000API", CallingConvention = CallingConvention.StdCall, EntryPoint = "InsertionSort")]
        public static extern int InsertionSort(IntPtr pHandle, IntPtr pData, int nWidth, int nHeight);

        //PHM6000_API(int) GetEncoderValueRange(void* pHandle, int nBeginLine, int nEndLine, unsigned long* nBeginValue, unsigned long* nEndValue);
        /// <summary>
        /// 获取编码器的值
        /// </summary>
        /// <param name="pHandle">相机接口句柄</param>
        /// <param name="nBeginLine">开始行的序号</param>
        /// <param name="nEndLine">结束行的序号</param>
        /// <param name="nBeginValue">用于返回开始行的编码器值, unsigned long* nBeginValue</param>
        /// <param name="nEndValue">用于返回结束行的编码器值, unsigned long* nEndValue</param>
        /// <returns>返回值为-1时表示调用失败</returns>
        [DllImport("PHM6000API", CallingConvention = CallingConvention.StdCall, EntryPoint = "GetEncoderValueRange")]
        public static extern int GetEncoderValueRange(IntPtr pHandle, int nBeginLine, int nEndLine, out uint nBeginValue, out uint nEndValue);

        //PHM6000_API(LBLineDataZA*) GetLineDataByEncoder(void* pHandle, unsigned long nEncoderValue);
        /// <summary>
        /// 获取编码器值指向的数据
        /// </summary>
        /// <param name="pHandle">相机接口句柄</param>
        /// <param name="nEncoderValue">编码器的值</param>
        /// <returns>返回值为NULL时表示调用失败,(LBLineDataZA*)</returns>
        [DllImport("PHM6000API", CallingConvention = CallingConvention.StdCall, EntryPoint = "GetLineDataByEncoder")]
        public static extern IntPtr GetLineDataByEncoder(IntPtr pHandle, uint nEncoderValue);

        //PHM6000_API(LBLineDataZA*) GetLineDataByIndex(void* pHandle, unsigned long nIndex);
        /// <summary>
        /// 通过编码器值获取数据
        /// </summary>
        /// <param name="pHandle">相机接口句柄</param>
        /// <param name="nIndex">数据的行序号</param>
        /// <returns>返回值为NULL时表示获取数据失败,(LBLineDataZA*)</returns>
        [DllImport("PHM6000API", CallingConvention = CallingConvention.StdCall, EntryPoint = "GetLineDataByIndex")]
        public static extern IntPtr GetLineDataByIndex(IntPtr pHandle, uint nIndex);
        //PHM6000_API(LBLineDataZA*) GetLineDataByIndex(void* pHandle, unsigned long nIndex);
        /// <summary>
        /// 通过编码器值获取数据
        /// </summary>
        /// <param name="pHandle">相机接口句柄</param>
        /// <param name="nIndex">数据的行序号</param>
        /// <returns>返回值为NULL时表示获取数据失败,(LBLineDataZA*)</returns>

        [DllImport("PHM6000API", CallingConvention = CallingConvention.StdCall, EntryPoint = "GetLineDataByIndex")]
        public static extern IntPtr GetLineDataByIndex(IntPtr pHandle, ulong nIndex);


        //PHM6000_API(void) SetTransformParameter(void* pHandle, float fAngle, int xOffset, int yOffset, int hMirror, int vMirror, int KeepImageSize = 0);
        /// <summary>
        /// 设置转换参数，用于获取转换后兴趣区内的数据
        /// </summary>
        /// <param name="pHandle">相机接口句柄</param>
        /// <param name="fAngle">旋转角度</param>
        /// <param name="xOffset">x向平移量</param>
        /// <param name="yOffset">y向平移量</param>
        /// <param name="hMirror">为1时水平镜像，为0时不变</param>
        /// <param name="vMirror">为1时垂直镜像，为0时不变</param>
        /// <param name="KeepImageSize">图像大小是否保持</param>
        [DllImport("PHM6000API", CallingConvention = CallingConvention.StdCall, EntryPoint = "SetTransformParameter")]
        public static extern void SetTransformParameter(IntPtr pHandle, float fAngle, int xOffset, int yOffset, int hMirror, int vMirror, int KeepImageSize = 0);

        #region PointCloud3D Functions
        
        [DllImport("PointCloud3D", CallingConvention = CallingConvention.StdCall, EntryPoint = "AddZAPoints")]
        public static extern int AddZAPoints(IntPtr pInstance, IntPtr points, int nCount, float fStepX, float fStepY, int nDownSample);

        [DllImport("PointCloud3D", CallingConvention = CallingConvention.StdCall, EntryPoint = "ClearPCLPoints")]
        public static extern int ClearPCLPoints(IntPtr pInstance);

        [DllImport("PointCloud3D", CallingConvention = CallingConvention.StdCall, EntryPoint = "GetPointCloudBound")]
        public static extern int GetPointCloudBound(IntPtr pInstance, ref double pMin, ref double pMax);

        [DllImport("PointCloud3D", CallingConvention = CallingConvention.StdCall, EntryPoint = "RenderPCLWindow")]
        public static extern void RenderPCLWindow(IntPtr pInstance, int nWidth, int nHeight);

        [DllImport("PointCloud3D", CallingConvention = CallingConvention.StdCall, EntryPoint = "SetLookUpTableRange")]
        public static extern void SetLookUpTableRange(IntPtr pInstance, double fMin, double fMax);

        [DllImport("PointCloud3D", CallingConvention = CallingConvention.StdCall, EntryPoint = "ShowCubeAxes")]
        public static extern void ShowCubeAxes(IntPtr pInstance, int bInit);

        [DllImport("PointCloud3D", CallingConvention = CallingConvention.StdCall, EntryPoint = "ShowLookUpTable")]
        public static extern void ShowLookUpTable(IntPtr pInstance, double x, double y, double xWide, double yWide);

        [DllImport("PointCloud3D", CallingConvention = CallingConvention.StdCall, EntryPoint = "UpdatePCLPointColors")]
        public static extern int UpdatePCLPointColors(IntPtr pInstance, string szColoring);

        #endregion

        /// <summary>
        /// 将结构体指针转换为double（模拟C++的(double)(int64)&操作）
        /// </summary>
        /// <param name="structurePtr">IntPtr structurePtr</param>
        /// <returns>double</returns>
        public static double StructurePtrToDouble(IntPtr structurePtr)
        {
            // 将指针转换为long，然后转换为double
            long ptrValue = structurePtr.ToInt64();
            return (double)ptrValue;
        }

        /// <summary>
        /// 将结构体转换为IntPtr并返回对应的double值
        /// </summary>
        /// <typeparam name="T">T </typeparam>
        /// <param name="structure">T structure</param>
        /// <returns>double</returns>
        public static double StructureToDoublePtr<T>(ref T structure)
        {
            IntPtr ptr = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(T)));
            Marshal.StructureToPtr(structure, ptr, false);

            long ptrValue = ptr.ToInt64();
            return (double)ptrValue;
        }

        /// <summary>
        /// 从double值恢复为指针并读取结构体
        /// </summary>
        /// <typeparam name="T">T </typeparam>
        /// <param name="doublePtr">double doublePtr</param>
        /// <returns>T </returns>
        public static T DoublePtrToStructure<T>(double doublePtr)
        {
            long ptrValue = (long)doublePtr;
            IntPtr ptr = new IntPtr(ptrValue);
            return (T)Marshal.PtrToStructure(ptr, typeof(T));
        }

        /// <summary>
        /// 释放由StructureToDoublePtr分配的内存
        /// </summary>
        /// <param name="doublePtr">double doublePtr</param>
        public static void FreeDoublePtr(double doublePtr)
        {
            long ptrValue = (long)doublePtr;
            IntPtr ptr = new IntPtr(ptrValue);
            Marshal.FreeHGlobal(ptr);
        }
        /// <summary>
        /// IntPtr To LBLineDataZA
        /// </summary>
        /// <param name="ptr">IntPtr ptr</param>
        /// <returns>LBLineDataZA</returns>
        public static LBLineDataZA ConvertToLBLineDataZA(IntPtr ptr)
        {
            // 首先读取info
            LBLineHeadInfo info = Marshal.PtrToStructure<LBLineHeadInfo>(ptr);

            // 计算数组开始的指针：ptr偏移info的大小
            IntPtr arrayPtr = ptr + Marshal.SizeOf<LBLineHeadInfo>();
            UInt32 pointCount = info.nPointCount;
            LBPointZA[] points = new LBPointZA[pointCount];
            int sizeOfPoint = Marshal.SizeOf<LBPointZA>();

            for (int i = 0; i < pointCount; i++)
            {
                points[i] = Marshal.PtrToStructure<LBPointZA>(arrayPtr + i * sizeOfPoint);
            }
            //Marshal.FreeHGlobal(arrayPtr);
            return new LBLineDataZA { info = info, data = points };
        }
    }
}