/// <summary>
/// 人脸特征比对
/// </summary>
/// <param name="faceFeature1">特征1</param>
/// <param name="faceFeature2">特征2</param>
/// <param name="similarity">相似度</param>
/// <param name="compareModel">ASF_LIFE_PHOTO：用于生活照之间的特征比对；ASF_ID_PHOTO：用于证件照或证件照和生活照之间的特征比对</param>
/// <returns>返回0表示正常；返回负数请根据ErrorCodeUtil类注释查看；其他值请在官网-帮助中心查询</returns>
public int ASFFaceFeatureCompare(FaceFeature faceFeature1, FaceFeature faceFeature2, out float similarity, ASF_CompareModel compareModel = ASF_CompareModel.ASF_LIFE_PHOTO)
{
similarity = 0f;
if (faceFeature1 == null || faceFeature2 == null)
{
return(ErrorCodeUtil.FEATURE_IS_NULL);
}
#region 将特征对象转化为特征结构体，再转化为非托管内存
ASF_FaceFeature asfFeatureStruct1 = new ASF_FaceFeature();
asfFeatureStruct1.featureSize = faceFeature1.featureSize;
asfFeatureStruct1.feature = MemoryUtil.Malloc(asfFeatureStruct1.featureSize);
MemoryUtil.Copy(faceFeature1.feature, 0, asfFeatureStruct1.feature, asfFeatureStruct1.featureSize);
IntPtr pFeature1 = MemoryUtil.Malloc(MemoryUtil.SizeOf <ASF_FaceFeature>());
MemoryUtil.StructureToPtr(asfFeatureStruct1, pFeature1);
ASF_FaceFeature asfFeatureStruct2 = new ASF_FaceFeature();
asfFeatureStruct2.featureSize = faceFeature2.featureSize;
asfFeatureStruct2.feature = MemoryUtil.Malloc(asfFeatureStruct2.featureSize);
MemoryUtil.Copy(faceFeature2.feature, 0, asfFeatureStruct2.feature, asfFeatureStruct2.featureSize);
IntPtr pFeature2 = MemoryUtil.Malloc(MemoryUtil.SizeOf <ASF_FaceFeature>());
MemoryUtil.StructureToPtr(asfFeatureStruct2, pFeature2);
#endregion
//调用SDK接口
int retCode = ASFFunctions.ASFFaceFeatureCompare(pEngine, pFeature1, pFeature2, ref similarity, compareModel);
MemoryUtil.FreeArray(pFeature1, pFeature2, asfFeatureStruct1.feature, asfFeatureStruct2.feature);
return(retCode);
}
/// <summary>
/// 提取单人脸特征
/// </summary>
/// <param name="pEngine"></param>
/// <param name="image"></param>
/// <param name="singleFaceInfo"></param>
/// <returns></returns>
public static ASF_FaceFeature ExtractFeature(IntPtr pEngine, Image image, ASF_SingleFaceInfo singleFaceInfo)
{
ImageInfo imageInfo = ImageUtil.ReadBMP(image);
if (imageInfo == null)
{
return(ReturnEmptyFeature());
}
IntPtr pSingleFaceInfo = MemoryUtil.Malloc(MemoryUtil.SizeOf <ASF_SingleFaceInfo>());
MemoryUtil.StructureToPtr(singleFaceInfo, pSingleFaceInfo);
IntPtr pFaceFeature = MemoryUtil.Malloc(MemoryUtil.SizeOf <ASF_FaceFeature>());
int retCode = -1;
try
{
retCode = ASFFunctions.ASFFaceFeatureExtract(pEngine, imageInfo.width, imageInfo.height, imageInfo.format, imageInfo.imgData, pSingleFaceInfo, pFaceFeature);
}
catch (Exception e)
{
Console.WriteLine(e.Message);
}
if (retCode != 0)
{
MemoryUtil.Free(pSingleFaceInfo);
MemoryUtil.Free(pFaceFeature);
MemoryUtil.Free(imageInfo.imgData);
pSingleFaceInfo = IntPtr.Zero;
pFaceFeature = IntPtr.Zero;
imageInfo.imgData = IntPtr.Zero;
return(ReturnEmptyFeature());
}
//人脸特征feature过滤
ASF_FaceFeature faceFeature = MemoryUtil.PtrToStructure <ASF_FaceFeature>(pFaceFeature);
byte[] feature = new byte[faceFeature.featureSize];
MemoryUtil.Copy(faceFeature.feature, feature, 0, faceFeature.featureSize);
ASF_FaceFeature localFeature = new ASF_FaceFeature();
localFeature.feature = MemoryUtil.Malloc(feature.Length);
MemoryUtil.Copy(feature, 0, localFeature.feature, feature.Length);
localFeature.featureSize = feature.Length;
//释放指针
MemoryUtil.Free(pSingleFaceInfo);
MemoryUtil.Free(pFaceFeature);
MemoryUtil.Free(imageInfo.imgData);
pSingleFaceInfo = IntPtr.Zero;
imageInfo.imgData = IntPtr.Zero;
return(localFeature);
}
/// <summary>
/// 提取特征值
/// </summary>
/// <param name="image"></param>
/// <param name="singleFaceInfo"></param>
/// <param name="registerOrNot"></param>
/// <returns></returns>
public FaceFeaturePro FaceFeatureExtractEx(ImageInfo image, SingleFaceInfo singleFaceInfo, ASF_RegisterOrNot registerOrNot)
{
if (_version == 2)
{
return(FaceFeatureExtract(image, singleFaceInfo));
}
MResult result = MResult.MOK;
ASF_FaceFeature feature = new ASF_FaceFeature {
};
if (_version >= 4)
{
result =
ASFFunctions.ASFFaceFeatureExtractEx(EngineHandler, image.ASFImageData, singleFaceInfo.ASFSingleFaceInfo, registerOrNot, singleFaceInfo.Mask ? 1 : 0, out feature);
}
else
{
result =
ASFFunctions.Compatible.ASFFaceFeatureExtractEx(EngineHandler, image.ASFImageData, singleFaceInfo.ASFSingleFaceInfo, out feature);
}
if (result == MResult.MOK)
{
var entity = new FaceFeaturePro();
entity.Size = feature.featureSize;
var buffers = new byte[feature.featureSize];
Marshal.Copy(feature.feature, buffers, 0, feature.featureSize);
entity.Buffers = buffers;
entity.ASFFaceFeature = feature;
return(entity);
}
return(null);
}
/// <summary>
/// 提取人脸特征
/// </summary>
/// <param name="pEngine">引擎Handle</param>
/// <param name="imageInfo">图像数据</param>
/// <param name="multiFaceInfo">人脸检测结果</param>
/// <returns>保存人脸特征结构体指针</returns>
public static IntPtr ExtractFeature(IntPtr pEngine, ImageInfo imageInfo, ASF_MultiFaceInfo multiFaceInfo, out ASF_SingleFaceInfo singleFaceInfo)
{
singleFaceInfo = new ASF_SingleFaceInfo();
singleFaceInfo.faceRect = MemoryUtil.PtrToStructure <MRECT>(multiFaceInfo.faceRects);
singleFaceInfo.faceOrient = MemoryUtil.PtrToStructure <int>(multiFaceInfo.faceOrients);
IntPtr pSingleFaceInfo = MemoryUtil.Malloc(MemoryUtil.SizeOf <ASF_SingleFaceInfo>()); // 申请内存，单人脸检测结构体
MemoryUtil.StructureToPtr(singleFaceInfo, pSingleFaceInfo); // 结构体进入内存
IntPtr pFaceFeature = MemoryUtil.Malloc(MemoryUtil.SizeOf <ASF_FaceFeature>()); // 申请内存，人脸特征结构体
int retCode = ASFFunctions.ASFFaceFeatureExtract(pEngine, imageInfo.width, imageInfo.height, imageInfo.format, imageInfo.imgData, pSingleFaceInfo, pFaceFeature); // 单人脸特征提取
Console.WriteLine("FR Extract Feature result:" + retCode); // 直接打印结果
if (retCode != 0) // 返回结果非0，即匹配到人脸，释放指针
{
// 释放指针
MemoryUtil.Free(pSingleFaceInfo); // 释放单人脸检测结构体指针
MemoryUtil.Free(pFaceFeature); // 释放人脸特征结构体指针
ASF_FaceFeature emptyFeature = new ASF_FaceFeature(); // 声明空人脸特征结构体
IntPtr pEmptyFeature = MemoryUtil.Malloc(MemoryUtil.SizeOf <ASF_FaceFeature>()); // 声明空人脸特征结构体指针
MemoryUtil.StructureToPtr(emptyFeature, pEmptyFeature); // 将数据从托管对象封送到非托管内存块
return(pEmptyFeature); // 匹配成功，返回空的人脸特征结构体指针
}
// 人脸特征feature过滤
ASF_FaceFeature faceFeature = MemoryUtil.PtrToStructure <ASF_FaceFeature>(pFaceFeature);// 将ptr托管的内存转化为结构体对象
int cc = faceFeature.featureSize;
var ff = faceFeature.feature;
byte[] feature = new byte[faceFeature.featureSize];
MemoryUtil.Copy(faceFeature.feature, feature, 0, faceFeature.featureSize);// source, destination, startIndex, length
ASF_FaceFeature localFeature = new ASF_FaceFeature();
localFeature.feature = MemoryUtil.Malloc(feature.Length); // 申请本地人脸特征指针
MemoryUtil.Copy(feature, 0, localFeature.feature, feature.Length); // source, startIndex, destination, length
localFeature.featureSize = feature.Length; // 设置本地特征值长度
IntPtr pLocalFeature = MemoryUtil.Malloc(MemoryUtil.SizeOf <ASF_FaceFeature>()); // 申请本地特征值指针空间
MemoryUtil.StructureToPtr(localFeature, pLocalFeature); // T t,IntPtr ptr
// 释放指针
MemoryUtil.Free(pSingleFaceInfo);
MemoryUtil.Free(pFaceFeature);
/******** 特征值feature存入数据库 start **********/
Users users = new Users();
users.Id = SidUtils.sid();
users.Feature = feature;
MysqlUtils mysqlUtils = new MysqlUtils();
mysqlUtils.InsertUserFaceFeature(users);
/******** 特征值feature存入数据库 end **********/
return(pLocalFeature);// 返回人脸特征
}
private static IntPtr ReturnEmptyStruct(out ASF_SingleFaceInfo singleFaceInfo)
{
singleFaceInfo = new ASF_SingleFaceInfo();
ASF_FaceFeature emptyFeatrue = new ASF_FaceFeature();
IntPtr pEmptyFeature = MemoryUtil.Malloc(MemoryUtil.SizeOf <ASF_FaceFeature>());
MemoryUtil.StructureToPtr(emptyFeatrue, pEmptyFeature);
return(pEmptyFeature);
}
/// <summary>
/// 提取单人脸特征
/// </summary>
/// <param name="pEngine">人脸识别引擎</param>
/// <param name="image">图片</param>
/// <param name="singleFaceInfo">单人脸信息</param>
/// <returns>单人脸特征</returns>
public static IntPtr ExtractFeature(IntPtr pEngine, Image image, ASF_SingleFaceInfo singleFaceInfo)
{
ImageInfo imageInfo = ImageHelper.ReadBMP(image);
IntPtr pSingleFaceInfo = MemoryHelper.Malloc(MemoryHelper.SizeOf <ASF_SingleFaceInfo>());
MemoryHelper.StructureToPtr(singleFaceInfo, pSingleFaceInfo);
IntPtr pFaceFeature = MemoryHelper.Malloc(MemoryHelper.SizeOf <ASF_FaceFeature>());
int retCode = -1;
try
{
retCode = ASFWrapper.ASFFaceFeatureExtract(pEngine, imageInfo.width, imageInfo.height, imageInfo.format, imageInfo.imgData, pSingleFaceInfo, pFaceFeature);
}
catch (Exception e)
{
//Console.WriteLine(e.Message);
SimplifiedLogHelper.WriteIntoSystemLog(nameof(Afw.Core.Helper.FaceProcessHelper), $"Extract Feature Exception => {e.ToString()}");
}
//Console.WriteLine("FR Extract Feature result:" + retCode);
SimplifiedLogHelper.WriteIntoSystemLog(nameof(Afw.Core.Helper.FaceProcessHelper), $"FR Extract Feature result:{retCode} =>[{retCode.ToEnum<MError>().GetFieldDescription()}]");
if (retCode != 0)
{
//释放指针
MemoryHelper.Free(pSingleFaceInfo);
MemoryHelper.Free(pFaceFeature);
ASF_FaceFeature emptyFeature = new ASF_FaceFeature();
IntPtr pEmptyFeature = MemoryHelper.Malloc(MemoryHelper.SizeOf <ASF_FaceFeature>());
MemoryHelper.StructureToPtr(emptyFeature, pEmptyFeature);
return(pEmptyFeature);
}
//人脸特征feature过滤
ASF_FaceFeature faceFeature = MemoryHelper.PtrToStructure <ASF_FaceFeature>(pFaceFeature);
byte[] feature = new byte[faceFeature.featureSize];
MemoryHelper.Copy(faceFeature.feature, feature, 0, faceFeature.featureSize);
ASF_FaceFeature localFeature = new ASF_FaceFeature();
localFeature.feature = MemoryHelper.Malloc(feature.Length);
MemoryHelper.Copy(feature, 0, localFeature.feature, feature.Length);
localFeature.featureSize = feature.Length;
IntPtr pLocalFeature = MemoryHelper.Malloc(MemoryHelper.SizeOf <ASF_FaceFeature>());
MemoryHelper.StructureToPtr(localFeature, pLocalFeature);
//释放指针
MemoryHelper.Free(pSingleFaceInfo);
MemoryHelper.Free(pFaceFeature);
MemoryHelper.Free(imageInfo.imgData);
return(pLocalFeature);
}
/// <summary>
/// 单人脸特征提取
/// </summary>
/// <param name="imageFormat">图片格式</param>
/// <param name="image">图片</param>
/// <param name="multiFaceInfo">人脸框对象</param>
/// <param name="faceIndex">人脸索引</param>
/// <param name="faceFeature">[out]特征结果</param>
/// <returns>返回0表示正常；返回负数请根据ErrorCodeUtil类注释查看；其他值请在官网-帮助中心查询</returns>
public int ASFFaceFeatureExtractEx(Image image, MultiFaceInfo multiFaceInfo, out FaceFeature faceFeature, int faceIndex = 0, ASF_ImagePixelFormat imageFormat = ASF_ImagePixelFormat.ASVL_PAF_RGB24_B8G8R8)
{
int retCode = -1;
faceFeature = new FaceFeature();
if (multiFaceInfo == null)
{
return(ErrorCodeUtil.MULPTIFACEINFO_IS_NULL);
}
if (faceIndex >= multiFaceInfo.faceNum)
{
return(ErrorCodeUtil.FACEINDEX_INVALID);
}
if (image == null)
{
return(ErrorCodeUtil.IMAGE_IS_NULL);
}
ImageInfo imageInfo = new ImageInfo();
imageInfo = ASF_ImagePixelFormat.ASVL_PAF_RGB24_B8G8R8.Equals(imageFormat) ? ImageUtil.ReadBMP(image) : ImageUtil.ReadBMP_IR(image);
if (imageInfo == null)
{
return(ErrorCodeUtil.IMAGE_DATA_READ_FAIL);
}
//转化单人脸信息
SingleFaceInfo singleFaceInfo = new SingleFaceInfo();
IntPtr pSIngleFaceInfo = MemoryUtil.Malloc(MemoryUtil.SizeOf <SingleFaceInfo>());
singleFaceInfo.faceRect = multiFaceInfo.faceRects[faceIndex];
singleFaceInfo.faceOrient = multiFaceInfo.faceOrients[faceIndex];
MemoryUtil.StructureToPtr(singleFaceInfo, pSIngleFaceInfo);
IntPtr pAsfFaceFeature = MemoryUtil.Malloc(MemoryUtil.SizeOf <ASF_FaceFeature>());
ASF_ImageData asfInfoData = CommonUtil.TransImageDataStructByImageInfo(imageInfo);
IntPtr pImageInfo = MemoryUtil.Malloc(MemoryUtil.SizeOf <ASF_ImageData>());
MemoryUtil.StructureToPtr(asfInfoData, pImageInfo);
//调用SDK接口
retCode = ASFFunctions.ASFFaceFeatureExtractEx(pEngine, pImageInfo, pSIngleFaceInfo, pAsfFaceFeature);
if (retCode != 0)
{
MemoryUtil.FreeArray(pSIngleFaceInfo, pAsfFaceFeature, imageInfo.imgData, pImageInfo);
return(retCode);
}
ASF_FaceFeature asfFeature = MemoryUtil.PtrToStructure <ASF_FaceFeature>(pAsfFaceFeature);
byte[] feature = new byte[asfFeature.featureSize];
MemoryUtil.Copy(asfFeature.feature, feature, 0, asfFeature.featureSize);
faceFeature.featureSize = asfFeature.featureSize;
faceFeature.feature = feature;
MemoryUtil.FreeArray(pSIngleFaceInfo, pAsfFaceFeature, imageInfo.imgData, pImageInfo);
return(retCode);
}
/// <summary>
/// 人脸特征比对，输出比对相似度。
/// </summary>
/// <param name="feature1"></param>
/// <param name="feature2"></param>
/// <returns></returns>
public float FaceFeatureCompare(ASF_FaceFeature feature1, byte[] feature2)
{
var f2 = new ASF_FaceFeature
{
featureSize = feature2.Length
};
var p2 = Marshal.AllocHGlobal(feature2.Length);
f2.feature = p2;
ASFFunctions.ASFFaceFeatureCompare(EngineHandler, feature1, f2, out float score, ASF_CompareModel.ASF_LIFE_PHOTO);
return(score);
}
/// <summary>
/// 提取人脸特征
/// </summary>
/// <param name="pEngine">引擎Handle</param>
/// <param name="imageInfo">图像数据</param>
/// <param name="multiFaceInfo">人脸检测结果</param>
/// <returns>保存人脸特征结构体指针</returns>
public static IntPtr ExtractFaceFeature(IntPtr pEngine, ImageInfo imageInfo, ASF_MultiFaceInfo multiFaceInfo, out ASF_SingleFaceInfo singleFaceInfo)
{
singleFaceInfo = new ASF_SingleFaceInfo();
if (multiFaceInfo.faceRects == null)
{
ASF_FaceFeature emptyFeature = new ASF_FaceFeature();
IntPtr pEmptyFeature = UtilToolMemory.Malloc(UtilToolMemory.SizeOf <ASF_FaceFeature>());
UtilToolMemory.StructureToPtr(emptyFeature, pEmptyFeature);
return(pEmptyFeature);
}
singleFaceInfo.faceRect = UtilToolMemory.PtrToStructure <MRECT>(multiFaceInfo.faceRects);
singleFaceInfo.faceOrient = UtilToolMemory.PtrToStructure <int>(multiFaceInfo.faceOrients);
IntPtr pSingleFaceInfo = UtilToolMemory.Malloc(UtilToolMemory.SizeOf <ASF_SingleFaceInfo>());
UtilToolMemory.StructureToPtr(singleFaceInfo, pSingleFaceInfo);
IntPtr pFaceFeature = UtilToolMemory.Malloc(UtilToolMemory.SizeOf <ASF_FaceFeature>());
int retCode = ASFFunctions.ASFFaceFeatureExtract(pEngine, imageInfo.width, imageInfo.height, imageInfo.format, imageInfo.imgData, pSingleFaceInfo, pFaceFeature);
Console.WriteLine("FR Extract Feature result:" + retCode);
if (retCode != 0)
{
//释放指针
UtilToolMemory.Free(pSingleFaceInfo);
UtilToolMemory.Free(pFaceFeature);
ASF_FaceFeature emptyFeature = new ASF_FaceFeature();
IntPtr pEmptyFeature = UtilToolMemory.Malloc(UtilToolMemory.SizeOf <ASF_FaceFeature>());
UtilToolMemory.StructureToPtr(emptyFeature, pEmptyFeature);
return(pEmptyFeature);
}
//人脸特征feature过滤
ASF_FaceFeature faceFeature = UtilToolMemory.PtrToStructure <ASF_FaceFeature>(pFaceFeature);
byte[] feature = new byte[faceFeature.featureSize];
UtilToolMemory.Copy(faceFeature.feature, feature, 0, faceFeature.featureSize);
ASF_FaceFeature localFeature = new ASF_FaceFeature();
localFeature.feature = UtilToolMemory.Malloc(feature.Length);
UtilToolMemory.Copy(feature, 0, localFeature.feature, feature.Length);
localFeature.featureSize = feature.Length;
IntPtr pLocalFeature = UtilToolMemory.Malloc(UtilToolMemory.SizeOf <ASF_FaceFeature>());
UtilToolMemory.StructureToPtr(localFeature, pLocalFeature);
//释放指针
UtilToolMemory.Free(pSingleFaceInfo);
UtilToolMemory.Free(pFaceFeature);
return(pLocalFeature);
}
/// <summary>
/// 提取单人脸特征
/// </summary>
/// <param name="pEngine">人脸识别引擎</param>
/// <param name="image">图片</param>
/// <param name="singleFaceInfo">单人脸信息</param>
/// <returns>单人脸特征</returns>
public static IntPtr ExtractFeature(IntPtr pEngine, Image image, ASF_SingleFaceInfo singleFaceInfo)
{
ImageInfo imageInfo = ImageUtil.ReadBMP(image); // 读取图片
IntPtr pSingleFaceInfo = MemoryUtil.Malloc(MemoryUtil.SizeOf <ASF_SingleFaceInfo>()); // 申请单人脸结构体指针空间
MemoryUtil.StructureToPtr(singleFaceInfo, pSingleFaceInfo); // 指针化
IntPtr pFaceFeature = MemoryUtil.Malloc(MemoryUtil.SizeOf <ASF_FaceFeature>()); // 申请人脸特征指针空间
int retCode = -1;
try
{
retCode = ASFFunctions.ASFFaceFeatureExtract(pEngine, imageInfo.width, imageInfo.height, imageInfo.format, imageInfo.imgData, pSingleFaceInfo, pFaceFeature);// 单人脸特征提取
}
catch (Exception e)
{
Console.WriteLine(e.Message);
}
Console.WriteLine("FR Extract Feature result:" + retCode);
if (retCode != 0)
{
//释放指针
MemoryUtil.Free(pSingleFaceInfo);
MemoryUtil.Free(pFaceFeature);
ASF_FaceFeature emptyFeature = new ASF_FaceFeature();
IntPtr pEmptyFeature = MemoryUtil.Malloc(MemoryUtil.SizeOf <ASF_FaceFeature>());
MemoryUtil.StructureToPtr(emptyFeature, pEmptyFeature);
return(pEmptyFeature);
}
//人脸特征feature过滤
ASF_FaceFeature faceFeature = MemoryUtil.PtrToStructure <ASF_FaceFeature>(pFaceFeature);
byte[] feature = new byte[faceFeature.featureSize];
MemoryUtil.Copy(faceFeature.feature, feature, 0, faceFeature.featureSize);
ASF_FaceFeature localFeature = new ASF_FaceFeature();
localFeature.feature = MemoryUtil.Malloc(feature.Length);
MemoryUtil.Copy(feature, 0, localFeature.feature, feature.Length);
localFeature.featureSize = feature.Length;
IntPtr pLocalFeature = MemoryUtil.Malloc(MemoryUtil.SizeOf <ASF_FaceFeature>());
MemoryUtil.StructureToPtr(localFeature, pLocalFeature);
//释放指针
MemoryUtil.Free(pSingleFaceInfo);
MemoryUtil.Free(pFaceFeature);
MemoryUtil.Free(imageInfo.imgData);
return(pLocalFeature);
}
/// <summary>
/// 获取特征值指针
/// </summary>
/// <param name="feature"></param>
/// <returns></returns>
public static IntPtr Feature2IntPtr(byte[] feature)
{
IntPtr pFaceFeature = IntPtr.Zero;
if (feature != null &&
feature.Length > 0)
{
ASF_FaceFeature faceFeature = new ASF_FaceFeature
{
Feature = MemoryUtil.Malloc(feature.Length)
};
MemoryUtil.Copy(feature, 0, faceFeature.Feature, feature.Length);
faceFeature.FeatureSize = feature.Length;
pFaceFeature = MemoryUtil.Malloc(MemoryUtil.SizeOf <ASF_FaceFeature>());
MemoryUtil.StructureToPtr(faceFeature, pFaceFeature);
}
return(pFaceFeature);
}
public StudentFaceFeature(t_face dbFace)
{
studentId = dbFace.studnet_id;
faceFeature = new ASF_FaceFeature();
faceFeature.featureSize = (int)dbFace.face_feature_length;
if (faceFeature.featureSize == dbFace.face_feature.Length)
{
faceFeature.feature = MemoryUtil.Malloc(faceFeature.featureSize);
MemoryUtil.Copy(dbFace.face_feature, 0, faceFeature.feature, faceFeature.featureSize);
pFaceFeature = MemoryUtil.Malloc(MemoryUtil.SizeOf <ASF_FaceFeature>());
MemoryUtil.StructureToPtr <ASF_FaceFeature>(faceFeature, pFaceFeature);
}
else
{
pFaceFeature = IntPtr.Zero;
faceFeature.feature = IntPtr.Zero;
faceFeature.featureSize = 0;
}
}
/// <summary>
/// 人脸特征比对，输出比对相似度。
/// </summary>
/// <param name="feature1"></param>
/// <param name="feature2"></param>
/// <returns></returns>
public float FaceFeatureCompare(byte[] feature1, byte[] feature2)
{
var f1 = new ASF_FaceFeature
{
featureSize = feature1.Length
};
var f2 = new ASF_FaceFeature
{
featureSize = feature2.Length
};
var p1 = Marshal.AllocHGlobal(feature1.Length);
var p2 = Marshal.AllocHGlobal(feature2.Length);
Marshal.Copy(feature1, 0, p1, feature1.Length);
Marshal.Copy(feature2, 0, p2, feature2.Length);
f1.feature = p1;
f2.feature = p2;
ASFFunctions.ASFFaceFeatureCompare(EngineHandler, f1, f2, out float score, ASF_CompareModel.ASF_LIFE_PHOTO);
Marshal.FreeHGlobal(p1);
Marshal.FreeHGlobal(p2);
return(score);
}
/// <summary>
/// 提取人脸特征
/// </summary>
/// <param name="pEngine">引擎Handle</param>
/// <param name="image">图像</param>
/// <returns>保存人脸特征结构体指针</returns>
public static IntPtr ExtractFaceFeature(IntPtr pEngine, Image image, out ASF_SingleFaceInfo singleFaceInfo)
{
if (image.Width > 1536 || image.Height > 1536)
{
image = UtilTool.ScaleImage(image, 1536, 1536);
}
else
{
image = UtilTool.ScaleImage(image, image.Width, image.Height);
}
if (image == null)
{
singleFaceInfo = new ASF_SingleFaceInfo();
ASF_FaceFeature emptyFeature = new ASF_FaceFeature();
IntPtr pEmptyFeature = UtilToolMemory.Malloc(UtilToolMemory.SizeOf <ASF_FaceFeature>());
UtilToolMemory.StructureToPtr(emptyFeature, pEmptyFeature);
return(pEmptyFeature);
}
ImageInfo imageInfo = UtilTool.ReadImage(image);
if (imageInfo == null)
{
singleFaceInfo = new ASF_SingleFaceInfo();
ASF_FaceFeature emptyFeature = new ASF_FaceFeature();
IntPtr pEmptyFeature = UtilToolMemory.Malloc(UtilToolMemory.SizeOf <ASF_FaceFeature>());
UtilToolMemory.StructureToPtr(emptyFeature, pEmptyFeature);
return(pEmptyFeature);
}
ASF_MultiFaceInfo multiFaceInfo = DetectFace(pEngine, imageInfo);
singleFaceInfo = new ASF_SingleFaceInfo();
IntPtr pFaceModel = ExtractFaceFeature(pEngine, imageInfo, multiFaceInfo, out singleFaceInfo);
UtilToolMemory.Free(imageInfo.imgData);
return(pFaceModel);
}
//辅助函数
private IntPtr PutFeatureByteIntoFeatureIntPtr(byte[] data)
{
try
{
if (data.Length > 0)
{
ASF_FaceFeature localFeature = new ASF_FaceFeature();
localFeature.featureSize = data.Length;
localFeature.feature = Marshal.AllocHGlobal(localFeature.featureSize);
Marshal.Copy(data, 0, localFeature.feature, data.Length);
IntPtr intPtrFeature = Marshal.AllocHGlobal(Marshal.SizeOf <ASF_FaceFeature>());
Marshal.StructureToPtr(localFeature, intPtrFeature, false);
return(intPtrFeature);
}
else
{
return(IntPtr.Zero);
}
}
catch
{
return(IntPtr.Zero);
}
}
/// <summary>
/// 人脸特征比对，输出比对相似度。
/// </summary>
/// <param name="feature1"></param>
/// <param name="feature2"></param>
/// <param name="compareModel"></param>
/// <returns></returns>
public float FaceFeatureCompare(ASF_FaceFeature feature1, ASF_FaceFeature feature2, ASF_CompareModel compareModel = ASF_CompareModel.ASF_LIFE_PHOTO)
{
ASFFunctions.ASFFaceFeatureCompare(EngineHandler, feature1, feature2, out float score, compareModel);
return(score);
}
/// <summary>
/// 从图像信息中提取人脸特征
/// </summary>
/// <param name="pEngine">虹软引擎句柄</param>
/// <param name="imageInfo">图像信息</param>
/// <param name="multiFaceInfo">人脸检测结果</param>
/// <param name="singleFaceInfo">单个人脸的位置</param>
/// <returns>保存人脸特征结构体指针</returns>
public static IntPtr ExtractFeatrue(IntPtr pEngine, ImageInfo imageInfo, ASF_MultiFaceInfo multiFaceInfo, out ASF_SingleFaceInfo singleFaceInfo)
{
singleFaceInfo = new ASF_SingleFaceInfo();
//如果没有检测到人脸
if (multiFaceInfo.faceRects == null)
{
//创建一个空的特征结构体
ASF_FaceFeature emptyFeature = new ASF_FaceFeature();
IntPtr pEmptyFeature = MemoryUtil.Malloc(MemoryUtil.SizeOf <ASF_FaceFeature>());
MemoryUtil.StructureToPtr(emptyFeature, pEmptyFeature);
return(pEmptyFeature);
}
singleFaceInfo.faceRect = MemoryUtil.PtrToStructure <MRECT>(multiFaceInfo.faceRects);
singleFaceInfo.faceOrient = MemoryUtil.PtrToStructure <int>(multiFaceInfo.faceOrients);
IntPtr pSingleFaceInfo = MemoryUtil.Malloc(MemoryUtil.SizeOf <ASF_SingleFaceInfo>());
MemoryUtil.StructureToPtr(singleFaceInfo, pSingleFaceInfo);
//创建一个人脸特征结构体指针
IntPtr pFaceFeature = MemoryUtil.Malloc(MemoryUtil.SizeOf <ASF_FaceFeature>());
//执行特征识别运算
int retCode = ASFFunctions.ASFFaceFeatureExtract(pEngine, imageInfo.width, imageInfo.height, imageInfo.format, imageInfo.imgData, pSingleFaceInfo, pFaceFeature);
Console.WriteLine("FR Extract Feature result: " + retCode);
//当执行结果不是成功
if (retCode != 0)
{
MemoryUtil.Free(pSingleFaceInfo);
MemoryUtil.Free(pFaceFeature);
pSingleFaceInfo = IntPtr.Zero;
pFaceFeature = IntPtr.Zero;
ASF_FaceFeature emptyFeature = new ASF_FaceFeature();
IntPtr pEmptyFeature = MemoryUtil.Malloc(MemoryUtil.SizeOf <ASF_FaceFeature>());
MemoryUtil.StructureToPtr(emptyFeature, pEmptyFeature);
return(pEmptyFeature);
}
#region 人脸特征深度复制
ASF_FaceFeature faceFeature = MemoryUtil.PtrToStructure <ASF_FaceFeature>((pFaceFeature));
byte[] feature = new byte[faceFeature.featureSize];
//将特征值提取出来(类型转换成C#的类型
MemoryUtil.Copy(faceFeature.feature, feature, 0, faceFeature.featureSize);
ASF_FaceFeature localFeature = new ASF_FaceFeature();
localFeature.feature = MemoryUtil.Malloc(feature.Length);
MemoryUtil.Copy(feature, 0, localFeature.feature, feature.Length);
localFeature.featureSize = feature.Length;
IntPtr pLocalFeature = MemoryUtil.Malloc(MemoryUtil.SizeOf <ASF_FaceFeature>());
MemoryUtil.StructureToPtr(localFeature, pLocalFeature);
MemoryUtil.Free(pSingleFaceInfo);
MemoryUtil.Free(pFaceFeature);
pSingleFaceInfo = IntPtr.Zero;
pFaceFeature = IntPtr.Zero;
#endregion
return(pLocalFeature);
}
public static extern MResult ASFFaceFeatureExtract(IntPtr hEngine, int width, int height, int format, IntPtr imgData, ASF_SingleFaceInfo faceInfo, ASF_RegisterOrNot registerOrNot, int mask, out ASF_FaceFeature feature);
public static extern MResult ASFFaceFeatureExtract(IntPtr hEngine, int width, int height, int format, IntPtr imgData, ASF_SingleFaceInfo faceInfo, out ASF_FaceFeature feature, int threadNum = 1);
/// <summary>
/// 图像显示到窗体上，得到每一帧图像，并进行处理（画框）
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void videoSource_Paint(object sender, PaintEventArgs e)
{
if (videoSource.IsRunning)// 摄像头运行中
{
//得到当前摄像头下的图片
Bitmap bitmap = videoSource.GetCurrentVideoFrame();
if (bitmap == null)
{
return;
}
Graphics g = e.Graphics;
float offsetX = videoSource.Width * 1f / bitmap.Width;
float offsetY = videoSource.Height * 1f / bitmap.Height;
//检测人脸，得到Rect框（方框）
ASF_MultiFaceInfo multiFaceInfo = FaceUtil.DetectFace(pVideoEngine, bitmap);
//得到最大人脸
ASF_SingleFaceInfo maxFace = FaceUtil.GetMaxFace(multiFaceInfo);
//得到Rect
MRECT rect = maxFace.faceRect;
float x = rect.left * offsetX;
float width = rect.right * offsetX - x;
float y = rect.top * offsetY;
float height = rect.bottom * offsetY - y;
//根据Rect进行画框
g.DrawRectangle(pen, x, y, width, height);
// 调整摄像头视频框
if (rect.left.ToString() == "0")
{
this.videoSource.Location = new System.Drawing.Point(this.Width - 1, this.Height - 1);
}
else
{
int xVideoSource = (int)(0.5 * (this.Width - this.videoSource.Width));
int yVideoSource = (int)(0.5 * (this.Height - this.videoSource.Height));
this.videoSource.Location = new System.Drawing.Point(xVideoSource, yVideoSource);
}
// this.logBox.AppendText(rect.left.ToString() + "\n");
// this.videoSource.Show();// 能画框的时候显示摄像头视频框
if (trackUnit.message != "" && x > 0 && y > 0)
{
//将上一帧检测结果显示到页面上
g.DrawString(trackUnit.message, font, brush, x, y + 5);
}
//保证只检测一帧，防止页面卡顿以及出现其他内存被占用情况
if (isLock == false)
{
isLock = true;
//异步处理提取特征值和比对，不然页面会比较卡
ThreadPool.QueueUserWorkItem(new WaitCallback(delegate
{
if (rect.left != 0 && rect.right != 0 && rect.top != 0 && rect.bottom != 0)
{
try
{
//提取人脸特征 TODO 这是当前摄像头下的人脸的特征值
IntPtr videoFaceFeature = FaceUtil.ExtractFeature(pVideoImageEngine, bitmap, maxFace);
float similarity = 0f;
//得到比对结果 star TODO 这边compareFeature中
// TODO 数据库中查询出feature
MysqlUtils mysqlUtils = new MysqlUtils();
List <byte[]> featureListFromDB = mysqlUtils.SelectUserFaceByFeature();// 数据库查询
var v = 0;
for (int i = 0; i < featureListFromDB.Count; i++)
{
//pFeatureItemFromDB = TabConvert.BytesToIntptr(featureListFromDB[i]);
//GCHandle hObject = GCHandle.Alloc(featureListFromDB[i], GCHandleType.Pinned);
//pFeatureItemFromDB = hObject.AddrOfPinnedObject();
ASF_FaceFeature localFeature = new ASF_FaceFeature();
localFeature.feature = MemoryUtil.Malloc(featureListFromDB[i].Length); // 申请本地人脸特征指针
MemoryUtil.Copy(featureListFromDB[i], 0, localFeature.feature, featureListFromDB[i].Length); // source, startIndex, destination, length
localFeature.featureSize = featureListFromDB[i].Length; // 设置本地特征值长度
IntPtr pLocalFeature = MemoryUtil.Malloc(MemoryUtil.SizeOf <ASF_FaceFeature>()); // 申请本地特征值指针空间
MemoryUtil.StructureToPtr(localFeature, pLocalFeature); // T t,IntPtr ptr
/*
* IntPtr pFeatureItemFromDB = MemoryUtil.Malloc(MemoryUtil.SizeOf<ASF_FaceFeature>());
* v++;
* Marshal.StructureToPtr(featureListFromDB[i], pFeatureItemFromDB, false);
* Marshal.FreeHGlobal(pFeatureItemFromDB);
*/
imagesFeatureList.Add(pLocalFeature);
}
int result = compareFeatureFromDB(videoFaceFeature, out similarity);
if (result > -1)
{
// TODO
//将比对结果放到显示消息中，用于最新显示
trackUnit.message = string.Format("你好，匹配到 {0}号，相似度是 {1}", result, similarity);
labelLoginUserName.Text = result.ToString();
Console.WriteLine(result.ToString() + ":" + similarity.ToString() + "\n");
// TODO
// 相似度不足0.8，窗口正常显示
if (similarity < 0.8)
{
this.Visible = true;
this.WindowState = FormWindowState.Normal;
}
else// 相似度超过80，自动缩小至系统托盘
{
this.Hide();
this.notifyIcon.Visible = true;
}
// TODO 隔段时间打开托盘
Thread.Sleep(5000);// TODO 设置多长时间再次验证人脸，这边设置了2秒
this.Visible = true;
this.WindowState = FormWindowState.Normal;
}
else
{
//重置显示消息
trackUnit.message = "";
}
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
finally
{
isLock = false;
}
}
isLock = false;
}));
}
}
}
public static extern MResult ASFFaceFeatureExtractEx(IntPtr hEngine, ASVLOFFSCREEN imgData, ASF_SingleFaceInfo faceInfo, out ASF_FaceFeature feature, int threadNum = 1);
public static extern MResult ASFFaceFeatureCompare(IntPtr hEngine, ASF_FaceFeature faceFeature1, ASF_FaceFeature faceFeature2, out float confidenceLevel, ASF_CompareModel compareModel = ASF_CompareModel.ASF_LIFE_PHOTO);
public static extern MResult ASFFaceFeatureExtractEx(IntPtr hEngine, ASVLOFFSCREEN imgData, ASF_SingleFaceInfo faceInfo, ASF_RegisterOrNot registerOrNot, int mask, out ASF_FaceFeature feature);
/// <summary>
/// 提取单人脸特征
/// </summary>
/// <param name="pEngine">人脸识别引擎</param>
/// <param name="image">图片</param>
/// <param name="singleFaceInfo">单人脸信息</param>
/// <returns>单人脸特征</returns>
public static IntPtr ExtractFaceFeature(IntPtr pEngine, Image image, ASF_SingleFaceInfo singleFaceInfo)
{
ImageInfo imageInfo = UtilTool.ReadImage(image);
if (imageInfo == null)
{
ASF_FaceFeature emptyFeature = new ASF_FaceFeature();
IntPtr pEmptyFeature = UtilToolMemory.Malloc(UtilToolMemory.SizeOf <ASF_FaceFeature>());
UtilToolMemory.StructureToPtr(emptyFeature, pEmptyFeature);
return(pEmptyFeature);
}
IntPtr pSingleFaceInfo = UtilToolMemory.Malloc(UtilToolMemory.SizeOf <ASF_SingleFaceInfo>());
UtilToolMemory.StructureToPtr(singleFaceInfo, pSingleFaceInfo);
IntPtr pFaceFeature = UtilToolMemory.Malloc(UtilToolMemory.SizeOf <ASF_FaceFeature>());
int retCode = -1;
try
{
retCode = ASFFunctions.ASFFaceFeatureExtract(pEngine, imageInfo.width, imageInfo.height, imageInfo.format, imageInfo.imgData, pSingleFaceInfo, pFaceFeature);
}
catch (Exception e)
{
Console.WriteLine(e.Message);
}
Console.WriteLine("FR Extract Feature result:" + retCode);
if (retCode != 0)
{
//释放指针
UtilToolMemory.Free(pSingleFaceInfo);
UtilToolMemory.Free(pFaceFeature);
UtilToolMemory.Free(imageInfo.imgData);
ASF_FaceFeature emptyFeature = new ASF_FaceFeature();
IntPtr pEmptyFeature = UtilToolMemory.Malloc(UtilToolMemory.SizeOf <ASF_FaceFeature>());
UtilToolMemory.StructureToPtr(emptyFeature, pEmptyFeature);
return(pEmptyFeature);
}
//人脸特征feature过滤
ASF_FaceFeature faceFeature = UtilToolMemory.PtrToStructure <ASF_FaceFeature>(pFaceFeature);
byte[] feature = new byte[faceFeature.featureSize];
UtilToolMemory.Copy(faceFeature.feature, feature, 0, faceFeature.featureSize);
ASF_FaceFeature localFeature = new ASF_FaceFeature();
localFeature.feature = UtilToolMemory.Malloc(feature.Length);
UtilToolMemory.Copy(feature, 0, localFeature.feature, feature.Length);
localFeature.featureSize = feature.Length;
IntPtr pLocalFeature = UtilToolMemory.Malloc(UtilToolMemory.SizeOf <ASF_FaceFeature>());
UtilToolMemory.StructureToPtr(localFeature, pLocalFeature);
//释放指针
UtilToolMemory.Free(pSingleFaceInfo);
UtilToolMemory.Free(pFaceFeature);
UtilToolMemory.Free(imageInfo.imgData);
return(pLocalFeature);
}
private static ASF_FaceFeature ReturnEmptyFeature()
{
ASF_FaceFeature emptyFeature = new ASF_FaceFeature();
return(emptyFeature);
}
public static extern int ASFFaceFeatureCompares(IntPtr pEngine, ref ASF_MultiFaceInfo faceFeature1, ref ASF_FaceFeature faceFeature2, out float result);
