/// <summary>
/// 口罩检测
/// </summary>
/// <param name="pEngine">引擎Handle</param>
/// <param name="imageInfo">图像数据</param>
/// <param name="singleFaceInfo">单人脸信息</param>
/// <returns>口罩检测结果</returns>
public static MaskInfo MaskEstimation(FaceEngine faceEngine, Image image, SingleFaceInfo singleFaceInfo, out int retCode)
{
MaskInfo maskInfo = new MaskInfo();
retCode = -1;
try
{
MultiFaceInfo multiFaceInfo = new MultiFaceInfo();
multiFaceInfo.faceNum = 1;
multiFaceInfo.faceOrients = new int[1];
multiFaceInfo.faceOrients[0] = singleFaceInfo.faceOrient;
multiFaceInfo.faceRects = new MRECT[1];
multiFaceInfo.faceRects[0] = singleFaceInfo.faceRect;
multiFaceInfo.faceDataInfoList = new FaceDataInfo[1];
multiFaceInfo.faceDataInfoList[0] = singleFaceInfo.faceDataInfo;
//人脸信息处理
retCode = faceEngine.ASFProcessEx(image, multiFaceInfo, FaceEngineMask.ASF_MASKDETECT);
if (retCode == 0)
{
//获取口罩检测结果
retCode = faceEngine.ASFGetMask(out maskInfo);
}
}
catch (Exception ex)
{
LogUtil.LogInfo(typeof(FaceUtil), ex);
}
return(maskInfo);
}
/// <summary>
/// 提取单人脸特征
/// </summary>
/// <param name="pEngine">人脸识别引擎</param>
/// <param name="image">图片</param>
/// <param name="singleFaceInfo">单人脸信息</param>
/// <returns>单人脸特征</returns>
public static FaceFeature ExtractFeature(FaceEngine faceEngine, Image image, SingleFaceInfo singleFaceInfo)
{
FaceFeature faceFeature = null;
try
{
MultiFaceInfo multiFaceInfo = new MultiFaceInfo();
multiFaceInfo.faceNum = 1;
multiFaceInfo.faceOrients = new int[1];
multiFaceInfo.faceOrients[0] = singleFaceInfo.faceOrient;
multiFaceInfo.faceRects = new MRECT[1];
multiFaceInfo.faceRects[0] = singleFaceInfo.faceRect;
multiFaceInfo.faceDataInfoList = new FaceDataInfo[1];
multiFaceInfo.faceDataInfoList[0] = singleFaceInfo.faceDataInfo;
//口罩检测
int retCode = -1;
MaskInfo maskInfo = MaskEstimation(faceEngine, image, singleFaceInfo, out retCode);
if (retCode != 0 || maskInfo.maskArray == null || maskInfo.maskArray.Length <= 0)
{
return(faceFeature);
}
bool isMask = maskInfo.maskArray[0].Equals(1);
faceEngine.ASFFaceFeatureExtractEx(image, multiFaceInfo, ASF_RegisterOrNot.ASF_RECOGNITION, out faceFeature, 0, isMask);
}
catch (Exception ex)
{
LogUtil.LogInfo(typeof(FaceUtil), ex);
}
return(faceFeature);
}
/// <summary>
/// 提取人脸特征，多人脸默认取第一个人脸特征
/// </summary>
/// <param name="pEngine">引擎Handle</param>
/// <param name="image">图像</param>
/// <returns>保存人脸特征结构体指针</returns>
public static FaceFeature ExtractFeature(FaceEngine faceEngine, Image image, out SingleFaceInfo singleFaceInfo, ref int retCode, int faceIndex = 0)
{
FaceFeature faceFeature = new FaceFeature();
singleFaceInfo = new SingleFaceInfo();
try
{
if (image == null)
{
return(faceFeature);
}
MultiFaceInfo multiFaceInfo = new MultiFaceInfo();
//人脸检测
retCode = faceEngine.ASFDetectFacesEx(image, out multiFaceInfo);
if (retCode != 0)
{
return(faceFeature);
}
singleFaceInfo.faceOrient = multiFaceInfo.faceOrients[faceIndex];
singleFaceInfo.faceRect = multiFaceInfo.faceRects[faceIndex];
retCode = faceEngine.ASFFaceFeatureExtractEx(image, multiFaceInfo, out faceFeature, faceIndex);
}
catch (Exception ex)
{
LogUtil.LogInfo(typeof(FaceUtil), ex);
}
return(faceFeature);
}
/// <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="image">图像</param>
/// <param name="thresold">图像质量检测阈值</param>
/// <returns>保存人脸特征结构体指针</returns>
public static FaceFeature ExtractFeature(FaceEngine faceEngine, Image image, float thresoldImg, float thresoleImgMask, ASF_RegisterOrNot registerOrNot, out SingleFaceInfo singleFaceInfo, out bool isMask, ref string featureResult, out int retCode, int faceIndex = 0)
{
FaceFeature faceFeature = new FaceFeature();
singleFaceInfo = new SingleFaceInfo();
isMask = false;
retCode = -1;
try
{
if (image == null)
{
return(faceFeature);
}
MultiFaceInfo multiFaceInfo;
//人脸检测
retCode = faceEngine.ASFDetectFacesEx(image, out multiFaceInfo);
if (retCode != 0 || multiFaceInfo.faceNum <= 0)
{
featureResult = string.Format("{1},接口返回值:{0}", retCode, retCode != 0 ? "人脸检测失败" : "检测到的人脸数为0");
return(faceFeature);
}
singleFaceInfo.faceOrient = multiFaceInfo.faceOrients[faceIndex];
singleFaceInfo.faceRect = multiFaceInfo.faceRects[faceIndex];
singleFaceInfo.faceDataInfo = multiFaceInfo.faceDataInfoList[faceIndex];
//口罩检测
MaskInfo maskInfo = MaskEstimation(faceEngine, image, singleFaceInfo, out retCode);
if (retCode != 0 || maskInfo.maskArray == null || maskInfo.maskArray.Length <= 0)
{
featureResult = string.Format("{1},接口返回值:{0}", retCode, retCode != 0 ? "口罩检测失败" : "检测到的口罩结果为空");
return(faceFeature);
}
isMask = maskInfo.maskArray[0].Equals(1);
//图像质量检测
float confidenceLevel = 0.0f;
retCode = faceEngine.ASFImageQualityDetectEx(image, multiFaceInfo, out confidenceLevel, faceIndex, isMask);
if (retCode != 0 || confidenceLevel < (isMask ? thresoleImgMask : thresoldImg))
{
featureResult = string.Format("{1},接口返回值:{0}", retCode, retCode != 0 ? "图像质量检测失败" : "图像质量过低");
return(faceFeature);
}
//特征提取
retCode = faceEngine.ASFFaceFeatureExtractEx(image, multiFaceInfo, registerOrNot, out faceFeature, faceIndex, isMask);
if (retCode != 0)
{
featureResult = string.Format("特征提取失败,接口返回值:{0}", retCode);
}
}
catch (Exception ex)
{
LogUtil.LogInfo(typeof(FaceUtil), ex);
}
return(faceFeature);
}
/// <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="image"></param>
/// <param name="singleFaceInfo"></param>
/// <returns></returns>
public float ImageQualityDetectEx(ImageInfo image, SingleFaceInfo singleFaceInfo)
{
if (_version < 4)
{
return(1); //2.x不支持,3.x结构差异大,不做兼容
}
var result = ASFFunctions.ASFImageQualityDetectEx(EngineHandler, image.ASFImageData, singleFaceInfo.ASFSingleFaceInfo, singleFaceInfo.Mask ? 1 : 1, out float confidenceLevel);
if (result == MResult.MOK)
{
return(confidenceLevel);
}
return(0);
}
/// <summary>
/// 提取单人脸特征
/// </summary>
/// <param name="pEngine">人脸识别引擎</param>
/// <param name="image">图片</param>
/// <param name="singleFaceInfo">单人脸信息</param>
/// <returns>单人脸特征</returns>
public static FaceFeature ExtractFeature(FaceEngine faceEngine, Image image, SingleFaceInfo singleFaceInfo)
{
FaceFeature faceFeature = new FaceFeature();
try
{
MultiFaceInfo multiFaceInfo = new MultiFaceInfo();
multiFaceInfo.faceNum = 1;
multiFaceInfo.faceOrients = new int[1];
multiFaceInfo.faceOrients[0] = singleFaceInfo.faceOrient;
multiFaceInfo.faceRects = new MRECT[1];
multiFaceInfo.faceRects[0] = singleFaceInfo.faceRect;
//图片质量检测完成，进行特征提取
faceEngine.ASFFaceFeatureExtractEx(image, multiFaceInfo, out faceFeature);
}
catch (Exception ex)
{
LogUtil.LogInfo(typeof(FaceUtil), ex);
}
return(faceFeature);
}
/// <summary>
/// 获取多个人脸检测结果中面积最大的人脸
/// </summary>
/// <param name="multiFaceInfo">人脸检测结果</param>
/// <returns>面积最大的人脸信息</returns>
public static SingleFaceInfo GetMaxFace(MultiFaceInfo multiFaceInfo)
{
SingleFaceInfo singleFaceInfo = new SingleFaceInfo();
singleFaceInfo.faceRect = new MRECT();
singleFaceInfo.faceOrient = 1;
int maxArea = 0;
int index = -1;
//遍历查找最大人脸索引
for (int i = 0; i < multiFaceInfo.faceNum; i++)
{
try
{
MRECT rect = multiFaceInfo.faceRects[i];
int area = (rect.right - rect.left) * (rect.bottom - rect.top);
if (maxArea <= area)
{
maxArea = area;
index = i;
}
}
catch (Exception ex)
{
LogUtil.LogInfo(typeof(FaceUtil), ex);
}
}
//获取对应的人脸信息
if (index != -1)
{
singleFaceInfo.faceRect = multiFaceInfo.faceRects[index];
singleFaceInfo.faceOrient = multiFaceInfo.faceOrients[index];
if (multiFaceInfo.faceID != null && multiFaceInfo.faceID.Length > index)
{
singleFaceInfo.faceID = multiFaceInfo.faceID[index];
}
}
return(singleFaceInfo);
}
/// <summary>
/// 获取多个人脸检测结果中面积最大的人脸
/// </summary>
/// <param name="multiFaceInfo">人脸检测结果</param>
/// <returns>面积最大的人脸信息</returns>
private static async Task <SingleFaceInfo> GetBiggestFaceAsync(MultiFaceInfo multiFaceInfo) =>
await Task.Run(() =>
{
var singleFaceInfo = new SingleFaceInfo(new Rect(), 1);
if (multiFaceInfo.FaceNum <= 0)
{
return(singleFaceInfo);
}
var maxArea = 0;
foreach (var face in multiFaceInfo.Faces)
{
var area = (face.FaceRect.Right - face.FaceRect.Left) * (face.FaceRect.Bottom - face.FaceRect.Top);
if (area <= maxArea)
{
continue;
}
maxArea = area;
singleFaceInfo = face;
}
return(singleFaceInfo);
});
/// <summary>
/// 红外活体检测
/// </summary>
/// <param name="pEngine">引擎Handle</param>
/// <param name="imageInfo">图像数据</param>
/// <param name="singleFaceInfo">单人脸信息</param>
/// <returns>活体检测结果</returns>
public static LivenessInfo LivenessInfo_IR(FaceEngine faceEngine, Image image, SingleFaceInfo singleFaceInfo, out int retCode)
{
LivenessInfo livenessInfo = new LivenessInfo();
retCode = -1;
try
{
MultiFaceInfo multiFaceInfo = new MultiFaceInfo();
multiFaceInfo.faceNum = 1;
multiFaceInfo.faceOrients = new int[1];
multiFaceInfo.faceOrients[0] = singleFaceInfo.faceOrient;
multiFaceInfo.faceRects = new MRECT[1];
multiFaceInfo.faceRects[0] = singleFaceInfo.faceRect;
multiFaceInfo.faceDataInfoList = new FaceDataInfo[1];
multiFaceInfo.faceDataInfoList[0] = singleFaceInfo.faceDataInfo;
//人脸信息处理
retCode = faceEngine.ASFProcessEx_IR(image, multiFaceInfo, FaceEngineMask.ASF_IR_LIVENESS);
if (retCode == 0)
{
//获取IR活体检测结果
retCode = faceEngine.ASFGetLivenessScore_IR(out livenessInfo);
}
}
catch (Exception ex)
{
LogUtil.LogInfo(typeof(FaceUtil), ex);
}
return(livenessInfo);
}
/// <summary>
/// 提取单人脸特征
/// </summary>
/// <param name="pEngine">人脸识别引擎</param>
/// <param name="image">图片</param>
/// <param name="singleFaceInfo">单人脸信息</param>
/// <returns>单人脸特征</returns>
public static bool ASFImageQualityDetectEx(FaceEngine faceEngine, Image image, SingleFaceInfo singleFaceInfo)
{
bool qualityResult = false;
try
{
MultiFaceInfo multiFaceInfo = new MultiFaceInfo();
multiFaceInfo.faceNum = 1;
multiFaceInfo.faceOrients = new int[1];
multiFaceInfo.faceOrients[0] = singleFaceInfo.faceOrient;
multiFaceInfo.faceRects = new MRECT[1];
multiFaceInfo.faceRects[0] = singleFaceInfo.faceRect;
//图片质量检测
ImageQualityInfo imageQualityInfo = new ImageQualityInfo();
int qualityRetCode = faceEngine.ASFImageQualityDetectEx(image, multiFaceInfo, out imageQualityInfo);
if (qualityRetCode == 0 && imageQualityInfo != null && imageQualityInfo.faceQualityValues[0] > 0.35)
{
qualityResult = true;
}
}
catch (Exception ex)
{
LogUtil.LogInfo(typeof(FaceUtil), ex);
}
return(qualityResult);
}
/// <summary>
/// 提取特征值
/// <para>使用当前引擎初始化时设置的RegisterOrNot</para>
/// </summary>
/// <param name="image"></param>
/// <param name="singleFaceInfo"></param>
/// <returns></returns>
public FaceFeaturePro FaceFeatureExtractEx(ImageInfo image, SingleFaceInfo singleFaceInfo)
{
return(FaceFeatureExtractEx(image, singleFaceInfo, RegisterOrNot));
}
