private LocateResult Detect(ImageData offInput, IntPtr pImageData, out ErrorCode ret)
{
var retCode =
TrackingWrapper.AFT_FSDK_FaceFeatureDetect(Engine, ref offInput, out var pDetectResult);
ret = (ErrorCode)retCode;
if (ret == ErrorCode.Ok)
{
var nativeResult = pDetectResult.ToStruct <AFT_FSDK_FACERES>();
var resolveResult = new LocateResult
{
FaceCount = nativeResult.nFace,
FacesOrient = Enumerable.Repeat((OrientCode)nativeResult.lfaceOrient, nativeResult.nFace)
.ToArray()
};
resolveResult.Faces = nativeResult.rcFace.ToStructArray <FaceRect>(resolveResult.FaceCount);
resolveResult.OffInput = offInput;
resolveResult.ImageDataPtr = pImageData;
return(resolveResult);
}
return(default(LocateResult));
}
/// <summary>
/// 根据人脸识别结果返回特征数据数组
/// </summary>
/// <param name="faces">人脸识别结果</param>
/// <param name="autoDispose">是否自动释放人脸识别结果</param>
/// <exception cref="FaceNotFoundException">如果识别结果中未包含人脸，则抛出此异常</exception>
/// <returns>脸部特征数据数组</returns>
public Feature[] ExtractFeatures(LocateResult faces, bool autoDispose = true)
{
if (faces.HasFace)
{
var features = new List <Feature>();
for (var faceIndex = 0; faceIndex < faces.FaceCount; faceIndex++)
{
var faceLocation = faces.Faces[faceIndex];
var orient = faces.FacesOrient[faceIndex];
var feature = ExtractFeature(faces.OffInput, faceLocation, orient);
if (feature != null)
{
features.Add(feature);
}
}
if (autoDispose)
{
faces.Dispose();
}
return(features.ToArray());
}
if (autoDispose)
{
faces.Dispose();
}
throw new FaceNotFoundException();
}
private void AnalyseFinish(IAsyncResult ar)
{
var func = ar.AsyncState as Func <LocateResult>;
try
{
LocateResult result = func.EndInvoke(ar);
this.UpdateStatusFormat("Successfully located {0} of {1} file(s). Matched {2} of {3} file(s) on disk.",
result.LocatedCount,
result.LocatedCount + result.UnlocatedCount,
result.TorrentFileLinks.Where(c => c.State == LinkState.Located)
.Where(c => c.LinkedFsFileInfo != null)
.Select(c => c.LinkedFsFileInfo.FilePath)
.Distinct()
.Count(), this._fileSystemFileInfos.Count);
this._locateResult = result;
this._unlocatedCount = result.UnlocatedCount;
EntityModel.Update(this._fileSystemEntityModel[0],
result.TorrentFileLinks.Where(c => c.State == LinkState.Located).Select(c => c.LinkedFsFileInfo));
this.RaisePropertyChanged(() => this.FileSystemEntityModel);
this.Set(() => this.TorrentEntityModel, ref this._torrentEntityModel,
new[] { EntityModel.Load(this._torrent.Name, result) });
}
catch (Exception ex)
{
MessageBox.Show(ex.ToString());
}
}
/// <summary>
/// 通用的评估函数
/// </summary>
/// <param name="locate"></param>
/// <param name="estimation"></param>
/// <param name="autoDispose"></param>
/// <returns>包含额外信息的位置</returns>
internal LocateResult Estimation(LocateResult locate, Action <ExtraFaceInput> estimation, bool autoDispose = true)
{
if (!locate.HasFace)
{
return(locate);
}
var faceInput = new ExtraFaceInput
{
lFaceNumber = locate.FaceCount,
pFaceRectArray = IntPtrExtensions.StructArrayToPtr(locate.Faces),
pFaceOrientArray =
IntPtrExtensions.StructArrayToPtr(locate.FacesOrient.Select(code => (int)code).ToArray())
};
try
{
estimation(faceInput);
return(locate);
}
finally
{
if (autoDispose)
{
locate.Dispose();
}
Marshal.FreeHGlobal(faceInput.pFaceRectArray);
Marshal.FreeHGlobal(faceInput.pFaceOrientArray);
}
}
/// <summary>
/// 进行检测
/// </summary>
/// <param name="imageData">图像数据</param>
/// <param name="width">图像宽度</param>
/// <param name="height">图像高度</param>
/// <param name="result">识别结果</param>
/// <returns>成功返回 MOK，否则返回失败 code</returns>
public override ErrorCode Detect(byte[] imageData, int width, int height, out LocateResult result)
{
var ret = ErrorCode.Ok;
result = CommonOperation.OffInputOperation(imageData, width, height,
(offInput, pImageData) => Detect(offInput, pImageData, out ret));
return(ret);
}
/// <summary>
/// 进行检测
/// </summary>
/// <param name="image">待检测的图像数据</param>
/// <param name="result">检测结果</param>
/// <returns>成功返回 MOK，否则返回失败 code</returns>
public override ErrorCode Detect(Bitmap image, out LocateResult result, LocateOperation operation = LocateOperation.None)
{
var ret = ErrorCode.Ok;
result = CommonOperation.OffInputOperation(image,
(offInput, pImageData) => Detect(offInput, pImageData, out ret, operation));
return(ret);
}
/// <summary>
/// 进行检测
/// </summary>
/// <param name="imageData">图像数据</param>
/// <param name="width">图像宽度</param>
/// <param name="height">图像高度</param>
/// <param name="result">识别结果</param>
/// <param name="pixelSize">像素大小</param>
/// <param name="operation">人脸检测额外操作</param>
/// <returns>成功返回 MOK，否则返回失败 code</returns>
public override ErrorCode Detect(byte[] imageData, int width, int height, out LocateResult result,
int pixelSize = 3, LocateOperation operation = LocateOperation.None)
{
var ret = ErrorCode.Ok;
result = CommonOperation.OffInputOperation(imageData, width, height,
(offInput, pImageData) => Detect(offInput, pImageData, out ret, operation), pixelSize);
return(ret);
}
private LocateResult Locate()
{
this._fileSystemFileInfos = FileSystemFileSearcher.SearchFolder(this._sourceFolder);
var locater = new TorrentFileLocater(this._torrent, this._fileSystemFileInfos,
() => this.Set(() => this.CurPorcess, ref this._curProcess, this._curProcess + 1));
this.Set(() => this.MaxProcess, ref this._maxProcess, this._torrent.Files.Length);
this.Set(() => this.CurPorcess, ref this._curProcess, 0);
LocateResult result = locater.Locate();
return(result);
}
public static EntityModel Load(string title, LocateResult result)
{
var root = new FolderModel(title);
foreach (TorrentFileLink file in result.TorrentFileLinks)
{
var folder = FindOrCreateFolder(root, file.TorrentFile.Path);
var fileModel = new FileModel(file.TorrentFile);
fileModel.Located = file.State == LinkState.Located;
folder.Entities.Add(fileModel);
}
return(root);
}
/// <summary>
/// 静态图片的性别评估
/// </summary>
/// <param name="locate">已经识别的人脸位置信息（图片数据未释放，如果释放，将出现异常）</param>
/// <param name="autoDispose">是否自动释放检测的人脸资源</param>
/// <returns>包含性别的位置信息</returns>
public override LocateResult StaticEstimation(LocateResult locate, bool autoDispose = true)
{
return(Estimation(locate, input =>
{
var code = (ErrorCode)GenderWrapper.ASGE_FSDK_GenderEstimation_StaticImage(Engine, ref locate.OffInput,
ref input,
out var result);
if (code != ErrorCode.Ok)
{
throw new FaceException(code);
}
locate.Genders = result.pResult.ToStructArray <int>(result.lFaceNumber);
}, autoDispose));
}
/// <summary>
/// 序列帧图片的年龄评估
/// </summary>
/// <param name="locate">已经识别的人脸位置信息（图片数据未释放，如果释放，将出现异常）</param>
/// <param name="autoDispose">是否自动释放检测的人脸资源</param>
/// <returns>包含年龄的位置信息</returns>
public override LocateResult PreviewEstimation(LocateResult locate, bool autoDispose = true)
{
return(Estimation(locate, input =>
{
var code = (ErrorCode)AgeWrapper.ASAE_FSDK_AgeEstimation_Preview(Engine, ref locate.OffInput,
ref input,
out var result);
if (code != ErrorCode.Ok)
{
throw new FaceException(code);
}
locate.Ages = result.pResult.ToStructArray <int>(result.lFaceNumber);
}, autoDispose));
}
/// <summary>
/// 根据locate数据，从图片中提供人脸特征，先执行 FaceLocateResult() 获得图片的人脸特征
/// </summary>
/// <param name="bitmap">图片</param>
/// <param name="locate">图片中的人脸数据</param>
/// <returns>返回一个人脸特征，适用于图片中只有一个人脸的情况</returns>
public Feature GetFaceFeature(Bitmap bitmap, LocateResult locate)
{
Feature feature = null;
var result = _detection.Detect(bitmap, out var locateResult);
if (result == Stepon.FaceRecognization.Common.ErrorCode.Ok && locateResult.HasFace)
{
using (_recognize = new FaceRecognize(AppConfigurations.AppId, AppConfigurations.FrKey))
{
feature = _recognize.ExtractFeature(locate.OffInput, locate.Faces[0], locate.FacesOrient[0]);
}
}
return(feature);
}
private LocateResult Detect(ImageData offInput, IntPtr pImageData, out ErrorCode ret, LocateOperation operation = LocateOperation.None)
{
System.IntPtr pDetectResult;
var retCode =
TrackingWrapper.AFT_FSDK_FaceFeatureDetect(Engine, ref offInput, out pDetectResult);
ret = (ErrorCode)retCode;
if (ret == ErrorCode.Ok)
{
var nativeResult = pDetectResult.ToStruct <AFT_FSDK_FACERES>();
var resolveResult = new LocateResult
{
FaceCount = nativeResult.nFace,
FacesOrient = Enumerable.Repeat((OrientCode)nativeResult.lfaceOrient, nativeResult.nFace)
.ToArray()
};
resolveResult.Faces = nativeResult.rcFace.ToStructArray <FaceRect>(resolveResult.FaceCount);
resolveResult.OffInput = offInput;
resolveResult.ImageDataPtr = pImageData;
if (operation.HasFlag(LocateOperation.IncludeAge))
{
//检测年龄
if (ageEstimate == null)
{
throw new InvalidOperationException("请采用年龄识别模块初始化检测器");
}
resolveResult = ageEstimate.StaticEstimation(resolveResult, false);
}
if (operation.HasFlag(LocateOperation.IncludeGender))
{
//性别
if (genderEstimate == null)
{
throw new InvalidOperationException("请采用性别识别模块初始化检测器");
}
resolveResult = genderEstimate.StaticEstimation(resolveResult, false);
}
return(resolveResult);
}
return(default(LocateResult));
}
private LocateResult Detect(ImageData offInput, IntPtr pImageData, out ErrorCode ret, LocateOperation operation = LocateOperation.None)
{
var retCode =
DetectionWrapper.AFD_FSDK_StillImageFaceDetection(Engine, ref offInput, out var pDetectResult);
ret = (ErrorCode)retCode;
if (ret == ErrorCode.Ok)
{
var nativeResult = pDetectResult.ToStruct <AFD_FSDK_FACERES>();
var resolveResult = new LocateResult {
FaceCount = nativeResult.nFace
};
var facesOrient = nativeResult.lfaceOrient.ToStructArray <int>(resolveResult.FaceCount);
resolveResult.FacesOrient = facesOrient.Select(e => (OrientCode)e).ToArray();
resolveResult.Faces = nativeResult.rcFace.ToStructArray <FaceRect>(resolveResult.FaceCount);
resolveResult.OffInput = offInput;
resolveResult.ImageDataPtr = pImageData;
if (operation.HasFlag(LocateOperation.IncludeAge))
{
//检测年龄
if (ageEstimate == null)
{
throw new InvalidOperationException("请采用年龄识别模块初始化检测器");
}
resolveResult = ageEstimate.StaticEstimation(resolveResult, false);
}
if (operation.HasFlag(LocateOperation.IncludeGender))
{
//性别
if (genderEstimate == null)
{
throw new InvalidOperationException("请采用性别识别模块初始化检测器");
}
resolveResult = genderEstimate.StaticEstimation(resolveResult, false);
}
return(resolveResult);
}
return(default(LocateResult));
}
/// <summary>
/// 返回图片人脸数据
/// </summary>
/// <param name="bitmap"></param>
/// <returns></returns>
public LocateResult FaceLocateResult(Bitmap bitmap)
{
LocateResult _locateResult = null;
var code = _detection.Detect(bitmap, out var locateResult);
try
{
if (code == Stepon.FaceRecognization.Common.ErrorCode.Ok)
{
_locateResult = locateResult;
}
}
catch (Exception error)
{
throw new Exception(error.Message);
}
return(_locateResult);
}
/**
* Locate a SIGMA on the pyramid.
*/
public void locate(double sigma, LocateResult result)
{
// octave = floor(log2(s))
int octave = (int)Math.Floor(Math.Log(sigma) / Math.Log(2));
// scale = logk(s/2^octave)
// Here we ROUND the scale to an integer value
double fscale = Math.Log(sigma / (double)(1 << octave))
* this.mOneOverLogK;
int scale = (int)Math.Floor((fscale + 0.5));
// The last scale in an octave has the same sigma as the first scale
// of the next octave. We prefer coarser octaves for efficiency.
if (scale == this.mNumScalesPerOctave - 1)
{
// If this octave is out of range, then it will be clipped to
// be in range on the next step below.
octave = octave + 1;
scale = 0;
}
// Clip the octave/scale to be in range of the pyramid
if (octave < 0)
{
result.octave = 0;
result.scale = 0;
}
else if (octave >= this.mNumOctaves)
{
result.octave = this.mNumOctaves - 1;
result.scale = this.mNumScalesPerOctave - 1;
}
else
{
result.octave = octave;
result.scale = scale;
}
Debug.Assert(result.octave >= 0); // , "Octave must be positive");
Debug.Assert(result.octave < this.mNumOctaves); // "Octave must be less than number of octaves");
Debug.Assert(result.scale >= 0); // , "Scale must be positive");
Debug.Assert(result.scale < this.mNumScalesPerOctave); // "Scale must be less than number of scale per octave");
}
private LocateResult Detect(ImageData offInput, IntPtr pImageData, out ErrorCode ret)
{
var retCode =
DetectionWrapper.AFD_FSDK_StillImageFaceDetection(Engine, ref offInput, out var pDetectResult);
ret = (ErrorCode)retCode;
if (ret == ErrorCode.Ok)
{
var nativeResult = pDetectResult.ToStruct <AFD_FSDK_FACERES>();
var resolveResult = new LocateResult {
FaceCount = nativeResult.nFace
};
var facesOrient = nativeResult.lfaceOrient.ToStructArray <int>(resolveResult.FaceCount);
resolveResult.FacesOrient = facesOrient.Select(e => (OrientCode)e).ToArray();
resolveResult.Faces = nativeResult.rcFace.ToStructArray <FaceRect>(resolveResult.FaceCount);
resolveResult.OffInput = offInput;
resolveResult.ImageDataPtr = pImageData;
return(resolveResult);
}
return(default(LocateResult));
}
public abstract ErrorCode Detect(byte[] imageData, int width, int height, out LocateResult result, int pixelSize = 3, LocateOperation operation = LocateOperation.None);
public abstract ErrorCode Detect(Bitmap image, out LocateResult result, LocateOperation operation = LocateOperation.None);
public abstract ErrorCode Detect(Bitmap image, out LocateResult result);
/// <summary> /// 序列帧图片的评估 /// </summary> /// <param name="locate">已经识别的人脸位置信息（图片数据未释放，如果释放，将出现异常）</param> /// <param name="autoDispose">是否自动释放检测的人脸资源</param> /// <returns>包含额外信息的位置</returns> public abstract LocateResult PreviewEstimation(LocateResult locate, bool autoDispose = true);
public abstract ErrorCode Detect(byte[] imageData, int width, int height, out LocateResult result);
/// <summary> /// 静态图片的评估 /// </summary> /// <param name="locate">已经识别的人脸位置信息（图片数据未释放，如果释放，将出现异常）</param> /// <param name="autoDispose">是否自动释放检测的人脸资源</param> /// <returns>包含年龄的位置信息</returns> public abstract LocateResult StaticEstimation(LocateResult locate, bool autoDispose = true);
