public async Task <List <Face> > GetFacesForPerson(Person person, PersonGroup group)
{
try
{
person.Faces.Clear();
if (person.FaceIds?.Count > 0)
{
foreach (var faceId in person.FaceIds)
{
var face = await GetFaceForPerson(person, group, faceId);
person.Faces.Add(face);
}
return(person.Faces);
}
return(default(List <Face>));
}
catch (Exception ex)
{
Log.Error(ex);
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 <Person> CreatePerson(string personName, PersonGroup group, string userData = null)
{
try
{
var result = Client.CreatePerson(group.Id, personName, userData);
var id = result.PersonId.ToString();
if (string.IsNullOrEmpty(id))
{
throw new Exception("CreatePersonResult returned invalid person Id");
}
var person = new Person
{
Name = personName,
Id = id,
UserData = userData
};
group.People.Add(person);
return(Task.FromResult(person));
}
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 <PersonGroup> CreatePersonGroup(string groupName, string userData = null)
{
try
{
var personGroupId = Guid.NewGuid().ToString();
Client.CreatePersonGroup(personGroupId, groupName, userData);
var group = new PersonGroup
{
Name = groupName,
Id = personGroupId,
UserData = userData
};
Groups.Add(group);
return(Task.FromResult(group));
}
catch (Exception ex)
{
Log.Error(ex.Message);
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 <Person> CreatePerson(string personName, PersonGroup group, string userData = null)
{
try
{
var tcs = new TaskCompletionSource <Person> ();
Client.CreatePersonWithPersonGroupId(group.Id, personName, userData, (result, error) =>
{
tcs.FailTaskIfErrored(error.ToException());
tcs.FailTaskByCondition(string.IsNullOrEmpty(result.PersonId), "CreatePersonResult returned invalid person Id");
if (tcs.IsNullFinishCanceledOrFaulted())
{
return;
}
var person = new Person
{
Name = personName,
Id = result.PersonId,
UserData = userData
};
group.People.Add(person);
tcs.SetResult(person);
}).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 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 TrainGroup(PersonGroup personGroup)
{
try
{
Client.TrainPersonGroup(personGroup.Id);
return(Task.FromResult(true));
}
catch (Exception ex)
{
Log.Error(ex.Message);
throw;
}
}
public async Task <List <IdentificationResult> > Identify(PersonGroup group, Face face, int maxNumberOfCandidates = 1)
{
try
{
//ensure people are loaded for this group
await GetPeopleForGroup(group);
return(await IdentifyInternal(group, new Face [] { face }, maxNumberOfCandidates));
}
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 UpdatePersonGroup(PersonGroup personGroup, string groupName, string userData = null)
{
try
{
Client.UpdatePersonGroup(personGroup.Id, groupName, userData);
personGroup.Name = groupName;
personGroup.UserData = userData;
return(Task.FromResult(true));
}
catch (Exception ex)
{
Log.Error(ex.Message);
throw;
}
}
public Task UpdatePerson(Person person, PersonGroup group, string personName, string userData = null)
{
try
{
Client.UpdatePerson(group.Id, UUID.FromString(person.Id), personName, userData);
person.Name = personName;
person.UserData = userData;
return(Task.FromResult(true));
}
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 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 <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;
}
}
