Pruebas Unitarias – Parte 1

Hola, sean bienvenidos a una nueva sección, donde vamos a explicar un poco todo lo relacionado con este tema muy interesante de unit testing, a continuación en la primera entrega de videos de programación y buenas practicas.

Espero les sea de provecho y utilidad, esperen la segunda parte que ya esta en el horno, salu2…

Como enviar un objeto con imagen por POST hacia un WebAPI en formato JSON

Sabemos que Json está revolucionando la programación hoy en día. XML ya empieza a irse desplazando de un tiempo para acá, mucho auge de tecnologías basadas en motores de JavaScript pero bueee la tecnología es así….

Este código es bien sencillo, por lo tanto en este artículo solo voy a hacer énfasis en ese fragmento de código, por lo que no voy a explicar otras cosas alrededor, la idea es poder tener la lógica en nuestras apps y que puedas incorporar esta funcionalidad tan vital para aplicaciones que interactúan mucho con imágenes o alguna captura de multimedios.

Previo a realizar esta subida de data hacia un servidor se debe de tener una WebApi, las WebAPIs son lo más sencillo y dinámico para exponer información, ya sea de un repositorio de data, así como la misma establece una capa de datos muy dinámica y portable por ser multiplataforma.

Ya teniendo tu propia WebAPI arriba en algún servidor (Azure, IIS, etc), se debe de crear una aplicación cliente que consumirá información y podrá hacer peticiones, sencillamente estamos trabajando en C#, ya sea un app Winform, WPF, Xamarin, UWP . También necesitamos la librería Json.Net que la puedes conseguir en Nuget

Volviendo al código tenemos:

public void UploadData(byte[] imagen) //recibimos la imagen como parametro en el metodo
{
  using (var client = new HttpClient())
  {
    var objetoClase1 = new ObjetoClase()
    {
      ID = Guid.NewGuid(),
      MediaStream = imagen, //esta es la imagen representada en Byte[]
      Description = "dummy";
    };
//La magia esta aqui
    var response = await client.PostAsync(new Uri("URL del WebAPI"), new HttpStringContent(JsonConvert.SerializeObject(objetoClase1), UnicodeEncoding.Utf8, "application/json"));

    if (response.IsSuccessStatusCode)
    {
    //Al entrar aqui es porque el POST hacia el webAPI fue exitoso (Codigo 200:OK)
    }
}
}

Espero les sea de utilidad.
Enjoy….

Cómo comprobar si un dispositivo Kinect está conectado con el sistema?

Si se trata de aplicaciones basadas en Kinect, Siempre es recomendable comprobar primero si hay algún sensor Kinect conectado a la PC antes de realizar cualquier operación con objetos KinectSensor. Los KinectSensors mantiene la referencia de todos los sensores conectados y, como se trata de una colección, que tiene una propiedad Count. Usted puede utilizar el KinectSensors.Count para comprobar el número de dispositivo. El recuento de dispositivo más de 0, sólo si hay uno o más dispositivo está conectado.

int deviceCount = KinectSensor.KinectSensors.Count;
if (deviceCount > 0)
{

this.sensor = KinectSensor.KinectSensors[0];
//El resto de la operacion aqui
}
else
{
// no hay sensor conectado.
}

Considere, usted tiene un dispositivo conectado, por lo que obtendrá de referencia del sensor conectado como se muestra en el fragmento de código.

son pequeños pero muy utiles consejos a la hora de validar y garantizar que tus aplicaciones para Kinect funcionen a la perfeccion..

pronto les hare llegar mas tips para utilizar este dispositivo de forma muy eficiente… salu2 😉

Demo Kinect Comandos por voz en ESPAÑOL

En este post explicare sobre el uso de el arreglo de microfonos del Kinect con un ejemplo donde a travez de las librerias Microsoft Speech SDK y el SDK de KINECT podremos a travez de comandos de voz dar alguna instruccion al computador para mostrar algo en una aplicacion C# natural en WPF…

Se me ocurrio un ejemplo similar al que nos trae la SDK Toolkit de Kinect donde al hablar se muestra el espectro de voz de la persona que habla, pero en este caso, utilizare para explicarles sencillamente como ejemplo una aplicacion que al decir un color de los que muestre en la aplicacion esta sea capaz de identificarlo y de pintarlo en la aplicación, dando un rango de exito o de fracaso…

Pensaran que es algo complejo de analizar y de sintetizar la voz y esas cosas pero realmente no nos complicaremos la vida y por suerte ya existen herramientas a la mano para hacer estas cosas como

Bien para esto es necesario previamente tener el Microsoft Speech SDK en este caso la version mas actual que es la 11.0 que la podemos descargar en el siguiente enlace: Microsoft Speech SDK v11.0

Tambien necesitaremos de una libreria de idioma en nuestro caso Español que debemos de desacargar de la pagina Oficial de Kinect en nuestro caso ES-mx (Español-Mexico) o ES-es (Español-España): Kinect for Windows Language Packs v11.0

Una vez instalado estas, procedemos ahora a crear un nuevo proyecto WPF en C# en Visual Studio 2012 o 2010 como lo vayan preferiendo.

blogaudiokinet1

Una vez creada la solucion del proyecto nos vamos al archivo MainWindow.xaml donde escribiremos el siguiente codigo..


<Window x:Class="WpfAudioKinectPruebaHablar.MainWindow"
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        
        Title="Kinect Audio Demo" Height="364" Width="680">
    <Grid Background="white">
        <TextBlock Text="KINECT Demo Audio Prueba" FontSize="36" HorizontalAlignment="Left" VerticalAlignment="Top" Margin="10,5,0,0" FontWeight="Light" />
        <StackPanel HorizontalAlignment="Center" VerticalAlignment="Bottom" >
            <TextBlock x:Name="tbColor" Height="100" Width="500"/>            
            <TextBlock x:Name="tbInfo" Text="" Foreground="Black" Height="50" FontSize="20" TextAlignment="Center" Padding="0,10,0,0"/>
            <TextBlock x:Name="tbSpeech" Text="" Foreground="Black" Height="60" FontSize="16" TextAlignment="Left" Padding="0,10,0,10"/>
        </StackPanel>
        <TextBlock FontSize="16" HorizontalAlignment="Left" Margin="80,93,0,0" Text="diga algo para activar el reconocimiento" VerticalAlignment="Top" Width="379" FontWeight="Light" />
        
    </Grid>
</Window>

En el codigo aparecen tres TextBlock de nombre tbColor, tbInfo, tbSpeech estos son para mostrar una breve leyenda, el color procesado y el indice de acierto…

Antes de iniciar el codigo y la logica de la aplicacion debemos de agregar las referencias o DLLs que ya habiamos mencionado que son la Microsoft.Speech y Microsoft.Kinect

addreference

ahora bien, vamos con la parte mas interesante que es la de trabajar con las librerias de Microsoft Speech y por supuesto la libreria de KINECT sdk, procedemos a abrir el code-behind de MainWindow.xaml que es MainWindow.cs; donde ya abierto, agregamos la libreria Microsoft.Kinect, las siguientes Microsoft.Speech.AudioFormat y Microsoft.Speech.Recognition


using Microsoft.Kinect;

using Microsoft.Speech.AudioFormat;
using Microsoft.Speech.Recognition;

siguiendo con el codigo creamos 5 variables de tipo SolidColorBrush y le di a cada una un color y creamos la variable kinect de tipo KinectSensor, un DispatcherTimer que le llame readyTimer y dos variables muy interesantes que vienen de la libreria Speech que son EnergyCalculatingPassThroughStream que es la variable que contendra el espectro de la energia y la forma de la voz sintetizada para a travez de la segunda variable que es la que crea una especie de gramatica dependiendo de la cultura y el enfasis de la voz la como se muestra en el siguiente codigo.


 private readonly SolidColorBrush redBrush = new SolidColorBrush(Colors.Red);
 private readonly SolidColorBrush greenBrush = new SolidColorBrush(Colors.Green);
 private readonly SolidColorBrush yellowBrush = new SolidColorBrush(Colors.Yellow);
 private readonly SolidColorBrush blueBrush = new SolidColorBrush(Colors.Blue);
 private readonly SolidColorBrush WhiteBrush = new SolidColorBrush(Colors.White);

 KinectSensor kinect;

 private DispatcherTimer readyTimer;
 private EnergyCalculatingPassThroughStream stream;
 private SpeechRecognitionEngine speechRecognizer;

«Suena dificil y complejo pero son solo sencillas primitivas para trabajar el reconocimiento de voz en nuestras aplicaciones».. aca les dejo unas rutinas establecidas para el control de la voz, sintetizarla y despues tomarla en la variable para asi ahora poder trabajar con ella a travez del Kinect, por ahora solo les dejo el siguiente codigo:

 private class EnergyCalculatingPassThroughStream : Stream
 {
   private const int SamplesPerPixel = 10;

   private readonly double[] energy = new double[500];
   private readonly object syncRoot = new object();
   private readonly Stream baseStream;

   private int index;
   private int sampleCount;
   private double avgSample;

 public EnergyCalculatingPassThroughStream(Stream stream)
 {
   this.baseStream = stream;
 }

 public override long Length
 {
   get { return this.baseStream.Length; }
 }

 public override long Position
 {
   get { return this.baseStream.Position; }
   set { this.baseStream.Position = value; }
 }

 public override bool CanRead
 {
   get { return this.baseStream.CanRead; }
 }

 public override bool CanSeek
 {
   get { return this.baseStream.CanSeek; }
 }

 public override bool CanWrite
 {
   get { return this.baseStream.CanWrite; }
 }

 public override void Flush()
 {
   this.baseStream.Flush();
 }

 public void GetEnergy(double[] energyBuffer)
 {
   lock (this.syncRoot)
   {
     int energyIndex = this.index;
     for (int i = 0; i < this.energy.Length; i++)       {       energyBuffer[i] = this.energy[energyIndex];       energyIndex++;       if (energyIndex >= this.energy.Length)
     {
       energyIndex = 0;
     }
   }
  }
 }

  public override int Read(byte[] buffer, int offset, int count)
  {
    int retVal = this.baseStream.Read(buffer, offset, count);
    const double A = 0.3;
    lock (this.syncRoot)
    {
    for (int i = 0; i < retVal; i += 2)      {        short sample = BitConverter.ToInt16(buffer, i + offset);        this.avgSample += sample * sample;        this.sampleCount++;        if (this.sampleCount == SamplesPerPixel)        {          this.avgSample /= SamplesPerPixel;          this.energy[this.index] = .2 + ((this.avgSample * 11) / (int.MaxValue / 2));          this.energy[this.index] = this.energy[this.index] > 10 ? 10 : this.energy[this.index];

        if (this.index > 0)
        {
          this.energy[this.index] = (this.energy[this.index] * A) + ((1 - A) * this.energy[this.index - 1]);
        }

     this.index++;

     if (this.index >= this.energy.Length)
     {
       this.index = 0;
     }

       this.avgSample = 0;
       this.sampleCount = 0;
    }
   }
  }

  return retVal;
 }

  public override long Seek(long offset, SeekOrigin origin)
  {
    return this.baseStream.Seek(offset, origin);
  }

  public override void SetLength(long value)
  {
    this.baseStream.SetLength(value);
  }

  public override void Write(byte[] buffer, int offset, int count)
  {
    this.baseStream.Write(buffer, offset, count);
  }
 }

Y aca les dejo todo codigo fuente para poner a andar nuestro Kinect por voz y en español!…. despues les seguire mostrando detalladamente cada una de las funcionalidades de este demo para que lo apliquen a un sin fin de cosas.

using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Threading;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Media;
using System.Windows.Media.Imaging;
using System.Windows.Threading;

using Microsoft.Kinect;

using Microsoft.Speech.AudioFormat;
using Microsoft.Speech.Recognition;
namespace WpfAudioKinectPruebaHablar
{
 ///
 /// Interaction logic for MainWindow.xaml
 ///
 public partial class MainWindow : Window
 {
 private readonly SolidColorBrush redBrush = new SolidColorBrush(Colors.Red);
 private readonly SolidColorBrush greenBrush = new SolidColorBrush(Colors.Green);
 private readonly SolidColorBrush yellowBrush = new SolidColorBrush(Colors.Yellow);
 private readonly SolidColorBrush blueBrush = new SolidColorBrush(Colors.Blue);
 private readonly SolidColorBrush WhiteBrush = new SolidColorBrush(Colors.White);

 KinectSensor kinect;

 private DispatcherTimer readyTimer;
 private EnergyCalculatingPassThroughStream stream;
 private SpeechRecognitionEngine speechRecognizer;

 #region class EnergyCalculatingPassThroughStream

 private class EnergyCalculatingPassThroughStream : Stream
 {
 private const int SamplesPerPixel = 10;

 private readonly double[] energy = new double[500];
 private readonly object syncRoot = new object();
 private readonly Stream baseStream;

 private int index;
 private int sampleCount;
 private double avgSample;

 public EnergyCalculatingPassThroughStream(Stream stream)
 {
 this.baseStream = stream;
 }

 public override long Length
 {
 get { return this.baseStream.Length; }
 }

 public override long Position
 {
 get { return this.baseStream.Position; }
 set { this.baseStream.Position = value; }
 }

 public override bool CanRead
 {
 get { return this.baseStream.CanRead; }
 }

 public override bool CanSeek
 {
 get { return this.baseStream.CanSeek; }
 }

 public override bool CanWrite
 {
 get { return this.baseStream.CanWrite; }
 }

 public override void Flush()
 {
 this.baseStream.Flush();
 }

 public void GetEnergy(double[] energyBuffer)
 {
 lock (this.syncRoot)
 {
 int energyIndex = this.index;
 for (int i = 0; i < this.energy.Length; i++) { energyBuffer[i] = this.energy[energyIndex]; energyIndex++; if (energyIndex >= this.energy.Length)
 {
 energyIndex = 0;
 }
 }
 }
 }

 public override int Read(byte[] buffer, int offset, int count)
 {
 int retVal = this.baseStream.Read(buffer, offset, count);
 const double A = 0.3;
 lock (this.syncRoot)
 {
 for (int i = 0; i < retVal; i += 2) { short sample = BitConverter.ToInt16(buffer, i + offset); this.avgSample += sample * sample; this.sampleCount++; if (this.sampleCount == SamplesPerPixel) { this.avgSample /= SamplesPerPixel; this.energy[this.index] = .2 + ((this.avgSample * 11) / (int.MaxValue / 2)); this.energy[this.index] = this.energy[this.index] > 10 ? 10 : this.energy[this.index];

 if (this.index > 0)
 {
 this.energy[this.index] = (this.energy[this.index] * A) + ((1 - A) * this.energy[this.index - 1]);
 }

 this.index++;

 if (this.index >= this.energy.Length)
 {
 this.index = 0;
 }

 this.avgSample = 0;
 this.sampleCount = 0;
 }
 }
 }

 return retVal;
 }

 public override long Seek(long offset, SeekOrigin origin)
 {
 return this.baseStream.Seek(offset, origin);
 }

 public override void SetLength(long value)
 {
 this.baseStream.SetLength(value);
 }

 public override void Write(byte[] buffer, int offset, int count)
 {
 this.baseStream.Write(buffer, offset, count);
 }
 }
 #endregion

public MainWindow()
{
 InitializeComponent();

 kinect = KinectSensor.KinectSensors[0];

 if (this.kinect != null)
 {
 this.InitializeKinect();
 }
}

 private void Start()
 {
 var audioSource = this.kinect.AudioSource;
 audioSource.BeamAngleMode = BeamAngleMode.Adaptive;

 audioSource.EchoCancellationMode = EchoCancellationMode.CancellationAndSuppression;
 var kinectStream = audioSource.Start();

 this.stream = new EnergyCalculatingPassThroughStream(kinectStream);
 this.speechRecognizer.SetInputToAudioStream(this.stream, new SpeechAudioFormatInfo
 (EncodingFormat.Pcm, 16000, 16, 1, 32000, 2, null));
 this.speechRecognizer.RecognizeAsync(RecognizeMode.Multiple);
 }

 private static RecognizerInfo GetKinectRecognizer()
 {
 Func<RecognizerInfo, bool> matchingFunc = r =>
 {
 string value;
 r.AdditionalInfo.TryGetValue("Kinect", out value);
 return "True".Equals(value, StringComparison.InvariantCultureIgnoreCase) &&
 "es-ES".Equals(r.Culture.Name,StringComparison.InvariantCultureIgnoreCase);
 };
 return SpeechRecognitionEngine.InstalledRecognizers().Where(matchingFunc).FirstOrDefault();
 }

 private SpeechRecognitionEngine CreateSpeechRecognizer()
 {
 RecognizerInfo ri = GetKinectRecognizer();
 if (ri == null)
 {
 MessageBox.Show(@"Hay un problema al inicializar el dispositivo de reconocimiento de voz.
 asegurese de tener Microsoft Speech SDK instalado y configurado.",
 "Falla al cargar Speech SDK", MessageBoxButton.OK, MessageBoxImage.Error);

 this.Close();
 return null;
 }

 SpeechRecognitionEngine sre;
 try
 {
 sre = new SpeechRecognitionEngine(ri.Id);
 }
 catch
 {
 MessageBox.Show(@"Hay un problema al inicializar el dispositivo de reconocimiento de voz.
 asegurese de tener Microsoft Speech SDK instalado y configurado.", "Falla al cargar Speech SDK",
 MessageBoxButton.OK, MessageBoxImage.Error);
 this.Close();
 return null;
 }

 var colors = new Choices();
 colors.Add("rojo");
 colors.Add("verde");
 colors.Add("azul");
 colors.Add("amarillo");

 var gb = new GrammarBuilder { Culture = ri.Culture };
 gb.Append(colors);

 // Create the actual Grammar instance, and then load it into the speech recognizer.
 var g = new Grammar(gb);

 sre.LoadGrammar(g);
 sre.SpeechRecognized += this.SreSpeechRecognized;
 sre.SpeechHypothesized += this.SreSpeechHypothesized;
 sre.SpeechRecognitionRejected += this.SreSpeechRecognitionRejected;

 return sre;
 }

 private void RejectSpeech(RecognitionResult result)
 {
 string status = "Rechazado: " + (result == null ? string.Empty : result.Text + " " + result.Confidence);
 this.ReportSpeechStatus(status);

 Dispatcher.BeginInvoke(new Action(() => { tbColor.Background = WhiteBrush; }), DispatcherPriority.Normal);
 }

 private void SreSpeechRecognitionRejected(object sender, SpeechRecognitionRejectedEventArgs e)
 {
 this.RejectSpeech(e.Result);
 }

 private void SreSpeechHypothesized(object sender, SpeechHypothesizedEventArgs e)
 {
 this.ReportSpeechStatus("Hipotetico: " + e.Result.Text + " " + e.Result.Confidence);
 }

 private void SreSpeechRecognized(object sender, SpeechRecognizedEventArgs e)
 {
 SolidColorBrush brush;

 if (e.Result.Confidence < 0.7) { this.RejectSpeech(e.Result); return; } switch (e.Result.Text.ToUpperInvariant()) { case "ROJO": brush = this.redBrush; break; case "VERDE": brush = this.greenBrush; break; case "AZUL": brush = this.blueBrush; break; case "AMARILLO": brush = this.yellowBrush; break; default: brush = this.WhiteBrush; break; } string status = "Reconocido: " + e.Result.Text + " " + e.Result.Confidence; this.ReportSpeechStatus(status); Dispatcher.BeginInvoke(new Action(() => { tbColor.Background = brush; }), DispatcherPriority.Normal);
 }

 private void ReportSpeechStatus(string status)
 {
 Dispatcher.BeginInvoke(new Action(() => { tbSpeech.Text = status; }), DispatcherPriority.Normal);
 }

 private void UpdateInstructionsText(string instructions)
 {
 Dispatcher.BeginInvoke(new Action(() => { tbInfo.Text = instructions; }), DispatcherPriority.Normal);
 }

 private void MainWindowClosing(object sender, System.ComponentModel.CancelEventArgs e)
 {
 this.UninitializeKinect();
 }

 private void ReadyTimerTick(object sender, EventArgs e)
 {
 this.Start();
 this.ReportSpeechStatus("Listo para reconocer voz!");
 this.UpdateInstructionsText("Diga: 'rojo', 'verde', 'amarillo' o 'azul'");
 this.readyTimer.Stop();
 this.readyTimer = null;
 }

 private void InitializeKinect()
 {
 var sensor = this.kinect;
 this.speechRecognizer = this.CreateSpeechRecognizer();
 try
 {
 sensor.Start();
 }
 catch (Exception)
 {

 }

 if (this.speechRecognizer != null && sensor != null)
 {
 // NOTE: Need to wait 4 seconds for device to be ready to stream audio right after initialization
 this.readyTimer = new DispatcherTimer();
 this.readyTimer.Tick += this.ReadyTimerTick;
 this.readyTimer.Interval = new TimeSpan(0, 0, 4);
 this.readyTimer.Start();

 this.ReportSpeechStatus("Inicializando el dispositivo de audio Kinect...");
 this.UpdateInstructionsText(string.Empty);

 this.Closing += this.MainWindowClosing;
 }
 }

 private void UninitializeKinect()
 {
 var sensor = this.kinect;

 if (this.speechRecognizer != null && sensor != null)
 {
 sensor.AudioSource.Stop();
 sensor.Stop();
 this.speechRecognizer.RecognizeAsyncCancel();
 this.speechRecognizer.RecognizeAsyncStop();
 }

 if (this.readyTimer != null)
 {
 this.readyTimer.Stop();
 this.readyTimer = null;
 }
 }

 }
}

nota: esta entrada esta sujeta a cambios por la actualizacion de la libreria KINECT, luego les seguire comentando acerca de esto, por ahora solo les adelanto este post!…

UPDATE «Novedades liberadas desde Octubre 2012 SDK»

Entre las nuevas cosas que nos viene ahora en esta actualizacion mencionare las mas destacadas y muy utiles para nosotros los desarrolladores.

1) El stream de infrarrojos está ahora expuesto en el API

El sensor Kinect está ahora expuesto como un formato de color de la imagen nueva. Usted puede utilizar el flujo de infrarrojos en muchos escenarios, tales como:

  •      Calibración de otras cámaras de color para el sensor de profundidad de Kinect
  •      La captura de imágenes en escala de grises en situaciones de poca luz
  •      Dos muestras de infrarrojos se han añadido a la caja de herramientas, y también se puede probar de infrarrojos en KinectExplorer. Esto proporciona a los desarrolladores un amplio espectro de escenarios de pruebas.
  •      Tenga en cuenta que el sensor no es capaz de capturar flujos de infrarrojos y corrientes de color al mismo tiempo. Puede, sin embargo, capturar flujos de infrarrojos y la profundidad simultáneamente.

2) Datos profundidad ampliados 

  • CopyDepthImagePixelData() ahora proporciona detalles más allá de 4 metros, por favor, tenga en cuenta que la calidad de los datos se degrada con la distancia. Además de los datos de profundidad extendidos, facilidad de uso de la profundidad del API de datos ha sido mejorada (enmascaramiento de bits ya no se requiere).
  • Esto significa que las aplicaciones serán capaces de leer los datos más allá de 4 metros cuando sea necesario.
3) Configuracion de color en la APIs de la Cámara

  • Los ajustes de color de la cámara ahora puede ser optimizado para su entorno.
  •      Ahora se puede ajustar el balance de blancos, contraste, tono, saturación y otros parámetros, dando una mejor imagen de color para cada usuario individual.
  •      Para ver la lista completa de los ajustes que se pueden optimizar, inicie el Explorador de Kinect desde el navegador Developer Toolkit y revisar la exposición y controles de color.

4) API de datos Acelerómetro

  • Los datos de los acelerómetros del sensor se expone ahora en la API. Esto permite la detección de la orientación del sensor.

5) Nueva API de conversión de coordenadas espacio

  • Existen varias APIs nuevo para convertir datos entre espacios de coordenadas: el color, la profundidad y el esqueleto.
  • Hay dos conjuntos de API: uno para la conversión de los píxeles individuales y la otra para la conversión de un cuadro de imagen completa.
  • Más allá de mejorar la facilidad de uso, este soporta la funcionalidad adicional mapeo de coordenadas previamente no disponibles para los desarrolladores.

6) Kinect Studio 1.6.0

  • Kinect Studio ha sido actualizado para soportar los rayos infrarrojos, raw bayer, datos extendidos de profundidad, y cuenta con acelerómetro.

7) Raw Bayer

  • El nuevo formato de color de imagen raw Bayer que permite hacer tu propia Bayer RGB conversiones de unidades de procesamiento central (CPU) o unidades de procesamiento gráfico (GPU). Esto permite a los desarrolladores elegir una calidad de conversión superior a RGB de Bayer que nuestro SDK proporciona de forma predeterminada.

Si no tienes la minima idea de que es un Bayer, para los que saben de fotografia tambien pueden refrescar su memoria con estos breves conceptos http://es.wikipedia.org/wiki/Mosaico_de_Bayer

Ademas de las amplias funciones destacadas en la nueva actualizacion tambien estan incluidos nuevos soportes de herramientas y compatibilidad en el sistema operativo Windows 8

Soporte para máquinas virtuales
El sensor Kinect para Windows ahora funciona en Windows que se ejecutan en una máquina virtual (VM) y ha sido probado con los siguientes entornos de VM:

  •      Microsoft HyperV
  •      VMWare
  •      paralelas

Esto amplía enormemente la utilidad de la Kinect para Windows SDK, ya que ahora se puede utilizar en cualquier máquina cuyo sistema operativo nativo admite que ejecuta Windows en uno de los paquetes VM mencionadas anteriormente. Además, esto permite varios escenarios de desarrollo, tales como ciertos enfoques de prueba automatizados.

Actualización Kinect Studio
La actualización simplifica la depuracion y comprobación de las aplicaciones mediante el uso de Kinect Studio para grabar, reproducir y depurar los datos de Kinect. Esta versión se ha actualizado para admitir los nuevos infrarrojo, crudo Bayer, datos extendidos de profundidad, y cuenta con acelerómetro.

Soporte para Windows 8
Al utilizar el Kinect para Windows SDK, puede desarrollar una aplicación Kinect para Windows para una aplicación de escritorio en Windows 8.

Soporte para Visual Studio 2012
El SDK es compatible el desarrollo con Visual Studio 2012, además con el soporte de Visual Studio 2010, y el nuevo Microsoft. NET Framework 4.5, además de los ya soportados. NET Framework 4.0. y el ya mencionado soporte para Windows 8

Tutorial KINECT camaras RGB y de profundidad (DEPTH)

Hola
Empezaremos por lo básico, en Visual Studio 2010 creamos un nuevo proyecto WPF y en mi caso le llamare KinectPruebaCamaras.

Ahora bien una vez creado el proyecto con sus archivos iniciales nos vamos a agregar la referencia para trabajar con nuestra KINECT

Ok hasta este punto ahora vamos a nuestro código XAML de nuestra aplicación e insertamos dos controles de imagen dentro del Grid inicial donde la primera le llamaremos VideoImage y a la otra DepthImage

Bien ahora vamos a lo que en realidad tenemos que hacer, nos vamos al code behind de nuestro archivo MainPage.xaml y empezamos por lo siguiente agregando la Referencia con el siguiente código.

using Microsoft.Kinect;

ahora declaramos una variable de tipo KinectSensor que yo llamare sensor y dos variables una de tipo byte que llamare pixeldata y otra de tipo short que llamare pixel.

KinectSensor sensor = KinectSensor.KinectSensors[0];
byte[] pixelData;
short[] pixel;

Ahora debemos de habilitar las camaras con estas dos rutinas, uno para la cámara de RGB y la otra para la cámara de profundidad (DEPTH),  debemos de indicar al Kinect que vamos a utilizar en este caso las dos camaras antes mencionadas.

public partial class MainWindow : Window
{
      KinectSensor sensor = KinectSensor.KinectSensors[0];
      byte[] pixelData;
      short[] pixel;

      public MainWindow()
      {
             InitializeComponent();
             sensor.ColorStream.Enable();
             sensor.DepthStream.Enable();
          
      }
}

“Vamos bien ahí”… bueno ahora necesitamos indicar tanto iniciar el KINECT al correr la aplicación y cuando cerremos la aplicación con estas dos sencillas rutinas Start() y Stop()… (“sencillo no!?”) y en la sección del método Window_Loaded vamos a crear dos eventos ruteados dentro de la variable sensor que yo llame que contiene toda la información del dispositivo que son ColorFrameReady y DepthFrameReady.

private void Window_Loaded(object sender, RoutedEventArgs e)
{
   sensor.ColorFrameReady += new EventHandler<ColorImageFrameReadyEventArgs>(sensor_ColorFrameReady);
   sensor.DepthFrameReady += new EventHandler<DepthImageFrameReadyEventArgs>(sensor_DepthFrameReady);

   sensor.Start();
}

private void Window_Closing(object sender, System.ComponentModel.CancelEventArgs e)
{
   sensor.Stop();
}

Bien ya creamos los objetos, tenemos las librerías de Kinect, inicializamos y cerramos nuestro dispositivo ahora bien falta capturar lo que nos llega de las dos camaras y guardarlas en una variable y mostrarlas en nuestra aplicación para poder empezar a trabajar en nuestro KINECT ahora vamos al método sensor_ColorFrameReady y colocamos el siguiente código.

void sensor_ColorFrameReady(object sender, ColorImageFrameReadyEventArgs e)
{
  bool receivedData = false;

  using (ColorImageFrame CFrame = e.OpenColorImageFrame())
  {
     if (CFrame == null)
     {
     }
     else
     {
     pixelData = new byte[CFrame.PixelDataLength];
     CFrame.CopyPixelDataTo(pixelData);
     receivedData = true;
     }
   }

   if (receivedData)
   {
     BitmapSource source = BitmapSource.Create(640, 480, 96, 96,
     PixelFormats.Bgr32, null, pixelData, 640 * 4);

     VideoImage.Source = source;
   }
      
 }

En el código que acabo de colocar creamos una variable de tipo boleana para detectar mediante una condición para capturar lo que nos arroja la cámara copiando los datos de lo que nos contiene CFrame y después volvemos a preguntar por nuestra variable boleana y de ser verdadero procede a crear un BitmapSource en el cual abrimos dándole los parámetros que demuestro en el código, detenerme a explicar los parámetros no son necesarios por ahora para este tutorial rapido pero en mi primer tutorial son los mismos parámetros que describi y explique, la novedad en esa función es que se pueden jugar ahora con valores superiores o inferiores en escalas proporcionales a la que colocamos por default que es 640 x 480.

Entonces bien ahora vamos a la siguiente cámara que es la de profundidad dando este codigo

void sensor_DepthFrameReady(object sender, DepthImageFrameReadyEventArgs e)
        {
            bool receivedData = false;

            using (DepthImageFrame CFrame = e.OpenDepthImageFrame())
            {
                if (CFrame == null)
                {
                }
                else
                {
                    pixel = new short[CFrame.PixelDataLength];
                    CFrame.CopyPixelDataTo(pixel);
                    receivedData = true;
                }
            }

            if (receivedData)
            {
                BitmapSource source = BitmapSource.Create(320, 240, 96, 96,
                        PixelFormats.Gray16, null, pixel, 320 * 4);

                DepthImage.Source = source;
            }
        }

Es el mismo tratamiento que explique en el método anterior pero lo que cambia es el formato de Pixeles y le colocamos Gray16 (PixelFormats.Gray16) y cambiamos la resolución a 320 x 240 claro también podemos colocarle la resolución de la otra cámara 640 x 480

Ahora corremos nuestra aplicación y tenemos las 2 camaras, tanto la de profundidad  como la RGB funcionando y habilitadas para trabajar con nuestra KINECT, es importante destacar que estos son los métodos básicos para tener  en funcionamiento estas 2 camaras, ya el resto queda de parte de nuestra creatividad

Estoy trabajando actualmente en el siguiente Tutorial para reconocimiento del personaje y de las librerías Skeleton para hacer infinidades de cosas con nuestro KINECT.

Salu2

Skeletons?… el desarrollo de una interfaz verdaderamente natural..

Hola una vez mas estoy aca para explicarles a fondo sobre las funciones y nociones basicas para poder desarrollar aplicaciones con este gran dispositivo de interfaz natural de usuario NUI KINECT.

Esta vez hablaremos acerca de Skeletons de una manera teorica, luego posteare un Tutorial basico de trabajo con estas funciones para reconocimiento de personas en una aplicacion…

Entonces veamos un poco que es Skeletons?… Son funciones que nos definen un patron de la anatomia del cuerpo humano reconocido a travez del KINECT para ser colocado dentro las aplicaciones a traves de la libreria de datos dinamica MICROSOFT.KINECT en su version 1.5 al ser esta la mas ultima liberada por Microsoft.Bien para una gran resumen veamos el siguiente grafico..

Joints: de forma mas española es la definicion de coyunturas o extremidades que son partes del cuerpo humano que unen sus extremidades, es esto la base de nuestra definicion de Skeletons en la SDK de KINECT, en la grafica se muestran cada una de sus Joints

Entonces bien esta nueva SDK nos ofrece 2 nuevas funciones añadidas tales como:
Modo de seguimiento del esqueleto en forma sentada
Proporciona la capacidad de rastrear el cuerpo de los usuarios superior (10 Joints), y dan a la parte inferior del cuerpo si no son visibles o relevantes para la aplicación. Además, permite la identificación de usuario cuando se sienta en un objeto de silla, sillón o de otro inanimado.
Mejorar el seguimiento del esqueleto
En el rango cercano, los usuarios que están sentados o de pie, se puede seguir dentro de 40 cm (16 pulgadas) del sensor. Además, el motor de seguimiento del esqueleto es ahora más rápido, hacer un mejor uso de la CPU y la ampliación de los recursos informáticos. Además, la información que acaba de agregar la orientación conjunta de los esqueletos es ideal para escenarios de animación Avatar y la detección sencilla postura.

En el siguiente post empezaremos desde cero con una aplicacion Skeletons para KINECT de una forma bien explicada y portable que podras usar en todas tus nuevas aplicaciones..

Salu2

Web Camps de Microsoft para este año…





Los Web Camps de Microsoft de 1 solo dia son una versión más pequeña de los eventos más grandes que son normalmente de 2 días.



Estos Web Camps te permiten
aprender y construir sitios web con ASP.NET, MVC, WebMatrix, OData y mucho más. Estos eventos cubrirá 1 de los 3 temas e incluirá presentaciones y el manejo del desarrollo de estas tecnologias. Más eventos vienen y se añadirá a la lista de abajo tan pronto como las fechas se confirman.

Esta es la lista de los países adicional que será el anfitrión de los campos de Web de este año: Argentina, Bélgica, Brasil, Canadá, Chile, Finlandia, Indonesia, Israel, Países Bajos, Nueva Zelanda, Noruega, Portugal, España, Tailandia, Turquía, Emiratos Árabes Unidos, el Reino Unido y los EE.UU. Este y Central.

para mas informacion siguelos en Twitter @Webcamps

Ciudad Pais
Fecha Tecnologia Link Registro

Caracas Venezuela 25-Jan-11 ASP.Net MVC Register Here
Maracaibo Venezuela 26-Jan-11 ASP.Net MVC Register Here
Porlamar Venezuela 28-Jan-11 ASP.Net MVC Register Here
Tunis Tunisia 1-Feb-11 ASP.Net MVC Register Here
Istanbul Turkey 1-Feb-11 WebMatrix Register Here
Montreal Canada 5-Feb-11 ASP.Net MVC Register Here
Calgary Canada 5-Feb-11 ASP.Net MVC Register Here
Jeddah Saudi Arabia 15-Feb-11 WebMatrix Register Here
Jeddah Saudi Arabia 16-Feb-11 WebMatrix Register Here
Toronto Canada 19-Feb-11 ASP.Net MVC Register Here
Riyadh Saudi Arabia 22-Feb-11 WebMatrix Register Here
Riyadh Saudi Arabia 23-Feb-11 WebMatrix Register Here
Mountain View, CA USA 26-Feb-11 ASP.Net MVC Register Here
Des Moines, IA USA 17-Mar-11 WebMatrix Register Here
Bad Homburg Germany 23-Mar-11 WebMatrix Register Here
Redmond USA 25-Mar-11 ASP.Net MVC Register Here
Ottawa Canada 26-Mar-11 ASP.Net MVC Register Here
Munich Germany 31-Mar-11 WebMatrix Register Here
Moulineaux France 5-Apr-11 TBA Register Here
Nashville, TN USA 27-Apr-11 WebMatrix Register Here
Columbus, OH USA 29-Apr-11 WebMatrix Register Here
Dallas, TX USA 16-May-11 WebMatrix Register Here
Moulineaux France 17-May-11 TBA Register Here
Little Rock, AR USA 18-May-11 WebMatrix Register Here
St. Louis, MO USA 20-May-11 WebMatrix Register Here
Minneapolis, MN USA 24-May-11 WebMatrix Register Here
Milwaukee, WI USA 25-May-11 WebMatrix Register Here
Southfield, MI USA 2-Jun-11 WebMatrix Register Here
Tulsa, OK USA 2-Jun-11 WebMatrix Register Here
Irvine, CA USA 10-Jun-11 ASP.NET MVC Muy Pronto
Moulineaux France 14-Jun-11 TBA Register Here

Por otro lado Proximamente se celebrara en un WebCamps en Porlamar donde estare presente y mi compañero de trabajo @ernesth tendra una gran y exelente ponencia sobre Jquery donde veremos el poder de esta tecnologia en la web….vamos ernesto esperamos una gran charla y buena vibra con este gran tema…

Nos vemos en el WebCamps el 28 de enero muchachos… 😀

El Futuro de Silverlight – Silvelight5

Como bien saben, Silverlight es la plataforma estratégica de Microsoft para desarrollar aplicaciones interactivas a través del escritorio (desktop), el teléfono y el browser. Es por lo anterior, que este producto es de suma importancia para la comunidad de desarrolladores, entusiastas y estudiantes del mundo tecnológico ya que en su siguiente versión incluirá aspectos realmente importantes.

En esta ocasión, se detallaron grandes temas en el ambito del desarrollo en Silverlight y el gran anuncio de Silverlight 5 con su primera version beta que sera liberada para la primavera y la version oficial para Octubre del proximo año,

Llamado Silverlight Firestarter! que tuvo lugar en la ciudad de Redmond Washington pero que se transmitio en vivo para todo el mundo con 3:30 horas de diferencia aca en Venezuela y para el mundo respectivamente. En esta ocasión la conferencia magistral o mundialmente conocido como Key Note, fue impartido por Scott Guthrie quien hablo del futuro de esta importante plataforma y la forma en que le permite a los desarrolladores integrar las diversas pantallas por la que las personas pasan horas conectados a la tecnología, de forma eficiente, dinámica y con una grandiosa experiencia de usuario.

El evento incluyo entrenamientos y laboratorios a través de videos, así como un panel de preguntas y respuestas que se enviaron y fueron contestadas por el equipo de producto de Silverlight en el evento.

¡Un evento para todos!

No importa que no sepas qué es Silverlight, ya que esta es una gran oportunidad de aprender, a través de las sesión general y los laboratorios de entrenamiento que serán impartidos a diversos niveles.

Si ya construyes aplicaciones en Silverlight y conoces de esta gran tecnología, aprenderás lo más nuevo y vanguardista del producto así como el futuro de esta plataforma para comenzar a crear aplicaciones tanto de consumo como de negocio que vayan apagadas a lo más actualizado y funcional para brindar una experiencia de usuario inigualable.

Compartire con ustedes lo que fue la agenda del evento. Una gran oportunidad de aprovechar la tecnología, maximizar los recursos desde el hogar o la oficina y aprender de lo último en tecnología de desarrollo

Todavia puedes ver algunos webcast y videos del evento: http://www.silverlight.net/news/events/firestarter/

Agenda Firestarter Live

Hora Ponente Detalles de la sessión
8:00 am Desayuno
9:00 am Scott Guthrie Scott Guthrie El futuro de Silverlight
10:45 am Jesse Liberty Jesse Liberty Estrategias de Data Binding con Silverlight y WP7
11:30 am Yavor Georgiev Yavor Georgiev Construcción de aplicaciones utilizando REST con WCF y LINQ
12:15 pm Almuerzo
1:00 pm Dan Wahlin Dan Wahlin Construccion de aplicaciones de negocios ricas en caracteristicas de hoy con RIA Services
1:45 pm John Papa John Papa MVVM: Porque y Como? Tips and Patrones usando MVVM y Patrones de servicio con Silverlight WP7
2:45 pm Tim Heuer Tim Heuer Tips and Trucos para una Grandiosa Experiencia de Instalacion
3:30 pm Scott Guthrie Mike Cook &
Jossef Goldberg
Optimización de sus Aplicaciones: Perfiles y Tips de Rendimiento
4:30 pm Jaime Rodriguez Jaime Rodriguez Tips de rendimiento para Silverlight en Windows Phone 7
5:15 pm Fiesta despues del evento!