Reconocimiento de Gestos Kinect + C#
92
1 ING. SISTEMAS COMPUTACIONALES IMPLEMENTACIÓN DE RECONOCIMIENTO FACIAL Y GESTICULACIONES PARA EL MANEJO Y CONTROL DE PROYECTO RESA JHONNATAN FLORES MIRAMON ASESOR INTERNO: M.T.I. EDUARDO VASQUEZ ZAYAS ASESOR EXTERNO: I.S.C. SILVIA DURÁN BRAVO TEHUACÁN, PUEBLA JUNIO 2013
-
Upload
jhonnatan-flores -
Category
Engineering
-
view
193 -
download
10
Transcript of Reconocimiento de Gestos Kinect + C#
1
ING. SISTEMAS COMPUTACIONALES
IMPLEMENTACIÓN DE RECONOCIMIENTO FACIAL Y
GESTICULACIONES PARA EL MANEJO Y CONTROL DE
PROYECTO RESA
JHONNATAN FLORES MIRAMON
ASESOR INTERNO: M.T.I. EDUARDO VASQUEZ ZAYAS
ASESOR EXTERNO: I.S.C. SILVIA DURÁN BRAVO
TEHUACÁN, PUEBLA JUNIO 2013
2
ÍNDICE
Introducción ....................................................................................................................................... 3
Justificación ....................................................................................................................................... 5
Objetivo General ............................................................................................................................... 7
Objetivos Específicos ....................................................................................................................... 7
Caracterización del área en que participo .................................................................................... 8
Problemas a resolver, priorizándolos ............................................................................................ 9
Alcances........................................................................................................................................... 10
Limitaciones..................................................................................................................................... 10
Fundamentos Teóricos .................................................................................................................. 10
Descripción de las actividades realizadas .................................................................................. 45
Resultados, planos, gráficas y programas ................................................................................. 85
Conclusiones y recomendaciones ............................................................................................... 89
Referencias bibliográficas ............................................................................................................. 91
3
Introducción
Hoy en día las TIC (tecnologías de la información y la comunicación) son tan
usuales en la vida cotidiana que las encontramos en casi todos los aspectos,
desde mandar un simple SMS, hasta realizar una videoconferencia por internet a
través de un dispositivo móvil. Estas tecnologías han cambiado la forma en que
las personas llevan a cabo sus actividades, que él no contar con nociones básicas
de cómo utilizar un dispositivo electrónico (computadora, celular, tableta, etc.)
podría limitar las posibilidades de desarrollo y/o interacción social de las mismas.
Actualmente el internet y las aplicaciones están ante la tercera generación de
desarrollo. La primera generación consistió en trabajar con información estática
que podía ser consultada a través de exploradores como si de un tablón de
noticias se tratara. La segunda generación se ha basado en que las aplicaciones
pudieran interaccionar con las personas; sirva como ejemplo los famosos carritos
de compra. La tercera generación se caracteriza por aplicaciones que puedan
interaccionar con otras aplicaciones; por ejemplo, para programar una reunión de
negocios, su aplicación de contactos interaccionará con su aplicación de
calendario que, a su vez, interaccionará con una aplicación de reserva de billetes
para viajar en avión, que consultará a su aplicación de preferencias de usuario, y
así cancelar alguna actividad ya programada.
Para usar una computadora lo primero el usuario piensa es el uso del teclado, el
ratón y el monitor esencialmente, ya que estos dispositivos son las interfaces
fundamentales mediante las cuales accederemos al control y manejo de los
programas que dentro funcionan, además de la interfaz de usuario la cual se
complementa con menús, iconos, ventanas, sonidos para avisar de informes,
errores o alertas, etcétera. Y aunque este tipo de interfaz ha sido muy bien
aceptado y utilizado en las últimas décadas, este modelo presenta grandes
limitaciones ante los nuevos escenarios de Tics.
Actualmente se busca que las interfaces sean más naturales e intuitivas, como
por ejemplo interfaces de voz y dialogo, reconocimiento de lenguaje natural,
4
reconocimiento de características humanas (gestos, movimientos, etc.), así, estas
interfaces son más amigables y ergonómicas ofreciéndonos una comunicación
más natural entre hombre-computadora, más eficiente y productiva para
interactuar de forma nativa, inspirado en la forma en la que el ser humano se
comunica.
5
Justificación
Las interfaces son la principal forma en que las personas interactúan con los
sistemas y aplicaciones, por lo tanto es de vital importancia hacerlas mucho más
amigables y naturales, por ese motivo el proyecto RESA busca en esta parte del
proyecto, además de simplificar las tareas junto con la domótica, que las interfaces
sean mucho más fáciles de entender y de utilizar.
Los escenarios actuales como ambientes 3D, entornos gráficos aumentados y
demás, han provocado que el uso de un teclado y un mouse sean ineficientes por
lo cual es esencial buscar nuevas alternativas de interacción hombre-
computadora. La interfaz natural de usuario (en inglés natural user interface o NUI)
es aquella en las que se interactúa con un sistema, aplicación, etc., sin utilizar
sistemas de mando o dispositivos de entrada de las GUI como sería un ratón, lápiz
óptico, touchpad, joystick etc., y en su lugar se hace uso de movimientos
gestuales tales como las manos o el cuerpo es el mismo mando de control, en el
caso de pantallas capacitivas multitáctiles la operación o control es por medio de
la yemas de los dedos en uno o varios contactos, también el control de sistemas
operativos por medio de voz humana y control cercano a la pantalla pero sin
tocarla.1
La evolución de las computadoras además de centrarse en el desarrollo de
hardware y software cada vez más potente, ha llevado también a la investigación y
creación de nuevas opciones de interfaces de usuario que se adapten a lo que ya
conoce y sabe el usuario y no lo contrario. La interfaz ideal sería aquella en que
los usuarios interactúen con las computadoras y dispositivos de manera natural e
intuitiva igual que lo hacen en el mundo real, invisible sin darse cuenta del uso de
alguna herramienta o hardware para llevar a cabo una tarea, esto incluso ya está
siendo posible gracias a que proyectos como RESA y similares se están llevando
a cabo.
1 Información de Wikipedia http://es.wikipedia.org/wiki/Interfaz_natural_de_usuario
6
El proyecto RESA es una forma de contribuir a aumentar la calidad de vida de las
personas, hacer más versátil la distribución de la casa, cambiar las condiciones
ambientales creando diferentes escenas predefinidas, y conseguir que la vivienda
sea más funcional al permitir desarrollar facetas domésticas, profesionales, y de
ocio bajo un mismo techo.
7
Objetivo General
Implementar reconocimiento facial y gesticulaciones del cuerpo para interactuar
con una aplicación de escritorio para el control y manejo de proyecto RESA
(Residencias Automáticas).
Objetivos Específicos
Implementar el comportamiento de un ratón con el dispositivo Kinect para
Windows sobre un sistema de interfaz natural.
Implementar el reconocimiento de gesticulaciones del cuerpo.
Implementar la navegación de menús a través del dispositivo Kinect para
Windows sobre un sistema de interfaz natural.
Implementar comandos para manipular y manejar aplicaciones con el
dispositivo Kinect sobre un sistema de interfaz natural.
Implementar el reconocimiento facial para administrar el acceso y control a
aplicaciones.
Integración de la interfaz gráfica para interactuar entre una aplicación de
escritorio y el hardware (dispositivos Inalámbricos) para crear una ambiente
más intuitivo.
8
Caracterización del área en que participó
ArqInSoftware es una empresa de profesionales dedicados a proporcionar
soluciones integrales basadas en el desarrollo de software y el uso de las nuevas
tendencias tecnológicas. Además brinda soporte técnico a las empresas y
particulares que lo soliciten, y su misión es: Producir software de calidad y
soluciones tecnológicas innovadoras, adaptables a las necesidades de
nuestros socios comerciales para fomentar su desarrollo y crecimiento, utilizando
un equipo de profesionales en desarrollo de software y tecnologías de
información altamente competitivo.
La empresa se divide en diferentes departamentos y el proyecto RESA se
encuentra dentro del área de Desarrollo de Software Interactivo que a su vez
pertenece al departamento de Sistemas y Desarrollo de Software.
En la siguiente figura se muestra el organigrama de la empresa y se identifica el
área donde se desarrolló el proyecto.
Figura 1 Organigrama de ArqInSoftware
9
El departamento de Desarrollo de Software Interactivo se encarga del estudio,
diseño, programación e implementación de soluciones que cubran los
requerimientos específicos para cada proyecto. Se basa en estándares de calidad
y con el personal profesional capacitado, lo cual permite crear soluciones
innovadoras, escalables y fáciles de usar. Todo esto con ideas que surgen de un
equipo de trabajo de gente joven, entusiasta y con gran experiencia en el ramo.
Las características principales que debe poseer cada aplicación que se desarrolla
en el departamento de desarrollo de software interactivo son las siguientes:
Debe ser muy fácil de manejar.
Un usuario con conocimientos informáticos mínimos debe ser capaz de
interactuar con las aplicaciones.
Se utiliza una computadora como soporte, excepto donde se trabaje con
algún otro dispositivo.
Control intuitivo que no hace falta haber manejado algo parecido antes.
Problemas a resolver, priorizándolos
El desarrollo del proyecto de residencia se centrara en resolver los siguientes
problemas:
Análisis de cada parte en que se divide el proyecto.
Documentar y comprender el funcionamiento de las librerías y dispositivos
que se utilizaran en el proyecto.
Diseñar los algoritmos con los cuales se llevaran a cabo los
reconocimientos de gestos del cuerpo.
Implementar los algoritmos necesarios para el reconocimiento de gestos.
Evaluar y optimizar los resultados obtenidos.
Integración con la interfaz de usuario, así como los dispositivos
inalámbricos que trabajaran en conjunto.
10
Alcances
Se manejara el reconocimiento de gestos e interacción con las aplicaciones.
Se manejara el reconocimiento facial para el seguimiento de gestos del rostro.
Se integrara la interfaz y los dispositivos para interactuar con el proyecto RESA.
Limitaciones
Se trabajará en un ambiente controlado.
Se necesita una computadora con Procesador Dual Core como mínimo y por lo
menos contar con 2GB RAM para el manejo de los dispositivos.
Para las pruebas es necesario contar con un dispositivo Kinect para Windows.
Se trabajará solo con algunos aparatos electrónicos por el momento con opción de
ampliar a más equipos en un futuro.
El tiempo establecido y sobre todo comprender el funcionamiento de las
bibliotecas utilizadas pueden ser un factor determinante para el desarrollo de
aplicaciones con el Kinect para Windows.
Fundamentos Teóricos
Domótica
La domótica es el conjunto de tecnologías aplicadas al control y la automatización
inteligente de la vivienda, que permite una gestión eficiente del uso de la energía,
además de aportar seguridad, confort, y comunicación entre el usuario y el
sistema.
Un sistema domótico es capaz de recoger información proveniente de unos
sensores o entradas, procesarla y emitir órdenes a unos actuadores o salidas. El
sistema puede acceder a redes exteriores de comunicación o información.
La domótica aplicada a edificios no destinados a vivienda, es decir oficinas,
hoteles, centros comerciales, de formación, hospitales y terciario, se denomina,
inmótica.
11
La domótica permite dar respuesta a los requerimientos que plantean estos
cambios sociales y las nuevas tendencias de nuestra forma de vida, facilitando el
diseño de casas y hogares más humanos, más personales, poli funcionales y
flexibles.
El sector de la domótica ha evolucionado considerablemente en los últimos años,
y en la actualidad ofrece una oferta más consolidada. Hoy en día, la domótica
aporta soluciones dirigidas a todo tipo de viviendas, incluidas las construcciones
de vivienda oficial protegida. Además, se ofrecen más funcionalidades por menos
dinero, más variedad de producto, y gracias a la evolución tecnológica, son más
fáciles de usar y de instalar. En definitiva, la oferta es mejor y de mayor calidad, y
su utilización es ahora más intuitiva y perfectamente manejable por cualquier
usuario. Paralelamente, los instaladores de domótica han incrementado su nivel
de formación y los modelos de implantación se han perfeccionado. Asimismo, los
servicios posventa garantizan el perfecto mantenimiento de todos los sistemas.
La red de control del sistema domótico se integra con la red de energía eléctrica y
se coordina con el resto de redes con las que tenga relación: telefonía, televisión,
y tecnologías de la información (Figura 2), cumpliendo con las reglas de
instalación aplicables a cada una de ellas.2
2 Información obtenida de: http://www.cedom.es/que-es-domotica.php
12
Figura 2 Domótica
¿Qué aporta la domótica?
La domótica contribuye a mejorar la calidad de vida del usuario:
Facilitando el ahorro energético: gestiona inteligentemente la iluminación,
climatización, agua caliente sanitaria, el riego, los electrodomésticos, etc.,
aprovechando mejor los recursos naturales, utilizando las tarifas horarias de
menor coste, y reduce de esta manera la factura energética. Además,
mediante la monitorización de consumos, se obtiene la información
necesaria para modificar los hábitos y aumentar el ahorro y la eficiencia.
Fomentando la accesibilidad: facilita el manejo de los elementos del hogar a
las personas con discapacidades de la forma que más se ajuste a sus
necesidades, además de ofrecer servicios de tele asistencia para aquellos
que lo necesiten.
13
Aportando seguridad de personas, animales y bienes: controles de intrusión
y alarmas técnicas que permiten detectar incendios, fugas de gas o
inundaciones de agua, etc.
Convirtiendo la vivienda en un hogar más confortable: gestión de
electrodomésticos, climatización, ventilación, iluminación natural y
artificial…
Garantizando las comunicaciones: recepción de avisos de anomalías e
información del funcionamiento de equipos e instalaciones, gestión remota
del hogar, etc.
Además, la domótica facilita la introducción de infraestructuras y la creación de
escenarios (ver Figura 3) que se complementan con los avances en la sociedad de
la información:
Comunicaciones: Transmisión de voz y datos, incluyendo textos, imágenes,
sonidos (multimedia) con redes locales (LAN) compartiendo acceso a
Internet, recursos e intercambio entre todos los dispositivos, acceso a
nuevos servicios de telefonía sobre IP, televisión digital, televisión por
cable, diagnóstico remoto, videoconferencias, etc.
Mantenimiento: Con capacidad de incorporar el tele mantenimiento de los
equipos.
Ocio y tiempo libre: Descansar y divertirse con radio, televisión, multi-room,
cine en casa, videojuegos, captura, tratamiento y distribución de imágenes
fijas (foto) y dinámicas (vídeo) y de sonido (música) dentro y fuera de la
casa, a través de Internet, etc.
Salud: Actuar en la sanidad mediante asistencia sanitaria, consultoría sobre
alimentación y dieta, telecontrol y alarmas de salud, medicina monitorizada,
cuidado médico, etc.
14
Compra: Comprar y vender mediante la telecompra, televenta, telereserva,
desde la casa, etc.
Finanzas: Gestión del dinero y las cuentas bancarias mediante la telebanca,
consultoría financiera.
Aprendizaje: Aprender y reciclarse mediante la tele-enseñanza, cursos a
distancia.
Actividad profesional: Trabajar total o parcialmente desde el hogar,
posibilidad viable para ciertas profesiones (teletrabajo), etc.
Ciudadanía: Gestiones múltiples con la Administración del Estado, la
Comunidad Autónoma y el Municipio, voto electrónico, etc.
Acceso a información: Museos, bibliotecas, libros, periódicos, información
meteorológica, etc.
Figura 3 Ejemplo de escenario domótica
15
Interfaz natural de usuario (NUI)
Los dispositivos móviles como teléfonos inteligentes y “tablets” han hecho popular
el uso de atractivas interfaces “multitouch”, este tipo de interfaces están
extendiéndose a otros dispositivos como mesas interactivas, cristales inteligentes
y otros tipos de superficies, para permitir interactuar de una manera más natural a
las personas con la información (ver Figura 4). Con la aparición de Wii y Kinect
que ha agregado el lenguaje corporal, los diseñadores y programadores han
pensado en una gran cantidad de aplicaciones que en los próximos años
cambiaran la manera en que nos comunicamos con las computadoras. En
computación, una interfaz natural de usuario o NUI, es el término común usado
por diseñadores y desarrolladores de interfaces de computadora para referirse a
una interfaz de usuario que es efectivamente invisible, o se vuelve invisible con las
interacciones aprendidas sucesivamente por sus usuarios. La palabra natural se
utiliza porque la mayoría de las interfaces de computadora utilizan
dispositivos artificiales de control, cuyo funcionamiento se tiene que aprender. Una
NUI se basa en que un usuario puede rápidamente hacer la transición de
principiante a experto. Mientras que la interfaz requiere de aprendizaje, por lo
tanto, “Natural” se refiere a un objetivo en la experiencia del usuario, que un
usuario siente “como algo natural” mientras interactúa con la tecnología.3
Figura 4 Evolución de las Interfaces
3 Información de Wikipedia: http://es.wikipedia.org/wiki/Interfaz_natural_de_usuario
16
Entorno de Desarrollo Integrado (IDE)
Un entorno de desarrollo integrado, llamado también IDE (sigla en inglés
de integrated development environment), es un programa informático compuesto
por un conjunto de herramientas de programación. Puede dedicarse en exclusiva
a un solo lenguaje de programación o bien puede utilizarse para varios.
Un IDE es un entorno de programación que ha sido empaquetado como un
programa de aplicación; es decir, consiste en un editor de código, un compilador,
un depurador y un constructor de interfaz gráfica (GUI). Los IDEs pueden ser
aplicaciones por sí solas o pueden ser parte de aplicaciones existentes. El
lenguaje Visual Basic, por ejemplo, puede ser usado dentro de las aplicaciones
de Microsoft Office, lo que hace posible escribir sentencias Visual Basic en forma
de macros para Microsoft Word.
Los IDE proveen un marco de trabajo amigable para la mayoría de los lenguajes
de programación tales como C++, PHP, Python, Java, C#, Delphi, Visual Basic,
etc. En algunos lenguajes, un IDE puede funcionar como un sistema en tiempo de
ejecución, en donde se permite utilizar el lenguaje de programación en forma
interactiva, sin necesidad de trabajo orientado a archivos de texto, como es el
caso de Smalltalk u Objective-C.
Microsoft Visual Studio
Microsoft Visual Studio es un entorno de desarrollo integrado (IDE, por sus siglas
en inglés) para sistemas operativos Windows. Soporta varios lenguajes de
programación tales como Visual C++, Visual C#, Visual J#, y Visual Basic .NET, al
igual que entornos de desarrollo web comoASP.NET. Aunque actualmente se han
desarrollado las extensiones necesarias para muchos otros.
Visual Studio permite a los desarrolladores crear aplicaciones, sitios y aplicaciones
web, así como servicios web en cualquier entorno que soporte la plataforma .NET
(a partir de la versión .NET 2002). Así se pueden crear aplicaciones que se
intercomuniquen entre estaciones de trabajo, páginas web y dispositivos móviles.
17
C#
C#, pronunciado C Sharp, es actualmente junto con Java, uno de los lenguajes de
programación más populares en Internet. Pero, además, apoyándose en la
biblioteca .NET, está disponible para el desarrollo de aplicaciones de propósito
general, aplicaciones con interfaz gráfica, aplicaciones para internet y aplicaciones
para móviles.
En los últimos tiempos C y C++ han sido los lenguajes más utilizados en el
desarrollo de aplicaciones en general. Ambos lenguajes proporcionan al
programador el nivel de abstracción preciso para abordar el desarrollo de
cualquier aplicación por compleja que sea, así como mecanismos de bajo nivel
para utilizar las características más avanzadas de las plataformas sobre las que se
desarrolla; pero, en general, el tiempo necesario para desarrollar una aplicación
resulta largo comparado con otros lenguajes como Visual Basic, que ofrecen
además de facilidad, una elevada productividad en el desarrollo de aplicaciones,
aunque eso sí, sacrificando la flexibilidad que los desarrolladores de C y C++
requieren. La solución que Microsoft da a este problema es el lenguaje
denominado C#. Se trata de un lenguaje moderno orientado a objetos que permite
desarrollar una amplia gama de aplicaciones para la nueva plataforma Microsoft
.NET.
Más que otra cosa, el objetivo de C# es permitir a todos los desarrolladores en
general, y a los de C y C++ en particular, abordar el desarrollo de aplicaciones
complejas con facilidad y rapidez pero sin sacrificar la potencia y el control que
ofrecen C y C++. Es un poco como tomar todas las cosas buenas de Visual Basic
y añadirlas a C++, aunque recortando algunas de las tradiciones más ocultas y
difíciles de conocer de C y C++. Esto elimina los errores de programación más
comunes en C/C++. Por ejemplo:
El recolector de basura libera al programador del peso que conlleva el
manejo manual de la memoria.
18
Todos los objetos creados dinámicamente así como as matrices son
iniciados a cero, y aunque C# no inicia automáticamente las variables
locales, el compilador avisará siempre que se intente utilizar una antes de
iniciarla.
C# unifica el sistema de tipos permitiendo ver a cada uno de ellos en el
lenguaje como un objeto.
Resumiendo, C# es un lenguaje orientado a objetos seguro y elegante que permite
a los desarrolladores construir un amplio rango de aplicaciones seguras y robustas
que se ejecutan sobre .NET Framework. .NET Framework (que incluye entre otras
cosas la biblioteca básica de .NET y el compilador C#) junto con otros
componentes de desarrollo como ASP.NET (formularios Web y servicios Web) y
ADO.NET, forman un paquete de desarrollo denominado Microsoft Visual Studio
que podemos utilizar para crear aplicaciones Windows tradicionales (aplicaciones
de escritorio que muestran una interfaz gráfica al usuario) y aplicaciones para la
Web. Para ello, este paquete proporciona un editor de código avanzado,
diseñadores de interfaces de usuario apropiados, depurador integrado y muchas
otras utilidades para facilitar un desarrollo rápido de aplicaciones.
La palabra “Visual” hace referencia, desde el lado del diseño, al método que se
utiliza para crear la interfaz gráfica de usuario si se dispone de la herramienta
adecuada (con Microsoft Visual Studio se utiliza el ratón para arrastrar y colocar
los objetos prefabricados en el lugar deseado dentro de un formulario) y desde el
lado de la ejecución, al aspecto grafico que toman los objetos cuando se ejecuta el
código que los crea, objetos que formara la interfaz gráfica que el usuario de la
aplicación utiliza para acceder a los servicios que ésta ofrece. Y “.NET” hace
referencia al ámbito donde operaran nuestras aplicaciones Web (Network - red).
19
Windows Presentation Foundation (WPF)
Windows Presentation Foundation (WPF) es una tecnología de Microsoft,
presentada como parte de Windows Vista. Permite el desarrollo de interfaces de
interacción en Windows tomando características de aplicaciones Windows y de
aplicaciones web.
WPF ofrece una amplia infraestructura y potencia gráfica con la que es posible
desarrollar aplicaciones visualmente atractivas, con facilidades de interacción que
incluyen animación, vídeo, audio, documentos, navegación o gráficos 3D.
Separa, con el lenguaje declarativo XAML y los lenguajes de programación de
.NET, la interfaz de interacción de la lógica del negocio, propiciando una
arquitectura Modelo Vista Controlador para el desarrollo de las aplicaciones.
WPF se incluye con Windows 7, Windows Vista y Windows Server 2008 y también
está disponible para Windows XP Service Pack 2 o posterior y Windows Server
2003.
Microsoft Silverlight es un subconjunto de WPF que permite crear aplicaciones
similares a Flash para web y móviles, con el mismo modelo de programación que
las aplicaciones .NET. No admite funciones 3D, pero soporta XPS y planos
basados en vectores.
XAML
XAML (acrónimo pronunciado xammel del inglés eXtensible Application Markup
Language, Lenguaje Extensible de Formato para Aplicaciones en español) es el
lenguaje de formato para la interfaz de usuario para la Base de Presentación de
Windows (WPF por sus siglas en inglés) y Silverlight, el cual es uno de los
"pilares" de la interfaz de programación de aplicaciones .NET en su versión 3.0
(conocida con anterioridad con el nombre clave WinFX).
XAML es un lenguaje declarativo basado en XML, optimizado para describir
gráficamente interfaces de usuarios visuales ricas desde el punto de vista gráfico,
tales como las creadas por medio de Adobe Flash. XUL y UIML son otros
20
ejemplos de lenguajes de interfaz basados en XML. SVGes un estándar de la
organización W3C, el cual soporta gráficos, animaciones, audio y video
integrados, eventos y comportamiento descrito por medio de escritura y puede ser
utilizado como lenguaje de interfaz basado en XML.
En su uso típico, los archivos tipo XAML serían producidos por una herramienta de
diseño visual, como Microsoft Visual Studio o Microsoft Expression. El XML
resultante es interpretado en forma instantánea por un sub-sistema de despliegue
de Windows Vista que reemplaza al GDI de las versiones anteriores de Windows.
Los elementos de XAML se interconectan con objetos del Entorno Común de
Ejecución para Lenguajes. Los atributos se conectan con propiedades o eventos
de esos objetos.
XAML fue diseñado para soportar las clases y métodos de la plataforma de
desarrollo .NET que tienen relación con la interacción con el usuario, en especial
el despliegue en pantalla. El acrónimo XAML originalmente significaba Extensible
Avalon Markup Language, Lenguaje Extensible de Formato de Avalon; habiendo
sido Avalon el nombre clave original de la Base de Presentación de Windows,
nombre que engloba a este grupo de clases de .NET.
Un archivo XAML puede ser compilado para obtener un archivo binario XAML
.baml, el cual puede ser insertado como un recurso en un ensamblado de
Framework .NET. En el momento de ejecución, el motor del Framework extrae el
archivo .baml de los recursos del ensamblado, se analiza sintácticamente, y crea
el correspondiente árbol visual WPF o Workflow.
Cuando se usa en Windows Presentation Foundation, XAML es usado para
describir interfaces visuales para usuarios. WPF permite la definición de objetos
en 2D y 3D, rotaciones, animaciones y otra variedad de características y efectos.
Cuando es usado en el contexto de Windows Workflow Foundation, XAML es
usado para describir lógica declarativa potencialmente larga (potentially long-
running declarative logic), como aquellos creados en el proceso de sistemas de
modelado y herramientas. El formato de serialización para WorkFlows había sido
llamado previamente XOML, para diferenciarlo de su uso en IU de los XAML, pero
21
esa diferenciación ya no existe. Sin embargo las extensiones de los archivos que
contienen marcado de workflow es todavía XOML.
Microsoft .NET
El principio de .NET es que los sitios Web aislados de hoy en día y los diferentes
dispositivos trabajen conectados a través de internet para ofrecer soluciones
mucho más ricas. Esto se conseguirá gracias a la aceptación de los estándares
abiertos basados en XML (Extensible Markup Language – lenguaje extensible
para describir documentos). De esta manera, Internet se convierte en una fuente
de servicios, no sólo de datos.
En definitiva, Internet y XML han dado lugar a una nueva fase de la informática en
la que los datos del usuario residen en Internet, no en un ordenador personal, y se
puede acceder a ellos desde cualquier ordenador de sobremesa, portátil, teléfono
móvil o agenda de bolsillo (PDA: Personal Digital Assistant). Ello se debe
fundamentalmente a que XML ha hecho posible que se puedan crear aplicaciones
potentes, para ser utilizadas por cualquiera, desde cualquier lugar. En el corazón
del nuevo enfoque de desarrollo está el concepto de servicio Web. Por ejemplo en
este contexto, el software no se instala desde un CD, sino que es un servicio,
como la televisión por pago, al que suscribirse a través de un medio de
comunicación.
Microsoft .NET extiende las ideas de Internet y sistema operativo haciendo de la
propia Internet la base de un nuevo sistema operativo. En última instancia, esto
permitirá a los desarrolladores crear programas que transciendan los límites de los
dispositivos y aprovechen por completo la conectividad de Internet y sus
aplicaciones. Para ello proporciona una plataforma que incluye los siguientes
componentes básicos:
Herramientas de programación para crear servicios Web XML con soporte
multilingüe: Visual Studio .NET y .NET Framework.
Infraestructura de servidores, incluyendo Windows y .NET Enterprise
Servers.
22
Un conjunto de servicios que actúan como bloque de construcción para el
sistema operativo de Internet que incluirán autentificación del usuario
(servicio Passport .NET), servicios para almacén de datos, administración
de preferencias de los usuarios, calendario y otros muchos. Para
entenderlo, compare los servicios con los bloques Lego; al unir bloques de
Lego se pueden construir soluciones (una casa, un barco, etc.). De la
misma forma la unión de servicios Web XML permite crear soluciones de
software para realizar una tarea concreta, ver Figura 5
Figura 5 Ecosistema .NET
Software de dispositivos .NET para hacer posible una nueva generación de
dispositivos inteligentes (ordenadores, teléfonos, consolas de juegos, etc.)
que puedan funcionar en el universo .NET.
Experiencias .NET utilizadas por los usuarios finales para acceder a los
servicios Web XML. Son análogas a las aplicaciones independientes de hoy
en día pero con algunas diferencias importantes; por ejemplo, pueden leer
las características del dispositivo que el usuario final está utilizando para
acceder y activar así la interfaz más adecuada, y utilizan servicios Web
XML.
23
Claramente, se requiere una infraestructura, no solo para facilitar el desarrollo de
aplicaciones sino también para hacer que el proceso de encontrar un servicio Web
e integrarlo en una aplicación resulte transparente para usuarios y desarrolladores:
.NET Framework proporción esa infraestructura.
Según se puede ver en la figura siguiente, .NET Framework es un
componente de desarrollo de multilenguaje y un entorno de ejecución:
Figura 6 Componentes .NET
Especificación común para todos los lenguajes
.NET Framework proporciona un entorno unificado para todos los lenguajes de
programación. Microsoft ha incluido en este marco de trabajo los lenguajes Visual
Basic, C#, C++ y JScript, y además, ha dejado la puerta abierta para que otros
fabricantes puedan incluir sus lenguajes (COBOL, Pascal, Perl, Smalltalk, etc.). Lo
más atractivo quizás de todo esto es la capacidad de escribir, por ejemplo, parte
de una aplicación en Visual Basic y el resto en C#. No obstante, para que un
código pueda interactuar con cualquier otro independientemente del lenguaje
utilizado, .NET Framework proporciona la “especificación común para los
24
lenguajes” (CLS – Common Language Specification) que define las características
fundamentales del lenguaje y las reglas de cómo deben ser utilizadas.
Una de las partes más importantes del CLS es la que se refiere a los tipos de
datos. Yendo un poco hacia atrás en la historia ¿recuerda lo diferentes que eran
los tipos de datos de VB6 y de C++? Para evitar este tipo de problemas y poder
gestionar de forma eficiente y segura el acceso a la memoria, el CLS define un
conjunto de datos comunes (Common Type System o CTS) que indica que tipos
de datos se pueden manejar, como se declaran y como se utilizan. De esta forma,
aunque cada lenguaje .NET utilice una sintaxis diferente para cada tipo de datos,
por ejemplo, Visual Basic utiliza Integer para un numero entero de 32 bits y C#
utiliza int, estos nombres no son más que sinónimos del tipo común
System.Int32. De esta forma, las bibliotecas que utilicen en sus interfaces hacia el
exterior de datos definidos en el CTS no presentaran problemas a la hora de ser
utilizadas desde cualquier otro código escrito en la plataforma .NET, permitiendo
así la interoperabilidad entre lenguajes.
Entorno de ejecución común de los lenguajes
.NET Framework proporciona un entorno de ejecución llamado CLR (Common
Language Runtime; es la implementación de Microsoft de un estándar llamado
Common Language Infraestructure o CLI, creado y promovido por Microsoft,
reconocido mundialmente por el ECMA). Se trata de una máquina virtual que
administra la ejecución de código y proporciona servicios que hacen más fácil el
proceso de desarrollo (en esencia, estamos hablando de una biblioteca utilizada
por cada aplicación .NET durante su ejecución). Ver Figura 7.
El proceso de ejecución de cualquier aplicación incluye los pasos siguientes:
1.- Diseñar y escribir el código fuente.
2.- Compilar el código fuente a código intermedio.
3.- Compilar el código intermedio a código nativo.
25
4.- Ejecutar el código nativo.
Puesto que .NET Framework es un entorno de ejecución multilingüe, soporta una
amplia variedad de los tipos de datos y características del lenguaje que serán
utilizadas en la medida que el lenguaje empleado soporte y en la medida que el
desarrollador adapte su código a las mismas. Esto es, es el compilador utilizado, y
no el CLR, el que establece el código que se utiliza. Por lo tanto cuando tengamos
que escribir un componente totalmente compatible con otros componentes escritos
en otros lenguajes, los tipos de datos y las características del lenguaje utilizado
deben estar admitidos por la especificación del lenguaje común (CLS).
Cuando se compila el código escrito, el compilador lo traduce a un código
intermedio denominado MSIL (Microsoft Intermediate Language) o simplemente IL,
correspondiente a un lenguaje independiente de la unidad central de proceso
(UCP). Esto quiere decir que el código producido por cualquier lenguaje .NET
puede transportarse a cualquier plataforma (Intel, Sparc, Motorola, etc.) que tenga
instalada una máquina virtual .NET y ejecutarse. Pensando en Internet esta
característica es crucial ya que esta red conecta ordenadores muy distintos.
MSIL incluye instrucciones para cargar, iniciar y llamar a los métodos de los
objetos, así como para operaciones aritméticas y lógicas, control de flujo, acceso
directo a memoria, manipulación de excepciones y otras operaciones.
Figura 7 Entorno de ejecución .NET
26
La siguiente figura muestra el aspecto que tiene un código intermedio de una
aplicación. Este código puede obtenerlo a través del desamblador ildasm.exe que
viene con la plataforma .NET.
Figura 8 Código Intermedio MSIL
Cuando el compilador produce MSIL también produce metadatos: información que
describe cada elemento manejado por el CLR (tipo, método, etc.). Esto es, el
código a ejecutar debe incluir esta información para que el CLR pueda
proporcionar servicios tales como administración de memoria, integración de
múltiples lenguajes, seguridad, control automático del tiempo de vida de los
objetos, etc. Tanto el código intermedio como los metadatos son almacenados en
un fichero ejecutable y portable (.exe o .dll), denominado ensamblado (assembly
en inglés), que permite que el código se describa así mismo, lo que significa que
no hay necesidad de bibliotecas de tipos o de lenguajes de definición de
interfaces.
Un ensamblado es la unidad fundamental de construcción de una aplicación .NET
y básicamente incluye dos partes diferenciadas: el manifiesto y el código MSIL.
27
El manifiesto, incluye los metadatos que describen completamente los
componentes en el ensamblado (versión, tipos, dependencias, etc.) y el código
describe el proceso a realizar.
Antes de que el código intermedio pueda ser ejecutado, debe ser convertido por
un compilador JIT (Just in Time: al instante) a código nativo, que es código
especifico de la CPU del ordenador sobre el que se está ejecutando JIT.
Figura 9 Proceso JIT
La máquina virtual no convierte todo el código MSIL a código nativo y después lo
ejecuta, sino que lo va convirtiendo bajo demanda con el fin de reducir el tiempo
de ejecución; esto es, cada momento es compilado a código nativo o cuando es
llamado por primera vez para ser ejecutado, y el código nativo que se obtiene se
guarda para que este accesible para subsiguientes llamadas. Este código nativo
se denomina “código administrado” si cumple la especificación CLS, en otro caso
recibe el nombre de “código no administrado”.
La máquina virtual (el CLR) proporciona la infraestructura necesaria para ejecutar
código administrado, así como también una velocidad de servicios que puedan ser
utilizados durante a ejecución (administración de memoria -incluye un recolector
de basura para eliminar un objeto cuando ya no este referenciado- , seguridad,
interoperabilidad con código no administrado, soporte multilenguaje para
depuración, soporte de versión, etc.).
El código no administrado es código creado sin tener en cuenta la especificación
del lenguaje común (CLS). Este código se ejecuta con los servicios mínimos del
CLR (por ejemplo, sin recolector de basura, depuración limitada, etc.).
28
Kinect
Microsoft Research invirtió veinte años de desarrollo en la tecnología de Kinect de
acuerdo con las palabras de Robert J.Bach. Kinect fue anunciado por primera vez
el 1 de junio de 2009 en la Electronic Entertainment Expo 2009 como "Project
Natal".
El nombre en clave Proyecto Natal responde a la tradición de Microsoft de utilizar
ciudades como nombres en clave. Alex Kipman, director de Microsoft, quien
incubó el proyecto, decidió ponerle el nombre de la ciudad brasileña Natal como
un homenaje a su país de origen y porque la palabra natal significa “de o en
relación al nacimiento”, lo que refleja la opinión de Microsoft en el proyecto como
“el nacimiento de la próxima generación de entretenimiento en el hogar”.
SDK para Kinect
El Kit de Desarrollo de Software de Kinect para Windows (SDK) permite a los
desarrolladores utilizar C++, C# o Visual Basic para crear aplicaciones que
soporten reconocimiento de gesticulaciones del cuerpo y de voz utilizando el
sensor Kinect para Windows y una computadora o dispositivo incorporado usando
Visual Studio 2010 o 2012.
El SDK incluye controladores para utilizar el sensor Kinect para Windows en un
equipo que ejecute Windows 8, Windows 7 o Windows Embedded Standard 7.
Además, la descarga incluye las API y las interfaces del dispositivo.
La última actualización del SDK de Kinect expone características adicionales del
sensor, mejora la eficiencia a la hora de programar con el sistema operativo y más
herramientas de apoyo así como varios ejemplos de muestra junto con su código
fuente.
29
Entorno de Desarrollo
Kinect para Windows requiere uno de los siguientes sistemas operativos
o Windows 7.
o Windows Embedded Standard 7.
o Windows 8.
Requisitos de hardware
o Procesador de 32 bits (x86) o 64 bits (x64).
o Procesador de doble núcleo a 2,66 GHz o superior.
o Bus USB 2.0 dedicado.
o 2 GB de RAM.
o Un sensor Kinect para Windows4
Requisitos de software
o Microsoft Visual Studio Express u otra edición de Visual Studio
2010/2012.
o .NET Framework 4.0 o Superior.
o Microsoft Speech Platform SDK v11 para el desarrollo de
aplicaciones con funciones de voz para Kinect para Windows.
4 Hasta la versión 1.5 del SDK para Kinect, se podía utilizar el dispositivo que se usa en la consola de Xbox, ya
que a la hora de instalar la versión 1.6 se actualiza automáticamente el firmware del dispositivo, dejando inutilizable para la computadora un dispositivo Kinect for Xbox, pero sigue funcionando igual en la consola.
30
Instalación del SDK
Antes de instalar el SDK de Kinect para Windows debemos considerar lo
siguiente:
1.- Verificar que el dispositivo este desconectado de la computadora donde lo
deseamos instalar.
2.- Verificar que Visual Studio este cerrado durante el proceso de instalación.
Si se tuvieran instalados en la computadora otros drivers para interactuar con el
dispositivo Kinect como por ejemplo los que proveen PrimeSense, se debería
considerar eliminarlos primero antes de instalar el SDK, pues las librerías que
Microsoft ofrece no son interoperables con por ejemplo Open NI5 u OpenKinect6.
Una vez descargado el instalador apropiado (x86 o x64)7 del SDK de Kinect solo
hace falta comenzar la instalación, y esto es muy fácil con el asistente de
instalación seguir los pasos hasta concluir la instalación del SDK. Terminado esto
ahora se procede a conectar el dispositivo; la computadora reconocerá e instalara
automáticamente los drivers necesarios, incluso se mostraran mensajes en la
barra de tareas informando el progreso de los sensores que se están
reconociendo, al finalizar la instalación se puede observar como el LED del
dispositivo cambia de rojo a verde indicando que está listo para comenzar a ser
utilizado. Para verificar que el dispositivo se ha instalado correctamente se pueden
probar los ejemplos del Kinect Developer Toolkit, también desde Panel de
Control/Administrador de dispositivos, encontraremos los siguientes dispositivos:
Microsoft Kinect Audio Array Control, Microsoft Kinect Camera, y Microsoft Kinect
Security Control. En la siguiente figura se muestra lo anterior.
5 OpenNI es un framework de codigo abierto usado para el desarrollo de sensores 3D, bibliotecas
middleware y aplicaciones. 6 OpenKinect es una comunidad de personas interesadas en el desarrollo de librerías de código abierto para
trabajar con el Kinect. 7 x86 y x64 se refiere a la arquitectura del Sistema Operativo a 32 y 64 bits respectivamente.
31
Figura 10 Hardware que se instala con el Kinect
Kinect Developer Toolkit
El uso del Toolkit es opcional, pero en el podemos encontrar proyectos de ejemplo
junto con su código fuente en donde se muestra cómo usar las características del
SDK, así como los componentes que encontramos como Kinect Button y Kinect
Viewer, User Controls, etc., para ayudarte a construir tu interfaz gráfica de una
manera más rápida, usando los componentes que el Toolkit ofrece y así enfocarte
únicamente en el problema a resolver y hacer de la experiencia de usuario de tu
aplicación consistente y mucho mejor.
32
Arquitectura del Kinect
El sensor de Kinect es una barra horizontal de aproximadamente 23 cm (9
pulgadas) conectada a una pequeña base circular con un eje de articulación de
rótula, y está diseñado para ser colocado longitudinalmente por encima o por
debajo de la pantalla de vídeo.
El dispositivo cuenta con una cámara RGB, un sensor de profundidad,
un micrófono de múltiples matrices y un procesador personalizado que ejecuta el
software patentado por PrimeSense8, que proporciona captura de movimiento de
todo el cuerpo en 3D, reconocimiento facial y capacidades de voz.
Figura 11 Dispositivo Kinect
El sensor contiene un mecanismo de inclinación motorizado y en caso de usar un
Kinect para Windows tiene que ser conectado a una toma de corriente, ya que la
corriente que puede proveerle el cable USB es insuficiente; para el caso del
modelo de Xbox 360, esto no es necesario ya que esta consola cuenta con una
toma especialmente diseñada para conectar el Kinect y esto permite proporcionar
la corriente necesaria que requiere el dispositivo para funcionar correctamente.
8 PrimeSense es una empresa que se encarga de dar soluciones tecnológicas innovadores sobre todo en
dispositivos 3D, dispositivos digitales, etc. Es esta empresa la que desarrollo el hardware con el cual funciona el Kinect, y este hardware también ha sido vendido a otras empresas como Asus.
33
Sensor de profundidad
El sensor de profundidad es un proyector de infrarrojos combinado con un
sensor CMOS monocromo que permite al Kinect ver la habitación en 3D en
cualquier condición de luz ambiental. El rango de detección de la profundidad del
sensor es ajustable gracias al software del dispositivo capaz de calibrar
automáticamente el sensor, basado en la jugabilidad y en el ambiente físico del
jugador, tal como la presencia de otros objetos en el área para descartarlos de los
movimientos y/o gestos del usuario.
Este sensor funciona básicamente proyectando un láser a través de toda el área
de visión para el dispositivo, generando algo llamado depth field y es lo que
separa una persona de un objeto (ver Figura 12), a grandes rasgos el Kinect
recibe el rebote del ruido IR y estos son convertidos a una escala de colores,
haciendo así que los cuerpos dependiendo de la distancia se vean como rojos,
verdes etcétera, llegando hasta grises los objetos más lejanos.
Figura 12 Proyección de Puntos IR
Cámara RGB
La cámara de color es una cámara de captación de movimiento VGA con un
resolución de 640 x 480 pixeles a 30 FPS9, un ángulo de visión horizontal de 57.7
grados y 43.5 grados vertical con -27 y +27 grados de inclinación hacia arriba y
hacia abajo.
9 FPS: Fotogramas por segundo
34
Figura 13 Angulo de visión del Kinect
Como ve el Kinect las cosas
A partir del SDK 1.6 del Kinect para Windows se aceptan dos modos de
reconocimiento, modo sentado (near mode) y modo normal (default mode), en el
primero, como su nombre lo indica acepta la detección de una persona cuando
está sentada, los límites físicos de reconocimiento para este modo son de 0.4 a 3
metros, aunque para un reconocimiento optimo la distancia recomendada oscila
entre 0.8 a 2.5 metros (ver Figura 14).
Figura 14 Near Mode
El rango de profundidad para el modo default es de 0.8 a 4 metros para detectar a
una persona de pie, aunque al igual que en el caso anterior el reconocimiento
optimo oscila entre 1.2 a 3.5 metros, incluso el reconocimiento es soportado a
mayor distancia pero se va deteriorando la calidad y recuperación de los datos
35
pues se filtraría mucho ruido y afectarían algunos objetos que se encuentren más
cerca que la persona que se esté detectando.
Figura 15 Default Mode
Rastreo del Esqueleto (Skeleton)
El rastreo del skeleton consta de procesar las imágenes y los datos que del sensor
de profundidad obtiene y las hace pasar por una serie de filtros para que el
sistema determine que es una persona y cualquier otro objeto que se encuentre en
el área de visión del dispositivo.
Figura 16 Rastreo de esqueletos
Para lograr el reconocimiento se siguen una seria de parámetros, para detectar
formas humanas e identificar las partes del cuerpo de una persona cada parte es
convertida a una coordenada 3D (x,y,z) o articulación (joint), así un conjunto de
36
articulaciones bien definidas forman un esqueleto virtual para cada imagen de
profundidad del sensor, aun así el dispositivo esta precargado con poses que
permiten llenar los espacios si es que existe una pose que este obstruida por
algún objeto, ya que el Kinect trabaja a 30 FPS este proceso se repite 30 veces en
un segundo.
Figura 17 Representación de joints del cuerpo
Para el reconocimiento del skeleton se presentan dos modos, modo completo y
modo sentado, el primero detecta 20 articulaciones que van desde los pies,
tobillos, rodillas, cintura, manos, codos, hombros y cabeza. Este modo bien es
utilizado en aplicaciones y juegos en el cual el usuario tenga que realizar
movimientos con todo el cuerpo y/o cambiar de posición, etc.
37
Figura 18 Esqueleto modo completo
Para el modo sentado solo se detectan 10 articulaciones que van desde las
manos, codos, hombros cuello y cabeza. Básicamente se aplica este modo para
aplicaciones donde se requiere manipular solo con las manos la interfaz, o incluso
con comandos de voz y donde no haría falta que el usuario estuviera de pie.
Figura 19 Esqueleto modo sentado
Arreglo de Micrófonos
El dispositivo Kinect cuenta con un arreglo de micrófonos con reconocimiento de +
y – 50 grados frente al sensor, este array de micrófonos está diseñado para poder
ignorar ruidos ambientales y otros sonidos que no sean la voz del usuario.
38
Figura 20 Entrada de audio del Kinect
Para poder lograr el reconocimiento y la eliminación de ruido el laboratorio de
Microsoft se migro a 250 casas con varios micrófonos y realizo pruebas y
grabaciones de los distintos ruidos y ambientes para diferentes hogares para
determinar así la configuración óptima.
Figura 21 Conjunto de micrófonos del Kinect
El arreglo de micrófonos se localiza a los laterales del dispositivo dejando el frente
del Kinect limpio y libre de orificios, es por esta razón que el Kinect tiene esa
anchura. Esta forma es mejor para capturar voces a distancia, pero es el
procesador que cancela los ruidos que provienen de aparatos de audio, la
televisión, etc. Así junto con el sensor de profundidad se puede averiguar tu
posición y crear una esfera de sonido que solo escuche al usuario en cuestión y
no a las personas que vayan pasando o a alguien que estuviera junto.
39
Figura 22 Umbral de sonido del Kinect
Figura 23 Micrófono direccional de Kinect
Con la actualización del nuevo SDK 1.7 de Kinect para Windows y gracias al
“Microsoft Speech Platform” ahora se permite el reconocimiento de hasta 26
lenguas distintas incluyendo ahora el español, se ha trabajado mucho en esta
parte pues el reconocimiento para cada lenguaje es distinto y Kinect presenta un
modelo acústico diferente para cada país y regiones específicas.
40
Microsoft Speech Platform SDK
Esta plataforma proporciona un conjunto completo de herramientas de desarrollo
para crear aplicaciones con habilitación de voz que aprovechan los motores de
voz que se pueden distribuir de Microsoft. Se puede utilizar Microsoft Speech
Platform para dar a las aplicaciones la capacidad de reconocer las palabras
(reconocimiento de voz) y para generar un sintetizador de voz (texto a voz). El uso
de este SDK ofrece a los usuarios una forma efectiva, intuitiva y natural de
interactuar con sus aplicaciones que complemente el uso del mouse, teclado, etc.
Reconocimiento del habla
El reconocimiento automático del habla (RAH) o reconocimiento automático de
voz es una parte de la inteligencia artificial que tiene como objetivo permitir la
comunicación hablada entre seres humanos y computadoras. El problema que se
plantea en un sistema de este tipo es el de hacer cooperar un conjunto de
informaciones que provienen de diversas fuentes de conocimiento (acústica,
fonética, fonológica, léxica, sintáctica, semántica y pragmática), en presencia de
ambigüedades, incertidumbres y errores inevitables para llegar a obtener una
interpretación aceptable del mensaje acústico recibido.
Un sistema de reconocimiento de voz es una herramienta computacional capaz de
procesar la señal de voz emitida por el ser humano y reconocer la información
contenida en ésta, convirtiéndola en texto o emitiendo órdenes que actúan sobre
un proceso. En su desarrollo intervienen diversas disciplinas, tales como:
la fisiología, la acústica, el procesamiento de señales, la inteligencia artificial y la
ciencia de la computación.
Diseño de un sistema de RAH
Un aspecto crucial en el diseño de un sistema de RAH es la elección del tipo
de aprendizaje que se utilice para construir las diversas fuentes de conocimiento.
41
Básicamente, existen dos tipos:
Aprendizaje deductivo: Las técnicas de Aprendizaje Deductivo se basan en
la transferencia de los conocimientos que un experto humano posee a un
sistema informático. Un ejemplo paradigmático de las metodologías que
utilizan tales técnicas lo constituyen los Sistemas Basados en el Conocimiento
y, en particular, los Sistemas Expertos.
Aprendizaje inductivo: Las técnicas de Aprendizaje Inductivo se basan en
que el sistema pueda, automáticamente, conseguir los conocimientos
necesarios a partir de ejemplos reales sobre la tarea que se desea modelizar.
En este segundo tipo, los ejemplos los constituyen aquellas partes de los
sistemas basados en los modelos ocultos de Márkov o en las redes neuronales
artificiales que son configuradas automáticamente a partir de muestras de
aprendizaje.
En la práctica, no existen metodologías que estén basadas únicamente en el
Aprendizaje Inductivo, de hecho, se asume un compromiso deductivo-inductivo en
el que los aspectos generales se suministran deductivamente y la caracterización
de la variabilidad inductivamente.
Decodificador acústico-fonético
Las fuentes de información acústica, fonética, fonológica y posiblemente léxica,
con los correspondientes procedimientos interpretativos, dan lugar a un módulo
conocido como decodificador acústico-fonético (o en ocasiones a un decodificador
léxico). La entrada al decodificador acústico-fonético es la señal vocal
convenientemente representada; para ello, es necesario que ésta sufra un pre
proceso de parametrización. En esta etapa previa es necesario asumir algún
modelo físico, contándose con modelos auditivos y modelos articulatorios.
42
Modelo del lenguaje
Las fuentes de conocimiento sintáctico, semántico y pragmático dan lugar al
modelo del lenguaje del sistema. Cuando la representación de la Sintaxis y de la
Semántica tiende a integrarse, se desarrollan sistemas de RAH de gramática
restringida para tareas concretas.
Clasificación
Los sistemas de reconocimiento de voz pueden clasificarse según los siguientes
criterios:
Entrenabilidad: determina si el sistema necesita un entrenamiento previo antes
de empezar a usarse.
Dependencia del hablante: determina si el sistema debe entrenarse para cada
usuario o es independiente del hablante.
Continuidad: determina si el sistema puede reconocer habla continua o el
usuario debe hacer pausas entre palabra y palabra.
Robustez: determina si el sistema está diseñado para usarse con señales poco
ruidosas o, por el contrario, puede funcionar aceptablemente en condiciones
ruidosas, ya sea ruido de fondo, ruido procedente del canal o la presencia de
voces de otras personas.
Tamaño del dominio: determina si el sistema está diseñado para reconocer
lenguaje de un dominio reducido (unos cientos de palabras p. e. reservas de
vuelos o peticiones de información meteorológica) o extenso (miles de
palabras).
Usos y aplicaciones
Aunque en teoría cualquier tarea en la que se interactúe con un ordenador puede
utilizar el reconocimiento de voz, actualmente las siguientes aplicaciones son las
más comunes:
Dictado automático: El dictado automático es, en el 2007, el uso más común
de las tecnologías de reconocimiento de voz. En algunos casos, como en el
43
dictado de recetas médicas y diagnósticos o el dictado de textos legales, se
usan corpus especiales para incrementar la precisión del sistema.
Control por comandos: Los sistemas de reconocimiento de habla diseñados
para dar órdenes a un computador (p.e. "Abrir Firefox", "cerrar ventana") se
llaman Control por comandos. Estos sistemas reconocen un vocabulario muy
reducido, lo que incrementa su rendimiento.
Telefonía: Algunos sistemas PBX permiten a los usuarios ejecutar comandos
mediante el habla, en lugar de pulsar tonos. En muchos casos se pide al
usuario que diga un número para navegar un menú.
Sistemas portátiles: Los sistemas portátiles de pequeño tamaño, como los
relojes o los teléfonos móviles, tienen unas restricciones muy concretas de
tamaño y forma, así que el habla es una solución natural para introducir datos
en estos dispositivos.
Sistemas diseñados para discapacitados: Los sistemas de reconocimiento de
voz pueden ser útiles para personas con discapacidades que les impidan
teclear con fluidez, así como para personas con problemas auditivos, que
pueden usarlos para obtener texto escrito a partir de habla. Esto permitiría, por
ejemplo, que los aquejados de sordera pudieran recibir llamadas telefónicas.
Coding4Fun KinectToolkit
Coding4Fun es una comunidad web dedicada a mostrar divertidos y frescos
proyectos de software y hardware. Coding4Fun inicio originalmente en 2005 como
una serie de artículos escritos para MSDN con el fin de resaltar interesantes
proyectos de Visual Studio .NET. Ahora trabajan con proyectos, artículos, blogs,
videos y herramientas que facilitan muchas tareas, entre ellas se encuentra
Coding4Fun Kinect Toolkit que es una serie de librerías que facilitan el trabajo
con el Kinect para Windows, simplemente con agregar las referencias al proyecto,
44
y hacer uso fácilmente código que expone, para controlar datos del sensor de
profundidad, los datos del Skeleton y controles como Hover Button para el cual
solo hace falta arrastrar, soltar y comenzar a trabajar.
Kinect Contrib
Kinect Contrib es un conjunto de extensiones para ayudar al desarrollo para el
SDK de Kinect para Windows. Este es un proyecto de la misma comunidad de
usuarios con el objetivo de mejorar y ampliar las capacidades de integración y
desarrollo del SDK para Kinect.
Kinect Contrib se puede descargar libremente del sitio:
http://kinectcontrib.codeplex.com/ y una vez instalada se agregan templates listos
para usar con el entorno preparado dependiendo de la aplicación con la que se
desee trabajar (ver Figura 24), ofrece plantillas para manejar los datos del sensor
de profundidad, datos del Skeleton y también para trabajar con la cámara de color
del Kinect.
Figura 24 Kinect Contrib Templates
45
Descripción de las actividades realizadas
Configuración del entorno de desarrollo
La primera tarea que debemos tener clara después de instalar el SDK de Kinect
para Windows y los drivers correspondientes es preparar el entorno de desarrollo
para que las aplicaciones puedan interactuar con el dispositivo de manera
correcta; a continuación se describirá la serie de pasos que hay que seguir para
realizar esta tarea.
En la siguiente figura se muestra el tipo de aplicación que se debe elegir en el IDE
Visual Studio, en este caso es un proyecto WPF Aplication, y se ha elegido a
propósito así porque la mayoría de la documentación que se encuentra en libros y
en internet en cuanto al manejo del SDK de Kinect para Windows se maneja en
Windows Presentation Foundation incluso el Toolkit y sus ejemplos son basados
en esta tecnología junto con sus diferentes lenguajes que pueden ser C#, Visual
Basic o C++.
Figura 25 Proyecto WPF
46
Una vez creado nuestro proyecto es muy importante agregar las referencias
necesarias que se instalan en la misma carpeta donde se encuentra el SDK de
Kinect para Windows.
Figura 26 Agregar Referencias
Comúnmente estas Dll’s10 necesarias se encuentran en C:\Program
Files\Microsoft SDKs\Kinect\(v1.x/Developer Toolkit v1.x.x), en este directorio
encontramos referencias como:
Microsoft.Kinect.Toolkit.dll
Microsoft.Kinect.Toolkit.Fusion.dll
Microsoft.Kinect.Toolkit.Interaction.dll
Microsoft.Kinect.Toolkit.Controls.dll
10
DLL es el término con el que se refiere a los archivos con código ejecutable que se cargan bajo demanda de un programa por parte del sistema operativo. Esta denominación es exclusiva de Microsoft.
47
Figura 27 Assembles del SDK 1.7 de Kinect
La referencia que nunca debe faltar en un proyecto donde se haga uso del Kinect
es precisamente Microsoft.Kinect.dll, pues en ella encontramos propiedades y
métodos con los cuales se administran y sobre todo se generan y obtienen datos
de los sensores de profundidad, la cámara RGB, Skeleton, Audio, etc.
Figura 28 Referencia a Microsoft.Kinect.dll
En el namespace Microsoft.Kinect podemos ver métodos como
AllFramesReadyEventArgs que nos da acceso en un solo evento a todos los
48
modos que estén habilitados por ejemplo al inicializar el dispositivo, así como
también el evento ColorImageFrame, DepthImageFrame, SkeletonFrame, etc.
Figura 29 Namespace Microsoft.Kinect
Para usar las nuevas mejoras que se liberaron con la versión 1.7 del SDK de
Kinect para Windows se tienen que agregar dos ficheros extra al proyecto y la
forma más fácil de acceder a ellos es en la carpeta de ejemplos del Toolkit que se
encuentra en C:\Program Files\Microsoft SDKs\Kinect\Developer Toolkit
v1.7.x\Samples\bin se pueden agregar desde el Explorador de soluciones de
Visual Studio o también copiando y pegando los archivos en la carpeta de nuestro
proyecto.
49
Figura 30 Ubicación de los archivos Kinect Interaction
Si agregamos KinectInteraction desde el explorador de soluciones debemos
modificar en las propiedades del archivo en la opción Copy to Output Directory:
Copy always, ya que de otra manera la aplicación lanzara una excepción en
tiempo de ejecución por la ausencia del mismo.
Figura 31 Propiedades necesarias a los archivos Kinect Interaction
50
Extracción y generación de datos con el Kinect
Para la extracción y control de datos que nos proporciona el Kinect debemos
conocer la arquitectura del dispositivo, como es que está administrando el
software al hardware y como es que el Kinect responde a esto. En la figura
siguiente se presenta un esquema en general del funcionamiento de una
aplicación que interactúa con el Kinect. En primer lugar se encuentra el Kinect
conectado al puerto USB de la computadora, a nivel de usuario de sistema
operativo se encuentra el SDK que realiza la conexión con el Kinect y permite
obtener los datos de los sensores de profundidad, la cámara de color e infrarrojos
así como el audio del array de micrófonos.
Figura 32 Flujo de datos desde el Kinect a una aplicación y viceversa
Una vez comprendido el flujo de datos que se lleva a cabo en una aplicación que
interactúa con el Kinect, es importante también mostrar el diagrama de flujo (ver
Figura 33) dentro de la aplicación, en el cual se puede observar cómo es que se
crean las variables necesarias para manejar el dispositivo (KinectSensor, un array
de bytes para almacenar el flujo de datos obtenidos) y los streams de datos
51
correspondientes, estos dependen de lo que se quiera manejar, por ejemplo
VideoFrameReady para el video, SkeletonFrameReady para acceder a las
propiedades y controlar un skeleton del usuario, DepthFrameReady para controlar
los datos de profundidad, etc.; después se verifica si el dispositivo está preparado
pues el SDK de Kinect expone diferentes modos en que se puede encontrar el
dispositivo en la propiedad Status como son: Conectado, Desconectado,
Inicializado, En Error, No Preparado, etc., seguido de esto se pregunta si hay
datos que leer porque aunque el dispositivo se encuentre preparado esto no
significa que obtendrá siempre datos válidos para trabajar, por ejemplo mientras
se hace el rastreo de un esqueleto y luego el usuario sale de la área visible, el
dispositivo pasa a un estado de preparado pero sin lectura de datos; para el
siguiente paso se procesan en alguna tarea específica dependiendo del stream
que se maneje ya sea de Profundidad (depth), Video o Audio, y cuando se decida
o ya no haya datos que procesar se termina la ejecución.
52
Figura 33 Diagrama de flujo de una aplicación que interactúa con el Kinect
53
A continuación se muestra la parte del Code-behind11 en que debemos inicializar
algunas variables para trabajar con los distintos modos que proporciona el Kinect y
que se serán necesarios para nuestro proyecto, enseguida esta la parte donde las
tareas que se llevan a cabo, se obtiene el Kinect y se establecen los streams que
utilizaremos en la aplicación. Ver Figura 34.
Figura 34 Inicialización de variables
Enseguida en el evento Loaded de la aplicación se establecen también los
manejadores para cada stream, es aquí donde la aplicación sabrá qué hacer
cuando detecte determinado tipo de dato. Ver Figura 35.
Figura 35 Se muestra como se suscriben a los streams
11
Code-behind: Es una técnica que básicamente separa en archivos diferentes el diseño de la aplicación y el código, para un mejor control, como su nombre lo indica el code-behind es la parte del código fuente.
54
Una vez descrito el proceso que conlleva el uso del Kinect en una aplicación se
describira cada parte de los modos en que se pueden extraer los datos y trabajar
con ellos. Se explicaran los 3 modos de los que hacemos uso en el proyecto
RESA.
• VideoFrameReady
• SkeletonFrameReady
• DepthFrameReady
A partir de este momento todo lo anterior en cuanto a inicializacion y manejo de
variables es exactamente igual, y nos centraremos basicamente en el
procesamiento de cada stream según estemos controlando, la Figura 36 indica en
que parte del diagrama de flujo estaremos trabajando.
Figura 36 Procesamiento de los Streams
55
Extraccion y manejo de la camara de video (VideoFrameReady)
Para hacer uso de los datos de la camara RGB lo primero que tenemos que hacer
es crear en nuestra interfaz, los elementos necesarios para desplegar el raw12 de
datos a un elemento visual como lo es uno de tipo Image que se encuentra en el
espacio de nombres System.Windows.Controls.Image y que sera perfecto para
esta tarea. Asi pues procederemos a crear un grid y dentro dos controles Image
como se muestra en la siguiente Figura.
Figura 37 XAML que crea nuestra interfaz
Esto creara en tiempo de diseño algo como lo que se muestra en la Figura 38.
Figura 38 Interfaz en tiempo de diseño con dos controles Image
En el tema anterior se mostró que para cada aplicacion que haga uso del Kinect
habia que seguir una serie de pasos, y para no ser tan repetitivos se omitira esa
parte que es donde se inicializan las variables y nos suscribimos al los eventos de
12
Formato de Imagen sin modificaciones") es un formato de archivo digital de imágenes que contiene la totalidad de los datos de la imagen tal y como ha sido captada por el sensor digital.
56
los manejadores de determinado stream, en este caso se usara
VideoFrameReady y DepthFrameReady en el evento Window_Loaded.
sensor.ColorFrameReady += runtime_VideoFrameReady;
Tip: para hacer mas rapida esta tarea se recomienda solo escribir
“sensor.VideoFrameReady+=” y a continuacion dos veces la tecla tab y el
Intellisense de Visual Studio nos creara el evento correspondiente.
En la figura siguiente se muestra el pseudocodigo del evento VideoFrameReady
que se encargara basicamente de obtener en la variable CFrame en stream de
ColorImageFrame si se obtienen datos se asigna un tamaño y se copian esos
datos en crudo, se indica la bandera receiveData a true para despues crear un
BitmapSource de esos datos que seran enviados a un control Image en su
propiedad Source y es esta en la que visualizaremos los datos de la camara de
color del Kinect.
Figura 39 Evento runtime_VideoFrameReady
57
Comprendiendo los valores que retorna el VideoFrameReady
El VideoFrame retorna un ImageFrameReadyEventArgs que contiene una clase
ImageFrame, como se muestra mas abajo ImageFrame contiene varias
propiedades como Tipo, para saber si es de color o profundidad asi como
resolucion con la cual podemos conocer el tamaño, etc. Tambien tenemos un tipo
Image que almacena los datos actuales de la imagen que estan almacenados en
un Array de Bytes.
Figura 40 Esquema de la clase ImageFrame
Convirtiendo el array de bytes a imagen
Para convertir el array de bytes que representa a una imagen y mostrarlo en un
control Image de WPF por ejemplo, podemos hacer uso de BitmapSource y en
tiempo de ejecucion estar creando un Bitmap con los valores obtenidos.
58
Datos de profundidad (DepthFrameReady)
Para mostrar los datos de la camara de profundidad manejaremos el evento
DepthFrameReady al cual nos suscribimos igualmente en el evento
Window_Loaded con la sentencia:
sensor.DepthFrameReady += runtime_DepthFrameReady;
Lo que sucede en el evento runtime_DepthFrameReady se describe en la
siguiente figura con el pseudocodigo, primero se obtiene en la variable DFrame el
flujo de datos de OpenDepthImageFrame que expone
DepthImageFrameReadyEventArgs a continuación se comprueba que
efectivamente los datos no sean nulos, se obtiene el tamaño del frame y se copian
a DFrame, después se cambia la bandera receiveData a true para que al pasar
por la validación de la siguiente sentencia se cree el Bitmap y se agregue como
source del control Image declarado anteriormente en la interfaz.
Figura 41 Evento runtime_DepthFrameeReady
59
A continuacion se muestra lo descrito anteriormente funcionando en la aplicación,
en la parte izquierda se muestra la camara RGB y en la parte derecha los datos de
profundidad.
Figura 42 Aplicación que muestra los datos RGB y los datos de profundidad
Implementacion de Hover Button para manejar el Kinect como cursor
Se describira la creacion de un Hover Button o Hover Control como el que
presentan los videojuegos y la interfaz estilo metro de la consola con el dispositivo
Kinect, se debe crear un user control para que a partir de este, se puedan
controlar no solo controles de boton si no cualquier otro elemento que herede del
tipo FrameworkElement que expone propiedades, eventos y metodos para
elementos de Windows Presentation Foundation, esta clase representa la
implementacion a nivel de core proporcionado por WPF y que se basa en el API
que se define en UIElement.
El control HoverButton puede contener una imagen, un texto o ambos y se pueden
cambiar de tamaño para adaptarse a las necesidades de la aplicación, se
implementa un evento click que ocurre despues de posicionar el cursor del kinect
por un determinado lapso de tiempo tambien personalizable.
A continuacion se presenta la implementacion del Control Hover Button, para esto
hace falta crear una nueva solucion o en su defecto si se esta trabajando ya sobre
60
un proyecto solo añadir un nuevo User Control que llamaremos HoverButton. Ver
Figura 43.
Figura 43 Creación de User Control
y se agregaran las propiedades siguientes:
Propiedad Tipo Valor Predeterminado
HoverColor Brush Color.White
TextColor Brush Color.White
Image String “”
TextSize Int 40
Se crea el XAML correspondiente y se enlazan las propiedades a la interfaz,
tambien se agregan las propiedades de duracion, animacion,etc. Figura 44.
61
Figura 44 Propiedades de HoverButton
Se agregan dos nuevos metodos para controlar la animacion cuando el cursor se
encuentre dentro del boton y la animacion de reversa para cuando salga del
mismo. Figura 45.
Figura 45 Métodos Hovering y Release
62
Controlar el mouse con las manos a traves del Kinect
Hasta hemos creado un control (Hover Button) que servira para interactuar con la
aplicación pero hace falta tambien controlar quien lo lanzara, es decir quien le dira
como y cuando debe ocurrir una accion, para llevar a cabo esta tarea
manejaremos en el evento en cual nos suscribimos en Window_Loaded.
sensor.SkeletonFrameReady += runtime_SkeletonFrameReady;
A continuación se muestra el pseudocodigo utilizado en el evento
runtime_SkeletonFrameReady, basicamente lo que sucede aquí es que se obtiene
en la variable SFrame los datos de Skeleton en ese momento, si se obtienen datos
validos se le da el tamaño y valores necesarios para trabajar al SFrame,
enseguida se obtiene el primer esqueleto trackeado, como se puede ver en la
linea 50 de la Figura 46, luego se pregunta nuevamente si los valores del skeleton
actual son diferentes de nulo, pues como se ha insistido en esto, no hace falta
comprobar solo una vez que hay un skeleton rastreado, puesto que una vez
detectado un usuario y se entre al evento entre la inea 48 y 49 si el usuario decide
salir del area visible para el dispositivo en ese momento ya no se cumpliria la
condicion y se generaria una excepcion, que puede ser controlada de esta
manera.
Figura 46 Manejo del mouse en SkeltonFrameReady
63
Como se puede observar para controlar la posicion del mouse se esta manejando
un evento setEllipsePosition que recibe como parametros una ellipse que no es
mas que un control de tipo System.Windows.Shapes.Ellipse, aunque tambien se
puede usar un tipo rectangle, line o cualquier otro que encierra el namespace
System.Windows.Shapes, también este método recibe un joint que en este caso
es el elemento clave pues será el joint de la mano con la cual el usuario podrá
visualizar en la interfaz de usuario como si de un mouse se tratara, aquí se crea
un vector que contendrá las coordenadas X,Y y Z. Ver Figura 47
Figura 47 Método SetEllipsePosition
Se hace tambien uso de un metodo llamado ScaleVector que practicamente lo que
esta haciendo es escalar en base a los parametros de tamaño y posicion de un
joint el vector por el cual se movera nuestro cursor, es en este metodo donde
podemos controlar la precision del cursor con respecto a la interfaz de la
aplicación, podemos por ejemplo multiplicar por 2 para hacer movimientos mas
rapidos pero que no estaran muy centrados respecto a la mano del usuario o
multiplicar por 0.5 para mantenernos mas cerca de la mano del usuario, esto ya
depende de como se desea tener el control, como se puede ver, se maneja un
width y un height que precisamente son el alto y ancho de la ventana donde se
ejecuta la aplicación, esto realmente es necesario pues debemos lograr que el
usuario llegue hasta el punto mas alejado de la pantalla desde el centro de la
aplicación sin que tenga que alejarse tanto o acercarse a la pantalla o vision del
64
Kinect, obviamente respetando los limites fisicos del mismo, ni tampoco que tenga
que caminar hacia un lado o hacia al otro para dar un click o mover un objeto,
entonces con esto logramos controlar esas situaciones. Ver Figura 48.
Figura 48 Método ScaleVector
Dentro del metodo setEllipsePosition tambien se hace uso de setPosition pues
antes se creo un vector que escala su posicion respecto al tamaño de la ventana
donde se ejecuta la aplicación, con estas mismas coordenadas se actualizara la
posición de la elipse que toma los valores de los joints del skeleton en ese
momento; enseguida se toman las posiciones del joint en cada instante pues ese
es el puntero del mouse.
Figura 49 Método setPosition
65
A continuación podemos observar el resultado de estas operaciones en una
aplicación. Ver Figura 50.
Figura 50 Interfaz que muestra los joints de las manos y la cabeza con tres elipses rojas
Se aprovecharan las bondades de la tecnología WPF para darle un mejor feeling a
lo que un usuario está acostumbrado a ver; al control elipse que es el puntero se
le asignara en su propiedad Fill un ImageBrush que lo hace es mostrar una
imagen como relleno, la imagen que asignaremos es una mano similar a la que se
muestra en la interfaz de la consola del Kinect, a continuación se muestra el
fragmento de código de cómo realizar esta tarea.
Figura 51 Cambiar cursor establece una imagen como relleno de un elemento elipse
66
Despues de aplicar el paso anterior, volvemos a lanzar la aplicación y
visualizamos los cambios con el cursor que es similar al que estamos
acostumbrados en la consola de Xbox y para el usuario es mas comodo trabajar
con un cursor en la interfaz que con una figura circular.
Figura 52 Aplicación que muestra el cursor con una mano
Manejo de datos del Skeleton (SkeletonFrameReady) junto con el Hover
Button
Ahora se mostrará un ejemplo de como utilizar el control Hover Button junto con el
stream de datos Skeleton ya que es el stream indicado pues haremos uso del los
joints que nos proporciona y justamente los Joints de las manos seran utilizados
como si se tratara de un mouse, asi una vez agregado en nuestra interfaz el
control Hover Button que acabamos de crear trabajaremos en el stream
SkeletonFrameReady.
Hasta esta parte como se ha mencionado antes solo trabajamos en la parte de
procesamiento que indicaba el diagrama de flujo que se mostró en el tema
extraccion y generacion de datos, asi que solo se mostrara el pseudocodigo del
manejador del evento SkeletonFrameReady.
67
sensor.SkeletonFrameReady += runtime_SkeletonFrameReady;
Hasta el punto en que se obitenen los datos del skeleton las cosas funcionan de la
misma manera como antes ya se habia dado la explicacion pero hasta esta parte
se obtienen los puntos de la cabeza, la mano izquierda y derecha, y sera en esta
parte del codigo donde se tendran que declarar todos aquellos manejadores,
acciones y eventos que interactuen con el Kinect, en este caso en CheckButton se
agrega un boton que es de tipo Hover Button y el Joint que lo disparará en este
caso HandRigth osea la mano derecha. Ver Figura 53.
Figura 53 Manejo del HoverButton en el SkeletonFrameReady
Lo que hace el metodo CheckButton es controlar si el control Hover Button ha sido
presionado (hovering), comunmente lo conocemos como MouseButtonDown, o
liberado (release) como MouseButtonUp, esto se logra a su vez a traves del
metodo IsItemMidpointInContainer.
68
Figura 54 Método CheckButton
Pero, ¿Como es que CheckButton a traves de IsItemMidpointInContainer puede
saber si el elemento se presiono o se libero?, pues lo que esta haciendo
IsItemMidpointInContainer es determinar con el target que es de tipo joint y con el
container que es un elemento de tipo HoverButton sus posicion y comparar si el
joint esta dentro en los limites de dicho elemento ya sea arriba, abajo, a la
izquierda y a la derecha, si esto se cumple quiere decir que el puntero se
encuentra dentro del elemento, de otro modo se encuentra fuera de el. Ver Figura
55.
Figura 55 Metodo que reconoce si se está dentro de un elemento
69
Mientras IsItemMidpointInContainer este actuando sera por que el metodo
FindValues le avisará que realmente se encuentra en el medio de un elemento y
con esto queda completo el proceso de Hovering y Release del control Hover
Button. Ver Figura 56.
Figura 56 Método que obtiene los límites de un control
Así es como se ve el control Hover Button funcionando en la aplicación
Figura 57 Aplicación donde se muestra la interacción del Kinect como cursor
70
Movimientos del cuerpo a comandos de interacción
Para lograr la interacción humano-computadora siempre se usan órdenes o
comandos que a través de la interfaz gráfica se traducen a tareas que debe
realizar la aplicación en cuestión, y que comúnmente se presentan como clic del
ratón, la presión de una tecla, etc. Cuando se habla de interacción con objetos
físicos del mundo real como abrir o cerrar una puerta, pasar la página de un libro
por ejemplo, se necesitaría sostener el objeto y girarlo o arrastrarlo de un lugar a
otro según sea el caso. Ya se ha explicado de la forma en que se maneja el Kinect
como cursor y como interactuar con un control que se ha creado y simular el clic
de un mouse, ahora se describirá la implementación de comandos que actúen
como arrastre e interacción con un menú en una interfaz de usuario común y
obviamente haciendo uso del Kinect como herramienta principal.
Figura 58 Interacción entre aplicación y Kinect
La figura siguiente muestra el esquema de cómo funciona un menú que es
controlado con el movimiento de la mano como si del cambio de una hoja de un
libro se tratara, se lleva la mano de izquierda a derecha o viceversa para ir de una
página a otra pues esta es la forma más usual en que un usuario está
acostumbrado manejar objetos de la vida real.
71
Figura 59 Esquema de un slider de interacción con el Kinect
Para llevar a cabo esta tarea vamos a preparar nuestra interfaz agregando
algunos controles de imagen, uno que será nuestro contenedor de imágenes y
otro en que mostraremos la cámara RGB del Kinect como ya se ha explicado
antes, entonces se tendrá algo similar en la parte del código en XAML.
Figura 60 Código XAML que muestra la preparación de la interfaz
72
Así es como se mostraría en tiempo de diseño, cabe resaltar que por el momento
el control llamado videoImage no está visible ya que una vez lanzada la aplicación
se cargaran los datos desde la cámara RGB. Ver Figura 61.
Figura 61 Interfaz en tiempo de diseño
Lo que se necesita es que cuando el usuario haga un movimiento como si de un
cambio de página se tratara ya sea de izquierda a derecha o de derecha a
izquierda se captara ese gesto y se desencadenara una acción que simule el pase
de página, menú, o mostrar más elementos respondiendo a dicha gesticulación.
Ver Figura 62.
73
Figura 62 Se puede observar como el usuario interactuaría con la aplicación
Lo que se ha agregado al evento es la comparación de la posición de la mano con
respecto a la posición de la cabeza esto es porque aunque se oye ridículamente
lógico pero la cabeza nunca cambiara de lugar en el cuerpo con respecto a las
manos y aprovecharemos esta ventaja para tomar como referencia desde y hacia
donde se está dando el gesto; como se puede observar en la Figura 63, si la
posición de la mano izquierda en x (L.x) es mayor a la posición de la cabeza (H.x)
se registra un movimiento de pase que va de izquierda a derecha, acción contraria
que sucede cuando la posición de la mano derecha en x (R.x) es menor a la
posición de la cabeza (H.x) se registra un movimiento de pase que va de derecha
a izquierda logrando así la gesticulación deseada.
74
Figura 63 Modelo que se maneja para administrar la gesticulación
Ahora se muestra el pseudocódigo utilizado dentro del evento
SkeletonFrameReady, como se podrá notar es de los eventos más importantes en
cualquier aplicación, porque mientras los otros streams muestran datos e
información de los sensores, para gestos del cuerpo necesitamos siempre de los
joints del skeleton y sus posiciones son vitales para controlar el movimiento que
simulara el slider en la aplicación, en el codigo se puede ver como se compara
HandRightPositionX < HeadPositionX como se había mencionado antes para
saber si se llevó la mano de la derecha a la izquierda o también HandLeftPositionX
> HeadPositionX para saber si se llevó la mano de izquierda a derecha, aquí solo
se cambia el índice de la imagen en el contenedor para mostrar la siguiente
imagen o la anterior según sea el caso, claro que sería dentro de esta condición
donde se manejaría la acción que la aplicación llevaría a cabo en caso de detectar
la gesticulación.
75
Figura 64 Pseudocodigo que procesa la gesticulación de arrastre de la mano
Reconocimiento de Voz
Para lograr el reconocimiento de voz con el dispositivo Kinect se ha estado
trabajando en nuestro entorno de desarrollo de forma similar para el control de los
diferentes streams de color, profundidad, skeleton, etc., pero ahora es necesario
modificar gran parte del código fuente y agregar algunas otras variables para el
manejo del reconocimiento del audio. Lo primero que se tiene que hacer es
agregar una variable de tipo SpeechRecognitionEngine que es la que administrara
el flujo del audio para hacer los reconocimientos de voz. Ver Figura 65.
Figura 65 Variables para manejar el reconocimiento de voz
76
Ahora en el evento SensorChooserOnKinectChanged se prepara el
speechRecognizer, entre la línea 42 y 44 de la figura siguiente se está omitiendo
el codigo que administra los streams de Video, Depth y Skeleton, pues aunque
igualmente se utilizan, solo sería codigo repetitivo, enseguida se obtiene el id del
recognizerInfo es decir la voz que se eligió, y se agregan los comandos de voz, es
decir las palabras, frases, etc., que necesitemos en nuestra aplicación.
Figura 66 Preparando speechRecognizer
En el evento anterior se hace uso de GetKinectRecognizer que lo que devuelve es
un RecognizerInfo con el lenguaje al que debe reconocer, esto se logra con la
sentencia en la línea 32 de la Figura 67 donde se recorren los recognizer
instalados en la computadora, recordemos que para la nueva versión del Speech
SDK ahora se reconoce la voz en español es por eso que hacemos la
comparación en CultureName con “es-MX” y se regresa ese recognizer para la voz
en español de México.
77
Figura 67 RecognizerInfo que devuelve el idioma de la voz que vamos a reconocer
El evento SpeechRecognized es el más importante pues aquí se hace la
comparación entre el resultado de confidencia de el comando de voz escuchado y
el límite de confianza para el reconocimiento, el umbral de reconocimiento toma
valores entre (0.0 y 1.0), si obtenemos un 30% de confianza tomaremos el
resultado como verdadero, cabe aclarar que para esta parte se deben tomar
medidas estrictas en cuanto a los comandos que queremos reconocer y no crear
condiciones ambiguas en cuanto a dicción por ejemplo “acción” y “canción”
podrían caer en el umbral de confianza al mismo tiempo y corremos el riesgo de
que la aplicación responda distinto a lo que esperamos.
Una vez que la condición en la línea 9 de la Figura 68 es validada se toma la lista
de comandos y para cada caso se dispara la acción deseada, es en este punto
donde podemos lanzar otra aplicación, enviar un mensaje, ejecutar un método,
etc.
78
Figura 68 Proceso que lanza las acciones de los comandos reconocidos
Como se recordará anteriormente también se debe controlar SpeechRejected que
se ejecuta al momento en que el comando es rechazado, aquí se pueden manejar
notificaciones por ejemplo para que el usuario hable con más claridad, que se pare
bien frente al Kinect, etc.
Figura 69 Proceso que se dispara cuando no se reconoce un comando de voz
79
Reconocimiento Facial
A continuación se va a describir el funcionamiento del FaceRecognition que se
puede lograr con el Kinect, para esto crearemos un nuevo proyecto WPF y se
seguirán los siguientes pasos:
Desde la carpeta de instalación del Kinect SDK Developer Toolkit, agregaremos
las referencias a los ensamblados de FaceTracking, la ubicación es similar a:
C:\Program Files\Microsoft SDKs\Kinect\Developer Toolkit vx.x.x\Samples\bin
Y agregamos las referencias
Microsoft.Kinect.Tookit
Microsoft.Kinect.Tookit.FaceTracking
Figura 70 Referencias necesarias para lograr el FaceTracking
También se tienen que cambiar en la propiedades del proyecto que compile en
modo x86, esto se logra haciendo clic derecho en el proyecto actual, luego en el
apartado build en Platform target elegimos x86. Ver Figura 71.
80
Figura 71 Modo de compilación x86
Después de realizar el paso anterior vamos a la ruta
C:\Program Files\Microsoft SDKs\Kinect\Developer Toolkit vx.x.x\Redist\x86
Y copiaremos los ensamblados a la carpeta de compilación de nuestro proyecto.
Ver Figura 72.
Figura 72 Carpeta Debug donde copiamos los asemblies de FaceTracking
Ahora se agregan al proyecto un user control llamado FaceTrackingViewer y una
clase llamada SkeletonFaceTracker, el código que poseen es bastante extenso y
es Open Source, así que podemos copiarlo, usarlo y modificarlo, etc.
81
La clase SkeletonFaceTracker es la encargada de utilizando los ensamblados del
Toolkit, reconocer y pintar los puntos de la cara. Para esto se suscribe al evento
OnFrameReady del sensor Kinect y en el mismo, utiliza el Toolkit para obtener los
puntos de la cara.
Figura 73 Evento OnFrameReady para obtener los puntos de la cara
Esta clase posee otra función que es la que se encarga de dibujar la máscara
sobre un canvas, donde están los puntos de la cara. A partir de la colección de
puntos se crea un array de triángulos y se los pinta sobre un contexto de trabajo.
Figura 74 Método que dibuja una maya en la cara con los puntos detectados
Ahora veremos la parte donde se pinta dentro del FaceTrackingViewer en el
evento OnAllFramesReady que es donde se están procesando todos los datos del
Kinect, cuando se identifica un skeleton se procede a crear una nueva instancia de
SkeletonFaceTracker y se ejecutan los pasos anteriores para detectar un
rostro/face. Ver Figura 75.
82
Figura 75 Se hace un proceso de trazado para cada Skeleton detectado
Finalmente en la función OnRender se pinta la cara
Figura 76 Función OnRender se dibuja la máscara de puntos en la aplicación
Figura 77 Aplicación FaceTracking en tiempo de ejecución
83
Como lograr la comparación entre rostros
Hasta ahora se ha mostrado a grandes rasgos como se hace el dibujado y
seguimiento de las facciones del rostro, ahora se necesita con esos datos hacer
funcionar el reconocimiento y analizar las características de los puntos que los
ensamblados del SDK nos proporciona, pues con ellos se puede obtener e
identificar hasta más de 80 joints del rostro y estos pueden ser de dos tipos, 2D y
3D siendo el segundo el que utilizaremos, pues con cada punto obtenemos
información en un vector tridimensional con valores de la posición en ese
momento de la cara en X, Y y Z a continuación se muestra una figura de como el
Kinect ve la cara trackeada.
Este es un esquema de la numeración de los puntos identificado en el rostro,
como se puede observar hay 87 puntos identificados en un rostro. Además que el
FaceTracking identifica 13 puntos más, como son el centro de los ojos, el centro
de la nariz, contornos de la boca y los límites de donde se está realizando el
trackeo.
Figura 78 Puntos que se reconocen en el rostro
84
Figura 79 Esquema de como el dispositivo trackea un rostro
Figura 80 Rango donde se lleva a cabo la validación y comparación de datos
85
Resultados, planos, gráficas y programas
Slide
Se implementó la funcionalidad de un slide en la aplicación tanto para pasar de
una pantalla a otra, como para navegar entre los menús, toda la estructura, diseño
y codificación se explicaron en puntos previos también se creó un control
HoverButton y el seguimiento de las manos para darle funcionalidad como ratón a
los gestos y esto obviamente va implícito en la aplicación, en la Figura 81 se
muestra como está actuando la mano del usuario como cursor en la aplicación y
se está manejando la cámara de color para que el usuario pueda ver los
movimientos que está haciendo en ese momento.
Figura 81 Aplicación con un Slide interactuado con el Kinect
En la Figura 82 se hace el pase a la siguiente imagen disponible y se ve el cambio
y se observa al usuario como está realizando la acción con el movimiento de la
mano
86
Figura 82 Pase al siguiente slide
Menú y aplicación con dispositivos
Con la descripción de todo lo anterior se logró crear un ambiente muy agradable a
la hora de trabajar con el Kinect y las gesticulaciones del cuerpo, la interfaz que se
muestra solo se hizo me manera meramente funcional pues esta parte del
proyecto solo se encarga del control del dispositivo para que interactúe con la
aplicación, se sabe que no es la mejor interfaz y no es el objetivo del desarrollo del
proyecto.
87
Figura 83 Primera Interfaz de prueba
Integración con otros dispositivos
Se logró integrar la parte del Kinect junto con el control de dispositivos
inalámbricos, este apartado pertenece a otro parte del proyecto RESA. A grandes
rasgos lo que está haciendo la aplicación es que a través del puerto serial se
envía una señal con dispositivos inalámbricos con tarjetas ZigBee13 y una placa
arduino para lograr la comunicación y envió de datos.
Además que también responde a comandos de voz para pasar de un menú a otro,
accionar un switch, etc.
13 ZigBee es el nombre de la especificación de un conjunto de protocolos de alto nivel de comunicación inalámbrica para su utilización con radiodifusión digital de bajo consumo, basada en el estándar IEEE 802.15.4 de redes inalámbricas de área personal
88
Figura 84 Kinect e Interacción con la Aplicación
En la parte de abajo se diseñó un menú con un slide para controlar las diferentes
vistas del proyecto, como son vigilancia, energía y control de los focos de la casa,
entre otros.
Figura 85 Se muestra el arrastre en un scroll para el manejo de un menú
Figura 86 Interacción de las manos del usuario
89
Conclusiones y recomendaciones
Al concluir el proyecto se implementó una interfaz natural de usuario y se
alcanzaron los objetivos propuestos al principio, realmente solo se presentó una
pequeña parte del proyecto RESA pues este se divide en tres aspectos que son:
La Interfaz de usuario, Comandos de interacción con el Kinect que es
precisamente el objetivo que describe este documento y por último la Interacción
con dispositivos electrónicos, como se puede comprender cada parte del proyecto
en general es importante, sin embargo al encontrarse esta parte en el medio de
ellas era de vital importancia avanzar con el control de los dispositivos y la interfaz
de usuario para que las otras dos partes del proyecto avanzaran también, a través
de la descripción y procedimientos de este proyecto no se presentan grandes
interfaces de usuario pues en realidad no es el objetivo principal, más bien solo
mostrar la funcionalidad y sobre todo interactuar con las aplicaciones basándonos
en gesticulaciones del cuerpo, comandos de voz, etc.
Con el desarrollo de este proyecto se han adquirido nuevos conocimientos y se ha
mirado en otra perspectiva la forma de hacer programas, algo muy distinto a lo
que se acostumbra a hacer en materias de la carrera, y es de gran satisfacción
además de concluir el trabajo hacer funcionar aplicaciones con las manos o
comandos de voz usando nada más que el cuerpo para dar órdenes sin tener que
adaptarse o aprender a manejar un dispositivo. Esto también sirve como inclusión
digital a personas mayores no acostumbradas o que a veces rechazan la
tecnología y por qué no también para los niños que están en etapa de aprendizaje
se convierte en una excelente herramienta para interactuar con las computadoras
y una forma más interesante para los profesores de enseñar y para los alumnos
en aprender.
Gracias al SDK de Kinect para Windows que Microsoft facilita se pudo explotar
bastante las funcionalidades y ejemplos que ya posee el Toolkit, esto proporciona
una gran ventaja en cuanto a productividad, aunque también se tuvo que invertir
bastante tiempo en comprender en funcionamiento de las librerías y ejemplos que
se mostraban, pero al final valió la pena todo el esfuerzo, se trabajó en un
90
ambiente controlado y con un equipo de trabajo bastante agradable, se espera
más adelante integrar completamente todas las partes del proyecto y porque no
seguir con nuevas propuestas de desarrollo porque después del estudio e
implementación del proyecto se han descubierto muchas de las posibilidades que
el dispositivo Kinect aporta, no solo en la domótica si no en todas las ramas que
uno puedan imaginar, como medicina, enseñanza, robótica, rehabilitación, salud, y
muchas otras más.
Finalmente queda decir que se ha trabajado y se ha desarrollado un producto con
mucho esfuerzo pero aún quedan muchas cosas por hacer, y mejorar algunos
procesos como la optimización del flujo de la aplicación en tiempo de ejecución
para que el rendimiento sea mayor y se puedan ejecutar otras tareas, con esto se
lograría que el sistema corra en computadoras no tan potentes aprovechando al
máximo los recursos, se estudiaron y comprendieron las interfaces naturales de
usuario y se logró crear una aplicación bastante cómoda que responde a los
gestos del cuerpo y a comandos de voz, se aprendieron bastantes cosas, se
adquirieron nuevos conocimientos, y se reforzaron otros más.
91
Referencias bibliográficas
1. Ceballos, Fco. Javier (2010). Enciclopedia de Microsoft Visual C# (3era Ed.). Madrid, España: RA-
MA Editorial.
2. Ceballos, Fco. Javier (2012). Visual C#. Interfaces gráficas y aplicaciones para Internet con WPF,
WCF y Silverlight (1era Ed.). Madrid, España: RA-MA Editorial.
3. Interfaz Natural de usuario. Disponible en: http://es.wikipedia.org/wiki/Interfaz_natural_de_usuario
(Consultado: 20/01/2013)
4. Que es la Domótica. Disponible en: http://www.cedom.es/que-es-domotica.php (Consultado:
23/01/2013)
5. Historia de C#. Disponible en: http://dotnetero.blogspot.es/ Historia CSharp (Consultado: 25/01/2013)
6. C# Definición. Disponible en: http://es.wikipedia.org/wiki/C_Sharp Definición (Consultado:
25/01/2013)
7. IDE. Disponible en: http://es.wikipedia.org/wiki/Entorno_de_desarrollo_integrado (Consultado:
26/01/2013)
8. Visual Studio. Disponible en: http://es.wikipedia.org/wiki/Microsoft_Visual_Studio (Consultado:
26/01/2013)
9. XAML. Disponible en: http://es.wikipedia.org/wiki/XAML (Consultado: 26/01/2013)
10. Introducción al IDE. Disponible en: http://msdn.microsoft.com/es-mx/library/ms173064(v=vs.80).aspx
(Consultado: 28/01/2013)
11. Entorno de desarrollo Integrado. Disponible en: http://msdn.microsoft.com/es-
mx/library/h8w79z10(v=vs.80).aspx (Consultado: 28/01/2013)
12. PrimeSense. PrimeSense Natural Interaction. Sitio Web. Disponible en http://www.primesense.com/
(Consultado: 28/01/2013)
13. Datos del Kinect. Disponible en: http://es.wikipedia.org/wiki/Kinect (Consultado: 04/02/2013)
14. Kinect for Windows SDK 1.5, 1.6, 1.7. Disponible en: http://msdn.microsoft.com/en-
us/library/hh855347.aspx (Consultado: 08/02/2013)
15. Requisitos para el Kinect. Disponible en: http://www.microsoft.com/en-us/kinectforwindows/
(Consultado: 10/02/2013)
16. Sitio Web Kinect for Developers. Disponible en: http://www.kinectfordevelopers.com/ (Consultado:
12/02/2013)
17. Blog con ejemplos y manejo del Kinect. Disponible en: http://hughfernandez.wordpress.com/
(Consultado: 30/03/2013)
18. Microsoft Research. Kinect for Windows SDK Programming Guide. Disponible en:
92
http://msdn.microsoft.com/en-us/library/hh855348.aspx (Consultado: 14/02/2013)
19. Coding4Fun. Disponible en: http://channel9.msdn.com/coding4fun/kinect (Consultado: 20/02/2013)
20. Kinect Contrib. Disponible en: http://channel9.msdn.com/coding4fun/kinect/Kinect-Contrib
(Consultado: 22/02/2013)
21. Manejo del Kinect. Disponible en: http://elbruno.com/category/msn-microsoft/kinect/ (Consultado:
26/02/2013)
22. Kinect Interactions with WPF - Part I: Getting Started. Disponible en:
http://dotneteers.net/blogs/vbandi/archive/2013/03/25/kinect-interactions-with-wpf-part-i-getting-
started.aspx (Consultado: 30/03/2013)
23. Crea tu propia plantilla de proyecto en Visual Studio 2010. Disponible en:
http://csharprules.blogspot.com.es/2012/09/crea-tu-propia-plantilla-de-proyecto-en.html (Consultado:
4/04/2013)
24. How to do Push to Press with Kinect SDK 1.7. Disponible en:
http://www.dotnetfunda.com/articles/article2214-how-to-do-push-to-press-with-kinect-sdk-17.aspx
(Consultado: 5/04/2013)
25. Painting a Skeleton. Disponible en: http://channel9.msdn.com/coding4fun/kinect/Painting-a-skeleton
(Consultado: 18/04/2013)
26. Skeletal Tracking Fundamentals. Disponible en:
http://channel9.msdn.com/Series/KinectSDKQuickstarts/Skeletal-Tracking-Fundamentals
(Consultado: 18/04/2013)
27. Kinect SDK for Windows – Hover Button / Hover Control. Disponible en:
http://blogs.msdn.com/b/tess/archive/2011/08/16/kinect-sdk-for-windows-hover-button-hover-
control.aspx (Consultado: 25/04/2013)
