using System;
using System.Runtime.InteropServices;
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
        {
            public int iXs;                            // 起始点（左上角） x 坐标
            public int iYs;                            // 起始点（左上角） y 坐标
            public int iXe;                            // 端点（右下） x 坐标
            public int iYe;                            // 端点（右下） y 坐标
        }

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

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

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

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

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

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

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

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

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

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


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

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

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

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

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

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

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


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

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

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

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

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


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

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

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

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

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

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

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

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

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

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

        [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））

        #endregion

        #region 项目
        /// <summary>
        /// 圆形Mark点定位
        /// </summary>
        /// <param name="tpImage">图像</param>
        /// <param name="tpHSVModel">HSV阈值</param>
        /// <param name="tpCircle">结果</param>
        /// <param name="tpDstImg">结果图</param>
        /// <param name="bHighAccuracy">是否使用高精度</param>
        /// <returns>0=FUNC_OK</returns>
        [DllImport("eyemLib.dll", CharSet = CharSet.None, CallingConvention = CallingConvention.Cdecl)]
        private static extern int eyemMarkerTracing(EyemImage tpImage, EyemHSVModel tpHSVModel, ref EyemOcsFXYR tpCircle, out EyemImage tpDstImg, bool bHighAccuracy = false);
        #endregion

        #region 通用
        //读取图像，支持彩色与多深度
        [DllImport("eyemLib.dll", CharSet = CharSet.None, CallingConvention = CallingConvention.Cdecl)]
        private static extern int eyemImageRead(string filename, int iFlags, out EyemImage tpImage);
        //释放图像资源
        [DllImport("eyemLib.dll", CharSet = CharSet.None, CallingConvention = CallingConvention.Cdecl)]
        private static extern void eyemImageFree(ref EyemImage tpImage);
        // 设定日志回调
        [DllImport("eyemLib.dll", CharSet = CharSet.None, CallingConvention = CallingConvention.Cdecl)]
        private static extern void setLogCallback(TCallBack cb);
        #endregion

        #region 日志
        public delegate void TCallBack(string msg);
        public static TCallBack sld = new TCallBack(TLogCallback);

        public static event TCallBack OnNewLogCallback;

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

        //程序启动时初始化一次
        public static void Init()
        {
            setLogCallback(sld);

            OnNewLogCallback += new TCallBack(EyemLib_OnNewLogCallback);
        }
        //程序结束时释放
        public static void Free()
        {
            setLogCallback(null); sld = null;
        }

        //记录算法日志
        private static void EyemLib_OnNewLogCallback(string msg)
        {
            //算法里输出的一切日志都会在这里
        }
        #endregion

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

            ////红色分割
            //EyemHSVModel tpHsvModel = new EyemHSVModel();
            //tpHsvModel.dpRangeL = new double[] { 0, 43, 46 }; tpHsvModel.dpRangeU = new double[] { 10, 255, 255 };
            //tpHsvModel.dpRangeLExt = new double[] { 156, 43, 46 }; tpHsvModel.dpRangeUExt = new double[] { 180, 255, 255 };

            ////绿色分割
            //EyemHSVModel tpHsvModel = new EyemHSVModel();
            //tpHsvModel.dpRangeL = new double[] { 35, 43, 46 }; tpHsvModel.dpRangeU = new double[] { 77, 255, 255 };
            //tpHsvModel.dpRangeLExt = new double[] { 0, 0, 0 }; tpHsvModel.dpRangeUExt = new double[] { 0, 0, 0 };

            ////蓝色分割
            //EyemHSVModel tpHsvModel = new EyemHSVModel();
            //tpHsvModel.dpRangeL = new double[] { 100, 43, 46 }; tpHsvModel.dpRangeU = new double[] { 124, 255, 255 };
            //tpHsvModel.dpRangeLExt = new double[] { 0, 0, 0 }; tpHsvModel.dpRangeUExt = new double[] { 0, 0, 0 };

            //EyemOcsFXYR tpCircle = new EyemOcsFXYR();
            //flag = eyemMarkerTracing(image, tpHsvModel, ref tpCircle, out tpDstImg);

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

            #region //从内存读图

            //image = eyemCvtToEyemImage(/*Bitmap*/);

            //flag = eyemMarkerTracing(image, tpHsvModel, ref tpCircle, out tpDstImg);

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