public async Task <bool> AddImageForPerson(PhotoFace photoFace, IRandomAccessStream stream)
{
if (photoFace == null || photoFace.Name == null)
{
return(false);
}
bool trained = false;
// create group
try
{
if (!await CheckIfGroupExistsAsync())
{
await _client.CreatePersonGroupAsync(_groupId, _groupId);
}
if (photoFace.PersonId == null || _personList == null || !_personList.Any(p => p.PersonId == photoFace.PersonId))
{
photoFace.PersonId = (await _client.CreatePersonAsync(_groupId, photoFace.Name)).PersonId;
}
await _client.AddPersonFaceAsync(_groupId, photoFace.PersonId, stream.AsStream(), targetFace : photoFace.Rect);
await _client.TrainPersonGroupAsync(_groupId);
while (!trained)
{
await Task.Delay(1000);
var status = await _client.GetPersonGroupTrainingStatusAsync(_groupId);
switch (status.Status)
{
case Status.Succeeded:
trained = true;
break;
case Status.Failed:
return(false);
}
}
_personList = await _client.GetPersonsAsync(_groupId);
return(true);
}
catch (FaceAPIException ex)
{
return(false);
}
}
public override async Task <FindGroupPeopleResult> ExecuteAsync(FindGroupPeopleContext request)
{
var result = new FindGroupPeopleResult();
var keyProvider = DependencyService.Get <IApiKeyProvider>();
string faceKey = keyProvider.GetApiKey(ApiKeyType.FaceApi);
var faceServiceClient = new FaceServiceClient(faceKey);
try
{
var people = await faceServiceClient.GetPersonsAsync(request.GroupId);
foreach (var person in people)
{
var p = new Mutant();
p.Name = person.Name;
p.Id = person.PersonId.ToString();
if (person.UserData != null)
{
p.Data = JsonConvert.DeserializeObject <UserData>(person.UserData);
}
result.People.Add(p);
//TODO: add person to store?
}
}
catch (FaceAPIException fex)
{
result.Notification.Add("Fetch People Group Failed! " + fex.ErrorMessage);
}
catch (Exception ex)
{
result.Notification.Add("Fetch People Group Failed! " + ex.Message);
}
return(result);
}
private async void GetPersons()
{
if (SelectedPersonGroup == null)
{
return;
}
Persons.Clear();
try
{
Person[] persons = await _faceServiceClient.GetPersonsAsync(SelectedPersonGroup.PersonGroupId);
if (persons == null || persons.Length == 0)
{
StatusText = $"No persons found in {SelectedPersonGroup.Name}.";
return;
}
foreach (Person person in persons)
{
Persons.Add(person);
}
}
catch (FaceAPIException ex)
{
StatusText = $"Failed to get persons from {SelectedPersonGroup.Name}: {ex.ErrorMessage}";
}
catch (Exception ex)
{
StatusText = $"Failed to get persons from {SelectedPersonGroup.Name}: {ex.Message}";
}
}
public async Task <Person[]> Get() //Get all members
{
FaceServiceClient faceClient = new FaceServiceClient(Configuration.Get("AppSettings:OxfordSubscriptionKeyPrimary"));
Person[] memberList = await faceClient.GetPersonsAsync(Configuration.Get("AppSettings:MemberGroupId"));
return(memberList);
}
private async void DeleteButtonClick()
{
Person[] persons = await faceServiceClient.GetPersonsAsync(GroupName);
Person person;
Guid personId;
try
{
person = persons.Where(item => item.Name == personName).First();
personId = person.PersonId;
await faceServiceClient.DeletePersonAsync(GroupName, personId);
TestText += "\nPerson deleted successfuly";
}
catch
{
TestText += "\nPerson doesnt exist in the list";
}
}
/// <summary>
/// 將人員群組的人員資料放入到字典檔中的動作
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private async void cbxPersonGroup_SelectedIndexChanged(object sender, EventArgs e)
{
string strPersonGroupId = ((Models.CognitiveModels.ListItem)cbxPersonGroup.SelectedItem).Value;
DicPerson = new Hashtable();
Person[] objPersons = await face.GetPersonsAsync(strPersonGroupId);
for (int i = 0; i < objPersons.Length; i++)
{
DicPerson.Add(objPersons[i].PersonId.ToString().Replace("{", "").Replace("}", ""), objPersons[i].Name);
}
}
public async Task LoadDataAsync()
{
Message = "Loading Data..";
// Check if face group alredy exists, otherwise create it.
try
{
await faceClient.GetPersonGroupAsync(Settings.PersonGroupId);
}
catch (FaceAPIException ex)
{
if (ex.ErrorCode == "PersonGroupNotFound")
{
await faceClient.CreatePersonGroupAsync(Settings.PersonGroupId, Settings.PersonGroupId);
}
else
{
throw;
}
}
currentEvent = await meetupService.GetCurrentEventAsync();
if (currentEvent == null)
{
Message = "No event scheduled.";
return;
}
registeredPersons = (await faceClient.GetPersonsAsync(Settings.PersonGroupId)).ToList();
RSVPs = await meetupService.GetRSVPsAsync(currentEvent.Id);
// Get comments start with 'Welcome' to track who comes to the event.
RSVPComments = (await meetupService.GetCommentsAsync(currentEvent.Id)).Where(x => x.CommentDetail.StartsWith("Welcome ")).ToList();
// Check if RSVPed meetup member is registered to Face API.
foreach (RSVP rsvp in RSVPs)
{
var registeredPerson = registeredPersons.FirstOrDefault(x => x.Name == rsvp.Member.Name);
if (registeredPerson == null)
{
var userData = new JObject();
userData["memberId"] = rsvp.Member.Id;
var createdPersonResult = await faceClient.CreatePersonAsync(Settings.PersonGroupId, rsvp.Member.Name, userData.ToString());
registeredPersons.Add(await faceClient.GetPersonAsync(Settings.PersonGroupId, createdPersonResult.PersonId));
}
}
await mediaCapture.StartPreviewAsync();
Identify();
}
public async Task UpsertPersonAsync(StorageFile image, string personName)
{
Log?.WriteLine($"Upsert person: {personName}");
// person group
try
{
var personGroup = await _faceClient.GetPersonGroupAsync(_groupName);
Log?.WriteLine($"Found person group: {personGroup.Name}");
}
catch (FaceAPIException ex)
{
if (ex.ErrorCode == "PersonGroupNotFound")
{
Log?.WriteLine("Creating person group");
await _faceClient.CreatePersonGroupAsync(_groupName, _groupName);
}
}
// person
var people = await _faceClient.GetPersonsAsync(_groupName);
var personId = people.FirstOrDefault(p => p.Name.ToLowerInvariant() == personName.ToLowerInvariant())?.PersonId;
if (personId == null || personId == Guid.Empty)
{
personId = (await _faceClient.CreatePersonAsync(_groupName, personName)).PersonId;
}
// face
await Task.Run(async() =>
{
using (var fileStream = File.OpenRead(image.Path))
{
await _faceClient.AddPersonFaceAsync(_groupName, (Guid)personId, fileStream, image.Path);
await _faceClient.TrainPersonGroupAsync(_groupName);
while (true)
{
var trainingStatus = await _faceClient.GetPersonGroupTrainingStatusAsync(_groupName);
Log?.WriteLine($"Training Status: {trainingStatus.Status.ToString()}");
if (trainingStatus.Status != Microsoft.ProjectOxford.Face.Contract.Status.Running)
{
break;
}
await Task.Delay(1500);
}
}
});
}
/// <summary>
/// This method creates a new person if it doesn't exist yet within the Face API, and uses its newly created person ID as its name.
/// </summary>
/// <param name="name">The name of the person to create: can either be a real name when updating a person, or a temporary GUID for a newly found person.</param>
/// <returns>The final person ID of the Face API created person, or the ID of the person with this name that already existed.</returns>
public async Task <Guid> CreatePerson(string name)
{
var persons = await faceServiceClient.GetPersonsAsync(personGroupId);
var result = persons.Where(p => p.Name == name).ToList();
if (result.Any())
{
// if the person exists, update its name with the possible new value
var person = result.FirstOrDefault();
return(person.PersonId);
}
// if the person doesn't exist, create him or her
var createPersonResult = await faceServiceClient.CreatePersonAsync(personGroupId, name);
// now update the name with its Face API person ID (because we do not yet know the name of newly found persons)
var newName = createPersonResult.PersonId.ToString();
await faceServiceClient.UpdatePersonAsync(personGroupId, createPersonResult.PersonId, newName);
return(createPersonResult.PersonId);
}
private async static void DeletePersons()
{
Console.WriteLine("Enter the Person Group Id");
string personGroupId = Console.ReadLine();
var persons = await _faceServiceClient.GetPersonsAsync(personGroupId);
if (!persons.Any())
{
Console.WriteLine("No Persons Registered");
return;
}
Console.WriteLine($"Deleting {persons.Count()} person(s)");
Console.WriteLine();
foreach (var person in persons)
{
Console.WriteLine($"Deleting {person.Name} with PersonId: {person.PersonId}...");
Console.WriteLine("===================================");
await _faceServiceClient.DeletePersonAsync(personGroupId, person.PersonId);
}
Console.WriteLine();
Console.WriteLine("Finished Deleting all persons");
}
/// <summary>
/// 放入人員清單的動作
/// </summary>
private async void BindPersons()
{
string strPersonGroupId = ((Models.CognitiveModels.ListItem)lbxPersonGroup.SelectedItem).Value;
lbxPerson.Items.Clear();
Person[] objPersons = await face.GetPersonsAsync(strPersonGroupId);
for (int i = 0; i < objPersons.Length; i++)
{
lbxPerson.Items.Add(
new Models.CognitiveModels.ListItem()
{
Text = objPersons[i].Name,
Value = objPersons[i].PersonId.ToString(),
});
}
}
public IEnumerable <Person> GetPersons(string groupName)
{
try
{
return(Task.Run(() => Api.GetPersonsAsync(groupName.ToLowerInvariant())).GetAwaiter().GetResult().Select(x => new Person
{
Name = x.Name,
Id = x.PersonId,
GroupName = groupName,
UserData = x.UserData
}));
}
catch (FaceAPIException ex)
{
throw new FaceApiException(ex.ErrorMessage);
}
}
public async Task <Person[]> GetPersonsAsync(string personGroupId)
{
return(await RunTaskWithAutoRetryOnQuotaLimitExceededError <Person[]>(() => faceClient.GetPersonsAsync(personGroupId)));
}
public async Task <Person[]> GetPersonGroupPersonList(string personGroupId)
{
var personList = await faceServiceClient.GetPersonsAsync(personGroupId);
return(personList);
}
// POST api/stream
public async Task <IHttpActionResult> Post()
{
Trace.TraceWarning("Received");
Trace.TraceError("Received: " + Request.Content);
if (!Request.Content.IsMimeMultipartContent())
{
throw new HttpResponseException(HttpStatusCode.UnsupportedMediaType);
}
var provider = new MultipartMemoryStreamProvider();
await Request.Content.ReadAsMultipartAsync(provider);
var results = new List <FaceData>();
foreach (var file in provider.Contents)
{
var filename = file.Headers.ContentDisposition.FileName.Trim('\"');
var buffer = await file.ReadAsByteArrayAsync();
using (var fileStream = new MemoryStream(buffer))
{
try
{
Trace.TraceError(FaceKey);
await PersonManager.CreateGroupIfNotExists();
var TargetFaces = new List <Guid>();
var faceServiceClient = new FaceServiceClient(FaceKey);
Trace.TraceError(EmotionKey);
var emotionServiceClient = new EmotionServiceClient(EmotionKey);
var faces = await faceServiceClient.DetectAsync(fileStream, true, false, new FaceAttributeType[] { FaceAttributeType.Smile });
var Rectangles = new Rectangle[faces.Length];
for (int idx = 0; idx < faces.Length; idx++)
{
TargetFaces.Add(faces[idx].FaceId);
var fr = faces[idx].FaceRectangle;
Rectangles[idx] = new Rectangle();
Rectangles[idx].Height = fr.Height;
Rectangles[idx].Top = fr.Top;
Rectangles[idx].Width = fr.Width;
Rectangles[idx].Left = fr.Left;
}
Trace.TraceError(faces.ToString());
// Get all persons
var Persons = await faceServiceClient.GetPersonsAsync(GroupName);
Trace.TraceError(Persons.ToString());
// Identify each face
// Call identify REST API, the result contains identified person information
var identifyResult = await faceServiceClient.IdentifyAsync(GroupName, TargetFaces.ToArray(), 0.3f, 4);
var emotion = await emotionServiceClient.RecognizeAsync(fileStream, Rectangles);
Trace.TraceError(emotion.ToString());
for (int idx = 0; idx < faces.Length; idx++)
{
// Update identification result for rendering
var f = faces[idx];
var face = TargetFaces[idx];
var res = identifyResult[idx];
var emot = emotion[idx];
var name = "Unknown";
var id = "";
var em = "";
var highest = 0f;
if (res.Candidates.Length > 0)
{
foreach (var person in Persons)
{
if (person.PersonId.ToString() == res.Candidates[0].PersonId.ToString())
{
name = person.Name;
id = person.UserData;
}
}
}
if (emot.Scores.Neutral > highest)
{
highest = emot.Scores.Neutral;
em = "Neutral";
}
if (emot.Scores.Happiness > highest)
{
highest = emot.Scores.Happiness;
em = "Happiness";
}
if (emot.Scores.Sadness > highest)
{
highest = emot.Scores.Sadness;
em = "Sadness";
}
if (emot.Scores.Surprise + emot.Scores.Fear > highest)
{
highest = emot.Scores.Surprise + emot.Scores.Fear;
em = "Surprise";
}
if (emot.Scores.Anger > highest)
{
highest = emot.Scores.Anger;
em = "Anger";
}
var dat = new FaceData();
dat.Emotion = em;
dat.Id = id;
dat.Name = name;
dat.FaceId = f.FaceId;
dat.FaceRectangle = f.FaceRectangle;
dat.FaceAttributes = f.FaceAttributes;
// Calculate color
int red = (int)(255 * (emot.Scores.Anger + emot.Scores.Surprise + emot.Scores.Fear));
int green = (int)(255 * emot.Scores.Happiness);
int blue = (int)(255 * emot.Scores.Sadness);
System.Drawing.Color color = System.Drawing.Color.FromArgb(red, green, blue);
ColorConversion.HSVToRGB(color.GetHue(), color.GetSaturation(), color.GetBrightness(), out red, out green, out blue);
dat.Color = "#" + red.ToString("X2") + green.ToString("X2") + blue.ToString("X2");
results.Add(dat);
}
}
catch (FaceAPIException ex)
{
Trace.TraceError(ex.ErrorCode + ", " + ex.ErrorMessage);
}
GC.Collect();
}
}
Trace.TraceError(results.ToString());
return(Json(results));
}
private async Task <string> Train(string testImageFile, string name)
{
string result = "";
try
{
Nullable <System.Guid> personId = null;
var faceServiceClient = new FaceServiceClient(subscriptionKey, apiRootUrl);
// I have already created a person group. If you haven't created please use the below code to create before get
// await faceServiceClient.CreatePersonGroupAsync(personGroupId, "<friendly name to your group>");
var personGroup = await faceServiceClient.GetPersonGroupAsync(personGroupId);
var persons = await faceServiceClient.GetPersonsAsync(personGroupId);
if (persons != null)
{
foreach (var item in persons)
{
if (item.Name.Equals(name, StringComparison.InvariantCultureIgnoreCase))
{
personId = item.PersonId;
}
}
}
if (personId == null)
{
CreatePersonResult personCreate = await faceServiceClient.CreatePersonAsync(
// Id of the PersonGroup that the person belonged to
personGroupId,
// Name of the person
name
);
personId = personCreate.PersonId;
}
if (personId == null)
{
return("personId is null");
}
using (Stream s = System.IO.File.OpenRead(testImageFile))
{
// Detect faces in the image and add to Anna
await faceServiceClient.AddPersonFaceAsync(
personGroupId, personId.Value, s);
}
await faceServiceClient.TrainPersonGroupAsync(personGroupId);
TrainingStatus trainingStatus = null;
while (true)
{
trainingStatus = await faceServiceClient.GetPersonGroupTrainingStatusAsync(personGroupId);
if (trainingStatus.Status != Status.Running)
{
break;
}
await Task.Delay(1000);
}
result = "Successfully trained";
}
catch (FaceAPIException e)
{
result = e.Message;
}
return(result);
}
