public Task AddPersonFace(PersonModel person, PersonGroupModel group, FaceImageModel face, UIImage photo, string userData = null)
{
try
{
var tcs = new TaskCompletionSource <bool>();
var faceRect = face.FaceRectangle.ToMPOFaceRect();
using (var jpgData = photo.AsJPEG(.8f))
{
Client.AddPersonFaceWithPersonGroupId(group.Id, person.Id, jpgData, userData, faceRect, (result, error) =>
{
tcs.FailTaskIfErrored(error.ToException());
tcs.FailTaskByCondition(string.IsNullOrEmpty(result.PersistedFaceId), "AddPersistedFaceResult returned invalid face Id");
face.Id = result.PersistedFaceId;
person.Faces.Add(face);
tcs.SetResult(true);
}).Resume();
}
return(tcs.Task);
}
catch (Exception ex)
{
Log.Error(ex.Message);
throw;
}
}
public Task<PersonGroupModel> CreatePersonGroup(string groupName, string userData = null)
{
try
{
var tcs = new TaskCompletionSource<PersonGroupModel>();
var personGroupId = Guid.NewGuid().ToString();
Client.CreatePersonGroupWithId(personGroupId, groupName, userData, error =>
{
tcs.FailTaskIfErrored(error.ToException());
var group = new PersonGroupModel
{
Name = groupName,
Id = personGroupId,
UserData = userData
};
Groups.Add(group);
tcs.SetResult(group);
}).Resume();
return tcs.Task;
}
catch (Exception ex)
{
Log.Error(ex.Message);
throw;
}
}
public Task <List <PersonModel> > ListPersonsInPersonGroup(PersonGroupModel group)
{
try
{
var tcs = new TaskCompletionSource <List <PersonModel> >();
Client.ListPersonsWithPersonGroupId(group.Id, (groupPeople, error) =>
{
tcs.FailTaskIfErrored(error.ToException());
var people = new List <PersonModel>(
groupPeople.Select(p => p.ToPerson())
);
group.People.AddRange(people);
tcs.SetResult(people);
}).Resume();
return(tcs.Task);
}
catch (Exception ex)
{
Log.Error(ex.Message);
throw;
}
}
public Task <Face> GetFaceForPerson(Person person, PersonGroup group, string persistedFaceId)
{
try
{
var tcs = new TaskCompletionSource <Face> ();
Client.GetPersonFaceWithPersonGroupId(group.Id, person.Id, persistedFaceId, (mpoFace, error) =>
{
tcs.FailTaskIfErrored(error.ToException());
if (tcs.IsNullFinishCanceledOrFaulted())
{
return;
}
var face = mpoFace.ToFace();
tcs.SetResult(face);
}).Resume();
return(tcs.Task);
}
catch (Exception ex)
{
Log.Error(ex);
throw;
}
}
public Task <VerifyResult> Verify(Face face, Person person, PersonGroup personGroup)
{
try
{
var tcs = new TaskCompletionSource <VerifyResult> ();
Client.VerifyWithFaceId(face.Id, person.Id, personGroup.Id, (verifyResult, error) =>
{
tcs.FailTaskIfErrored(error.ToException());
if (tcs.IsNullFinishCanceledOrFaulted())
{
return;
}
var result = new VerifyResult
{
IsIdentical = verifyResult.IsIdentical,
Confidence = verifyResult.Confidence
};
tcs.SetResult(result);
}).Resume();
return(tcs.Task);
}
catch (Exception ex)
{
Log.Error(ex);
throw;
}
}
public Task <PersonModel> CreatePerson(string personName, PersonGroupModel group, string userData = null)
{
try
{
var tcs = new TaskCompletionSource <PersonModel>();
Client.CreatePersonWithPersonGroupId(group.Id, personName, userData, (result, error) =>
{
tcs.FailTaskIfErrored(error.ToException());
tcs.FailTaskByCondition(string.IsNullOrEmpty(result.PersonId), "CreatePersonResult returned invalid person Id");
var person = new PersonModel
{
Name = personName,
Id = result.PersonId,
UserData = userData
};
group.People.Add(person);
tcs.SetResult(person);
}).Resume();
return(tcs.Task);
}
catch (Exception ex)
{
Log.Error(ex.Message);
throw;
}
}
public Task DeletePerson(PersonModel person, PersonGroupModel group)
{
try
{
var tcs = new TaskCompletionSource <bool>();
Client.DeletePersonWithPersonGroupId(group.Id, person.Id, error =>
{
tcs.FailTaskIfErrored(error.ToException());
if (group.People.Contains(person))
{
group.People.Remove(person);
}
tcs.SetResult(true);
}).Resume();
return(tcs.Task);
}
catch (Exception ex)
{
Log.Error(ex.Message);
throw;
}
}
public Task DeleteFace(Person person, PersonGroup group, Face face)
{
try
{
var tcs = new TaskCompletionSource <bool> ();
Client.DeletePersonFaceWithPersonGroupId(group.Id, person.Id, face.Id, error =>
{
tcs.FailTaskIfErrored(error.ToException());
if (tcs.IsNullFinishCanceledOrFaulted())
{
return;
}
if (person.Faces.Contains(face))
{
person.Faces.Remove(face);
}
tcs.SetResult(true);
}).Resume();
return(tcs.Task);
}
catch (Exception ex)
{
Log.Error(ex);
throw;
}
}
public Task <List <PersonGroup> > GetGroups(bool forceRefresh = false)
{
try
{
if (Groups.Count == 0 || forceRefresh)
{
var tcs = new TaskCompletionSource <List <PersonGroup> > ();
Client.ListPersonGroupsWithCompletion((groups, error) =>
{
tcs.FailTaskIfErrored(error.ToException());
if (tcs.IsNullFinishCanceledOrFaulted())
{
return;
}
Groups = new List <PersonGroup> (
groups.Select(g => g.ToPersonGroup())
);
tcs.SetResult(Groups);
}).Resume();
return(tcs.Task);
}
return(Task.FromResult(Groups));
}
catch (Exception ex)
{
Log.Error(ex);
throw;
}
}
public Task UpdatePerson(Person person, PersonGroup group, string personName, string userData = null)
{
try
{
var tcs = new TaskCompletionSource <bool> ();
Client.UpdatePersonWithPersonGroupId(group.Id, person.Id, personName, userData, error =>
{
tcs.FailTaskIfErrored(error.ToException());
if (tcs.IsNullFinishCanceledOrFaulted())
{
return;
}
person.Name = personName;
person.UserData = userData;
tcs.SetResult(true);
}).Resume();
return(tcs.Task);
}
catch (Exception ex)
{
Log.Error(ex);
throw;
}
}
public Task<List<PersonGroupModel>> GetPersonGroups(bool forceRefresh = false)
{
try
{
if (Groups.Count == 0 || forceRefresh)
{
var tcs = new TaskCompletionSource<List<PersonGroupModel>>();
Client.ListPersonGroupsWithCompletion((groups, error) =>
{
tcs.FailTaskIfErrored(error.ToException());
Groups = new List<PersonGroupModel>(
groups.Select(g => g.ToPersonGroup())
);
tcs.SetResult(Groups);
}).Resume();
return tcs.Task;
}
return Task.FromResult(Groups);
}
catch (Exception ex)
{
Log.Error(ex.Message);
throw;
}
}
public Task TrainGroup(PersonGroup personGroup)
{
try
{
var tcs = new TaskCompletionSource <bool> ();
Client.TrainPersonGroupWithPersonGroupId(personGroup.Id, error =>
{
tcs.FailTaskIfErrored(error.ToException());
if (tcs.IsNullFinishCanceledOrFaulted())
{
return;
}
tcs.SetResult(true);
}).Resume();
return(tcs.Task);
}
catch (Exception ex)
{
Log.Error(ex);
throw;
}
}
public Task <List <FaceGroup> > GroupFaces(List <Face> targetFaces)
{
try
{
var tcs = new TaskCompletionSource <List <FaceGroup> > ();
var faceIds = targetFaces.Select(f => f.Id).ToArray();
var results = new List <FaceGroup> ();
Client.GroupWithFaceIds(faceIds, (groupResult, error) =>
{
tcs.FailTaskIfErrored(error.ToException());
if (tcs.IsNullFinishCanceledOrFaulted())
{
return;
}
//for (var i = 0; i < groupResult.Groups.Count; i++)
//{
// var faceGroup = groupResult.Groups [i];
// results.Add (new FaceGroup
// {
// Title = $"Face Group #{i + 1}",
// Faces = targetFaces.Where (f => faceGroup.Contains (f.Id)).ToList ()
// });
//}
//if (groupResult.MesseyGroup.Length > 0)
//{
// results.Add (new FaceGroup
// {
// Title = "Messy Group",
// Faces = targetFaces.Where (f => groupResult.MesseyGroup.Contains (f.Id)).ToList ()
// });
//}
tcs.SetResult(results);
}).Resume();
return(tcs.Task);
}
catch (Exception ex)
{
Log.Error(ex);
throw;
}
}
Task <List <IdentificationResult> > IdentifyInternal(PersonGroup group, Face [] detectedFaces, int maxNumberOfCandidates = 1)
{
try
{
var results = new List <IdentificationResult> ();
var tcs = new TaskCompletionSource <List <IdentificationResult> > ();
var detectedFaceIds = detectedFaces.Select(f => f.Id).ToArray();
Client.IdentifyWithPersonGroupId(group.Id, detectedFaceIds, maxNumberOfCandidates, async(identifyResults, error) =>
{
tcs.FailTaskIfErrored(error.ToException());
if (tcs.IsNullFinishCanceledOrFaulted())
{
return;
}
foreach (MPOIdentifyResult result in identifyResults)
{
var face = detectedFaces.FirstOrDefault(f => f.Id == result.FaceId);
foreach (MPOCandidate candidate in result.Candidates)
{
var person = await GetPerson(group, candidate.PersonId);
var identifyResult = new IdentificationResult
{
Person = person,
Face = face,
Confidence = candidate.Confidence
};
results.Add(identifyResult);
}
}
tcs.SetResult(results);
}).Resume();
return(tcs.Task);
}
catch (Exception ex)
{
Log.Error(ex);
throw;
}
}
public Task DeletePersonGroup(string personGroupId)
{
try
{
var tcs = new TaskCompletionSource<bool>();
Client.DeletePersonGroupWithPersonGroupId(personGroupId, error =>
{
tcs.FailTaskIfErrored(error.ToException());
tcs.SetResult(true);
}).Resume();
return tcs.Task;
}
catch (Exception ex)
{
Log.Error(ex.Message);
throw;
}
}
public Task <Person> GetPerson(PersonGroup group, string personId)
{
try
{
//if people are already loaded for this group try to find it there...
if (group.People?.Count > 0)
{
var person = group.People.FirstOrDefault(p => p.Id == personId);
if (person != null)
{
return(Task.FromResult(person));
}
}
var tcs = new TaskCompletionSource <Person> ();
Client.GetPersonWithPersonGroupId(group.Id, personId, (mpoPerson, error) =>
{
tcs.FailTaskIfErrored(error.ToException());
if (tcs.IsNullFinishCanceledOrFaulted())
{
return;
}
var person = mpoPerson.ToPerson();
//add them to the group?
group.People.Add(person);
tcs.SetResult(person);
}).Resume();
return(tcs.Task);
}
catch (Exception ex)
{
Log.Error(ex);
throw;
}
}
public Task <List <FaceImageModel> > Detect(UIImage photo)
{
try
{
List <FaceImageModel> faces = new List <FaceImageModel>();
var tcs = new TaskCompletionSource <List <FaceImageModel> >();
using (var jpgData = photo.AsJPEG(.8f))
{
Client.DetectWithData(jpgData, true, true, new NSObject[0], (detectedFaces, error) =>
{
tcs.FailTaskIfErrored(error.ToException());
foreach (var detectedFace in detectedFaces)
{
var face = detectedFace.ToFace();
faces.Add(face);
using (var croppedImage = photo.Crop(face.FaceRectangle))
{
//save to disk
using (var data = croppedImage.AsJPEG())
{
data.Save(face.PhotoPath, true);
}
}
}
tcs.SetResult(faces);
}).Resume();
}
return(tcs.Task);
}
catch (Exception ex)
{
Log.Error(ex.Message);
throw;
}
}
public Task <List <SimilarFaceResult> > FindSimilar(Face targetFace, List <Face> faceList)
{
try
{
var tcs = new TaskCompletionSource <List <SimilarFaceResult> > ();
var faceIds = faceList.Select(f => f.Id).ToArray();
var results = new List <SimilarFaceResult> ();
Client.FindSimilarWithFaceId(targetFace.Id, faceIds, (similarFaces, error) =>
{
tcs.FailTaskIfErrored(error.ToException());
if (tcs.IsNullFinishCanceledOrFaulted())
{
return;
}
foreach (var similarFace in similarFaces)
{
var face = faceList.FirstOrDefault(f => f.Id == similarFace.FaceId);
results.Add(new SimilarFaceResult
{
Face = face,
FaceId = similarFace.FaceId,
Confidence = similarFace.Confidence
});
}
tcs.SetResult(results);
}).Resume();
return(tcs.Task);
}
catch (Exception ex)
{
Log.Error(ex);
throw;
}
}
public Task AddFaceForPerson(Person person, PersonGroup group, Face face, UIImage photo, string userData = null, float quality = .8f)
{
var tcs = new TaskCompletionSource <bool> ();
try
{
var faceRect = face.FaceRectangle.ToMPOFaceRect();
using (var jpgData = photo.AsJPEG(quality))
{
Client.AddPersonFaceWithPersonGroupId(group.Id, person.Id, jpgData, userData, faceRect, (result, error) =>
{
tcs.FailTaskIfErrored(error.ToException());
tcs.FailTaskByCondition(string.IsNullOrEmpty(result?.PersistedFaceId), "AddPersistedFaceResult returned invalid face Id");
if (tcs.IsNullFinishCanceledOrFaulted())
{
return;
}
face.Id = result.PersistedFaceId;
face.UpdatePhotoPath();
person.Faces.Add(face);
face.SavePhotoFromSource(photo);
tcs.SetResult(true);
}).Resume();
}
return(tcs.Task);
}
catch (Exception ex)
{
Log.Error(ex);
throw;
}
}
public Task <List <FaceImageModel> > GetPersonFaces(PersonModel person, PersonGroupModel group)
{
try
{
person.Faces.Clear();
if (person.FaceIds != null)
{
var tcs = new TaskCompletionSource <List <FaceImageModel> >();
foreach (var faceId in person.FaceIds)
{
Client.GetPersonFaceWithPersonGroupId(group.Id, person.Id, faceId, (mpoFace, error) =>
{
tcs.FailTaskIfErrored(error.ToException());
var face = mpoFace.ToFace();
person.Faces.Add(face);
if (person.Faces.Count == person.FaceIds.Count)
{
tcs.SetResult(person.Faces);
}
}).Resume();
}
return(tcs.Task);
}
return(Task.FromResult(default(List <FaceImageModel>)));
}
catch (Exception ex)
{
Log.Error(ex.Message);
throw;
}
}
public Task <List <Face> > DetectFacesInPhoto(UIImage photo, float quality = .8f, params MPOFaceAttributeType [] attributes)
{
try
{
List <Face> faces = new List <Face> ();
var tcs = new TaskCompletionSource <List <Face> > ();
using (var jpgData = photo.AsJPEG(quality))
{
Client.DetectWithData(jpgData, true, true, attributes, (detectedFaces, error) =>
{
tcs.FailTaskIfErrored(error.ToException());
if (tcs.IsNullFinishCanceledOrFaulted())
{
return;
}
foreach (var detectedFace in detectedFaces)
{
var face = detectedFace.ToFace();
faces.Add(face);
face.SavePhotoFromSource(photo);
}
tcs.SetResult(faces);
}).Resume();
}
return(tcs.Task);
}
catch (Exception ex)
{
Log.Error(ex);
throw;
}
}
public Task <List <Person> > GetPeopleForGroup(PersonGroup group, bool forceRefresh = false)
{
try
{
if (group.People?.Count > 0 && !forceRefresh)
{
return(Task.FromResult(group.People));
}
var tcs = new TaskCompletionSource <List <Person> > ();
Client.ListPersonsWithPersonGroupId(group.Id, (mpoPeople, error) =>
{
tcs.FailTaskIfErrored(error.ToException());
if (tcs.IsNullFinishCanceledOrFaulted())
{
return;
}
var people = new List <Person> (
mpoPeople.Select(p => p.ToPerson())
);
group.People.Clear();
group.People.AddRange(people);
tcs.SetResult(people);
}).Resume();
return(tcs.Task);
}
catch (Exception ex)
{
Log.Error(ex);
throw;
}
}
public Task <PersonGroup> CreatePersonGroup(string groupName, string userData = null)
{
try
{
var tcs = new TaskCompletionSource <PersonGroup> ();
var personGroupId = Guid.NewGuid().ToString();
Client.CreatePersonGroupWithId(personGroupId, groupName, userData, error =>
{
tcs.FailTaskIfErrored(error.ToException());
if (tcs.IsNullFinishCanceledOrFaulted())
{
return;
}
var group = new PersonGroup
{
Name = groupName,
Id = personGroupId,
UserData = userData
};
Groups.Add(group);
tcs.SetResult(group);
}).Resume();
return(tcs.Task);
}
catch (Exception ex)
{
Log.Error(ex);
throw;
}
}
public Task UpdatePerson(PersonModel person, PersonGroupModel group, string personName, string userData = null)
{
try
{
var tcs = new TaskCompletionSource <bool>();
Client.UpdatePersonWithPersonGroupId(group.Id, person.Id, personName, userData, error =>
{
tcs.FailTaskIfErrored(error.ToException());
person.Name = personName;
person.UserData = userData;
tcs.SetResult(true);
}).Resume();
return(tcs.Task);
}
catch (Exception ex)
{
Log.Error(ex.Message);
throw;
}
}
