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

namespace eyemLib_Sharp
{
    public unsafe class EyemLibDemo
    {
        #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
        {
            int iXs;                            // 起始点（左上角） x 坐标
            int iYs;                            // 起始点（左上角） y 坐标
            int iXe;                            // 端点（右下） x 坐标
            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;                        // 某种可能会使用的值
        }

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

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

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

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

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

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

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

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


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

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

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

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

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

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

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


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

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

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

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

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


        [StructLayout(LayoutKind.Sequential)]
        public struct EyemOcsDRQ                    // 直線(ヘッセの標準形)やベクトルの表現に使用
        {
            double dR;                              // ρ
            double dQ;                              // θ
        }

        [StructLayout(LayoutKind.Sequential)]
        public struct EyemOcsDXYQS
        {
            double dX;                              // Ｘ座標
            double dY;                              // Ｙ座標
            double dQ;                              // 回転角(単位：rad)
            double dS;                              // スケール
        }

        [StructLayout(LayoutKind.Sequential)]
        public struct EyemOcsDABCD                  // 平面(一般形)の表現に使用
        {
            double dA;                              // a
            double dB;                              // b
            double dC;                              // c
            double dD;                              // d
        }

        [StructLayout(LayoutKind.Sequential)]
        public struct EyemOcsDXYLSQ                 // 楕円の表現に使用
        {
            double dXo;                             // 中心のＸ座標
            double dYo;                             // 中心のＹ座標
            double dL;                              // 長軸半径
            double dS;                              // 短軸半径
            double dQ;                              // 長軸の傾き(単位：rad)
        }

        [StructLayout(LayoutKind.Sequential)]
        public struct EyemOcsDPV                        // ３次元空間内の直線の表現に使用
        {
            EyemOcsDXYZ tP;                             // 直線上の１点の座標
            EyemOcsDXYZ tV;                             // 直線の方向ベクトル
        }

        [StructLayout(LayoutKind.Sequential)]
        public struct EyemOcsDCRUVW                     // 楕円体の表現に使用
        {
            EyemOcsDXYZ tC;                             // 楕円体の中心
            EyemOcsDXYZ tR;                             // 軸の半径(dX：長軸, dY：中軸, dZ：短軸)
            double dU;                                  // 長軸のＸＹ平面への射影がＸ軸となす角(単位：rad)
            double dV;                                  // 長軸のＸＹ平面とのなす角(単位：rad)
            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
        {
            int iLabel;                         // 标签
            double dX;                          // ｘ坐标
            double dY;                          // ｙ坐标
            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;                       // 码内容
        }
        #endregion

        #region 项目
        //普通器件
        [DllImport("eyemLib.dll", CharSet = CharSet.None, CallingConvention = CallingConvention.Cdecl)]
        private static extern int eyemCountObject(EyemImage tpImage, string fileName, ref string pNumObj, out EyemImage tpDstImg);
        //异型器件
        [DllImport("eyemLib.dll", CharSet = CharSet.None, CallingConvention = CallingConvention.Cdecl)]
        private static extern int eyemCountObjectIrregularParts(EyemImage tpImage, string fileName, string strType, string tplName, double dMinScore, ref string pNumObj, out EyemImage tpDstImg);
        //读码程序
        [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);

        /// <summary>
        /// 背景变化跟踪
        /// </summary>
        /// <param name="tpRefImg">参考图像，在初始化时创建背景图像</param>
        /// <param name="tpNextImg">相机采集图像</param>
        /// <param name="tpArray">监控位置集合</param>
        /// <param name="iArraySize">集合大小</param>
        /// <param name="ipResults">结果（大小和监控位置一样）</param>
        /// <returns>0 正常；-3 图像不存在</returns>
        [DllImport("eyemLib.dll", CharSet = CharSet.None, CallingConvention = CallingConvention.Cdecl)]
        private static extern int eyemTrackFeature(EyemImage tpRefImg, EyemImage tpNextImg, IntPtr tpArray, int iArraySize, IntPtr ipResults);
        #endregion

        #region 通用

        // Win32 memory copy function
        [DllImport("ntdll.dll", CallingConvention = CallingConvention.Cdecl)]
        private static extern byte* memcpy(byte* dst, byte* src, int count);
        //读取图像，支持彩色与多深度
        [DllImport("eyemLib.dll", CharSet = CharSet.None, CallingConvention = CallingConvention.Cdecl)]
        private static extern int eyemImageRead(string filename, int iFalgs, out EyemImage tpImage);
        //读取视频，支持彩色
        [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);
        //释放视频句柄
        [DllImport("eyemLib.dll", CharSet = CharSet.None, CallingConvention = CallingConvention.Cdecl)]
        private static extern bool eyemVideoCaptureFree(IntPtr hObject);
        //读取Raw格式图像，仅支持8/16位
        [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);
        //创建图像(uint8_t、int8_t、uint16_t、int16_t、int32_t、float_t、double_t)
        [DllImport("eyemLib.dll", CharSet = CharSet.None, CallingConvention = CallingConvention.Cdecl)]
        private static extern int eyemImageMalloc(int iWidth, int iHeight, int iChannels, string ccSubType, out EyemImage tpImage);
        //拷贝图像（必须预分配空间）
        [DllImport("eyemLib.dll", CharSet = CharSet.None, CallingConvention = CallingConvention.Cdecl)]
        private static extern int eyemImageCopy(EyemImage tpImage, ref EyemImage tpDstImg);
        //图像颜色空间转换
        [DllImport("eyemLib.dll", CharSet = CharSet.None, CallingConvention = CallingConvention.Cdecl)]
        private static extern int eyemCvtImageColor(EyemImage tpImage, ColorConversionCodes iCCodes, ref EyemImage tpDstImg);
        //图像数据格式转换(uint8_t、int8_t、uint16_t、int16_t、int32_t、float_t、double_t)
        [DllImport("eyemLib.dll", CharSet = CharSet.None, CallingConvention = CallingConvention.Cdecl)]
        private static extern int eyemCvtImageType(EyemImage tpImage, string ccSubType, double alpha, double beta, ref EyemImage tpDstImg);
        //图像相加
        [DllImport("eyemLib.dll", CharSet = CharSet.None, CallingConvention = CallingConvention.Cdecl)]
        private static extern int eyemImageAdd(EyemImage tpImage1, EyemImage tpImage2, ref EyemImage tpDstImg);
        //图像相减
        [DllImport("eyemLib.dll", CharSet = CharSet.None, CallingConvention = CallingConvention.Cdecl)]
        private static extern int eyemImageSub(EyemImage tpImageMinuend, EyemImage tpImageSubtrahend, ref EyemImage tpDstImg);
        //图像相除
        [DllImport("eyemLib.dll", CharSet = CharSet.None, CallingConvention = CallingConvention.Cdecl)]
        private static extern int eyemImageDiv(EyemImage tpImage1, EyemImage tpImage2, ref EyemImage tpDstImg);
        //图像取绝对值
        [DllImport("eyemLib.dll", CharSet = CharSet.None, CallingConvention = CallingConvention.Cdecl)]
        private static extern int eyemImageAbs(EyemImage tpImage, ref EyemImage tpDstImg);
        //释放图像资源
        [DllImport("eyemLib.dll", CharSet = CharSet.None, CallingConvention = CallingConvention.Cdecl)]
        private static extern void eyemImageFree(ref EyemImage tpImage);

        #endregion

        //
        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 ipNum; EyemImage* tpImages;
            VideoHandle hObject;
            eyemVideoCapture(fileName, out hObject, out tpImages, out ipNum);

            //信号值,用于后续处理，不需要可以不用
            int[] bitSingle = new int[tpRois.Count];

            //类似于实时采集的图像
            for (int i = 1; i < ipNum; i++)
            {
                //存放结果
                int[] iArrRes = new int[tpRois.Count];
                //fixed (int* ipResults = &iArrRes[0])
                //{
                int iRet = eyemTrackFeature(tpImages[0], tpImages[i], hGlobal, tpRois.Count, Marshal.UnsafeAddrOfPinnedArrayElement(iArrRes, 0)/* new IntPtr((void*)ipResults)*/);
                //}
                //过滤出有效信号（连续存在数帧以上才算，防止误触发），或者直接用iArrRes的值作为信号，可能会有干扰的情况
                toSingleFilter(iArrRes, ref bitSingle);
                for (int j = 0; j < bitSingle.Length; j++)
                {
                    //设定信号持续帧数阈值
                    if (bitSingle[j] > 15)
                    {
                        //检测到信号
                        Console.WriteLine("检测到：" + j + "处有信号");
                    }
                }
            }
            //释放资源（必须）
            Marshal.FreeHGlobal(hGlobal);
            hObject.Dispose();
        }

        //信号过滤
        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;
                    }
                }
            }
        }

        #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 释放句柄
        //释放解码句柄
        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
    }
}