/// <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)
{
IntPtr pMultiFaceInfo = MemoryUtil.Malloc(MemoryUtil.SizeOf <ASF_MultiFaceInfo>());
MemoryUtil.StructureToPtr(multiFaceInfo, pMultiFaceInfo);
if (multiFaceInfo.faceNum == 0)
{
return(new ASF_AgeInfo());
}
//人脸信息处理
int retCode = ASFFunctions.ASFProcess(pEngine, imageInfo.width, imageInfo.height, imageInfo.format, imageInfo.imgData, pMultiFaceInfo, FaceEngineMask.ASF_AGE);
//获取年龄信息
IntPtr pAgeInfo = MemoryUtil.Malloc(MemoryUtil.SizeOf <ASF_AgeInfo>());
retCode = ASFFunctions.ASFGetAge(pEngine, pAgeInfo);
Console.WriteLine("Get Age Result:" + retCode);
ASF_AgeInfo ageInfo = MemoryUtil.PtrToStructure <ASF_AgeInfo>(pAgeInfo);
//释放内存
MemoryUtil.Free(pMultiFaceInfo);
MemoryUtil.Free(pAgeInfo);
return(ageInfo);
}
/// <summary>
/// 获取多个人脸检测结果中面积最大的人脸
/// </summary>
/// <param name="multiFaceInfo">人脸检测结果</param>
/// <returns>面积最大的人脸信息</returns>
public static ASF_SingleFaceInfo GetMaxFace(ASF_MultiFaceInfo multiFaceInfo)
{
ASF_SingleFaceInfo singleFaceInfo = new ASF_SingleFaceInfo();
singleFaceInfo.faceRect = new MRECT();
singleFaceInfo.faceOrient = 1;
int maxArea = 0;
int index = -1;
for (int i = 0; i < multiFaceInfo.faceNum; i++)
{
MRECT rect = MemoryUtil.PtrToStructure <MRECT>(multiFaceInfo.faceRects + MemoryUtil.SizeOf <MRECT>() * i);
int area = (rect.right - rect.left) * (rect.bottom - rect.top);
if (maxArea <= area)
{
maxArea = area;
index = i;
}
}
if (index != -1)
{
singleFaceInfo.faceRect = MemoryUtil.PtrToStructure <MRECT>(multiFaceInfo.faceRects + MemoryUtil.SizeOf <MRECT>() * index);
singleFaceInfo.faceOrient = MemoryUtil.PtrToStructure <int>(multiFaceInfo.faceOrients + MemoryUtil.SizeOf <int>() * index);
}
return(singleFaceInfo);
}
/// <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, out int retCode)
{
retCode = -1;
IntPtr pMultiFaceInfo = MemoryUtil.Malloc(MemoryUtil.SizeOf <ASF_MultiFaceInfo>());
MemoryUtil.StructureToPtr(multiFaceInfo, pMultiFaceInfo);
if (multiFaceInfo.faceNum == 0)
{
return(new ASF_GenderInfo());
}
//人脸信息处理
retCode = ASFFunctions.ASFProcess(pEngine, imageInfo.width, imageInfo.height, imageInfo.format, imageInfo.imgData, pMultiFaceInfo, FaceEngineMask.ASF_GENDER);
if (retCode == 0)
{
//获取性别信息
IntPtr pGenderInfo = MemoryUtil.Malloc(MemoryUtil.SizeOf <ASF_GenderInfo>());
retCode = ASFFunctions.ASFGetGender(pEngine, pGenderInfo);
Console.WriteLine("Get Gender Result:" + retCode);
ASF_GenderInfo genderInfo = MemoryUtil.PtrToStructure <ASF_GenderInfo>(pGenderInfo);
//释放内存
MemoryUtil.Free(pMultiFaceInfo);
MemoryUtil.Free(pGenderInfo);
return(genderInfo);
}
else
{
return(new ASF_GenderInfo());
}
}
/// <summary>
/// 人脸3D角度检测
/// </summary>
/// <param name="pEngine">引擎Handle</param>
/// <param name="imageInfo">图像数据</param>
/// <param name="multiFaceInfo">人脸检测结果</param>
/// <returns>保存人脸3D角度检测结果结构体</returns>
public static ASF_Face3DAngle Face3DAngleDetection(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;
return(new ASF_Face3DAngle());
}
//人脸信息处理
retCode = ASFFunctions.ASFProcess(pEngine, imageInfo.width, imageInfo.height, imageInfo.format, imageInfo.imgData, pMultiFaceInfo, FaceEngineMask.ASF_FACE3DANGLE);
if (retCode == 0)
{
//获取人脸3D角度
IntPtr pFace3DAngleInfo = MemoryUtil.Malloc(MemoryUtil.SizeOf <ASF_Face3DAngle>());
retCode = ASFFunctions.ASFGetFace3DAngle(pEngine, pFace3DAngleInfo);
Console.WriteLine("Get Face3D Angle Result:" + retCode);
ASF_Face3DAngle face3DAngle = MemoryUtil.PtrToStructure <ASF_Face3DAngle>(pFace3DAngleInfo);
//释放内存
MemoryUtil.Free(pMultiFaceInfo);
MemoryUtil.Free(pFace3DAngleInfo);
return(face3DAngle);
}
else
{
return(new ASF_Face3DAngle());
}
}
/// <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);// 返回人脸特征
}
/// <summary>
/// 获取图片信息
/// </summary>
/// <param name="image">图片</param>
/// <returns>成功或失败</returns>
public static ImageInfo ReadBMP(Image image)
{
ImageInfo imageInfo = new ImageInfo();
//将Image转换为Format24bppRgb格式的BMP
Bitmap bm = new Bitmap(image);
BitmapData data = bm.LockBits(new Rectangle(0, 0, bm.Width, bm.Height), ImageLockMode.ReadOnly, PixelFormat.Format24bppRgb);
try
{
//位图中第一个像素数据的地址。它也可以看成是位图中的第一个扫描行
IntPtr ptr = data.Scan0;
//定义数组长度
int soureBitArrayLength = data.Height * Math.Abs(data.Stride);
byte[] sourceBitArray = new byte[soureBitArrayLength];
//将bitmap中的内容拷贝到ptr_bgr数组中
MemoryUtil.Copy(ptr, sourceBitArray, 0, soureBitArrayLength);
//填充引用对象字段值
imageInfo.width = data.Width;
imageInfo.height = data.Height;
imageInfo.format = ASF_ImagePixelFormat.ASVL_PAF_RGB24_B8G8R8;
//获取去除对齐位后度图像数据
int line = imageInfo.width * 3;
int pitch = Math.Abs(data.Stride);
int bgr_len = line * imageInfo.height;
byte[] destBitArray = new byte[bgr_len];
/*
* 图片像素数据在内存中是按行存储，一般图像库都会有一个内存对齐，在每行像素的末尾位置
* 每行的对齐位会使每行多出一个像素空间（三通道如RGB会多出3个字节，四通道RGBA会多出4个字节）
* 以下循环目的是去除每行末尾的对齐位，将有效的像素拷贝到新的数组
*/
for (int i = 0; i < imageInfo.height; ++i)
{
Array.Copy(sourceBitArray, i * pitch, destBitArray, i * line, line);
}
imageInfo.imgData = MemoryUtil.Malloc(destBitArray.Length);
MemoryUtil.Copy(destBitArray, 0, imageInfo.imgData, destBitArray.Length);
return(imageInfo);
}
catch (Exception e)
{
Console.WriteLine(e.Message);
}
finally
{
bm.UnlockBits(data);
}
return(null);
}
/// <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 = MemoryUtil.Malloc(MemoryUtil.SizeOf <ASF_MultiFaceInfo>());
int retCode = ASFFunctions.ASFDetectFaces(pEngine, imageInfo.width, imageInfo.height, imageInfo.format, imageInfo.imgData, pMultiFaceInfo);
multiFaceInfo = MemoryUtil.PtrToStructure <ASF_MultiFaceInfo>(pMultiFaceInfo);
return(multiFaceInfo);
}
/// <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="pEngine">引擎Handle</param>
/// <param name="image">图像</param>
/// <returns>保存人脸特征结构体指针</returns>
public static IntPtr ExtractFeature(IntPtr pEngine, Image image, out ASF_SingleFaceInfo singleFaceInfo)
{
image = ImageUtil.ScaleImage(image, image.Width, image.Height);
ImageInfo imageInfo = ImageUtil.ReadBMP(image);
ASF_MultiFaceInfo multiFaceInfo = DetectFace(pEngine, imageInfo);
singleFaceInfo = new ASF_SingleFaceInfo();
IntPtr pFaceModel = ExtractFeature(pEngine, imageInfo, multiFaceInfo, out singleFaceInfo);
MemoryUtil.Free(imageInfo.imgData);
return(pFaceModel);
}
/// <summary>
/// 单人脸性别检测
/// </summary>
/// <param name="pEngine">引擎Handle</param>
/// <param name="image">图片</param>
/// <param name="singleFaceInfo">单人脸信息</param>
/// <returns>性别估计结果</returns>
public static ASF_GenderInfo GenderEstimation(IntPtr pEngine, Image image, ASF_SingleFaceInfo singleFaceInfo)
{
ImageInfo imageInfo = ImageUtil.ReadBMP(image);
ASF_MultiFaceInfo multiFaceInfo = new ASF_MultiFaceInfo();
multiFaceInfo.faceRects = MemoryUtil.Malloc(MemoryUtil.SizeOf <MRECT>());
MemoryUtil.StructureToPtr <MRECT>(singleFaceInfo.faceRect, multiFaceInfo.faceRects);
multiFaceInfo.faceOrients = MemoryUtil.Malloc(MemoryUtil.SizeOf <int>());
MemoryUtil.StructureToPtr <int>(singleFaceInfo.faceOrient, multiFaceInfo.faceOrients);
multiFaceInfo.faceNum = 1;
ASF_GenderInfo genderInfo = GenderEstimation(pEngine, imageInfo, multiFaceInfo);
MemoryUtil.Free(imageInfo.imgData);
return(genderInfo);
}
public static ASF_MultiFaceInfo DetectFace(IntPtr pEngine, Image image)
{
lock (locks)
{
ASF_MultiFaceInfo multiFaceInfo = new ASF_MultiFaceInfo();
if (image != null)
{
image = ImageUtil.ScaleImage(image, image.Width, image.Height);
ImageInfo imageInfo = ImageUtil.ReadBMP(image);
multiFaceInfo = DetectFace(pEngine, imageInfo);
MemoryUtil.Free(imageInfo.imgData);
return(multiFaceInfo);
}
else
{
return(multiFaceInfo);
}
}
}