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


namespace eyemLib_Sharp
{
    public unsafe class EyemLib
    {
        #region 图像常量

        public static readonly int CV_8U = 0;
        public static readonly int CV_8S = 1;
        public static readonly int CV_16U = 2;
        public static readonly int CV_16S = 3;
        public static readonly int CV_32S = 4;
        public static readonly int CV_32F = 5;
        public static readonly int CV_64F = 6;

        #endregion

        #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
        }

        #endregion

        #region 结构体
        // 图像信息
        [StructLayout(LayoutKind.Sequential)]
        public struct EyemImage
        {
            public IntPtr ucpImage;                    // 地址
            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 坐标
        }

        ///////////////////////////////////////////////////////////////////////////////
        // 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 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 通用

        // 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);
        //读取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);
        //创建图像
        [DllImport("eyemLib.dll", CharSet = CharSet.None, CallingConvention = CallingConvention.Cdecl)]
        private static extern int eyemImageMalloc(int iWidth, int iHeight, int iChannels, int iType, out EyemImage tpImage);
        //释放图像资源
        [DllImport("eyemLib.dll", CharSet = CharSet.None, CallingConvention = CallingConvention.Cdecl)]
        private static extern void eyemImageFree(IntPtr ipImage);

        #endregion

        #region 2 值 blob 分析

        //二值化图像
        [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);
        [DllImport("eyemLib.dll", CharSet = CharSet.None, CallingConvention = CallingConvention.Cdecl)]
        private static extern int eyemBinThreshold(EyemImage tpSrsImg, int iLightDark, int binMethod, out EyemImage tpDstImg);
        //Sauvola二值化
        [DllImport("eyemLib.dll", CharSet = CharSet.None, CallingConvention = CallingConvention.Cdecl)]
        private static extern int eyemBinNiBlack(EyemImage tpSrcImg, out EyemImage tpDstImg, int iType, int iWinSize, double dK, int binarizationMethod, double r);
        //动态阈值
        [DllImport("eyemLib.dll", CharSet = CharSet.None, CallingConvention = CallingConvention.Cdecl)]
        private static extern int eyemBinDynThreshold(EyemImage tpSrcImg, EyemImage tpThresholdImg, int iOffset, int iLightDark, out EyemImage tpDstImg);
        //二值Blob分析
        [DllImport("eyemLib.dll", CharSet = CharSet.None, CallingConvention = CallingConvention.Cdecl)]
        private static extern int eyemBinBlob(EyemImage tpImage, out BlobHandle hObject, int iAreaThrs, out EyemImage tpDstImage, out EyemChainCode* tpContours, out EyemBinBlob* tpResult, out int ipNum);
        //释放Blob资源
        [DllImport("eyemLib.dll", CharSet = CharSet.None, CallingConvention = CallingConvention.Cdecl)]
        private static extern bool eyemBinFree(IntPtr hObject);

        #endregion

        #region 矩阵运算

        //创建二维矩阵
        [DllImport("eyemLib.dll", CharSet = CharSet.None, CallingConvention = CallingConvention.Cdecl)]
        private static extern IntPtr eyemMatMallocMatrix(int iRows, int iCols, [In]double[] dpData);
        //释放二维矩阵
        [DllImport("eyemLib.dll", CharSet = CharSet.None, CallingConvention = CallingConvention.Cdecl)]
        private static extern void eyemMatFreeMatrix(IntPtr intPtr);
        //初始化矩阵
        [DllImport("eyemLib.dll", CharSet = CharSet.None, CallingConvention = CallingConvention.Cdecl)]
        private static extern void eyemMatZero(IntPtr vpA);
        //复制矩阵
        [DllImport("eyemLib.dll", CharSet = CharSet.None, CallingConvention = CallingConvention.Cdecl)]
        private static extern void eyemMatCopy(IntPtr vpDst, IntPtr vpSrc);
        //矩阵相加
        [DllImport("eyemLib.dll", CharSet = CharSet.None, CallingConvention = CallingConvention.Cdecl)]
        private static extern void eyemMatAdd(IntPtr vpA, IntPtr vpB, IntPtr vpC);

        #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);
        //findLine
        [DllImport("eyemLib.dll", CharSet = CharSet.None, CallingConvention = CallingConvention.Cdecl)]
        private static extern int eyemEdge1dFindLine(EyemImage tpImage, EyemOcsDXY tpLineSt, EyemOcsDXY tpLineEd, int iWhRoi, int iTransition, out MeasureHandle hObject);

        //释放工具所使用句柄
        [DllImport("eyemLib.dll", CharSet = CharSet.None, CallingConvention = CallingConvention.Cdecl)]
        private static extern bool eyemEdge1dGenMeasureFree(IntPtr hObject);
        #endregion

        [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 dThresh);

        #region 稳健估计
        [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);

        #endregion

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

        public static void eyemReadImageTool(string fileName)
        {
            EyemImage ucpImage;
            EyemImage tpDstImg = new EyemImage();
            //int flag = eyemImageRead("D:\\图片及统计结果\\图片及统计结果\\data\\6D551\\6D551-R014212020040601587-20200624140637.png", 0, out ucpImage);
            //int flag = eyemImageReadRaw(fileName, 3072, 3072, 2, out ucpImage);
            int flag = eyemImageRead(fileName, -1, out ucpImage);
            if (flag != 0)
            {
                Console.WriteLine("读图失败！");
                return;
            }
            int flags = eyemImageMalloc(ucpImage.iWidth, ucpImage.iHeight, 3, CV_16U, out tpDstImg);

            //ucpImage.iWidth = 3072; ucpImage.iHeight = 3072; ucpImage.iDepth = 2;
            //Bitmap bmp = new Bitmap(ucpImage.iWidth, ucpImage.iHeight, System.Drawing.Imaging.PixelFormat.Format8bppIndexed);
            //ColorPalette color_palette_gray_ = bmp.Palette;
            //for (int i = 0; i < 256; i++)
            //{
            //    color_palette_gray_.Entries[i] = System.Drawing.Color.FromArgb(i, i, i);
            //}
            //bmp.Palette = color_palette_gray_;
            //BitmapData bdd = bmp.LockBits(new Rectangle(0, 0, bmp.Width, bmp.Height), ImageLockMode.WriteOnly, bmp.PixelFormat);
            //memcpy((byte*)bdd.Scan0.ToPointer(), (byte*)ucpImage.ucpImage.ToPointer(), bdd.Stride * bdd.Height);
            //bmp.UnlockBits(bdd);
            //bmp.Dispose();

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

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

            #region Test 1DEdge
            //EyemOcsDXY tpLineSt = new EyemOcsDXY();
            //tpLineSt.dX = 947;
            //tpLineSt.dY = 1;
            //EyemOcsDXY tpLineEd = new EyemOcsDXY();
            //tpLineEd.dX = 149;
            //tpLineEd.dY = 548;

            //MeasureHandle hObject;
            //eyemEdge1dGenMeasureRect(ucpImage, tpLineSt, tpLineEd, 10, "all", 0, 0.9, 30, out hObject);
            //eyemEdge1dGenPosRect(ucpImage, tpLineSt, tpLineEd, 50, 0, 0.9, 30, out hObject);
            //eyemEdge1dFindLine(ucpImage, tpLineSt, tpLineEd, 15, 0, out hObject);
            ///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
            //eyemBinAutoThreshold(ucpImage, 1.8, 1, 6, out tpDstImg);
            //eyemSkeleton(ucpImage);
            //eyemBinBinaryImage(ucpImage, 0, 3, out tpDtImg);
            //eyemBinDynThreshold(ucpImage, ucpImage, 3, 1, out tpDstImg);
            //eyemBinNiBlack(ucpImage, out tpDstImg, 0, 11, 0.5, 3, 128);
            #endregion

            #region Test Sauvola

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

            #endregion

            #region Test RobustFitLine

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

            //double k = 2.0, b = 1.0;//y=2x+1
            //for (int i = 0; i < 100; i += 5)
            //{
            //    taPoint.dX = i;
            //    taPoint.dY = k * taPoint.dX + b;
            //    taPoints.Add(taPoint);
            //}
            //taPoint.dX = 50;
            //taPoint.dY = 45;
            //taPoints.Add(taPoint);

            //taPoint.dX = 60;
            //taPoint.dY = 76;
            //taPoints.Add(taPoint);

            //taPoint.dX = 38;
            //taPoint.dY = 58;
            //taPoints.Add(taPoint);


            //taPoint.dX = 71;
            //taPoint.dY = 37;
            //taPoints.Add(taPoint);

            //taPoint.dX = 15;
            //taPoint.dY = 50;
            //taPoints.Add(taPoint);

            //taPoint.dX = 36;
            //taPoint.dY = 56;
            //taPoints.Add(taPoint);

            //taPoint.dX = 18;
            //taPoint.dY = 8;
            //taPoints.Add(taPoint);


            //taPoint.dX = 100;
            //taPoint.dY = 100;
            //taPoints.Add(taPoint);

            //taPoint.dX = 16;
            //taPoint.dY = 16;
            //taPoints.Add(taPoint);

            //taPoint.dX = 18;
            //taPoint.dY = 28;
            //taPoints.Add(taPoint);


            //taPoint.dX = 17;
            //taPoint.dY = 37;
            //taPoints.Add(taPoint);

            //taPoint.dX = 28;
            //taPoint.dY = 48;
            //taPoints.Add(taPoint);


            //IntPtr tpPoint = teStructArray2IntPtr(taPoints.ToArray(), taPoints.Count);
            //eyemRobustFitLine(taPoints.Count, tpPoint, 6, 0, ref tpLine);
            //Marshal.FreeHGlobal(tpPoint);
            #endregion

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

            #region Test Edge
            //eyemEdgesPixel(ucpImage, 15);
            #endregion

            EyemRect tpRoi = new EyemRect();
            tpRoi.iXs = tpRoi.iYs = 0;
            tpRoi.iWidth = ucpImage.iWidth;
            tpRoi.iHeight = ucpImage.iHeight;
            //
            string pNumObj = "";
            string file = fileName.Split(new string[] { "\\" }, StringSplitOptions.RemoveEmptyEntries)[2];
            //"IP_SMALL_PARTS","IP_LARGE_PARTS","IP_LONG_PARTS",""
            //eyemCountObject(ucpImage, file.Replace(".png", ""), 35, 0, 100, 5, ref pNumObj, out tpDstImg);
            //eyemCountObjectIrregularParts(ucpImage, file.Replace(".png", ""), 0d, "IP_LONG_PARTS", 100, 5, ref pNumObj, out tpDstImg);
            //int ipNum; EyemBarCode* tpResults;
            //DataCodeHandle hObject;
            //int iRes = eyemDetectAndDecode(ucpImage, tpRoi, file.Replace(".png", ""), "QR_CODE|DATA_MATRIX|CODE_39|CODE_128", out hObject, out tpResults, out ipNum, false, 11, 5, 128, 256, 1d);
            //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();
            //sw.Stop();
            //Console.WriteLine("耗时：" + sw.ElapsedMilliseconds.ToString() + "，结果：" + pNumObj);
            //free image
            eyemImageFree(ucpImage.ucpImage);
        }

        //计算最佳参数
        public static void eyemReadImageToolTest(string fileName)
        {
            EyemImage ucpImage;
            int flag = eyemImageRead(fileName, -1, out ucpImage);
            if (flag != 0)
            {
                Console.WriteLine("读图失败！");
                return;
            }
            EyemRect tpRoi = new EyemRect();
            tpRoi.iXs = tpRoi.iYs = 0;
            tpRoi.iWidth = ucpImage.iWidth;
            tpRoi.iHeight = ucpImage.iHeight;
            //
            System.Collections.Generic.Dictionary<int, int> dictPara = new System.Collections.Generic.Dictionary<int, int>();

            string file = fileName.Split(new string[] { "\\" }, StringSplitOptions.RemoveEmptyEntries)[2];
            for (int ii = 5; ii < 27; ii += 2)
            {
                int ipNum; EyemBarCode* tpResults;
                DataCodeHandle hObject;
                int iRes = eyemDetectAndDecode(ucpImage, tpRoi, file.Replace(".png", ""), "QR_CODE|DATA_MATRIX|CODE_128", out hObject, out tpResults, out ipNum, false, ii, 5, 128, 215, 1d);
                dictPara.Add(ii, ipNum);
                hObject.Dispose();
                //Console.WriteLine("数量：" + ipNum + "；" + "参数：" + ii.ToString());
            }
            var sortResult = from dic in dictPara orderby dic.Value descending select dic;
            foreach (KeyValuePair<int, int> kvp in sortResult)
            {
                int ipNum; EyemBarCode* tpResults;
                DataCodeHandle hObject;
                int iRes = eyemDetectAndDecode(ucpImage, tpRoi, file.Replace(".png", ""), "QR_CODE|DATA_MATRIX|CODE_128", out hObject, out tpResults, out ipNum, false, kvp.Key, 5, 128, 215, 1d);
                hObject.Dispose();
                Console.WriteLine("最佳参数：" + kvp.Key);
                break;
            }
            //free image
            eyemImageFree(ucpImage.ucpImage);
            return;
        }


        #region 结构转内存指针
        public static IntPtr teStructArray2IntPtr(EyemOcsDXY[] tpPoints, int iLength)
        {
            if (tpPoints == null)
                throw new ArgumentNullException("cvPoint2D32f");
            //分配结构体需要的内存
            IntPtr memory = Marshal.AllocHGlobal(checked(Marshal.SizeOf(typeof(EyemOcsDXY)) * iLength));
            for (int index = 0; index < iLength; index++)
            {
                Marshal.StructureToPtr(tpPoints[index], (IntPtr)(checked((long)memory + index * Marshal.SizeOf(typeof(EyemOcsDXY)))), false);
            }
            return memory;
        }
        #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);
            }
        }

        #endregion
    }
}