/// <summary>
/// 性别检测
/// </summary>
/// <param name="pEngine">引擎Handle</param>
/// <param name="imageInfo">图像数据</param>
/// <param name="multiFaceInfo">人脸检测结果</param>
/// <returns>保存性别估计结果结构体</returns>
public static ASF_GenderInfo GenderEstimation(IntPtr pEngine, ImageInfo imageInfo, ASF_MultiFaceInfo multiFaceInfo)
{
IntPtr pMultiFaceInfo = MemoryHelper.Malloc(MemoryHelper.SizeOf <ASF_MultiFaceInfo>());
MemoryHelper.StructureToPtr(multiFaceInfo, pMultiFaceInfo);
if (multiFaceInfo.faceNum == 0)
{
return(new ASF_GenderInfo());
}
//人脸信息处理
int retCode = ASFWrapper.ASFProcess(pEngine, imageInfo.width, imageInfo.height, imageInfo.format, imageInfo.imgData, pMultiFaceInfo, FaceEngineMask.ASF_GENDER);
//获取性别信息
IntPtr pGenderInfo = MemoryHelper.Malloc(MemoryHelper.SizeOf <ASF_GenderInfo>());
retCode = ASFWrapper.ASFGetGender(pEngine, pGenderInfo);
//Console.WriteLine("Get Gender Result:" + retCode);
SimplifiedLogHelper.WriteIntoSystemLog(nameof(Afw.Core.Helper.FaceProcessHelper), $"Get Gender Result:{retCode}");
ASF_GenderInfo genderInfo = MemoryHelper.PtrToStructure <ASF_GenderInfo>(pGenderInfo);
//释放内存
MemoryHelper.Free(pMultiFaceInfo);
MemoryHelper.Free(pGenderInfo);
return(genderInfo);
}
/// <summary>
/// 年龄检测
/// </summary>
/// <param name="pEngine">引擎Handle</param>
/// <param name="imageInfo">图像数据</param>
/// <param name="multiFaceInfo">人脸检测结果</param>
/// <returns>年龄检测结构体</returns>
public static ASF_AgeInfo AgeEstimation(IntPtr pEngine, ImageInfo imageInfo, ASF_MultiFaceInfo multiFaceInfo, out int retCode)
{
retCode = -1;
IntPtr pMultiFaceInfo = MemoryHelper.Malloc(MemoryHelper.SizeOf <ASF_MultiFaceInfo>());
MemoryHelper.StructureToPtr(multiFaceInfo, pMultiFaceInfo);
if (multiFaceInfo.faceNum == 0)
{
return(new ASF_AgeInfo());
}
//人脸信息处理
retCode = ASFWrapper.ASFProcess(pEngine, imageInfo.width, imageInfo.height, imageInfo.format, imageInfo.imgData, pMultiFaceInfo, FaceEngineMask.ASF_AGE);
if (retCode == 0)
{
//获取年龄信息
IntPtr pAgeInfo = MemoryHelper.Malloc(MemoryHelper.SizeOf <ASF_AgeInfo>());
retCode = ASFWrapper.ASFGetAge(pEngine, pAgeInfo);
//Console.WriteLine("Get Age Result:" + retCode);
SimplifiedLogHelper.WriteIntoSystemLog(nameof(Afw.Core.Helper.FaceProcessHelper), $"Get Age Result:{retCode}");
ASF_AgeInfo ageInfo = MemoryHelper.PtrToStructure <ASF_AgeInfo>(pAgeInfo);
//释放内存
MemoryHelper.Free(pMultiFaceInfo);
MemoryHelper.Free(pAgeInfo);
return(ageInfo);
}
else
{
return(new ASF_AgeInfo());
}
}
internal static void TestASF_GetVersion()
{
IntPtr pImageEngine = IntPtr.Zero;
//初始化引擎
uint detectMode = DetectionMode.ASF_DETECT_MODE_VIDEO;
//检测脸部的角度优先值
int detectFaceOrientPriority = ASF_OrientPriority.ASF_OP_0_HIGHER_EXT;
//人脸在图片中所占比例，如果需要调整检测人脸尺寸请修改此值，有效数值为2-32
int detectFaceScaleVal = 16;
//最大需要检测的人脸个数
int detectFaceMaxNum = 5;
//引擎初始化时需要初始化的检测功能组合
int combinedMask = FaceEngineMask.ASF_FACE_DETECT | FaceEngineMask.ASF_FACERECOGNITION | FaceEngineMask.ASF_AGE | FaceEngineMask.ASF_GENDER | FaceEngineMask.ASF_FACE3DANGLE;
//初始化引擎，正常值为0，其他返回值请参考http://ai.arcsoft.com.cn/bbs/forum.php?mod=viewthread&tid=19&_dsign=dbad527e
var retCode = ASFWrapper.ASFInitEngine(detectMode, detectFaceOrientPriority, detectFaceScaleVal, detectFaceMaxNum, combinedMask, out pImageEngine);
if (pImageEngine != IntPtr.Zero)
{
IntPtr v = ASFWrapper.ASFGetVersion(pImageEngine);
var stuv = (Core.Domain.ASF_VERSION)Marshal.PtrToStructure(v, typeof(Core.Domain.ASF_VERSION));
Console.WriteLine(stuv.CopyRight);
}
Console.WriteLine(retCode.ToEnum <MError>().GetFieldDescription());
}
/// <summary>
/// RGB活体检测
/// </summary>
/// <param name="pEngine"></param>
/// <param name="imageInfo"></param>
/// <param name="multiFaceInfo"></param>
/// <returns></returns>
public static ASF_LivenessInfo LivenessEstimation(IntPtr pEngine, ImageInfo imageInfo, ASF_MultiFaceInfo multiFaceInfo)
{
IntPtr pMultiFaceInfo = MemoryHelper.Malloc(MemoryHelper.SizeOf <ASF_MultiFaceInfo>());
MemoryHelper.StructureToPtr(multiFaceInfo, pMultiFaceInfo);
try
{
if (multiFaceInfo.faceNum == 0)
{
return(new ASF_LivenessInfo());
}
if (multiFaceInfo.faceNum > 1)
{
ASF_SingleFaceInfo singleFaceInfo = GetMaxFace(multiFaceInfo);
ASF_MultiFaceInfo multiFaceInfoNeo = new ASF_MultiFaceInfo();
multiFaceInfoNeo.faceRects = MemoryHelper.Malloc(MemoryHelper.SizeOf <MRECT>());
MemoryHelper.StructureToPtr <MRECT>(singleFaceInfo.faceRect, multiFaceInfoNeo.faceRects);
multiFaceInfoNeo.faceOrients = MemoryHelper.Malloc(MemoryHelper.SizeOf <int>());
MemoryHelper.StructureToPtr <int>(singleFaceInfo.faceOrient, multiFaceInfoNeo.faceOrients);
multiFaceInfoNeo.faceNum = 1;
MemoryHelper.StructureToPtr(multiFaceInfoNeo, pMultiFaceInfo);
}
//活体信息检测
int retCode = ASFWrapper.ASFProcess(pEngine, imageInfo.width, imageInfo.height, imageInfo.format, imageInfo.imgData, pMultiFaceInfo, FaceEngineMask.ASF_LIVENESS);
if (retCode == 0)
{
//获取活体信息
IntPtr pLivenessInfo = MemoryHelper.Malloc(MemoryHelper.SizeOf <ASF_LivenessInfo>());
retCode = ASFWrapper.ASFGetLivenessScore(pEngine, pLivenessInfo);
SimplifiedLogHelper.WriteIntoSystemLog(nameof(Afw.Core.Helper.FaceProcessHelper), $"Get Liveness Result:{retCode}");
ASF_LivenessInfo livenessInfo = MemoryHelper.PtrToStructure <ASF_LivenessInfo>(pLivenessInfo);
//释放内存
MemoryHelper.Free(pLivenessInfo);
return(livenessInfo);
}
else
{
return(new ASF_LivenessInfo());
}
}
catch (Exception ex)
{
Afw.Core.Helper.SimplifiedLogHelper.WriteIntoSystemLog(nameof(FaceProcessHelper), $"LivenessEstimation Exception => {ex.ToString()}");
}
finally
{
//释放内存
MemoryHelper.Free(pMultiFaceInfo);
MemoryHelper.Free(imageInfo.imgData);
}
return(new ASF_LivenessInfo());
}
/// <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);
}
public static MError UnintialEngine(IntPtr ptrEngine)
{
var retCode = MError.MERR_UNKNOWN.ToInt();
try
{
retCode = ASFWrapper.ASFUninitEngine(ptrEngine);
}
catch (Exception ex)
{
retCode = MError.MERR_UNKNOWN.ToInt();
Afw.Core.Helper.SimplifiedLogHelper.WriteIntoSystemLog(nameof(Activation), $"ASFUninitEngine Exception : {ex.ToString()}");
}
return(retCode.ToEnum <MError>());
}
/// <summary>
/// 人脸检测(PS:检测RGB图像的人脸时，必须保证图像的宽度能被4整除，否则会失败)
/// </summary>
/// <param name="pEngine">引擎Handle</param>
/// <param name="imageInfo">图像数据</param>
/// <returns>人脸检测结果</returns>
public static ASF_MultiFaceInfo DetectFace(IntPtr pEngine, ImageInfo imageInfo)
{
ASF_MultiFaceInfo multiFaceInfo = new ASF_MultiFaceInfo();
IntPtr pMultiFaceInfo = MemoryHelper.Malloc(MemoryHelper.SizeOf <ASF_MultiFaceInfo>());
int retCode = ASFWrapper.ASFDetectFaces(pEngine, imageInfo.width, imageInfo.height, imageInfo.format, imageInfo.imgData, pMultiFaceInfo);
var errCode = retCode.ToEnum <MError>();
if (errCode == MError.MOK)
{
multiFaceInfo = MemoryHelper.PtrToStructure <ASF_MultiFaceInfo>(pMultiFaceInfo);
}
else
{
throw new FaceDetectException(errCode);
}
return(multiFaceInfo);
}
/// <summary>
///
/// </summary>
/// <param name="similarity"></param>
/// <param name="ptrVideoImageEngine"></param>
/// <param name="feature"></param>
/// <param name="feature2"></param>
/// <returns></returns>
public static MError FaceFeatureCompare(
out float similarity,
IntPtr ptrVideoImageEngine,
IntPtr feature,
IntPtr feature2)
{
similarity = 0f;
var retCode = MError.MERR_UNKNOWN.ToInt();
try
{
retCode = ASFWrapper.ASFFaceFeatureCompare(ptrVideoImageEngine, feature, feature2, out similarity);
}
catch (Exception ex)
{
retCode = MError.MERR_UNKNOWN.ToInt();
Afw.Core.Helper.SimplifiedLogHelper.WriteIntoSystemLog(nameof(Activation), $"FaceFeatureCompare Exception : {ex.ToString()}");
}
return(retCode.ToEnum <MError>());
}
/// <summary>
/// 初始化引擎
/// </summary>
/// <param name="detectMode">AF_DETECT_MODE_VIDEO 视频模式 | AF_DETECT_MODE_IMAGE 图片模式</param>
/// <param name="detectFaceOrientPriority">检测脸部的角度优先值，推荐：ASF_OrientPriority.ASF_OP_0_HIGHER_EXT</param>
/// <param name="detectFaceScaleVal">用于数值化表示的最小人脸尺寸</param>
/// <param name="detectFaceMaxNum">最大需要检测的人脸个数</param>
/// <param name="combinedMask">用户选择需要检测的功能组合，可单个或多个</param>
/// <param name="ptrEngine">初始化返回的引擎handle</param>
/// <returns>调用结果</returns>
public static MError InitialEngine(
uint detectMode,
int detectFaceOrientPriority,
int detectFaceScaleVal,
int detectFaceMaxNum,
int combinedMask,
out IntPtr ptrEngine)
{
ptrEngine = IntPtr.Zero;
var retCode = MError.MERR_UNKNOWN.ToInt();
try
{
retCode = ASFWrapper.ASFInitEngine(detectMode, detectFaceOrientPriority, detectFaceScaleVal, detectFaceMaxNum, combinedMask, out ptrEngine);
}
catch (Exception ex)
{
retCode = MError.MERR_UNKNOWN.ToInt();
Afw.Core.Helper.SimplifiedLogHelper.WriteIntoSystemLog(nameof(Activation), $"ASFOnlineActivation Exception : {ex.ToString()}");
}
return(retCode.ToEnum <MError>());
}
internal static void TestGetActiveFileInfo()
{
IntPtr fileInfo = MemoryHelper.Malloc(MemoryHelper.SizeOf <ASF_ActiveFileInfo>());
var ret = ASFWrapper.ASFGetActiveFileInfo(fileInfo);
if (ret.ToEnum <MError>() == MError.MOK && IntPtr.Zero != fileInfo)
{
var s = (Core.Domain.ASF_ActiveFileInfo)Marshal.PtrToStructure(fileInfo, typeof(Core.Domain.ASF_ActiveFileInfo));
var t = typeof(Core.Domain.ASF_ActiveFileInfo);
System.Reflection.FieldInfo[] mis = t.GetFields();
foreach (var mi in mis)
{
Console.WriteLine($"{mi.Name} => {mi.GetValue(s)}");
}
}
else
{
Console.WriteLine($"ERROR:{ret.ToEnum<MError>()},fileInfo={fileInfo}");
}
}
public void Dispose()
{
if (ptrImageEngine != IntPtr.Zero)
{
ASFWrapper.ASFUninitEngine(ptrImageEngine);
}
if (ptrVideoEngine != IntPtr.Zero)
{
ASFWrapper.ASFUninitEngine(ptrVideoEngine);
}
if (ptrVideoImageEngine != IntPtr.Zero)
{
ASFWrapper.ASFUninitEngine(ptrVideoImageEngine);
}
//if (deviceVideo.IsRunning)
deviceVideo?.SignalToStop();
//if (deviceVideoIr.IsRunning)
deviceVideoIr?.SignalToStop();
}
public static MError ASFOnlineActivation()
{
var retCode = MError.MERR_UNKNOWN.ToInt();
var appId = AppSettingManager.AppId;
var sdkKey64 = AppSettingManager.SdkKey64;
var sdkKey32 = AppSettingManager.SdkKey32;
var is64CPU = Afw.Core.PlatformProb.Is64BitOperatingSystem;
var sdkKey = is64CPU ? sdkKey64 : sdkKey32;
try
{
retCode = ASFWrapper.ASFOnlineActivation(appId, sdkKey);
}
catch (Exception ex)
{
if (ex.Message.IndexOf("无法加载 DLL") > -1)
{
retCode = MError.MERR_COMPONENT_NOT_EXIST.ToInt();
}
Afw.Core.Helper.SimplifiedLogHelper.WriteIntoSystemLog(nameof(Activation), $"ASFOnlineActivation Exception : {ex.ToString()}");
}
return(retCode.ToEnum <MError>());
}
