/// <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 = UtilToolMemory.Malloc(UtilToolMemory.SizeOf <ASF_MultiFaceInfo>());
int retCode = ASFFunctions.ASFDetectFaces(pEngine, imageInfo.width, imageInfo.height, imageInfo.format, imageInfo.imgData, pMultiFaceInfo);
if (retCode != 0)
{
UtilToolMemory.Free(pMultiFaceInfo);
return(multiFaceInfo);
}
multiFaceInfo = UtilToolMemory.PtrToStructure <ASF_MultiFaceInfo>(pMultiFaceInfo);
UtilToolMemory.Free(pMultiFaceInfo);
return(multiFaceInfo);
}
/// <summary>
/// 引擎初始化
/// </summary>
/// <param name="detectMode">检测模式</param>
/// <param name="detectFaceOrientPriority">检测脸部的角度优先值</param>
/// <param name="detectFaceScaleVal">用于数值化表示的最小人脸尺寸</param>
/// <param name="detectFaceMaxNum">最大需要检测的人脸个数</param>
/// <param name="combinedMask">用户选择需要检测的功能组合，可单个或多个</param>
/// <returns>返回0表示正常；其他值请在官网-帮助中心查询</returns>
public int ASFInitEngine(DetectionMode detectMode, ASF_OrientPriority detectFaceOrientPriority, int detectFaceScaleVal, int detectFaceMaxNum, int combinedMask)
{
pEngine = IntPtr.Zero;
if (detectFaceScaleVal < 2 || detectFaceScaleVal > 32)
{
detectFaceScaleVal = 16;
}
if (detectFaceMaxNum < 1 || detectFaceMaxNum > 50)
{
detectFaceMaxNum = 10;
}
int retCode = ASFFunctions.ASFInitEngine(detectMode, detectFaceOrientPriority, detectFaceScaleVal, detectFaceMaxNum, combinedMask, ref pEngine);
return(retCode);
}
/// <summary>
/// 窗体关闭事件
/// </summary>
private void Form_Closed(object sender, FormClosedEventArgs e)
{
//销毁引擎
int retCode = ASFFunctions.ASFUninitEngine(pImageEngine);
Console.WriteLine("UninitEngine pImageEngine Result:" + retCode);
//销毁引擎
retCode = ASFFunctions.ASFUninitEngine(pVideoEngine);
Console.WriteLine("UninitEngine pVideoEngine Result:" + retCode);
if (videoSource.IsRunning)
{
videoSource.SignalToStop(); //关闭摄像头
}
}
/// <summary>
/// 该接口目前仅支持单人脸IR活体检测（不支持年龄、性别、3D角度的检测），默认取第一张人脸
/// </summary>
/// <param name="pEngine">引擎handle</param>
/// <param name="imageFormat">图像格式</param>
/// <param name="image">图片</param>
/// <param name="multiFaceInfo">人脸框信息</param>
/// <param name="combinedMask">检测属性</param>
/// <returns>返回0表示正常；返回负数请根据ErrorCodeUtil类注释查看；其他值请在官网-帮助中心查询</returns>
public int ASFProcess_IR(Image image, MultiFaceInfo multiFaceInfo, int combinedMask, ASF_ImagePixelFormat imageFormat = ASF_ImagePixelFormat.ASVL_PAF_GRAY)
{
if (multiFaceInfo == null)
{
return(ErrorCodeUtil.MULPTIFACEINFO_IS_NULL);
}
if (image == null)
{
return(ErrorCodeUtil.IMAGE_IS_NULL);
}
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);
}
//转化多人脸信息
ASF_MultiFaceInfo multiFaceInfoStruct = new ASF_MultiFaceInfo();
IntPtr pMultiFaceInfo = MemoryUtil.Malloc(MemoryUtil.SizeOf <ASF_MultiFaceInfo>());
multiFaceInfoStruct.faceNum = multiFaceInfo.faceNum;
if (multiFaceInfo.faceNum > 0)
{
if (multiFaceInfo.faceID != null)
{
multiFaceInfoStruct.faceID = MemoryUtil.Malloc(multiFaceInfo.faceNum * MemoryUtil.SizeOf <int>());
Marshal.Copy(multiFaceInfo.faceID, 0, multiFaceInfoStruct.faceID, multiFaceInfo.faceNum);
}
multiFaceInfoStruct.faceOrients = MemoryUtil.Malloc(multiFaceInfo.faceNum * MemoryUtil.SizeOf <int>());
Marshal.Copy(multiFaceInfo.faceOrients, 0, multiFaceInfoStruct.faceOrients, multiFaceInfo.faceNum);
multiFaceInfoStruct.faceRects = MemoryUtil.Malloc(MemoryUtil.SizeOf <MRECT>() * multiFaceInfo.faceNum);
byte[] allByte = new byte[MemoryUtil.SizeOf <MRECT>() * multiFaceInfo.faceNum];
for (int i = 0; i < multiFaceInfo.faceNum; i++)
{
byte[] tempBytes = MemoryUtil.StructToBytes(multiFaceInfo.faceRects[i]);
tempBytes.CopyTo(allByte, MemoryUtil.SizeOf <MRECT>() * i);
}
Marshal.Copy(allByte, 0, multiFaceInfoStruct.faceRects, allByte.Length);
}
MemoryUtil.StructureToPtr(multiFaceInfoStruct, pMultiFaceInfo);
//调用SDK接口
int retCode = ASFFunctions.ASFProcess_IR(pEngine, imageInfo.width, imageInfo.height, imageInfo.format, imageInfo.imgData, pMultiFaceInfo, combinedMask);
//释放内存
MemoryUtil.FreeArray(multiFaceInfoStruct.faceID, multiFaceInfoStruct.faceOrients, multiFaceInfoStruct.faceRects, pMultiFaceInfo);
return(retCode);
}
/// <summary>
/// 设置活体阈值：取值范围[0-1]内部默认数值RGB-0.5，IR-0.7， 用户可以根据实际需求，设置不同的阈值
/// </summary>
/// <param name="rgbThreshold">RGB活体阈值</param>
/// <param name="irThreshole">IR活体阈值</param>
/// <returns>返回0表示正常；返回负数请根据ErrorCodeUtil类注释查看；其他值请在官网-帮助中心查询</returns>
public int ASFSetLivenessParam(float rgbThreshold = 0.5f, float irThreshole = 0.7f)
{
ASF_LivenessThreshold livebessThreshold = new ASF_LivenessThreshold();
//对应设置阈值
livebessThreshold.thresholdmodel_BGR = (rgbThreshold >= 0 && rgbThreshold <= 1) ? rgbThreshold : 0.5f;
livebessThreshold.thresholdmodel_IR = (irThreshole >= 0 && irThreshole <= 1) ? irThreshole : 0.7f;
IntPtr pLivenessThreshold = MemoryUtil.Malloc(MemoryUtil.SizeOf <ASF_LivenessThreshold>());
MemoryUtil.StructureToPtr(livebessThreshold, pLivenessThreshold);
//调用SDK接口
int retCode = ASFFunctions.ASFSetLivenessParam(pEngine, pLivenessThreshold);
MemoryUtil.Free(pLivenessThreshold);
return(retCode);
}
public void Dispose()
{
if (pImageEngine != IntPtr.Zero)
{
int result = ASFFunctions.ASFUninitEngine(pImageEngine);
if (result == 0)
{
pImageEngine = IntPtr.Zero;
}
else
{
LoggerService.logger.Info($"图片采集引擎销毁失败，错误代码: {result}");
}
}
}
/// <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 ASFFaceFeatureExtract(Image image, MultiFaceInfo multiFaceInfo, out FaceFeature faceFeature, int faceIndex = 0, ASF_ImagePixelFormat imageFormat = ASF_ImagePixelFormat.ASVL_PAF_RGB24_B8G8R8)
{
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 = 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>());
//调用SDK接口
int retCode = ASFFunctions.ASFFaceFeatureExtract(pEngine, imageInfo.width, imageInfo.height, imageInfo.format, imageInfo.imgData, pSIngleFaceInfo, pAsfFaceFeature);
if (retCode != 0)
{
MemoryUtil.FreeArray(pSIngleFaceInfo, pAsfFaceFeature, imageInfo.imgData);
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);
return(retCode);
}
/// <summary>
/// 人脸检测/人脸追踪
/// </summary>
/// <param name="imageFormat">图片格式</param>
/// <param name="image">图片</param>
/// <param name="multiFaceInfo">多人脸对象</param>
/// <param name="detectModel">检测模式</param>
/// <returns>返回0表示正常；返回负数请根据ErrorCodeUtil类注释查看；其他值请在官网-帮助中心查询</returns>
public int ASFDetectFaces(Image image, out MultiFaceInfo multiFaceInfo, ASF_ImagePixelFormat imageFormat = ASF_ImagePixelFormat.ASVL_PAF_RGB24_B8G8R8, ASF_DetectModel detectModel = ASF_DetectModel.ASF_DETECT_MODEL_RGB)
{
multiFaceInfo = new MultiFaceInfo();
//判断图像是否为空
if (image == null)
{
return(ErrorCodeUtil.IMAGE_IS_NULL);
}
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);
}
IntPtr pMultiFaceInfo = MemoryUtil.Malloc(MemoryUtil.SizeOf <ASF_MultiFaceInfo>());
//调用SDK接口
int retCode = ASFFunctions.ASFDetectFaces(pEngine, imageInfo.width, imageInfo.height, imageInfo.format, imageInfo.imgData, pMultiFaceInfo);
if (retCode != 0)
{
MemoryUtil.FreeArray(imageInfo.imgData, pMultiFaceInfo);
return(retCode);
}
ASF_MultiFaceInfo multiFaceInfoStruct = MemoryUtil.PtrToStructure <ASF_MultiFaceInfo>(pMultiFaceInfo);
MemoryUtil.FreeArray(imageInfo.imgData, pMultiFaceInfo);
//转化非托管内存到托管内存
multiFaceInfo.faceNum = multiFaceInfoStruct.faceNum;
if (multiFaceInfo.faceNum > 0)
{
if (multiFaceInfoStruct.faceID != IntPtr.Zero)
{
multiFaceInfo.faceID = new int[multiFaceInfo.faceNum];
Marshal.Copy(multiFaceInfoStruct.faceID, multiFaceInfo.faceID, 0, multiFaceInfo.faceNum);
}
multiFaceInfo.faceOrients = new int[multiFaceInfo.faceNum];
Marshal.Copy(multiFaceInfoStruct.faceOrients, multiFaceInfo.faceOrients, 0, multiFaceInfo.faceNum);
multiFaceInfo.faceRects = new MRECT[multiFaceInfo.faceNum];
for (int i = 0; i < multiFaceInfo.faceNum; i++)
{
multiFaceInfo.faceRects[i] = MemoryUtil.PtrToStructure <MRECT>(multiFaceInfoStruct.faceRects + MemoryUtil.SizeOf <MRECT>() * i);
}
}
return(retCode);
}
/// <summary>
/// Infrared in vivo detection
/// </summary>
/// <param name="pEngine">Engine Handle</param>
/// <param name="imageInfo">Image data</param>
/// <param name="multiFaceInfo">In vivo test results</param>
/// <returns>Preserve the structure of in vivo detection results</returns>
public static ASF_LivenessInfo LivenessInfo_IR(IntPtr pEngine, ImageInfo imageInfo, ASF_MultiFaceInfo multiFaceInfo, out int retCode)
{
IntPtr pMultiFaceInfo = MemoryUtil.Malloc(MemoryUtil.SizeOf <ASF_MultiFaceInfo>());
MemoryUtil.StructureToPtr(multiFaceInfo, pMultiFaceInfo);
if (multiFaceInfo.faceNum == 0)
{
retCode = -1;
//Release memory
MemoryUtil.Free(pMultiFaceInfo);
return(new ASF_LivenessInfo());
}
try
{
//Face information processing
retCode = ASFFunctions.ASFProcess_IR(pEngine, imageInfo.width, imageInfo.height, imageInfo.format, imageInfo.imgData, pMultiFaceInfo, FaceEngineMask.ASF_IR_LIVENESS);
if (retCode == 0)
{
//Obtain in vivo test results
IntPtr pLivenessInfo = MemoryUtil.Malloc(MemoryUtil.SizeOf <ASF_LivenessInfo>());
retCode = ASFFunctions.ASFGetLivenessScore_IR(pEngine, pLivenessInfo);
Console.WriteLine("Get Liveness Result:" + retCode);
ASF_LivenessInfo livenessInfo = MemoryUtil.PtrToStructure <ASF_LivenessInfo>(pLivenessInfo);
//Release memory
MemoryUtil.Free(pMultiFaceInfo);
MemoryUtil.Free(pLivenessInfo);
return(livenessInfo);
}
else
{
//Release memory
MemoryUtil.Free(pMultiFaceInfo);
return(new ASF_LivenessInfo());
}
}
catch
{
retCode = -1;
//Release memory
MemoryUtil.Free(pMultiFaceInfo);
return(new ASF_LivenessInfo());
}
}
/// <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)
{
//释放指针
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);
return(pLocalFeature);
}
/// <summary>
/// 匹配事件
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void matchBtn_Click(object sender, EventArgs e)
{
if (imagesFeatureList.Count == 0)
{
MessageBox.Show("请注册人脸!", "提示", MessageBoxButtons.OK, MessageBoxIcon.Error);
return;
}
if (image1Feature == IntPtr.Zero)
{
if (picImageCompare.Image == null)
{
MessageBox.Show("请选择识别图!", "提示", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
else
{
MessageBox.Show("比对失败，识别图未提取到特征值!", "提示", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
return;
}
float compareSimilarity = 0f;
int compareNum = 0;
AppendText(string.Format("------------------------------开始比对，时间:{0}------------------------------\r\n", DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss:ms")));
for (int i = 0; i < imagesFeatureList.Count; i++)
{
IntPtr feature = imagesFeatureList[i];
float similarity = 0f;
long t1 = DateTime.Now.ToFileTime();
int ret = ASFFunctions.ASFFaceFeatureCompare(pEngine, image1Feature, feature, ref similarity);
long t2 = DateTime.Now.ToFileTime();
AppendText(string.Format("与{0}号比对结果:{1}\r\n", i, similarity));
imageList.Items[i].Text = string.Format("{0}号({1})", i, similarity);
if (similarity > compareSimilarity)
{
compareSimilarity = similarity;
compareNum = i;
}
}
if (compareSimilarity > 0)
{
lblCompareInfo.Text = " " + compareNum + "号," + compareSimilarity;
}
AppendText(string.Format("------------------------------比对结束，时间:{0}------------------------------\r\n", DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss:ms")));
}
/// <summary>
/// 红外活体检测
/// </summary>
/// <param name="pEngine">引擎Handle</param>
/// <param name="imageInfo">图像数据</param>
/// <param name="multiFaceInfo">活体检测结果</param>
/// <returns>保存活体检测结果结构体</returns>
public static ASF_LivenessInfo LivenessInfo_IR(IntPtr pEngine, ImageInfo imageInfo, ASF_MultiFaceInfo multiFaceInfo, out int retCode)
{
IntPtr pMultiFaceInfo = UtilToolMemory.Malloc(UtilToolMemory.SizeOf <ASF_MultiFaceInfo>());
UtilToolMemory.StructureToPtr(multiFaceInfo, pMultiFaceInfo);
if (multiFaceInfo.faceNum == 0)
{
retCode = -1;
//释放内存
UtilToolMemory.Free(pMultiFaceInfo);
return(new ASF_LivenessInfo());
}
try
{
//人脸信息处理
retCode = ASFFunctions.ASFProcess_IR(pEngine, imageInfo.width, imageInfo.height, imageInfo.format, imageInfo.imgData, pMultiFaceInfo, FaceEngineMask.ASF_IR_LIVENESS);
if (retCode == 0)
{
//获取活体检测结果
IntPtr pLivenessInfo = UtilToolMemory.Malloc(UtilToolMemory.SizeOf <ASF_LivenessInfo>());
retCode = ASFFunctions.ASFGetLivenessScore_IR(pEngine, pLivenessInfo);
Console.WriteLine("Get Liveness Result:" + retCode);
ASF_LivenessInfo livenessInfo = UtilToolMemory.PtrToStructure <ASF_LivenessInfo>(pLivenessInfo);
//释放内存
UtilToolMemory.Free(pMultiFaceInfo);
UtilToolMemory.Free(pLivenessInfo);
return(livenessInfo);
}
else
{
//释放内存
UtilToolMemory.Free(pMultiFaceInfo);
return(new ASF_LivenessInfo());
}
}
catch
{
retCode = -1;
//释放内存
UtilToolMemory.Free(pMultiFaceInfo);
return(new ASF_LivenessInfo());
}
}
public void initFaceEngine()
{
//初始化引擎
uint detectMode = DetectionMode.ASF_DETECT_MODE_IMAGE;
//Image模式下检测脸部的角度优先值
int imageDetectFaceOrientPriority = ASF_OrientPriority.ASF_OP_0_ONLY;
//人脸在图片中所占比例，如果需要调整检测人脸尺寸请修改此值，有效数值为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
int result = ASFFunctions.ASFInitEngine(detectMode, imageDetectFaceOrientPriority, detectFaceScaleVal, detectFaceMaxNum, combinedMask, ref pImageEngine);
LoggerService.logger.Info($"初始化图片采集用人脸识别引擎结果：{result}");
}
/// <summary>
/// 注册并激活 虹软人脸识别SDK引擎
///
/// 需要获取APP_ID，SDKKEY64(从虹软官网申请)
/// </summary>
/// <returns>返回执行结果</returns>
public static int InitARCFaceEngine()
{
//读取App.config文件
AppSettingsReader appSetting = new AppSettingsReader();
string appId = (string)appSetting.GetValue("APP_ID", typeof(string));
string sdkKey64 = (string)appSetting.GetValue("SDKKEY64", typeof(string));
string sdkKet32 = (string)appSetting.GetValue("SDKKEY32", typeof(string));
//判断运行的CPU位数
var is64CPU = Environment.Is64BitProcess;
if (string.IsNullOrWhiteSpace(appId) || string.IsNullOrWhiteSpace(is64CPU?sdkKey64:sdkKet32))
{
MessageBox.Show($"请在App.Config配置文件中先配置APP_ID和SDKKEY{(is64CPU ? 64:32)}");
return(-1);
}
//用来存储 人脸识别SDK 申请激活后的结果
int result = 0;
try
{
result = ASFFunctions.ASFActivation(appId, is64CPU ? sdkKey64 : sdkKet32);
}
catch (Exception ex)
{
if (ex.Message.Contains("无法加载DLL"))
{
MessageBox.Show("请将sdk相关DLL放入bin对应的x86或x64下的文件夹中!");
}
else
{
MessageBox.Show("引擎初始化失败！");
}
return(-2);
}
LoggerService.logger.Info("人脸识别引擎激活成功。");
return(result);
}
/// <summary>
/// 激活并初始化引擎
/// </summary>
private void ActiveAndInitEngines()
{
//读取配置文件中的 APP_ID 和 SDKKEY
AppSettingsReader reader = new AppSettingsReader();
string appId = (string)reader.GetValue("APP_ID", typeof(string));
string sdkKey = (string)reader.GetValue("SDKKEY", typeof(string));
int retCode = 0;
//激活引擎
try
{
retCode = ASFFunctions.ASFActivation(appId, sdkKey);
}
catch (Exception ex)
{
//异常处理
return;
}
#region 图片引擎pImageEngine初始化
//初始化引擎
uint detectMode = DetectionMode.ASF_DETECT_MODE_IMAGE;
//检测脸部的角度优先值
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
retCode = ASFFunctions.ASFInitEngine(detectMode, detectFaceOrientPriority, detectFaceScaleVal, detectFaceMaxNum, combinedMask, ref pImageEngine);
if (retCode == 0)
{
this.Text = ("图片引擎初始化成功!\n");
}
else
{
this.Text = (string.Format("图片引擎初始化失败!错误码为:{0}\n", retCode));
}
#endregion
}
/// <summary>
/// 得到feature比较结果
/// </summary>
/// <param name="feature"></param>
/// <returns></returns>
private int compareFeature(IntPtr feature, out float similarity)
{
int result = -1;
similarity = 0f;
//如果人脸库不为空，则进行人脸匹配
if (imagesFeatureList != null && imagesFeatureList.Count > 0)
{
for (int i = 0; i < imagesFeatureList.Count; i++)
{
//调用人脸匹配方法，进行匹配
ASFFunctions.ASFFaceFeatureCompare(pVideoRGBImageEngine, feature, imagesFeatureList[i], ref similarity);
if (similarity >= threshold)
{
result = i;
break;
}
}
}
return(result);
}
/// <summary>
/// 窗体关闭事件
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void IdentityVerify_FormClosed(object sender, FormClosedEventArgs e)
{
//销毁引擎
int retCode = ASFFunctions.ASFUninitEngine(pImageEngine);
Console.WriteLine("UninitEngine pImageEngine Result:" + retCode);
//销毁引擎
retCode = ASFFunctions.ASFUninitEngine(pVideoEngine);
Console.WriteLine("UninitEngine pVideoEngine Result:" + retCode);
//销毁引擎
retCode = ASFFunctions.ASFUninitEngine(pVideoImageEngine);
Console.WriteLine("UninitEngine pVideoImageEngine Result:" + retCode);
if (videoSource.IsRunning)
{
videoSource.SignalToStop(); //关闭摄像头
}
idCardHelper.CloseService();
this.Dispose();
this.Close();
MemoryUtil.ClearMemory();
}
/// <summary>
/// 获取人脸信息列表
/// </summary>
/// <param name="pEngine"></param>
/// <param name="bitmap"></param>
/// <returns></returns>
public static List <FaceInfoModel> GetFaceInfos(IntPtr pEngine, Image bitmap)
{
List <FaceInfoModel> listRet = new List <FaceInfoModel>();
try
{
List <int> AgeList = new List <int>();
List <int> GenderList = new List <int>();
//检测人脸，得到Rect框
ASF_MultiFaceInfo multiFaceInfo = FaceUtil.DetectFace(pEngine, bitmap);
MultiFaceModel multiFaceModel = new MultiFaceModel(multiFaceInfo);
//人脸信息处理
ImageInfo imageInfo = ImageUtil.ReadBMP(bitmap);
int retCode = ASFFunctions.ASFProcess(pEngine, imageInfo.width, imageInfo.height, imageInfo.format, imageInfo.imgData, ref multiFaceInfo, FaceEngineMask.ASF_AGE | FaceEngineMask.ASF_GENDER);
//获取年龄信息
ASF_AgeInfo ageInfo = new ASF_AgeInfo();
retCode = ASFFunctions.ASFGetAge(pEngine, ref ageInfo);
AgeList = ageInfo.PtrToAgeArray(ageInfo.ageArray, ageInfo.num);
//获取性别信息
ASF_GenderInfo genderInfo = new ASF_GenderInfo();
retCode = ASFFunctions.ASFGetGender(pEngine, ref genderInfo);
GenderList = genderInfo.PtrToGenderArray(genderInfo.genderArray, genderInfo.num);
for (int i = 0; i < multiFaceInfo.faceNum; i++)
{
FaceInfoModel faceInfo = new FaceInfoModel();
faceInfo.age = AgeList[i];
faceInfo.gender = GenderList[i];
faceInfo.faceRect = multiFaceModel.FaceInfoList[i].faceRect;
faceInfo.feature = ExtractFeature(pEngine, bitmap, multiFaceModel.FaceInfoList[i]);//提取单人脸特征
faceInfo.faceOrient = multiFaceModel.FaceInfoList[i].faceOrient;
listRet.Add(faceInfo);
}
return(listRet);//返回多人脸信息
}
catch {
return(listRet);
}
}
/// <summary>
/// 得到feature比较结果
/// </summary>
/// <param name="pVideoFaceFeature"></param>
/// <returns></returns>
private int compareFeatureFromDB(IntPtr pVideoFaceFeature, out float similarity)
{
int result = -1;
similarity = 0f;
//如果人脸库不为空，则进行人脸匹配
if (imagesFeatureList != null && imagesFeatureList.Count > 0)
{
for (int i = 0; i < imagesFeatureList.Count; i++)
{
//调用人脸匹配方法，进行人脸特征匹配
ASFFunctions.ASFFaceFeatureCompare(pVideoImageEngine, pVideoFaceFeature, imagesFeatureList[i], ref similarity);
if (similarity >= threshold)// 相似度大于阈值，输出人脸序号，暂时默认阈值为0.8
{
result = i;
break;
}
}
}
return(result);
}
/// <summary>
/// 窗体关闭事件
/// </summary>
private void Form_Closed(object sender, FormClosedEventArgs e)
{
if (rgbVideoSource.IsRunning)
{
btnStartVideo_Click(sender, e); //关闭摄像头
}
//销毁引擎
int retCode = ASFFunctions.ASFUninitEngine(pImageEngine);
Console.WriteLine("UninitEngine pImageEngine Result:" + retCode);
//销毁引擎
retCode = ASFFunctions.ASFUninitEngine(pVideoEngine);
Console.WriteLine("UninitEngine pVideoEngine Result:" + retCode);
//销毁引擎
retCode = ASFFunctions.ASFUninitEngine(pVideoRGBImageEngine);
Console.WriteLine("UninitEngine pVideoImageEngine Result:" + retCode);
//销毁引擎
retCode = ASFFunctions.ASFUninitEngine(pVideoIRImageEngine);
Console.WriteLine("UninitEngine pVideoIRImageEngine Result:" + retCode);
}
/// <summary>
/// 获取IR活体结果
/// </summary>
/// <param name="livenessInfo">IR活体结果</param>
/// <returns>返回0表示正常；返回负数请根据ErrorCodeUtil类注释查看；其他值请在官网-帮助中心查询</returns>
public int ASFGetLivenessScore_IR(out LivenessInfo livenessInfo)
{
livenessInfo = new LivenessInfo();
IntPtr pLiveness = MemoryUtil.Malloc(MemoryUtil.SizeOf <ASF_LivenessInfo>());
//调用SDK接口
int retCode = ASFFunctions.ASFGetLivenessScore_IR(pEngine, pLiveness);
if (retCode != 0)
{
MemoryUtil.Free(pLiveness);
return(retCode);
}
//转化结果
ASF_LivenessInfo asfLivenessInfo = MemoryUtil.PtrToStructure <ASF_LivenessInfo>(pLiveness);
livenessInfo.num = asfLivenessInfo.num;
if (asfLivenessInfo.num > 0)
{
livenessInfo.isLive = new int[asfLivenessInfo.num];
Marshal.Copy(asfLivenessInfo.isLive, livenessInfo.isLive, 0, asfLivenessInfo.num);
}
MemoryUtil.FreeArray(pLiveness);
return(retCode);
}
/// <summary>
/// 获取年龄结果
/// </summary>
/// <param name="pEngine">引擎handle</param>
/// <param name="ageInfo">out 年龄结果</param>
/// <returns>返回0表示正常；返回负数请根据ErrorCodeUtil类注释查看；其他值请在官网-帮助中心查询</returns>
public int ASFGetAge(out AgeInfo ageInfo)
{
ageInfo = new AgeInfo();
IntPtr pAgeInfo = MemoryUtil.Malloc(MemoryUtil.SizeOf <ASF_AgeInfo>());
//调用SDK接口
int retCode = ASFFunctions.ASFGetAge(pEngine, pAgeInfo);
if (retCode != 0)
{
MemoryUtil.Free(pAgeInfo);
return(retCode);
}
//转化结果
ASF_AgeInfo asfAgeInfo = MemoryUtil.PtrToStructure <ASF_AgeInfo>(pAgeInfo);
ageInfo.num = asfAgeInfo.num;
if (ageInfo.num > 0)
{
ageInfo.ageArray = new int[ageInfo.num];
Marshal.Copy(asfAgeInfo.ageArray, ageInfo.ageArray, 0, ageInfo.num);
}
MemoryUtil.FreeArray(pAgeInfo);
return(retCode);
}
/// <summary>
/// 获取性别结果
/// </summary>
/// <param name="pEngine">引擎handle</param>
/// <param name="genderInfo">out 性别结果</param>
/// <returns>返回0表示正常；返回负数请根据ErrorCodeUtil类注释查看；其他值请在官网-帮助中心查询</returns>
public int ASFGetGender(out GenderInfo genderInfo)
{
genderInfo = new GenderInfo();
IntPtr pGenderInfo = MemoryUtil.Malloc(MemoryUtil.SizeOf <ASF_GenderInfo>());
//调用SDK接口
int retCode = ASFFunctions.ASFGetGender(pEngine, pGenderInfo);
if (retCode != 0)
{
MemoryUtil.Free(pGenderInfo);
return(retCode);
}
//转化结果
ASF_GenderInfo asfGenderInfo = MemoryUtil.PtrToStructure <ASF_GenderInfo>(pGenderInfo);
genderInfo.num = asfGenderInfo.num;
if (genderInfo.num > 0)
{
genderInfo.genderArray = new int[genderInfo.num];
Marshal.Copy(asfGenderInfo.genderArray, genderInfo.genderArray, 0, genderInfo.num);
}
MemoryUtil.FreeArray(pGenderInfo);
return(retCode);
}
/// <summary>
/// 初始化引擎
/// </summary>
private void InitEngines()
{
//读取配置文件
AppSettingsReader reader = new AppSettingsReader();
string appId = (string)reader.GetValue("APP_ID", typeof(string));
string sdkKey64 = (string)reader.GetValue("SDKKEY64", typeof(string));
string sdkKey32 = (string)reader.GetValue("SDKKEY32", typeof(string));
var is64CPU = Environment.Is64BitProcess;
if (is64CPU)
{
if (string.IsNullOrWhiteSpace(appId) || string.IsNullOrWhiteSpace(sdkKey64))
{
chooseMultiImgBtn.Enabled = false;
matchBtn.Enabled = false;
btnClearFaceList.Enabled = false;
chooseImgBtn.Enabled = false;
MessageBox.Show("请在App.config配置文件中先配置APP_ID和SDKKEY64!");
return;
}
}
else
{
if (string.IsNullOrWhiteSpace(appId) || string.IsNullOrWhiteSpace(sdkKey32))
{
chooseMultiImgBtn.Enabled = false;
matchBtn.Enabled = false;
btnClearFaceList.Enabled = false;
chooseImgBtn.Enabled = false;
MessageBox.Show("请在App.config配置文件中先配置APP_ID和SDKKEY32!");
return;
}
}
//激活引擎 如出现错误，1.请先确认从官网下载的sdk库已放到对应的bin中，2.当前选择的CPU为x86或者x64
int retCode = 0;
try
{
retCode = ASFFunctions.ASFActivation(appId, is64CPU ? sdkKey64 : sdkKey32);
}
catch (Exception ex)
{
chooseMultiImgBtn.Enabled = false;
matchBtn.Enabled = false;
btnClearFaceList.Enabled = false;
chooseImgBtn.Enabled = false;
if (ex.Message.IndexOf("无法加载 DLL") > -1)
{
MessageBox.Show("请将sdk相关DLL放入bin对应的x86或x64下的文件夹中!");
}
else
{
MessageBox.Show("激活引擎失败!");
}
return;
}
Console.WriteLine("Activate Result:" + retCode);
//初始化引擎
uint detectMode = DetectionMode.ASF_DETECT_MODE_IMAGE;
//检测脸部的角度优先值
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
retCode = ASFFunctions.ASFInitEngine(detectMode, detectFaceOrientPriority, detectFaceScaleVal, detectFaceMaxNum, combinedMask, ref pEngine);
Console.WriteLine("InitEngine Result:" + retCode);
AppendText((retCode == 0) ? "引擎初始化成功!\n" : string.Format("引擎初始化失败!错误码为:{0}\n", retCode));
if (retCode != 0)
{
chooseMultiImgBtn.Enabled = false;
matchBtn.Enabled = false;
btnClearFaceList.Enabled = false;
chooseImgBtn.Enabled = false;
}
}
///<summary>
///图像质量检测
///推荐阈值0.35
///图像数据以结构体形式传入，对采用更高字节对齐方式的图像兼容性更好
///</summary>
/// <param name="hEngine">引擎handle</param>
/// <param name="imgData">图片数据</param>
/// <param name="detectedFaces">人脸位置信息</param>
/// <param name="imageQualityInfo">图像质量检测结果</param>
/// <param name="detectModel">预留字段，当前版本使用默认参数(ASF_DETECT_MODEL_RGB)即可</param>
/// <returns>调用结果</returns>
public int ASFImageQualityDetectEx(Image image, MultiFaceInfo multiFaceInfo, out ImageQualityInfo imageQualityInfo, ASF_ImagePixelFormat imageFormat = ASF_ImagePixelFormat.ASVL_PAF_RGB24_B8G8R8, ASF_DetectModel detectModel = ASF_DetectModel.ASF_DETECT_MODEL_RGB)
{
int retCode = -1;
imageQualityInfo = new ImageQualityInfo();
if (multiFaceInfo == null)
{
return(ErrorCodeUtil.MULPTIFACEINFO_IS_NULL);
}
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);
}
ASF_ImageData asfInfoData = CommonUtil.TransImageDataStructByImageInfo(imageInfo);
IntPtr pImageInfo = MemoryUtil.Malloc(MemoryUtil.SizeOf <ASF_ImageData>());
MemoryUtil.StructureToPtr(asfInfoData, pImageInfo);
ASF_ImageQualityInfo ImageQualityInfoStruct = new ASF_ImageQualityInfo();
IntPtr pImageQualityInfo = MemoryUtil.Malloc(MemoryUtil.SizeOf <ASF_ImageQualityInfo>());
//转化人脸信息
ASF_MultiFaceInfo multiFaceInfoStruct = new ASF_MultiFaceInfo();
IntPtr pMultiFaceInfo = MemoryUtil.Malloc(MemoryUtil.SizeOf <ASF_MultiFaceInfo>());
multiFaceInfoStruct.faceNum = multiFaceInfo.faceNum;
if (multiFaceInfo.faceNum > 0)
{
if (multiFaceInfo.faceID != null)
{
multiFaceInfoStruct.faceID = MemoryUtil.Malloc(multiFaceInfo.faceNum * MemoryUtil.SizeOf <int>());
Marshal.Copy(multiFaceInfo.faceID, 0, multiFaceInfoStruct.faceID, multiFaceInfo.faceNum);
}
multiFaceInfoStruct.faceOrients = MemoryUtil.Malloc(multiFaceInfo.faceNum * MemoryUtil.SizeOf <int>());
Marshal.Copy(multiFaceInfo.faceOrients, 0, multiFaceInfoStruct.faceOrients, multiFaceInfo.faceNum);
multiFaceInfoStruct.faceRects = MemoryUtil.Malloc(MemoryUtil.SizeOf <MRECT>() * multiFaceInfo.faceNum);
byte[] allByte = new byte[MemoryUtil.SizeOf <MRECT>() * multiFaceInfo.faceNum];
for (int i = 0; i < multiFaceInfo.faceNum; i++)
{
byte[] tempBytes = MemoryUtil.StructToBytes(multiFaceInfo.faceRects[i]);
tempBytes.CopyTo(allByte, MemoryUtil.SizeOf <MRECT>() * i);
}
Marshal.Copy(allByte, 0, multiFaceInfoStruct.faceRects, allByte.Length);
}
MemoryUtil.StructureToPtr(multiFaceInfoStruct, pMultiFaceInfo);
//调用SDK接口
retCode = ASFFunctions.ASFImageQualityDetectEx(pEngine, pImageInfo, pMultiFaceInfo, pImageQualityInfo);
if (retCode != 0)
{
MemoryUtil.FreeArray(imageInfo.imgData, pMultiFaceInfo, pImageInfo, pImageQualityInfo);
return(retCode);
}
ImageQualityInfoStruct = MemoryUtil.PtrToStructure <ASF_ImageQualityInfo>(pImageQualityInfo);
MemoryUtil.FreeArray(imageInfo.imgData, pMultiFaceInfo, pImageInfo, pImageQualityInfo);
//转化非托管内存到托管内存
imageQualityInfo.num = ImageQualityInfoStruct.num;
if (imageQualityInfo.num > 0)
{
imageQualityInfo.faceQualityValues = new float[imageQualityInfo.num];
Marshal.Copy(ImageQualityInfoStruct.faceQualityValues, imageQualityInfo.faceQualityValues, 0, imageQualityInfo.num);
}
return(retCode);
}
private void btnSelectImageToRecognize_Click(object sender, EventArgs e)
{
OpenFileDialog openFileDialog = new OpenFileDialog();
openFileDialog.Title = "Select";
openFileDialog.Filter = "Image File|*.bmp;*.jpg;*.jpeg;*.png";
//openFileDialog.Multiselect = true;
openFileDialog.FileName = string.Empty;
if (openFileDialog.ShowDialog() == DialogResult.OK)
{
var numStart = imagePathList.Count;
string fileName = openFileDialog.FileName;
if (!checkImage(fileName))
{
return;
}
image1Feature = IntPtr.Zero;
pictureBoxToRecognize.ImageLocation = fileName;
Image srcImage = ImageUtil.readFromFile(fileName);
ASF_SingleFaceInfo singleFaceInfo = new ASF_SingleFaceInfo();
//提取人脸特征
image1Feature = FaceUtil.ExtractFeature(pImageEngine, srcImage, out singleFaceInfo);
if (imagesFeatureList.Count == 0)
{
MessageBox.Show("请注册人脸!", "提示", MessageBoxButtons.OK, MessageBoxIcon.Error);
return;
}
if (image1Feature == IntPtr.Zero)
{
if (pictureBoxToRecognize.Image == null)
{
MessageBox.Show("请选择识别图!", "提示", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
else
{
MessageBox.Show("比对失败，识别图未提取到特征值!", "提示", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
return;
}
for (int i = 0; i < imagesFeatureDictionary.Count; i++)
{
IntPtr feature = imagesFeatureDictionary.ElementAt(i).Key;
float similarity = 0f;
int ret = ASFFunctions.ASFFaceFeatureCompare(pImageEngine, image1Feature, feature, ref similarity);
//增加异常值处理
if (similarity.ToString().IndexOf("E") > -1)
{
similarity = 0f;
}
if (similarity > threshold)
{
string name = imagesFeatureDictionary.ElementAt(i).Value;
AppendText("对比结果：" + name + " 可信度：" + similarity + "\r\n");
return;
}
}
AppendText("无结果\r\n");
}
}
/// <summary>
/// 激活接口
/// </summary>
/// <param name="appId">appId</param>
/// <param name="appKey">appKey</param>
/// <returns>返回0或90114表示正常；其他值请在官网-帮助中心查询</returns>
public int ASFOnlineActivation(string appId, string appKey)
{
return(ASFFunctions.ASFOnlineActivation(appId, appKey));
}
/// <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);
}
/// <summary>
/// 初始化引擎
/// </summary>
private void InitEngines()
{
//读取配置文件
AppSettingsReader reader = new AppSettingsReader();
string appId = (string)reader.GetValue("APP_ID", typeof(string));
string sdkKey64 = (string)reader.GetValue("SDKKEY64", typeof(string));
string sdkKey32 = (string)reader.GetValue("SDKKEY32", typeof(string));
rgbCameraIndex = (int)reader.GetValue("RGB_CAMERA_INDEX", typeof(int));
irCameraIndex = (int)reader.GetValue("IR_CAMERA_INDEX", typeof(int));
//判断CPU位数
var is64CPU = Environment.Is64BitProcess;
if (string.IsNullOrWhiteSpace(appId) || string.IsNullOrWhiteSpace(is64CPU ? sdkKey64 : sdkKey32))
{
//禁用相关功能按钮
ControlsEnable(false, chooseMultiImgBtn, matchBtn, btnClearFaceList, chooseImgBtn);
MessageBox.Show(string.Format("请在App.config配置文件中先配置APP_ID和SDKKEY{0}!", is64CPU ? "64" : "32"));
return;
}
//在线激活引擎 如出现错误，1.请先确认从官网下载的sdk库已放到对应的bin中，2.当前选择的CPU为x86或者x64
int retCode = 0;
try
{
retCode = ASFFunctions.ASFActivation(appId, is64CPU ? sdkKey64 : sdkKey32);
}
catch (Exception ex)
{
//禁用相关功能按钮
ControlsEnable(false, chooseMultiImgBtn, matchBtn, btnClearFaceList, chooseImgBtn);
if (ex.Message.Contains("无法加载 DLL"))
{
MessageBox.Show("请将sdk相关DLL放入bin对应的x86或x64下的文件夹中!");
}
else
{
MessageBox.Show("激活引擎失败!");
}
return;
}
Console.WriteLine("Activate Result:" + retCode);
//初始化引擎
uint detectMode = DetectionMode.ASF_DETECT_MODE_IMAGE;
//Video模式下检测脸部的角度优先值
int videoDetectFaceOrientPriority = ASF_OrientPriority.ASF_OP_0_HIGHER_EXT;
//Image模式下检测脸部的角度优先值
int imageDetectFaceOrientPriority = ASF_OrientPriority.ASF_OP_0_ONLY;
//人脸在图片中所占比例，如果需要调整检测人脸尺寸请修改此值，有效数值为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
retCode = ASFFunctions.ASFInitEngine(detectMode, imageDetectFaceOrientPriority, detectFaceScaleVal, detectFaceMaxNum, combinedMask, ref pImageEngine);
Console.WriteLine("InitEngine Result:" + retCode);
AppendText((retCode == 0) ? "引擎初始化成功!\n" : string.Format("引擎初始化失败!错误码为:{0}\n", retCode));
if (retCode != 0)
{
//禁用相关功能按钮
ControlsEnable(false, chooseMultiImgBtn, matchBtn, btnClearFaceList, chooseImgBtn);
}
//初始化视频模式下人脸检测引擎
uint detectModeVideo = DetectionMode.ASF_DETECT_MODE_VIDEO;
int combinedMaskVideo = FaceEngineMask.ASF_FACE_DETECT | FaceEngineMask.ASF_FACERECOGNITION;
retCode = ASFFunctions.ASFInitEngine(detectModeVideo, videoDetectFaceOrientPriority, detectFaceScaleVal, detectFaceMaxNum, combinedMaskVideo, ref pVideoEngine);
//RGB视频专用FR引擎
detectFaceMaxNum = 1;
combinedMask = FaceEngineMask.ASF_FACE_DETECT | FaceEngineMask.ASF_FACERECOGNITION | FaceEngineMask.ASF_LIVENESS;
retCode = ASFFunctions.ASFInitEngine(detectMode, imageDetectFaceOrientPriority, detectFaceScaleVal, detectFaceMaxNum, combinedMask, ref pVideoRGBImageEngine);
//IR视频专用FR引擎
combinedMask = FaceEngineMask.ASF_FACE_DETECT | FaceEngineMask.ASF_FACERECOGNITION | FaceEngineMask.ASF_IR_LIVENESS;
retCode = ASFFunctions.ASFInitEngine(detectMode, imageDetectFaceOrientPriority, detectFaceScaleVal, detectFaceMaxNum, combinedMask, ref pVideoIRImageEngine);
Console.WriteLine("InitVideoEngine Result:" + retCode);
initVideo();
}
public event setResultValue setFormResultValue; //第二步：声明一个委托类型的事件
/// <summary>
/// 激活并初始化引擎
/// </summary>
private void ActiveAndInitEngines()
{
//读取配置文件中的 APP_ID 和 SDKKEY
AppSettingsReader reader = new AppSettingsReader();
string appId = (string)reader.GetValue("APP_ID", typeof(string));
string sdkKey = (string)reader.GetValue("SDKKEY", typeof(string));
int retCode = 0;
//激活引擎
try
{
retCode = ASFFunctions.ASFActivation(appId, sdkKey);
}
catch (Exception ex)
{
//异常处理
return;
}
#region 图片引擎pImageEngine初始化
//初始化引擎
uint detectMode = DetectionMode.ASF_DETECT_MODE_IMAGE;
//检测脸部的角度优先值
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
retCode = ASFFunctions.ASFInitEngine(detectMode, detectFaceOrientPriority, detectFaceScaleVal, detectFaceMaxNum, combinedMask, ref pImageEngine);
if (retCode == 0)
{
lbl_msg.Text = ("图片引擎初始化成功!\n");
}
else
{
lbl_msg.Text = (string.Format("图片引擎初始化失败!错误码为:{0}\n", retCode));
}
#endregion
#region 初始化视频模式下人脸检测引擎
uint detectModeVideo = DetectionMode.ASF_DETECT_MODE_VIDEO;
int combinedMaskVideo = FaceEngineMask.ASF_FACE_DETECT | FaceEngineMask.ASF_FACERECOGNITION;
retCode = ASFFunctions.ASFInitEngine(detectModeVideo, detectFaceOrientPriority, detectFaceScaleVal, detectFaceMaxNum, combinedMaskVideo, ref pVideoEngine);
if (retCode == 0)
{
lbl_msg.Text = ("视频引擎初始化成功!\n");
}
else
{
lbl_msg.Text = (string.Format("视频引擎初始化失败!错误码为:{0}\n", retCode));
}
#endregion
#region 视频专用FR引擎
detectFaceMaxNum = 1;
combinedMask = FaceEngineMask.ASF_FACERECOGNITION | FaceEngineMask.ASF_FACE3DANGLE | FaceEngineMask.ASF_LIVENESS;
retCode = ASFFunctions.ASFInitEngine(detectMode, detectFaceOrientPriority, detectFaceScaleVal, detectFaceMaxNum, combinedMask, ref pVideoImageEngine);
Console.WriteLine("InitVideoEngine Result:" + retCode);
if (retCode == 0)
{
lbl_msg.Text = ("视频专用FR引擎初始化成功!\n");
}
else
{
lbl_msg.Text = (string.Format("视频专业FR引擎初始化失败!错误码为:{0}\n", retCode));
}
// 摄像头初始化
filterInfoCollection = new FilterInfoCollection(FilterCategory.VideoInputDevice);
lbl_msg.Text = (string.Format("摄像头初始化完成...\n"));
#endregion
}
