using Microsoft.Win32.SafeHandles;
using System;
using System.Runtime.InteropServices;
using System.Diagnostics;
using System.Collections.Generic;
using System.Drawing;
using System.Drawing.Imaging;
using System.Threading;
using System.IO;

namespace eyemLib_Sharp
{
    public unsafe class EyemLib
    {

        #region 枚举

        //稳健估计方法
        public enum ROBUST_METHOD
        {
            EYEM_DIST_USER = -1,
            EYEM_DIST_L1 = 1,
            EYEM_DIST_L12 = 2,
            EYEM_DIST_FAIR = 3,
            EYEM_DIST_WELSCH = 4,
            EYEM_DIST_HUBER = 5,
            EYEM_DIST_BISQUARE = 6,
            EYEM_DIST_CAUCHY = 7,
            EYEM_DIST_LOGISTIC = 8,
            EYEM_DIST_ANDREWS = 9,
            EYEM_DIST_ATLWORTH = 10
        }

        //图像格式信息
        enum ColorConversionCodes
        {
            COLOR_BGR2BGRA = 0, //!< add alpha channel to RGB or BGR image
            COLOR_RGB2RGBA = COLOR_BGR2BGRA,

            COLOR_BGRA2BGR = 1, //!< remove alpha channel from RGB or BGR image
            COLOR_RGBA2RGB = COLOR_BGRA2BGR,

            COLOR_BGR2RGBA = 2, //!< convert between RGB and BGR color spaces (with or without alpha channel)
            COLOR_RGB2BGRA = COLOR_BGR2RGBA,

            COLOR_RGBA2BGR = 3,
            COLOR_BGRA2RGB = COLOR_RGBA2BGR,

            COLOR_BGR2RGB = 4,
            COLOR_RGB2BGR = COLOR_BGR2RGB,

            COLOR_BGRA2RGBA = 5,
            COLOR_RGBA2BGRA = COLOR_BGRA2RGBA,

            COLOR_BGR2GRAY = 6, //!< convert between RGB/BGR and grayscale, @ref color_convert_rgb_gray "color conversions"
            COLOR_RGB2GRAY = 7,
            COLOR_GRAY2BGR = 8,
            COLOR_GRAY2RGB = COLOR_GRAY2BGR,
            COLOR_GRAY2BGRA = 9,
            COLOR_GRAY2RGBA = COLOR_GRAY2BGRA,
            COLOR_BGRA2GRAY = 10,
            COLOR_RGBA2GRAY = 11,

            COLOR_BGR2BGR565 = 12, //!< convert between RGB/BGR and BGR565 (16-bit images)
            COLOR_RGB2BGR565 = 13,
            COLOR_BGR5652BGR = 14,
            COLOR_BGR5652RGB = 15,
            COLOR_BGRA2BGR565 = 16,
            COLOR_RGBA2BGR565 = 17,
            COLOR_BGR5652BGRA = 18,
            COLOR_BGR5652RGBA = 19,

            COLOR_GRAY2BGR565 = 20, //!< convert between grayscale to BGR565 (16-bit images)
            COLOR_BGR5652GRAY = 21,

            COLOR_BGR2BGR555 = 22,  //!< convert between RGB/BGR and BGR555 (16-bit images)
            COLOR_RGB2BGR555 = 23,
            COLOR_BGR5552BGR = 24,
            COLOR_BGR5552RGB = 25,
            COLOR_BGRA2BGR555 = 26,
            COLOR_RGBA2BGR555 = 27,
            COLOR_BGR5552BGRA = 28,
            COLOR_BGR5552RGBA = 29,

            COLOR_GRAY2BGR555 = 30, //!< convert between grayscale and BGR555 (16-bit images)
            COLOR_BGR5552GRAY = 31,

            COLOR_BGR2XYZ = 32, //!< convert RGB/BGR to CIE XYZ, @ref color_convert_rgb_xyz "color conversions"
            COLOR_RGB2XYZ = 33,
            COLOR_XYZ2BGR = 34,
            COLOR_XYZ2RGB = 35,

            COLOR_BGR2YCrCb = 36, //!< convert RGB/BGR to luma-chroma (aka YCC), @ref color_convert_rgb_ycrcb "color conversions"
            COLOR_RGB2YCrCb = 37,
            COLOR_YCrCb2BGR = 38,
            COLOR_YCrCb2RGB = 39,

            COLOR_BGR2HSV = 40, //!< convert RGB/BGR to HSV (hue saturation value), @ref color_convert_rgb_hsv "color conversions"
            COLOR_RGB2HSV = 41,

            COLOR_BGR2Lab = 44, //!< convert RGB/BGR to CIE Lab, @ref color_convert_rgb_lab "color conversions"
            COLOR_RGB2Lab = 45,

            COLOR_BGR2Luv = 50, //!< convert RGB/BGR to CIE Luv, @ref color_convert_rgb_luv "color conversions"
            COLOR_RGB2Luv = 51,
            COLOR_BGR2HLS = 52, //!< convert RGB/BGR to HLS (hue lightness saturation), @ref color_convert_rgb_hls "color conversions"
            COLOR_RGB2HLS = 53,

            COLOR_HSV2BGR = 54, //!< backward conversions to RGB/BGR
            COLOR_HSV2RGB = 55,

            COLOR_Lab2BGR = 56,
            COLOR_Lab2RGB = 57,
            COLOR_Luv2BGR = 58,
            COLOR_Luv2RGB = 59,
            COLOR_HLS2BGR = 60,
            COLOR_HLS2RGB = 61,

            COLOR_BGR2HSV_FULL = 66,
            COLOR_RGB2HSV_FULL = 67,
            COLOR_BGR2HLS_FULL = 68,
            COLOR_RGB2HLS_FULL = 69,

            COLOR_HSV2BGR_FULL = 70,
            COLOR_HSV2RGB_FULL = 71,
            COLOR_HLS2BGR_FULL = 72,
            COLOR_HLS2RGB_FULL = 73,

            COLOR_LBGR2Lab = 74,
            COLOR_LRGB2Lab = 75,
            COLOR_LBGR2Luv = 76,
            COLOR_LRGB2Luv = 77,

            COLOR_Lab2LBGR = 78,
            COLOR_Lab2LRGB = 79,
            COLOR_Luv2LBGR = 80,
            COLOR_Luv2LRGB = 81,

            COLOR_BGR2YUV = 82, //!< convert between RGB/BGR and YUV
            COLOR_RGB2YUV = 83,
            COLOR_YUV2BGR = 84,
            COLOR_YUV2RGB = 85,

            //! YUV 4:2:0 family to RGB
            COLOR_YUV2RGB_NV12 = 90,
            COLOR_YUV2BGR_NV12 = 91,
            COLOR_YUV2RGB_NV21 = 92,
            COLOR_YUV2BGR_NV21 = 93,
            COLOR_YUV420sp2RGB = COLOR_YUV2RGB_NV21,
            COLOR_YUV420sp2BGR = COLOR_YUV2BGR_NV21,

            COLOR_YUV2RGBA_NV12 = 94,
            COLOR_YUV2BGRA_NV12 = 95,
            COLOR_YUV2RGBA_NV21 = 96,
            COLOR_YUV2BGRA_NV21 = 97,
            COLOR_YUV420sp2RGBA = COLOR_YUV2RGBA_NV21,
            COLOR_YUV420sp2BGRA = COLOR_YUV2BGRA_NV21,

            COLOR_YUV2RGB_YV12 = 98,
            COLOR_YUV2BGR_YV12 = 99,
            COLOR_YUV2RGB_IYUV = 100,
            COLOR_YUV2BGR_IYUV = 101,
            COLOR_YUV2RGB_I420 = COLOR_YUV2RGB_IYUV,
            COLOR_YUV2BGR_I420 = COLOR_YUV2BGR_IYUV,
            COLOR_YUV420p2RGB = COLOR_YUV2RGB_YV12,
            COLOR_YUV420p2BGR = COLOR_YUV2BGR_YV12,

            COLOR_YUV2RGBA_YV12 = 102,
            COLOR_YUV2BGRA_YV12 = 103,
            COLOR_YUV2RGBA_IYUV = 104,
            COLOR_YUV2BGRA_IYUV = 105,
            COLOR_YUV2RGBA_I420 = COLOR_YUV2RGBA_IYUV,
            COLOR_YUV2BGRA_I420 = COLOR_YUV2BGRA_IYUV,
            COLOR_YUV420p2RGBA = COLOR_YUV2RGBA_YV12,
            COLOR_YUV420p2BGRA = COLOR_YUV2BGRA_YV12,

            COLOR_YUV2GRAY_420 = 106,
            COLOR_YUV2GRAY_NV21 = COLOR_YUV2GRAY_420,
            COLOR_YUV2GRAY_NV12 = COLOR_YUV2GRAY_420,
            COLOR_YUV2GRAY_YV12 = COLOR_YUV2GRAY_420,
            COLOR_YUV2GRAY_IYUV = COLOR_YUV2GRAY_420,
            COLOR_YUV2GRAY_I420 = COLOR_YUV2GRAY_420,
            COLOR_YUV420sp2GRAY = COLOR_YUV2GRAY_420,
            COLOR_YUV420p2GRAY = COLOR_YUV2GRAY_420,

            //! YUV 4:2:2 family to RGB
            COLOR_YUV2RGB_UYVY = 107,
            COLOR_YUV2BGR_UYVY = 108,
            //COLOR_YUV2RGB_VYUY = 109,
            //COLOR_YUV2BGR_VYUY = 110,
            COLOR_YUV2RGB_Y422 = COLOR_YUV2RGB_UYVY,
            COLOR_YUV2BGR_Y422 = COLOR_YUV2BGR_UYVY,
            COLOR_YUV2RGB_UYNV = COLOR_YUV2RGB_UYVY,
            COLOR_YUV2BGR_UYNV = COLOR_YUV2BGR_UYVY,

            COLOR_YUV2RGBA_UYVY = 111,
            COLOR_YUV2BGRA_UYVY = 112,
            //COLOR_YUV2RGBA_VYUY = 113,
            //COLOR_YUV2BGRA_VYUY = 114,
            COLOR_YUV2RGBA_Y422 = COLOR_YUV2RGBA_UYVY,
            COLOR_YUV2BGRA_Y422 = COLOR_YUV2BGRA_UYVY,
            COLOR_YUV2RGBA_UYNV = COLOR_YUV2RGBA_UYVY,
            COLOR_YUV2BGRA_UYNV = COLOR_YUV2BGRA_UYVY,

            COLOR_YUV2RGB_YUY2 = 115,
            COLOR_YUV2BGR_YUY2 = 116,
            COLOR_YUV2RGB_YVYU = 117,
            COLOR_YUV2BGR_YVYU = 118,
            COLOR_YUV2RGB_YUYV = COLOR_YUV2RGB_YUY2,
            COLOR_YUV2BGR_YUYV = COLOR_YUV2BGR_YUY2,
            COLOR_YUV2RGB_YUNV = COLOR_YUV2RGB_YUY2,
            COLOR_YUV2BGR_YUNV = COLOR_YUV2BGR_YUY2,

            COLOR_YUV2RGBA_YUY2 = 119,
            COLOR_YUV2BGRA_YUY2 = 120,
            COLOR_YUV2RGBA_YVYU = 121,
            COLOR_YUV2BGRA_YVYU = 122,
            COLOR_YUV2RGBA_YUYV = COLOR_YUV2RGBA_YUY2,
            COLOR_YUV2BGRA_YUYV = COLOR_YUV2BGRA_YUY2,
            COLOR_YUV2RGBA_YUNV = COLOR_YUV2RGBA_YUY2,
            COLOR_YUV2BGRA_YUNV = COLOR_YUV2BGRA_YUY2,

            COLOR_YUV2GRAY_UYVY = 123,
            COLOR_YUV2GRAY_YUY2 = 124,
            //CV_YUV2GRAY_VYUY    = CV_YUV2GRAY_UYVY,
            COLOR_YUV2GRAY_Y422 = COLOR_YUV2GRAY_UYVY,
            COLOR_YUV2GRAY_UYNV = COLOR_YUV2GRAY_UYVY,
            COLOR_YUV2GRAY_YVYU = COLOR_YUV2GRAY_YUY2,
            COLOR_YUV2GRAY_YUYV = COLOR_YUV2GRAY_YUY2,
            COLOR_YUV2GRAY_YUNV = COLOR_YUV2GRAY_YUY2,

            //! alpha premultiplication
            COLOR_RGBA2mRGBA = 125,
            COLOR_mRGBA2RGBA = 126,

            //! RGB to YUV 4:2:0 family
            COLOR_RGB2YUV_I420 = 127,
            COLOR_BGR2YUV_I420 = 128,
            COLOR_RGB2YUV_IYUV = COLOR_RGB2YUV_I420,
            COLOR_BGR2YUV_IYUV = COLOR_BGR2YUV_I420,

            COLOR_RGBA2YUV_I420 = 129,
            COLOR_BGRA2YUV_I420 = 130,
            COLOR_RGBA2YUV_IYUV = COLOR_RGBA2YUV_I420,
            COLOR_BGRA2YUV_IYUV = COLOR_BGRA2YUV_I420,
            COLOR_RGB2YUV_YV12 = 131,
            COLOR_BGR2YUV_YV12 = 132,
            COLOR_RGBA2YUV_YV12 = 133,
            COLOR_BGRA2YUV_YV12 = 134,

            //! Demosaicing
            COLOR_BayerBG2BGR = 46,
            COLOR_BayerGB2BGR = 47,
            COLOR_BayerRG2BGR = 48,
            COLOR_BayerGR2BGR = 49,

            COLOR_BayerBG2RGB = COLOR_BayerRG2BGR,
            COLOR_BayerGB2RGB = COLOR_BayerGR2BGR,
            COLOR_BayerRG2RGB = COLOR_BayerBG2BGR,
            COLOR_BayerGR2RGB = COLOR_BayerGB2BGR,

            COLOR_BayerBG2GRAY = 86,
            COLOR_BayerGB2GRAY = 87,
            COLOR_BayerRG2GRAY = 88,
            COLOR_BayerGR2GRAY = 89,

            //! Demosaicing using Variable Number of Gradients
            COLOR_BayerBG2BGR_VNG = 62,
            COLOR_BayerGB2BGR_VNG = 63,
            COLOR_BayerRG2BGR_VNG = 64,
            COLOR_BayerGR2BGR_VNG = 65,

            COLOR_BayerBG2RGB_VNG = COLOR_BayerRG2BGR_VNG,
            COLOR_BayerGB2RGB_VNG = COLOR_BayerGR2BGR_VNG,
            COLOR_BayerRG2RGB_VNG = COLOR_BayerBG2BGR_VNG,
            COLOR_BayerGR2RGB_VNG = COLOR_BayerGB2BGR_VNG,

            //! Edge-Aware Demosaicing
            COLOR_BayerBG2BGR_EA = 135,
            COLOR_BayerGB2BGR_EA = 136,
            COLOR_BayerRG2BGR_EA = 137,
            COLOR_BayerGR2BGR_EA = 138,

            COLOR_BayerBG2RGB_EA = COLOR_BayerRG2BGR_EA,
            COLOR_BayerGB2RGB_EA = COLOR_BayerGR2BGR_EA,
            COLOR_BayerRG2RGB_EA = COLOR_BayerBG2BGR_EA,
            COLOR_BayerGR2RGB_EA = COLOR_BayerGB2BGR_EA,

            //! Demosaicing with alpha channel
            COLOR_BayerBG2BGRA = 139,
            COLOR_BayerGB2BGRA = 140,
            COLOR_BayerRG2BGRA = 141,
            COLOR_BayerGR2BGRA = 142,

            COLOR_BayerBG2RGBA = COLOR_BayerRG2BGRA,
            COLOR_BayerGB2RGBA = COLOR_BayerGR2BGRA,
            COLOR_BayerRG2RGBA = COLOR_BayerBG2BGRA,
            COLOR_BayerGR2RGBA = COLOR_BayerGB2BGRA,

            COLOR_COLORCVT_MAX = 143
        };

        #endregion

        #region 结构体
        // 图像信息
        [StructLayout(LayoutKind.Sequential)]
        public struct EyemImage
        {
            public IntPtr vpImage;                     // 地址
            public int iWidth;                         // 图像内存 x 方向大小
            public int iHeight;                        // 图像内存 y 方向大小
            public int iDepth;                         // 图像位深度（详见说明）
            public int iChannels;                      // 图像通道数
        }

        // 矩形定义
        [StructLayout(LayoutKind.Sequential)]
        public struct EyemRect
        {
            public int iXs;                            // 起始点（左上角） x 坐标
            public int iYs;                            // 起始点（左上角） y 坐标
            public int iWidth;                         // x 方向大小（宽度）
            public int iHeight;                        // y 方向大小（高度）
        }

        [StructLayout(LayoutKind.Sequential)]
        public struct EyemRect2
        {
            public int iXs;                            // 起始点（左上角） x 坐标
            public int iYs;                            // 起始点（左上角） y 坐标
            public int iXe;                            // 端点（右下） x 坐标
            public int iYe;                            // 端点（右下） y 坐标
        }

        [StructLayout(LayoutKind.Sequential)]
        public struct EyemRect3
        {
            public int iXs;                            // 起始点（左上角） x 坐标
            public int iYs;                            // 起始点（左上角） y 坐标
            public int iWidth;                         // x 方向大小（宽度）
            public int iHeight;                        // y 方向大小（高度）
            public double dVar;                        // 某种可能会使用的值
        }

        [StructLayout(LayoutKind.Sequential)]
        public struct BboxContainer
        {
            //最多支持100个目标
            [MarshalAs(UnmanagedType.ByValArray, SizeConst = 100)]
            public EyemRect[] bboxes;
        }

        ///////////////////////////////////////////////////////////////////////////////
        // Orthogonal Coordinate System

        /////////////////////
        // int type
        //
        [StructLayout(LayoutKind.Sequential)]
        public struct EyemOcsIXY
        {
            public int iX;                             // Ｘ坐标
            public int iY;                             // Ｙ坐标
        }

        [StructLayout(LayoutKind.Sequential)]
        public struct EyemOcsIXYZ
        {
            public int iX;                             // Ｘ坐标
            public int iY;                             // Ｙ坐标
            public int iZ;                             // Ｚ坐标
        }

        [StructLayout(LayoutKind.Sequential)]
        public struct EyemOcsIXYQ
        {
            public int iX;                             // Ｘ坐标
            public int iY;                             // Ｙ坐标
            public int iQ;                             // θ
        }

        [StructLayout(LayoutKind.Sequential)]
        public struct EyemOcsIXYR                      // 用于表示圆
        {
            public int iX;                             // Ｘ坐标
            public int iY;                             // Ｙ坐标
            public int iR;                             // 半径
        }

        [StructLayout(LayoutKind.Sequential)]
        public struct EyemOcsIABC                      // 用于表示直线（一般形式）
        {
            public int iA;                             // a
            public int iB;                             // b
            public int iC;                             // c
        }

        [StructLayout(LayoutKind.Sequential)]
        public struct EyemOcsIRQ                       // 用于表示直线（黑森标准形式）或矢量
        {
            public int iR;                             // ρ
            public int iQ;                             // θ
        }

        [StructLayout(LayoutKind.Sequential)]
        public struct EyemOcsIXYQS
        {
            public int iX;                             // Ｘ坐标(单位：像素)
            public int iY;                             // Ｙ坐标(单位：像素)
            public int iQ;                             // 斜率(単位：rad)
            public int iS;                             // 刻度
        }


        /////////////////////
        // float type
        //
        [StructLayout(LayoutKind.Sequential)]
        public struct EyemOcsFXY
        {
            public float fX;                           // Ｘ坐标
            public float fY;                           // Ｙ坐标
        }

        [StructLayout(LayoutKind.Sequential)]
        public struct EyemOcsFXYZ
        {
            public float fX;                           // Ｘ坐标
            public float fY;                           // Ｙ坐标
            public float fZ;                           // Ｚ坐标
        }

        [StructLayout(LayoutKind.Sequential)]
        public struct EyemOcsFXYQ
        {
            public float fX;                           // Ｘ坐标
            public float fY;                           // Ｙ坐标
            public float fQ;                           // θ
        }

        [StructLayout(LayoutKind.Sequential)]
        public struct EyemOcsFXYR                      // 用于表示圆
        {
            public float fX;                           // Ｘ坐标
            public float fY;                           // Ｙ坐标
            public float fR;                           // 半径
        }

        [StructLayout(LayoutKind.Sequential)]
        public struct EyemOcsFABC                      // 用于表示直线（一般形式）
        {
            public float fA;                           // a
            public float fB;                           // b
            public float fC;                           // c
        }

        [StructLayout(LayoutKind.Sequential)]
        public struct EyemOcsFRQ                       // 用于表示直线（黑森标准形式）或矢量
        {
            public float fR;                           // ρ
            public float fQ;                           // θ
        }

        [StructLayout(LayoutKind.Sequential)]
        public struct EyemOcsFXYQS
        {
            public float fX;                           // Ｘ坐标(単位：像素)
            public float fY;                           // Ｙ坐标(単位：像素)
            public float fQ;                           // 斜率(単位：rad)
            public float fS;                           // 刻度
        }


        /////////////////////
        // double type
        //
        [StructLayout(LayoutKind.Sequential)]
        public struct EyemOcsDXY
        {
            public double dX;                          // Ｘ坐标
            public double dY;                          // Ｙ坐标
        }

        [StructLayout(LayoutKind.Sequential)]
        public struct EyemOcsDXYZ
        {
            public double dX;                          // Ｘ坐标
            public double dY;                          // Ｙ坐标
            public double dZ;                          // Ｚ坐标
        }

        [StructLayout(LayoutKind.Sequential)]
        public struct EyemOcsDXYQ
        {
            public double dX;                          // Ｘ坐标
            public double dY;                          // Ｙ坐标
            public double dQ;                          // θ
        }

        [StructLayout(LayoutKind.Sequential)]
        public struct EyemOcsDXYR                      // 用于表示圆
        {
            public double dX;                          // 中心的Ｘ坐标
            public double dY;                          // 中心的Ｙ坐标
            public double dR;                          // 半径
        }

        [StructLayout(LayoutKind.Sequential)]
        public struct EyemOcsDABC                      // 直线(一般形)的表现形式
        {
            public double dA;                          // a
            public double dB;                          // b
            public double dC;                          // c
        }


        [StructLayout(LayoutKind.Sequential)]
        public struct EyemOcsDRQ                       // 用于表示直线（黑森标准形状）和矢量
        {
            public double dR;                          // ρ
            public double dQ;                          // θ
        }

        [StructLayout(LayoutKind.Sequential)]
        public struct EyemOcsDXYQS
        {
            public double dX;                          // X坐标
            public double dY;                          // Y坐标
            public double dQ;                          // 旋转角度(単位：rad)
            public double dS;                          // 规模
        }

        [StructLayout(LayoutKind.Sequential)]
        public struct EyemOcsDABCD                     // 用于表示平面（一般形式）
        {
            public double dA;                          // a
            public double dB;                          // b
            public double dC;                          // c
            public double dD;                          // d
        }

        [StructLayout(LayoutKind.Sequential)]
        public struct EyemOcsDXYLSQ                    // 用于表示椭圆
        {
            public double dXo;                         // 中心X坐标
            public double dYo;                         // 中心Y坐标
            public double dL;                          // 长轴半径
            public double dS;                          // 短轴半径
            public double dQ;                          // 长轴倾斜角(単位：rad)
        }

        [StructLayout(LayoutKind.Sequential)]
        public struct EyemOcsDPV                       // 用于表示三维空间中的直线
        {
            public EyemOcsDXYZ tP;                     // 直线上一点的坐标
            public EyemOcsDXYZ tV;                     // 直线方向矢量
        }

        [StructLayout(LayoutKind.Sequential)]
        public struct EyemOcsDCRUVW                    // 用于表示椭圆体
        {
            public EyemOcsDXYZ tC;                     // 椭圆体中心
            public EyemOcsDXYZ tR;                     // 轴半径（dX：长轴、dY：中轴、dZ：短轴）
            public double dU;                          // 长轴投影到 XY 平面与 X 轴的角（单位：rad）
            public double dV;                          // 长轴与XY平面之角（单位：rad）
            public double dW;                          // 绕长轴旋转角度（单位：rad）
        }

        // Blob 分析结果
        [StructLayout(LayoutKind.Sequential)]
        public struct EyemBinBlob
        {
            public int iLabel;                          // 标签
            public int iArea;                           // 面积
            public double dCenterX;                     // 重心ｘ坐标
            public double dCenterY;                     // 重心ｙ坐标
            public int iXs, iYs, iXe, iYe;              // 外接矩形（始点，终点）
            public int iWidth, iHeight;                 // 外接矩形（x 方向大小（宽度），y 方向大小（高度））
            public double dTheta;                       // 主轴倾斜角（rad）
        }

        [StructLayout(LayoutKind.Sequential)]
        public struct EyemChainCode
        {
            public int iLabel;                         // 标签
            public double dX;                          // ｘ坐标
            public double dY;                          // ｙ坐标
            public double dVx, dVy;                    // 向量
        }

        // 条码 解码结果
        [StructLayout(LayoutKind.Sequential)]
        public struct EyemBarCode
        {
            public double dAngle;                      // 角度
            public int iCenterX;                       // x坐标
            public int iCenterY;                       // y坐标
            public IntPtr hType;                       // 码类型
            public IntPtr hText;                       // 码内容
        }

        [StructLayout(LayoutKind.Sequential)]
        public struct EyemModelID
        {
            public IntPtr vpImage;                     // 地址
            public int iXs;                            // 图像X坐标
            public int iYs;                            // 图像Y坐标
            public int iWidth;                         // 图像内存X方向大小
            public int iHeight;                        // 图像内存Y方向大小
            public double dMatchDeg;                   // 匹配度
            public IntPtr lpszName;                    // 名称
        }

        public struct EyemRigidMatrix
        {

            public double a00;                         // a00
            public double a01;                         // a01
            public double b00;                         // b00
            public double a10;                         // a10
            public double a11;                         // a11
            public double b10;                         // b10
        }
        #endregion

        #region 通用

        /// <summary>
        /// Win32 memory copy function
        /// </summary>
        /// <param name="dst">目标地址</param>
        /// <param name="src">源地址</param>
        /// <param name="count">长度</param>
        /// <returns></returns>
        [DllImport("ntdll.dll", CallingConvention = CallingConvention.Cdecl)]
        private static extern byte* memcpy(byte* dst, byte* src, int count);
        /// <summary>
        /// 读取图像文件
        /// </summary>
        /// <param name="filename">文件名</param>
        /// <param name="iFalgs">读取标志,-1:按照原样加载图像 0:始终将图像转化成单通道灰度图像 1:如果设置，请始终将图像转换为3通道BGR彩色图像
        /// 2:在输入具有相应深度时返回16位/32位图像，否则将其转换为8位 4:以任何可能的颜色格式读取图像 </param>
        /// <param name="tpImage">图像</param>
        /// <returns></returns>
        [DllImport("eyemLib.dll", CharSet = CharSet.None, CallingConvention = CallingConvention.Cdecl)]
        private static extern int eyemImageRead(string filename, int iFalgs, out EyemImage tpImage);
        /// <summary>
        /// 从指针创建图像
        /// </summary>
        /// <param name="vpScan0">数据地址</param>
        /// <param name="iWidth">数据宽度</param>
        /// <param name="iHeight">数据高度</param>
        /// <param name="iDepth">数据深度</param>
        /// <param name="iChannels">通道数</param>
        /// <param name="tpImage">图像</param>
        /// <returns></returns>
        [DllImport("eyemLib.dll", CharSet = CharSet.None, CallingConvention = CallingConvention.Cdecl)]
        private static extern int eyemImageFromBitmap(IntPtr vpScan0, int iWidth, int iHeight, int iDepth, int iChannels, out EyemImage tpImage);
        /// <summary>
        /// 读取视频，支持彩色
        /// </summary>
        /// <param name="filename">视频文件名</param>
        /// <param name="hObject">返回句柄</param>
        /// <param name="tpImages">返回图像</param>
        /// <param name="ipNum">图像数量</param>
        /// <returns></returns>
        [DllImport("eyemLib.dll", CharSet = CharSet.None, CallingConvention = CallingConvention.Cdecl)]
        private static extern int eyemVideoCapture(string filename, out VideoHandle hObject, out EyemImage* tpImages, out int ipNum);
        /// <summary>
        /// 释放视频资源
        /// </summary>
        /// <param name="hObject">句柄</param>
        /// <returns></returns>
        [DllImport("eyemLib.dll", CharSet = CharSet.None, CallingConvention = CallingConvention.Cdecl)]
        private static extern bool eyemVideoCaptureFree(IntPtr hObject);
        /// <summary>
        /// 读取Raw格式图像，仅支持8/16位
        /// </summary>
        /// <param name="filename">文件名(.raw)</param>
        /// <param name="iWidth">图像宽度</param>
        /// <param name="iHeight">图像高度</param>
        /// <param name="iDepth">图像深度</param>
        /// <param name="tpImage">图像</param>
        /// <returns></returns>
        [DllImport("eyemLib.dll", CharSet = CharSet.None, CallingConvention = CallingConvention.Cdecl)]
        private static extern int eyemImageReadRaw(string filename, int iWidth, int iHeight, int iDepth, out EyemImage tpImage);
        /// <summary>
        /// 释放图像资源
        /// </summary>
        /// <param name="tpImage">图像</param>
        [DllImport("eyemLib.dll", CharSet = CharSet.None, CallingConvention = CallingConvention.Cdecl)]
        private static extern void eyemImageFree(ref EyemImage tpImage);
        // 设定日志回调
        [DllImport("eyemLib.dll", CharSet = CharSet.None, CallingConvention = CallingConvention.Cdecl)]
        private static extern void setLogCallback(TCallBack cb);
        #endregion

        #region 2 值 blob 分析

        /// <summary>
        /// 自适应二值化图像
        /// </summary>
        /// <param name="tpImage">图像</param>
        /// <param name="dSigma">sigma</param>
        /// <param name="iLightDark">二值化形式</param>
        /// <param name="binMethod">二值化方法</param>
        /// <param name="tpDstImg">结果图像</param>
        /// <returns></returns>
        [DllImport("eyemLib.dll", CharSet = CharSet.None, CallingConvention = CallingConvention.Cdecl)]
        private static extern int eyemBinAutoThreshold(EyemImage tpImage, double dSigma, int iLightDark, int binMethod, out EyemImage tpDstImg);

        /// <summary>
        /// 全局二值化
        /// </summary>
        /// <param name="tpSrcImg">原图</param>
        /// <param name="iLightDark">黑白</param>
        /// <param name="dThresh">阈值</param>
        /// <param name="dMaxVal">最大值</param>
        /// <param name="tpDstImg">结果图像</param>
        /// <returns></returns>
        [DllImport("eyemLib.dll", CharSet = CharSet.None, CallingConvention = CallingConvention.Cdecl)]
        private static extern int eyemBinThreshold(EyemImage tpSrcImg, int iLightDark, double dThresh, double dMaxVal, out EyemImage tpDstImg);

        /// <summary>
        /// 局部自适应二值化
        /// </summary>
        /// <param name="tpSrcImg">图像</param>
        /// <param name="iLightDark">二值化类型</param>
        /// <param name="iWinSize">窗口大小</param>
        /// <param name="dK">补偿</param>
        /// <param name="binarizationMethod">二值化方法</param>
        /// <param name="dR">半径</param>
        /// <param name="tpDstImg">结果图像</param>
        /// <returns></returns>
        [DllImport("eyemLib.dll", CharSet = CharSet.None, CallingConvention = CallingConvention.Cdecl)]
        private static extern int eyemBinNiBlack(EyemImage tpSrcImg, int iLightDark, int iWinSize, double dK, int binarizationMethod, double dR, out EyemImage tpDstImg);

        /// <summary>
        /// 动态阈值
        /// </summary>
        /// <param name="tpSrcImg">图像</param>
        /// <param name="tpThresholdImg">处理后图像(一般为滤波后图像)</param>
        /// <param name="iOffset">补偿</param>
        /// <param name="iLightDark">二值化形式</param>
        /// <param name="tpDstImg">结果图像</param>
        /// <returns></returns>
        [DllImport("eyemLib.dll", CharSet = CharSet.None, CallingConvention = CallingConvention.Cdecl)]
        private static extern int eyemBinDynThreshold(EyemImage tpSrcImg, EyemImage tpThresholdImg, double iOffset, int iLightDark, out EyemImage tpDstImg);
        /// <summary>
        /// 二值Blob分析
        /// </summary>
        /// <param name="tpImage">图像</param>
        /// <param name="hObject">结果句柄</param>
        /// <param name="iAreaThrs">面积过滤</param>
        /// <param name="tpResult">结果</param>
        /// <param name="ipNum">结果数量</param>
        /// <param name="tpDstImage">结果图像</param>
        /// <returns></returns>
        [DllImport("eyemLib.dll", CharSet = CharSet.None, CallingConvention = CallingConvention.Cdecl)]
        private static extern int eyemBinBlob(EyemImage tpImage, out BlobHandle hObject, int iAreaThrs, out EyemBinBlob* tpResult, out int ipNum, out EyemImage tpDstImage);
        /// <summary>
        /// 释放Blob资源
        /// </summary>
        /// <param name="hObject">结果句柄</param>
        /// <returns></returns>
        [DllImport("eyemLib.dll", CharSet = CharSet.None, CallingConvention = CallingConvention.Cdecl)]
        private static extern bool eyemBinFree(IntPtr hObject);

        #endregion

        #region 矩阵运算
        /// <summary>
        /// 创建图像
        /// </summary>
        /// <param name="iWidth">图像宽度</param>
        /// <param name="iHeight">图像高度</param>
        /// <param name="iChannels">通道数</param>
        /// <param name="ccSubType">数据类型(uint8_t、int8_t、uint16_t、int16_t、int32_t、float_t、double_t)</param>
        /// <param name="tpImage">图像</param>
        /// <returns></returns>
        [DllImport("eyemLib.dll", CharSet = CharSet.None, CallingConvention = CallingConvention.Cdecl)]
        private static extern int eyemMatMalloc(int iWidth, int iHeight, int iChannels, string ccSubType, out EyemImage tpImage);
        /// <summary>
        /// 拷贝图像
        /// </summary>
        /// <param name="tpDstImg">目标图像</param>
        /// <param name="tpImage">源图像</param>
        /// <returns></returns>
        [DllImport("eyemLib.dll", CharSet = CharSet.None, CallingConvention = CallingConvention.Cdecl)]
        private static extern int eyemMatCopy(ref EyemImage tpDstImg, EyemImage tpImage);
        /// <summary>
        /// 图像加运算
        /// </summary>
        /// <param name="tpImage1">图像</param>
        /// <param name="tpImage2">图像</param>
        /// <param name="tpDstImg">结果图像</param>
        /// <returns></returns>
        [DllImport("eyemLib.dll", CharSet = CharSet.None, CallingConvention = CallingConvention.Cdecl)]
        private static extern int eyemMatAdd(EyemImage tpImage1, EyemImage tpImage2, ref EyemImage tpDstImg);
        /// <summary>
        /// 图像减运算
        /// </summary>
        /// <param name="tpImageMinuend">减</param>
        /// <param name="tpImageSubtrahend">被减</param>
        /// <param name="tpDstImg">结果图像</param>
        /// <returns></returns>
        [DllImport("eyemLib.dll", CharSet = CharSet.None, CallingConvention = CallingConvention.Cdecl)]
        private static extern int eyemMatSub(EyemImage tpImageMinuend, EyemImage tpImageSubtrahend, ref EyemImage tpDstImg);
        /// <summary>
        /// 图像绝对值
        /// </summary>
        /// <param name="tpImage">图像</param>
        /// <returns></returns>
        [DllImport("eyemLib.dll", CharSet = CharSet.None, CallingConvention = CallingConvention.Cdecl)]
        private static extern int eyemMatAbs(ref EyemImage tpImage);
        /// <summary>
        /// 图像颜色空间转换
        /// </summary>
        /// <param name="tpImage">图像</param>
        /// <param name="iCCodes">转换代码</param>
        /// <param name="tpDstImg">结果图像</param>
        /// <returns></returns>
        [DllImport("eyemLib.dll", CharSet = CharSet.None, CallingConvention = CallingConvention.Cdecl)]
        private static extern int eyemCvtColor(EyemImage tpImage, ColorConversionCodes iCCodes, ref EyemImage tpDstImg);
        /// <summary>
        /// 图像数据格式转换
        /// </summary>
        /// <param name="tpImage">图像</param>
        /// <param name="ccSubType">转换类型(uint8_t、int8_t、uint16_t、int16_t、int32_t、float_t、double_t)</param>
        /// <param name="alpha">乘值</param>
        /// <param name="beta">加值</param>
        /// <param name="tpDstImg">结果图像</param>
        /// <returns></returns>
        [DllImport("eyemLib.dll", CharSet = CharSet.None, CallingConvention = CallingConvention.Cdecl)]
        private static extern int eyemCvtType(EyemImage tpImage, string ccSubType, double alpha, double beta, ref EyemImage tpDstImg);
        /// <summary>
        /// 图像除运算
        /// </summary>
        /// <param name="tpImage1">除</param>
        /// <param name="tpImage2">被除</param>
        /// <param name="tpDstImg">结果图像</param>
        /// <returns></returns>
        [DllImport("eyemLib.dll", CharSet = CharSet.None, CallingConvention = CallingConvention.Cdecl)]
        private static extern int eyemMatDiv(EyemImage tpImage1, EyemImage tpImage2, ref EyemImage tpDstImg);
        #endregion

        #region  一维边缘测量

        //边缘测量
        [DllImport("eyemLib.dll", CharSet = CharSet.None, CallingConvention = CallingConvention.Cdecl)]
        private static extern int eyemEdge1dGenMeasureRect(EyemImage tpImage, EyemOcsDXY tpLineSt, EyemOcsDXY tpLineEd, int iWhRoi, string strSubType, int iTransition, double dSigma, double dAmpThresh, out MeasureHandle hObject);
        [DllImport("eyemLib.dll", CharSet = CharSet.None, CallingConvention = CallingConvention.Cdecl)]
        //边缘查找
        private static extern int eyemEdge1dGenPosRect(EyemImage tpImage, EyemOcsDXY tpLineSt, EyemOcsDXY tpLineEd, int iWhRoi, int iTransition, double dSigma, double dAmpThresh, out MeasureHandle hObject);
        /// <summary>
        /// 寻找边缘
        /// </summary>
        /// <param name="tpImage">图像</param>
        /// <param name="tpLineSt">卡尺起点</param>
        /// <param name="tpLineEd">卡尺终点</param>
        /// <param name="iWhRoi">卡尺宽度</param>
        /// <param name="nCalipers">卡尺数量</param>
        /// <param name="iSearchDirec">搜索方向（起点到终点方向的垂直方向）</param>
        /// <param name="dAmpThreshold">最小边缘幅度</param>
        /// <param name="ccTransition">灰度值过渡的类型以确定边缘'first','all', 'negative', 'positive'</param>
        /// <param name="hObject">结果</param>
        /// <returns></returns>
        [DllImport("eyemLib.dll", CharSet = CharSet.None, CallingConvention = CallingConvention.Cdecl)]
        private static extern int eyemEdge1dFindLine(EyemImage tpImage, EyemOcsDXY tpLineSt, EyemOcsDXY tpLineEd, int iWhRoi, int nCalipers, int iSearchDirec, double dAmpThreshold, string ccTransition, out MeasureHandle hObject);
        [DllImport("eyemLib.dll", CharSet = CharSet.None, CallingConvention = CallingConvention.Cdecl)]
        private static extern int eyemSkeleton(EyemImage tpImage);
        //边缘
        [DllImport("eyemLib.dll", CharSet = CharSet.None, CallingConvention = CallingConvention.Cdecl)]
        private static extern int eyemEdgesPixel(EyemImage tpImage, double dThreshold, out IntPtr hObject, out int ipNum, out EyemOcsDXY* hResults);
        //释放工具所使用句柄
        [DllImport("eyemLib.dll", CharSet = CharSet.None, CallingConvention = CallingConvention.Cdecl)]
        private static extern bool eyemEdge1dGenMeasureFree(IntPtr hObject);
        #endregion

        #region 稳健估计
        /// <summary>
        /// 鲁棒直线拟合
        /// </summary>
        /// <param name="iPtnNum">点数量</param>
        /// <param name="taPoint">点</param>
        /// <param name="iCalcMode">计算方式</param>
        /// <param name="dRobustCoef">鲁棒系数,如果采用预设定的值则设置为0</param>
        /// <param name="tpLine">直线</param>
        /// <returns></returns>
        [DllImport("eyemLib.dll", CharSet = CharSet.None, CallingConvention = CallingConvention.Cdecl)]
        private static extern int eyemRobustFitLine(int iPtnNum, IntPtr taPoint, int iCalcMode, double dRobustCoef, ref EyemOcsDABC tpLine);
        /// <summary>
        /// 直线拟合
        /// </summary>
        /// <param name="iPtnNum">点数量</param>
        /// <param name="taPoint">点</param>
        /// <param name="numToIgnore">忽略的点</param>
        /// <param name="tpLine">直线</param>
        /// <returns></returns>
        [DllImport("eyemLib.dll", CharSet = CharSet.None, CallingConvention = CallingConvention.Cdecl)]
        private static extern int eyemFitLine(int iPtnNum, IntPtr taPoint, int numToIgnore, ref EyemOcsDABC tpLine);
        /// <summary>
        /// RANSAC拟合圆
        /// </summary>
        /// <param name="iPtnNum">点数量</param>
        /// <param name="taPoint">点</param>
        /// <param name="dClippingFactor">消除异常值因子</param>
        /// <param name="tpLine">线</param>
        /// <returns></returns>
        [DllImport("eyemLib.dll", CharSet = CharSet.None, CallingConvention = CallingConvention.Cdecl)]
        private static extern int eyemFitLineRANSAC(int iPtnNum, IntPtr taPoint, double dClippingFactor, ref EyemOcsDABC tpLine);
        /// <summary>
        /// 鲁棒圆拟合
        /// </summary>
        /// <param name="iPtnNum">点数量</param>
        /// <param name="taPoint">点</param>
        /// <param name="iCalcMode">计算方式</param>
        /// <param name="dRobustCoef">鲁棒系数,如果采用预设定的值则设置为0</param>
        /// <param name="tpCircle">圆</param>
        /// <returns></returns>
        [DllImport("eyemLib.dll", CharSet = CharSet.None, CallingConvention = CallingConvention.Cdecl)]
        private static extern int eyemRobustFitCircle(int iPtnNum, IntPtr taPoint, int iCalcMode, double dRobustCoef, ref EyemOcsDXYR tpCircle);
        /// <summary>
        /// 圆拟合
        /// </summary>
        /// <param name="iPtnNum">点数量</param>
        /// <param name="taPoint">点</param>
        /// <param name="iCalcMode">计算方式</param>
        /// <param name="numToIgnore">忽略的点</param>
        /// <param name="RMS">rms误差</param>
        /// <param name="tpCircle">圆</param>
        /// <returns></returns>
        [DllImport("eyemLib.dll", CharSet = CharSet.None, CallingConvention = CallingConvention.Cdecl)]
        private static extern int eyemFitCircle(int iPtnNum, IntPtr taPoint, int numToIgnore, ref double dRMS, ref EyemOcsDXYR tpCircle);
        /// <summary>
        /// 鲁棒平面拟合
        /// </summary>
        /// <param name="iPtnNum">点数量</param>
        /// <param name="taPoint">点</param>
        /// <param name="iCalcMode">计算模式</param>
        /// <param name="dRobustCoef">鲁棒系数,如果采用预设定的值则设置为0</param>
        /// <param name="tpPlane">平面</param>
        /// <returns></returns>
        [DllImport("eyemLib.dll", CharSet = CharSet.None, CallingConvention = CallingConvention.Cdecl)]
        private static extern int eyemRobustFitPlane(int iPtnNum, IntPtr taPoint, int iCalcMode, double dRobustCoef, ref EyemOcsDABCD tpPlane);
        /// <summary>
        /// 刚性变换
        /// </summary>
        /// <param name="iPtnNum">点数量</param>
        /// <param name="taPointA">A坐标系中的点</param>
        /// <param name="taPointB">B坐标系中的点</param>
        /// <param name="tpResult">结果</param>
        /// <returns></returns>
        [DllImport("eyemLib.dll", CharSet = CharSet.None, CallingConvention = CallingConvention.Cdecl)]
        private static extern int eyemFitRTMatrix(int iPtnNum, IntPtr taPointA, IntPtr taPointB, ref EyemRigidMatrix tpResult);

        /// <summary>
        /// 鲁棒椭圆拟合
        /// </summary>
        /// <param name="iPtnNum">点数量</param>
        /// <param name="taPoint">点</param>
        /// <param name="iCalcMode">计算方式</param>
        /// <param name="dRobustCoef">鲁棒系数,如果采用预设定的值则设置为0</param>
        /// <param name="tpEllipse">椭圆</param>
        /// <returns></returns>
        [DllImport("eyemLib.dll", CharSet = CharSet.None, CallingConvention = CallingConvention.Cdecl)]
        private static extern int eyemRobustFitEllipse(int iPtnNum, IntPtr taPoint, int iCalcMode, double dRobustCoef, ref EyemOcsDXYLSQ tpEllipse);
        #endregion

        #region 二维几何计算

        /// <summary>
        /// 根据两个点计算直线
        /// </summary>
        /// <param name="tpPoint1">点一</param>
        /// <param name="tpPoint2">点二</param>
        /// <param name="tpLine">直线</param>
        /// <returns></returns>
        [DllImport("eyemLib.dll", CharSet = CharSet.None, CallingConvention = CallingConvention.Cdecl)]
        private static extern int eyemClp2dLineTwoPoints(EyemOcsDXY tpPoint1, EyemOcsDXY tpPoint2, ref EyemOcsDABC tpLine);

        /// <summary>
        /// 计算两直线交点
        /// </summary>
        /// <param name="tpLine1">线一</param>
        /// <param name="tpLine2">线二</param>
        /// <param name="taPoint">交点</param>
        /// <returns></returns>
        [DllImport("eyemLib.dll", CharSet = CharSet.None, CallingConvention = CallingConvention.Cdecl)]
        private static extern int eyemClp2dIntersectionTwoLines(EyemOcsDABC tpLine1, EyemOcsDABC tpLine2, ref EyemOcsDXY tpPoint);

        /// <summary>
        /// 计算两点的垂直平分线
        /// </summary>
        /// <param name="tpPoint1">点一</param>
        /// <param name="tpPoint2">点二</param>
        /// <param name="tpLine">线</param>
        /// <returns></returns>
        [DllImport("eyemLib.dll", CharSet = CharSet.None, CallingConvention = CallingConvention.Cdecl)]
        private static extern int eyemClp2dMidperpendicularTwoPoints(EyemOcsDXY tpPoint1, EyemOcsDXY tpPoint2, ref EyemOcsDABC tpLine);

        /// <summary>
        /// 过一点作已知直线的垂线
        /// </summary>
        /// <param name="tpPoint"></param>
        /// <param name="tpLine"></param>
        /// <param name="tpVertical"></param>
        /// <returns></returns>
        [DllImport("eyemLib.dll", CharSet = CharSet.None, CallingConvention = CallingConvention.Cdecl)]
        private static extern int eyemClp2dVerticalLinePointAndLine(EyemOcsDXY tpPoint, EyemOcsDABC tpLine, ref EyemOcsDABC tpVertical);

        /// <summary>
        /// 指定点和斜率计算直线
        /// </summary>
        /// <param name="tpPoint">点</param>
        /// <param name="dSlope">斜率（角度）</param>
        /// <param name="tpLine">直线</param>
        [DllImport("eyemLib.dll", CharSet = CharSet.None, CallingConvention = CallingConvention.Cdecl)]
        private static extern void eyemClp2dLinePointAndSlope(EyemOcsDXY tpPoint, double dSlope, ref EyemOcsDABC tpLine);

        /// <summary>
        /// 计算两直线角度(锐角)
        /// </summary>
        /// <param name="tpLine1">直线一</param>
        /// <param name="tpLine2">直线二</param>
        /// <param name="dpAngle">角度</param>
        /// <returns></returns>
        [DllImport("eyemLib.dll", CharSet = CharSet.None, CallingConvention = CallingConvention.Cdecl)]
        private static extern int eyemClp2dAngleTwoLines(EyemOcsDABC tpLine1, EyemOcsDABC tpLine2, ref double dpAngle);

        /// <summary>
        /// 两条直线的角平分线
        /// </summary>
        /// <param name="tpLine1">直线一</param>
        /// <param name="tpLine2">直线二</param>
        /// <param name="tpLineC">直线</param>
        /// <returns></returns>
        [DllImport("eyemLib.dll", CharSet = CharSet.None, CallingConvention = CallingConvention.Cdecl)]
        private static extern int eyemClp2dCenterLineOfTwoLines(EyemOcsDABC tpLine1, EyemOcsDABC tpLine2, ref EyemOcsDABC tpLineC);

        /// <summary>
        /// 计算点到直线距离
        /// </summary>
        /// <param name="tpPoint">点</param>
        /// <param name="tpLine">直线</param>
        /// <param name="dpDist">距离</param>
        /// <returns></returns>
        [DllImport("eyemLib.dll", CharSet = CharSet.None, CallingConvention = CallingConvention.Cdecl)]
        private static extern int eyemClp2dDistancePointToLine(EyemOcsDXY tpPoint, EyemOcsDABC tpLine, ref double dpDist);

        /// <summary>
        /// 直线平移
        /// </summary>
        /// <param name="tpSrcL">直线</param>
        /// <param name="tpTrans">点</param>
        /// <param name="tpDstL">移动后的直线</param>
        /// <returns></returns>
        [DllImport("eyemLib.dll", CharSet = CharSet.None, CallingConvention = CallingConvention.Cdecl)]
        private static extern int eyemClp2dTranslationOfLine(EyemOcsDABC tpSrcL, EyemOcsDXY tpTrans, ref EyemOcsDABC tpDstL);

        /// <summary>
        /// 计算三角形面积
        /// </summary>
        /// <param name="tpPoint1">点1</param>
        /// <param name="tpPoint2">点2</param>
        /// <param name="tpPoint3">点3</param>
        /// <param name="dpArea">面积</param>
        [DllImport("eyemLib.dll", CharSet = CharSet.None, CallingConvention = CallingConvention.Cdecl)]
        private static extern void eyemClp2dAreaTriangle(EyemOcsDXY tpPoint1, EyemOcsDXY tpPoint2, EyemOcsDXY tpPoint3, ref double dpArea);

        /// <summary>
        /// 根据三个点计算圆
        /// </summary>
        /// <param name="tpPoint1">点1</param>
        /// <param name="tpPoint2">点2</param>
        /// <param name="tpPoint3">点3</param>
        /// <param name="tpCircle">圆</param>
        /// <returns></returns>
        [DllImport("eyemLib.dll", CharSet = CharSet.None, CallingConvention = CallingConvention.Cdecl)]
        private static extern int eyemClp2dCircleThreePoints(EyemOcsDXY tpPoint1, EyemOcsDXY tpPoint2, EyemOcsDXY tpPoint3, ref EyemOcsDXYR tpCircle);

        /// <summary>
        /// 直线与圆交点
        /// </summary>
        /// <param name="tpLine"></param>
        /// <param name="tpCircle"></param>
        /// <param name="tpPoint1"></param>
        /// <param name="tpPoint2"></param>
        /// <returns></returns>
        [DllImport("eyemLib.dll", CharSet = CharSet.None, CallingConvention = CallingConvention.Cdecl)]
        private static extern int eyemClp2dIntersectionLineAndCircle(EyemOcsDABC tpLine, EyemOcsDXYR tpCircle, ref EyemOcsDXY tpPoint1, ref EyemOcsDXY tpPoint2);

        /// <summary>
        /// 点到圆的切线及切点
        /// </summary>
        /// <param name="tpPoint">点</param>
        /// <param name="tpCircle">圆</param>
        /// <param name="tpTangent1">切线一</param>
        /// <param name="tpContact1">切点一</param>
        /// <param name="tpTangent2">切线二</param>
        /// <param name="tpContact2">切点二</param>
        /// <returns></returns>
        [DllImport("eyemLib.dll", CharSet = CharSet.None, CallingConvention = CallingConvention.Cdecl)]
        private static extern int eyemClp2dTangentPointToCircle(EyemOcsDXY tpPoint, EyemOcsDXYR tpCircle, ref EyemOcsDABC tpTangent1, ref EyemOcsDXY tpContact1, ref EyemOcsDABC tpTangent2, ref EyemOcsDXY tpContact2);
        #endregion

        #region 深度学习目标检测器
        /// <summary>
        /// 初始化检测器
        /// </summary>
        /// <param name="detectorConfigPath">配置文件</param>
        /// <param name="detectorModelPath">模型文件</param>
        /// <returns></returns>
        [DllImport("eyemLib.dll", CharSet = CharSet.None, CallingConvention = CallingConvention.Cdecl)]
        private static extern int eyemInitNNDetector(string detectorConfigPath, string detectorModelPath);

        /// <summary>
        /// 目标检测器
        /// </summary>
        /// <param name="tpImage">输入图像</param>
        /// <returns></returns>
        [DllImport("eyemLib.dll", CharSet = CharSet.None, CallingConvention = CallingConvention.Cdecl)]
        private static extern int eyemNNDetector(EyemImage tpImage, out int ipNum, ref BboxContainer container);
        #endregion

        #region 项目
        //普通器件(仍采用旧的算法)
        [DllImport("eyemLib.dll", CharSet = CharSet.None, CallingConvention = CallingConvention.Cdecl)]
        private static extern int eyemCountObject(EyemImage tpImage, EyemRect tpRoi, string fileName, [MarshalAs(UnmanagedType.LPArray)]int[] ipReelNum, out EyemImage tpDstImg);
        //异型器件(新版本新算法)
        [DllImport("eyemLib.dll", CharSet = CharSet.None, CallingConvention = CallingConvention.Cdecl)]
        private static extern int eyemCountObjectIrregularParts(EyemImage tpImage, EyemRect tpRoi, string fileName, string strType, [MarshalAs(UnmanagedType.LPArray)]int[] ipReelNum, out EyemImage tpDstImg);
        //普通器件(新版本新算法)
        [DllImport("eyemLib.dll", CharSet = CharSet.None, CallingConvention = CallingConvention.Cdecl)]
        private static extern int eyemCountObjectE(EyemImage tpImage, EyemRect tpRoi, string fileName, [MarshalAs(UnmanagedType.LPArray)]int[] ipReelNum, out EyemImage tpDstImg);
        //异型器件(新版本模板匹配)
        [DllImport("eyemLib.dll", CharSet = CharSet.None, CallingConvention = CallingConvention.Cdecl)]
        private static extern int eyemCountObjectIrregularPartsE(EyemImage tpImage, EyemRect tpRoi, string fileName, string ccTplName, IntPtr hModelID, [MarshalAs(UnmanagedType.LPArray)]int[] ipReelNum, out EyemImage tpDstImg);
        //创建模板匹配模型
        [DllImport("eyemLib.dll", CharSet = CharSet.None, CallingConvention = CallingConvention.Cdecl)]
        private static extern int eyemCreateTemplateModel(EyemImage tpImage, EyemRect tpRoi, double dMinScore, string ccTplName);
        //获取模板图像
        [DllImport("eyemLib.dll", CharSet = CharSet.None, CallingConvention = CallingConvention.Cdecl)]
        private static extern int eyemAchvTemplateImage(EyemImage tpImage, EyemRect tpRoi, out EyemImage tpDstImg);
        //选取最匹配模板
        [DllImport("eyemLib.dll", CharSet = CharSet.None, CallingConvention = CallingConvention.Cdecl)]
        private static extern int eyemMatchTemplateModel(EyemImage tpImage, IntPtr hModelID, ref string lpszTplName);
        //加载模板到内存
        [DllImport("eyemLib.dll", CharSet = CharSet.None, CallingConvention = CallingConvention.Cdecl)]
        private static extern int eyemInitModel(string ccTplName, out IntPtr hModelID);
        //通过名称获取模板
        [DllImport("eyemLib.dll", CharSet = CharSet.None, CallingConvention = CallingConvention.Cdecl)]
        private static extern int eyemAchvModelByName(string ccTplName, IntPtr hModelID, ref EyemModelID tpModelID);
        //插入模板
        [DllImport("eyemLib.dll", CharSet = CharSet.None, CallingConvention = CallingConvention.Cdecl)]
        private static extern int eyemInsertModel(IntPtr hModelID, string ccTplName);
        //通过名称移除模板
        [DllImport("eyemLib.dll", CharSet = CharSet.None, CallingConvention = CallingConvention.Cdecl)]
        private static extern int eyemRemoveModelByName(IntPtr hModelID, string ccTplName);
        //释放模板内存
        [DllImport("eyemLib.dll", CharSet = CharSet.None, CallingConvention = CallingConvention.Cdecl)]
        private static extern int eyemReleaseModel(ref IntPtr hModelID);
        //读码程序
        [DllImport("eyemLib.dll", CharSet = CharSet.None, CallingConvention = CallingConvention.Cdecl)]
        private static extern int eyemDetectAndDecode(EyemImage tpImage, EyemRect tpRoi, string fileName, string strCodeType, out DataCodeHandle hObject, out EyemBarCode* tpResults, out int ipNum, bool bUseNiBlack, int iBlockSize, int iRangeC, int iSymbolMin, int iSymbolMax, double dScaleUpAndDown = 0.5, double dToleErr = 0.5, double dMinorStep = 1.0);
        //释放解码句柄
        [DllImport("eyemLib.dll", CharSet = CharSet.None, CallingConvention = CallingConvention.Cdecl)]
        private static extern bool eyemDetectAndDecodeFree(IntPtr hObject);
        //基于深度学习读码程序（仅支持QR、DataMatrix）
        [DllImport("eyemLib.dll", CharSet = CharSet.None, CallingConvention = CallingConvention.Cdecl)]
        private static extern int eyemDetectAndDecodeUseNN(EyemImage tpImage, EyemRect tpRoi, out DataCodeHandle hObject, out EyemBarCode* tpResults, out int ipNum, out EyemImage tpDstImg);
        //基于深度学习一维码读码程序（）
        [DllImport("eyemLib.dll", CharSet = CharSet.None, CallingConvention = CallingConvention.Cdecl)]
        private static extern int eyemDetectAndDecodeBarcodeUseNN(EyemImage tpImage, EyemRect tpRoi, out DataCodeHandle hObject, out EyemBarCode* tpResults, out int ipNum, out EyemImage tpDstImg);
        //加载模型配置文件
        [DllImport("eyemLib.dll", CharSet = CharSet.None, CallingConvention = CallingConvention.Cdecl)]
        private static extern int eyemInitNNDataCodeModel(string detectorConfigPath, string detectorModelPath, string superResolutionConfigPath, string superResolutionModelPath);
        //背景变化跟踪
        [DllImport("eyemLib.dll", CharSet = CharSet.None, CallingConvention = CallingConvention.Cdecl)]
        private static extern int eyemTrackFeature(EyemImage tpRefImg, EyemImage tpNextImg, IntPtr tpArray, int iArraySize, IntPtr ipResults, out EyemImage tpDstImg);
        //插件机
        [DllImport("eyemLib.dll", CharSet = CharSet.None, CallingConvention = CallingConvention.Cdecl)]
        private static extern int eyemAOIForTSAV(EyemImage tpRefImg, EyemImage tpNextImg, IntPtr tpArray, int iArraySize);
        //跳过程序执行
        [DllImport("eyemLib.dll", CharSet = CharSet.None, CallingConvention = CallingConvention.Cdecl)]
        private static extern int setSkipProcessID(int pid);
        //圆形mark点定位
        [DllImport("eyemLib.dll", CharSet = CharSet.None, CallingConvention = CallingConvention.Cdecl)]
        private static extern int eyemMarkerTracing(EyemImage tpImage, double dThreshold, ref EyemOcsFXYR tpCircle, bool bHighAccuracy = false);
        //多功能工具
        [DllImport("eyemLib.dll", CharSet = CharSet.None, CallingConvention = CallingConvention.Cdecl)]
        private static extern int eyemMulFuncTool(EyemImage tpImage, EyemRect tpRoi, string funcName, double dThreshold, int iNumToIgnore, ref EyemOcsFXYR tpCircle, out EyemImage tpDstImg);
        #endregion

        #region 测试专用接口
        //测试接口
        [DllImport("eyemLib.dll", CharSet = CharSet.None, CallingConvention = CallingConvention.Cdecl)]
        private static extern int eyemLibImpl(EyemImage tpImage, out EyemImage tpDstImg);

        #endregion

        #region 日志功能
        // 日志回调
        public delegate void TCallBack(string msg);
        public static TCallBack sld = new TCallBack(TLogCallback);

        public static event TCallBack OnNewLogCallback;

        public static void TLogCallback(string msg)
        {
            OnNewLogCallback?.Invoke(msg);
        }

        public static log4cpp.LogManager logcpp = null;

        public static void Init()
        {
            logcpp = new log4cpp.LogManager("D:\\日志\\", "_运行日志", log4cpp.GenerateMode.ByEveryDay);

            setLogCallback(sld);

            OnNewLogCallback += new TCallBack(EyemLib_OnNewLogCallback);

            eyemInitNNDataCodeModel(".\\darknet\\detect-tiny.cfg", ".\\darknet\\detect-tiny.weights", ".\\darknet\\sr.prototxt", ".\\darknet\\sr.caffemodel");
        }

        public static void Free()
        {
            setLogCallback(null); sld = null;
        }

        //记录日志
        private static void EyemLib_OnNewLogCallback(string msg)
        {
            //算法里输出的一切日志都会在这里
            logcpp.WriteLog("[" + Thread.CurrentThread.ManagedThreadId.ToString("X16") + "]" + msg);
        }

        //设置跳过程序执行
        public static void setSkipProcess(int pid)
        {
            setSkipProcessID(pid);
        }

        #endregion

        public static void eyemReadImageTool(string fileName)
        {
            EyemImage image;
            EyemImage tpDstImg = new EyemImage();
            //EyemOcsFXYR tpCircle = new EyemOcsFXYR();
            //int flag = eyemImageReadRaw(fileName, 3072, 3072, 2, out ucpImage);
            int flag = eyemImageRead(fileName, -1, out image);
            if (flag != 0)
            {
                Console.WriteLine("读图失败！");
                return;
            }

            Stopwatch sw = new Stopwatch();
            sw.Restart();

            //EyemImage image1 = new EyemImage(); EyemImage image2 = new EyemImage();
            //flag = eyemMatMalloc(512, 512, 1, "uint8_t", out image1);
            //flag = eyemMatMalloc(512, 512, 1, "uint8_t", out image2);

            //flag = eyemMatCopy(ref image2, image1);

            //flag = eyemMatAdd(image1, image2, ref tpDstImg);

            //flag = eyemMatSub(image1, image2, ref tpDstImg);

            //flag = eyemMatAbs(ref tpDstImg);

            //flag = eyemCvtType(tpDstImg, "uint16_t", 1.0, 128, ref tpDstImg);

            //flag = eyemCvtColor(tpDstImg, ColorConversionCodes.COLOR_GRAY2BGR, ref tpDstImg);

            //flag = eyemLibImpl(image, out tpDstImg);


            //flag = eyemMarkerTracing(image, 130, ref tpCircle);


            #region Test Blob
            //int ipNum;
            //BlobHandle hObject;
            //EyemBinBlob* eyemBlob;
            //eyemBinBlob(image, out hObject, 100, out eyemBlob, out ipNum, out tpDstImg);
            //for (int i = 0; i < ipNum; i++)
            //{
            //    //tpResult.Add(eyemBlob[i]);
            //}
            //hObject.Dispose();
            #endregion

            #region Test 1DEdge
            EyemOcsDXY tpLineSt = new EyemOcsDXY();
            tpLineSt.dX = 671;
            tpLineSt.dY = 718;
            EyemOcsDXY tpLineEd = new EyemOcsDXY();
            tpLineEd.dX = 858;
            tpLineEd.dY = 716;

            MeasureHandle hObject;
            //eyemEdge1dGenMeasureRect(image, tpLineSt, tpLineEd, 10, "all", 0, 0.9, 30, out hObject);
            //eyemEdge1dGenPosRect(image, tpLineSt, tpLineEd, 50, 0, 0.9, 30, out hObject);
            sw.Restart();
            eyemEdge1dFindLine(image, tpLineSt, tpLineEd, 25, 35, -1, 15, "negative", out hObject);
            sw.Stop();
            Console.WriteLine("时间：" + sw.ElapsedMilliseconds.ToString());
            return;
            //hObject.Dispose();
            #endregion

            #region  Test Matrix

            //double[] dpData = new double[9] { 1, 0, 1, 2, 2, 2, 3, 3, 3 };
            //IntPtr vpA = eyemMatMallocMatrix(3, 3, dpData);

            //eyemMatZero(vpA);

            //double[] dpData2 = new double[9] { 1, 0, 1, 2, 0, 2, 3, 0, 3 };

            //IntPtr vpB = eyemMatMallocMatrix(3, 3, dpData);

            //IntPtr vpC = IntPtr.Zero;
            //eyemMatAdd(vpA, vpB, vpC);

            //eyemMatFreeMatrix(vpA);

            //eyemMatFreeMatrix(vpB);


            #endregion

            #region Test Binary
            //eyemBinThreshold(image, 0, 130, 255, out tpDstImg);
            //eyemBinAutoThreshold(ucpImage, 1.8, 1, 6, out tpDstImg);
            //eyemSkeleton(ucpImage);
            //eyemBinBinaryImage(ucpImage, 0, 3, out tpDtImg);
            //eyemBinDynThreshold(image, image, 2.5, 1, out tpDstImg);
            //eyemBinNiBlack(image, 0, 5, 0.5, 3, 11, out tpDstImg);
            #endregion

            #region Test Sauvola

            //eyemBinNiBlack(ucpImage, out tpDstImg, 0, 5, 0.001, 3, 5);

            #endregion

            #region Test Edge
            //int iCount; IntPtr hHandle; EyemOcsDXY* hResults;
            //eyemEdgesPixel(image, 45, out hHandle, out iCount, out hResults);
            #endregion

            #region Test RobustFitLine

            //EyemOcsDXY taPoint = new EyemOcsDXY();
            //List<EyemOcsDXY> taPoints = new List<EyemOcsDXY>();

            //x^2/4+y^2/9=1

            //for (double i = -2.0; i <= 2.0; i += 0.1)
            //{
            //    taPoint.dX = i;
            //    taPoint.dY = 3 * Math.Sqrt(1 - Math.Pow(i, 2) / 4);
            //    taPoints.Add(taPoint);

            //    taPoint.dX = i;
            //    taPoint.dY = -3 * Math.Sqrt(1 - Math.Pow(i, 2) / 4);
            //    taPoints.Add(taPoint);
            //}

            //taPoint.dX = 0;
            //taPoint.dY = 2;
            //taPoints.Add(taPoint);

            //taPoint.dX = 2;
            //taPoint.dY = 1;
            //taPoints.Add(taPoint);

            //taPoint.dX = 1;
            //taPoint.dY = -1;
            //taPoints.Add(taPoint);

            //taPoint.dX = -1;
            //taPoint.dY = -2;
            //taPoints.Add(taPoint);

            //taPoint.dX = -3;
            //taPoint.dY = 1;
            //taPoints.Add(taPoint);

            //taPoint.dX = -1;
            //taPoint.dY = -1;
            //taPoints.Add(taPoint);


            //EyemOcsDXYZ taPoint = new EyemOcsDXYZ();
            //List<EyemOcsDXYZ> taPoints = new List<EyemOcsDXYZ>();
            //for (int x = 0; x < 6; x++)
            //{
            //    for (int y = 0; y < 6; y++)
            //    {
            //        taPoint.dX = x;
            //        taPoint.dY = y;
            //        taPoint.dZ = x + 2 * y + 5;
            //        taPoints.Add(taPoint);
            //    }
            //}

            //taPoint.dX = 10;
            //taPoint.dY = 10;
            //taPoint.dZ = 10;
            //taPoints.Add(taPoint);

            //taPoint.dX = 5;
            //taPoint.dY = 5;
            //taPoint.dZ = 12;
            //taPoints.Add(taPoint);

            //taPoint.dX = 7;
            //taPoint.dY = 7;
            //taPoint.dZ = -2;
            //taPoints.Add(taPoint);

            //taPoint.dX = 2;
            //taPoint.dY = 2;
            //taPoint.dZ = -4;
            //taPoints.Add(taPoint);



            //EyemOcsDABCD tpPlane = new EyemOcsDABCD();
            //IntPtr tpPoint = eyemStructArray2IntPtr(taPoints.ToArray());
            ////eyemRobustFitPlane(taPoints.Count, tpPoint, 6, 0, ref tpPlane);
            //EyemOcsDXYLSQ tpEllipse = new EyemOcsDXYLSQ();
            //eyemRobustFitEllipse(taPoints.Count, tpPoint, 6, 0, ref tpEllipse);

            //return;
            //eyemFitLine(taPoints.Count, tpPoint, 10, ref tpLine);
            //eyemRobustFitLine(taPoints.Count, tpPoint, 2, 0, ref tpLine);
            //eyemFitLineRANSAC(taPoints.Count, tpPoint, 5, ref tpLine);
            //EyemOcsDXYR tpCircle = new EyemOcsDXYR(); double dRMS = 0.0;
            //eyemRobustFitCircle(taPoints.Count, tpPoint, 6, 0, ref tpCircle);
            //eyemFitCircle(taPoints.Count, tpPoint, 15, ref dRMS, ref tpCircle);

            //EyemOcsDABC tpLine2 = new EyemOcsDABC();
            //EyemOcsDXY tpPoint1 = new EyemOcsDXY();
            //tpPoint1.dX = -2; tpPoint1.dY = 0;
            //EyemOcsDXY tpPoint2 = new EyemOcsDXY();
            //tpPoint2.dX = 2; tpPoint2.dY = 0;
            //eyemClp2dLineTwoPoints(tpPoint1, tpPoint2, ref tpLine2);

            //EyemOcsDXY taPointx = new EyemOcsDXY();
            //taPointx.dX = -4; taPointx.dY = 4;

            //EyemOcsDABC tpVertic = new EyemOcsDABC();
            //eyemClp2dLinePointAndSlope(taPointx, 45, ref tpVertic);

            //EyemOcsDXY tpPoint1 = new EyemOcsDXY(); EyemOcsDXY tpPoint2 = new EyemOcsDXY(); EyemOcsDXYR tpCircle2 = new EyemOcsDXYR();

            //EyemOcsDABC tpTangent1 = new EyemOcsDABC(); EyemOcsDABC tpTangent2 = new EyemOcsDABC();

            //tpCircle2.dX = 2; tpCircle2.dY = -5; tpCircle2.dR = 3;
            //eyemClp2dTangentPointToCircle(taPointx, tpCircle2, ref tpTangent1, ref tpPoint1, ref tpTangent2, ref tpPoint2);


            //eyemClp2dIntersectionLineAndCircle(tpVertic, tpCircle2, ref tpPoint1, ref tpPoint2);

            //EyemOcsDABC tpVertic2 = new EyemOcsDABC();
            //eyemClp2dLinePointAndSlope(taPointx, 45.0, ref tpVertic2);

            //EyemOcsDABC tpVerticC = new EyemOcsDABC();
            //eyemClp2dCenterLineOfTwoLines(tpVertic, tpVertic2, ref tpVerticC);

            //EyemOcsDXY taPointy = new EyemOcsDXY();
            //eyemClp2dIntersectionTwoLines(tpLine, tpVertic2, ref taPointy);

            //Marshal.FreeHGlobal(tpPoint);


            //return;
            #endregion

            #region Test WriteImage
            //eyemImageWrite("D:\\Matlab测试图像\\xxx.bmp", tpDstImg);
            #endregion

            #region Test NNDetector
            //eyemInitNNDetector(".\\darknet\\detect-tiny-label.cfg", ".\\darknet\\detect-tiny-label.weights");

            //int ipNum = 0;
            //BboxContainer container = new BboxContainer();
            //eyemNNDetector(image, out ipNum, ref container);
            #endregion


            EyemRect tpRoi = new EyemRect();
            tpRoi.iXs = 200; tpRoi.iYs = 150;
            tpRoi.iWidth = image.iWidth - 400;
            tpRoi.iHeight = image.iHeight - 300;

            //flag = eyemMulFuncTool(image, tpRoi, "__func1", 65, 75, ref tpCircle, out tpDstImg);

            int[] ipReelNum = new int[4];
            string file = fileName.Split(new string[] { "\\" }, StringSplitOptions.RemoveEmptyEntries)[2];

            //获取用于制作模板的图像
            //flag = eyemAchvTemplateImage(image, tpRoi, out tpDstImg);

            //Bitmap bitmap = eyemCvtToBitmap(tpDstImg);
            //if (bitmap != null)
            //{
            //    bitmap.Save(System.Windows.Forms.Application.StartupPath + "\\ResOut\\" + file);
            //}

            ////创建模板匹配模型
            //EyemRect tpRoi2 = new EyemRect();
            //tpRoi2.iXs = 0; tpRoi2.iYs = 0;
            //tpRoi2.iWidth = image.iWidth;
            //tpRoi2.iHeight = image.iHeight;

            //double matchDeg = 0.75;
            //flag = eyemCreateTemplateModel(image, tpRoi2, matchDeg, "D:\\模板文件\\" + file.Replace(".png", ".tpl"));

            ////加载模板到内存
            //IntPtr hModelID = IntPtr.Zero;

            //flag = eyemInitModel("D:\\模板文件", out hModelID);

            //string selectModel = "";
            //flag = eyemMatchTemplateModel(tpDstImg, hModelID, ref selectModel);

            ////插入模板
            //flag = eyemInsertModel(hModelID, "D:\\模板文件及图像\\df871193-6632-48f9-abfe-540c3fc49c3f.tpl");

            //string[] tpModels = selectModel.Split(new char[] { ',' }, StringSplitOptions.RemoveEmptyEntries);

            //if (tpModels.Length <= 0)
            //{
            //    logcpp.WriteLog("选择模板少于0");
            //    return;
            //}

            ////根据名称获取模板
            //EyemModelID tpModelID = new EyemModelID();
            //eyemAchvModelByName(tpModels[0], hModelID, ref tpModelID);

            //EyemImage tpModeImg = new EyemImage();
            //tpModeImg.iChannels = 1; tpModeImg.iDepth = 0;
            //tpModeImg.iWidth = tpModelID.iWidth; tpModeImg.iHeight = tpModelID.iHeight; tpModeImg.vpImage = tpModelID.vpImage;

            //Bitmap bitmap = eyemCvtToBitmap(tpModeImg);

            //if (bitmap != null)
            //{
            //    bitmap.Save(System.Windows.Forms.Application.StartupPath + "\\ResOut\\" + file);
            //}

            //最好释放掉，如果对象供其他接口使用要先释放
            //eyemImageFree(ref tpDstImg);

            //"IP_SMALL_PARTS","IP_LARGE_PARTS","IP_LONG_PARTS","IP_LOWCONTRAST_PARTS"
            //eyemCountObject(image, tpRoi, file.Replace(".png", ""), ipReelNum, out tpDstImg);
            //eyemCountObjectIrregularParts(image, tpRoi, file.Replace(".png", ""), "IP_LARGE_PARTS", ipReelNum, out tpDstImg);
            //eyemCountObjectE(image, tpRoi, fileName, ipReelNum, out tpDstImg);
            //eyemCountObjectIrregularPartsE(image, tpRoi, file.Replace(".png", ""), tpModels[0], hModelID, ipReelNum, out tpDstImg);
            //eyemCountObjectIrregularPartsE(image, tpRoi, file.Replace(".png", ""), "D:\\模板文件\\" + /*file.Replace(".png", ".tpl")*/"74d571ed-9fd4-4959-85dd-3195261e4b48.tpl", ref pNumObj, out tpDstImg);

            //移除模板
            //flag = eyemRemoveModelByName(hModelID, "D:\\模板文件及图像\\df871193-6632-48f9-abfe-540c3fc49c3f.tpl");

            Bitmap bitmap = eyemCvtToBitmap(tpDstImg);
            if (bitmap != null)
            {
                //bitmap.Save("D:\\ResOut\\" + file);
                bitmap.Save(System.Windows.Forms.Application.StartupPath + "\\ResOut\\" + file);
            }

            //< 解码测试
            //int ipNum; EyemBarCode* tpResults;
            //DataCodeHandle hObject;
            //int iRes = eyemDetectAndDecode(image, tpRoi, file.Replace(".png", ""), "QR_CODE|DATA_MATRIX", out hObject, out tpResults, out ipNum, false, 11, 5, 128, 256);
            //for (int i = 0; i < ipNum; i++)
            //{
            //    Console.WriteLine("类型：" + Marshal.PtrToStringAnsi(tpResults[i].hType) + "；坐标" + "[" + tpResults[i].iCenterX.ToString() + "," + tpResults[i].iCenterY.ToString() + "]" + "；角度：" + tpResults[i].dAngle.ToString("F4") + "," + "；内容：" + Marshal.PtrToStringAnsi(tpResults[i].hText) + "");
            //    Marshal.FreeCoTaskMem(tpResults[i].hText); Marshal.FreeCoTaskMem(tpResults[i].hType);
            //}
            //hObject.Dispose();
            //flag = eyemDetectAndDecodeUseNN(image, tpRoi, out hObject, out tpResults, out ipNum, out tpDstImg);
            //flag = eyemDetectAndDecodeBarcodeUseNN(image, tpRoi, out hObject, out tpResults, out ipNum, out tpDstImg);

            string strReelNum = "";
            //for (int i = 0; i < 4; i++)
            //{
            //    strReelNum += ipReelNum[i].ToString() + ",";
            //}

            sw.Stop();
            Console.WriteLine(file + "--->" + "耗时：" + sw.ElapsedMilliseconds.ToString() + "ms" + "，结果：" + strReelNum);

            //Bitmap bitmap = eyemCvtToBitmap(tpDstImg);
            //if (bitmap != null)
            //{
            //    bitmap.Save("D:\\ResOut\\" + file);
            //}
            //for (int i = 0; i < ipNum; i++)
            //{
            //    Console.WriteLine("类型：" + Marshal.PtrToStringAnsi(tpResults[i].hType) + "；坐标" + "[" + tpResults[i].iCenterX.ToString() + "," + tpResults[i].iCenterY.ToString() + "]" + "；角度：" + tpResults[i].dAngle.ToString("F4") + "," + "；内容：" + Marshal.PtrToStringAnsi(tpResults[i].hText) + "");
            //    Marshal.FreeCoTaskMem(tpResults[i].hText); Marshal.FreeCoTaskMem(tpResults[i].hType);
            //}
            //hObject.Dispose();

            //在关闭程序时释放
            //eyemReleaseModel(ref hModelID);
            //free image
            eyemImageFree(ref tpDstImg);
            eyemImageFree(ref image);
        }

        public static void eyemReadImageToolE(string fileName, IntPtr hModelID)
        {
            Stopwatch sw = new Stopwatch();
            sw.Restart();

            EyemImage image;
            EyemImage tpDstImg = new EyemImage();

            int flag = eyemImageRead(fileName, -1, out image);
            if (flag != 0)
            {
                Console.WriteLine("读图失败！");
                return;
            }

            EyemRect tpRoi = new EyemRect();
            tpRoi.iXs = 50; tpRoi.iYs = 50;
            tpRoi.iWidth = image.iWidth - 100;
            tpRoi.iHeight = image.iHeight - 100;

            //
            int[] pNumObj = new int[4];
            string file = fileName.Split(new string[] { "\\" }, StringSplitOptions.RemoveEmptyEntries)[2];

            //获取用于制作模板的图像
            //flag = eyemAchvTemplateImage(image, tpRoi, out tpDstImg);

            //测试插入模板
            //eyemInsertModel(hModelID, "D:\\模板文件及图像\\df871193-6632-48f9-abfe-540c3fc49c3f.tpl");

            ////测试获取模板
            //EyemModelID tpModelID0 = new EyemModelID();
            //eyemAchvModelByName("D:\\模板文件及图像\\df871193-6632-48f9-abfe-540c3fc49c3f.tpl", hModelID, ref tpModelID0);

            string selectModel = "";
            flag = eyemMatchTemplateModel(tpDstImg, hModelID, ref selectModel);

            //根据名称获取模板
            EyemModelID tpModelID = new EyemModelID();
            eyemAchvModelByName(selectModel.Split(new char[] { ',' }, StringSplitOptions.RemoveEmptyEntries)[0], hModelID, ref tpModelID);

            EyemImage tpModeImg = new EyemImage();
            tpModeImg.iChannels = 1; tpModeImg.iDepth = 0;
            tpModeImg.iWidth = tpModelID.iWidth; tpModeImg.iHeight = tpModelID.iHeight; tpModeImg.vpImage = tpModelID.vpImage;

            string str = Marshal.PtrToStringAnsi(tpModelID.lpszName);

            Bitmap bitmap = eyemCvtToBitmap(tpModeImg);

            bitmap.Dispose();

            //if (bitmap != null)
            //{
            //    bitmap.Save(System.Windows.Forms.Application.StartupPath + "\\ResOut\\" + file);
            //}

            //最好释放掉，如果对象供其他接口使用要先释放
            eyemImageFree(ref tpDstImg);

            //点料
            eyemCountObjectIrregularPartsE(image, tpRoi, file.Replace(".png", ""), selectModel.Split(new char[] { ',' }, StringSplitOptions.RemoveEmptyEntries)[0], hModelID, pNumObj, out tpDstImg);

            //测试移除模板
            //eyemRemoveModelByName(hModelID, "D:\\模板文件及图像\\df871193-6632-48f9-abfe-540c3fc49c3f.tpl");

            //free image
            eyemImageFree(ref tpDstImg);
            eyemImageFree(ref image);

            sw.Stop();
            Console.WriteLine("耗时：" + sw.ElapsedMilliseconds.ToString() + "，结果：" + pNumObj + "，所用模板：" + str);
        }

        public static void eyemReadProcssedImage(string fileName)
        {
            EyemImage image;
            EyemImage tpDstImg = new EyemImage();

            int flag = eyemImageRead(fileName, -1, out image);
            if (flag != 0)
            {
                Console.WriteLine("读图失败！");
                return;
            }

            EyemRect tpRoi = new EyemRect();
            tpRoi.iXs = 200; tpRoi.iYs = 200;
            tpRoi.iWidth = image.iWidth - 400;
            tpRoi.iHeight = image.iHeight - 400;

            //
            string file = fileName.Split(new string[] { "\\" }, StringSplitOptions.RemoveEmptyEntries)[2];

            //获取用于制作模板的图像
            flag = eyemAchvTemplateImage(image, tpRoi, out tpDstImg);

            Bitmap bitmap = eyemCvtToBitmap(tpDstImg);

            if (bitmap != null)
            {
                bitmap.Save("D:\\ResOut\\" + file);
            }

            //建议释放掉
            bitmap.Dispose();
        }

        public static int eyemInitModelE(out IntPtr hModelID)
        {
            return eyemInitModel("D:\\模板文件", out hModelID);
        }

        public static int eyemReleaseModelE(ref IntPtr hModelID)
        {
            return eyemReleaseModel(ref hModelID);
        }

        public static void eyemTestVideoCapture(string fileName)
        {
            List<EyemRect3> tpRois = new List<EyemRect3>();
            EyemRect3 roi1 = new EyemRect3();
            roi1.iXs = 0; roi1.iYs = 400; roi1.iWidth = 100; roi1.iHeight = 100; roi1.dVar = 0.35;
            EyemRect3 roi2 = new EyemRect3();
            roi2.iXs = 101; roi2.iYs = 400; roi2.iWidth = 100; roi2.iHeight = 100; roi2.dVar = 0.35;
            EyemRect3 roi3 = new EyemRect3();
            roi3.iXs = 202; roi3.iYs = 400; roi3.iWidth = 100; roi3.iHeight = 100; roi3.dVar = 0.35;
            EyemRect3 roi4 = new EyemRect3();
            roi4.iXs = 303; roi4.iYs = 400; roi4.iWidth = 100; roi4.iHeight = 100; roi4.dVar = 0.35;

            //需要监控的位置信息
            tpRois.Add(roi1); tpRois.Add(roi2); tpRois.Add(roi3); tpRois.Add(roi4);

            //结构体转内存指针
            IntPtr hGlobal = eyemStructArray2IntPtr(tpRois.ToArray());

            //信号值,用于后续处理
            int[] bitSingle = new int[tpRois.Count];

            EyemImage tpDstImg, tpRefImg, tpNextImg;
            eyemImageRead(fileName + "\\右侧BOX_12 2021-06-22-10-33-06-Original.png", -1, out tpRefImg);

            eyemImageRead(fileName + "\\右侧BOX_12 2021-06-22-08-35-38-Comp.png", -1, out tpNextImg);

            //存放结果
            int[] iArrRes = new int[tpRois.Count];
            //int iRet = eyemAOIForTSAV(tpImages[0], tpImages[i], hGlobal, tpRois.Count);
            int iRet = eyemTrackFeature(tpRefImg, tpNextImg, hGlobal, tpRois.Count, Marshal.UnsafeAddrOfPinnedArrayElement(iArrRes, 0), out tpDstImg);
            //过滤出有效信号（连续存在数帧以上才算，防止误触发），或者直接用iArrRes的值作为信号
            //toSingleFilter(iArrRes, ref bitSingle);
            //for (int j = 0; j < bitSingle.Length; j++)
            //{
            //    //设定信号持续帧数阈值
            //    if (bitSingle[j] > 15)
            //    {
            //        //检测到信号
            //        Console.WriteLine("检测到：" + j + "处有信号");
            //    }
            //}
            eyemImageFree(ref tpDstImg);
            //释放资源
            Marshal.FreeHGlobal(hGlobal);
        }

        public static void toSingleFilter(int[] iArrRes, ref int[] bitSingle)
        {
            for (int i = 0; i < iArrRes.Length; i++)
            {
                bitSingle[i] += iArrRes[i];
                if (bitSingle[i] >= 1)//信号起始
                {
                    //如果有一帧没检测到就重新累计
                    if (iArrRes[i] == 0)
                    {
                        bitSingle[i] = 0;
                    }
                }
            }
        }

        public static void eyemTest()
        {
            Stopwatch sw = new Stopwatch();
            sw.Restart();

            EyemImage image;
            EyemImage tpDstImg = new EyemImage();
            int flag = eyemImageRead(".\\1.png", -1, out image);
            if (flag != 0)
            {
                Console.WriteLine("读图失败！");
                return;
            }
            flag = eyemInitNNDataCodeModel(".\\darknet\\detect-tiny.cfg", ".\\darknet\\detect-tiny.weights", "", "");

            EyemRect tpRoi = new EyemRect();
            tpRoi.iXs = 0; tpRoi.iYs = 0;
            tpRoi.iWidth = image.iWidth;
            tpRoi.iHeight = image.iHeight;
            //<解码测试
            int ipNum; EyemBarCode* tpResults;
            DataCodeHandle hObject;
            flag = eyemDetectAndDecodeUseNN(image, tpRoi, out hObject, out tpResults, out ipNum, out tpDstImg);
            hObject.Dispose();

            sw.Stop();

            Bitmap bitmap = eyemCvtToBitmap(tpDstImg);

            if (bitmap != null)
            {
                bitmap.Save(".\\" + "predictions.png");
            }

            Console.WriteLine("时间花费：" + sw.ElapsedMilliseconds.ToString());

            //free image
            eyemImageFree(ref tpDstImg);
            eyemImageFree(ref image);
        }

        #region 文件重新命名
        public static void eyemRenameFile(string filePath)
        {
            List<string> fileNames = new List<string>();
            getAllFiles(filePath, ref fileNames);
            //批量重命名
            for (int index = 0; index < fileNames.Count; index++)
            {
                string destFileNmae = "D://标签识别//" + index.ToString().PadLeft(5, '0') + ".png";
                File.Move(fileNames[index], destFileNmae);
            }
        }

        static void getAllFiles(string filePath, ref List<string> fileNames)
        {
            getDirectory(filePath, ref fileNames);
        }

        public static void getFileName(string path, ref List<string> fileNames)
        {
            DirectoryInfo root = new DirectoryInfo(path);
            foreach (FileInfo f in root.GetFiles())
            {
                fileNames.Add(f.FullName);
            }
        }

        public static void getDirectory(string path, ref List<string> fileNames)
        {
            getFileName(path, ref fileNames);
            DirectoryInfo root = new DirectoryInfo(path);
            foreach (DirectoryInfo d in root.GetDirectories())
            {
                getDirectory(d.FullName, ref fileNames);
            }
        }
        #endregion

        #region EyemImage与Bitmap相互转换
        public static Bitmap eyemCvtToBitmap(EyemImage tpImage)
        {
            if (tpImage.vpImage == IntPtr.Zero || tpImage.iDepth != 0)
                return null;

            PixelFormat format;

            switch (tpImage.iChannels)
            {
                case 1:
                    format = PixelFormat.Format8bppIndexed;
                    break;
                case 3:
                    format = PixelFormat.Format24bppRgb;
                    break;
                case 4:
                    format = PixelFormat.Format32bppArgb;
                    break;
                default:
                    return null;
            }

            Bitmap bitmap = new Bitmap(tpImage.iWidth, tpImage.iHeight, format);

            //对于输出灰度图像
            if (format == PixelFormat.Format8bppIndexed)
            {
                ColorPalette palette = bitmap.Palette;
                for (int i = 0; i < 256; i++)
                {
                    palette.Entries[i] = Color.FromArgb(i, i, i);
                }
                bitmap.Palette = palette;
            }

            //锁定数据区
            BitmapData bd = bitmap.LockBits(new Rectangle(0, 0, tpImage.iWidth, tpImage.iHeight),
                ImageLockMode.WriteOnly, format);

            try
            {
                int pd = ((tpImage.iWidth * tpImage.iChannels) + 3) / 4 * 4;

                long bytesToCopy = tpImage.iWidth * tpImage.iChannels;

                for (int y = 0; y < tpImage.iHeight; y++)
                {
                    long offsetSrc = (y * tpImage.iWidth * tpImage.iChannels);
                    long offsetDst = (y * pd);

                    Buffer.MemoryCopy((byte*)(tpImage.vpImage.ToPointer()) + offsetSrc, (byte*)(bd.Scan0.ToPointer()) + offsetDst, bytesToCopy, bytesToCopy);
                }
            }
            finally
            {
                bitmap.UnlockBits(bd);
            }
            return bitmap;
        }

        public static EyemImage eyemCvtToEyemImage(Bitmap bitmap)
        {
            EyemImage tpImage = new EyemImage();
            //锁定数据区
            BitmapData bd = bitmap.LockBits(new Rectangle(0, 0, bitmap.Width, bitmap.Height),
                ImageLockMode.ReadOnly, bitmap.PixelFormat);

            switch (bitmap.PixelFormat)
            {
                case PixelFormat.Format8bppIndexed:
                    tpImage.iChannels = 1;
                    break;
                case PixelFormat.Format24bppRgb:
                    tpImage.iChannels = 3;
                    break;
                case PixelFormat.Format32bppArgb:
                    tpImage.iChannels = 4;
                    break;
                default:
                    throw new Exception("Image formats are not supported");
            }
            //仅支持8位
            tpImage.iDepth = 0;
            //图像尺寸
            tpImage.iWidth = bitmap.Width; tpImage.iHeight = bitmap.Height;
            //分配内存(释放不是用eyemImageFree,用Marshal.FreeHGlobal(tpImage.vpImage))
            tpImage.vpImage = Marshal.AllocHGlobal(bd.Stride * bd.Height);
            try
            {
                int pd = ((tpImage.iWidth * tpImage.iChannels) + 3) / 4 * 4;

                long bytesToCopy = tpImage.iWidth * tpImage.iChannels;

                for (int y = 0; y < tpImage.iHeight; y++)
                {
                    long offsetSrc = y * pd;
                    long offsetDst = y * tpImage.iWidth * tpImage.iChannels;

                    Buffer.MemoryCopy((byte*)(bd.Scan0.ToPointer()) + offsetSrc, (byte*)(tpImage.vpImage.ToPointer()) + offsetDst, bytesToCopy, bytesToCopy);
                }
            }
            finally
            {
                bitmap.UnlockBits(bd);
            }
            return tpImage;
        }

        public static void eyemCvtToEyemImage(Bitmap bitmap, out EyemImage tpImage)
        {
            int channels = 0;
            switch (bitmap.PixelFormat)
            {
                case PixelFormat.Format8bppIndexed:
                    channels = 1;
                    break;
                case PixelFormat.Format24bppRgb:
                    channels = 3;
                    break;
                case PixelFormat.Format32bppArgb:
                    channels = 4;
                    break;
                default:
                    break;
            }
            //锁定数据区
            BitmapData bd = bitmap.LockBits(new Rectangle(0, 0, bitmap.Width, bitmap.Height),
                ImageLockMode.ReadOnly, bitmap.PixelFormat);
            try
            {
                eyemImageFromBitmap(bd.Scan0, bd.Width, bd.Height, 0, channels, out tpImage);
            }
            finally
            {
                bitmap.UnlockBits(bd);
            }
        }
        #endregion

        #region 结构体转内存指针
        public static IntPtr eyemStructArray2IntPtr<T>(T[] tpArray)
        {
            if (tpArray == null)
                throw new ArgumentNullException(typeof(T).Name.ToString());
            //分配结构体需要的内存，需要释放
            IntPtr hGlobal = Marshal.AllocHGlobal(checked(Marshal.SizeOf(typeof(T)) * tpArray.Length));
            for (int index = 0; index < tpArray.Length; index++)
            {
                Marshal.StructureToPtr(tpArray[index], (IntPtr)(checked((long)hGlobal + index * Marshal.SizeOf(typeof(T)))), false);
            }
            return hGlobal;
        }
        #endregion

        #region 释放句柄
        //释放Blob句柄
        public class BlobHandle : SafeHandleZeroOrMinusOneIsInvalid
        {
            public BlobHandle() : base(true) { }
            protected override bool ReleaseHandle()
            {
                return eyemBinFree(handle);
            }
        }
        //释放测量句柄
        public class MeasureHandle : SafeHandleZeroOrMinusOneIsInvalid
        {
            public MeasureHandle() : base(true) { }
            protected override bool ReleaseHandle()
            {
                return eyemEdge1dGenMeasureFree(handle);
            }
        }
        //释放解码句柄
        public class DataCodeHandle : SafeHandleZeroOrMinusOneIsInvalid
        {
            public DataCodeHandle() : base(true) { }
            protected override bool ReleaseHandle()
            {
                return eyemDetectAndDecodeFree(handle);
            }
        }
        //释放视频句柄
        public class VideoHandle : SafeHandleZeroOrMinusOneIsInvalid
        {
            public VideoHandle() : base(true) { }
            protected override bool ReleaseHandle()
            {
                return eyemVideoCaptureFree(handle);
            }
        }

        #endregion
    }
}