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 结构体
        // 图像信息
        [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 项目
        //圆形/矩形（红色）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);
        #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 void eyemImageFree(ref EyemImage tpImage);

        #endregion

        //例程
        public static void eyeyTestTemplateModelMethod(string fileName)
        {
            #region //从本地读图
            //EyemImage image;
            //int flag = eyemImageRead(fileName, -1, out image);
            //if (flag != 0)
            //{
            //    Console.WriteLine("读图失败！");
            //    return;
            //}

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

            ////free image
            //eyemImageFree(ref image);
            #endregion

            #region //从网络读图

            //image = eyemCvtToEyemImage(bitmap);

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

            ////free image
            //Marshal.FreeHGlobal(image.vpImage);
            #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;
        }
        #endregion

    }
}