C# 人脸识别库 0.1

[next ViewFaceCore 0.2]

.NET 人脸识别库 ViewFaceCore

这是基于 SeetaFace6 人脸识别开发的 .NET 平台下的人脸识别库
这是一个使用超简单的人脸识别库
这是一个基于 .NET Standard 2.0 开发的库
这个库已经发布到 NuGet ，你可以一键集成到你的项目
此项目可以免费商业使用

⭐、开源

开源协议：Apache-2.0
GitHub地址： ViewFaceCore
十分感谢您的小星星

一、示例

示例项目地址：WinForm 摄像头人脸检测
示例项目效果：

二、使用

一分钟在你的项目里集成人脸识别

1. 创建你的 .NET 应用

.NET Standard >= 2.0
.NET Core >= 2.0
.NET Framework >= 4.6.1^2

2. 使用 Nuget 安装 ViewFaceCore

• Author : View
• Version >= 0.1.1

此 Nuget 包会自动添加依赖的 C++ 库，以及最精简的识别模型。
如果需要其它场景的识别模型，请下载 SeetaFace6 模型文件。

3. 在项目中编写你的代码

• 按照 说明 自己编写
• 或者参考以下代码

简单的调用示例

static void Main()
        {
            ViewFace viewFace = new ViewFace((str) => { Debug.WriteLine(str); }); // 初始化人脸识别类，并设置 日志回调函数
            viewFace.DetectorSetting = new DetectorSetting() { FaceSize = 20, MaxWidth = 2000, MaxHeight = 2000, Threshold = 0.5 };

            // 系统默认使用的轻量级识别模型。如果对精度有要求，请切换到 Normal 模式；并下载需要模型文件 放入生成目录的 model 文件夹中
            viewFace.FaceType = FaceType.Normal;
            // 系统默认使用5个人脸关键点。//不建议改动，除非是使用口罩模型。
            viewFace.MarkType = MarkType.Light;

            #region 识别老照片
            float[] oldEigenValues;
            Bitmap oldImg = (Bitmap)Image.FromFile(@"C:UsersyangwOneDrive图片Camera RollIMG_20181103_142707.jpg"/*老图片路径*/); // 从文件中加载照片 // 或者视频帧等
            var oldFaces = viewFace.FaceDetector(oldImg); // 检测图片中包含的人脸信息。(置信度、位置、大小)
            if (oldFaces.Length > 0) //识别到人脸
            {
                { // 打印人脸信息
                    Console.WriteLine($"识别到的人脸数量：{oldFaces.Length} 。人脸信息：
");
                    Console.WriteLine($"序号	人脸置信度	位置X	位置Y	宽度	高度");
                    for (int i = 0; i < oldFaces.Length; i++)
                    {
                        Console.WriteLine($"{i + 1}	{oldFaces[i].Score}	{oldFaces[i].Location.X}	{oldFaces[i].Location.Y}	{oldFaces[i].Location.Width}	{oldFaces[i].Location.Height}");
                    }
                    Console.WriteLine();
                }
                var oldPoints = viewFace.FaceMark(oldImg, oldFaces[0]); // 获取 第一个人脸 的识别关键点。(人脸识别的关键点数据)
                oldEigenValues = viewFace.Extract(oldImg, oldPoints); // 获取 指定的关键点 的特征值。
            }
            else { oldEigenValues = new float[0]; /*未识别到人脸*/ }
            #endregion

            #region 识别新照片
            float[] newEigenValues;
            Bitmap newImg = (Bitmap)Image.FromFile(@"C:UsersyangwOneDrive图片Camera RollIMG_20181129_224339.jpg"/*新图片路径*/); // 从文件中加载照片 // 或者视频帧等
            var newFaces = viewFace.FaceDetector(newImg); // 检测图片中包含的人脸信息。(置信度、位置、大小)
            if (newFaces.Length > 0) //识别到人脸
            {
                { // 打印人脸信息
                    Console.WriteLine($"识别到的人脸数量：{newFaces.Length} 。人脸信息：
");
                    Console.WriteLine($"序号	人脸置信度	位置X	位置Y	宽度	高度");
                    for (int i = 0; i < newFaces.Length; i++)
                    {
                        Console.WriteLine($"{i + 1}	{newFaces[i].Score}	{newFaces[i].Location.X}	{newFaces[i].Location.Y}	{newFaces[i].Location.Width}	{newFaces[i].Location.Height}");
                    }
                    Console.WriteLine();
                }
                var newPoints = viewFace.FaceMark(newImg, newFaces[0]); // 获取 第一个人脸 的识别关键点。(人脸识别的关键点数据)
                newEigenValues = viewFace.Extract(newImg, newPoints); // 获取 指定的关键点 的特征值。
            }
            else { newEigenValues = new float[0]; /*未识别到人脸*/ }
            #endregion

            try
            {
                float similarity = viewFace.Similarity(oldEigenValues, newEigenValues); // 对比两张照片上的数据，确认是否是同一个人。
                Console.WriteLine($"阈值 = {Face.Threshold[viewFace.FaceType]}	相似度 = {similarity}");
                Console.WriteLine($"是否是同一个人：{viewFace.IsSelf(similarity)}");
            }
            catch (Exception e)
            { Console.WriteLine(e); }

            Console.ReadKey();
        }

三、说明

命名空间：ViewFaceCore.Sharp : 人脸识别类所在的命名空间

• 属性说明：

属性名称	类型	说明	默认值
ModelPath	string	获取或设置模型路径 [ 如非必要，请勿修改 ]	./model/
FaceType	FaceType	获取或设置人脸类型	FaceType.Light
MarkType	MarkType	获取或设置人脸关键点类型	MarkType.Light
DetectorSetting	DetectorSetting	获取或设置人脸检测器设置	new DetectorSetting()

• 方法说明：

using System.Drawing;
using ViewFaceCore.Sharp;
using ViewFaceCore.Sharp.Model;

// 识别 bitmap 中的人脸，并返回人脸的信息。
FaceInfo[] FaceDetector(Bitmap);

// 识别 bitmap 中指定的人脸信息 info 的关键点坐标。
FaceMarkPoint[] FaceMark(Bitmap, FaceInfo);

// 提取人脸特征值。
float[] Extract(Bitmap, FaceMarkPoint[]);

// 计算特征值相似度。
float Similarity(float[], float[]);

// 判断相似度是否为同一个人。
bool IsSelf(float);

四、实现

此项目受到了 SeetaFaceEngine.NET 项目的启发

这个项目本质上来说还是调用了 SeetaFace 的 C++ 类库来实现的人脸识别功能。针对本人遇到过的相关的类库的使用都不太方便，而且使用的 SeetaFace 的版本较老，故萌生了自己重新开发的想法。

本项目在开发完成之后为了方便调用，采用了 Nuget 包的形式，将所有需要的依赖以及最小识别模型一起打包。在使用时非常简单，只需要 nuget 安装，编写代码，运行即可，不需要多余的操作。

首先查看 SeetaFace ，已经更新到了v3(v6即v3)(上面前辈的项目是基于v1开发的)，最新版本暂时没有开源，但是可以免费商用。然后是根据以前的经验和 SeetaFace6 文档的指导，以及前辈的项目，做了以下操作。

1.对SeetaFace6 的接口进行了 C++ 形式的封装。

目前主要实现了 人脸检测，关键点提取，特征值提取，特征值对比几个人脸识别中的基础接口。有了这几个接口，可以完整的实现一套人脸识别和验证的流程。

• c++封装的接口代码如下：

#include "seeta/FaceDetector.h"
#include "seeta/FaceLandmarker.h"
#include "seeta/FaceRecognizer.h"

#include <time.h>

#define View_Api extern "C" __declspec(dllexport)

using namespace std;

typedef void(_stdcall* LogCallBack)(const char* logText);

string modelPath = "./model/"; // 模型所在路径
LogCallBack logger = NULL; // 日志回调函数

// 打印日志
void WriteLog(string str) { if (logger != NULL) { logger(str.c_str()); } }

void WriteMessage(string fanctionName, string message) { WriteLog(fanctionName + "	 Message:" + message); }
void WriteModelName(string fanctionName, string modelName) { WriteLog(fanctionName + "	 Model.Name:" + modelName); }
void WriteRunTime(string fanctionName, int start) { WriteLog(fanctionName + "	 Run.Time:" + to_string(clock() - start) + " ms"); }
void WriteError(string fanctionName, const std::exception& e) { WriteLog(fanctionName + "	 Error:" + e.what()); }

// 注册日志回调函数
View_Api void V_SetLogFunction(LogCallBack writeLog)
{
    logger = writeLog;
    WriteMessage(__FUNCDNAME__, "Successed.");
}

// 设置人脸模型目录
View_Api void V_SetModelPath(const char* path)
{
    modelPath = path;
    WriteMessage(__FUNCDNAME__, "Model.Path:" + modelPath);
}
// 获取人脸模型目录
View_Api bool V_GetModelPath(char** path)
{
    try
    {
#pragma warning(disable:4996)
        strcpy(*path, modelPath.c_str());

        return true;
    }
    catch (const std::exception& e)
    {
        WriteError(__FUNCDNAME__, e);
        return false;
    }
}

seeta::FaceDetector* v_faceDetector = NULL;

// 人脸检测结果
static SeetaFaceInfoArray detectorInfos;
// 人脸数量检测器
View_Api int V_DetectorSize(unsigned char* imgData, int width, int height, int channels, double faceSize = 20, double threshold = 0.9, double maxWidth = 2000, double maxHeight = 2000, int type = 0)
{
    try {
        clock_t start = clock();

        SeetaImageData img = { width, height, channels, imgData };
        if (v_faceDetector == NULL) {
            seeta::ModelSetting setting;
            setting.set_device(SEETA_DEVICE_CPU);
            string modelName = "face_detector.csta";
            switch (type)
            {
            case 1: modelName = "mask_detector.csta"; break;
            }
            setting.append(modelPath + modelName);
            WriteModelName(__FUNCDNAME__, modelName);
            v_faceDetector = new seeta::FaceDetector(setting);
        }

        if (faceSize != 20) { v_faceDetector->set(seeta::FaceDetector::Property::PROPERTY_MIN_FACE_SIZE, faceSize); }
        if (threshold != 0.9) { v_faceDetector->set(seeta::FaceDetector::Property::PROPERTY_THRESHOLD, threshold); }
        if (maxWidth != 2000) { v_faceDetector->set(seeta::FaceDetector::Property::PROPERTY_MAX_IMAGE_WIDTH, maxWidth); }
        if (maxHeight != 2000) { v_faceDetector->set(seeta::FaceDetector::Property::PROPERTY_MAX_IMAGE_HEIGHT, maxHeight); }

        auto infos = v_faceDetector->detect(img);
        detectorInfos = infos;

        WriteRunTime("V_Detector", start); // 此方法已经是人脸检测的全过程，故计时器显示为 人脸识别方法
        return infos.size;
    }
    catch (const std::exception& e)
    {
        WriteError(__FUNCDNAME__, e);
        return -1;
    }
}
// 人脸检测器
View_Api bool V_Detector(float* score, int* x, int* y, int* width, int* height)
{
    try
    {
        //clock_t start = clock();

        for (int i = 0; i < detectorInfos.size; i++, detectorInfos.data++)
        {
            *score = detectorInfos.data->score;
            *x = detectorInfos.data->pos.x;
            *y = detectorInfos.data->pos.y;
            *width = detectorInfos.data->pos.width;
            *height = detectorInfos.data->pos.height;
            score++, x++, y++, width++, height++;
        }
        detectorInfos.data = NULL;
        detectorInfos.size = NULL;

        //WriteRunTime(__FUNCDNAME__, start); // 此方法只是将 人脸数量检测器 获取到的数据赋值传递，并不耗时。故不显示此方法的调用时间
        return true;
    }
    catch (const std::exception& e)
    {
        WriteError(__FUNCDNAME__, e);
        return false;
    }
}


seeta::FaceLandmarker* v_faceLandmarker = NULL;
// 人脸关键点数量
View_Api int V_FaceMarkSize(int type = 0)
{
    try
    {
        clock_t start = clock();

        if (v_faceLandmarker == NULL) {
            seeta::ModelSetting setting;
            setting.set_device(SEETA_DEVICE_CPU);
            string modelName = "face_landmarker_pts68.csta";
            switch (type)
            {
            case 1: modelName = "face_landmarker_mask_pts5.csta"; break;
            case 2: modelName = "face_landmarker_pts5.csta"; break;
            }
            setting.append(modelPath + modelName);
            WriteModelName(__FUNCDNAME__, modelName);
            v_faceLandmarker = new seeta::FaceLandmarker(setting);
        }
        int size = v_faceLandmarker->number();

        WriteRunTime(__FUNCDNAME__, start);
        return size;
    }
    catch (const std::exception& e)
    {
        WriteError(__FUNCDNAME__, e);
        return -1;
    }
}
// 人脸关键点
View_Api bool V_FaceMark(unsigned char* imgData, int width, int height, int channels, int x, int y, int fWidth, int fHeight, double* pointX, double* pointY, int type = 0)
{
    try
    {
        clock_t start = clock();

        SeetaImageData img = { width, height, channels, imgData };
        SeetaRect face = { x, y, fWidth, fHeight };
        if (v_faceLandmarker == NULL) {
            seeta::ModelSetting setting;
            setting.set_device(SEETA_DEVICE_CPU);
            string modelName = "face_landmarker_pts68.csta";
            switch (type)
            {
            case 1: modelName = "face_landmarker_mask_pts5.csta"; break;
            case 2: modelName = "face_landmarker_pts5.csta"; break;
            }
            setting.append(modelPath + modelName);
            WriteModelName(__FUNCDNAME__, modelName);
            v_faceLandmarker = new seeta::FaceLandmarker(setting);
        }
        std::vector<SeetaPointF> _points = v_faceLandmarker->mark(img, face);

        if (!_points.empty()) {
            for (auto iter = _points.begin(); iter != _points.end(); iter++)
            {
                *pointX = (*iter).x;
                *pointY = (*iter).y;
                pointX++;
                pointY++;
            }

            WriteRunTime(__FUNCDNAME__, start);
            return true;
        }
        else { return false; }
    }
    catch (const std::exception& e)
    {
        WriteError(__FUNCDNAME__, e);
        return false;
    }
}

seeta::FaceRecognizer* v_faceRecognizer = NULL;
// 获取人脸特征值长度
View_Api int V_ExtractSize(int type = 0)
{
    try
    {
        clock_t start = clock();

        if (v_faceRecognizer == NULL) {
            seeta::ModelSetting setting;
            setting.set_id(0);
            setting.set_device(SEETA_DEVICE_CPU);
            string modelName = "face_recognizer.csta";
            switch (type)
            {
            case 1: modelName = "face_recognizer_mask.csta"; break;
            case 2: modelName = "face_recognizer_light.csta"; break;
            }
            setting.append(modelPath + modelName);
            WriteModelName(__FUNCDNAME__, modelName);
            v_faceRecognizer = new seeta::FaceRecognizer(setting);
        }
        int length = v_faceRecognizer->GetExtractFeatureSize();

        WriteRunTime(__FUNCDNAME__, start);
        return length;
    }
    catch (const std::exception& e)
    {
        WriteError(__FUNCDNAME__, e);
        return -1;
    }
}
// 提取人脸特征值
View_Api bool V_Extract(unsigned char* imgData, int width, int height, int channels, SeetaPointF* points, float* features, int type = 0)
{
    try
    {
        clock_t start = clock();

        SeetaImageData img = { width, height, channels, imgData };
        if (v_faceRecognizer == NULL) {
            seeta::ModelSetting setting;
            setting.set_id(0);
            setting.set_device(SEETA_DEVICE_CPU);
            string modelName = "face_recognizer.csta";
            switch (type)
            {
            case 1: modelName = "face_recognizer_mask.csta"; break;
            case 2: modelName = "face_recognizer_light.csta"; break;
            }
            setting.append(modelPath + modelName);
            WriteModelName(__FUNCDNAME__, modelName);
            v_faceRecognizer = new seeta::FaceRecognizer(setting);
        }
        int length = v_faceRecognizer->GetExtractFeatureSize();
        std::shared_ptr<float> _features(new float[v_faceRecognizer->GetExtractFeatureSize()], std::default_delete<float[]>());
        v_faceRecognizer->Extract(img, points, _features.get());

        for (int i = 0; i < length; i++)
        {
            *features = _features.get()[i];
            features++;
        }

        WriteRunTime(__FUNCDNAME__, start);
        return true;

    }
    catch (const std::exception& e)
    {
        WriteError(__FUNCDNAME__, e);
        return false;
    }
}
// 人脸特征值相似度计算
View_Api float V_CalculateSimilarity(float* leftFeatures, float* rightFeatures, int type = 0)
{
    try
    {
        clock_t start = clock();

        if (v_faceRecognizer == NULL) {
            seeta::ModelSetting setting;
            setting.set_id(0);
            setting.set_device(SEETA_DEVICE_CPU);
            string modelName = "face_recognizer.csta";
            switch (type)
            {
            case 1: modelName = "face_recognizer_mask.csta"; break;
            case 2: modelName = "face_recognizer_light.csta"; break;
            }
            setting.append(modelPath + modelName);
            WriteModelName(__FUNCDNAME__, modelName);
            v_faceRecognizer = new seeta::FaceRecognizer(setting);
        }

        auto similarity = v_faceRecognizer->CalculateSimilarity(leftFeatures, rightFeatures);
        WriteMessage(__FUNCDNAME__, "Similarity = " + to_string(similarity));
        WriteRunTime(__FUNCDNAME__, start);
        return similarity;
    }
    catch (const std::exception& e)
    {
        WriteError(__FUNCDNAME__, e);
        return -1;
    }
}

// 释放资源
View_Api void V_Dispose()
{
    if (v_faceDetector != NULL) delete v_faceDetector;
    if (v_faceLandmarker != NULL) delete v_faceLandmarker;
    if (v_faceRecognizer != NULL) delete v_faceRecognizer;
}

2.采用 C# 对上诉接口进行了导入。

因为C++的项目测CPU架构区分x86和x64，所以C# 层也需要区分架构封装

using System.Runtime.InteropServices;
using System.Text;
using ViewFaceCore.Sharp.Model;

namespace ViewFaceCore.Plus
{
    /// <summary>
    /// 日志回调函数
    /// </summary>
    /// <param name="logText"></param>
    public delegate void LogCallBack(string logText);

    class ViewFacePlus64
    {
        const string LibraryPath = @"FaceLibrariesx64ViewFace.dll";
        /// <summary>
        /// 设置日志回调函数(用于日志打印)
        /// </summary>
        /// <param name="writeLog"></param>
        [DllImport(LibraryPath, EntryPoint = "V_SetLogFunction", CallingConvention = CallingConvention.Cdecl)]
        public static extern void SetLogFunction(LogCallBack writeLog);

        /// <summary>
        /// 设置人脸模型的目录
        /// </summary>
        /// <param name="path"></param>
        [DllImport(LibraryPath, EntryPoint = "V_SetModelPath", CallingConvention = CallingConvention.Cdecl)]
        private extern static void SetModelPath(byte[] path);
        /// <summary>
        /// 设置人脸模型的目录
        /// </summary>
        /// <param name="path"></param>
        public static void SetModelPath(string path) => SetModelPath(Encoding.UTF8.GetBytes(path));

        /// <summary>
        /// 释放使用的资源
        /// </summary>
        [DllImport(LibraryPath, EntryPoint = "V_Dispose", CallingConvention = CallingConvention.Cdecl)]
        public extern static void ViewDispose();

        /// <summary>
        /// 获取人脸模型的目录
        /// </summary>
        /// <param name="path"></param>
        [DllImport(LibraryPath, EntryPoint = "V_GetModelPath", CallingConvention = CallingConvention.Cdecl)]
        private extern static bool GetModelPathEx(ref string path);
        /// <summary>
        /// 获取人脸模型的目录
        /// </summary>
        public static string GetModelPath() { string path = string.Empty; GetModelPathEx(ref path); return path; }

        /// <summary>
        /// 人脸检测器检测到的人脸数量
        /// </summary>
        /// <param name="imgData"></param>
        /// <param name="width"></param>
        /// <param name="height"></param>
        /// <param name="channels"></param>
        /// <param name="faceSize">最小人脸是人脸检测器常用的一个概念，默认值为20，单位像素。
        /// <para>最小人脸和检测器性能息息相关。主要方面是速度，使用建议上，我们建议在应用范围内，这个值设定的越大越好。SeetaFace采用的是BindingBox Regresion的方式训练的检测器。如果最小人脸参数设置为80的话，从检测能力上，可以将原图缩小的原来的1/4，这样从计算复杂度上，能够比最小人脸设置为20时，提速到16倍。</para>
        /// </param>
        /// <param name="threshold">检测器阈值默认值是0.9，合理范围为[0, 1]。这个值一般不进行调整，除了用来处理一些极端情况。这个值设置的越小，漏检的概率越小，同时误检的概率会提高</param>
        /// <param name="maxWidth">可检测的图像最大宽度。默认值2000。</param>
        /// <param name="maxHeight">可检测的图像最大高度。默认值2000。</param>
        /// <param name="type"></param>
        /// <returns></returns>
        [DllImport(LibraryPath, EntryPoint = "V_DetectorSize", CallingConvention = CallingConvention.Cdecl)]
        public extern static int DetectorSize(byte[] imgData, int width, int height, int channels, double faceSize = 20, double threshold = 0.9, double maxWidth = 2000, double maxHeight = 2000, int type = 0);
        /// <summary>
        /// 人脸检测器
        /// <para>调用此方法前必须先调用 <see cref="DetectorSize(byte[], int, int, int, double, double, double, double, int)"/></para>
        /// </summary>
        /// <param name="score">人脸置信度集合</param>
        /// <param name="x">人脸位置集合</param>
        /// <param name="y">人脸位置集合</param>
        /// <param name="width">人脸大小集合</param>
        /// <param name="height">人脸大小集合</param>
        /// <returns></returns>
        [DllImport(LibraryPath, EntryPoint = "V_Detector", CallingConvention = CallingConvention.Cdecl)]
        public extern static bool Detector(float[] score, int[] x, int[] y, int[] width, int[] height);

        /// <summary>
        /// 人脸关键点数量
        /// </summary>
        /// <returns></returns>
        [DllImport(LibraryPath, EntryPoint = "V_FaceMarkSize", CallingConvention = CallingConvention.Cdecl)]
        public extern static int FaceMarkSize(int type = 0);
        /// <summary>
        /// 人脸关键点
        /// </summary>
        /// <param name="imgData"></param>
        /// <param name="width"></param>
        /// <param name="height"></param>
        /// <param name="channels"></param>
        /// <param name="x"></param>
        /// <param name="y"></param>
        /// <param name="fWidth"></param>
        /// <param name="fHeight"></param>
        /// <param name="pointX"></param>
        /// <param name="pointY"></param>
        /// <param name="type"></param>
        /// <returns></returns>
        [DllImport(LibraryPath, EntryPoint = "V_FaceMark", CallingConvention = CallingConvention.Cdecl)]
        public extern static bool FaceMark(byte[] imgData, int width, int height, int channels, int x, int y, int fWidth, int fHeight, double[] pointX, double[] pointY, int type = 0);

        /// <summary>
        /// 提取特征值
        /// </summary>
        /// <param name="imgData"></param>
        /// <param name="width"></param>
        /// <param name="height"></param>
        /// <param name="channels"></param>
        /// <param name="points"></param>
        /// <param name="features"></param>
        /// <param name="type"></param>
        /// <returns></returns>
        [DllImport(LibraryPath, EntryPoint = "V_Extract", CallingConvention = CallingConvention.Cdecl)]
        public extern static bool Extract(byte[] imgData, int width, int height, int channels, FaceMarkPoint[] points, float[] features, int type = 0);
        /// <summary>
        /// 特征值大小
        /// </summary>
        /// <returns></returns>
        [DllImport(LibraryPath, EntryPoint = "V_ExtractSize", CallingConvention = CallingConvention.Cdecl)]
        public extern static int ExtractSize(int type = 0);

        /// <summary>
        /// 计算相似度
        /// </summary>
        /// <param name="leftFeatures"></param>
        /// <param name="rightFeatures"></param>
        /// <param name="type"></param>
        /// <returns></returns>
        [DllImport(LibraryPath, EntryPoint = "V_CalculateSimilarity", CallingConvention = CallingConvention.Cdecl)]
        public extern static float Similarity(float[] leftFeatures, float[] rightFeatures, int type = 0);
    }
    class ViewFacePlus32
    {
        const string LibraryPath = @"FaceLibrariesx86ViewFace.dll";
        /// <summary>
        /// 设置日志回调函数(用于日志打印)
        /// </summary>
        /// <param name="writeLog"></param>
        [DllImport(LibraryPath, EntryPoint = "V_SetLogFunction", CallingConvention = CallingConvention.Cdecl)]
        public static extern void SetLogFunction(LogCallBack writeLog);

        /// <summary>
        /// 设置人脸模型的目录
        /// </summary>
        /// <param name="path"></param>
        [DllImport(LibraryPath, EntryPoint = "V_SetModelPath", CallingConvention = CallingConvention.Cdecl)]
        private extern static void SetModelPath(byte[] path);
        /// <summary>
        /// 设置人脸模型的目录
        /// </summary>
        /// <param name="path"></param>
        public static void SetModelPath(string path) => SetModelPath(Encoding.UTF8.GetBytes(path));

        /// <summary>
        /// 释放使用的资源
        /// </summary>
        [DllImport(LibraryPath, EntryPoint = "V_Dispose", CallingConvention = CallingConvention.Cdecl)]
        public extern static void ViewDispose();

        /// <summary>
        /// 获取人脸模型的目录
        /// </summary>
        /// <param name="path"></param>
        [DllImport(LibraryPath, EntryPoint = "V_GetModelPath", CallingConvention = CallingConvention.Cdecl)]
        private extern static bool GetModelPathEx(ref string path);
        /// <summary>
        /// 获取人脸模型的目录
        /// </summary>
        public static string GetModelPath() { string path = string.Empty; GetModelPathEx(ref path); return path; }

        /// <summary>
        /// 人脸检测器检测到的人脸数量
        /// </summary>
        /// <param name="imgData"></param>
        /// <param name="width"></param>
        /// <param name="height"></param>
        /// <param name="channels"></param>
        /// <param name="faceSize">最小人脸是人脸检测器常用的一个概念，默认值为20，单位像素。
        /// <para>最小人脸和检测器性能息息相关。主要方面是速度，使用建议上，我们建议在应用范围内，这个值设定的越大越好。SeetaFace采用的是BindingBox Regresion的方式训练的检测器。如果最小人脸参数设置为80的话，从检测能力上，可以将原图缩小的原来的1/4，这样从计算复杂度上，能够比最小人脸设置为20时，提速到16倍。</para>
        /// </param>
        /// <param name="threshold">检测器阈值默认值是0.9，合理范围为[0, 1]。这个值一般不进行调整，除了用来处理一些极端情况。这个值设置的越小，漏检的概率越小，同时误检的概率会提高</param>
        /// <param name="maxWidth">可检测的图像最大宽度。默认值2000。</param>
        /// <param name="maxHeight">可检测的图像最大高度。默认值2000。</param>
        /// <param name="type"></param>
        /// <returns></returns>
        [DllImport(LibraryPath, EntryPoint = "V_DetectorSize", CallingConvention = CallingConvention.Cdecl)]
        public extern static int DetectorSize(byte[] imgData, int width, int height, int channels, double faceSize = 20, double threshold = 0.9, double maxWidth = 2000, double maxHeight = 2000, int type = 0);
        /// <summary>
        /// 人脸检测器
        /// <para>调用此方法前必须先调用 <see cref="DetectorSize(byte[], int, int, int, double, double, double, double, int)"/></para>
        /// </summary>
        /// <param name="score">人脸置信度集合</param>
        /// <param name="x">人脸位置集合</param>
        /// <param name="y">人脸位置集合</param>
        /// <param name="width">人脸大小集合</param>
        /// <param name="height">人脸大小集合</param>
        /// <returns></returns>
        [DllImport(LibraryPath, EntryPoint = "V_Detector", CallingConvention = CallingConvention.Cdecl)]
        public extern static bool Detector(float[] score, int[] x, int[] y, int[] width, int[] height);

        /// <summary>
        /// 人脸关键点数量
        /// </summary>
        /// <returns></returns>
        [DllImport(LibraryPath, EntryPoint = "V_FaceMarkSize", CallingConvention = CallingConvention.Cdecl)]
        public extern static int FaceMarkSize(int type = 0);
        /// <summary>
        /// 人脸关键点
        /// </summary>
        /// <param name="imgData"></param>
        /// <param name="width"></param>
        /// <param name="height"></param>
        /// <param name="channels"></param>
        /// <param name="x"></param>
        /// <param name="y"></param>
        /// <param name="fWidth"></param>
        /// <param name="fHeight"></param>
        /// <param name="pointX"></param>
        /// <param name="pointY"></param>
        /// <param name="type"></param>
        /// <returns></returns>
        [DllImport(LibraryPath, EntryPoint = "V_FaceMark", CallingConvention = CallingConvention.Cdecl)]
        public extern static bool FaceMark(byte[] imgData, int width, int height, int channels, int x, int y, int fWidth, int fHeight, double[] pointX, double[] pointY, int type = 0);

        /// <summary>
        /// 提取特征值
        /// </summary>
        /// <param name="imgData"></param>
        /// <param name="width"></param>
        /// <param name="height"></param>
        /// <param name="channels"></param>
        /// <param name="points"></param>
        /// <param name="features"></param>
        /// <param name="type"></param>
        /// <returns></returns>
        [DllImport(LibraryPath, EntryPoint = "V_Extract", CallingConvention = CallingConvention.Cdecl)]
        public extern static bool Extract(byte[] imgData, int width, int height, int channels, FaceMarkPoint[] points, float[] features, int type = 0);
        /// <summary>
        /// 特征值大小
        /// </summary>
        /// <returns></returns>
        [DllImport(LibraryPath, EntryPoint = "V_ExtractSize", CallingConvention = CallingConvention.Cdecl)]
        public extern static int ExtractSize(int type = 0);

        /// <summary>
        /// 计算相似度
        /// </summary>
        /// <param name="leftFeatures"></param>
        /// <param name="rightFeatures"></param>
        /// <param name="type"></param>
        /// <returns></returns>
        [DllImport(LibraryPath, EntryPoint = "V_CalculateSimilarity", CallingConvention = CallingConvention.Cdecl)]
        public extern static float Similarity(float[] leftFeatures, float[] rightFeatures, int type = 0);
    }
}

3.采用 C# 的面向对象的封装

因为C#的项目默认都是 AnyCPU，所以为了简化调用，在这一层封装的时候增加了架构判断，当在你的项目中引用的时候，不用做任何修改。

且因为C++的C#导入方法在和原生的C#写法略有差异，且数据的转换和传递比较麻烦，所以类库中对外隐藏了 C# 导入层。并使用大家都更熟悉的C#的面向对象的方式进行进一步的封装和简化。

    /// <summary>
    /// 人脸识别类
    /// </summary>
    public class ViewFace
    {
        bool Platform64 { get; set; } = false;
        // <para>需要模型：<see langword=""/></para>

        // ctor
        /// <summary>
        /// 使用默认的模型目录初始化人脸识别类
        /// </summary>
        public ViewFace() : this("./model/") { }
        /// <summary>
        /// 使用指定的模型目录初始化人脸识别类
        /// </summary>
        /// <param name="modelPath">模型目录</param>
        public ViewFace(string modelPath)
        {
            Platform64 = IntPtr.Size == 8;
            if (Platform64)
            { ViewFacePlus64.SetModelPath(modelPath); }
            else
            { ViewFacePlus32.SetModelPath(modelPath); }
        }
        /// <summary>
        /// 使用指定的日志回调函数初始化人脸识别类
        /// </summary>
        /// <param name="action">日志回调函数</param>
        public ViewFace(LogCallBack action) : this("./model/", action) { }
        /// <summary>
        /// 使用指定的模型目录、日志回调函数初始化人脸识别类
        /// </summary>
        /// <param name="modelPath">模型目录</param>
        /// <param name="action">日志回调函数</param>
        public ViewFace(string modelPath, LogCallBack action) : this(modelPath)
        {
            if (Platform64)
            { ViewFacePlus64.SetLogFunction(action); }
            else
            { ViewFacePlus32.SetLogFunction(action); }
        }

        // public property
        /// <summary>
        /// 获取或设置模型路径
        /// </summary>
        public string ModelPath
        {
            get
            {
                if (Platform64)
                { return ViewFacePlus64.GetModelPath(); }
                else
                { return ViewFacePlus32.GetModelPath(); }
            }
            set
            {
                if (Platform64)
                { ViewFacePlus64.SetModelPath(value); }
                else
                { ViewFacePlus32.SetModelPath(value); }
            }
        }
        /// <summary>
        /// 获取或设置人脸类型
        /// <para>
        /// <listheader>此属性可影响到以下方法：</listheader><br />
        /// • <c><see cref="FaceDetector(Bitmap)"/></c><br />
        /// • <c><see cref="Extract(Bitmap, FaceMarkPoint[])"/></c><br />
        /// • <c><see cref="Similarity(float[], float[])"/></c><br />
        /// </para>
        /// </summary>
        public FaceType FaceType { get; set; } = FaceType.Light;
        /// <summary>
        /// 获取或设置人脸关键点类型
        /// <para>
        /// <listheader>此属性可影响到以下方法：</listheader><br />
        /// • <c><see cref="FaceMark(Bitmap, FaceInfo)"/></c><br />
        /// </para>
        /// </summary>
        public MarkType MarkType { get; set; } = MarkType.Light;
        /// <summary>
        /// 获取或设置人脸检测器设置
        /// </summary>
        public DetectorSetting DetectorSetting { get; set; } = new DetectorSetting();


        // public method
        /// <summary>
        /// 识别 <paramref name="bitmap"/> 中的人脸，并返回人脸的信息。
        /// <para>
        /// 当 <c><see cref="FaceType"/> <see langword="="/> <see cref="FaceType.Normal"/> <see langword="||"/> <see cref="FaceType.Light"/></c> 时， 需要模型：<see langword="face_detector.csta"/><br/>
        /// 当 <c><see cref="FaceType"/> <see langword="="/> <see cref="FaceType.Mask"/></c> 时， 需要模型：<see langword="mask_detector.csta"/><br/>
        /// </para>
        /// </summary>
        /// <param name="bitmap">包含人脸的图片</param>
        /// <returns></returns>
        public FaceInfo[] FaceDetector(Bitmap bitmap)
        {
            byte[] bgr = ImageSet.Get24BGRFromBitmap(bitmap, out int width, out int height, out int channels);
            int size;
            if (Platform64)
            { size = ViewFacePlus64.DetectorSize(bgr, width, height, channels, DetectorSetting.FaceSize, DetectorSetting.Threshold, DetectorSetting.MaxWidth, DetectorSetting.MaxHeight, (int)FaceType); }
            else
            { size = ViewFacePlus32.DetectorSize(bgr, width, height, channels, DetectorSetting.FaceSize, DetectorSetting.Threshold, DetectorSetting.MaxWidth, DetectorSetting.MaxHeight, (int)FaceType); }
            float[] _socre = new float[size];
            int[] _x = new int[size];
            int[] _y = new int[size];
            int[] _width = new int[size];
            int[] _height = new int[size];
            if (Platform64)
            { _ = ViewFacePlus64.Detector(_socre, _x, _y, _width, _height); }
            else
            { _ = ViewFacePlus32.Detector(_socre, _x, _y, _width, _height); }
            List<FaceInfo> infos = new List<FaceInfo>();
            for (int i = 0; i < size; i++)
            {
                infos.Add(new FaceInfo() { Score = _socre[i], Location = new FaceRect() { X = _x[i], Y = _y[i], Width = _width[i], Height = _height[i] } });
            }
            return infos.ToArray();
        }

        /// <summary>
        /// 识别 <paramref name="bitmap"/> 中指定的人脸信息 <paramref name="info"/> 的关键点坐标。
        /// <para>
        /// 当 <see cref="FaceType"/> <see langword="="/> <see cref="FaceType.Normal"/> 时， 需要模型：<see langword="face_landmarker_pts68.csta"/><br/>
        /// 当 <see cref="FaceType"/> <see langword="="/> <see cref="FaceType.Mask"/> 时， 需要模型：<see langword="face_landmarker_mask_pts5.csta"/><br/>
        /// 当 <see cref="FaceType"/> <see langword="="/> <see cref="FaceType.Light"/> 时， 需要模型：<see langword="face_landmarker_pts5.csta"/><br/>
        /// </para>
        /// </summary>
        /// <param name="bitmap">包含人脸的图片</param>
        /// <param name="info">指定的人脸信息</param>
        /// <returns></returns>
        public FaceMarkPoint[] FaceMark(Bitmap bitmap, FaceInfo info)
        {
            byte[] bgr = ImageSet.Get24BGRFromBitmap(bitmap, out int width, out int height, out int channels);
            int size;
            if (Platform64)
            { size = ViewFacePlus64.FaceMarkSize((int)MarkType); }
            else
            { size = ViewFacePlus32.FaceMarkSize((int)MarkType); }
            double[] _pointX = new double[size];
            double[] _pointY = new double[size];
            bool val;
            if (Platform64)
            { val = ViewFacePlus64.FaceMark(bgr, width, height, channels, info.Location.X, info.Location.Y, info.Location.Width, info.Location.Height, _pointX, _pointY, (int)MarkType); }
            else
            { val = ViewFacePlus32.FaceMark(bgr, width, height, channels, info.Location.X, info.Location.Y, info.Location.Width, info.Location.Height, _pointX, _pointY, (int)MarkType); }
            if (val)
            {
                List<FaceMarkPoint> points = new List<FaceMarkPoint>();
                for (int i = 0; i < size; i++)
                { points.Add(new FaceMarkPoint() { X = _pointX[i], Y = _pointY[i] }); }
                return points.ToArray();
            }
            else
            { throw new Exception("人脸关键点获取失败"); }
        }

        /// <summary>
        /// 提取人脸特征值。
        /// <para>
        /// 当 <see cref="FaceType"/> <see langword="="/> <see cref="FaceType.Normal"/> 时， 需要模型：<see langword="face_recognizer.csta"/><br/>
        /// 当 <see cref="FaceType"/> <see langword="="/> <see cref="FaceType.Mask"/> 时， 需要模型：<see langword="face_recognizer_mask.csta"/><br/>
        /// 当 <see cref="FaceType"/> <see langword="="/> <see cref="FaceType.Light"/> 时， 需要模型：<see langword="face_recognizer_light.csta"/><br/>
        /// </para>
        /// </summary>
        /// <param name="bitmap"></param>
        /// <param name="points"></param>
        /// <returns></returns>
        public float[] Extract(Bitmap bitmap, FaceMarkPoint[] points)
        {
            byte[] bgr = ImageSet.Get24BGRFromBitmap(bitmap, out int width, out int height, out int channels);
            float[] features;
            if (Platform64)
            { features = new float[ViewFacePlus64.ExtractSize((int)FaceType)]; }
            else
            { features = new float[ViewFacePlus32.ExtractSize((int)FaceType)]; }

            if (Platform64)
            { ViewFacePlus64.Extract(bgr, width, height, channels, points, features, (int)FaceType); }
            else
            { ViewFacePlus32.Extract(bgr, width, height, channels, points, features, (int)FaceType); }
            return features;
        }

        /// <summary>
        /// 计算特征值相似度。
        /// <para>只能计算相同 <see cref="FaceType"/> 计算出的特征值</para>
        /// <para>
        /// 当 <see cref="FaceType"/> <see langword="="/> <see cref="FaceType.Normal"/> 时， 需要模型：<see langword="face_recognizer.csta"/><br/>
        /// 当 <see cref="FaceType"/> <see langword="="/> <see cref="FaceType.Mask"/> 时， 需要模型：<see langword="face_recognizer_mask.csta"/><br/>
        /// 当 <see cref="FaceType"/> <see langword="="/> <see cref="FaceType.Light"/> 时， 需要模型：<see langword="face_recognizer_light.csta"/><br/>
        /// </para>
        /// </summary>
        /// <exception cref="ArgumentException"/>
        /// <exception cref="ArgumentNullException"/>
        /// <param name="leftFeatures"></param>
        /// <param name="rightFeatures"></param>
        /// <returns></returns>
        public float Similarity(float[] leftFeatures, float[] rightFeatures)
        {
            if (leftFeatures.Length == 0 || rightFeatures.Length == 0)
                throw new ArgumentNullException("参数不能为空", nameof(leftFeatures));
            if (leftFeatures.Length != rightFeatures.Length)
                throw new ArgumentException("两个参数长度不一致");


            if (Platform64)
            { return ViewFacePlus64.Similarity(leftFeatures, rightFeatures, (int)FaceType); }
            else
            { return ViewFacePlus32.Similarity(leftFeatures, rightFeatures, (int)FaceType); }
        }

        /// <summary>
        /// 判断相似度是否为同一个人。
        /// </summary>
        /// <param name="similarity">相似度</param>
        /// <returns></returns>
        public bool IsSelf(float similarity) => similarity > Face.Threshold[FaceType];

        /// <summary>
        /// 释放资源
        /// </summary>
        ~ViewFace()
        {
            if (Platform64)
            { ViewFacePlus64.ViewDispose(); }
            else
            { ViewFacePlus32.ViewDispose(); }
        }
    }

五、也许…

• 此项目还未实现 SeetaFace6 中的许多特性，也许：

　　　　想起 GitHub 密码，持续更新…
　　　　删除代码仓库跑路…

• 如果在使用过程中遇到问题，你也许可以：

　　　　在 GitHub 报告Bug…
　　　　向我 发送邮件