//ObservableCollection son colecciones de datos que reciben notificacion al insertar o eliminar
private ObservableCollection <EmoFace> ExtractFaces(Emotion[] emotions, EmoPicture emoPicture)
{
//Crea una lista observable de caras
var facesList = new ObservableCollection <EmoFace>();
//Emotions es una lista, asi que se itera para agregar datos de la cara
foreach (var emotion in emotions)
{
var emoface = new EmoFace()
{
X = emotion.FaceRectangle.Left,
Y = emotion.FaceRectangle.Top,
Width = emotion.FaceRectangle.Width,
Height = emotion.FaceRectangle.Height,
Picture = emoPicture,
};
//Aqui se devuelve la lista con los Scores de las emociones de dicha cara
emoface.Emotions = ProcessEmotions(emotion.Scores, emoface);
//Se agrega los datos
facesList.Add(emoface);
}
//Retornamos la lista de Caras
return(facesList);
}
public async Task <IActionResult> PutEmoPicture([FromRoute] int id, [FromBody] EmoPicture emoPicture)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (id != emoPicture.Id)
{
return(BadRequest());
}
_context.Entry(emoPicture).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!EmoPictureExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public IHttpActionResult PutEmoPicture(int id, EmoPicture emoPicture)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (id != emoPicture.Id)
{
return(BadRequest());
}
db.Entry(emoPicture).State = EntityState.Modified;
try
{
db.SaveChanges();
}
catch (DbUpdateConcurrencyException)
{
if (!EmoPictureExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(StatusCode(HttpStatusCode.NoContent));
}
public async Task <EmoPicture> DetectAndExtracFacesAsync(Stream vImageString)
{
//Emotion[] vEmotion = await emoClient.RecognizeAsync(vImageString);
//var vPicture = new EmoPicture();
//vPicture.Faces = ExtractFaces(vEmotion, vPicture);
//return vPicture;
var emoPicture = new EmoPicture();
try
{
IEnumerable <FaceAttributeType> faceAttributes = new FaceAttributeType[] { FaceAttributeType.Emotion };
Face[] faces = await emoClientFace.DetectAsync(vImageString, false, false, faceAttributes);
emoPicture.Faces = ExtractFaces(faces, emoPicture); //Face
}
catch (Exception exc)
{
throw;
}
return(emoPicture);
}
// Se crea el metodo ExtacFaces Para pasarlo como valor en el DetectAndExtracFacesAsync y posteriormente
// Retornar los valores ingresador como un Stream
private ObservableCollection <EmoFace> ExtracFaces(Emotion[] emotions, EmoPicture emoPicture)
{
// Se instancia como una listaObjerbable EmoFace
// ObservableCollection se usa para traer los datos en una lista y para detectar cambio que
// Se hagan en el.
var listaFaces = new ObservableCollection <EmoFace>();
// Se recorre emotions para irle agregando los valores de cognitive a los atributos de
// EmoFace
foreach (var emotion in emotions)
{
// Se crea una lista dentro de un foreach para ir reciviendo la informacion
// de cada foto entrante y almacenarla en un arreglo para luego analizarla
var emoface = new EmoFace()
{
// Se le agregan propiedades de recuedro a los atributos de EmoFace
X = emotion.FaceRectangle.Left,
Y = emotion.FaceRectangle.Top,
Width = emotion.FaceRectangle.Width,
Height = emotion.FaceRectangle.Height,
Picture = emoPicture,
};
// Se Carga una ,lista con los valores agregados a las propiedades de emoface
emoface.Emotions = ProcessEmotions(emotion.Scores, emoface);
// Y se van guardando los valores
listaFaces.Add(emoface);
}
// Retornamos la listaFaces con los valores
return(listaFaces);
}
public async Task <IActionResult> Edit(int id, [Bind("Id,Name,Path")] EmoPicture emoPicture)
{
if (id != emoPicture.Id)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(emoPicture);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!EmoPictureExists(emoPicture.Id))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(emoPicture));
}
private ObservableCollection <EmoFace> EstracFaces(Emotion[] emotions,
EmoPicture emoPicture)
{
var listaFaces = new ObservableCollection <EmoFace>();
try
{
foreach (var emotion in emotions)
{
var emoface = new EmoFace()
{
X = emotion.FaceRectangle.Left,
Y = emotion.FaceRectangle.Top,
Width = emotion.FaceRectangle.Width,
Height = emotion.FaceRectangle.Height,
Picture = emoPicture
};
emoface.Emotions = ProcessEmotions(emotion.Scores, emoface);
listaFaces.Add(emoface);
}
return(listaFaces);
}
catch (Exception e)
{
return(listaFaces);
}
}
public async void DetectAndExtractFaces(Stream imageStream)
{
Emotion[] emotions = await emoClient.RecognizeAsync(imageStream);
var emoPicture = new EmoPicture();
//emoPicture.Faces = ExtractFaces(emotions,emoPicture);
}
public ActionResult DeleteConfirmed(int id)
{
EmoPicture emoPicture = db.EmoPictures.Find(id);
db.EmoPictures.Remove(emoPicture);
db.SaveChanges();
return(RedirectToAction("Index"));
}
public async Task <EmoPicture> DetectAndExtractFacesAsync(Stream ImageStream)
{
Emotion[] emotions = await EmoClient.RecognizeAsync(ImageStream);
var emopic = new EmoPicture();
emopic.Faces = ExtractFaces(emotions, emopic);
return(emopic);
}
public async Task <EmoPicture> DetectAndExtracFacesAsync(Stream imageStream) //async void ---> pero como retorna un EmoPicture debe ir dentro de un Task
{
Emotion[] emotions = await emoClient.RecognizeAsync(imageStream);
var emoPicture = new EmoPicture();
emoPicture.Faces = ExtractFaces(emotions, emoPicture);
return(emoPicture);
}
public async Task <EmoPicture> DetectAndExtractFacesAsync(Stream imageStream)
{
var emotions = await EmoClient.RecognizeAsync(imageStream);
var emoPicture = new EmoPicture();
emoPicture.Faces = ExtractFaces(emotions, emoPicture);
return(emoPicture);
}
public ActionResult Edit([Bind(Include = "Id,Name,Path")] EmoPicture emoPicture)
{
if (ModelState.IsValid)
{
db.Entry(emoPicture).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(emoPicture));
}
public async Task <EmoPicture> DetectedFacesAndExtracFacesAsync(Stream imageStream, IList <FaceAttributeType> faceAttributes)
{
IList <DetectedFace> faceList = await faceClient.Face.DetectWithStreamAsync(imageStream, true, false, faceAttributes);
EmoPicture emoPicture = new EmoPicture();
emoPicture.Faces = ExtractFaces(faceList, emoPicture);
return(emoPicture);
}
public async Task <EmoPicture> DetectAndExtractFacesAsync(Stream imageStream)
{
Microsoft.ProjectOxford.Emotion.Contract.Emotion[] emotions = await emoClient.RecognizeAsync(imageStream);
var emoPicture = new EmoPicture();
emoPicture.Faces = ExtractFaces(emotions, emoPicture);
return(emoPicture);
}
public IHttpActionResult GetEmoPicture(int id)
{
EmoPicture emoPicture = db.EmoPictures.Find(id);
if (emoPicture == null)
{
return NotFound();
}
return Ok(emoPicture);
}
public async Task <IActionResult> Create([Bind("Id,Name,Path")] EmoPicture emoPicture)
{
if (ModelState.IsValid)
{
_context.Add(emoPicture);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(emoPicture));
}
public async Task <IHttpActionResult> GetEmoPicture(int id)
{
EmoPicture emoPicture = await db.EmoPictures.FindAsync(id);
if (emoPicture == null)
{
return(NotFound());
}
return(Ok(emoPicture));
}
public ActionResult Create([Bind(Include = "Id,Name,Path")] EmoPicture emoPicture)
{
if (ModelState.IsValid)
{
db.EmoPictures.Add(emoPicture);
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(emoPicture));
}
public async Task <EmoPicture> DetectAndExtractFacesAsync(Stream imageStream)
{
IEnumerable <FaceAttributeType> faceAttributes = new FaceAttributeType[] { FaceAttributeType.Emotion };
Face[] faces = await emoClient.DetectAsync(imageStream, false, false, faceAttributes);
var emoPicture = new EmoPicture();
emoPicture.Faces = ExtractFaces(faces, emoPicture);
return(emoPicture);
}
public IHttpActionResult PostEmoPicture(EmoPicture emoPicture)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
db.EmoPictures.Add(emoPicture);
db.SaveChanges();
return(CreatedAtRoute("DefaultApi", new { id = emoPicture.Id }, emoPicture));
}
public async Task <IActionResult> PostEmoPicture([FromBody] EmoPicture emoPicture)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
_context.EmoPictures.Add(emoPicture);
await _context.SaveChangesAsync();
return(CreatedAtAction("GetEmoPicture", new { id = emoPicture.Id }, emoPicture));
}
public IHttpActionResult DeleteEmoPicture(int id)
{
EmoPicture emoPicture = db.EmoPictures.Find(id);
if (emoPicture == null)
{
return NotFound();
}
db.EmoPictures.Remove(emoPicture);
db.SaveChanges();
return Ok(emoPicture);
}
// GET: EmoPictures/Delete/5
public ActionResult Delete(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
EmoPicture emoPicture = db.EmoPictures.Find(id);
if (emoPicture == null)
{
return(HttpNotFound());
}
return(View(emoPicture));
}
public async Task <IHttpActionResult> DeleteEmoPicture(int id)
{
EmoPicture emoPicture = await db.EmoPictures.FindAsync(id);
if (emoPicture == null)
{
return(NotFound());
}
db.EmoPictures.Remove(emoPicture);
await db.SaveChangesAsync();
return(Ok(emoPicture));
}
//Metodo que se ejecuta en un hilo asincrono
public async Task <EmoPicture> DetectAndExtractFacesAsync(Stream imageStream)
{
//Recibe un array de Emociones
Emotion[] emotions = await emoCliente.RecognizeAsync(imageStream);
//Variable e instancia del modelo EmoPicture
var emoPicture = new EmoPicture();
/*Es un metodo que devuelve una lista, que recibe el Array de emociones, y la fotografia
* extrae las caras de la pintura*/
emoPicture.Faces = ExtractFaces(emotions, emoPicture);
//Retornamos la Pintura
return(emoPicture);
}
// Al tener porpiedades dentro del metodo asyncronas se tiene que agregar un async
// y es recomendable al nombre del metodo ponerle Async al final para mostrar que es
// un metodo async. Se agrega un Task para especificar que se esta usando el modelo
// Picture y se crea un parametro Stream imageStream para recivir la imagenes
public async Task <EmoPicture> DetectAndExtracFacesAsync(Stream imageStream)
{
// Se llama Emotion y sus propiedades se reciven como array ya que se pueden almacenar varias imagenes
// y se almacenarian en un array.
// Se llaman los servicios de Emotion llamando el emoClient para hacer uso de la propiedad
// RecognizeAsync y iniciar un reconocimiento en este caso de la imagen(imageStream)
Emotion[] emotions = await emoClient.RecognizeAsync(imageStream);
// Se instancia emoPicture para pasarle co
var emoPicture = new EmoPicture();
// Se agregan las emociones a emoPicture
emoPicture.Faces = ExtracFaces(emotions, emoPicture);
// Se retorna la lista con los valores de emoPictures.EmoFaces que es la collection de EmoFace
return(emoPicture);
}
// GET: EmoPictures/Details/5
public ActionResult Details(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
EmoPicture emoPicture = db.EmoPictures.Find(id);
if (emoPicture == null)
{
return(HttpNotFound());
}
var emoFaces = db.EmoFaces.Include(e => e.Picture);
ViewBag.lista = emoFaces.ToList();
return(View(emoPicture));
}
public async Task <EmoPicture> DetectAndExtracFacesAsync(Stream imageStream)
{
try
{
IEnumerable <FaceAttributeType> faceAttributes = new FaceAttributeType[] { FaceAttributeType.Emotion };
Face[] faces = await emoClient.DetectAsync(imageStream, false, false, faceAttributes);
var emoPicture = new EmoPicture();
emoPicture.Faces = ExtractFaces(faces, emoPicture);
return(emoPicture);
}
catch (Exception ex)
{
string error = ex.Message;
return(null);
}
}
private ObservableCollection <EmoFace> ExtractFaces(Emotion[] emotions, EmoPicture emopic)
{
var Faces = new ObservableCollection <EmoFace>();
foreach (var emotion in emotions)
{
var emoface = new EmoFace()
{
X = emotion.FaceRectangle.Left,
Y = emotion.FaceRectangle.Top,
Height = emotion.FaceRectangle.Height,
Width = emotion.FaceRectangle.Width,
Picture = emopic,
};
emoface.Emotion = ProcessEmotion(emotion.Scores, emoface);
Faces.Add(emoface);
}
return(Faces);
}
