using System;
using System.Runtime.InteropServices;
using System.IO;
using OpenCvSharp;

// 人脸比对（备注：人脸比对，实际上是人脸的特征值比对，提取出人脸特征值，用compare_feature方法比对)
namespace FaceAI
{  
    // 人脸比较1:1、1:N、抽取人脸特征值、按特征值比较等
    public class FaceCompare       
    {
        //  提取人脸特征值(传图片文件路径) 
        /// <summary>
        /// 提取人脸特征值，为512个浮点值，已加密
        /// </summary>
        /// <param name="file_name">图片信息，数据大小小于10M，传入图片文件路径</param>
        /// <param name="length">通过引用返回特征值的长度，若为2048表示提取正确，其他值表示提取了错误的特征值</param>
        /// <returns></returns>
        [DllImport("BaiduFaceApi.dll", EntryPoint = "get_face_feature", CharSet = CharSet.Ansi
            , CallingConvention = CallingConvention.Cdecl)]
        public static extern IntPtr get_face_feature(string file_name, ref int length);
        // 提取人脸特征值(传二进制图片buffer）
        /// <summary>
        /// 提取人脸特征值，为2048个byte (传入二进制图片buffer)
        /// </summary>
        /// <param name="buf"></param>
        /// <param name="size"></param>
        /// <param name="length"></param>
        /// <returns></returns>
        [DllImport("BaiduFaceApi.dll", EntryPoint = "get_face_feature_by_buf", CharSet = CharSet.Ansi
            , CallingConvention = CallingConvention.Cdecl)]
        public static extern IntPtr get_face_feature_by_buf(byte[] buf, int size, ref int length);
        //// 获取人脸特征值（传入opencv视频帧及人脸信息，适应于多人脸）
        ///// <summary>
        ///// 获取人脸特征值（传入opencv视频帧及人脸信息，适应于多人脸）
        ///// </summary>
        ///// <param name="mat"></param>
        ///// <param name="info"></param>
        ///// <param name="feaptr"></param>
        ///// <returns></returns>
        //[DllImport("BaiduFaceApi.dll", EntryPoint = "get_face_feature_by_face", CharSet = CharSet.Ansi
        //    , CallingConvention = CallingConvention.Cdecl)]
        //public static extern int get_face_feature_by_face(IntPtr mat, ref TrackFaceInfo info, ref IntPtr feaptr);
        // 人脸1:1比对(传图片文件路径)
        /// <summary>
        /// 人脸对比接口（传入图片文件路径）
        /// </summary>
        /// <param name="file_name1">需要对比的第一张图片，小于10M，传入图片文件路径</param>
        /// <param name="file_name2">需要对比的第二张图片，小于10M，传入图片文件路径</param>
        /// <returns></returns>
        [DllImport("BaiduFaceApi.dll", EntryPoint = "match", CharSet = CharSet.Ansi
            , CallingConvention = CallingConvention.Cdecl)]
        public static extern IntPtr match(string file_name1, string file_name2);
        // 人脸1:1比对（传二进制图片buffer）
        /// <summary>
        /// 人脸对比接口（传入二进制图片buffer）
        /// </summary>
        /// <param name="buf1">需要对比的第一张图片，小于10M</param>
        /// <param name="size1">图片1的大小</param>
        /// <param name="buf2">需要对比的第二张图片，小于10M</param>
        /// <param name="size2">图片2的大小</param>
        /// <returns></returns>
        [DllImport("BaiduFaceApi.dll", EntryPoint = "match_by_buf", CharSet = CharSet.Ansi
            , CallingConvention = CallingConvention.Cdecl)]
        public static extern IntPtr match_by_buf(byte[] buf1, int size1, byte[] buf2, int size2);
        // 人脸1:1比对（传opencv视频帧）
        /// <summary>
        /// 人脸1:1比对（传opencv视频帧）
        /// </summary>
        /// <param name="img1"></param>
        /// <param name="img2"></param>
        /// <returns></returns>
        [DllImport("BaiduFaceApi.dll", EntryPoint = "match_by_mat", CharSet = CharSet.Ansi
            , CallingConvention = CallingConvention.Cdecl)]
        public static extern IntPtr match_by_mat(IntPtr img1, IntPtr img2);// byte[] buf1, int size1, byte[] buf2, int size2);
        // 人脸1:1比对（传人脸特征值和二进制图片buffer)
        /// <summary>
        /// 人脸对比接口(传入二进制图片buffer)
        /// </summary>
        /// <param name="feature">文件特征</param>
        /// <param name="fea_len"></param>
        /// <param name="buf2"></param>
        /// <param name="size2"></param>
        /// <returns></returns>
        [DllImport("BaiduFaceApi.dll", EntryPoint = "match_by_feature", CharSet = CharSet.Ansi
            , CallingConvention = CallingConvention.Cdecl)]
        public static extern IntPtr match_by_feature(byte[] feature, int fea_len, byte[] buf2, int size2);
        // 特征值比对（传2个人脸的特征值）
        /// <summary>
        /// 特征值比对
        /// </summary>
        /// <param name="f1"></param>
        /// <param name="f1_len"></param>
        /// <param name="f2"></param>
        /// <param name="f2_len"></param>
        /// <returns></returns>
        [DllImport("BaiduFaceApi.dll", EntryPoint = "compare_feature", CharSet = CharSet.Ansi
            , CallingConvention = CallingConvention.Cdecl)]
        public static extern float compare_feature(byte[] f1, int f1_len, byte[] f2, int f2_len);
        // 1:N人脸识别（传图片文件路径和库里的比对）
        /// <summary>
        /// 人脸识别，提供1：N查找 (传入图片文件路径)
        /// </summary>
        /// <param name="image">图片信息，数据大小小于10M，传入图片文件路径</param>
        /// <param name="group_id_list">组id列表。默认至少填写一个group_id，从指定的group中进行查找。需要同时查询多个group，用逗号分隔，上限10个</param>
        /// <param name="user_id">用户id，若指定了某个user，则只会与指定group下的这个user进行对比；若user_id传空字符串” ”，则会与此group下的所有user进行1：N识别</param>
        /// <param name="user_top_num">识别后返回的用户top数，默认为1，最多返回50个结果</param>
        /// <returns></returns>
        [DllImport("BaiduFaceApi.dll", EntryPoint = "identify", CharSet = CharSet.Ansi
           , CallingConvention = CallingConvention.Cdecl)]
        public static extern IntPtr identify(string image, string group_id_list, string user_id, int user_top_num = 1);
        // 1:N人脸识别（传图片二进制文件buffer和库里的比对）
        /// <summary>
        /// 人脸识别，提供1：N查找 (传入二进制图片buffer）
        /// </summary>
        /// <param name="buf">二进制图片信息，数据大小小于10M</param>
        /// <param name="size">图片大小</param>
        /// <param name="group_id_list">组id列表。默认至少填写一个group_id，从指定的group中进行查找。需要同时查询多个group，用逗号分隔，上限10个</param>
        /// <param name="user_id">用户id，若指定了某个user，则只会与指定group下的这个user进行对比；若user_id传空字符串” ”，则会与此group下的所有user进行1：N识别</param>
        /// <param name="user_top_num">识别后返回的用户top数，默认为1，最多返回50个结果</param>
        /// <returns></returns>
        [DllImport("BaiduFaceApi.dll", EntryPoint = "identify_by_buf", CharSet = CharSet.Ansi
           , CallingConvention = CallingConvention.Cdecl)]
        public static extern IntPtr identify_by_buf(byte[] buf, int size, string group_id_list,
            string user_id, int user_top_num = 1);
        // 1:N人脸识别（传人脸特征值和库里的比对）
        /// <summary>
        /// 1:N人脸识别（传人脸特征值和库里的比对）
        /// </summary>
        /// <param name="feature"></param>
        /// <param name="fea_len"></param>
        /// <param name="group_id_list">组id列表。默认至少填写一个group_id，从指定的group中进行查找。需要同时查询多个group，用逗号分隔，上限10个</param>
        /// <param name="user_id">用户id，若指定了某个user，则只会与指定group下的这个user进行对比；若user_id传空字符串” ”，则会与此group下的所有user进行1：N识别</param>
        /// <param name="user_top_num">识别后返回的用户top数，默认为1，最多返回50个结果</param>
        /// <returns></returns>
        [DllImport("BaiduFaceApi.dll", EntryPoint = "identify_by_feature", CharSet = CharSet.Ansi
          , CallingConvention = CallingConvention.Cdecl)]
        public static extern IntPtr identify_by_feature(byte[] feature, int fea_len, string group_id_list,
            string user_id, int user_top_num = 1);

        // 提前加载库里所有数据到内存中
        /// <summary>
        /// 提前加载库里所有数据到内存中
        /// </summary>
        /// <returns></returns>
        [DllImport("BaiduFaceApi.dll", EntryPoint = "load_db_face", CharSet = CharSet.Ansi
          , CallingConvention = CallingConvention.Cdecl)]
        public static extern bool load_db_face();

        // 1:N人脸识别（传人脸图片文件和内存已加载的整个库数据比对）
        /// <summary>
        /// 1:N人脸识别（传人脸图片文件和内存已加载的整个库数据比对）
        /// </summary>
        /// <param name="image"></param>
        /// <param name="user_top_num"></param>
        /// <returns></returns>
        [DllImport("BaiduFaceApi.dll", EntryPoint = "identify_with_all", CharSet = CharSet.Ansi
          , CallingConvention = CallingConvention.Cdecl)]
        public static extern IntPtr identify_with_all(string image, int user_top_num = 1);

        // 1:N人脸识别（传人脸图片文件和内存已加载的整个库数据比对）
        /// <summary>
        /// 
        /// </summary>
        /// <param name="image">图片的二进制文件</param>
        /// <param name="size"></param>
        /// <param name="user_top_num"></param>
        /// <returns></returns>
        [DllImport("BaiduFaceApi.dll", EntryPoint = "identify_by_buf_with_all", CharSet = CharSet.Ansi
          , CallingConvention = CallingConvention.Cdecl)]
        public static extern IntPtr identify_by_buf_with_all(byte[] image, int size, int user_top_num = 1);

        // 1:N人脸识别（传人脸特征值和内存已加载的整个库数据比对）
        /// <summary>
        /// 1:N人脸识别（传人脸特征值和内存已加载的整个库数据比对）
        /// </summary>
        /// <param name="feature"></param>
        /// <param name="fea_len"></param>
        /// <param name="user_top_num"></param>
        /// <returns></returns>
        [DllImport("BaiduFaceApi.dll", EntryPoint = "identify_by_feature_with_all", CharSet = CharSet.Ansi
          , CallingConvention = CallingConvention.Cdecl)]
        public static extern IntPtr identify_by_feature_with_all(byte[] feature, int fea_len, int user_top_num = 1);


        // 测试获取人脸特征值(2048个byte）
        public void test_get_face_feature()
        {
            byte[] fea = new byte[2048];
            string file_name = "G:\\Development\\Application\\testface\\img\\beckham\\2.jpg";
            int len = 0;
            IntPtr ptr = get_face_feature(file_name, ref len);
            if (ptr == IntPtr.Zero)
            {
                Console.WriteLine("get face feature error");
            }
            else
            {
                if (len == 2048)
                {
                    Console.WriteLine("get face feature success");
                    Marshal.Copy(ptr, fea, 0, 2048);
                    // 可保存特征值2048个字节的fea到文件中
                    // FileUtil.byte2file("G:\\Development\\Application\\testface\\img\\beckham\\fea1.txt",fea, 2048);
                }
                else
                {
                    Console.WriteLine("get face feature error");
                }
            }
        }
        /// <summary>
        /// 获取人脸特征值(2048个byte）
        /// </summary>
        /// <param name="fileName"></param>
        /// <returns></returns>
        public string GetFaceFeature(string fileName)
        {
            try
            {
                byte[] fea = new byte[2048];
                string file_name = fileName == null ? fileName : "G:\\Development\\Application\\testface\\img\\beckham\\2.jpg";
                int len = 0;
                IntPtr ptr = get_face_feature(file_name, ref len);
                if (ptr == IntPtr.Zero)
                {
                    Console.WriteLine("get face feature error");
                    return "error";
                }
                else
                {
                    if (len == 2048)
                    {
                        Console.WriteLine("get face feature success");
                        Marshal.Copy(ptr, fea, 0, 2048);
                        return fea.ToString();
                        // 可保存特征值2048个字节的fea到文件中
                        // FileUtil.byte2file("G:\\Development\\Application\\testface\\img\\beckham\\fea1.txt",fea, 2048);
                    }
                    else
                    {
                        Console.WriteLine("get face feature error");
                        return "error";
                    }
                }
            }
            catch (Exception e)
            {
                throw e;
            }
        }
        /// <summary>
        /// 获取人脸特征值 2048Byte
        /// </summary>
        /// <param name="file_name">图片信息，数据大小小于10M，传入图片文件路径</param>
        /// <param name="length">通过引用返回特征值的长度，若为2048表示提取正确，其他值表示提取了错误的特征值</param>
        /// <returns></returns>
        public string GetFaceFeature(string file_name, ref int length)
        {
            byte[] fea = new byte[2048];
            int len = length == 0 ? 0 : length; //defalut=0
            string result = "";
            IntPtr ptr = get_face_feature(file_name, ref len);
            if (ptr == IntPtr.Zero)
            {
                result = ("get face feature error");
            }
            else
            {
                if (len == 2048)
                {
                    result = ("get face feature success");
                    Marshal.Copy(ptr, fea, 0, 2048);
                    // 可保存特征值2048个字节的fea到文件中
                    // FileUtil.byte2file("G:\\Development\\Application\\testface\\img\\beckham\\fea1.txt",fea, 2048);
                }
                else
                {
                    result = ("get face feature error");
                }
            }
            return result;
        }


        //// 测试获取人脸特征值(2048个byte）
        //public void test_get_face_feature_by_buf()
        //{
        //    byte[] fea = new byte[2048];
        //    System.Drawing.Image img = System.Drawing.Image.FromFile("G:\\Development\\Application\\testface\\img\\beckham\\2.jpg");
        //    byte[] img_bytes = ImageUtil.img2byte(img);
        //    int len = 0;
        //    IntPtr ptr = get_face_feature_by_buf(img_bytes, img_bytes.Length, ref len);
        //    if (ptr == IntPtr.Zero)
        //    {
        //        Console.WriteLine("get face feature error");
        //    }
        //    else
        //    {
        //        if (len == 2048)
        //        {
        //            Console.WriteLine("get face feature success");
        //            Marshal.Copy(ptr, fea, 0, 2048);
        //            // 可保存特征值2048个字节的fea到文件中
        //            //  FileUtil.byte2file("G:\\Development\\Application\\testface\\img\\beckham\\fea2.txt",fea, 2048);
        //        }
        //        else
        //        {
        //            Console.WriteLine("get face feature error");
        //        }
        //    }
        //}

        ///// <summary>
        ///// 获取人脸特征值 2048byte
        ///// </summary>
        ///// <param name="filePath"></param>
        ///// <returns></returns>
        //public string GetFaceFeatureByBuffer(string filePath)
        //{
        //    byte[] fea = new byte[2048];
        //    string result = "";
        //    System.Drawing.Image img = System.Drawing.Image.FromFile(filePath);
        //    byte[] img_bytes = ImageUtil.img2byte(img);
        //    int len = 0;
        //    IntPtr ptr = get_face_feature_by_buf(img_bytes, img_bytes.Length, ref len);
        //    if (ptr == IntPtr.Zero)
        //    {
        //        result = ("get face feature error");
        //    }
        //    else
        //    {
        //        if (len == 2048)
        //        {
        //            result = ("get face feature success");
        //            Marshal.Copy(ptr, fea, 0, 2048);
        //            // 可保存特征值2048个字节的fea到文件中
        //            //  FileUtil.byte2file("G:\\Development\\Application\\testface\\img\\beckham\\fea2.txt",fea, 2048);
        //        }
        //        else
        //        {
        //            result = ("get face feature error");
        //        }
        //    }
        //    return result;
        //}


        // 测试1:1比较，传入图片文件路径
        public void test_match()
        {
            string file1 = "G:\\Development\\Application\\testface\\img\\beckham\\1.jpg";
            string file2 = "G:\\Development\\Application\\testface\\img\\beckham\\9.jpg";
            IntPtr ptr = match(file1, file2);
            string buf = Marshal.PtrToStringAnsi(ptr);
            Console.WriteLine("match res is:" + buf);
        }
        /// <summary>
        /// 1:1比较 传入图片文件路径
        /// </summary>
        /// <param name="file1"></param>
        /// <param name="file2"></param>
        /// <returns></returns>
        public string FaceMatch(string file1, string file2)
        {
            IntPtr ptr = match(file1, file2);
            string buf = Marshal.PtrToStringAnsi(ptr);
            Console.WriteLine("match res is:" + buf);
            return buf;
        }
        // 测试1:1比较，传入图片文件二进制buffer
        //public void test_match_by_buf()
        //{
        //    System.Drawing.Image img1 = System.Drawing.Image.FromFile("d:\\444.bmp");
        //    byte[] img_bytes1 = ImageUtil.img2byte(img1);

        //    System.Drawing.Image img2 = System.Drawing.Image.FromFile("d:\\555.png");
        //    byte[] img_bytes2 = ImageUtil.img2byte(img2);
        //    Console.WriteLine("IntPtr ptr = match_by_buf");
        //    IntPtr ptr = match_by_buf(img_bytes1, img_bytes1.Length, img_bytes2, img_bytes2.Length);
        //    string buf = Marshal.PtrToStringAnsi(ptr);
        //    Console.WriteLine("match_by_buf res is:" + buf);
        //}
        /// <summary>
        /// 1:1比较 传图片二进制Buffer
        /// </summary>
        /// <param name="file1"></param>
        /// <param name="file2"></param>
        /// <returns></returns>
        public string FaceMatchByBuffer(byte[] file1, byte[] file2)
        {
            // System.Drawing.Image img1 = System.Drawing.Image.FromFile(file1);
            byte[] img_bytes1 = file1; // ImageUtil.img2byte(img1);

            // System.Drawing.Image img2 = System.Drawing.Image.FromFile(file2);
            byte[] img_bytes2 = file2; // ImageUtil.img2byte(img2);
            Console.WriteLine("IntPtr ptr = match_by_buf");
            IntPtr ptr = match_by_buf(img_bytes1, img_bytes1.Length, img_bytes2, img_bytes2.Length);
            string buf = Marshal.PtrToStringAnsi(ptr);
            return ("match_by_buf res is:" + buf);
        }
        // 测试1:1比较，传入opencv视频帧
        public void test_match_by_mat()
        {
            Mat img1 = Cv2.ImRead("d:\\444.bmp");
            Mat img2 = Cv2.ImRead("d:\\555.png");
            IntPtr ptr = match_by_mat(img1.CvPtr, img2.CvPtr);// img_bytes1, img_bytes1.Length, img_bytes2, img_bytes2.Length);
            string buf = Marshal.PtrToStringAnsi(ptr);
            Console.WriteLine("match_by_buf res is:" + buf);
        }
        /// <summary>
        /// 1:1比较，传入opencv视频帧
        /// </summary>
        /// <param name="file1"></param>
        /// <param name="file2"></param>
        /// <returns></returns>
        public string FaceMatchByMat(string file1, string file2)
        {
            Mat img1 = Cv2.ImRead(file1);
            Mat img2 = Cv2.ImRead(file2);
            IntPtr ptr = match_by_mat(img1.CvPtr, img2.CvPtr);// img_bytes1, img_bytes1.Length, img_bytes2, img_bytes2.Length);
            string buf = Marshal.PtrToStringAnsi(ptr);
            return ("match_by_buf res is:" + buf);

        }
        // 测试根据特征值和图片二进制buf比较
        //public void test_match_by_feature()
        //{
        //    // 获取特征值2048个字节
        //    byte[] fea = new byte[2048];
        //    string file_name = "G:\\Development\\Application\\testface\\img\\beckham\\2.jpg";
        //    int len = 0;
        //    IntPtr ptr = get_face_feature(file_name, ref len);
        //    if (len != 2048)
        //    {
        //        Console.WriteLine("get face feature error!");
        //        return;
        //    }
        //    Marshal.Copy(ptr, fea, 0, 2048);
        //    // 获取图片二进制buffer
        //    System.Drawing.Image img2 = System.Drawing.Image.FromFile("G:\\Development\\Application\\testface\\img\\beckham\\8.jpg");
        //    byte[] img_bytes2 = ImageUtil.img2byte(img2);

        //    IntPtr ptr_res = match_by_feature(fea, fea.Length, img_bytes2, img_bytes2.Length);
        //    string buf = Marshal.PtrToStringAnsi(ptr_res);
        //    Console.WriteLine("match_by_feature res is:" + buf);

        //}
        /// <summary>
        /// 根据特征值和图片二进制buf比较
        /// </summary>
        /// <param name="file_name">需要对比的特征值</param>
        /// <param name="file_buffer">需要对比的第二张图片，小于10M</param>
        /// <returns></returns>
        public string FaceMatchByFeature(byte[] file_name, byte[] file_buffer)
        {
            // 获取特征值2048个字节
            byte[] fea = file_name; // new byte[2048];
            //int len = 0;
            //IntPtr ptr = get_face_feature(file_name, ref len);
            //if (len != 2048)
            //{
            //    return ("get face feature error!");
            //}
            //Marshal.Copy(ptr, fea, 0, 2048);
            //// 获取图片二进制buffer
            //System.Drawing.Image img2 = System.Drawing.Image.FromFile(file_buffer);
            byte[] img_bytes2 = file_buffer; // ImageUtil.img2byte(img2);

            IntPtr ptr_res = match_by_feature(fea, fea.Length, img_bytes2, img_bytes2.Length);
            string buf = Marshal.PtrToStringAnsi(ptr_res);
            Console.WriteLine("match_by_feature res is:" + buf);
            return buf;

        }

        // 测试1:N比较，传入图片文件路径
        public /*void*/string test_identify(string str, string usr_grp, string usr_id)
        {
            string file1 = str;//"G:\\Development\\Application\\testface\\img\\beckham\\6.jpg";
            string user_group = usr_grp;//"test_group";
            string user_id = usr_id;//"test_user";
            IntPtr ptr = identify(file1, user_group, user_id);
            string buf = Marshal.PtrToStringAnsi(ptr);
            Console.WriteLine("identify res is:" + buf);
            return buf;
        }
        /// <summary>
        /// 1:N比较，传入图片文件路径
        /// </summary>
        /// <param name="file">图片信息，数据大小小于10M，传入图片文件路径</param>
        /// <param name="user_group">组id列表。默认至少填写一个group_id，从指定的group中进行查找。需要同时查询多个group，用逗号分隔，上限10个</param>
        /// <param name="user_id">用户id，若指定了某个user，则只会与指定group下的这个user进行对比；若user_id传空字符串” ”，则会与此group下的所有user进行1：N识别</param>
        /// <returns></returns>
        public static string FaceIdentify(string file, string user_group, string user_id)
        {
            string file1 = file;
            IntPtr ptr = identify(file1, user_group, user_id);
            string buf = Marshal.PtrToStringAnsi(ptr);
            Console.WriteLine("identify res is:" + buf);
            return buf;
        }

        // 测试1:N比较，传入图片文件二进制buffer
        //public void test_identify_by_buf(string str, string usr_grp, string usr_id)
        //{
        //    System.Drawing.Image img = System.Drawing.Image.FromFile(str);//"G:\\Development\\Application\\testface\\img\\beckham\\2.jpg");
        //    byte[] img_bytes = ImageUtil.img2byte(img);

        //    string user_group = usr_grp;//"test_group";
        //    string user_id = usr_id;// "test_user";
        //    IntPtr ptr = identify_by_buf(img_bytes, img_bytes.Length, user_group, user_id);
        //    string buf = Marshal.PtrToStringAnsi(ptr);
        //    Console.WriteLine("identify_by_buf res is:" + buf);
        //}
        /// <summary>
        /// 1:N比较，传入图片文件二进制buffer
        /// </summary>
        /// <param name="str">二进制图片信息，数据大小小于10M</param>
        /// <param name="usr_grp">组id列表。默认至少填写一个group_id，从指定的group中进行查找。需要同时查询多个group，用逗号分隔，上限10个</param>
        /// <param name="usr_id">用户id，若指定了某个user，则只会与指定group下的这个user进行对比；若user_id传空字符串” ”，则会与此group下的所有user进行1：N识别</param>
        /// <returns></returns>
        public string FaceIdentifyByBuffer(byte[] str, string usr_grp, string usr_id)
        {
            // System.Drawing.Image img = System.Drawing.Image.FromFile(str);
            byte[] img_bytes = str; // ImageUtil.img2byte(img);

            string user_group = usr_grp;//"test_group";
            string user_id = usr_id;// "test_user";
            IntPtr ptr = identify_by_buf(img_bytes, img_bytes.Length, user_group, user_id);
            string buf = Marshal.PtrToStringAnsi(ptr);
            Console.WriteLine("identify_by_buf res is:" + buf);
            return buf;
        }

        // 测试1:N比较，传入提取的人脸特征值
        public void test_identify_by_feature()
        {
            // 获取特征值2048个字节
            byte[] fea = new byte[2048];
            string file_name = "G:\\Development\\Application\\testface\\img\\beckham\\2.jpg";
            int len = 0;
            IntPtr ptr = get_face_feature(file_name, ref len);
            if (len != 2048)
            {
                Console.WriteLine("get face feature error!");
                return;
            }
            Marshal.Copy(ptr, fea, 0, 2048);

            string user_group = "test_group";
            string user_id = "test_user";
            IntPtr ptr_res = identify_by_feature(fea, fea.Length, user_group, user_id);
            string buf = Marshal.PtrToStringAnsi(ptr_res);
            Console.WriteLine("identify_by_feature res is:" + buf);
        }
        /// <summary>
        /// 1:N比较，传入提取的人脸特征值
        /// </summary>
        /// <param name="file_name">传入图片特征</param>
        /// <param name="userGroup">组id列表。默认至少填写一个group_id，从指定的group中进行查找。需要同时查询多个group，用逗号分隔，上限10个</param>
        /// <param name="userId">用户id，若指定了某个user，则只会与指定group下的这个user进行对比；若user_id传空字符串” ”，则会与此group下的所有user进行1：N识别</param>
        /// 
        public static string FaceIdentifyByFeature(string file_name, string userGroup, string userId)
        {
            // 获取特征值2048个字节
            byte[] fea = new byte[2048];
            int len = 0;
            IntPtr ptr = get_face_feature(file_name, ref len);
            if (len != 2048)
            {
                return ("get face feature error!");
            }
            Marshal.Copy(ptr, fea, 0, 2048);

            string user_group = userGroup == null ? "test_group" : userGroup;
            string user_id = userId == null ? "test_user" : userId;
            IntPtr ptr_res = identify_by_feature(fea, fea.Length, user_group, user_id);
            string buf = Marshal.PtrToStringAnsi(ptr_res);
            Console.WriteLine("identify_by_feature res is:" + buf);
            return buf;
        }

        // 通过特征值比对（1:1）
        public void test_compare_feature()
        {
            // 获取特征值1   共2048个字节
            byte[] fea1 = new byte[2048];
            string file_name1 = "G:\\Development\\Application\\testface\\img\\beckham\\2.jpg";
            int len1 = 0;
            IntPtr ptr1 = get_face_feature(file_name1, ref len1);
            if (len1 != 2048)
            {
                Console.WriteLine("get face feature error!");
                return;
            }
            Marshal.Copy(ptr1, fea1, 0, 2048);

            // 获取特征值2   共2048个字节
            byte[] fea2 = new byte[2048];
            string file_name2 = "G:\\Development\\Application\\testface\\img\\beckham\\8.jpg";
            int len2 = 0;
            IntPtr ptr2 = get_face_feature(file_name2, ref len2);
            if (len2 != 2048)
            {
                Console.WriteLine("get face feature error!");
                return;
            }
            Marshal.Copy(ptr2, fea2, 0, 2048);
            // 比对
            float score = compare_feature(fea1, len1, fea2, len2);
            Console.WriteLine("compare_feature score is:" + score);
        }
        /// <summary>
        /// 通过特征值比对（1:1） 对人脸特征值进行比较，可返回人脸特征相似分值（百分制）
        /// </summary>
        /// <param name="file_name1">2048个byte数组的特征值(传图片路径)</param>
        /// <param name="file_name2">2048个byte数组的特征值（传图片路径）</param>
        /// <returns></returns>
        public static string FaceCompareFeature(string file_name1, string file_name2)
        {
            string mes = "入：";
            try
            {

                // 获取特征值1   共2048个字节
                byte[] fea1 = new byte[2048];
                int len1 = 0;
                IntPtr ptr1 = get_face_feature(file_name1, ref len1);
                if (len1 != 2048)
                {
                    return mes += "get face feature error!";
                }
                Marshal.Copy(ptr1, fea1, 0, 2048);

                // 获取特征值2   共2048个字节
                byte[] fea2 = new byte[2048];
                int len2 = 0;
                IntPtr ptr2 = get_face_feature(file_name2, ref len2);
                if (len2 != 2048)
                {
                    return mes += "get face feature error!";
                }
                Marshal.Copy(ptr2, fea2, 0, 2048);
                // 比对
                // len1 特征值1的长度
                float score = compare_feature(fea1, len1, fea2, len2);
                Console.WriteLine("compare_feature score is:" + score);
                return mes += score.ToString();

            }
            catch (Exception ex)
            {
                return mes += ex;
            }
        }
        /// <summary>
        /// 通过特征值比对（1:1） 对人脸特征值进行比较，可返回人脸特征相似分值（百分制）
        /// </summary>
        /// <param name="face1">2048个byte数组的特征值</param>
        /// <param name="face2">2048个byte数组的特征值</param>
        /// <returns></returns>
        public string FaceCompareFeatureByBuffer(byte[] face1, byte[] face2)
        {
            if (face1.Length == 2048 && face2.Length == 2048)
            {
                // 获取特征值1   共2048个字节
                byte[] fea1 = new byte[2048];
                fea1 = face1;
                int len1 = 0;
                // 获取特征值1   共2048个字节
                byte[] fea2 = new byte[2048];
                fea2 = face2;
                int len2 = 0;
                // 比对
                // len1 特征值1的长度
                float score = compare_feature(fea1, len1, fea2, len2);
                Console.WriteLine("compare_feature score is:" + score);
                return score.ToString();
            }
            else
            {
                return "byte should be 2048";
            }
        }

        // 测试1:N比较，传入提取的人脸特征值和已加载的内存中整个库比较
        public void test_identify_by_feature_with_all()
        {
            // 加载整个数据库到内存中
            load_db_face();
            // 获取特征值2048个字节
            byte[] fea = new byte[2048];
            string file_name = "G:\\Development\\Application\\testface\\img\\beckham\\2.jpg";
            int len = 0;
            IntPtr ptr = get_face_feature(file_name, ref len);
            if (len != 2048)
            {
                Console.WriteLine("get face feature error!");
                return;
            }
            Marshal.Copy(ptr, fea, 0, 2048);
            IntPtr ptr_res = identify_by_feature_with_all(fea, fea.Length);
            string buf = Marshal.PtrToStringAnsi(ptr_res);
            Console.WriteLine("identify_by_feature_with_all res is:" + buf);
        }
        /// <summary>
        /// 1:N比较，传入提取的人脸特征值和已加载的内存中整个库比较
        /// </summary>
        /// <param name="file_name">传入人脸文件特征值</param>
        /// <returns></returns>
        public string FaceIdentifyByFeatureWithAll(byte[] file_name)
        {
            // 加载整个数据库到内存中
            load_db_face();
            // 获取特征值2048个字节
            byte[] fea = new byte[2048];
            fea = file_name;
            int len = 0;
            //IntPtr ptr = get_face_feature(file_name, ref len);
            //if (len != 2048)
            //{
            //    Console.WriteLine("get face feature error!");
            //    return "error";
            //}
            // Marshal.Copy(ptr, fea, 0, 2048);
            IntPtr ptr_res = identify_by_feature_with_all(fea, fea.Length);
            string buf = Marshal.PtrToStringAnsi(ptr_res);
            Console.WriteLine("identify_by_feature_with_all res is:" + buf);
            return buf;
        }

        // 测试1:N比较，传入图片文件路径和已加载的内存中整个库比较
        public void test_identify_with_all()
        {
            // 加载整个数据库到内存中
            load_db_face();
            // 1:N
            string file1 = "G:\\Development\\Application\\testface\\img\\beckham\\3.jpg";
            IntPtr ptr = identify_with_all(file1);
            string buf = Marshal.PtrToStringAnsi(ptr);
            Console.WriteLine("identify_with_all res is:" + buf);
        }
        /// <summary>
        /// 1:N比较，传入图片文件路径和已加载的内存中整个库比较
        /// </summary>
        /// <param name="file1">传入图片路径</param>
        /// <returns></returns>
        public string FaceIndentifyWithAll(string file1)
        {
            // 加载整个数据库到内存中
            load_db_face();
            // 1:N
            IntPtr ptr = identify_with_all(file1);
            string buf = Marshal.PtrToStringAnsi(ptr);
            Console.WriteLine("identify_with_all res is:" + buf);
            return buf;
        }
       

        /// <summary>
        /// 1:N比较，传入图片文件二进制buffer和已加载的内存中整个库比较
        /// </summary>
        /// <param name="file_name"></param>
        /// <returns></returns>
        public string FaceIdentifyByBufferWithAll(byte[] file_name)
        {
            // 加载整个数据库到内存中
            load_db_face();
            // 1:N
            // System.Drawing.Image img = System.Drawing.Image.FromFile(file_name);
            byte[] img_bytes = file_name;// ImageUtil.img2byte(img);

            IntPtr ptr = identify_by_buf_with_all(img_bytes, img_bytes.Length);
            string buf = Marshal.PtrToStringAnsi(ptr);
            Console.WriteLine("identify_by_buf_with_all res is:" + buf);
            return buf;
        }

    }
}