using System;
using System.Drawing;
using System.Drawing.Imaging;
using System.Collections.Generic;
using System.Runtime.InteropServices;


#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 EyemBlobParams
{
    // public bool isLight;
    public bool filterByArea;                         //斑点大小限制
    public int minArea, maxArea;                      //最小面积/最大面积
    public bool filterByCircularity;                  //斑点圆度限制
    public float minCircularity, maxCircularity;      //圆度最小/大限制
    public bool filterByInertia;                      //斑点的惯性率限制
    public float minInertiaRatio, maxInertiaRatio;    //惯性率最小/大限制
    public bool filterByConvexity;                    //斑点凸度限制
    public float minConvexity, maxConvexity;          //凸度最小/大限制
}

// 条码 解码结果
[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;                    // 名称
}

[StructLayout(LayoutKind.Sequential)]
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
}


[StructLayout(LayoutKind.Sequential)]
public struct EyemHSVModel
{
    [MarshalAs(UnmanagedType.ByValArray, SizeConst = 3)]
    public double[] dpRangeL, dpRangeU;        // 提取下限，提取上限[H S V]
    [MarshalAs(UnmanagedType.ByValArray, SizeConst = 3)]
    public double[] dpRangeLExt, dpRangeUExt;  // 额外提取下限，额外提取上限（针对处于跨模型颜色，比如红色）[H S V]
}// 用于HSV颜色模型分割（H（0-180）、S（0-255）、V（0-255））


[StructLayout(LayoutKind.Sequential)]
public struct EyemTargetMatch
{
    public float fCenterX;
    public float fCenterY;
    public float fMatchScore;
    public float fMatchAngle;
}

#endregion

#region 枚举

//图像格式转换信息
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_BGR2HSV = 40, //!< convert RGB/BGR to HSV (hue saturation value), @ref color_convert_rgb_hsv "color conversions"
    COLOR_RGB2HSV = 41,

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

#endregion

public unsafe class EyemLibDotNet
{
    #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="cb">长度</param>
    /// <returns>地址</returns>
    [DllImport("eyemLib.dll", CallingConvention = CallingConvention.Cdecl)]
    private static extern IntPtr eyemMallocMemBlock(int cb);
    /// <summary>
    /// 释放从非托管内存中分配的内存
    /// </summary>
    /// <param name="block">地址</param>
    [DllImport("eyemLib.dll", CallingConvention = CallingConvention.Cdecl)]
    private static extern void eyemFreeMemBlock(IntPtr block);
    /// <summary>
    /// 读取图像文件
    /// </summary>
    /// <param name="filename">文件名</param>
    /// <param name="iFlags">读取标志,-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 iFlags, 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);
    #endregion

    #region 2值化

    /// <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="tpImage">图像</param>
    /// <param name="ipRangeL">下限[0,0,0]</param>
    /// <param name="ipRangeU">上限[255,255,255]</param>
    /// <param name="tpDstImg">结果</param>
    /// <returns></returns>
    [DllImport("eyemLib.dll", CharSet = CharSet.None, CallingConvention = CallingConvention.Cdecl)]
    private static extern int eyemBinThresholdC(EyemImage tpImage, EyemHSVModel tpHSVModel, 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);
    #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="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 eyemCvtImageColor(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">乘值,1.0</param>
    /// <param name="beta">加值,0.0</param>
    /// <param name="tpDstImg">结果图像</param>
    /// <returns></returns>
    [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);

    /// <summary>
    /// 拷贝指定位置的图像
    /// </summary>
    /// <param name="tpImage">图像</param>
    /// <param name="tpRoi">位置</param>
    /// <param name="tpDstImg">结果</param>
    /// <returns></returns>
    [DllImport("eyemLib.dll", CharSet = CharSet.None, CallingConvention = CallingConvention.Cdecl)]
    private static extern int eyemCopyRegion(EyemImage tpImage, EyemRect tpRoi, out EyemImage tpDstImg);

    /// <summary>
    /// 统计非零像素数量
    /// </summary>
    /// <param name="tpImage">图像</param>
    /// <returns>结果</returns>
    [DllImport("eyemLib.dll", CharSet = CharSet.None, CallingConvention = CallingConvention.Cdecl)]
    private static extern int eyemCountNonZero(EyemImage tpImage);
    #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;
    }

    /// <summary>
    /// Bitmap转EyemImage(需单独释放)
    /// </summary>
    /// <param name="bitmap"></param>
    /// <returns></returns>
    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;
    }

    /// <summary>
    /// Bitmap转EyemImage(可由eyemImageFree释放)
    /// </summary>
    /// <param name="bitmap"></param>
    /// <returns></returns>
    public static EyemImage eyemCvtToEyemImage2(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;
        //分配内存（可由自带释放）
        tpImage.vpImage = eyemMallocMemBlock(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;
    }
    #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;
    }

    public static List<T> eyemIntPtr2StructArray<T>(IntPtr hGlobal, int Size)
    {
        if (hGlobal == IntPtr.Zero)
            throw new ArgumentNullException(typeof(IntPtr).Name.ToString());
        //
        List<T> tpArray = new List<T>();
        for (int index = 0; index < Size; index++)
        {
            IntPtr lpArray = new IntPtr(checked(hGlobal.ToInt64() + index * Marshal.SizeOf(typeof(T))));
            var structure = Marshal.PtrToStructure<T>(lpArray);
            tpArray.Add(structure);
        }
        return tpArray;
    }

    #endregion

    #region 项目 随项目改变添加

    #endregion
}