/// <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 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);
}
//IplImageから特徴量作成
private bool FeatureFromIpl()
{
foreach (IplImage ipl_image in this.FaceIplList)
{
FaceFeature.MakeFeatureFromIpl(ipl_image, 0);
}
return(true);
}
/// <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="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);
}
private static void UpdateUVs(Config[] configs)
{
foreach (var config in configs)
{
var armorMeshFolderPath = "Assets/Character_Editor/Meshes/" + config.folderName + "/Armor/";
var weaponMeshFolderPath = "Assets/Character_Editor/Meshes/" + config.folderName + "/Weapon/";
var meshPaths = new Dictionary <int, string>()
{
{ Arm.GetMerheOrder(MeshType.ArmRight), armorMeshFolderPath + "Armor_Arm/ArmRight" },
{ Arm.GetMerheOrder(MeshType.ArmLeft), armorMeshFolderPath + "Armor_Arm/ArmLeft" },
{ Belt.GetMerheOrder(), armorMeshFolderPath + "Armor_Belt" },
{ BeltAdd.GetMerheOrder(), armorMeshFolderPath + "Armor_BeltAdd" },
{ Hair.GetMerheOrder(), armorMeshFolderPath + "Armor_Hair" },
{ Helm.GetMerheOrder(), armorMeshFolderPath + "Armor_Helm" },
{ Beard.GetMerheOrder(), armorMeshFolderPath + "Armor_Jaw" },
{ FaceFeature.GetMerheOrder(), armorMeshFolderPath + "Armor_Feature" },
{ Leg.GetMerheOrder(MeshType.LegRight), armorMeshFolderPath + "Armor_Leg/LegRight" },
{ Leg.GetMerheOrder(MeshType.LegLeft), armorMeshFolderPath + "Armor_Leg/LegLeft" },
{ Shoulder.GetMerheOrder(MeshType.ShoulderRight), armorMeshFolderPath + "Armor_Shoulder/ShoulderRight" },
{ Shoulder.GetMerheOrder(MeshType.ShoulderLeft), armorMeshFolderPath + "Armor_Shoulder/ShoulderLeft" },
{ Torso.GetMerheOrder(), armorMeshFolderPath + "Armor_Torso" },
{ TorsoAdd.GetMerheOrder(), armorMeshFolderPath + "Armor_TorsoAdd" },
{ Hand.GetMerheOrder(MeshType.HandRight), weaponMeshFolderPath + "HandRight" },
{ Hand.GetMerheOrder(MeshType.HandLeft), weaponMeshFolderPath + "HandLeft" },
};
var myList = meshPaths.ToList();
myList.Sort((pair1, pair2) => pair1.Key.CompareTo(pair2.Key));
int atlasSize = 4;
float uvsStep = 1f / atlasSize;
for (int itemNum = 0; itemNum < myList.Count; itemNum++)
{
if (!AssetDatabase.IsValidFolder(myList[itemNum].Value))
{
continue;
}
var meshGUIDs = AssetDatabase.FindAssets("t:GameObject", new string[] { myList[itemNum].Value });
for (int meshNum = 0; meshNum < meshGUIDs.Length; meshNum++)
{
var tempMesh = AssetDatabase.LoadAssetAtPath <GameObject>(AssetDatabase.GUIDToAssetPath(meshGUIDs[meshNum]));
// Mesh tempMesh = UnityEngine.Object.Instantiate(meshObject);
//Update LOD parts for each armor item
var armorsParts = tempMesh.GetComponentsInChildren <MeshFilter>();
for (var armLOD = 0; armLOD < armorsParts.Length; armLOD++)
{
if (armorsParts[armLOD] != null)
{
var mTempMesh = (Mesh)GameObject.Instantiate(armorsParts[armLOD].sharedMesh);
//Update UVS for new atlas
Vector2[] uvs = mTempMesh.uv;
for (int i = 0; i < uvs.Length; i++)
{
uvs[i] = new Vector2(uvs[i].x / atlasSize + uvsStep * (itemNum % atlasSize),
uvs[i].y / atlasSize + uvsStep * (atlasSize - 1 - (itemNum / atlasSize)));
}
mTempMesh.uv = uvs;
//assigne the selected LOD Mesh with new UV's to the new mesh to be exported
if (!Directory.Exists(myList[itemNum].Value + "/Meshes/"))
{
Directory.CreateDirectory(myList[itemNum].Value + "/Meshes/");
}
CreateOrReplaceAsset <Mesh>(mTempMesh,
myList[itemNum].Value + "/Meshes/" + armorsParts[armLOD].sharedMesh.name + "_New.asset");
AssetDatabase.SaveAssets();
}
}
}
}
var prefabsPath = "Assets/Character_Editor/Prefabs/" + config.folderName;
var prefabGUIDs = AssetDatabase.FindAssets("t:Prefab", new string[] { prefabsPath });
for (int prefNum = 0; prefNum < prefabGUIDs.Length; prefNum++)
{
var pPath = AssetDatabase.GUIDToAssetPath(prefabGUIDs[prefNum]);
if (pPath.Contains("/Model/"))
{
var originalPrefab = AssetDatabase.LoadAssetAtPath <GameObject>(pPath);
var originalPrefabInstance = GameObject.Instantiate(originalPrefab);
originalPrefabInstance.name = originalPrefab.name;
foreach (var filter in originalPrefabInstance.GetComponentsInChildren <MeshFilter>())
{
var lodMeshPath = AssetDatabase.GetAssetPath(filter.sharedMesh);
var index = lodMeshPath.LastIndexOf("/");
if (index != -1)
{
lodMeshPath = lodMeshPath.Substring(0, index) + "/Meshes/" + filter.sharedMesh.name + "_New.asset";
var changedMesh = AssetDatabase.LoadAssetAtPath <Mesh>(lodMeshPath);
filter.mesh = changedMesh;
var newDirPath = pPath.Substring(0, pPath.IndexOf("Model/")) + "StaticModel/";
var fullDirPath = Application.dataPath.Substring(0, Application.dataPath.Length - 6) + newDirPath;
if (Directory.Exists(fullDirPath))
{
Directory.Delete(fullDirPath, true);
}
Directory.CreateDirectory(fullDirPath);
Object prefab = PrefabUtility.CreateEmptyPrefab(newDirPath + originalPrefabInstance.name + ".prefab");
PrefabUtility.ReplacePrefab(originalPrefabInstance, prefab, ReplacePrefabOptions.ConnectToPrefab);
AssetDatabase.SaveAssets();
}
}
GameObject.DestroyImmediate(originalPrefabInstance);
}
}
}
}
public FaceFeat()
{
t = entTypes.Face;
addDef();
f = smf.FaceFeatures.Add(def);
}
//リストから学習を行う
private void buttonTrainFile_Click(object sender, EventArgs e)
{
//ファイルを選択
OpenFileDialog ofd = new OpenFileDialog();
//はじめのファイル名を指定する
//はじめに「ファイル名」で表示される文字列を指定する
ofd.FileName = "";
//はじめに表示されるフォルダを指定する
//指定しない（空の文字列）の時は、現在のディレクトリが表示される
ofd.InitialDirectory = @"";
//[ファイルの種類]に表示される選択肢を指定する
//指定しないとすべてのファイルが表示される
ofd.Filter =
"学習用ファイルリスト|*.txt";
//[ファイルの種類]ではじめに
//「すべてのファイル」が選択されているようにする
ofd.FilterIndex = 2;
//タイトルを設定する
ofd.Title = "判定する画像ファイルを選択して下さい";
ofd.RestoreDirectory = true;
ofd.CheckFileExists = true;
ofd.CheckPathExists = true;
//ダイアログを表示する
if (ofd.ShowDialog() == DialogResult.OK)
{
}
//出力用のフォルダを設定する
InputFileList = ofd.FileName;
OutPutFolda = @"D:\myprog\github\svm_out"; // 仮設定
//学習するファイルを読み込む
ReadFileList();
FaceFeature face_feature = new FaceFeature();
face_feature.FaceList = this.FaceList;
face_feature.IDList = this.IDList;
face_feature.OutPutFolda = this.OutPutFolda;
//学習実行
SVMManage svm_manage = new SVMManage();
//特徴点を出す
face_feature.DetectFacePoint();
if (APPSetting.NORMALIZE_USE)
{
//特徴点を正規化する
face_feature.NormalizeFeature();
svm_manage.TrainingExec(face_feature.ScaleFeatuerValueList);
}
else
{
svm_manage.TrainingExec(face_feature.FeatuerValueList);
}
//エラー表示
MessageBox.Show("lisvm_model.xmlを作成しました",
"完了",
MessageBoxButtons.OK
);
}
public override string GetFolderPath()
{
return(FaceFeature.GetFolderPath(CharacterRace));
}
