El Bruno

Buenas.

Soy una persona que vive al límite, intento que cada minuto sea intenso por las dudas que sea el último (ya hay más de uno que se quiere encargar de esto); y es por esto que cuando saco un drive usb lo hago directamente tirando el cable, y utilizo Windows 8 como mi SO de trabajo del día a día.

Algunas personas cuando van a dar una evaluación de un producto, se bajan una beta, la prueban 5 minutos y comienzan a opinar sobre la misma. En el caso de Windows 8 yo he decidido utilizarlo como SO durante los últimos meses y la verdad es que estoy bastante contento.

Más allá de detalles como que no me funciona la VPN de Avanade, que Instalar Team Foundation Server 2010 es un infierno; Windows 8 va muy bien. Pero hace unos días me encontré con que las herramientas de desarrollo para Windows Phone no funcionan en Windows 8.

Así que después de preguntar a Josue y en los foros de MSDN, llegué al post del gran Jorge Serrano, donde comentaba como instalar las mismas en Windows Server 2008. Seguí sus pasos teniendo en cuenta de que Windows 8 Developer Preview se presenta a si mismo como un server (chan!!!) pues tuve un resultado bastante satisfactorio. Por un lado pude instalar las herramientas de desarrollo, e inclusive activar mi licencia de desarrollo en mi Windows Phone.

Pero luego con el emulador no tuve tanta suerte. En primer lugar desde Visual Studio 2010 no es posible lanzar el mismo:

y si por algún motivo se te ocurre hacer la inteligente opción de cambiar el modo de compatibilidad para que lo ejecute en modo Windows 7

pues te encuentras con uno de los smiles que espero que no se haga famoso en el futuro próximo

Pero bueno, la gran solución consiste en pasar del emulador y trabajar directamente con el dispositivo …

Y en este punto volvemos al punto 1.

Los que vivimos la vida al límite

• sacamos los pen drives de forma insegura tirando del cable
• utilizamos Windows 8 como nuestro SO para el día a día
• no utilizamos el emulador para las pruebas con Windows Phone, desplegamos y probamos directamente en el dispositivo

Saludos @ Here

El Bruno

Referencias:

http://geeks.ms/blogs/jorge/archive/2011/06/18/instalando-las-windows-phone-developer-tools-en-windows-2008.aspx

http://social.msdn.microsoft.com/Forums/es-ES/windowsphone7/thread/8e75b24c-3ec9-499c-92e5-a4d42c038f35

Buenas,

aquellos que estén utilizando Windows 8, seguramente estarán hasta las narices de que todos los links se abran en el Internet Explorer 10 de la interfaz metro. Esto se soluciona con 2 clicks, y por eso me apunto el post para cuando instale el nuevo preview

1. Abrir Internet Explorer en modo metro

2. Presionar Windows + I, para acceder a las settings de IE10

3. En este punto nos aparece una opción para abrir los links por defecto en Internet Explorer en Desktop

4. A partir de este momento todos los links se abrirán en el IE10 de nuestro Windows de toda la vida.

Saludos @ Home

El Bruno

Buenas,

hoy hago un repoll de una noticia que más de unos seguramente ya habrá leído por alli: en el 2012 tendremos un Kinect especial para PC.

Entre las novedades que se comentan sobre este nuevo Kinect, lo primero que llama la atención es que tendrá una conexión directa USB para PC. Pero tal vez lo más interesante es que el espacio de trabajo requerido del mismo, será mucho menor que con el sensor actual (bajaremos de los 2 metros promedio), inclusive hablan de reconocimiento de objetos a 40 cms

Bueno … poco no es y los que estamos desarrollando aplicaciones con Kinect, esperamos tener pronto una beta del Hardware para probar el mismo (hasta aquí puedo decir !!!)

Saludos @ Home

El Bruno

Fuente: http://blogs.msdn.com/b/kinectforwindows/archive/2011/11/22/kinect-for-windows-building-the-future.aspx

Buenas,

hace un par de días el amigo Víctor me comentó que estaba por comenzar un proyecto desde cero, así que sentamos las bases mínimas de colaboración y calidad para el mismo. Si comienzas un proyecto desde cero, donde trabajen diferentes personas en modo desconectado, es recomendable aplicar una serie de normas que ayuden a que “las reglas del juego sean las mismas para todos”. En el caso del estilo de codificación, pues StyleCop es un excelente aliado para esto. Además, en Avanade Spain tenemos una plantilla extendida de compilación que entre otras cosas aplica las reglas de StyleCop a una ejecución de Team Build e indica que nivel de calidad estética tiene nuestro código (si quieres más info al respecto hablamos porque la plantilla hace muchas cosas que no viene Out Of the Box con TFS2010).

Pero vuelvo que me disperso, desde que comencé a trabajar con Windows 8 no había instalado el plugin de StyleCop en mi entorno de trabajo. Así que para demostrarle las capacidades de StyleCop a Victor, me descargué la última versión y me llevé una gran sorpresa > esta versión esta 100% INTEGRADA CON RESHARPER 6.0. Vamos que se adapta como un plugin para ReSharper y a partir de aquí te encuentras con el análisis en tiempo de codificación de las reglas de StyleCop.

Obviamente, que para gustos > colores, y que no creo que todas las reglas deban aplicarse en todos los casos. Pero es agradable ver que por ejemplo, ahora los [this.] son obligatorios según StyleCop (ReSharper los aborrecía), y que todo tu código seguramente no cumplirá las reglas básicas. Sobre una WCF Application creada desde cero, la lista de errores es bastante larga.

Pero no desesperes, que siempre tienes la opción de definir el comportamiento deseado para cada una de las reglas. Por ejemplo, si no crees en la documentación (ni tampoco en los reyes magos), pues puedes desactivar esta regla en particular para que se comporte como un Hint, por ejemplo.

O inclusive en las opciones generales de inspección de código de ReSharper, puedes definir las acciones a tomar para cada una de las reglas de StyleCop.

Si me preguntas a mi qué me parece, pues te diré que me parece genial

Saludos @ Here

El Bruno

Buenas,

después del pequeño post que escribí hace 2 días [#KINECT] HowTo: Mostrar el contenido del depth sensor en nuestras aplicaciones, hoy veremos un poco más el detalle o las tripas de este mecanismo. Así como el visor de la cámara simplemente es mapa de valores RGB que convertimos a una imagen y luego mostramos con un IMAGE de WPF, la información que nos da el sensor de profundidad es una colección de distancias que luego "pintamos” en nuestra aplicación.

El rango de distancias que maneja Kinect va desde los 0,85 metros hasta los 4 metros; y la información que nos provee el sensor de profundidad es en milímetros. Si analizamos el código del ejemplo del post, veremos que durante el procesamiento del evento DepthFrameReady() del sensor, trabajamos con un objeto del tipo PlanarImage (línea 3). En este caso el array de pixels que nos retorna el sensor contiene 2 bytes por cada pixels. Cada uno de estos bytes nos determina la distancia a cada una de las cámaras que utiliza el sensor.

   1: void KinectDepthFrameReady(object sender, ImageFrameReadyEventArgs e)

   2: {

   3:     var planarImage = e.ImageFrame.Image;

   4:     var depthImageHelper = new DepthImageHelper();

   5:     byte[] convertedDepthBits = 

   6:            depthImageHelper.ConvertDepthFrame(planarImage.Bits, RuntimeOptions);

   7:     if (this.imageHelper == null)

   8:     {

   9:         this.imageHelper = new InteropBitmapHelper(planarImage.Width, 

  10:                                                    planarImage.Height, 

  11:                                                    convertedDepthBits);

  12:         this.DepthSensorViewer.Source = this.imageHelper.InteropBitmap;

  13:     }

  14:     else

  15:     {

  16:         this.imageHelper.UpdateBits(convertedDepthBits);

  17:     }

  18: }

Adicionalmente, si inicializamos el sensor con la opción [DepthAndPlayerIndex], el array de información contendrá 3 bytes donde el 3er byte corresponde a un player específico reconocido por el sensor.

Para identificar el valor real de la profundidad de cada elemento del array, tenemos que verificar si el sensor se inicializó con la opción [Depth], o con [DepthAndPlayerIndex]. En el ejemplo del post, lo hacemos a partir de un simple cálculo teniendo en cuenta si trabajamos con 3 o 2 bytes. En este caso depthFrame es un array de bytes que luego convertimos a una imagen utilizando la clase InteropBitmapHelper que vimos en el post anterior.

   1: var hasPlayerData = runtimeOptions.HasFlag(RuntimeOptions.UseDepthAndPlayerIndex);

   2: for (int i16 = 0, i32 = 0; i16 < depthFrame16.Length && i32 < depthFrame32.Length; i16 += 2, i32 += 4)

   3: {

   4:     var player = hasPlayerData ? depthFrame16[i16] & 0x07 : -1;

   5:     int realDepth;

   6:  

   7:     if (hasPlayerData)

   8:     {

   9:         realDepth = (depthFrame16[i16 + 1] << 5) | (depthFrame16[i16] >> 3);

  10:     }

  11:     else

  12:     {

  13:         realDepth = (depthFrame16[i16 + 1] << 8) | (depthFrame16[i16]);

  14:     }

  15:  

  16:     // transform 13-bit depth information into an 8-bit intensity appropriate

  17:     // for display (we disregard information in most significant bit)

  18:     var intensity = (byte)(255 - (255 * realDepth / 0x0fff));

  19:  

  20:     depthFrame32[i32 + RedIndex] = 0;

  21:     depthFrame32[i32 + GreenIndex] = 0;

  22:     depthFrame32[i32 + BlueIndex] = 0;

La gran carencia en este punto, es poder lograr conocer la profundidad de un Joint o de un elemento del Skeleton para poder tener acceso a gesturas como Push o Pull.

Lamentablemente eso no viene de fábrica en la Beta 2 del SDK de Kinect, pero …. tampoco es tan complicado no?

En el próximo post de Kinect lo solucionamos con 4 líneas de código (eso si el Victor me devuelve el Kinect!!!!)

Saludos @ Home

El Bruno

PD: he terminado de escribir el post, pero veo que en los retos de MSDN lo explican muy pero muy bien !!! http://blogs.msdn.com/b/esmsdn/archive/2011/07/20/reto-kinect-usar-las-c-225-maras-del-sensor.aspx

Buenas,

si bien hace un par de semanas que ha salido al mercado, recién ahora tengo tiempo para hacerme un poco de autobombo y promocionar mi nuevo libro sobre trabajo en equipo con Visual Studio ALM. Otra vez me he aprovechado de la gente de CampusMVP para que sean los que publiquen el librako, aunque esta vez es un libro 100% diferente del anterior. En mi anterior libro “Visual Studio 2010, .NET 4.0 y ALM”  hice un recorrido por muchas de las novedades de esta versión de Visual Studio y de .NET Framework. Tenía a mi favor un nuevo lenguaje que comentar F# (que a lo tonto ya va por su versión 3.0), un nuevo IDE, nuevas herramientas, etc.

Ahora el enfoque es diferente. Después de trabajar más de 6 años con Visual Studio + Team Foundation, decidí plasmar en un libro mis experiencias al respecto. En este libro doy un repaso por al ABC de las bases de un proyecto de software: gestión de código fuente, gestión del trabajo y gestión de la calidad. Es increíble la cantidad de proyectos de software que suelen fallar por tener problemas en alguno de estos pilares; y es por eso que comento algunas experiencias y sugerencias al respecto.

¡Cuidado! doy por sentado que si te sientas frente a este libro (o lo lees de pie en el metro) conocerás herramientas de ALM y conceptos de AGILE, SCRUM, etc. Inclusive puedes llevar adelante todos los ejemplos y sugerencias sin las herramientas de Visual Studio ALM (aunque no creo que nadie lo haga).

Resumiendo, es un libro de experiencias personales y sugerencias sobre como llevar adelante un proyecto de software trabajando en equipo.

Si quieres darle un vistazo  las primeras 27 páginas, donde verás un poco de historias de vampiros y merge, puedes hacerlo desde http://es.scribd.com/doc/71555650/Trabajo-en-equipo-con-Visual-Studio-ALM-Bruno-Capuano-Krasis-Press-Indice

Shop: http://www.campusmvp.com/catalogo/Product-Trabajando-en-equipo-con-Visual-Studio-ALM_145.aspx

Saludos @ Home

El Bruno

PD: todo el dinero recaudado del libro va a una cuenta bancaria del Valentino y la Martina. Mis enanos agradecidos

Buenas,

como parte del programa Bizspark, con el que Microsoft ayuda a las empresas a desarrollar con sus productos, ahora Microsoft realiza un pequeño concurso para ayudar a 10 empresas que quieran desarrollar aplicaciones con Kinect. Si eres uno de los 10 elegidos, podrás pasar 3 meses en el campus de Redmond de Microsoft trabajando codo a codo con expertos en el tema, además de U$S 20000, el kit de desarrollo de Kinect, y otras cosillas más. Si quieres ver más detalles, los puedes consultar en http://www.microsoft.com/bizspark/kinectaccelerator/

Y obviamente, yo ya me he apuntado.

Saludos @ Home

El Bruno

Fuentes:

• http://www.microsoft.com/bizspark/kinectaccelerator/
• http://news.idg.no/cw/art.cfm?id=3E6DE51B-A5F5-C72C-B444BABF3380B7F0

Buenas,

hoy toca modificar un poco el código de la aplicación que muestra el contenido de la cámara web de Kinect para mostrar en este caso, la imagen procesada del Depth Sensor de Kinect en una aplicación WPF. La imagen que nos entrega el Depth Sensor es el resultado del proceso de la información que retorna el sensor infrarojo que posee Kinect junto con la imagen de la cámara de Kinect. Con estos 2 elementos (y un par de cosillas más) Kinect consigue armar un modelo con cierta profundidad que es el que nos entrega el Depth Sensor.

La gran diferencia con el post anterior es que en este caso trabajaremos con el evento DepthFrameReady() (línea 42) que es el que nos entregará la imagen procesada del DepthSensor. A partir de este momento, trabajamos con una clase externa DepthImageHelper() para procesar la imagen del sensor en un formato compatible con un IMAGE.

   1: namespace ElBruno.KinectViewer

   2: {

   3:     using System.Windows;

   4:     using Microsoft.Research.Kinect.Nui;

   5:  

   6:     /// <summary>

   7:     /// Interaction logic for MainWindow.xaml

   8:     /// </summary>

   9:     public partial class MainWindow

  10:     {

  11:         private Runtime kinect;

  12:         private InteropBitmapHelper imageHelper;

  13:         private RuntimeOptions RuntimeOptions { get; set; }

  14:         

  15:         public MainWindow()

  16:         {

  17:             InitializeComponent();

  18:             Loaded += MainWindowLoaded;

  19:         }

  20:  

  21:         void MainWindowLoaded(object sender, RoutedEventArgs e)

  22:         {

  23:             InitKinect();

  24:         }

  25:  

  26:         void InitKinect()

  27:         {

  28:             if (Runtime.Kinects.Count == 0)

  29:                 return;

  30:             kinect = Runtime.Kinects[0];

  31:             RuntimeOptions = RuntimeOptions.UseDepthAndPlayerIndex | 

  32:                 RuntimeOptions.UseSkeletalTracking | 

  33:                 RuntimeOptions.UseColor;

  34:             kinect.Initialize(RuntimeOptions);

  35:             kinect.DepthStream.Open(ImageStreamType.Depth, 2, ImageResolution.Resolution320x240,

  36:                 RuntimeOptions.HasFlag(RuntimeOptions.UseDepthAndPlayerIndex) || 

  37:                 RuntimeOptions.HasFlag(RuntimeOptions.UseSkeletalTracking) ? 

  38:                 ImageType.DepthAndPlayerIndex : ImageType.Depth);

  39:             kinect.DepthFrameReady += this.KinectDepthFrameReady;

  40:         }

  41:  

  42:         void KinectDepthFrameReady(object sender, ImageFrameReadyEventArgs e)

  43:         {

  44:             var planarImage = e.ImageFrame.Image;

  45:             var depthImageHelper = new DepthImageHelper();

  46:             byte[] convertedDepthBits = depthImageHelper.ConvertDepthFrame(planarImage.Bits, RuntimeOptions);

  47:  

  48:             if (this.imageHelper == null)

  49:             {

  50:                 this.imageHelper = new InteropBitmapHelper(planarImage.Width, planarImage.Height, convertedDepthBits);

  51:                 this.DepthSensorViewer.Source = this.imageHelper.InteropBitmap;

  52:             }

  53:             else

  54:             {

  55:                 this.imageHelper.UpdateBits(convertedDepthBits);

  56:             }

  57:         }

  58:     }

  59: }

Si ejecutamos la aplicación podremos ver el resultado del DepthSensor similar a la siguiente imagen.

El código del ejemplo lo pueden descargar desde

Saludos @ Here

El Bruno

Fuente: http://en.wikipedia.org/wiki/Kinect

Buenas,

en el post de hoy vamos a mover el ángulo del sensor hacia arriba o hacia abajo utilizando las APIs del SDK.

Inicialmente es posible mover la cámara hacia arriba o hacia abajo unos 27º, y para probarlos vamos a partir del ejemplo del día de ayer.

1. Modificamos nuestra aplicación para que nos permita definir el ángulo de inclinación del Kinect utilizando una caja de texto y un botón.

2. El Xaml queda como el siguiente ejemplo

   1: <Window x:Class="ElBruno.KinectViewer.MainWindow"

   2:         xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"

   3:         xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"

   4:         Title="El Bruno - Kinect Viewer" Height="480" Width="740">

   5:     <Grid>

   6:         <Grid.RowDefinitions>

   7:             <RowDefinition Height="40"></RowDefinition>

   8:             <RowDefinition Height="*"></RowDefinition>

   9:             <RowDefinition Height="40"></RowDefinition>

  10:         </Grid.RowDefinitions>

  11:         <TextBlock Text="Camera Viewer" FontSize="20" HorizontalAlignment="Center" 

  12:                    Foreground="Black" Grid.Row="0" />

  13:         <Image x:Name="CameraViewer" Margin="10,10,10,10" 

  14:                Stretch="Fill" Grid.Row="1" />

  15:         <StackPanel Orientation="Horizontal" HorizontalAlignment="Center" Grid.Row="2" >

  16:             <TextBox x:Name="txtAngle" Text="0" FontSize="20" HorizontalAlignment="Center" Foreground="Black" />

  17:             <Button x:Name="SetCameraAngle" Click="SetCameraAngle_Click" Content="Set Camera Angle" />

  18:         </StackPanel>

  19:     </Grid>

  20: </Window>

3. Luego la implementación del evento click del botón es más bien simple

   1: private void SetCameraAngleClick(object sender, RoutedEventArgs e)

   2: {

   3:     _kinect.NuiCamera.ElevationAngle = Convert.ToInt32(txtAngle.Text);

   4: }

Hoy no pondré el ejemplo para descargar ya que es bastante simple de modificar. Y para mañana algo de Audio y Speech si el AVE me lo permite.

Saludos @ Here

El Bruno

Referencia: http://abhijitjana.net/2011/09/18/development-with-kinect-net-sdk-part-iii-adjusting-the-kinect-camera-angle/

Buenas,

después de mostrar como se pinta el Skeleton en Kinect aquí y aquí, hoy vamos a un ejemplo más simple (en lo que cabe) donde mostraremos el contenido de la cámara de Kinect en un IMAGE de WPF.

Tutorial

1. Crear un nuevo proyecto de tipo WPF Application en Visual Studio 2010.

2. Agregamos las siguientes referencias

• Microsoft.Research.Kinect
  <%Program Files%>\Microsoft SDKs\Kinect\v1.0 Beta2\Assemblies\Microsoft.Research.Kinect.dll

3. Modificamos la MainWindow para mostrar un título y un Image donde mostraremos el contenido de la cámara

   1: <Window x:Class="ElBruno.KinectViewer.MainWindow"

   2:         xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"

   3:         xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"

   4:         Title="El Bruno - Kinect Viewer" Height="480" Width="740">

   5:     <Grid>

   6:         <TextBlock Text="Camera Viewer" FontSize="20" 

   7:                     HorizontalAlignment="Center" Foreground="Black" />

   8:         <Image x:Name="CameraViewer" Margin="10,40,10,10" Stretch="Fill" />

   9:     </Grid>

  10: </Window>

4. A continuación inicializamos el runtime de Kinect (líneas 17 a 26), teniendo en cuenta que solo utilizaremos el feed de la cámara (línea 22). Además nos suscribimos al evento VideoFrameReady() que es el que nos entregará la información para procesarla y mostrarla en nuestro Image (línea 36).

   1: public partial class MainWindow

   2: {

   3:     private Runtime _kinect;

   4:     private InteropBitmapHelper _imageHelper;

   5:  

   6:     public MainWindow()

   7:     {

   8:         InitializeComponent();

   9:         Loaded += MainWindowLoaded;

  10:     }

  11:  

  12:     void MainWindowLoaded(object sender, RoutedEventArgs e)

  13:     {

  14:         InitKinect();

  15:     }

  16:  

  17:     void InitKinect()

  18:     {

  19:         if (Runtime.Kinects.Count == 0)

  20:             return;

  21:         _kinect = Runtime.Kinects[0];

  22:         _kinect.Initialize(RuntimeOptions.UseColor);

  23:         _kinect.VideoStream.Open(ImageStreamType.Video, 2, 

  24:                                  ImageResolution.Resolution640x480, ImageType.Color);

  25:         _kinect.VideoFrameReady += KinectVideoFrameReady;

  26:     }

  27:  

  28:     void KinectVideoFrameReady(object sender, ImageFrameReadyEventArgs e)

  29:     {

  30:         var planarImage = e.ImageFrame.Image;

  31:         if (_imageHelper == null)

  32:         {

  33:             _imageHelper = new InteropBitmapHelper(planarImage.Width, 

  34:                                                    planarImage.Height, 

  35:                                                    planarImage.Bits);

  36:             CameraViewer.Source = _imageHelper.InteropBitmap;

  37:         }

  38:         else

  39:         {

  40:             _imageHelper.UpdateBits(planarImage.Bits);

  41:         }   

  42:     }

  43: }

5. En este ejemplo estoy utilizando una clase distribuida con el SDK de Kinect, InteropBitmapHelper que nos ayuda a trabajar de una forma más efectiva con las imágenes.

6. Una vez terminado el proyecto, ya podemos ejecutar el mismo y podremos ver el feed de la cámara del sensor Kinect

Nota: ya lo sé, la tableta, un HP TouchSmart, 2 portátiles, etc. demasiado para un domingo …

Puedes descargar el ejemplo desde

Saludos @ Home

El Bruno

Buenas,

después del post de ayer donde mostré como pintar en un Canvas un skeleton a partir de los datos que nos brinda Kinect, me han llegado un par de preguntas donde me preguntan como pintar 2 skeletons.

Pues bien para lograr algo similar a las siguientes imágenes, lo único que debemos modificar sobre el código de ayer es la rutina donde Kinect nos indica que ha detectado un Skeleton. En esta rutina nos encargábamos de pintar el mismo, pues bien ahora lo hacemos así:

   1: void KinectSkeletonFrameReady(object sender, SkeletonFrameReadyEventArgs e)

   2: {

   3:     var skeletonId = 0;

   4:     Skeleton.Children.Clear();

   5:     foreach (var skeleton in e.SkeletonFrame.Skeletons.Where

   6:              (skeleton => 

   7:                        SkeletonTrackingState.Tracked == skeleton.TrackingState))

   8:     {

   9:         PaintBones(skeleton, KinectCanvas.SkeletonColors[skeletonId]);

  10:         PaintJoints(skeleton);

  11:         skeletonId++;

  12:     }

  13: }

La gran diferencia está en que para cada Skeleton importamos un color estático desde un diccionario. Amarillo y verde para mi gusto.

   1: public static Dictionary<int, Color> SkeletonColors 

   2:         = new Dictionary<int, Color>

   3:           {

   4:             {0, Colors.Yellow},

   5:             {1, Colors.Green}

   6:           };

En este punto ya podremos tener un skeleton tracker que nos ayude a mostrar una pose estática:

O un salto de a 2.

Detalle interesante, en las imágenes anteriores podemos ver como el Valentino me llega hasta las rodillas y los puntos del Skeleton así lo demuestran.

El ejemplo para descargar desde

Saludos @ Home

El Bruno

Buenas,

Hoy toca cerrar el viernes con un tutorial de los interesantes > como pintar un skeleton en WPF utilizando la Beta 2 del Kinect for Windows SDK. La base de un skeleton en Kinect es una colección de Joints con los que luego podemos “armar el skeleton”. Además es posible armar y pintar más de un skeleton, para este ejemplo, pues solo pintamos el skeleton[0] en amarillo.

Tutorial

1. Crear un nuevo proyecto de tipo WPF Application en Visual Studio 2010.

2. Agregamos las siguientes referencias

• Microsoft.Research.Kinect
  <%Program Files%>\Microsoft SDKs\Kinect\v1.0 Beta2\Assemblies\Microsoft.Research.Kinect.dll

3. Modificamos la MainWindow para mostrar un título y un Canvas donde mostraremos el skeleton

   1: <Window x:Class="ElBruno.KinectSkeleton01.MainWindow"

   2:         xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"

   3:         xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"

   4:         Title="MainWindow" Height="480" Width="360">

   5:     <Grid>

   6:         <TextBlock Text="El Bruno - Skeleton Viewer" 

   7:                    FontSize="20" HorizontalAlignment="Center" />

   8:         <Canvas x:Name="Skeleton" Margin="10,40,10,10" 

   9:                 Background="Black" />

  10:     </Grid>

  11: </Window>

La ventana queda similar a la siguiente

4. Agregamos un manejador para el evento Load() de la Window. Además agregamos un runtime para trabajar contra el Kinect e inicializamos el mismo con las opciones básicas de trabajo.

   1: private Runtime _kinect;

   2:  

   3: public MainWindow()

   4: {

   5:     InitializeComponent();

   6:     Loaded += MainWindowLoaded;

   7: }

   8:  

   9: void MainWindowLoaded(object sender, RoutedEventArgs e)

  10: {

  11:     InitKinect();

  12: }

  13:  

  14: void InitKinect()

  15: {

  16:     if (Runtime.Kinects.Count == 0)

  17:         return;

  18:  

  19:     _kinect = Runtime.Kinects[0];

  20:     _kinect.Initialize(RuntimeOptions.UseDepthAndPlayerIndex | 

  21:       RuntimeOptions.UseSkeletalTracking | RuntimeOptions.UseColor);

  22:  

  23:         _kinect.VideoStream.Open(ImageStreamType.Video, 2, 

  24:                 ImageResolution.Resolution640x480, ImageType.Color);

  25:         _kinect.DepthStream.Open(ImageStreamType.Depth, 2, 

  26:                 ImageResolution.Resolution320x240, ImageType.DepthAndPlayerIndex);

  27:     _kinect.SkeletonFrameReady += KinectSkeletonFrameReady;

  28: }

En este ejemplo no he puesto ningún tipo de gestión de excepciones, trabajando con una Beta deberíamos agregar algo después.

5. A continuación sólo nos queda pintar nuestro esqueleto en Kinect. Para esto utilizaremos la colección de Joints que nos retorna el Runtime y en el evento KinectSkeletonFrameReady pintaremos los Joints y los Bones que unen los mismos.

   1: void KinectSkeletonFrameReady(object sender, SkeletonFrameReadyEventArgs e)

   2: {

   3:     foreach (var skeleton in 

   4:              e.SkeletonFrame.Skeletons.Where

   5:             (skeleton => 

   6:                       SkeletonTrackingState.Tracked == skeleton.TrackingState))

   7:     {

   8:         Skeleton.Children.Clear();

   9:         PaintBones(skeleton);

  10:         PaintJoints(skeleton);

  11:     }

  12: }

6. Obviamente para que funcione la rutina anterior hace falta la implementación de PaintJoins y de PaintBones. Como pueden ver en el siguiente fragmento de código, es bastante simple ya que solo se recorren las colecciones y se pinta a partir de las mismas.

   1: private void PaintJoints(SkeletonData skeleton)

   2: {

   3:     foreach (Joint joint in skeleton.Joints)

   4:     {

   5:         var jointPos = _kinectCanvas.GetDisplayPosition(joint);

   6:         var jointLine = new Line

   7:                             {

   8:                                 X1 = jointPos.X - 3

   9:                             };

  10:         jointLine.X2 = jointLine.X1 + 6;

  11:         jointLine.Y1 = jointLine.Y2 = jointPos.Y;

  12:         jointLine.Stroke = KinectCanvas.JointColors[joint.ID];

  13:         jointLine.StrokeThickness = 6;

  14:         Skeleton.Children.Add(jointLine);

  15:     }

  16: }

  17:  

  18: private void PaintBones(SkeletonData skeleton)

  19: {

  20:     var brush = new SolidColorBrush(Colors.Yellow);

  21:     Skeleton.Children.Add(_kinectCanvas.GetBodySegment

  22:         (skeleton.Joints, brush, JointID.HipCenter, 

  23:         JointID.Spine, JointID.ShoulderCenter, JointID.Head));

  24:     Skeleton.Children.Add(_kinectCanvas.GetBodySegment

  25:         (skeleton.Joints, brush, JointID.ShoulderCenter, 

  26:         JointID.ShoulderLeft, JointID.ElbowLeft, JointID.WristLeft, JointID.HandLeft));

  27:     Skeleton.Children.Add(_kinectCanvas.GetBodySegment

  28:         (skeleton.Joints, brush, JointID.ShoulderCenter,

  29:         JointID.ShoulderRight, JointID.ElbowRight, JointID.WristRight, JointID.HandRight));

  30:     Skeleton.Children.Add(_kinectCanvas.GetBodySegment

  31:         (skeleton.Joints, brush, JointID.HipCenter, JointID.HipLeft,

  32:         JointID.KneeLeft, JointID.AnkleLeft, JointID.FootLeft));

  33:     Skeleton.Children.Add(_kinectCanvas.GetBodySegment

  34:         (skeleton.Joints, brush, JointID.HipCenter, JointID.HipRight,

  35:         JointID.KneeRight, JointID.AnkleRight, JointID.FootRight));

  36: }

En el ejemplo completo pueden ver la clase KinectCanvas() que es la que posee las definiciones para convertir joints en points y bones en lineas.

7. Si ejecutamos la aplicación y somos rápidos para sacar un screenshot podremos algo similar a

El ejemplo completo se puede descargar desde

Saludos @ Here

El Bruno

Buenas,

mientras me sigo pegando con PowerShell (endemoniado lenguaje de scripting avanzado) me apunto sacar de los borradores un post. En esta ocasión el gran Brian Keller nos ayuda a los que solemos ir de presentación en presentación de productos en fase Beta.

En estas demos, es importante conocer el producto y “donde hacer click”, pero es casi más importante conocer “donde NO hacer click”. Una beta puede estropearse en segundos y dejarnos una demo a la mitad …

Por suerte Brian Keller (o algún esbirro) ha creado una serie de demos utilizando DemoMate, que nos permiten repasar varios puntos de las nuevas capacidades de ALM de Visual Studio 11.

Vamos con el listado:

Online:
Agile Project Management in Team Foundation Server 11
Building the Right Software - Generating Storyboards and Collecting Stakeholder Feedback with Visual Studio 11
Diagnosing Issues in Production with IntelliTrace and Visual Studio 11
Exploratory Testing and Other Enhancements in Microsoft Test Manager 11
Making Developers More Productive with Team Foundation Server 11
Unit Testing with Visual Studio 11 - MSTest, NUnit, xUnit.net, and Code Clone

Offline: (gets installed locally on your computer)
Agile Project Management in Team Foundation Server 11
Building the Right Software - Generating Storyboards and Collecting Stakeholder Feedback with Visual Studio 11
Diagnosing Issues in Production with IntelliTrace and Visual Studio 11
Exploratory Testing and Other Enhancements in Microsoft Test Manager 11
Making Developers More Productive with Team Foundation Server 11
Unit Testing with Visual Studio 11 - MSTest, NUnit, xUnit.net, and Code Clone

Saludos @ Home

El Bruno

Fuente: http://blogs.msdn.com/b/briankel/archive/2011/10/16/demomates-for-visual-studio-11-alm-demos.aspx

Buenas,

si como yo te encuentras con la necesidad de instalarte un Team Foundation Server 11 Basic en un Windows 8 Developer Preview, es probable que te encuentres con alguno de los siguientes errores:

Error    [ Application Tier ] TF255120: Compatibility mode for Internet Information Services (IIS) 6.0 is not enabled. Team Foundation Server requires this on this operating system.
Error    [ Application Tier ] TF255456: You must configure Internet Information Services (IIS) to use the Static Content component. Team Foundation Server requires the Static Content component in IIS.
Error    [ Application Tier ] TF255397: Windows Authentication has not been configured as a role service in Internet Information Services (IIS). Team Foundation Server requires that Windows Authentication is installed as one of the role services in IIS.
Error    [ Application Tier ] TF255397: Windows Authentication has not been configured as a role service in Internet Information Services (IIS). Team Foundation Server requires that Windows Authentication is installed as one of the role services in IIS.
Error    [ Application Tier ] TF255397: Windows Authentication has not been configured as a role service in Internet Information Services (IIS). Team Foundation Server requires that Windows Authentication is installed as one of the role services in IIS.

Éstos errores nos indican que debemos activar algunas features para nuestro servicio de Internet Information Server que no vienen por defecto activadas en Windows 8.

El comando para poder activar las features necesarias es el siguiente:

dism /online /enable-feature /featurename:IIS-NetFxExtensibility /featurename:IIS-ASPNET /all

Y es importante lanzar el mismo con privilegios de administrador desde un Command Promt en Windows 8.

Saludos @ AVE

El Bruno

Fuente: http://social.msdn.microsoft.com/Forums/en-US/tfssetup/thread/2bc48ea2-a652-4f98-9676-2243675c43fa/

Buenas,

si trabajas con Kinect seguro que alguno de estos proyectos que ya se han actualizado a la Beta 2 del SDK te resultan conocidos:

• Kinect Toolbox
  http://kinecttoolbox.codeplex.com/
• Coding4Fun Kinect Toolkit
  http://c4fkinect.codeplex.com/

Si no los conoces, pues deberías :)

Saludos @ Home

El Bruno

Buenas,

ahora que ya tenemos la Beta 2 de Kinect for Windows SDK en nuestras manos, pues veamos como detectar cuando se conecta o desconecta un sensor Kinect a nuestro ordenador.

Tutorial

1. Creamos una aplicación del tipo WPF Application

2. Agregamos las siguientes referencias

• Microsoft.Research.Kinect
  <%Program Files%>\Microsoft SDKs\Kinect\v1.0 Beta2\Assemblies\Microsoft.Research.Kinect.dll

3. A continuación modificamos nuestro MainWindow para inicializar la captura de eventos en el Load de la Window.

   1: <Window x:Class="ElBruno.KinectStatus.MainWindow"

   2:         xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"

   3:         xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"

   4:         Title="MainWindow" Height="350" Width="525" Loaded="WindowLoaded">

   5:     <Grid>

   6:         

   7:     </Grid>

   8: </Window>

4. Implementamos el evento WindowLoad() y en el mismo nos suscribimos al cambio de estado que se dispara cuando se conecta uno o más sensores Kinect.

   1: using System.Windows;

   2: using Microsoft.Research.Kinect.Nui;

   3:  

   4: namespace ElBruno.KinectStatus

   5: {

   6:     public partial class MainWindow : Window

   7:     {

   8:         public MainWindow()

   9:         {

  10:             InitializeComponent();

  11:         }

  12:  

  13:         private void WindowLoaded(object sender, RoutedEventArgs e)

  14:         {

  15:             Runtime.Kinects.StatusChanged += KinectsStatusChanged;

  16:         }

  17:  

  18:         private void KinectsStatusChanged(object sender, StatusChangedEventArgs e)

  19:         {

  20:             MessageBox.Show(e.Status.ToString());

  21:         }

  22:     }

  23: }

5. En este punto ya podremos compilar y ejecutar nuestra aplicación. Después de conectar y desconectar varias veces el dispositivo podremos ver algo similar a lo siguiente

Más fácil imposible no ?

A seguir jugando …

Saludos @ Home

El Bruno

Buenas,

¡¡¡ toma mate !!! la beta 2 del SDK de Kinect for Windows ya está disponible para descargar desde http://www.kinectforwindows.org/download/

Entre las novedades de esta versión me toca apuntar

• Ejemplos de código! por fin :D
• Un seguimiento de movimientos mas fino
• Capacidad para trabajar cuando se desconecta y conecta nuevamente el sensor

Vamos que tenemos de todo para comenzar en el día que Kinect cumple 1 añito

Y para finalizar, el nuevo site oficial es http://www.kinectforwindows.org/

Saludos @ Here

El Bruno

Buenas,

hoy veremos una interesante opción para el análisis de código que se ha incorporado en Visual Studio 11. En este caso se trata de la capacidad de encontrar secciones de código duplicadas dentro de una solución.

Todos sabemos que en las prisas del día a día, muchas veces nos saltamos todas las buenas prácticas y en lugar de darle un poco a la máquina de pensar, utilizamos el copy & paste como patrón de implementación de código. Esto a la larga nos va a traer más problemas que soluciones, pero … bueno no les quiero contar algo que ya saben.

Si estás trabajando y te encuentras con una porción de código que te “da un mal olor”, ahora tienes la capacidad de seleccionar la misma, desplegar el menú contextual y seleccionar la opción "”Find Matching Clones in Solution”.

Como quería hacer una prueba buena y sobre una buena base de código, pues me decidí a analizar el código fuente de Enterprise Library 5. Como después de un rato de buscar no encontré porciones de código duplicadas, agregue una nueva clase en la que “me encargué de forzar el error”.

Cuando finaliza la búsqueda de secciones duplicadas, veremos que en la ventana de resultados podremos ver el código seleccionado y sus clones.

Si en cambio seleccionamos una porción de código que se repite más de una vez, pues podremos ver en la ventana de resultados los diferentes resultados encontrados. Estos resultados pueden ser “copias exactas” o inclusive implementaciones parciales del código que se analiza, cool

Saludos @ Home

El Bruno

Buenas,

Microsoft Kinect como dispositivo ha significado una revolución en este su primer año de vida (bueno casi que todavía faltan un par de días para su primer cumpleaños). Además de tener un par de records en su haber, la salida del Kinect for Windows SDK Beta nos ha permitido crear un nuevo tipo de aplicaciones que hasta el día de hoy, solo podíamos pensar como parte de películas de ciencia ficción.

En el siguiente video, Microsoft nos presenta 12 aplicaciones reales desarrolladas con Kinect que dejando a un lado las clásicas aplicaciones de juegos, nos permiten a los usuarios tener una nueva herramienta en diferentes campos como la medicina o la educación.

La verdad es que si bien los números de Kinect asombran por la cuota de penetración en el mercado o la cantidad de aplicaciones desarrolladas, lo más interesante es ver cómo se está abriendo el abanico a nuevas posibilidades y como cada vez los límites son más cercanos.

Saludos @ Home

El Bruno

Fuente: http://www.microsoft.com/Presspass/Features/2011/oct11/10-31KinectEffect.mspx